elation-engine 0.9.127 → 0.10.0

package/css/systems/render.css

@@ -3,7 +3,7 @@ engine-systems-render-view>canvas {
   z-index: 1;
 }
 .engine_systems_render_css3d {
-  position:fixed;
+  position:absolute;
   top: 0;
   left: 0;
   z-index: 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elation-engine",
   "description": "WebGL/WebVR engine written in Javascript",
-  "version": "0.9.127",
+  "version": "0.10.0",
   "main": "",
   "author": "James Baicoianu",
   "license": "MIT",

package/scripts/external/three/three.js

@@ -45631,7 +45631,7 @@
 			// ensure there is a value node
 			if ( ! targetObject ) {
 
-				console.error( 'THREE.PropertyBinding: Trying to update node for track: ' + this.path + ' but it wasn\'t found.' );
+				//console.error( 'THREE.PropertyBinding: Trying to update node for track: ' + this.path + ' but it wasn\'t found.' );
 				return;
 
 			}

package/scripts/systems/ai.js

@@ -15,7 +15,7 @@ elation.require("engine.things.controller", function() {
           try {
             this.performThink(this.thinkers[i], ev.data);
           } catch (e) {
-            console.log(e.stack);
+            console.log(e);
           }
         }
       }

package/scripts/systems/controls.js

@@ -220,15 +220,16 @@ elation.require(['ui.window', 'ui.panel', 'ui.toggle', 'ui.slider', 'ui.label',
       }
       this.initialized = true;
     }
-    this.addCommands = function(context, commands) {
-      this.contexts[context] = commands;
+    this.addCommands = function(context, commands, target=null) {
+      if (!this.contexts[context]) this.contexts[context] = new Map();
+      this.contexts[context].set(target, commands);
     }
     this.addContexts = function(contexts) {
       for (var k in contexts) {
         this.addContext(k, contexts[k]);
       }
     }
-    this.addContext = function(context, contextargs) {
+    this.addContext = function(context, contextargs, target=null) {
       var commands = {};
       var bindings = {};
       var states = {};
@@ -240,10 +241,11 @@ elation.require(['ui.window', 'ui.panel', 'ui.toggle', 'ui.slider', 'ui.label',
         commands[k] = contextargs[k][1];
         states[k] = 0;
       }
-      this.addCommands(context, commands);
+      this.addCommands(context, commands, target);
       this.addBindings(context, bindings);
-      this.contextstates[context] = states;
-      console.log("[controls] added control context: " + context);
+      if (!this.contextstates[context]) this.contextstates[context] = new Map();
+      this.contextstates[context].set(target, states);
+      console.log("[controls] added control context: " + context, target, states);
 
       // FIXME - context state object should be a JS class, with reset() as a member function
       states._reset = function() {
@@ -257,9 +259,14 @@ elation.require(['ui.window', 'ui.panel', 'ui.toggle', 'ui.slider', 'ui.label',
       return states;
     }
     this.activateContext = function(context, target) {
-      if (this.activecontexts.indexOf(context) == -1) {
+      let idx = this.activecontexts.indexOf(context);
+      if (idx == -1) {
         console.log('[controls] activate control context ' + context);
         this.activecontexts.unshift(context);
+      } else {
+        // Move context to top of the context stack if it's already active
+        this.activecontexts.splice(idx, 1);
+        this.activecontexts.unshift(context);
       }
       if (target) {
         this.contexttargets[context] = target;
@@ -307,19 +314,37 @@ elation.require(['ui.window', 'ui.panel', 'ui.toggle', 'ui.slider', 'ui.label',
 //console.log('fired!', firedev);
           for (var j = 0; j < this.activecontexts.length; j++) {
             var context = this.activecontexts[j];
-            var contextstate = this.contextstates[context] || {};
+            let target = this.contexttargets[context] || null;
+            var contextstate;
+            if (this.contextstates[context]) {
+              if (target && this.contextstates[context].has(target)) {
+                contextstate = this.contextstates[context].get(target);
+              } else {
+                contextstate = this.contextstates[context].get(target);
+              }
+            }
+            if (!contextstate) contextstate = {};
             if (this.bindings[context] && this.bindings[context][this.changes[i]]) {
               var action = this.bindings[context][this.changes[i]];
-              if (this.contexts[context][action]) {
+              let contextdef;
+              if (this.contexts[context]) {
+                if (this.contexts[context].has(target)) {
+                  contextdef = this.contexts[context].get(target);
+                } else {
+                  contextdef = this.contexts[context].get(null);
+                }
+              }
+              if (!contextdef) contextdef = {};
+              if (contextdef[action]) {
                 contextstate[action] = this.state[this.changes[i]];
                 //var ev = {timeStamp: now, type: this.changes[i], value: this.state[this.changes[i]], data: contextstate};
                 var ev = {timeStamp: now, type: action, value: this.state[this.changes[i]], data: contextstate};
                 //console.log('call it', this.changes[i], this.bindings[context][this.changes[i]], this.state[this.changes[i]]);
                 if (this.contexttargets[context]) {
                   ev.target = this.contexttargets[context];
-                  this.contexts[context][action].call(ev.data, ev);
+                  contextdef[action].call(ev.data, ev);
                 } else {
-                  this.contexts[context][action](ev);
+                  contextdef[action](ev);
                 }
                 break; // Event was handled, no need to check other active contexts
               } else {

package/scripts/systems/world.js

@@ -406,7 +406,7 @@ elation.require([
           //console.log(logprefix + "\t- added new " + type + ": " + name, currentobj);
         }
       } catch (e) {
-        console.error(e.stack);
+        console.error(e);
       }
       return currentobj;
     }

package/scripts/things/generic.js

@@ -54,14 +54,16 @@ elation.component.add("engine.things.generic", function() {
       'acceleration':   { type: 'vector3', default: [0, 0, 0], comment: 'Object acceleration (m/s^2)' },
       'angular':        { type: 'vector3', default: [0, 0, 0], comment: 'Object angular velocity (radians/sec)' },
       'angularacceleration': { type: 'vector3', default: [0, 0, 0], comment: 'Object angular acceleration (radians/sec^2)' },
-      'mass':           { type: 'float', default: 0.0, comment: 'Object mass (kg)' },
+      'mass':           { type: 'float', default: 0.0, comment: 'Object mass (kg)', set: this.updatePhysics },
       'exists':         { type: 'bool', default: true, comment: 'Exists' },
       'visible':        { type: 'bool', default: true, comment: 'Is visible' },
       'physical':       { type: 'bool', default: true, comment: 'Simulate physically' },
       'collidable':     { type: 'bool', default: true, comment: 'Can crash into other things' },
-      'restitution':    { type: 'float', default: 0.5, comment: 'Amount of energy preserved after each bounce', set: this.updatePhysics },
-      'dynamicfriction':{ type: 'float', default: 0.0, comment: 'Dynamic friction inherent to this object', set: this.updatePhysics },
-      'staticfriction': { type: 'float', default: 0.0, comment: 'Static friction inherent to this object', set: this.updatePhysics },
+      'restitution':    { type: 'float', default: 0.8, comment: 'Amount of energy preserved after each bounce', set: this.updatePhysics },
+      'dynamicfriction':{ type: 'float', default: 0.2, comment: 'Dynamic friction inherent to this object', set: this.updatePhysics },
+      'staticfriction': { type: 'float', default: 0.2, comment: 'Static friction inherent to this object', set: this.updatePhysics },
+      'rollingfriction': { type: 'float', default: 0.5, comment: 'Rolling friction inherent to this object', set: this.updatePhysics },
+
       //'fog':            { type: 'bool', default: true, comment: 'Affected by fog' },
       'shadow':         { type: 'bool', default: true, refreshMaterial: true, comment: 'Casts and receives shadows' },
       'wireframe':      { type: 'bool', default: false, refreshMaterial: true, comment: 'Render this object as a wireframe' },
@@ -754,6 +756,7 @@ elation.component.add("engine.things.generic", function() {
         material: {
           dynamicfriction: this.properties.dynamicfriction,
           staticfriction: this.properties.staticfriction,
+          rollingfriction: this.properties.rollingfriction,
         },
         object: this
       });
@@ -1919,9 +1922,11 @@ elation.component.add("engine.things.generic", function() {
   }
   this.updatePhysics = function() {
     if (this.objects.dynamics) {
+      this.objects.dynamics.mass = this.properties.mass;
       this.objects.dynamics.restitution = this.restitution;
       this.objects.dynamics.material.dynamicfriction = this.dynamicfriction;
       this.objects.dynamics.material.staticfriction = this.staticfriction;
+      this.objects.dynamics.material.rollingfriction = this.rollingfriction;
     }
   }
 });

package/scripts/things/player.js

@@ -15,6 +15,7 @@ elation.require(['engine.things.generic', 'engine.things.camera', 'engine.things
         jumpstrength: { type: 'float', default: 300.0 },
         jumptime: { type: 'float', default: 150 },
         movefriction: { type: 'float', default: 4.0 },
+        drag: { type: 'float', default: 0 },
         defaultplayer: { type: 'boolean', default: true },
         startposition: { type: 'vector3', default: new THREE.Vector3() },
         startorientation: { type: 'quaternion', default: new THREE.Quaternion() },
@@ -22,7 +23,7 @@ elation.require(['engine.things.generic', 'engine.things.camera', 'engine.things
         walking: { type: 'boolean', default: true },
         running: { type: 'boolean', default: false },
         flying: { type: 'boolean', default: false, set: function(key, value) { this.properties.flying = value; this.toggle_flying(value); }},
-        dynamicfriction:{ type: 'float', default: 2.0, comment: 'Dynamic friction inherent to this object' },
+        dynamicfriction:{ type: 'float', default: 4.0, comment: 'Dynamic friction inherent to this object' },
         staticfriction: { type: 'float', default: 1.9, comment: 'Static friction inherent to this object' },
         fov: { type: 'float', default: 75, set: this.updateCamera },
         turnhead: { type: 'boolean', default: false, set: this.updateHeadLock },
@@ -189,6 +190,7 @@ elation.require(['engine.things.generic', 'engine.things.camera', 'engine.things
     }
     this.createForces = function() {
       this.frictionForce = this.objects.dynamics.addForce("friction", this.properties.movefriction);
+      this.dragForce = this.objects.dynamics.addForce("drag", this.properties.drag);
       this.gravityForce = this.objects.dynamics.addForce("gravity", this.gravityVector);
       this.moveForce = this.objects.dynamics.addForce("static", {});
       this.jumpForce = this.objects.dynamics.addForce("static", {});
@@ -333,7 +335,6 @@ elation.require(['engine.things.generic', 'engine.things.camera', 'engine.things
               this.frictionForce.update(this.properties.movefriction);
               if (this.controlstate['jump']) {
                 this.jumpForce.update(new THREE.Vector3(0, this.jumpstrength, 0));
-                //console.log('jump up!', this.jumpForce.force.toArray());
                 setTimeout(elation.bind(this, function() {
                   this.jumpForce.update(new THREE.Vector3(0, 0, 0));
                 }), this.jumptime);
@@ -686,7 +687,8 @@ elation.require(['engine.things.generic', 'engine.things.camera', 'engine.things
           var intersects = _caster.intersectObjects(objects, true);
           if (intersects.length > 0) {
             for (var i = 0; i < intersects.length; i++) {
-              if (intersects[i].distance <= 1 + this.fatness/* && (intersects[i].object.userData.thing && intersects[i].object.userData.thing !== this) */) {
+              let thing = intersects[i].object.userData.thing;
+              if (thing && thing !== this && intersects[i].distance <= 1 + this.fatness) {
                 return intersects[i];
               }
             }