scenejs_on_rails 1.0.0 → 1.0.1

data/vendor/assets/javascripts/scenejs_plugins/node/prims/cylinder.js

@@ -0,0 +1,186 @@
+/**
+ * Sphere geometry node type
+ *
+ * @author Moritz Kornher
+ *
+ * Usage example:
+ *
+ * someNode.addNode({
+ *      type: "prims/cylinder",
+ *      radiusTop: 20, // Default
+ *      radiusBottom: 20, // Default
+ *      height: 100, // Default
+ *      radialSegments: 8, // Default
+ *      heightSegments: 1, // Default
+ *      openEnded: false // Default
+ *  });
+ */
+
+(function () {
+
+    SceneJS.Types.addType("prims/cylinder", {
+
+        init:function (params) {
+            this.addNode(build.call(this, params));
+        }
+    });
+
+    function build(params) {
+
+        // Thanks awfully to: http://www.e-reading-lib.com/bookreader.php/143437/Pike_-_DirectX_8_Programming_Tutorial.html
+
+        /* config */
+        var radiusTop = params.radiusTop !== undefined ? params.radiusTop : 20;
+        var radiusBottom = params.radiusBottom !== undefined ? params.radiusBottom : 20;
+        var height = params.height !== undefined ? params.height : 100;
+
+        var radialSegments   = params.radialSegments  || 8;
+        var heightSegments   = params.heightSegments  || 1;
+
+        var openEnded = params.openEnded || false;
+        /* config end */
+
+        var heightHalf = height / 2;
+        var heightLength = height / heightSegments;
+
+        var radialAngle = (2.0 * Math.PI / radialSegments);
+        var radialLength = 1.0 / radialSegments;
+
+        var nextRadius = this.radiusBottom;
+        var radiusChange = (radiusTop-radiusBottom)/heightSegments;
+
+        var positions = [];
+        var normals = [];
+        var uvs = [];
+        var indices = [];
+
+        // create vertices
+        var normalY = (90.0 - (Math.atan(height / (radiusBottom - radiusTop))) * 180/Math.PI) / 90.0;
+
+        for (var h = 0; h <= heightSegments; h++) {
+            var currentRadius = radiusTop - h*radiusChange;
+            var currentHeight = heightHalf - h*heightLength
+
+            for (var i=0; i <= radialSegments; i++) {
+                var x = Math.sin(i * radialAngle);
+                var z = Math.cos(i * radialAngle);
+
+                normals.push(currentRadius * x);
+                normals.push(normalY); //todo
+                normals.push(currentRadius * z);
+                uvs.push(1 - (i*radialLength));
+                uvs.push(0 + h*1/heightSegments);
+                positions.push(currentRadius * x);
+                positions.push(currentHeight);
+                positions.push(currentRadius * z);
+            }
+        }
+
+        // create faces
+        for (var h = 0; h < heightSegments; h++) {
+            for (var i=0; i <= radialSegments; i++) {
+                var first = h * (radialSegments + 1) + i;
+                var second = first + radialSegments;
+                indices.push(first);
+                indices.push(second);
+                indices.push(second + 1);
+
+                indices.push(first);
+                indices.push(second + 1);
+                indices.push(first + 1);
+            }
+        }
+
+        // create top cap
+        if (!openEnded && radiusTop > 0) {
+            var startIndex = (positions.length/3);
+
+            // top center
+            normals.push(0.0);
+            normals.push(1.0);
+            normals.push(0.0);
+            uvs.push(0.5);
+            uvs.push(0.5);
+            positions.push(0);
+            positions.push(heightHalf);
+            positions.push(0);
+
+            // top triangle fan
+            for (var i=0; i <= radialSegments; i++) {
+                var x = Math.sin(i * radialAngle);
+                var z = Math.cos(i * radialAngle);
+                var tu = (0.5 * Math.sin(i * radialAngle)) + 0.5;
+                var tv = (0.5 * Math.cos(i * radialAngle)) + 0.5;
+
+                normals.push(radiusTop * x);
+                normals.push(1.0);
+                normals.push(radiusTop * z);
+                uvs.push(tu);
+                uvs.push(tv);
+                positions.push(radiusTop * x);
+                positions.push(heightHalf);
+                positions.push(radiusTop * z);
+            }
+
+            for (var i=0; i < radialSegments; i++) {
+                var center = startIndex;
+                var first = startIndex + 1 + i;
+                indices.push(first);
+                indices.push(first + 1);
+                indices.push(center);
+            }
+        }
+
+        // create bottom cap
+        if (!openEnded && radiusBottom > 0) {
+            var startIndex = (positions.length/3);
+
+            // top center
+            normals.push(0.0);
+            normals.push(-1.0);
+            normals.push(0.0);
+            uvs.push(0.5);
+            uvs.push(0.5);
+            positions.push(0);
+            positions.push(0-heightHalf);
+            positions.push(0);
+
+            // top triangle fan
+            for (var i=0; i <= radialSegments; i++) {
+                var x = Math.sin(i * radialAngle);
+                var z = Math.cos(i * radialAngle);
+                var tu = (0.5 * Math.sin(i * radialAngle)) + 0.5;
+                var tv = (0.5 * Math.cos(i * radialAngle)) + 0.5;
+
+                normals.push(radiusBottom * x);
+                normals.push(-1.0);
+                normals.push(radiusBottom * z);
+                uvs.push(tu);
+                uvs.push(tv);
+                positions.push(radiusBottom * x);
+                positions.push(0-heightHalf);
+                positions.push(radiusBottom * z);
+            }
+
+            for (var i=0; i < radialSegments; i++) {
+                var center = startIndex;
+                var first = startIndex + 1 + i;
+                indices.push(first);
+                indices.push(first + 1);
+                indices.push(center);
+            }
+        }
+
+        return {
+            type: "geometry",
+            primitive:params.wire ? "lines" : "triangles",
+            coreId : "cylinder_" + (params.wire ? "wire" : "solid") + "_" + (params.openEnded ? "open" : "closed") + "_"
+                + radiusTop + "_" + radiusBottom + "_" + radialSegments + "_"
+                + height + "_" + heightSegments,
+            positions : new Float32Array(positions),
+            normals: new Float32Array(normals),
+            uv : new Float32Array(uvs),
+            indices : new Uint16Array(indices)
+        };
+    }
+})();

