scenejs_on_rails 1.0.0 → 1.0.1

data/vendor/assets/javascripts/scenejs_plugins/lib/frustum/frustumCullSystem.js

@@ -0,0 +1,185 @@
+/**
+ * A frustum cuilling system, which manages a frustum culling worker implemented in frustumCullWorker.js
+ */
+(function () {
+
+    define(function () {
+        return System;
+    });
+
+    function System(systemId) {
+
+        this.systemId = systemId;
+
+        // Maximum number of bodies supported per system
+        var maxBodies = 1000;
+
+        var bodies = [];
+        var map = new Map(bodies);
+
+        // Create engine in worker
+        var workerPath = SceneJS.getConfigs().pluginPath + "/lib/frustum/frustumCullWorker.js";
+        var worker = new Worker(workerPath);
+
+        var workerOutputBuf = new ArrayBuffer(maxBodies * 3);
+
+        // True while worker is busy integrating
+        // We don't send integration requests to it while this is true
+        var integrating = false;
+
+        // System is integrating only when this true
+        var enabled = true;
+
+        // Schedules integration when true
+        var needIntegrate = true;
+
+        // Route updates from engine to bodies
+        worker.addEventListener('message',
+            function (e) {
+
+                var data = e.data;
+                workerOutputBuf = data.buffer; // Worker transfers ownership of buffer to us
+                var output = new Int16Array(workerOutputBuf);
+                var lenOutput = data.lenOutput;
+                var bodyId;
+                var body;
+                var intersect;
+                var canvasSize;
+
+                // The data buffer from the web worker contains a 3-element portion for
+                // each body, each of which contains the body ID, frustum intesection status
+                // and projected canvas size:
+                //
+                // [
+                //      bodyId, intersect, canvasSize
+                //      bodyId, intersect, canvasSize
+                //      ...
+                // ]
+                for (var i = 0, len = lenOutput - 2; i < len; i += 3) {
+                    bodyId = output[i]; // First element for body ID
+                    body = bodies[bodyId];
+                    intersect = output[i + 1];
+                    canvasSize = output[i + 2];
+                    if (body) { // May have been deleted
+                        body.callback(intersect, canvasSize);
+                    }
+                }
+
+                integrating = false;
+
+            }, false);
+
+        /**
+         * Configures this system
+         * @param configs Values for configs
+         */
+        this.setConfigs = function (configs) {
+            needIntegrate = true;
+            worker.postMessage({ cmd:"setConfigs", configs:configs });
+        };
+
+        /**
+         * Enable or disable this system.
+         * To save on CPU, you would typically disable the system when its not in view.
+         * @param enable
+         */
+        this.setEnabled = function (enable) {
+            enabled = enable;
+            if (enable) {
+                needIntegrate = true;
+            }
+        };
+
+        /**
+         * Creates a body, returns it's unique ID
+         * @param params Body params
+         * @param callback Callback fired whenever body updated
+         * @return Body ID
+         */
+        this.createBody = function (params, callback) {
+            needIntegrate = true;
+            var bodyId = map.add({
+                callback:callback
+            });
+            worker.postMessage({ cmd:"createBody", bodyId:bodyId, bodyCfg:params });
+            return bodyId;
+        };
+
+        /**
+         * Updates an existing body
+         * @param bodyId Body ID
+         * @param params Body params
+         */
+        this.updateBody = function (bodyId, params) {
+            needIntegrate = true;
+            worker.postMessage({ cmd:"updateBody", bodyId:bodyId, bodyCfg:params });
+        };
+
+        /**
+         * Removes a body
+         */
+        this.removeBody = function (bodyId) {
+            worker.postMessage({ cmd:"removeBody", bodyId:bodyId });
+            map.remove(bodyId);
+        };
+
+        /**
+         * Integrates this system
+         * Does nothing when system is disabled with {@link System#setEnabled}.
+         */
+        this.integrate = function () {
+            if (!enabled) {
+                return;
+            }
+            if (integrating) { // Don't choke worker
+                return;
+            }
+            if (needIntegrate) {
+                integrating = true;
+                needIntegrate = false;
+                // Transfer ownership of output buffer to the worker
+                var msg = {
+                    cmd:"integrate",
+                    buffer:workerOutputBuf
+                };
+                worker.postMessage(msg, [msg.buffer]);
+            }
+        };
+
+        /**
+         * Destroys system, terminating its worker
+         */
+        this.destroy = function () {
+            worker.terminate();
+        };
+    }
+
+    /**
+     * Uniquely ID'd map of items
+     * @param items Array that will contain the items
+     */
+    function Map(items) {
+        this.add = function (item) {
+
+            // Start looking from the beginning of the array
+            // because we don't want an infinitely-expanding
+            // sparse array as we remove then add nodes.
+
+            // We're trading insertion overhead for the benefit
+            // of a nicely packed array that's fast to traverse
+            // when posting output.
+
+            var i = 0;
+            while (true) {
+                if (!items[i]) {
+                    items[i] = item;
+                    return i;
+                }
+                i++;
+            }
+        };
+        this.remove = function (id) {
+            delete items[id];
+        };
+    }
+})();

