Add gamepad.js

examples/gamepad.js

@@ -0,0 +1,266 @@
+//
+//  controller.js
+//  examples
+//
+//  Created by Ryan Huffman on 10/9/14.
+//  Copyright 2014 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
+//
+
+gamepad = Joysticks.joystickWithName("Wireless 360 Controller");
+
+if (!gamepad) {
+    print("No gamepad found.");
+}
+
+// Controller axis/button mappings
+var GAMEPAD = {
+    AXES: {
+        LEFT_JOYSTICK_X: 0,
+        LEFT_JOYSTICK_Y: 1,
+
+        RIGHT_JOYSTICK_X: 2,
+        RIGHT_JOYSTICK_Y: 3,
+
+        LEFT_TRIGGER: 4,
+        RIGHT_TRIGGER: 5,
+    },
+    BUTTONS: {
+        DPAD_UP: 0,
+        DPAD_DOWN: 1,
+        DPAD_LEFT: 2,
+        DPAD_RIGHT: 3,
+
+        LEFT_JOYSTICK: 6,
+        RIGHT_JOYSTICK: 7,
+
+        LEFT_BUMPER: 8,
+        RIGHT_BUMPER: 9,
+
+        // Face buttons, ABXY on an XBOX controller
+        FACE_BOTTOM: 11,
+        FACE_RIGHT: 12,
+        FACE_LEFT: 13,
+        FACE_TOP: 14,
+    }
+}
+
+// Button/axis mappings
+var AXIS_STRAFE = GAMEPAD.AXES.LEFT_JOYSTICK_X;
+var AXIS_FORWARD = GAMEPAD.AXES.LEFT_JOYSTICK_Y;
+var AXIS_ROTATE = GAMEPAD.AXES.RIGHT_JOYSTICK_X;
+
+var BUTTON_TURN_AROUND = GAMEPAD.BUTTONS.RIGHT_JOYSTICK;
+
+var BUTTON_FLY_UP = GAMEPAD.BUTTONS.RIGHT_BUMPER;
+var BUTTON_FLY_DOWN = GAMEPAD.BUTTONS.LEFT_BUMPER
+var BUTTON_WARP = GAMEPAD.BUTTONS.FACE_BOTTOM;
+
+var BUTTON_WARP_FORWARD = GAMEPAD.BUTTONS.DPAD_UP;
+var BUTTON_WARP_BACKWARD = GAMEPAD.BUTTONS.DPAD_DOWN;
+var BUTTON_WARP_LEFT = GAMEPAD.BUTTONS.DPAD_LEFT;
+var BUTTON_WARP_RIGHT = GAMEPAD.BUTTONS.DPAD_RIGHT;
+
+// Distance in meters to warp via BUTTON_WARP_*
+var WARP_DISTANCE = 1;
+
+// Walk speed in m/s
+var MOVE_SPEED = 2;
+
+// Amount to rotate in radians
+var ROTATE_INCREMENT = Math.PI / 8;
+
+// Pick from above where we want to warp
+var WARP_PICK_OFFSET = { x: 0, y: 10, z: 0 };
+
+// When warping, the warp position will snap to a target below the current warp position.
+// This is the max distance it will snap to.
+var WARP_PICK_MAX_DISTANCE = 100;
+
+var flyDownButtonState = false;
+var flyUpButtonState = false;
+
+// Current move direction, axis aligned - that is, looking down and moving forward
+// will not move you into the ground, but instead will keep you on the horizontal plane.
+var moveDirection = { x: 0, y: 0, z: 0 };
+
+var warpActive = false;
+var warpPosition = { x: 0, y: 0, z: 0 };
+
+var WARP_SPHERE_SIZE = 1;
+var warpSphere = Overlays.addOverlay("sphere", {
+    position: { x: 0, y: 0, z: 0 },
+    size: WARP_SPHERE_SIZE,
+    color: { red: 0, green: 255, blue: 0 },
+    alpha: 1.0,
+    solid: true,
+    visible: false,
+});
+
+var WARP_LINE_HEIGHT = 10;
+var warpLine = Overlays.addOverlay("line3d", {
+    position: { x: 0, y: 0, z:0 },
+    end: { x: 0, y: 0, z: 0 },
+    color: { red: 0, green: 255, blue: 255},
+    alpha: 1,
+    lineWidth: 5,
+    visible: false,
+});
+
+function copyVec3(vec) {
+    return { x: vec.x, y: vec.y, z: vec.z };
+}
+
+function activateWarp() {
+    if (warpActive) return;
+    warpActive = true;
+
+    updateWarp();
+}
+
+function updateWarp() {
+    if (!warpActive) return;
+
+    var look = Quat.getFront(Camera.getOrientation());
+    var pitch = Math.asin(look.y);
+
+    // Get relative to looking straight down
+    pitch += Math.PI / 2;
+
+    // Scale up
+    pitch *= 2;
+    var distance = pitch * pitch * pitch;
+
+    var warpDirection = Vec3.normalize({ x: look.x, y: 0, z: look.z });
+    warpPosition = Vec3.multiply(warpDirection, distance);
+    warpPosition = Vec3.sum(MyAvatar.position, warpPosition);
+
+    var pickRay = {
+        origin: Vec3.sum(warpPosition, WARP_PICK_OFFSET),
+        direction: { x: 0, y: -1, z: 0 }
+    };
+
+    var intersection = Voxels.findRayIntersection(pickRay);
+
+    if (intersection.intersects && intersection.distance < WARP_PICK_MAX_DISTANCE) {
+        // Warp 1 meter above the object - this is an approximation
+        // TODO Get the actual offset to the Avatar's feet and plant them to
+        // the object.
+        warpPosition = Vec3.sum(intersection.intersection, { x: 0, y: 1, z:0 });
+    }
+
+    // Adjust overlays to match warp position
+    Overlays.editOverlay(warpSphere, {
+        position: warpPosition,
+        visible: true,
+    });
+    Overlays.editOverlay(warpLine, {
+        position: warpPosition,
+        end: Vec3.sum(warpPosition, { x: 0, y: WARP_LINE_HEIGHT, z: 0 }),
+        visible: true,
+    });
+}
+
+function finishWarp() {
+    if (!warpActive) return;
+    warpActive = false;
+    Overlays.editOverlay(warpSphere, {
+        visible: false,
+    });
+    Overlays.editOverlay(warpLine, {
+        visible: false,
+    });
+    MyAvatar.position = warpPosition;
+}
+
+function reportAxisValue(axis, newValue, oldValue) {
+    if (Math.abs(oldValue) < 0.2) oldValue = 0;
+    if (Math.abs(newValue) < 0.2) newValue = 0;
+
+    if (axis == AXIS_FORWARD) {
+        moveDirection.z = newValue;
+    } else if (axis == AXIS_STRAFE) {
+        moveDirection.x = newValue;
+    } else if (axis == AXIS_ROTATE) {
+        if (oldValue == 0 && newValue != 0) {
+            var rotateRadians = newValue > 0 ? -ROTATE_INCREMENT : ROTATE_INCREMENT;
+            var orientation = MyAvatar.orientation;
+            orientation = Quat.multiply(Quat.fromPitchYawRollRadians(0, rotateRadians, 0), orientation) ;
+            MyAvatar.orientation = orientation;
+        }
+    }
+}
+
+function reportButtonValue(button, newValue, oldValue) {
+    print("The value for button " + button + " has changed from " + oldValue + " to " + newValue);
+    if (button == BUTTON_FLY_DOWN) {
+        flyDownButtonState = newValue;
+    } else if (button == BUTTON_FLY_UP) {
+        flyUpButtonState = newValue;
+    } else if (button == BUTTON_WARP) {
+        if (newValue) {
+            activateWarp();
+        } else {
+            finishWarp();
+        }
+    } else if (button == BUTTON_TURN_AROUND) {
+        if (newValue) {
+            MyAvatar.orientation = Quat.multiply(
+                Quat.fromPitchYawRollRadians(0, Math.PI, 0), MyAvatar.orientation);
+        }
+    } else if (newValue) {
+        var direction = null;
+
+        if (button == BUTTON_WARP_FORWARD) {
+            direction = Quat.getFront(Camera.getOrientation());
+        } else if (button == BUTTON_WARP_BACKWARD) {
+            direction = Quat.getFront(Camera.getOrientation());
+            direction = Vec3.multiply(-1, direction);
+        } else if (button == BUTTON_WARP_LEFT) {
+            direction = Quat.getRight(Camera.getOrientation());
+            direction = Vec3.multiply(-1, direction);
+        } else if (button == BUTTON_WARP_RIGHT) {
+            direction = Quat.getRight(Camera.getOrientation());
+        }
+
+        if (direction) {
+            direction.y = 0;
+            direction = Vec3.multiply(Vec3.normalize(direction), WARP_DISTANCE);
+            MyAvatar.position = Vec3.sum(MyAvatar.position, direction);
+        }
+    }
+
+    if (flyUpButtonState && !flyDownButtonState) {
+        moveDirection.y = 1;
+    } else if (!flyUpButtonState && flyDownButtonState) {
+        moveDirection.y = -1;
+    } else {
+        moveDirection.y = 0;
+    }
+}
+
+function update(dt) {
+    var velocity = { x: 0, y: 0, z: 0 };
+    var move = copyVec3(moveDirection);
+    move.y = 0;
+    if (Vec3.length(move) > 0) {
+        velocity = Vec3.multiplyQbyV(Camera.getOrientation(), move);
+        velocity.y = 0;
+        velocity = Vec3.multiply(Vec3.normalize(velocity), MOVE_SPEED);
+    }
+
+    if (moveDirection.y != 0) {
+        velocity.y = moveDirection.y * MOVE_SPEED;
+    }
+
+    MyAvatar.setVelocity(velocity);
+
+    updateWarp();
+}
+
+gamepad.axisValueChanged.connect(reportAxisValue);
+gamepad.buttonStateChanged.connect(reportButtonValue);
+
+Script.update.connect(update);