scenejs_on_rails 1.0.0 → 1.0.1

data/vendor/assets/javascripts/scenejs_plugins/node/canvas/capture.js

@@ -0,0 +1,107 @@
+/**
+ * Custom node which captures images of the scene canvas
+ *
+ * Usage example:
+ *
+ * someNode.addNode({
+ *      type: "canvas/capture",
+ *
+ *      // Optional image format, "jpeg" (default), "png" or "bmp"
+ *      format: "jpeg",
+ *
+ *      // Optional image result size, defaults to current size of canvas at time of capture
+ *      width: 300,
+ *      height: 400
+ * });
+ *
+ *  scene.getNode("myCanvasCapture",
+ *      function (myCanvasCapture) {
+ *
+ *         // Subscribe to captured image
+ *         myCanvasCapture.on("image",
+ *             function (data) {
+ *                 var src = data.src;       // Data URL
+ *                 var width = data.width;   // Width of image
+ *                 var height = data.height; // Height of image
+ *             });
+ *
+ *        // Do capture
+ *        myCanvasCapture.capture({
+ *
+ *             // Optional dimensions of desired image, falls back on node config,
+  *             // or if not specified there, the current size of canvas
+ *             width: 500,
+ *             height: 400,
+ *
+ *             // Optional format - falls back on node config,
+ *             // or if not specified there, "jpeg"
+ *             format: "jpeg"
+ *        });
+ */
+require([
+
+    // This prefix routes to the 3rd-party libs directory containing resources used by plugins
+    "scenejsPluginDeps/canvas2image"
+],
+    function () {
+
+        SceneJS.Types.addType("canvas/capture", {
+
+            construct:function (params) {
+                this._format = params.format ? supportedFormat(params.format) : "jpeg";
+                this._width = params.width;
+                this._height = params.height;
+            },
+
+            capture:function (params) {
+
+                params = params || {};
+
+                var scene = this.getScene();
+                scene.renderFrame({ force:true }); // HACK - need to fix need for this in SceneJS
+                var canvas = scene.getCanvas();
+
+                var width = params.width || this._width || canvas.width;
+                var height = params.height || this._height || canvas.height;
+
+                var image;
+
+                var format = params.format ? this._supportedFormat(params.format) : this._format;
+
+                switch (format) {
+                    case "jpeg":
+                        image = Canvas2Image.saveAsJPEG(canvas, true, width, height);
+                        break;
+
+                    case "png":
+                        image = Canvas2Image.saveAsPNG(canvas, true, width, height);
+                        break;
+
+                    case "bmp":
+                        image = Canvas2Image.saveAsBMP(canvas, true, width, height);
+                        break;
+
+                    default:
+                        this.log("error", "format unsupported: " + format);
+                        return;
+                }
+
+                this.publish("image", {
+                    src:image.src,
+                    format:format,
+                    width:width,
+                    height:height
+                });
+            },
+
+            _supportedFormat:function (format) {
+                if (format != "jpeg" && format != "png" && format != "bmp") {
+                    this.log("error", "unsupported format for canvas/capture node: " + format
+                        + " - supported types are 'jpeg', 'bmp' and 'png' - falling back on 'jpeg'");
+                    return "jpeg";
+                }
+                return format;
+            }
+        });
+
+    });

data/vendor/assets/javascripts/scenejs_plugins/node/demos/color.js

@@ -0,0 +1,30 @@
+SceneJS.Types.addType("demos/color", {
+
+    construct:function (params) {
+
+        this._material = this.addNode({
+            type:"material",
+
+            // Custom node types are responsible for attaching any child nodes that
+            // are specified in their properties
+            nodes:params.nodes
+        });
+
+        // Set initial color, if provided
+        if (params.color) {
+            this.setColor(params.color);
+        }
+    },
+
+    setColor:function (color) {
+        this._material.setColor(color);
+    },
+
+    getColor:function () {
+        return this._material.getColor();
+    },
+
+    destruct:function () {
+        // Not used
+    }
+});

data/vendor/assets/javascripts/scenejs_plugins/node/demos/redTeapot.js

