Updating gun.js to new controller API

examples/controllers/hydra/gun.js

@@ -15,24 +15,61 @@
 //  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
 //
 
+Script.include([ "../../libraries/utils.js" ]);
+Script.include([ "../../libraries/constants.js" ]);
+Script.include([ "../../libraries/toolBars.js" ]);
+
 HIFI_PUBLIC_BUCKET = "http://s3.amazonaws.com/hifi-public/";
 
-var RED = { red: 255, green: 0, blue: 0 };
 var LASER_WIDTH = 2;
+var POSE_CONTROLS = [ Controller.Standard.LeftHand, Controller.Standard.RightHand ];
+var TRIGGER_CONTROLS = [ Controller.Standard.LT, Controller.Standard.RT ];
+var MIN_THROWER_DELAY = 1000;
+var MAX_THROWER_DELAY = 1000;
+var RELOAD_INTERVAL = 5;
+var GUN_MODEL = HIFI_PUBLIC_BUCKET + "cozza13/gun/m1911-handgun+1.fbx?v=4";
+var BULLET_VELOCITY = 10.0;
+var GUN_OFFSETS = [ {
+    x: -0.04,
+    y: 0.26,
+    z: 0.04
+}, {
+    x: 0.04,
+    y: 0.26,
+    z: 0.04
+} ];
 
+var GUN_ORIENTATIONS = [ Quat.fromPitchYawRollDegrees(0, 90, 90), Quat.fromPitchYawRollDegrees(0, -90, 270) ];
+
+var BARREL_OFFSETS = [ {
+    x: -0.12,
+    y: 0.12,
+    z: 0.04
+}, {
+    x: 0.12,
+    y: 0.12,
+    z: 0.04
+} ];
+
+var mapping = Controller.newMapping();
+var validPoses = [ false, false ];
+var barrelVectors = [ 0, 0 ];
+var barrelTips = [ 0, 0 ];
 var pointer = [];
+
 pointer.push(Overlays.addOverlay("line3d", {
-    start: { x: 0, y: 0, z: 0 },
+    start: ZERO_VECTOR,
-    end: { x: 0, y: 0, z: 0 },
+    end: ZERO_VECTOR,
-    color: RED,
+    color: COLORS.RED,
     alpha: 1,
     visible: true,
     lineWidth: LASER_WIDTH
 }));
