scenejs_on_rails 1.0.0 → 1.0.1

data/vendor/assets/javascripts/scenejs_plugins/node/heightmaps/custom.js

@@ -0,0 +1,185 @@
+(function () {
+
+    SceneJS.Types.addType("heightmaps/custom", {
+
+        construct:function (params) {
+
+            if (!params.src) {
+                throw "heightmap param expected: src";
+            }
+
+            params.xSize = params.xSize || 1.0;
+            params.ySize = params.ySize || 1.0;
+            params.zSize = params.zSize || 1.0;
+
+            params.xSegments = params.xSegments || 1;
+            params.zSegments = params.zSegments || 1;
+
+            var self = this;
+
+            // Notify SceneJS so it can support loading/busy indicators etc
+            this._taskId = this.taskStarted("Loading heightmap");
+
+            var image = new Image();
+
+            image.onload = function (e) {
+
+                var element = window.document.createElement('canvas');
+                element.width = image.width;
+                element.height = image.height;
+
+                var c = element.getContext("2d");
+
+                c.drawImage(image, 0, 0);
+
+                var imageData = c.getImageData(0, 0, image.width, image.height).data;
+
+                var mesh = createMeshData(params, image, imageData);
+
+                var wire = params.wire;
+
+                if (self._taskId) {
+
+                    self._taskId = self.taskFinished(self._taskId);
+
+                    // Create geometry node
+                    self.addNode({
+                        type:"rotate",
+                        x:1,
+                        angle:90,
+                        nodes:[
+                            {
+                                type:"geometry",
+                                primitive:wire ? "lines" : "triangles",
+                                positions:mesh.positions,
+                                normals:!wire ? "auto" : null, // Get SceneJS to compute the normals
+                                uv:!wire ? mesh.uv : null,
+                                indices:mesh.indices,
+                                coreId:"heightmap_" + (wire == true ? "wire_" : "") + params.zSize + "_" + params.xSize + "_" + params.xSegments + "_" + params.zSegments
+                            }
+                        ]
+                    });
+                }
+            };
+
+            image.onerror = function () {
+                self._taskId = self.taskFailed(self._taskId);
+            };
+
+            image.src = params.src;
+        },
+
+        destruct:function () {
+            this._taskId = self.taskFinished(this._taskId);
+        }
+    });
+
+    function createMeshData(params, image, imageData) {
+
+        var imageWidth = image.width;
+        var imageHeight = image.height;
+
+        var positions = [];
+        var uvs = [];
+        var indices = [];
+
+        var width = params.xSize;
+        var height = params.zSize;
+
+        var xSegments = params.xSegments;
+        var zSegments = params.zSegments;
+
+        var halfWidth = width / 2;
+        var halfHeight = height / 2;
+
+        var gridX = xSegments;
+        var gridZ = zSegments;
+
+        var gridX1 = gridX + 1;
+        var gridZ1 = gridZ + 1;
+
+        var segWidth = width / gridX;
+        var segHeight = height / gridZ;
+
+        var imgX;
+        var imgY;
+
+        var x;
+        var y;
+        var z;
+
+        for (var px = 0; px <= gridZ; px++) {
+            for (var py = 0; py <= gridX; py++) {
+
+                x = px * segWidth;
+                y = py * segHeight;
+
+                imgX = Math.round((x / width) * imageWidth);
+                imgY = Math.round((y / height) * imageHeight);
+
+                z = (imageData[(imageWidth * imgY + imgX) * 4]) / 255 * params.ySize;
+
+                if (z == undefined) {
+                    z = 0;
+                }
+
+                positions.push(x - halfWidth);
+                positions.push(-y + halfHeight);
+                positions.push(-z);
+            }
+        }
+
+        var a;
+        var b;
+        var c;
+        var d;
+
+        for (var iz = 0; iz < gridZ; iz++) {
+            for (var ix = 0; ix < gridX; ix++) {
+
+                a = ix + gridX1 * iz;
+                b = ix + gridX1 * ( iz + 1 );
+                c = ( ix + 1 ) + gridX1 * ( iz + 1 );
+                d = ( ix + 1 ) + gridX1 * iz;
+
+                indices.push(a);
+                indices.push(b);
+                indices.push(c);
+
+                indices.push(c);
+                indices.push(d);
+                indices.push(a);
+
+                // a
+                uvs.push(ix / gridX);
+                uvs.push(1 - iz / gridZ);
+
+                //b
+                uvs.push(ix / gridX);
+                uvs.push(1 - ( iz + 1 ) / gridZ);
+
+                //c
+                uvs.push(( ix + 1 ) / gridX);
+                uvs.push(1 - ( iz + 1 ) / gridZ);
+
+                //c
+                uvs.push(( ix + 1 ) / gridX);
+                uvs.push(1 - ( iz + 1 ) / gridZ);
+
+                //d
+                uvs.push(( ix + 1 ) / gridX, 1 - iz / gridZ);
+                uvs.push(1 - iz / gridZ);
+
+                //a
+                uvs.push(ix / gridX);
+                uvs.push(1 - iz / gridZ);
+            }
+        }
+
+        return {
+            positions:positions,
+            uv:uvs,
+            indices:indices
+        };
+    }
+})();