@@ -0,0 +1,52 @@
+/**
+ * A red teapot node type with attributes for position and size.
+ * Demonstrates how to expose settable attributes on a custom node type.
+ */
+SceneJS.Types.addType("demos/redTeapot", {
+
+    construct:function (params) {
+
+        // Create child nodes
+
+        this._translate = this.addNode({
+            type:"translate"
+        });
+
+        this._scale = this._translate.addNode({
+            type:"scale",
+            x:1, y:1, z:1,
+            nodes:[
+                {
+                    type:"material",
+                    color:{ r:1.0, g:0.6, b:0.6 },
+                    nodes:[
+                        {
+                            type:"geometry",
+                            source:{
+                                type:"teapot"
+                            }
+                        }
+                    ]
+                }
+            ]
+        });
+
+        // Set initial position and size, if provided
+        if (params.pos) {
+            this.setPos(params.pos);
+        }
+        if (params.size) {
+            this.setSize(params.size);
+        }
+    },
+
+    // Sets position of teapot
+    setPos:function (pos) {
+        this._translate.setXYZ(pos);
+    },
+
+    // Sets size of teapot
+    setSize:function (size) {
+        this._scale.setXYZ(size);
+    }
+});

data/vendor/assets/javascripts/scenejs_plugins/node/demos/spinningTeapot.js

@@ -0,0 +1,43 @@
+/**
+ * A spinning teapot node type.
+ * Demonstrates how to hook the type into the scene animation loop for autonomous animation.
+ */
+SceneJS.Types.addType("demos/spinningTeapot", {
+
+    construct:function (params) {
+
+        // Create child nodes
+        var rotate = this.addNode({
+            type:"rotate",
+            y:1,
+            angle:0,
+            nodes:[
+                {
+                    type:"material",
+                    color:{ r:0.6, g:1.0, b:0.6 },
+                    nodes:[
+                        {
+                            type:"geometry",
+                            source:{
+                                type:"teapot"
+                            }
+                        }
+                    ]
+                }
+            ]
+        });
+
+        // Spin the teapot within the scene animation loop
+        var angle = 0;
+        this._tick = this.getScene().on("tick",
+            function () {
+                rotate.setAngle(angle);
+                angle += 0.1;
+            });
+    },
+
+    // Node destructor, unsubscribes from scene tick
+    destruct:function () {
+        this.getScene().off(this._tick);
+    }
+});

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

@@ -0,0 +1,36 @@
+SceneJS.Types.addType("effects/crt", {
+
+    construct:function (params) {
+
+        this._shader = this.addNode({
+            type:"shader",
+
+            shaders:[
+
+                {
+                    stage:"fragment",
+                    code:"vec4 myPixelColorFunc(vec4 color) {\n\
+                              float m = mod(gl_FragCoord.y, 4.0);\n\
+                              if (m < 1.5) {\n\
+                                  color = vec4(0.0, 0.0, 0.0, 1.0);\n\
+                              } else if (m < 2.0) {\n\
+                                  color = vec4(0.2, 0.2, 0.2, 1.0);\n\
+                              } else if (m < 2.5) {\n\
+                                  color = vec4(0.2, 0.2, 0.2, 1.0);\n\
+                              }\n\
+                              return color;\n\
+                          }",
+
+                    hooks:{
+                        pixelColor:"myPixelColorFunc"
+                    }
+                }
+            ],
+            nodes:params.nodes
+        });
+    },
+
+    destruct:function () {
+        // Not used
+    }
+});

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