+
 pointer.push(Overlays.addOverlay("line3d", {
-    start: { x: 0, y: 0, z: 0 },
+    start: ZERO_VECTOR,
-    end: { x: 0, y: 0, z: 0 },
+    end: ZERO_VECTOR,
-    color: RED,
+    color: COLORS.RED,
     alpha: 1,
     visible: true,
     lineWidth: LASER_WIDTH
@@ -42,56 +79,27 @@ function getRandomFloat(min, max) {
     return Math.random() * (max - min) + min;
 }
 
-var lastX = 0;
-var lastY = 0;
-var yawFromMouse = 0;
-var pitchFromMouse = 0;
-var isMouseDown = false; 
-
-var MIN_THROWER_DELAY = 1000;
-var MAX_THROWER_DELAY = 1000;
-var LEFT_BUTTON_3 = 3;
-var RELOAD_INTERVAL = 5;
-
-var KICKBACK_ANGLE = 15;
-var elbowKickAngle = 0.0;
-var rotationBeforeKickback; 
-
 var showScore = false;
-
+// Load some sound to use for loading and firing
-
-// Load some sound to use for loading and firing 
 var fireSound = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Guns/GUN-SHOT2.raw");
 var loadSound = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Guns/Gun_Reload_Weapon22.raw");
 var impactSound = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Guns/BulletImpact2.raw");
 var targetHitSound = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Space%20Invaders/hit.raw");
 var targetLaunchSound = SoundCache.getSound(HIFI_PUBLIC_BUCKET + "sounds/Space%20Invaders/shoot.raw");
 
-var gunModel = "https://s3.amazonaws.com/hifi-public/cozza13/gun/m1911-handgun+1.fbx?v=4";
-
 var audioOptions = {
-  volume: 0.9
+    volume: 0.9
 }
 
 var shotsFired = 0;
-var shotTime = new Date(); 
+var shotTime = new Date();
-
+var isLaunchButtonPressed = false;
-var activeControllers = 0; 
+var score = 0;
-
-// initialize our controller triggers
-var triggerPulled = new Array();
-var numberOfTriggers = Controller.getNumberOfTriggers();
-for (t = 0; t < numberOfTriggers; t++) {
-    triggerPulled[t] = false;
-}
-
-var isLaunchButtonPressed = false; 
-var score = 0; 
 
 var bulletID = false;
 var targetID = false;
 
-//  Create overlay buttons and reticle 
+// Create overlay buttons and reticle
 
 var BUTTON_SIZE = 32;
 var PADDING = 3;
@@ -99,78 +107,91 @@ var NUM_BUTTONS = 3;
 
 var screenSize = Controller.getViewportDimensions();
 var startX = screenSize.x / 2 - (NUM_BUTTONS * (BUTTON_SIZE + PADDING)) / 2;
-Script.include(["../../libraries/toolBars.js"]);
+
-var toolBar = new ToolBar(0, 0, ToolBar.HORIZONTAL, "highfidelity.gun.toolbar", function (screenSize) {
+var toolBar = new ToolBar(0, 0, ToolBar.HORIZONTAL, "highfidelity.gun.toolbar", function(screenSize) {
     return {
         x: startX,
         y: (screenSize.y - (BUTTON_SIZE + PADDING)),
     };
 });
-var reticle = Overlays.addOverlay("image", {
-                    x: screenSize.x / 2 - (BUTTON_SIZE / 2),
-                    y: screenSize.y / 2 - (BUTTON_SIZE / 2),
-                    width: BUTTON_SIZE,
-                    height: BUTTON_SIZE,
-                    imageURL: HIFI_PUBLIC_BUCKET + "images/gun/crosshairs.svg",
-                    alpha: 1
-                });
 
 var offButton = toolBar.addOverlay("image", {
-                    width: BUTTON_SIZE,
+    width: BUTTON_SIZE,
-                    height: BUTTON_SIZE,
+    height: BUTTON_SIZE,
-                    imageURL: HIFI_PUBLIC_BUCKET + "images/gun/close.svg",
+    imageURL: HIFI_PUBLIC_BUCKET + "images/gun/close.svg",
-                    alpha: 1
+    alpha: 1
-                });
+});
 
 startX += BUTTON_SIZE + PADDING;
 var platformButton = toolBar.addOverlay("image", {
-                    x: startX,
+    x: startX,
-                    y: screenSize.y - (BUTTON_SIZE + PADDING),
+    y: screenSize.y - (BUTTON_SIZE + PADDING),
-                    width: BUTTON_SIZE,
+    width: BUTTON_SIZE,
-                    height: BUTTON_SIZE,
+    height: BUTTON_SIZE,
-                    imageURL: HIFI_PUBLIC_BUCKET + "images/gun/platform-targets.svg",
+    imageURL: HIFI_PUBLIC_BUCKET + "images/gun/platform-targets.svg",
-                    alpha: 1
+    alpha: 1
-                });
+});
 
 startX += BUTTON_SIZE + PADDING;
 var gridButton = toolBar.addOverlay("image", {
-                    x: startX,
+    x: startX,
-                    y: screenSize.y - (BUTTON_SIZE + PADDING),
+    y: screenSize.y - (BUTTON_SIZE + PADDING),
-                    width: BUTTON_SIZE,
+    width: BUTTON_SIZE,
-                    height: BUTTON_SIZE,
+    height: BUTTON_SIZE,
-                    imageURL: HIFI_PUBLIC_BUCKET + "images/gun/floating-targets.svg",
+    imageURL: HIFI_PUBLIC_BUCKET + "images/gun/floating-targets.svg",
-                    alpha: 1
+    alpha: 1
-                });
+});
 
 if (showScore) {
     var text = Overlays.addOverlay("text", {
-                    x: screenSize.x / 2 - 100,
+        x: screenSize.x / 2 - 100,
-                    y: screenSize.y / 2 - 50,
+        y: screenSize.y / 2 - 50,
-                    width: 150,
+        width: 150,
-                    height: 50,
+        height: 50,
-                    color: { red: 0, green: 0, blue: 0},
+        color: {
-                    textColor: { red: 255, green: 0, blue: 0},
+            red: 0,
-                    topMargin: 4,
+            green: 0,
-                    leftMargin: 4,
+            blue: 0
-                    text: "Score: " + score
+        },
-                });
+        textColor: {
+            red: 255,
+            green: 0,
+            blue: 0
+        },
+        topMargin: 4,
+        leftMargin: 4,
+        text: "Score: " + score
+    });
 }
 