data/vendor/assets/javascripts/scenejs_plugins/lib/frustum/frustumCullSystemPool.js

@@ -0,0 +1,174 @@
+/**
+ * Container of frustum culling systems
+ */
+define([
+    // Prefix routes to plugin support libs
+    "scenejsPluginDeps/frustum/frustumCullSystem"
+],
+    function (System) {
+
+        // Systems
+        var items = {};
+
+        // Each scene/lookat/camera combination will have its own culling system
+        // Each system will actually be distributed across multiple systems
+        // This is the number of client scene nodes that will be served by each of those
+        // TODO: tune this
+        var BODIES_PER_SYSTEM = 100;
+
+        return  {
+
+            /**
+             * Acquire a frustum culling system for a SceneJS node
+             *
+             * @param {SceneJS.Node} node
+             * @return {System} The system
+             */
+            getSystem:function (node) {
+
+                // Get parent lookat and camera nodes,
+                // along with the scene root
+
+                var lookat = node.getParentOfType("lookAt");
+                var camera = node.getParentOfType("camera");
+                var scene = node.getScene();
+
+                // Generate a system ID unique to the
+                // scene and whatever view and projection
+                // coordinate system we are within
+
+                var systemBaseId =
+                    scene.getId()
+                        + (lookat ? ("." + lookat.getId()) : ".default")
+                        + (camera ? ("." + camera.getId()) : ".default")
+                        + ".";
+
+                var systemId;
+                var item;
+
+                // Try to acquire an existing system
+                // using the system ID
+
+                for (var i = 0, done = false; !done; i++) {
+                    systemId = systemBaseId + i;
+                    item = items[systemId];
+                    if (item) {
+                        if (item.useCount < BODIES_PER_SYSTEM) {
+                            item.useCount++;
+                            return item.system;
+                        }
+                    } else {
+                        done = true;
+                    }
+                }
+
+                // Did not acquire a system - create a new system
+
+                var system = new System(systemId);
+
+                item = {
+                    useCount:1,
+                    system:system,
+                    scene:scene
+                };
+
+                var systemConfigs = {};
+
+                // Updates to a parent 'lookat' node
+                // will update the system's frustum
+
+                if (lookat) {
+                    item.lookat = lookat;
+                    item.viewMatSub = lookat.on("matrix",
+                        function (matrix) {
+                            system.setConfigs({
+                                viewMat:matrix
+                            });
+                        });
+                } else {
+                    systemConfigs.viewMat = SceneJS.Lookat.getDefaultMatrix();
+                }
+
+                // Updates to a parent 'camera' node
+                // will update the system's frustum
+
+                if (camera) {
+                    item.camera = camera;
+                    item.projMatSub = camera.on("matrix",
+                        function (matrix) {
+                            system.setConfigs({
+                                projMat:matrix
+                            });
+                        });
+                } else {
+                    systemConfigs.projMat = SceneJS.Camera.getDefaultMatrix();
+                }
+
+                // Updates to a parent 'enable' node will
+                // enable or disable this culling system
+
+//                var enabled = true;
+//                var enable = node.getParentOfType("enable");
+//                if (enable) {
+//                    item.enable = enable;
+//                    item.enableSub = enable.on("enabled",
+//                        function (_enabled) {
+//                            enabled = _enabled;
+//                        });
+//                }
+
+                // Integrate the system on each scene tick,
+                // unless disabled by parent 'enable' node
+
+                item.tickSub = scene.on("tick", // Start integrating the system on scene tick
+                    function () {
+                       // if (enabled) {
+                            system.integrate();
+                       // }
+                    });
+
+                //
+
+                var canvas = scene.getCanvas();
+                systemConfigs.viewport = [0, 0, canvas.width, canvas.height];
+
+                system.setConfigs(systemConfigs);
+
+                items[systemId] = item;
+
+                return system;
+            },
+
+
+            /**
+             * Release a frustum culling system, destroying it if no more users.
+             * @param {System} system
+             */
+            putSystem:function (system) {
+                var item = items[system.systemId];
+                if (item) {
+                    if (item.useCount-- <= 0) {
+                        item.system.destroy();
+
+                        // Unsubscribe from any parent nodes
+                        // we were updating the system off
+
+                        if (item.lookat) {
+                            item.lookat.off(item.viewMatSub);
+                        }
+                        if (item.camera) {
+                            item.camera.off(item.projMatSub);
+                        }
+                        if (item.enable) {
+                            item.enable.off(item.enableSub);
+                        }
+
+                        // Stop integrating the system
+                        item.scene.off(item.tickSub);
+
+                        delete items[system.systemId];
+                    }
+                }
+            }
+        };
+    });