data/vendor/assets/javascripts/scenejs_plugins/node/import/3ds.js

@@ -0,0 +1,91 @@
+/**
+ * 3DS importer plugin
+ *
+ * Uses the K3D library to parse 3DS
+ * © 2012 Ivan Kuckir
+ * http://k3d.ivank.net/
+ *
+ */
+require([
+
+    // This prefix routes to the 3rd-party libs directory containing resources used by plugins
+    "scenejsPluginDeps/k3d"
+],
+    function () {
+
+        SceneJS.Types.addType("import/3ds", {
+
+            construct:function (params) {
+
+                if (!params.src) {
+                    this.log("error", "Attribute expected: src");
+                }
+
+                // Notify SceneJS so it can support loading/busy indicators etc
+                this._taskId = this.taskStarted("Loading .3DS");
+
+                var self = this;
+
+                load(params.src,
+                    function (data) {
+
+                        var m = K3D.parse.from3DS(data);
+
+                        console.log(m);
+
+                        var mesh = m.edit.objects[0].mesh;
+
+                        // Need to flip the UV coordinates on Y-axis for SceneJS geometry
+                        for (var i = 1, len = mesh.uvt.length; i < len; i += 2) {
+                            mesh.uvt[i] *= -1.0;
+                        }
+
+                        self.addNode({
+                            type:"geometry",
+                            primitive:"triangles",
+                            positions:mesh.vertices,
+                            uv:mesh.uvt,
+                            //normals:"auto",
+                            indices:mesh.indices
+                        });
+
+                        self._taskId = self.taskFinished(self._taskId);
+                    },
+
+                    function (err) {
+                        self.log("error", "Failed to load file: " + err);
+                        self._taskId = self.taskFailed(self._taskId);
+                    });
+
+            },
+
+            destruct:function () {
+                this._taskId = this.taskFinished(this._taskId);
+            }
+        });
+
+
+        function load(url, ok, error) {
+            var xhr = new XMLHttpRequest();
+            xhr.responseType = "arraybuffer";
+//            xhr.addEventListener('progress',
+//                function (event) {
+//                    // TODO: Update the task? { type:'progress', loaded:event.loaded, total:event.total }
+//                }, false);
+            xhr.addEventListener('load',
+                function (event) {
+                    if (event.target.response) {
+                        ok(event.target.response);
+                    } else {
+                        error('Invalid file [' + url + ']');
+                    }
+                }, false);
+            xhr.addEventListener('error',
+                function () {
+                    error('Couldn\'t load URL [' + url + ']');
+                }, false);
+            xhr.open('GET', url, true);
+            xhr.send(null);
+        }
+
+    })();

data/vendor/assets/javascripts/scenejs_plugins/node/import/md2.js

@@ -0,0 +1,139 @@
+/**
+ * MD2 importer
+ *
+ * Uses the K3D library to parse .MD2
+ * © 2012 Ivan Kuckir
+ * http://k3d.ivank.net/
+ *
+ */
+require([
+
+    // This prefix routes to the 3rd-party libs directory containing resources used by plugins
+    "scenejsPluginDeps/k3d"
+],
+    function () {
+
+        SceneJS.Types.addType("import/md2", {
+
+            construct:function (params) {
+
+                if (!params.src) {
+                    this.log("error", "Attribute expected: src");
+                }
+
+                // Notify SceneJS so it can support loading/busy indicators etc
+                this._taskId = this.taskStarted("Loading .MD2");
+
+                var self = this;
+
+                load(params.src,
+                    function (data) {
+
+                        var m = K3D.parse.fromMD2(data);
+
+                        // Build morph targets
+                        var keys = [];
+                        var morphTargets = [];
+                        for (var i = 0, len = m.frames.length - 3; i < len; i++) { // TODO: why do I need to skip the last three frames?
+                            var f = m.frames[i];
+                            keys.push((1.0 / len) * i);
+
+                            // Target
+                            var verts = K3D.edit.unwrap(m.i_verts, f.verts, 3);
+
+                            // In my model, Y and Z are swapped
+                            K3D.edit.transform(verts, K3D.mat.rotateDeg(90, 0, 0));
+                            morphTargets.push({
+                                positions:verts
+                            })
+                        }
+
+                        // Build UVs
+                        var uv = K3D.edit.unwrap(m.i_uvt, m.c_uvt, 2);
+                        for (var i = 1, len = uv.length; i < len; i += 2) { // Flip UVs on Y-axis for SceneJS
+                            uv[i] *= -1.0;
+                        }
+
+                        // Build indices
+                        var indices = [];
+                        for (var i = 0; i < m.i_verts.length; i++) {
+                            indices.push(i);
+                        }
+
+                        // Create morph wrapping geometry
+                        // Morph has positions in targets, geometry has UVs and indices
+                        var morph = self.addNode({
+                            type:"morphGeometry",
+                            factor:0,
+                            keys:keys,
+                            targets:morphTargets,
+                            nodes:[
+                                {
+                                    type:"geometry",
+                                    primitive:"triangles",
+                                    uv:uv,
+                                    indices:indices
+                                }
+                            ]
+                        });
+
+                        // If rate param is given, then
+                        // automatically play the morph
+
+                        if (params.rate) {
+
+                            var factor = 0;
+                            var lastKey = (keys.length > 0) ? keys[keys.length - 1] : 0;
+                            var rate = params.rate;
+
+                            // Start morphing
+                            this._tick = self.getScene().on("tick",
+                                function () {
+                                    morph.setFactor(factor);
+                                    factor += rate;
+                                    if (factor > lastKey) {
+                                        factor = factor % lastKey;
+                                    }
+                                });
+                        }
+
+                        // Done
+                        self._taskId = self.taskFinished(self._taskId);
+                    },
+
+                    function (err) {
+                        self.log("error", "Failed to load file: " + err);
+                        self._taskId = self.taskFailed(self._taskId);
+                    });
+
+            },
+
+            destruct:function () {
+                if (this._tick) {
+                    this.getScene().off(this._tick); // Stop morphing
+                }
+                this._taskId = this.taskFinished(this._taskId); // Just in case
+            }
+        });
+
+
+        function load(url, ok, error) {
+            var xhr = new XMLHttpRequest();
+            xhr.responseType = "arraybuffer";
+            xhr.addEventListener('load',
+                function (event) {
+                    if (event.target.response) {
+                        ok(event.target.response);
+                    } else {
+                        error('Invalid file [' + url + ']');
+                    }
+                }, false);
+            xhr.addEventListener('error',
+                function () {
+                    error('Couldn\'t load URL [' + url + ']');
+                }, false);
+            xhr.open('GET', url, true);
+            xhr.send(null);
+        }
+
+    })();

