scenejs_on_rails 1.0.0 → 1.0.1

data/vendor/assets/javascripts/scenejs_plugins/node/physics/body.js

@@ -0,0 +1,85 @@
+/**
+ * Physics rigid-body
+ *
+ * Documentation: https://github.com/xeolabs/scenejs/wiki/Physics
+ */
+require([
+    // Prefix routes to plugin support libs
+    "scenejsPluginDeps/physics/physics"
+],
+    function (physics) {
+
+        SceneJS.Types.addType("physics/body", {
+
+            construct:function (params) {
+
+                // Don't need to provide initial attributes for our scene nodes
+                // because that will will happen via an update from the physics
+                // system once we have created the physics body.
+
+                var translate;
+                var rotate;
+
+                if (params.shape == "sphere") {
+
+                    // No point in rotating a sphere
+                    translate = this.addNode({
+                        type:"translate",
+                        nodes:params.nodes
+                    });
+
+                } else {
+
+                    translate = this.addNode({
+                        type:"translate"
+                    });
+
+                    rotate = translate.addNode({
+                        type:"matrix",
+                        nodes:params.nodes // Plugin node is responsible for attaching specified child nodes
+                    });
+                }
+
+                // Get physics system for this scene
+                // When params.systemId is undefined, get the default system for this scene
+                this._system = physics.getSystem(this.getScene(), params.systemId);
+
+                try {
+
+                    // There must be no overlap in params for SceneJS and the physics system
+                    // because we are just passing those params straight through to the system.
+
+                    this._bodyId = this._system.createBody(params,
+                        function (pos, dir) { // Body update handler
+                            translate.setXYZ({ x:pos[0], y:pos[1], z:pos[2] });
+                            if (rotate) {
+                                rotate.setElements(dir);
+                            }
+                        });
+                } catch (e) {
+                    this.log("error", e);
+                }
+            },
+
+            preCompile:function () {
+                if (this._bodyId != undefined) {
+                    var material = window._sceneJSPhysicsMaterial;
+                    if (material) {
+                        // Inherit state from parent "physics/material" node
+                        this._system.updateBody(this._bodyId, material);
+                    }
+                }
+            },
+
+            postCompile:function () {
+                // Not used
+            },
+
+            destruct:function () {
+                if (this._bodyId) {
+                    this._system.removeBody(this._bodyId);
+                }
+                physics.putSystem(this._system);
+            }
+        });
+    });

data/vendor/assets/javascripts/scenejs_plugins/node/physics/box.js

@@ -0,0 +1,30 @@
+/**
+ * A box geometry with rigid-body physics behavior
+ *
+ * Documentation: https://github.com/xeolabs/scenejs/wiki/Physics
+ *
+ */
+SceneJS.Types.addType("physics/box", {
+    construct:function (params) {
+
+        this.addNode({
+            type:"physics/body",
+            shape: "box",
+            pos: params.pos,
+            size: params.size,
+            mass: params.mass,
+            restitution: params.restitution,
+            friction: params.friction,
+            velocity: params.velocity,
+            movable: params.movable,
+
+            nodes:[
+                {
+                    type:"prims/box",
+                    size: params.size
+                }
+            ]
+        });
+    }
+});
+

data/vendor/assets/javascripts/scenejs_plugins/node/physics/material.js

@@ -0,0 +1,35 @@
+/**
+ * Physics material
+ *
+ * Documentation: https://github.com/xeolabs/scenejs/wiki/Physics
+ */
+require([
+    // Prefix routes to plugin support libs
+    "scenejsPluginDeps/physics/physics"
+],
+    function (physics) {
+
+        SceneJS.Types.addType("physics/material", {
+
+            construct:function (params) {
+                this._material = params;
+                if (params.nodes) {
+                    this.addNodes(params.nodes);
+                }
+            },
+
+            preCompile:function () {
+
+                // Child "physics/body" nodes will look for this on the window scope.
+
+                // Seems a bit dirty to put it on window scope, but it's OK because
+                // there can only be one scene compilation happening at any moment.
+
+                window._sceneJSPhysicsMaterial = this._material;
+            },
+
+            postCompile:function () {
+                window._sceneJSPhysicsMaterial = null;
+            }
+        });
+    });

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