@@ -0,0 +1,159 @@
+SceneJS.Types.addType("effects/fog", {
+
+    construct:function (params) {
+
+        // Holds params for custom shader node
+        this._shaderParams = {
+            fogMode:1.0, // 0.0 disabled, 1.0 linear, 2.0 exponential, 3.0 quadratic, 4.0 constant
+            fogDensity:0.05, // Fog density in range of [0.0..1.0]
+            fogStart:0.0, // Nearest point of fog in view space (receeding Z-axis is positive)
+            fogEnd:10000.0, // Furthest point of fog in view space
+            fogColor:[0.6, 0.0, 0.0]  // Colour of fog - the colour that objects blend into
+        };
+
+        // Custom shader node
+        this._shader = this.addNode({
+            type:"shader",
+            coreId:"effects/fog",
+
+            shaders:[
+
+                {
+                    stage:"fragment",
+                    code:[
+
+                        /* Parameter uniforms
+                         */
+                        "uniform float  fogMode;",
+                        "uniform float  fogDensity;",
+                        "uniform float  fogStart;",
+                        "uniform float  fogEnd;",
+                        "uniform vec3   fogColor;",
+
+                        /* Collected view-space fragment position
+                         */
+                        "vec4 _viewPos;",
+
+                        /* Collects view-space fragment position
+                         */
+                        "void fogViewPosFunc(vec4 viewPos) {",
+                        "   _viewPos = viewPos;",
+                        "}",
+
+                        /* Modifies fragment colour
+                         */
+                        "vec4 fogPixelColorFunc(vec4 color) {",
+                        "   if (fogMode != 0.0) {", // not "disabled"
+                        "       float fogFactor = (1.0 - fogDensity);",
+                        "       if (fogMode != 4.0) {", // not "constant"
+                        "           if (fogMode == 1.0) {", // "linear"
+                        "               fogFactor *= clamp(pow(max((fogEnd - length(- _viewPos.xyz)) / " +
+                            "                   (fogStart - fogEnd), 0.0), 2.0), 0.0, 1.0);",
+                        "           } else {", // "exp" or "exp2"
+                        "               fogFactor *= clamp((fogStart - length(- _viewPos.xyz)) / (fogStart - fogEnd), 0.0, 1.0);",
+                        "           }",
+                        "       }",
+                        "       return color * (fogFactor + vec4(fogColor, 1.0)) * (1.0 - fogFactor);",
+                        "   }",
+                        "   return color;",
+                        "}"
+                    ],
+
+                    /* Bind our functions to hooks
+                     */
+                    hooks:{
+                        viewPos:"fogViewPosFunc",
+                        pixelColor:"fogPixelColorFunc"
+                    }
+                }
+            ],
+
+            // Declare parameters and set default values
+            params:this._shaderParams,
+
+            nodes:params.nodes
+        });
+
+        if (params.mode != undefined) {
+            this.setMode(params.mode);
+        }
+        if (params.density != undefined) {
+            this.setDensity(params.density);
+        }
+        if (params.start != undefined) {
+            this.setStart(params.start);
+        }
+        if (params.end != undefined) {
+            this.setEnd(params.end);
+        }
+        if (params.color != undefined) {
+            this.setColor(params.color);
+        }
+    },
+
+    setMode:function (mode) {
+        switch (mode) {
+            case "disabled":
+                this._shaderParams.fogMode = 0;
+                break;
+            case "linear":
+                this._shaderParams.fogMode = 1;
+                break;
+            case "exp":
+                this._shaderParams.fogMode = 2;
+                break;
+            case "exp2":
+                this._shaderParams.fogMode = 3;
+                break;
+            case "constant":
+                this._shaderParams.fogMode = 4;
+                break;
+        }
+        this._shader.setParams(this._shaderParams);
+    },
+
+    getMode:function () {
+        return ["disabled", "linear", "exp", "exp2", "constant"][this._shaderParams.fogMode]; // TODO: optimize
+    },
+
+    setDensity:function (density) {
+        this._shaderParams.fogDensity = density;
+        this._shader.setParams(this._shaderParams);
+    },
+
+    getDensity:function () {
+        return this._shaderParams.fogDensity;
+    },
+
+    setStart:function (start) {
+        this._shaderParams.fogStart = start;
+        this._shader.setParams(this._shaderParams);
+    },
+
+    getStart:function () {
+        return this._shaderParams.fogStart;
+    },
+
+    setEnd:function (end) {
+        this._shaderParams.fogEnd = end;
+        this._shader.setParams(this._shaderParams);
+    },
+
+    getEnd:function () {
+        return this._shaderParams.fogEnd;
+    },
+
+    setColor:function (color) {
+        this._shaderParams.fogColor = [color.r || 0, color.g || 0, color.b || 0 ];
+        this._shader.setParams(this._shaderParams);
+    },
+
+    getColor:function () {
+        var color = this._shaderParams.fogColor;
+        return { r:color[0], g:color[1], b:color[2] };
+    },
+
+    destruct:function () {
+        // Not used
+    }
+});

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

@@ -0,0 +1,50 @@
+SceneJS.Types.addType("effects/snowyPeaks", {
+
+    construct:function (params) {
+
+        var altitude = params.altitude || 0;
+
+        this._shader = this.addNode({
+            type:"shader",
+            shaders:[
+                {
+                    stage:"fragment",
+                    code:[
+                        "float posY = 0.0;",
+                        "vec4 myWorldPosFunc(vec4 pos){",
+                        "   posY=pos.y;",
+                        "   return pos;",
+                        "}",
+
+                        "uniform float altitude;",
+                        "vec3 myMaterialBaseColorFunc(vec3 color) {",
+                        "   if (posY > altitude) {",
+                        "       color = vec3(1.0, 1.0, 1.0);",
+                        "   }",
+                        "   return color;",
+                        "}"
+                    ],
+                    hooks:{
+                        materialBaseColor:"myMaterialBaseColorFunc",
+                        worldPos:"myWorldPosFunc"
+                    }
+                }
+            ],
+            params:{
+                altitude:altitude
+            },
+            nodes:params.nodes
+        });
+    },
+
+    setAltitude:function (altitude) {
+        this._shader.setParams({
+            altitude:altitude
+        });
+    },
+
+    destruct:function () {
+        // Not used
+    }
+})
+;