data/vendor/assets/javascripts/scenejs_plugins/node/import/obj.js

@@ -0,0 +1,100 @@
+/**
+ * WaveFront OBJ mesh importer
+ *
+ * Uses the K3D library to parse OBJ
+ * © 2012 Ivan Kuckir
+ * http://k3d.ivank.net/
+ *
+ */
+require([
+
+    // This prefix routes to the 3rd-party libs directory containing resources used by plugins
+    "scenejsPluginDeps/k3d"
+],
+    function () {
+
+        SceneJS.Types.addType("import/obj", {
+
+            construct:function (params) {
+
+                if (!params.src) {
+                    this.log("error", "Attribute expected: src");
+                }
+
+                // Notify SceneJS so it can support loading/busy indicators etc
+                this._taskId = this.taskStarted("Loading .OBJ");
+
+                var self = this;
+
+                load(params.src,
+                    function (data) {
+
+                        var m = K3D.parse.fromOBJ(data);	// done !
+
+                        // unwrap simply duplicates some values, so they can be indexed with indices [0,1,2,3 ... ]
+                        // In some rendering engines, you can have only one index value for vertices, UVs, normals ...,
+                        // so "unwrapping" is a simple solution.
+
+                        var positions = K3D.edit.unwrap(m.i_verts, m.c_verts, 3);
+                        var normals = K3D.edit.unwrap(m.i_norms, m.c_norms, 3);
+                        var uv = K3D.edit.unwrap(m.i_uvt, m.c_uvt, 2);
+
+                        var indices = [];
+                        for (var i = 0; i < m.i_verts.length; i++) {
+                            indices.push(i);
+                        }
+
+                        // Need to flip the UV coordinates on Y-axis for SceneJS geometry
+                        for (var i = 1, len = uv.length; i < len; i += 2) {
+                            uv[i] *= -1.0;
+                        }
+
+                        self.addNode({
+                            type:"geometry",
+                            primitive:"triangles",
+                            positions:positions,
+                            uv:uv.length > 0 ? uv : undefined,
+                            normals:normals.length > 0 ? normals : undefined,
+                            indices:indices
+                        });
+
+                        self._taskId = self.taskFinished(self._taskId);
+                    },
+
+                    function (err) {
+                        self.log("error", "Failed to load file: " + err);
+                        self._taskId = self.taskFailed(self._taskId);
+                    });
+
+            },
+
+            destruct:function () {
+                this._taskId = this.taskFinished(this._taskId);
+            }
+        });
+
+
+        function load(url, ok, error) {
+            var xhr = new XMLHttpRequest();
+            xhr.responseType = "arraybuffer";
+//            xhr.addEventListener('progress',
+//                function (event) {
+//                    // TODO: Update the task? { type:'progress', loaded:event.loaded, total:event.total }
+//                }, false);
+            xhr.addEventListener('load',
+                function (event) {
+                    if (event.target.response) {
+                        ok(event.target.response);
+                    } else {
+                        error('Invalid file [' + url + ']');
+                    }
+                }, false);
+            xhr.addEventListener('error',
+                function () {
+                    error('Couldn\'t load URL [' + url + ']');
+                }, false);
+            xhr.open('GET', url, true);
+            xhr.send(null);
+        }
+
+    })();