scenejs_on_rails 1.0.0 → 1.0.1

data/vendor/assets/javascripts/scenejs_plugins/node/effects/wobble.js

@@ -0,0 +1,42 @@
+SceneJS.Types.addType("effects/wobble", {
+
+    construct:function (params) {
+
+        var shader = this.addNode({
+            type:"shader",
+            shaders:[
+                {
+                    stage:"vertex",
+                    code:"uniform float time;\n\
+                          vec4 myWorldPosFunc(vec4 pos){\n\
+                              pos.x=pos.x+sin(pos.x*5.0+time+10.0)*0.1;\n\
+                              pos.y=pos.y+sin(pos.y*5.0+time+10.0)*0.1;\n\
+                              pos.z=pos.z+sin(pos.z*5.0+time+10.0)*0.1;\n\
+                              return pos;\n\
+                          }\n",
+                    hooks:{
+                        worldPos:"myWorldPosFunc"
+                    }
+                }
+            ],
+            params:{
+                time:0.5
+            },
+            nodes:params.nodes
+        });
+
+        var time = 0;
+
+        this._tick = this.getScene().on("tick",
+            function () {
+                shader.setParams({
+                    time:time
+                });
+                time += 0.1;
+            });
+    },
+
+    destruct:function () {
+        this.getScene().off(this._tick);
+    }
+});

data/vendor/assets/javascripts/scenejs_plugins/node/effects/xray.js

@@ -0,0 +1,126 @@
+SceneJS.Types.addType("effects/xray", {
+
+    construct:function (params) {
+
+        this._shader = this.addNode({
+            type:"shader",
+
+            shaders:[
+                {
+                    "stage":"fragment",
+                    "code":[
+                        "uniform bool   xrayEnabled;",
+                        "uniform float  xrayOpacity;",
+                        "uniform bool   xrayMonochrome;",
+
+                        "vec3           myworldNormal = vec3(0.0, 0.0,  1.0);",
+                        "vec3           myworldEyeVec = vec3(0.0, 0.0, -1.0);",
+
+                        "void myWorldNormalFunc(vec3 vec) {",
+                        "   myworldNormal = vec;",
+                        "}",
+
+                        "void myWorldEyeVecFunc(vec3 vec) {",
+                        "   myworldEyeVec = vec;",
+                        "}",
+
+                        "vec4 myPixelColorFunc(vec4 color) {",
+                        "   if (xrayEnabled && xrayOpacity < 1.0) {",
+                        "       if (xrayMonochrome) {",
+                        "           color = vec4(0.2, 0.2, 0.3, (xrayOpacity + 0.9 - abs(dot(myworldNormal, myworldEyeVec))));",
+                        "       } else {",
+                        "           color.a = (xrayOpacity + 0.9 - abs(dot(myworldNormal, myworldEyeVec)));",                        
+                        "       }",
+                        "   }",
+                        "   return color;",
+                        "}"
+                    ],
+
+                    hooks:{
+                        worldNormal:"myWorldNormalFunc",
+                        worldEyeVec:"myWorldEyeVecFunc",
+                        pixelColor:"myPixelColorFunc"
+                    }
+                }
+            ],
+            params:{
+                xrayEnabled:true,
+                xrayOpacity:0.4,
+                xrayMonochrome:false
+            }
+        });
+
+        // Enable transparency with a flag
+        this._flags = this._shader.addNode({
+            type:"flags",
+            flags:{
+                transparent:true,
+                backfaces:false
+            },
+
+            // Child nodes that will receive the x-ray effect
+            nodes:params.nodes
+        });
+
+        this.setEnabled(params.enabled != undefined ? params.enabled : true);
+        this.setOpacity(params.opacity != undefined ? params.opacity : 0.4);
+        this.setMonochrome(params.monochrome != undefined ? params.monochrome : false);
+    },
+
+    /**
+     * Enables or disables the X-Ray effect
+     * @param {Boolean} enabled
+     */
+    setEnabled:function (enabled) {
+        this._enabled = enabled;
+        this._shader.setParams({ xrayEnabled:enabled });
+        this._flags.setTransparent(enabled);
+    },
+
+    /**
+     * Gets whether the X-Ray effect is enabled or not
+     * @return {Boolean}
+     */
+    getEnabled:function () {
+        return !!this._enabled;
+    },
+
+    /**
+     * Sets the degree of opacity for X-Ray effect, with 0 being fully transparent and 1 being fully opaque
+     * @param {Number} opacity
+     */
+    setOpacity:function (opacity) {
+        this._opacity = opacity;
+        this._shader.setParams({ xrayOpacity:opacity });
+    },
+
+    /**
+     * Gets the degree of opacity
+     * @return {Number}
+     */
+    getOpacity:function () {
+        return this._opacity;
+    },
+
+    /**
+     * Sets whether the X-Ray effect is monochrome or not
+     * @param {Boolean} monochrome
+     */
+    setMonochrome:function (monochrome) {
+        this._monochrome = monochrome;
+        this._shader.setParams({ xrayMonochrome:monochrome });        
+    },
+
+    /**
+     * Gets whether the X-Ray effect is monochrome or not
+     * @return {Boolean}
+     */
+    getMonochrome:function () {
+        return !!this._monochrome;
+    },
+
+    destruct:function () {
+        // Not used
+    }
+})
+;

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