data/vendor/assets/javascripts/scenejs_plugins/node/prims/grid.js

@@ -0,0 +1,47 @@
+SceneJS.Types.addType("prims/grid", {
+
+    construct:function (params) {
+
+        this._translate = this.addNode({
+            type:"translate"
+        });
+
+        this._scale = this._translate.addNode({
+            type:"scale",
+            x:1000,
+            y:.5,
+            z:1000,
+            nodes:[
+                {
+                    type:"rotate",
+                    x:1,
+                    angle:90,
+                    nodes:[
+                        {
+                            type:"prims/plane",
+                            wire:params.wire != false,
+                            widthSegments:params.xSegments || 200,
+                            heightSegments:params.zSegments || 200
+                        }
+                    ]
+                }
+            ]
+        });
+
+        if (params.pos) {
+            this.setPos(params.pos);
+        }
+
+        if (params.size) {
+            this.setSize(params.size);
+        }
+    },
+
+    setPos:function (pos) {
+        this._translate.setXYZ(pos);
+    },
+
+    setSize:function (size) {
+        this._scale.setXYZ(size);
+    }
+});

data/vendor/assets/javascripts/scenejs_plugins/node/prims/plane.js

@@ -0,0 +1,137 @@
+/**
+ * Plane geometry node type
+ *
+ * Usage example:
+ *
+ * someNode.addNode({
+ *      type: "prims/plane",
+ *      width: 10,
+ *      height: 20,
+ *      wire: false // Default
+ *  });
+ */
+(function () {
+
+    SceneJS.Types.addType("prims/plane", {
+
+        construct:function (params) {
+            this.addNode(build.call(this, params));
+        }
+    });
+
+    function build(params) {
+
+        var width = params.width || 1.0;
+        var height = params.height || 1.0;
+
+        var widthSegments = params.widthSegments || 1;
+        var heightSegments = params.heightSegments || 1;
+
+        var coreId = "prims/plane_" + (params.wire == true ? "wire_" : "") + height + "_" + widthSegments + "_" + heightSegments;
+
+        // If a node core already exists for a prim with the given properties,
+        // then for efficiency we'll share that core rather than create another geometry
+        if (this.getScene().hasCore("geometry", coreId)) {
+            return {
+                type: "geometry",
+                coreId:coreId
+            };
+        }
+
+        // Otherwise, create a new geometry
+
+        var positions = [];
+        var normals = [];
+        var uvs = [];
+        var indices = [];
+
+        var ix, iz;
+        var halfWidth = width / 2;
+        var halfHeight = height / 2;
+
+        var gridX = widthSegments;
+        var gridZ = heightSegments;
+
+        var gridX1 = gridX + 1;
+        var gridZ1 = gridZ + 1;
+
+        var segWidth = width / gridX;
+        var segHeight = height / gridZ;
+
+        var x;
+        var y;
+
+        for (iz = 0; iz < gridZ1; iz++) {
+            for (ix = 0; ix < gridX1; ix++) {
+
+                x = ix * segWidth - halfWidth;
+                y = iz * segHeight - halfHeight;
+
+                positions.push(x);
+                positions.push(-y);
+                positions.push(0);
+
+                normals.push(0);
+                normals.push(0);
+                normals.push(1);
+            }
+        }
+
+        var a;
+        var b;
+        var c;
+        var d;
+
+        for (iz = 0; iz < gridZ; iz++) {
+            for (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 {
+            type: "geometry",
+            primitive:params.wire ? "lines" : "triangles",
+            coreId:coreId,
+            positions:new Float32Array(positions),
+            normals:new Float32Array(normals),
+            uv:new Float32Array(uvs),
+            indices:new Uint16Array(indices)
+        };
+    }
+})();

data/vendor/assets/javascripts/scenejs_plugins/node/prims/quad.js

@@ -0,0 +1,43 @@
+/**
+ * Quad geometry node type
+ *
+ * Usage example:
+ *
+ * someNode.addNode({
+ *      type: "prims/quad",
+ *      wire: false // Default
+ *  });
+ */
+(function () {
+
+    SceneJS.Types.addType("prims/quad", {
+        construct:function (params) {
+            this.addNode(build.call(this, params));
+        }
+    });
+
+    function build(params) {
+
+        var coreId = "prims/quad" + (params.wire ? "wire" : "_solid");
+
+        // If a node core already exists for a prim with the given properties,
+        // then for efficiency we'll share that core rather than create another geometry
+        if (this.getScene().hasCore("geometry", coreId)) {
+            return {
+                type: "geometry",
+                coreId:coreId
+            };
+        }
+
+        // Otherwise, create a new geometry
+        return {
+            type: "geometry",
+            primitive:params.wire ? "lines" : "triangles",
+            coreId:coreId,
+            positions:[ 1, 1, 0, -1, 1, 0, -1, -1, 0, 1, -1, 0 ],
+            normals:[ -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0 ],
+            uv:[ 1, 1, 0, 1, 0, 0, 1, 0 ],
+            indices:[ 0, 1, 2, 0, 2, 3 ]
+        };
+    }
+})();

data/vendor/assets/javascripts/scenejs_plugins/node/prims/sphere.js

@@ -0,0 +1,107 @@
+/**
+ * Sphere geometry node type
+ *
+ * Usage example:
+ *
+ * someNode.addNode({
+ *      type: "prims/sphere",
+ *      latitudeBands: 30, // Default
+ *      longitudeBands: 30, // Default
+ *      radius: 1, // Default
+ *      wire: false // Default
+ *  });
+ */
+(function () {
+
+    SceneJS.Types.addType("prims/sphere", {
+
+        construct:function (params) {
+            this.addNode(build.call(this, params));
+        }
+    });
+
+    function build(params) {
+
+        // Thanks awfully to: http://learningwebgl.com/cookbook/index.php/How_to_draw_a_sphere
+
+        var latitudeBands = params.latitudeBands || 30;
+        var longitudeBands = params.longitudeBands || 30;
+        var radius = params.radius || 1;
+
+        var coreId = "prims/sphere_" + (params.wire ? "wire" : "_solid") + radius + "_" + longitudeBands + "_" + latitudeBands;
+
+        // If a node core already exists for a prim with the given properties,
+        // then for efficiency we'll share that core rather than create another geometry
+        if (this.getScene().hasCore("geometry", coreId)) {
+            return {
+                type: "geometry",
+                coreId:coreId
+            };
+        }
+
+        // Otherwise, create a new geometry
+
+        var positions = [];
+        var normals = [];
+        var uvs = [];
+        for (var latNumber = 0; latNumber <= latitudeBands; latNumber++) {
+            var theta = latNumber * Math.PI / latitudeBands;
+            var sinTheta = Math.sin(theta);
+            var cosTheta = Math.cos(theta);
+
+            for (var longNumber = 0; longNumber <= longitudeBands; longNumber++) {
+                var phi = longNumber * 2 * Math.PI / longitudeBands;
+                var sinPhi = Math.sin(phi);
+                var cosPhi = Math.cos(phi);
+
+                var x = cosPhi * sinTheta;
+                var y = cosTheta;
+                var z = sinPhi * sinTheta;
+                var u = 1- (longNumber / longitudeBands);
+                var v = latNumber / latitudeBands;
+
+                normals.push(x);
+                normals.push(y);
+                normals.push(z);
+                uvs.push(u);
+                uvs.push(v);
+                positions.push(radius * x);
+                positions.push(radius * y);
+                positions.push(radius * z);
+            }
+        }
+
+        var indices = [];
+        for (var latNumber = 0; latNumber < latitudeBands; latNumber++) {
+            for (var longNumber = 0; longNumber < longitudeBands; longNumber++) {
+                var first = (latNumber * (longitudeBands + 1)) + longNumber;
+                var second = first + longitudeBands + 1;
+//                indices.push(first);
+//                indices.push(second);
+//                indices.push(first + 1);
+//
+//                indices.push(second);
+//                indices.push(second + 1);
+//                indices.push(first + 1);
+
+
+                indices.push(first + 1);
+                indices.push(second + 1);
+                indices.push(second);
+                indices.push(first + 1);
+                indices.push(second);
+                indices.push(first);
+            }
+        }
+
+        return {
+            type: "geometry",
+            primitive:params.wire ? "lines" : "triangles",
+            coreId : coreId,
+            positions : new Float32Array(positions),
+            normals: new Float32Array(normals),
+            uv : new Float32Array(uvs),
+            indices : new Uint16Array(indices)
+        };
+    }
+})();