Merge pull request #4634 from ctrlaltdavid/20471

CR for Job #20471 - Create rain.js

examples/acScripts/rain.js

@@ -0,0 +1,163 @@
+//
+//  rain.js
+//  examples
+//
+//  Created by David Rowe on 9 Apr 2015.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+var RainSquall = function (properties) {
+    var // Properties
+        squallOrigin,
+        squallRadius,
+        dropsPerMinute = 60,
+        dropSize = { x: 0.1, y: 0.1, z: 0.1 },
+        dropFallSpeed = 1,                                      // m/s
+        dropLifetime = 60,                                      // Seconds
+        dropSpinMax = 0,                                        // Maximum angular velocity per axis; deg/s
+        debug = false,                                          // Display origin circle; don't use running on Stack Manager
+        // Other
+        squallCircle,
+        SQUALL_CIRCLE_COLOR = { red: 255, green: 0, blue: 0 },
+        SQUALL_CIRCLE_ALPHA = 0.5,
+        SQUALL_CIRCLE_ROTATION = Quat.fromPitchYawRollDegrees(90, 0, 0),
+        raindropProperties,
+        RAINDROP_MODEL_URL = "https://s3.amazonaws.com/hifi-public/ozan/Polyworld/Sets/sky/tetrahedron_v1-Faceted2.fbx",
+        raindropTimer,
+        raindrops = [],                                         // HACK: Work around raindrops not always getting velocities
+        raindropVelocities = [],                                // HACK: Work around raindrops not always getting velocities
+        DEGREES_TO_RADIANS = Math.PI / 180;
+
+    function processProperties() {
+        if (!properties.hasOwnProperty("origin")) {
+            print("ERROR: Rain squall origin must be specified");
+            return;
+        }
+        squallOrigin = properties.origin;
+
+        if (!properties.hasOwnProperty("radius")) {
+            print("ERROR: Rain squall radius must be specified");
+            return;
+        }
+        squallRadius = properties.radius;
+
+        if (properties.hasOwnProperty("dropsPerMinute")) {
+            dropsPerMinute = properties.dropsPerMinute;
+        }
+
+        if (properties.hasOwnProperty("dropSize")) {
+            dropSize = properties.dropSize;
+        }
+
+        if (properties.hasOwnProperty("dropFallSpeed")) {
+            dropFallSpeed = properties.dropFallSpeed;
+        }
+
+        if (properties.hasOwnProperty("dropLifetime")) {
+            dropLifetime = properties.dropLifetime;
+        }
+
+        if (properties.hasOwnProperty("dropSpinMax")) {
+            dropSpinMax = properties.dropSpinMax;
+        }
+
+        if (properties.hasOwnProperty("debug")) {
+            debug = properties.debug;
+        }
+
+        raindropProperties = {
+            type: "Model",
+            modelURL: RAINDROP_MODEL_URL,
+            lifetime: dropLifetime,
+            dimensions: dropSize,
+            velocity: { x: 0, y: -dropFallSpeed, z: 0 },
+            damping: 0,
+            angularDamping: 0,
+            ignoreForCollisions: true
+        };
+    }
+
+    function createRaindrop() {
+        var angle,
+            radius,
+            offset,
+            drop,
+            spin = { x: 0, y: 0, z: 0 },
+            maxSpinRadians = properties.dropSpinMax * DEGREES_TO_RADIANS,
+            i;
+
+        // HACK: Work around rain drops not always getting velocities set at creation
+        for (i = 0; i < raindrops.length; i += 1) {
+            Entities.editEntity(raindrops[i], raindropVelocities[i]);
+        }
+
+        angle = Math.random() * 360;
+        radius = Math.random() * squallRadius;
+        offset = Vec3.multiplyQbyV(Quat.fromPitchYawRollDegrees(0, angle, 0), { x: 0, y: -0.1, z: radius });
+        raindropProperties.position = Vec3.sum(squallOrigin, offset);
+        if (properties.dropSpinMax > 0) {
+            spin = { 
+                x: Math.random() * maxSpinRadians,
+                y: Math.random() * maxSpinRadians,
+                z: Math.random() * maxSpinRadians
+            };
+            raindropProperties.angularVelocity = spin;
+        }
+        drop = Entities.addEntity(raindropProperties);
+
+        // HACK: Work around rain drops not always getting velocities set at creation
+        raindrops.push(drop);
+        raindropVelocities.push({
+            velocity: raindropProperties.velocity,
+            angularVelocity: spin
+        });
+        if (raindrops.length > 5) {
+            raindrops.shift();
+            raindropVelocities.shift();
+        }
+    }
+
+    function setUp() {
+        if (debug) {
+            squallCircle = Overlays.addOverlay("circle3d", {
+                size: { x: 2 * squallRadius, y: 2 * squallRadius },
+                color: SQUALL_CIRCLE_COLOR,
+                alpha: SQUALL_CIRCLE_ALPHA,
+                solid: true,
+                visible: debug,
+                position: squallOrigin,
+                rotation: SQUALL_CIRCLE_ROTATION
+            });
+        }
+
+        raindropTimer = Script.setInterval(createRaindrop, 60000 / dropsPerMinute);
+    }
+
+    function tearDown() {
+        Script.clearInterval(raindropTimer);
+        if (debug) {
+            Overlays.deleteOverlay(squallCircle);
+        }
+    }
+
+    processProperties();
+    setUp();
+    Script.scriptEnding.connect(tearDown);
+
+    return {
+    };
+};
+
+var rainSquall1 = new RainSquall({
+    origin: { x: 1195, y: 1223, z: 1020 },
+    radius: 25,
+    dropsPerMinute: 120,
+    dropSize: { x: 0.1, y: 0.1, z: 0.1 },
+    dropFallSpeed: 3,
+    dropLifetime: 30,
+    dropSpinMax: 180,
+    debug: false
+});