data/vendor/assets/javascripts/scenejs_plugins/lib/frustum/frustumCullWorker.js

@@ -0,0 +1,142 @@
+/**
+ * Web worker containing an instance of a frustum culling engine implemented
+ * in frustumCullEngine.js
+ *
+ * This worker accepts various commands to configure the engine, add or remove
+ * bodies, and integrate, which means find and changes in frustum intersection
+ * status and projected canvas size of the bodies.
+ *
+ * On each integration, for each body whose intersection state and/or canvas size
+ * has changed, this worker posts back an Int16Array containing those updates.
+ *
+ * Input Commands
+ * --------------------------------------------------------------------------
+ *
+ * Configure the system
+ * --------------------
+ * {
+ *      cmd: "setConfigs",
+ *      viewMat: Array(16),
+ *      projMat: Array(16),
+ *      viewport: Array[4]
+ * }
+ *
+ * Create a body
+ * -------------
+ *
+ * Axis-aligned bounding box:
+ * {
+ *      cmd: "createBody",
+ *      bodyId: Number,
+ *      bodyCfg: {
+ *          shape: "box",
+ *          min: [Number, Number, Number],
+ *          max: [Number, Number, Number],
+ *          frustumCull: Boolean, // Perform frustum culling for this body? Default is true.
+ *          detailCull: Boolean, // Perform detail culling for this body? Default is true.
+ *      }
+ *  }
+ *
+ * Remove a body:
+ * {
+ *      cmd: "removeBody",
+ *      bodyId: Number
+ * }
+ *
+ * Integrate the engine:
+ * {
+ *      cmd: "integrate"
+ * }
+ *
+ * For efficiency, the physics system manages bodies in an array. The "bodyId"
+ * parameter on the "createBody" command is the index for that body in the array.
+ *
+ * The "removeBody" command will delete a body from the array, leaving a hole.
+ *
+ * The worker can handle holes in the array OK, but in order to keep the array
+ * from getting too sparse, it's the reponsibility of the worker client to make
+ * its next "createBody" command specify a "bodyId" that indexes that hole, to plug
+ * the gap with the next new body.
+ *
+ * Output Buffer
+ * --------------------------------------------------------------------------
+ *
+ * The output buffer is an Int16Array containing a 3-element portion for each
+ * body, each of which contains the body ID, its frustum intersection status and the
+ * projected size within the viewport:
+ *
+ * [
+ *      bodyId, intersect, canvasSize,
+ *      bodyId, intersect, canvasSize
+ *      ...
+ * ]
+ *
+ * intersect:
+ *      0 == body is completely outside frustum
+ *      1 == body is partially inside frustum
+ *      2 == body is completely inside frustum
+ *      Undefined when body frustumCull == false
+ *
+ * canvasSize:
+ *      For box, will be the length of diagonal size of projected boundary.
+ *      Undefined when body detailCull == false or intersect == 0.
+ *
+ */
+importScripts("frustumCullEngine.js");
+
+// Array in which this worker posts back status for each updated body
+var output;
+
+// The engine
+var engine = new Engine();
+
+// Handle a command from worker owner
+addEventListener("message",
+    function (e) {
+
+        var data = e.data;
+
+        switch (data.cmd) {
+
+            // Configure the engine
+            case "setConfigs":
+                engine.setConfigs(data.configs);
+                break;
+
+            // Create a body
+            case "createBody":
+                engine.addBody(data.bodyId, data.bodyCfg);
+                break;
+
+            // Remove a body
+            case "removeBody":
+                engine.removeBody(data.bodyId);
+                break;
+
+            // Integrate the engine and post back the body updates
+            case "integrate":
+                var output = new Int16Array(data.buffer);
+                var body;
+                var ibuf = 0;
+                engine.integrate(
+                    function (updatedBodies, numUpdated) {
+                        for (var i = 0; i < numUpdated; i++) {
+                            body = updatedBodies[i];
+                            output[ibuf++] = body.bodyId;
+                            output[ibuf++] = body.intersect;
+                            output[ibuf++] = body.canvasSize;
+                        }
+                        // Post the output
+                        var response = {
+                            buffer:output.buffer,
+                            lenOutput:ibuf
+                        };
+                        self.postMessage(response, [response.buffer]);
+                    });
+                break;
+
+            default:
+                break;
+        }
+    }, false);
+