@@ -0,0 +1,112 @@
+require([
+    // Prefix routes to plugin support libs
+    "scenejsPluginDeps/frustum/frustumCullSystemPool"
+],
+    function (pool) {
+
+        SceneJS.Types.addType("frustum/body", {
+
+            construct:function (params) {
+
+                // Frustum culling and projected canvas size enabled by default
+                this._frustumCull = params.frustumCull != undefined ? params.frustumCull : true;
+                this._detailCull = params.detailCull != undefined ? params.detailCull : true;
+
+                var shape = params.shape || "box";
+
+                switch (shape) {
+                    case "box":
+                        this._bodyCfg = {
+                            shape:shape,
+                            min:params.min || [0, 0, 0],
+                            max:params.max || [0, 0, 0],
+                            frustumCull:this._frustumCull,
+                            detailCull:this._detailCull
+                        };
+                        if (params.showBoundary) {
+                            this.addNode({
+                                type:"prims/boundary",
+                                min:params.min || [0, 0, 0],
+                                max:params.max || [0, 0, 0],
+                                wire:true
+                            });
+                        }
+                        break;
+
+//                    case "sphere":
+//                        this._bodyCfg = {
+//                            shape:"sphere",
+//                            center:params.center || [0, 0, 0],
+//                            radius:params.radius || 1.0
+//                        };
+//                        break;
+
+                    default:
+                        this.log("error", "Unsupported value for attribute 'shape'");
+                }
+
+                if (params.nodes) {
+                    this.addNodes(params.nodes);
+                }
+            },
+
+            preCompile:function () {
+
+                // This node might have been relocated in the scene graph
+                // and therefore inherits new view and projection transforms,
+                // so we'll release any existing system just in case.
+
+                this._putBody();
+                this._getBody();
+            },
+
+            _putBody:function () {
+                if (this._bodyId) {
+                    this._system.removeBody(this._bodyId);
+                    this._bodyId = null;
+                }
+                if (this._system) {
+                    pool.putSystem(this._system);
+                    this._system = null;
+                }
+            },
+
+            _getBody:function () {
+                try {
+                    this._system = pool.getSystem(this);
+                    var self = this;
+                    this._bodyId = this._system.createBody(this._bodyCfg,
+                        function (intersect, canvasSize) { // Body update handler
+
+                            // Not that much overhead in relaying status
+                            // updates via pub/sub because they only happen sparsely,
+                            // ie. for bodies whose status actually changes
+
+                            if (self._frustumCull) { // Frustum culling switching enabled
+                                self.publish("intersect", intersect);
+                            }
+
+                            if (self._detailCull) { // LOD switching enabled
+                                self.publish("canvasSize", canvasSize);
+                            }
+
+                            //  self.log(" intersect = " + intersect + ", canvasSize = " + canvasSize);
+                        });
+                } catch (e) {
+                    this.log("Error : " + e);
+                    if (this._system) {
+                        pool.putSystem(this._system);
+                        this._system = null;
+                    }
+                }
+            },
+
+            postCompile:function () {
+                // Not used
+            },
+
+            destruct:function () {
+                this._putBody();
+            }
+        });
+    });

data/vendor/assets/javascripts/scenejs_plugins/node/frustum/cull.js