@@ -0,0 +1,47 @@
+/**
+ * A plane geometry with rigid-body physics behavior
+ *
+ * Documentation: https://github.com/xeolabs/scenejs/wiki/Physics
+ *
+ */
+SceneJS.Types.addType("physics/plane", {
+    construct:function (params) {
+
+        this.addNode({
+            type:"physics/body",
+            shape:"plane",
+            pos:params.pos,
+            dir:params.dir,
+            mass:params.mass,
+            restitution:params.restitution,
+            friction:params.friction,
+            velocity:params.velocity,
+            movable:params.movable,
+
+            nodes:[
+                {
+                    type:"scale",
+                    x:1000,
+                    y:.5,
+                    z:1000,
+                    nodes:[
+                        {
+                            type:"rotate",
+                            x:1,
+                            angle:90,
+                            nodes:[
+                                {
+                                    type:"prims/plane",
+                                    wire:params.wire,
+                                    xSegments:params.xSegments || 100,
+                                    zSegments:params.zSegments || 100
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        });
+    }
+});
+

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

@@ -0,0 +1,32 @@
+/**
+ * A sphere geometry with rigid-body physics behavior
+ *
+ * Documentation: https://github.com/xeolabs/scenejs/wiki/Physics
+ *
+ */
+SceneJS.Types.addType("physics/sphere", {
+    construct:function (params) {
+
+        this.addNode({
+            type:"physics/sphere",
+            shape: "sphere",
+            pos: params.pos,
+            radius: params.radius,
+            mass: params.mass,
+            restitution: params.restitution,
+            friction: params.friction,
+            velocity: params.velocity,
+            movable: params.movable,
+
+            nodes:[
+                {
+                    type:"prims/radius",
+                    latitudeBands: params.latitudeBands,
+                    longitudeBands: params.longitudeBands,
+                    radius: params.radius
+                }
+            ]
+        });
+    }
+});
+

data/vendor/assets/javascripts/scenejs_plugins/node/physics/system.js

@@ -0,0 +1,44 @@
+/**
+ * Configuration for a physics system
+ *
+ * Documentation: https://github.com/xeolabs/scenejs/wiki/Physics
+ */
+require([
+    // Prefix routes to plugin support libs
+    "scenejsPluginDeps/physics/physics"
+],
+    function (physics) {
+
+        SceneJS.Types.addType("physics/system", {
+
+            construct:function (params) {
+
+                // Get physics system for this scene
+                // When params.systemId is undefined, get the default system for this scene
+                this._system = physics.getSystem(this.getScene(), params.systemId);
+
+                this.setConfigs(params);
+            },
+
+            /**
+             * Configures the physics system
+             * @param params
+             */
+            setConfigs:function (params) {
+                this._system.setConfigs(params);
+            },
+
+            /**
+             * Enable or disable this physics system.
+             * To save CPU, you would typically disable the system when its not in view.
+             * @param enabled
+             */
+            setEnabled:function (enabled) {
+                this._system.setEnabled(enabled);
+            },
+
+            destruct:function () {
+                physics.putSystem(this._system);
+            }
+        });
+    });

data/vendor/assets/javascripts/scenejs_plugins/node/physics/teapot.js

@@ -0,0 +1,29 @@
+/**
+ * A teapot geometry with rigid-body physics behavior
+ *
+ * Documentation: https://github.com/xeolabs/scenejs/wiki/Physics
+ *
+ */
+SceneJS.Types.addType("physics/teapot", {
+    construct:function (params) {
+
+        this.addNode({
+            type:"physics/body",
+            shape: "sphere",
+            pos: params.pos,
+            radius: 1,
+            mass: params.mass,
+            restitution: params.restitution,
+            friction: params.friction,
+            velocity: params.velocity,
+            movable: params.movable,
+
+            nodes:[
+                {
+                    type:"prims/teapot"
+                }
+            ]
+        });
+    }
+});
+

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

@@ -0,0 +1,73 @@
+/**
+ * Boundary geometry node type
+ *
+ * Usage example:
+ *
+ * someNode.addNode({
+ *      type: "prims/box",
+ *      min: [-9, -3, -2],
+ *      max: [2,3,12],
+ *      wire: false // Default
+ *  });
+ */
+(function () {
+
+    SceneJS.Types.addType("prims/boundary", {
+
+        construct:function (params) {
+            this.addNode(build.call(this, params));
+        }
+    });
+
+    function build(params) {
+
+        var min = params.min || [0, 0, 0];
+        var max = params.max || [0, 0, 0];
+
+        var xmin = min[0];
+        var ymin = min[1];
+        var zmin = min[2];
+        var xmax = max[0];
+        var ymax = max[1];
+        var zmax = max[2];
+
+        var coreId = "prims/boundary_" + xmin + "_" + ymin + "_" + zmin + "_"
+            + xmax + "_" + ymax + "_" + zmax + (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:[
+                xmax, ymax, zmax,
+                xmax, ymin, zmax,
+                xmin, ymin, zmax,
+                xmin, ymax, zmax,
+                xmax, ymax, zmin,
+                xmax, ymin, zmin,
+                xmin, ymin, zmin,
+                xmin, ymax, zmin
+            ],
+            indices:[
+                0, 1, 1,
+                2, 2, 3,
+                3, 0, 4,
+                5, 5, 6,
+                6, 7, 7,
+                4, 0, 4,
+                1, 5, 2,
+                6, 3, 7
+            ]
+        }
+    }
+})();

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

@@ -0,0 +1,87 @@
+/**
+ * Box geometry node type
+ *
+ * Usage example:
+ *
+ * someNode.addNode({
+ *      type: "prims/box",
+ *      xSize: 10,
+ *      ySize: 20,
+ *      zSize: 1.5,
+ *      wire: false // Default
+ *  });
+ */
+(function () {
+
+    SceneJS.Types.addType("prims/box", {
+
+        construct:function (params) {
+            this.addNode(build.call(this, params));
+        }
+    });
+
+    function build(params) {
+
+        var x, y, z;
+        if (params.size) {
+            x = params.size[0];
+            y = params.size[1];
+            z = params.size[2];
+        } else {
+            // Deprecated
+            x = params.xSize || 1;
+            y = params.ySize || 1;
+            z = params.zSize || 1;
+        }
+
+        var coreId = "prims/box_" + x + "_" + y + "_" + z + (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:new Float32Array([
+                x, y, z, -x, y, z, -x, -y, z, x, -y, z, // v0-v1-v2-v3 front
+                x, y, z, x, -y, z, x, -y, -z, x, y, -z, // v0-v3-v4-v5 right
+                x, y, z, x, y, -z, -x, y, -z, -x, y, z, // v0-v5-v6-v1 top
+                -x, y, z, -x, y, -z, -x, -y, -z, -x, -y, z, // v1-v6-v7-v2 left
+                -x, -y, -z, x, -y, -z, x, -y, z, -x, -y, z, // v7-v4-v3-v2 bottom
+                x, -y, -z, -x, -y, -z, -x, y, -z, x, y, -z // v4-v7-v6-v5 back
+            ]),
+            normals:new Float32Array([
+                0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, // v0-v1-v2-v3 front
+                1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, // v0-v3-v4-v5 right
+                0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, // v0-v5-v6-v1 top
+                -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, // v1-v6-v7-v2 left
+                0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1, 0, // v7-v4-v3-v2 bottom
+                0, 0, -1, 0, 0, -1, 0, 0, -1, 0, 0, -1     // v4-v7-v6-v5 back
+            ]),
+            uv:new Float32Array([
+                x, y, 0, y, 0, 0, x, 0, // v0-v1-v2-v3 front
+                0, y, 0, 0, x, 0, x, y, // v0-v3-v4-v5 right
+                x, 0, x, y, 0, y, 0, 0, // v0-v5-v6-v1 top
+                x, y, 0, y, 0, 0, x, 0, // v1-v6-v7-v2 left
+                0, 0, x, 0, x, y, 0, y, // v7-v4-v3-v2 bottom
+                0, 0, x, 0, x, y, 0, y    // v4-v7-v6-v5 back
+            ]),
+            indices:new Uint16Array([
+                0, 1, 2, 0, 2, 3, // front
+                4, 5, 6, 4, 6, 7, // right
+                8, 9, 10, 8, 10, 11, // top
+                12, 13, 14, 12, 14, 15, // left
+                16, 17, 18, 16, 18, 19, // bottom
+                20, 21, 22, 20, 22, 23   // back
+            ])
+        };
+    }
+})();