-var BULLET_VELOCITY = 10.0;
-
 function entityCollisionWithEntity(entity1, entity2, collision) {
     if (entity2 === targetID) {
         score++;
         if (showScore) {
-            Overlays.editOverlay(text, { text: "Score: " + score } );
+            Overlays.editOverlay(text, {
+                text: "Score: " + score
+            });
         }
 
-        //  We will delete the bullet and target in 1/2 sec, but for now we can see them bounce!
+        // We will delete the bullet and target in 1/2 sec, but for now we can
+        // see them bounce!
         Script.setTimeout(deleteBulletAndTarget, 500);
 
         // Turn the target and the bullet white
-        Entities.editEntity(entity1, { color: { red: 255, green: 255, blue: 255 }});
+        Entities.editEntity(entity1, {
-        Entities.editEntity(entity2, { color: { red: 255, green: 255, blue: 255 }});
+            color: {
+                red: 255,
+                green: 255,
+                blue: 255
+            }
+        });
+        Entities.editEntity(entity2, {
+            color: {
+                red: 255,
+                green: 255,
+                blue: 255
+            }
+        });
 
         // play the sound near the camera so the shooter can hear it
         audioOptions.position = Vec3.sum(Camera.getPosition(), Quat.getFront(Camera.getOrientation()));
@@ -188,41 +209,45 @@ function shootBullet(position, velocity, grenade) {
 
     var bVelocity = grenade ? Vec3.multiply(GRENADE_VELOCITY, Vec3.normalize(velocity)) : velocity;
     var bSize = grenade ? GRENADE_SIZE : BULLET_SIZE;
-    var bGravity = grenade ? GRENADE_GRAVITY : BULLET_GRAVITY; 
+    var bGravity = grenade ? GRENADE_GRAVITY : BULLET_GRAVITY;
+
+    bulletID = Entities.addEntity({
+        type: "Sphere",
+        position: position,
+        dimensions: {
+            x: bSize,
+            y: bSize,
+            z: bSize
+        },
+        color: {
+            red: 0,
+            green: 0,
+            blue: 0
+        },
+        velocity: bVelocity,
+        lifetime: BULLET_LIFETIME,
+        gravity: {
+            x: 0,
+            y: bGravity,
+            z: 0
+        },
+        damping: 0.01,
+        density: 8000,
+        ignoreCollisions: false,
+        collisionsWillMove: true
+    });
 
-    bulletID = Entities.addEntity(
-        { type: "Sphere",
-          position: position, 
-          dimensions: { x: bSize, y: bSize, z: bSize }, 
-          color: {  red: 0, green: 0, blue: 0 },  
-          velocity: bVelocity, 
-          lifetime: BULLET_LIFETIME,
-          gravity: {  x: 0, y: bGravity, z: 0 },
-          damping: 0.01,
-          density: 8000,
-          ignoreCollisions: false,
-          collisionsWillMove: true
-      });
     Script.addEventHandler(bulletID, "collisionWithEntity", entityCollisionWithEntity);
 
-    // Play firing sounds 
+    // Play firing sounds
-    audioOptions.position = position;   
+    audioOptions.position = position;
     Audio.playSound(fireSound, audioOptions);
     shotsFired++;
     if ((shotsFired % RELOAD_INTERVAL) == 0) {
         Audio.playSound(loadSound, audioOptions);
     }
-
-    // Kickback the arm 
-    if (elbowKickAngle > 0.0) {
-        MyAvatar.setJointData("LeftForeArm", rotationBeforeKickback);
-    }
-    rotationBeforeKickback = MyAvatar.getJointRotation("LeftForeArm"); 
-    var armRotation = MyAvatar.getJointRotation("LeftForeArm"); 
-    armRotation = Quat.multiply(armRotation, Quat.fromPitchYawRollDegrees(0.0, 0.0, KICKBACK_ANGLE));
-    MyAvatar.setJointData("LeftForeArm", armRotation);
-    elbowKickAngle = KICKBACK_ANGLE;
 }
+
 function shootTarget() {
     var TARGET_SIZE = 0.50;
     var TARGET_GRAVITY = 0.0;
@@ -232,95 +257,152 @@ function shootTarget() {
     var DISTANCE_TO_LAUNCH_FROM = 5.0;
     var ANGLE_RANGE_FOR_LAUNCH = 20.0;
     var camera = Camera.getPosition();
-    
+
-    var targetDirection = Quat.angleAxis(getRandomFloat(-ANGLE_RANGE_FOR_LAUNCH, ANGLE_RANGE_FOR_LAUNCH), { x:0, y:1, z:0 });
+    var targetDirection = Quat.angleAxis(getRandomFloat(-ANGLE_RANGE_FOR_LAUNCH, ANGLE_RANGE_FOR_LAUNCH), {
+        x: 0,
+        y: 1,
+        z: 0
+    });
     targetDirection = Quat.multiply(Camera.getOrientation(), targetDirection);
     var forwardVector = Quat.getFront(targetDirection);
- 
+
     var newPosition = Vec3.sum(camera, Vec3.multiply(forwardVector, DISTANCE_TO_LAUNCH_FROM));
 
     var velocity = Vec3.multiply(forwardVector, TARGET_FWD_VELOCITY);
     velocity.y += TARGET_UP_VELOCITY;
 
-    targetID = Entities.addEntity(
+    targetID = Entities.addEntity({
-        { type: "Box",
+        type: "Box",
-          position: newPosition, 
+        position: newPosition,
-          dimensions: { x: TARGET_SIZE * (0.5 + Math.random()), y: TARGET_SIZE * (0.5 + Math.random()), z: TARGET_SIZE * (0.5 + Math.random()) / 4.0 }, 
+        dimensions: {
-          color: {  red: Math.random() * 255, green: Math.random() * 255, blue: Math.random() * 255 },  
+            x: TARGET_SIZE * (0.5 + Math.random()),
-          velocity: velocity, 
+            y: TARGET_SIZE * (0.5 + Math.random()),
-          gravity: {  x: 0, y: TARGET_GRAVITY, z: 0 }, 
+            z: TARGET_SIZE * (0.5 + Math.random()) / 4.0
-          lifetime: TARGET_LIFETIME,
+        },
-          rotation:  Camera.getOrientation(),
+        color: {
-          damping: 0.1,
+            red: Math.random() * 255,
-          density: 100.0, 
+            green: Math.random() * 255,
-          collisionsWillMove: true });
+            blue: Math.random() * 255
+        },
+        velocity: velocity,
+        gravity: {
+            x: 0,
+            y: TARGET_GRAVITY,
+            z: 0
+        },
+        lifetime: TARGET_LIFETIME,
+        rotation: Camera.getOrientation(),
+        damping: 0.1,
+        density: 100.0,
+        collisionsWillMove: true
+    });
 
-    // Record start time 
+    // Record start time
     shotTime = new Date();
 
     // Play target shoot sound
-    audioOptions.position = newPosition;   
+    audioOptions.position = newPosition;
     Audio.playSound(targetLaunchSound, audioOptions);
 }
 
 function makeGrid(type, scale, size) {
-    var separation = scale * 2; 
+    var separation = scale * 2;
     var pos = Vec3.sum(Camera.getPosition(), Vec3.multiply(10.0 * scale * separation, Quat.getFront(Camera.getOrientation())));
     var x, y, z;
-    var GRID_LIFE = 60.0; 
+    var GRID_LIFE = 60.0;
-    var dimensions; 
+    var dimensions;
 
     for (x = 0; x < size; x++) {
         for (y = 0; y < size; y++) {
             for (z = 0; z < size; z++) {
-                
-                dimensions = { x: separation/2.0 * (0.5 + Math.random()), y: separation/2.0 * (0.5 + Math.random()), z: separation/2.0 * (0.5 + Math.random()) / 4.0 };
 
-                Entities.addEntity(
+                dimensions = {
-                    { type: type,
+                    x: separation / 2.0 * (0.5 + Math.random()),
-                      position: { x: pos.x + x * separation, y: pos.y + y * separation, z: pos.z + z * separation },
+                    y: separation / 2.0 * (0.5 + Math.random()),
-                      dimensions: dimensions, 
+                    z: separation / 2.0 * (0.5 + Math.random()) / 4.0
-                      color: {  red: Math.random() * 255, green: Math.random() * 255, blue: Math.random() * 255 },  
+                };
-                      velocity: {  x: 0, y: 0, z: 0 }, 
+
-                      gravity: {  x: 0, y: 0, z: 0 }, 
+                Entities.addEntity({
-                      lifetime: GRID_LIFE,
+                    type: type,
-                      rotation:  Camera.getOrientation(),
+                    position: {
-                      damping: 0.1,
+                        x: pos.x + x * separation,
-                      density: 100.0, 
+                        y: pos.y + y * separation,
-                      collisionsWillMove: true });
+                        z: pos.z + z * separation
+                    },
+                    dimensions: dimensions,
+                    color: {
+                        red: Math.random() * 255,
+                        green: Math.random() * 255,
+                        blue: Math.random() * 255
+                    },
+                    velocity: {
+                        x: 0,
+                        y: 0,
+                        z: 0
+                    },
+                    gravity: {
+                        x: 0,
+                        y: 0,
+                        z: 0
+                    },
+                    lifetime: GRID_LIFE,
+                    rotation: Camera.getOrientation(),
+                    damping: 0.1,
+                    density: 100.0,
+                    collisionsWillMove: true
+                });
             }
         }
     }
 }
 
 function makePlatform(gravity, scale, size) {
-    var separation = scale * 2; 
+    var separation = scale * 2;
     var pos = Vec3.sum(Camera.getPosition(), Vec3.multiply(10.0 * scale * separation, Quat.getFront(Camera.getOrientation())));
     pos.y -= separation * size;
     var x, y, z;
-    var TARGET_LIFE = 60.0; 
+    var TARGET_LIFE = 60.0;
     var INITIAL_GAP = 0.5;
-    var dimensions; 
+    var dimensions;
 
     for (x = 0; x < size; x++) {
         for (y = 0; y < size; y++) {
             for (z = 0; z < size; z++) {
 
-                dimensions = { x: separation/2.0, y: separation, z: separation/2.0 };
+                dimensions = {
+                    x: separation / 2.0,
+                    y: separation,
+                    z: separation / 2.0
+                };
 
-                Entities.addEntity(
+                Entities.addEntity({
-                    { type: "Box",
+                    type: "Box",
-                      position: { x: pos.x - (separation * size  / 2.0) + x * separation, 
+                    position: {
-                                  y: pos.y + y * (separation + INITIAL_GAP), 
+                        x: pos.x - (separation * size / 2.0) + x * separation,
-                                  z: pos.z - (separation * size / 2.0) + z * separation },
+                        y: pos.y + y * (separation + INITIAL_GAP),
-                      dimensions: dimensions, 
+                        z: pos.z - (separation * size / 2.0) + z * separation
-                      color: {  red: Math.random() * 255, green: Math.random() * 255, blue: Math.random() * 255 },  
+                    },
-                      velocity: {  x: 0, y: 0.05, z: 0 }, 
+                    dimensions: dimensions,
-                      gravity: {  x: 0, y: gravity, z: 0 }, 
+                    color: {
-                      lifetime: TARGET_LIFE,
+                        red: Math.random() * 255,
-                      damping: 0.1,
+                        green: Math.random() * 255,
-                      density: 100.0, 
+                        blue: Math.random() * 255
-                      collisionsWillMove: true });
+                    },
+                    velocity: {
+                        x: 0,
+                        y: 0.05,
+                        z: 0
+                    },
+                    gravity: {
+                        x: 0,
+                        y: gravity,
+                        z: 0
+                    },
+                    lifetime: TARGET_LIFE,
+                    damping: 0.1,
+                    density: 100.0,
+                    collisionsWillMove: true
+                });
             }
         }
     }
@@ -328,9 +410,21 @@ function makePlatform(gravity, scale, size) {
     // Make a floor for this stuff to fall onto
     Entities.addEntity({
         type: "Box",
-        position: { x: pos.x, y: pos.y - separation / 2.0, z: pos.z }, 
+        position: {
-        dimensions: { x: 2.0 * separation * size, y: separation / 2.0, z: 2.0 * separation * size },
+            x: pos.x,
-        color: { red: 100, green: 100, blue: 100 },
+            y: pos.y - separation / 2.0,
+            z: pos.z
+        },
+        dimensions: {
+            x: 2.0 * separation * size,
+            y: separation / 2.0,
+            z: 2.0 * separation * size
+        },
+        color: {
+            red: 100,
+            green: 100,
+            blue: 100
+        },
         lifetime: TARGET_LIFE
     });
 
@@ -340,7 +434,7 @@ function keyPressEvent(event) {
     // if our tools are off, then don't do anything
     if (event.text == "t") {
         var time = MIN_THROWER_DELAY + Math.random() * MAX_THROWER_DELAY;
-        Script.setTimeout(shootTarget, time); 
+        Script.setTimeout(shootTarget, time);
     } else if ((event.text == ".") || (event.text == "SPACE")) {
         shootFromMouse(false);
     } else if (event.text == ",") {
@@ -348,7 +442,7 @@ function keyPressEvent(event) {
     } else if (event.text == "r") {
         playLoadSound();
     } else if (event.text == "s") {
-        //  Hit this key to dump a posture from hydra to log
+        // Hit this key to dump a posture from hydra to log
         Quat.print("arm = ", MyAvatar.getJointRotation("LeftArm"));
         Quat.print("forearm = ", MyAvatar.getJointRotation("LeftForeArm"));
         Quat.print("hand = ", MyAvatar.getJointRotation("LeftHand"));
@@ -356,137 +450,70 @@ function keyPressEvent(event) {
 }
 
 function playLoadSound() {
-    audioOptions.position = Vec3.sum(Camera.getPosition(), Quat.getFront(Camera.getOrientation())); 
+    audioOptions.position = MyAvatar.leftHandPose.translation;
     Audio.playSound(loadSound, audioOptions);
-    // Raise arm to firing posture 
-    takeFiringPose();
-}
-
-function clearPose() {
-    MyAvatar.clearJointData("LeftForeArm");
-    MyAvatar.clearJointData("LeftArm");
-    MyAvatar.clearJointData("LeftHand");
 }
 
 function deleteBulletAndTarget() {
     Entities.deleteEntity(bulletID);
     Entities.deleteEntity(targetID);
-    bulletID = false; 
+    bulletID = false;
-    targetID = false; 
+    targetID = false;
 }
 
-function takeFiringPose() {
-    clearPose();
-    if (Controller.getNumberOfSpatialControls() == 0) {
-        MyAvatar.setJointData("LeftForeArm", {x: -0.251919, y: -0.0415449, z: 0.499487, w: 0.827843});
-        MyAvatar.setJointData("LeftArm", { x: 0.470196, y: -0.132559, z: 0.494033, w: 0.719219});
-        MyAvatar.setJointData("LeftHand", { x: -0.0104815, y: -0.110551, z: -0.352111, w: 0.929333});
-    }
-}
-
-MyAvatar.attach(gunModel, "RightHand", {x:0.04, y: 0.22, z: 0.02}, Quat.fromPitchYawRollDegrees(-172, -85, 79), 0.40);
-MyAvatar.attach(gunModel, "LeftHand", {x:-0.04, y: 0.22, z: 0.02}, Quat.fromPitchYawRollDegrees(-172, 85, -79), 0.40);
-
-//  Give a bit of time to load before playing sound
-Script.setTimeout(playLoadSound, 2000); 
-
 function update(deltaTime) {
-    if (activeControllers == 0) {
+    // FIXME we should also expose MyAvatar.handPoses[2], MyAvatar.tipPoses[2]
-        if (Controller.getNumberOfSpatialControls() > 0) { 
+    var tipPoses = [ MyAvatar.leftHandTipPose, MyAvatar.rightHandTipPose ];
-            activeControllers = Controller.getNumberOfSpatialControls();
-            clearPose();
-        }
-    }
 
-    var KICKBACK_DECAY_RATE = 0.125;
+    for (var side = 0; side < 2; side++) {
-    if (elbowKickAngle > 0.0)  {       
+        // First check if the controller is valid
-        if (elbowKickAngle > 0.5) {
+        var controllerPose = Controller.getPoseValue(POSE_CONTROLS[side]);
-            var newAngle = elbowKickAngle * KICKBACK_DECAY_RATE;
+        validPoses[side] = controllerPose.valid;
-            elbowKickAngle -= newAngle; 
+        if (!controllerPose.valid) {
-            var armRotation = MyAvatar.getJointRotation("LeftForeArm");
+            Overlays.editOverlay(pointer[side], {
-            armRotation = Quat.multiply(armRotation, Quat.fromPitchYawRollDegrees(0.0, 0.0, -newAngle));
+                visible: false
-            MyAvatar.setJointData("LeftForeArm", armRotation);
-        } else {
-            MyAvatar.setJointData("LeftForeArm", rotationBeforeKickback);
-            if (Controller.getNumberOfSpatialControls() > 0) {
-                clearPose();
-            }
-            elbowKickAngle = 0.0;
-        }
-    }
-
-
-    // check for trigger press
-
-    var numberOfTriggers = 2; 
-    var controllersPerTrigger = 2;
-
-    if (numberOfTriggers == 2 && controllersPerTrigger == 2) {
-        for (var t = 0; t < 2; t++) {
-            var shootABullet = false;
-            var triggerValue = Controller.getTriggerValue(t);
-            if (triggerPulled[t]) {
-                // must release to at least 0.1
-                if (triggerValue < 0.1) {
-                    triggerPulled[t] = false; // unpulled
-                }
-            } else {
-                // must pull to at least 
-                if (triggerValue > 0.5) {
-                    triggerPulled[t] = true; // pulled
-                    shootABullet = true;
-                }
-            }
-            var palmController = t * controllersPerTrigger; 
-            var palmPosition = Controller.getSpatialControlPosition(palmController);
-            var fingerTipController = palmController + 1; 
-            var fingerTipPosition = Controller.getSpatialControlPosition(fingerTipController);
-            var laserTip = Vec3.sum(Vec3.multiply(100.0, Vec3.subtract(fingerTipPosition, palmPosition)), palmPosition);
-
-            //  Update Lasers 
-            Overlays.editOverlay(pointer[t], {
-                start: palmPosition,
-                end: laserTip,
-                alpha: 1
             });
-
+            continue;
-            if (shootABullet) {
-                 
-                var palmToFingerTipVector = 
-                        {   x: (fingerTipPosition.x - palmPosition.x),
-                            y: (fingerTipPosition.y - palmPosition.y),
-                            z: (fingerTipPosition.z - palmPosition.z)  };
-                                    
-                // just off the front of the finger tip
-                var position = { x: fingerTipPosition.x + palmToFingerTipVector.x/2, 
-                                 y: fingerTipPosition.y + palmToFingerTipVector.y/2, 
-                                 z: fingerTipPosition.z  + palmToFingerTipVector.z/2};   
-                   
-                var velocity = Vec3.multiply(BULLET_VELOCITY, Vec3.normalize(palmToFingerTipVector)); 
-
-                shootBullet(position, velocity, false);
-            }
         }
+
+        // Need to adjust the laser
+        var tipPose = tipPoses[side];
+        var handRotation = MyAvatar.getJointCombinedRotation(side == 0 ? "LeftHand" : "RightHand");
+        // handRotation = Quat.multiply(Quat.inverse(MyAvatar.orientation),
+        // handRotation);
+        var barrelOffset = Vec3.multiplyQbyV(handRotation, BARREL_OFFSETS[side]);
+        barrelTips[side] = Vec3.sum(tipPose.translation, barrelOffset);
+        barrelVectors[side] = Vec3.multiplyQbyV(handRotation, {
+            x: 0,
+            y: 1,
+            z: 0
+        });
+
+        var laserTip = Vec3.sum(Vec3.multiply(100.0, barrelVectors[side]), barrelTips[side]);
+        // Update Lasers
+        Overlays.editOverlay(pointer[side], {
+            start: barrelTips[side],
+            end: laserTip,
+            alpha: 1,
+            visible: true
+        });
     }
 }
 
-function shootFromMouse(grenade) {
+function triggerChanged(side, value) {
-    var DISTANCE_FROM_CAMERA = 1.0;
+    var pressed = (value != 0);
-    var camera = Camera.getPosition();
+    if (pressed) {
-    var forwardVector = Quat.getFront(Camera.getOrientation());
+        var position = barrelTips[side];
-    var newPosition = Vec3.sum(camera, Vec3.multiply(forwardVector, DISTANCE_FROM_CAMERA));
+        var velocity = Vec3.multiply(BULLET_VELOCITY, Vec3.normalize(barrelVectors[side]));
-    var velocity = Vec3.multiply(forwardVector, BULLET_VELOCITY);
+        shootBullet(position, velocity, false);
-    shootBullet(newPosition, velocity, grenade);
+    }
-}
-
-function mouseReleaseEvent(event) { 
-    //  position 
-    isMouseDown = false;
 }
 
 function mousePressEvent(event) {
-    var clickedText = false;
+    var clickedOverlay = Overlays.getOverlayAtPoint({
-    var clickedOverlay = Overlays.getOverlayAtPoint({x: event.x, y: event.y});
+        x: event.x,
+        y: event.y
+    });
     if (clickedOverlay == offButton) {
         Script.stop();
     } else if (clickedOverlay == platformButton) {
@@ -494,25 +521,37 @@ function mousePressEvent(event) {
         makePlatform(-9.8, 1.0, platformSize);
     } else if (clickedOverlay == gridButton) {
         makeGrid("Box", 1.0, 3);
-    } 
+    }
 }
 
 function scriptEnding() {
-    Overlays.deleteOverlay(reticle);
+    mapping.disable();
     toolBar.cleanup();
-    Overlays.deleteOverlay(pointer[0]);
+    for (var i = 0; i < pointer.length; ++i) {
-    Overlays.deleteOverlay(pointer[1]);
+        Overlays.deleteOverlay(pointer[i]);
+    }
     Overlays.deleteOverlay(text);
-    MyAvatar.detachOne(gunModel);
+    MyAvatar.detachOne(GUN_MODEL);
-    MyAvatar.detachOne(gunModel);
+    MyAvatar.detachOne(GUN_MODEL);
     clearPose();
 }
 
+MyAvatar.attach(GUN_MODEL, "LeftHand", GUN_OFFSETS[0], GUN_ORIENTATIONS[1], 0.40);
+MyAvatar.attach(GUN_MODEL, "RightHand", GUN_OFFSETS[1], GUN_ORIENTATIONS[1], 0.40);
+
+// Give a bit of time to load before playing sound
+Script.setTimeout(playLoadSound, 2000);
+
+mapping.from(Controller.Standard.LT).constrainToPositiveInteger().to(function(value) {
+    triggerChanged(0, value);
+});
+
+mapping.from(Controller.Standard.RT).constrainToPositiveInteger().to(function(value) {
+    triggerChanged(1, value);
+});
+mapping.enable();
+
 Script.scriptEnding.connect(scriptEnding);
 Script.update.connect(update);
-Controller.mouseReleaseEvent.connect(mouseReleaseEvent);
 Controller.mousePressEvent.connect(mousePressEvent);
 Controller.keyPressEvent.connect(keyPressEvent);
-
-
-