@@ -0,0 +1,42 @@
+SceneJS.Types.addType("frustum/cull", {
+
+    construct:function (params) {
+
+        var self = this;
+
+        this.addNode({
+                type:"frustum/body",
+                shape:params.shape,
+                min:params.min,
+                max:params.max,
+                showBoundary:params.showBoundary,
+                frustumCull: params.frustumCull ? params.frustumCull : true, // Enable frustum culling?
+                detailCull: false // Don't need LOD switching
+            },
+            function (body) {
+                if (params.nodes) {
+                    self.addNode({
+                            type:"enable",
+                            enabled:false,
+                            nodes:params.nodes
+                        },
+                        function (enable) {
+                            body.on("intersect",
+                                function (intersect) {
+                                    switch (intersect) {
+                                        case 0: // Completely outside frustum
+                                            enable.setEnabled(false);
+                                            break;
+                                        case 1: // Partially inside frustum
+                                            enable.setEnabled(true);
+                                            break;
+                                        case 2: // Completely inside frustum
+                                            enable.setEnabled(true);
+                                            break;
+                                    }
+                                });
+                        });
+                }
+            });
+    }
+});

data/vendor/assets/javascripts/scenejs_plugins/node/frustum/lod.js

@@ -0,0 +1,125 @@
+SceneJS.Types.addType("frustum/lod", {
+
+    construct:function (params) {
+
+        var self = this;
+
+        var sizes = params.sizes;
+        if (!sizes) {
+            this.log("error", "mandatory attribute missing: 'sizes'");
+            return;
+        }
+
+        var nodes = params.nodes;
+        if (!nodes) {
+            this.log("error", "mandatory attribute missing: 'nodes'");
+            return;
+        }
+
+        if (sizes.length != nodes.length) {
+            this.log("error", "invalid attribute(s): 'sizes' and 'nodes' should be arrays of equal length");
+            return;
+        }
+
+        for (var i = 0, len = sizes.length; i < len; i++) {
+            if (sizes[i] <= 0) {
+                this.log("error", "invalid attribute: values in 'sizes' should be greater than zero");
+                return;
+            }
+            if (i > 0) {
+                if (sizes[i] <= sizes[i - 1]) {
+                    this.log("error", "invalid attribute: values in 'sizes' should be in ascending order");
+                    return;
+                }
+            }
+        }
+
+        this.addNode({
+                type:"frustum/body",
+                shape:params.shape,
+                min:params.min,
+                max:params.max,
+                showBoundary:params.showBoundary,
+                frustumCull: params.frustumCull ? params.frustumCull : true, // Enable frustum culling?
+                detailCull:true // Enable detail culling information (default)
+            },
+            function (body) {
+                if (params.nodes) {
+                    var childNodes = [];
+                    for (var i = 0, len = params.nodes.length; i < len; i++) {
+                        childNodes.push(self.addNode({
+                            type:"enable",
+                            enabled:false,
+                            nodes:[
+                                params.nodes[i]
+                            ]
+                        }));
+                    }
+
+                    // The currently active child node
+                    var currentNode;
+
+                    // If frustum culling is not disabled by
+                    // params.frustumCull, then we'll get notification
+                    // whenever the boundaries intersection status
+                    // changes with respect to the view frustum.
+
+                    body.on("intersect",
+                        function (intersect) {
+                            if (currentNode) {
+                                switch (intersect) {
+                                    case 0: // Completely outside frustum
+                                        currentNode.setEnabled(false);
+                                        break;
+                                    case 1: // Partially inside frustum
+                                        currentNode.setEnabled(true);
+                                        break;
+                                    case 2: // Completely inside frustum
+                                        currentNode.setEnabled(true);
+                                        break;
+                                }
+                            }
+                        });
+
+                    // If frustum culling is not disabled by params.frustumCull,
+                    // then we'll get notifications of change in projected canvas
+                    // size for the boundary as long as the "intersect" notification
+                    // reported that the boundary is not outside the view frustum.
+
+                    // If frustum culling is disabled. then we'll get
+                    // notification of canvas size changes regardless of
+                    // whether the boundary is outside the frustum of not.
+
+                    body.on("canvasSize",
+                        function (canvasSize) {
+
+                            if (currentNode) {
+
+                                // We only get a 2d size update when the size has changed,
+                                // so its safe to say we'll not be immediately re-enabling
+                                // the currently enabled child node. No need to avoid
+                                // any redundant re-enabling or disabling here.
+
+                                currentNode.setEnabled(false);
+                            }
+//
+                            if (canvasSize == -1) {
+                                // All Culled
+                                return;
+                            }
+
+                            // Enable the appropriate child, if any,
+                            // for the boundary's projected 2D size
+
+                            for (var i = sizes.length - 1; i >= 0; i--) {
+                                if (canvasSize >= sizes[i]) {
+                                    currentNode = childNodes[i];
+                                    currentNode.setEnabled(true);
+                                    return;
+                                }
+                            }
+                        });
+                }
+            });
+    }
+});