overte-JulianGro/script-archive/entityScripts/movable.js
2016-05-25 11:11:06 -07:00

431 lines
17 KiB
JavaScript

//
// movable.js
// examples/entityScripts
//
// Created by Brad Hefta-Gaub on 11/17/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
//
(function(){
this.entityID = null;
this.properties = null;
this.graboffset = null;
this.clickedAt = null;
this.firstHolding = true;
this.clicked = { x: -1, y: -1};
this.lastMovedPosition = { x: -1, y: -1};
this.lastMovedTime = 0;
this.rotateOverlayTarget = null;
this.rotateOverlayInner = null;
this.rotateOverlayOuter = null;
this.rotateOverlayCurrent = null;
this.rotateMode = false;
this.originalRotation = null;
this.moveSoundURLS = [
"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove1.wav",
"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove2.wav",
"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove3.wav"
];
this.turnSoundURLS = [
"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove1.wav",
"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove2.wav",
"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureMove3.wav"
// TODO: determine if these or other turn sounds work better than move sounds.
//"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureTurn1.wav",
//"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureTurn2.wav",
//"http://public.highfidelity.io/sounds/MovingFurniture/FurnitureTurn3.wav"
];
this.moveSounds = new Array();
this.turnSounds = new Array();
this.moveSound = null;
this.turnSound = null;
this.moveInjector = null;
this.turnInjector = null;
var debug = false;
var displayRotateTargets = true; // change to false if you don't want the rotate targets
var rotateOverlayTargetSize = 10000; // really big target
var innerSnapAngle = 22.5; // the angle which we snap to on the inner rotation tool
var innerRadius;
var outerRadius;
var yawCenter;
var yawZero;
var rotationNormal;
var yawNormal;
var stopSoundDelay = 100; // number of msecs of not moving to have sound stop
this.getRandomInt = function(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
this.downloadSounds = function() {
for (var i = 0; i < this.moveSoundURLS.length; i++) {
this.moveSounds[i] = SoundCache.getSound(this.moveSoundURLS[i]);
}
for (var i = 0; i < this.turnSoundURLS.length; i++) {
this.turnSounds[i] = SoundCache.getSound(this.turnSoundURLS[i]);
}
}
this.pickRandomSounds = function() {
var moveIndex = this.getRandomInt(0, this.moveSounds.length - 1);
var turnIndex = this.getRandomInt(0, this.turnSounds.length - 1);
if (debug) {
print("Random sounds -- turn:" + turnIndex + " move:" + moveIndex);
}
this.moveSound = this.moveSounds[moveIndex];
this.turnSound = this.turnSounds[turnIndex];
}
// Play move sound
this.playMoveSound = function() {
if (debug) {
print("playMoveSound()");
}
if (this.moveSound && this.moveSound.downloaded) {
if (debug) {
print("playMoveSound() --- calling this.moveInjector = Audio.playSound(this.moveSound...)");
}
if (!this.moveInjector) {
this.moveInjector = Audio.playSound(this.moveSound, { position: this.properties.position, loop: true, volume: 0.1 });
} else {
this.moveInjector.restart();
}
}
}
// Play turn sound
this.playTurnSound = function() {
if (debug) {
print("playTurnSound()");
}
if (this.turnSound && this.turnSound.downloaded) {
if (debug) {
print("playTurnSound() --- calling this.turnInjector = Audio.playSound(this.turnSound...)");
}
if (!this.turnInjector) {
this.turnInjector = Audio.playSound(this.turnSound, { position: this.properties.position, loop: true, volume: 0.1 });
} else {
this.turnInjector.restart();
}
}
}
// stop sound
this.stopSound = function() {
if (debug) {
print("stopSound()");
}
if (this.turnInjector) {
this.turnInjector.stop();
}
if (this.moveInjector) {
this.moveInjector.stop();
}
}
// Pr, Vr are respectively the Ray's Point of origin and Vector director
// Pp, Np are respectively the Plane's Point of origin and Normal vector
this.rayPlaneIntersection = function(Pr, Vr, Pp, Np) {
var d = -Vec3.dot(Pp, Np);
var t = -(Vec3.dot(Pr, Np) + d) / Vec3.dot(Vr, Np);
return Vec3.sum(Pr, Vec3.multiply(t, Vr));
};
// updates the piece position based on mouse input
this.updatePosition = function(mouseEvent) {
var pickRay = Camera.computePickRay(mouseEvent.x, mouseEvent.y)
var upVector = { x: 0, y: 1, z: 0 };
var intersection = this.rayPlaneIntersection(pickRay.origin, pickRay.direction,
this.properties.position, upVector);
var newPosition = Vec3.sum(intersection, this.graboffset);
Entities.editEntity(this.entityID, { position: newPosition });
};
this.grab = function(mouseEvent) {
// first calculate the offset
var pickRay = Camera.computePickRay(mouseEvent.x, mouseEvent.y)
var upVector = { x: 0, y: 1, z: 0 };
var intersection = this.rayPlaneIntersection(pickRay.origin, pickRay.direction,
this.properties.position, upVector);
this.graboffset = Vec3.subtract(this.properties.position, intersection);
};
this.stopSoundIfNotMoving = function(mouseEvent) {
var nowDate = new Date();
var nowMSecs = nowDate.getTime();
if(mouseEvent.x == this.lastMovedPosition.x && mouseEvent.y == this.lastMovedPosition.y) {
var elapsedSinceLastMove = nowMSecs - this.lastMovedMSecs;
if (debug) {
print("elapsedSinceLastMove:" + elapsedSinceLastMove);
}
if (elapsedSinceLastMove > stopSoundDelay) {
if (debug) {
print("calling stopSound()...");
}
this.stopSound();
}
} else {
// if we've moved, then track our last move position and time...
this.lastMovedMSecs = nowMSecs;
this.lastMovedPosition.x = mouseEvent.x;
this.lastMovedPosition.y = mouseEvent.y;
}
}
this.move = function(mouseEvent) {
this.updatePosition(mouseEvent);
if (this.moveInjector === null || !this.moveInjector.playing) {
this.playMoveSound();
}
};
this.release = function(mouseEvent) {
this.updatePosition(mouseEvent);
};
this.rotate = function(mouseEvent) {
var pickRay = Camera.computePickRay(mouseEvent.x, mouseEvent.y)
var result = Overlays.findRayIntersection(pickRay);
if (result.intersects) {
var center = yawCenter;
var zero = yawZero;
var centerToZero = Vec3.subtract(center, zero);
var centerToIntersect = Vec3.subtract(center, result.intersection);
var angleFromZero = Vec3.orientedAngle(centerToZero, centerToIntersect, rotationNormal);
var distanceFromCenter = Vec3.distance(center, result.intersection);
var snapToInner = false;
// var innerRadius = (Vec3.length(selectionManager.worldDimensions) / 2) * 1.1;
if (distanceFromCenter < innerRadius) {
angleFromZero = Math.floor(angleFromZero/innerSnapAngle) * innerSnapAngle;
snapToInner = true;
}
var yawChange = Quat.fromVec3Degrees({ x: 0, y: angleFromZero, z: 0 });
Entities.editEntity(this.entityID, { rotation: Quat.multiply(yawChange, this.originalRotation) });
// update the rotation display accordingly...
var startAtCurrent = 360-angleFromZero;
var endAtCurrent = 360;
var startAtRemainder = 0;
var endAtRemainder = 360-angleFromZero;
if (angleFromZero < 0) {
startAtCurrent = 0;
endAtCurrent = -angleFromZero;
startAtRemainder = -angleFromZero;
endAtRemainder = 360;
}
if (snapToInner) {
Overlays.editOverlay(this.rotateOverlayOuter, { startAt: 0, endAt: 360 });
Overlays.editOverlay(this.rotateOverlayInner, { startAt: startAtRemainder, endAt: endAtRemainder });
Overlays.editOverlay(this.rotateOverlayCurrent, { startAt: startAtCurrent, endAt: endAtCurrent, size: innerRadius,
majorTickMarksAngle: innerSnapAngle, minorTickMarksAngle: 0,
majorTickMarksLength: -0.25, minorTickMarksLength: 0, });
} else {
Overlays.editOverlay(this.rotateOverlayInner, { startAt: 0, endAt: 360 });
Overlays.editOverlay(this.rotateOverlayOuter, { startAt: startAtRemainder, endAt: endAtRemainder });
Overlays.editOverlay(this.rotateOverlayCurrent, { startAt: startAtCurrent, endAt: endAtCurrent, size: outerRadius,
majorTickMarksAngle: 45.0, minorTickMarksAngle: 5,
majorTickMarksLength: 0.25, minorTickMarksLength: 0.1, });
}
}
if (this.turnInjector === null || !this.turnInjector.playing) {
this.playTurnSound();
}
};
// All callbacks start by updating the properties
this.updateProperties = function(entityID) {
if (this.entityID === null) {
this.entityID = entityID;
}
this.properties = Entities.getEntityProperties(this.entityID);
};
this.cleanupRotateOverlay = function() {
Overlays.deleteOverlay(this.rotateOverlayTarget);
Overlays.deleteOverlay(this.rotateOverlayInner);
Overlays.deleteOverlay(this.rotateOverlayOuter);
Overlays.deleteOverlay(this.rotateOverlayCurrent);
this.rotateOverlayTarget = null;
this.rotateOverlayInner = null;
this.rotateOverlayOuter = null;
this.rotateOverlayCurrent = null;
}
this.displayRotateOverlay = function(mouseEvent) {
var yawOverlayAngles = { x: 90, y: 0, z: 0 };
var yawOverlayRotation = Quat.fromVec3Degrees(yawOverlayAngles);
yawNormal = { x: 0, y: 1, z: 0 };
yawCenter = this.properties.position;
rotationNormal = yawNormal;
// Size the overlays to the current selection size
var diagonal = (Vec3.length(this.properties.dimensions) / 2) * 1.1;
var halfDimensions = Vec3.multiply(this.properties.dimensions, 0.5);
innerRadius = diagonal;
outerRadius = diagonal * 1.15;
var innerAlpha = 0.2;
var outerAlpha = 0.2;
this.rotateOverlayTarget = Overlays.addOverlay("circle3d", {
position: this.properties.position,
size: rotateOverlayTargetSize,
color: { red: 0, green: 0, blue: 0 },
alpha: 0.0,
solid: true,
visible: true,
rotation: yawOverlayRotation,
ignoreRayIntersection: false
});
this.rotateOverlayInner = Overlays.addOverlay("circle3d", {
position: this.properties.position,
size: innerRadius,
innerRadius: 0.9,
alpha: innerAlpha,
color: { red: 51, green: 152, blue: 203 },
solid: true,
visible: displayRotateTargets,
rotation: yawOverlayRotation,
hasTickMarks: true,
majorTickMarksAngle: innerSnapAngle,
minorTickMarksAngle: 0,
majorTickMarksLength: -0.25,
minorTickMarksLength: 0,
majorTickMarksColor: { red: 0, green: 0, blue: 0 },
minorTickMarksColor: { red: 0, green: 0, blue: 0 },
ignoreRayIntersection: true, // always ignore this
});
this.rotateOverlayOuter = Overlays.addOverlay("circle3d", {
position: this.properties.position,
size: outerRadius,
innerRadius: 0.9,
startAt: 0,
endAt: 360,
alpha: outerAlpha,
color: { red: 51, green: 152, blue: 203 },
solid: true,
visible: displayRotateTargets,
rotation: yawOverlayRotation,
hasTickMarks: true,
majorTickMarksAngle: 45.0,
minorTickMarksAngle: 5,
majorTickMarksLength: 0.25,
minorTickMarksLength: 0.1,
majorTickMarksColor: { red: 0, green: 0, blue: 0 },
minorTickMarksColor: { red: 0, green: 0, blue: 0 },
ignoreRayIntersection: true, // always ignore this
});
this.rotateOverlayCurrent = Overlays.addOverlay("circle3d", {
position: this.properties.position,
size: outerRadius,
startAt: 0,
endAt: 0,
innerRadius: 0.9,
color: { red: 224, green: 67, blue: 36},
alpha: 0.8,
solid: true,
visible: displayRotateTargets,
rotation: yawOverlayRotation,
ignoreRayIntersection: true, // always ignore this
hasTickMarks: true,
majorTickMarksColor: { red: 0, green: 0, blue: 0 },
minorTickMarksColor: { red: 0, green: 0, blue: 0 },
});
var pickRay = Camera.computePickRay(mouseEvent.x, mouseEvent.y)
var result = Overlays.findRayIntersection(pickRay);
yawZero = result.intersection;
};
this.preload = function(entityID) {
this.updateProperties(entityID); // All callbacks start by updating the properties
this.downloadSounds();
};
this.clickDownOnEntity = function(entityID, mouseEvent) {
this.updateProperties(entityID); // All callbacks start by updating the properties
this.grab(mouseEvent);
var nowDate = new Date();
var nowMSecs = nowDate.getTime();
this.clickedAt = nowMSecs;
this.firstHolding = true;
this.clicked.x = mouseEvent.x;
this.clicked.y = mouseEvent.y;
this.lastMovedPosition.x = mouseEvent.x;
this.lastMovedPosition.y = mouseEvent.y;
this.lastMovedMSecs = nowMSecs;
this.pickRandomSounds();
};
this.holdingClickOnEntity = function(entityID, mouseEvent) {
this.updateProperties(entityID); // All callbacks start by updating the properties
if (this.firstHolding) {
// if we haven't moved yet...
if (this.clicked.x == mouseEvent.x && this.clicked.y == mouseEvent.y) {
var d = new Date();
var now = d.getTime();
if (now - this.clickedAt > 500) {
this.displayRotateOverlay(mouseEvent);
this.firstHolding = false;
this.rotateMode = true;
this.originalRotation = this.properties.rotation;
}
} else {
this.firstHolding = false;
}
}
if (this.rotateMode) {
this.rotate(mouseEvent);
} else {
this.move(mouseEvent);
}
this.stopSoundIfNotMoving(mouseEvent);
};
this.clickReleaseOnEntity = function(entityID, mouseEvent) {
this.updateProperties(entityID); // All callbacks start by updating the properties
if (this.rotateMode) {
this.rotate(mouseEvent);
} else {
this.release(mouseEvent);
}
if (this.rotateOverlayTarget != null) {
this.cleanupRotateOverlay();
this.rotateMode = false;
}
this.firstHolding = false;
this.stopSound();
};
})