415 lines
No EOL
15 KiB
JavaScript
415 lines
No EOL
15 KiB
JavaScript
//
|
|
// sit.js
|
|
//
|
|
// Created by Clement Brisset on 3/3/17
|
|
// Copyright 2017 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() {
|
|
Script.include("/~/system/libraries/utils.js");
|
|
if (!String.prototype.startsWith) {
|
|
String.prototype.startsWith = function(searchString, position){
|
|
position = position || 0;
|
|
return this.substr(position, searchString.length) === searchString;
|
|
};
|
|
}
|
|
|
|
var SETTING_KEY = "com.highfidelity.avatar.isSitting";
|
|
var ANIMATION_URL = "http://hifi-content.s3.amazonaws.com/alexia/Sitting_Idle.fbx";
|
|
var ANIMATION_FPS = 30;
|
|
var ANIMATION_FIRST_FRAME = 1;
|
|
var ANIMATION_LAST_FRAME = 350;
|
|
var RELEASE_TIME = 500; // ms
|
|
var RELEASE_DISTANCE = 0.2; // meters
|
|
var MAX_IK_ERROR = 30;
|
|
var IK_SETTLE_TIME = 250; // ms
|
|
var DESKTOP_UI_CHECK_INTERVAL = 500;
|
|
var DESKTOP_MAX_DISTANCE = 2.8;
|
|
var SIT_DELAY = 25;
|
|
var ALPHA_START = 0.7; //for overlays
|
|
var MAX_RESET_DISTANCE = 0.5; // meters
|
|
var OVERRIDEN_DRIVE_KEYS = [
|
|
DriveKeys.TRANSLATE_X,
|
|
DriveKeys.TRANSLATE_Y,
|
|
DriveKeys.TRANSLATE_Z,
|
|
DriveKeys.STEP_TRANSLATE_X,
|
|
DriveKeys.STEP_TRANSLATE_Y,
|
|
DriveKeys.STEP_TRANSLATE_Z,
|
|
];
|
|
this.transparencyInterval = null;
|
|
this.entityID = null;
|
|
this.animStateHandlerID = null;
|
|
this.interval = null;
|
|
this.sitDownSettlePeriod = null;
|
|
this.lastTimeNoDriveKeys = null;
|
|
this.sittingDown = false;
|
|
|
|
var checkForHover;
|
|
|
|
// Preload the animation file
|
|
this.animation = AnimationCache.prefetch(ANIMATION_URL);
|
|
|
|
this.preload = function(entityID) {
|
|
this.entityID = entityID;
|
|
}
|
|
this.unload = function() {
|
|
if (Settings.getValue(SETTING_KEY) === this.entityID) {
|
|
this.standUp();
|
|
}
|
|
if (this.interval !== null) {
|
|
Script.clearInterval(this.interval);
|
|
this.interval = null;
|
|
}
|
|
|
|
if (this.transparencyInterval !== null) {
|
|
Script.clearInterval(this.transparencyInterval);
|
|
this.transparencyInterval = null;
|
|
}
|
|
|
|
if (checkForHover !== null) {
|
|
Script.clearInterval(checkForHover);
|
|
checkForHover = null;
|
|
}
|
|
|
|
this.cleanupOverlay();
|
|
}
|
|
|
|
this.setSeatUser = function(user) {
|
|
try {
|
|
var userData = Entities.getEntityProperties(this.entityID, ["userData"]).userData;
|
|
userData = JSON.parse(userData);
|
|
|
|
if (user !== null) {
|
|
userData.seat.user = user;
|
|
} else {
|
|
delete userData.seat.user;
|
|
}
|
|
|
|
Entities.editEntity(this.entityID, {
|
|
userData: JSON.stringify(userData)
|
|
});
|
|
} catch (e) {
|
|
// Do Nothing
|
|
}
|
|
}
|
|
this.getSeatUser = function() {
|
|
try {
|
|
var properties = Entities.getEntityProperties(this.entityID, ["userData", "position"]);
|
|
var userData = JSON.parse(properties.userData);
|
|
|
|
// If MyAvatar return my uuid
|
|
if (userData.seat.user === MyAvatar.sessionUUID) {
|
|
return userData.seat.user;
|
|
}
|
|
|
|
|
|
// If Avatar appears to be sitting
|
|
if (userData.seat.user) {
|
|
var avatar = AvatarList.getAvatar(userData.seat.user);
|
|
if (avatar && (Vec3.distance(avatar.position, properties.position) < RELEASE_DISTANCE)) {
|
|
return userData.seat.user;
|
|
}
|
|
}
|
|
} catch (e) {
|
|
// Do nothing
|
|
}
|
|
|
|
// Nobody on the seat
|
|
return null;
|
|
}
|
|
|
|
// Is the seat used
|
|
this.checkSeatForAvatar = function() {
|
|
var seatUser = this.getSeatUser();
|
|
|
|
// If MyAvatar appears to be sitting
|
|
if (seatUser === MyAvatar.sessionUUID) {
|
|
var properties = Entities.getEntityProperties(this.entityID, ["position"]);
|
|
return Vec3.distance(MyAvatar.position, properties.position) < RELEASE_DISTANCE;
|
|
}
|
|
|
|
return seatUser !== null;
|
|
}
|
|
|
|
this.rolesToOverride = function() {
|
|
return MyAvatar.getAnimationRoles().filter(function(role) {
|
|
return !(role.startsWith("right") || role.startsWith("left"));
|
|
});
|
|
}
|
|
|
|
// Handler for user changing the avatar model while sitting. There's currently an issue with changing avatar models while override role animations are applied,
|
|
// so to avoid that problem, re-apply the role overrides once the model has finished changing.
|
|
this.modelURLChangeFinished = function () {
|
|
print("Sitter's model has FINISHED changing. Reapply anim role overrides.");
|
|
var roles = this.rolesToOverride();
|
|
for (i in roles) {
|
|
MyAvatar.overrideRoleAnimation(roles[i], ANIMATION_URL, ANIMATION_FPS, true, ANIMATION_FIRST_FRAME, ANIMATION_LAST_FRAME);
|
|
}
|
|
}
|
|
|
|
this.sitDown = function() {
|
|
if (this.checkSeatForAvatar()) {
|
|
print("Someone is already sitting in that chair.");
|
|
return;
|
|
}
|
|
|
|
|
|
print("Sitting down (" + this.entityID + ")");
|
|
this.sittingDown = true;
|
|
|
|
var now = Date.now();
|
|
this.sitDownSettlePeriod = now + IK_SETTLE_TIME;
|
|
this.lastTimeNoDriveKeys = now;
|
|
|
|
var previousValue = Settings.getValue(SETTING_KEY);
|
|
Settings.setValue(SETTING_KEY, this.entityID);
|
|
this.setSeatUser(MyAvatar.sessionUUID);
|
|
if (previousValue === "") {
|
|
MyAvatar.characterControllerEnabled = false;
|
|
MyAvatar.hmdLeanRecenterEnabled = false;
|
|
var roles = this.rolesToOverride();
|
|
for (i in roles) {
|
|
MyAvatar.overrideRoleAnimation(roles[i], ANIMATION_URL, ANIMATION_FPS, true, ANIMATION_FIRST_FRAME, ANIMATION_LAST_FRAME);
|
|
}
|
|
|
|
for (var i in OVERRIDEN_DRIVE_KEYS) {
|
|
MyAvatar.disableDriveKey(OVERRIDEN_DRIVE_KEYS[i]);
|
|
}
|
|
|
|
MyAvatar.resetSensorsAndBody();
|
|
}
|
|
|
|
var properties = Entities.getEntityProperties(this.entityID, ["position", "rotation"]);
|
|
var index = MyAvatar.getJointIndex("Hips");
|
|
MyAvatar.pinJoint(index, properties.position, properties.rotation);
|
|
|
|
this.animStateHandlerID = MyAvatar.addAnimationStateHandler(function(properties) {
|
|
return { headType: 0 };
|
|
}, ["headType"]);
|
|
Script.update.connect(this, this.update);
|
|
MyAvatar.onLoadComplete.connect(this, this.modelURLChangeFinished);
|
|
}
|
|
|
|
this.standUp = function() {
|
|
|
|
print("Standing up (" + this.entityID + ")");
|
|
MyAvatar.removeAnimationStateHandler(this.animStateHandlerID);
|
|
Script.update.disconnect(this, this.update);
|
|
MyAvatar.onLoadComplete.disconnect(this, this.modelURLChangeFinished);
|
|
|
|
if (MyAvatar.sessionUUID === this.getSeatUser()) {
|
|
this.setSeatUser(null);
|
|
}
|
|
|
|
if (Settings.getValue(SETTING_KEY) === this.entityID) {
|
|
Settings.setValue(SETTING_KEY, "");
|
|
|
|
for (var i in OVERRIDEN_DRIVE_KEYS) {
|
|
MyAvatar.enableDriveKey(OVERRIDEN_DRIVE_KEYS[i]);
|
|
}
|
|
|
|
|
|
var roles = this.rolesToOverride();
|
|
for (i in roles) {
|
|
MyAvatar.restoreRoleAnimation(roles[i]);
|
|
}
|
|
MyAvatar.characterControllerEnabled = true;
|
|
MyAvatar.hmdLeanRecenterEnabled = true;
|
|
|
|
var index = MyAvatar.getJointIndex("Hips");
|
|
MyAvatar.clearPinOnJoint(index);
|
|
|
|
MyAvatar.resetSensorsAndBody();
|
|
|
|
Script.setTimeout(function() {
|
|
MyAvatar.bodyPitch = 0.0;
|
|
MyAvatar.bodyRoll = 0.0;
|
|
}, SIT_DELAY);
|
|
}
|
|
this.sittingDown = false;
|
|
}
|
|
|
|
//on trigger at a certain distance, sit in the chair (VR)
|
|
this.startNearTrigger = function() {
|
|
this.sitDown();
|
|
};
|
|
|
|
//on trigger at a certain distance, sit in the chair (VR)
|
|
this.startFarTrigger = function() {
|
|
var properties = Entities.getEntityProperties(this.entityID, ["position"]);
|
|
if(Vec3.distance(MyAvatar.position, properties.position) < DESKTOP_MAX_DISTANCE){
|
|
this.sitDown();
|
|
}
|
|
};
|
|
|
|
this.createOverlay = function() {
|
|
var url;
|
|
|
|
if(HMD.active){ //change the image based on what modality the user is in
|
|
url = "http://hifi-content.s3.amazonaws.com/alexia/TriggerToSit.png";
|
|
} else {
|
|
url = "http://hifi-content.s3.amazonaws.com/alexia/ClickToSit.png";
|
|
}
|
|
|
|
this.overlay = Overlays.addOverlay("image3d", {
|
|
position: { x: 0.0, y: 0.0, z: 0.0},
|
|
dimensions: { x: 0.1, y: 0.1 },
|
|
url: url,
|
|
ignoreRayIntersection: false,
|
|
alpha: ALPHA_START,
|
|
visible: true,
|
|
isFacingAvatar: true,
|
|
emissive: true
|
|
});
|
|
|
|
var overlayDimensions = {
|
|
x: 0.3,
|
|
y: 0.3
|
|
}
|
|
|
|
var properties = Entities.getEntityProperties(this.entityID, ["position", "registrationPoint", "dimensions", "rotation"]);
|
|
var yOffset = (0.8 - properties.registrationPoint.y) * properties.dimensions.y + (overlayDimensions.y / 2.0);
|
|
var overlayPosition = Vec3.sum(properties.position, { x: 0, y: yOffset, z: 0 });
|
|
Overlays.editOverlay(this.overlay, {
|
|
position: overlayPosition,
|
|
dimensions: overlayDimensions,
|
|
});
|
|
|
|
}
|
|
|
|
// User can also click on overlay to sit down
|
|
var that = this;
|
|
this.mousePressOnOverlay = function (overlayID, pointerEvent) {
|
|
if (overlayID === that.overlay && pointerEvent.isLeftButton) {
|
|
that.sitDown();
|
|
}
|
|
};
|
|
|
|
Overlays.mousePressOnOverlay.connect(this.mousePressOnOverlay);
|
|
|
|
this.cleanupOverlay = function() {
|
|
if (this.overlay !== null) {
|
|
Overlays.deleteOverlay(this.overlay);
|
|
this.overlay = null;
|
|
}
|
|
}
|
|
|
|
this.update = function(dt) {
|
|
|
|
if (this.sittingDown === true) {
|
|
var properties = Entities.getEntityProperties(this.entityID);
|
|
var avatarDistance = Vec3.distance(MyAvatar.position, properties.position);
|
|
var ikError = MyAvatar.getIKErrorOnLastSolve();
|
|
var now = Date.now();
|
|
var shouldStandUp = false;
|
|
|
|
// Check if a drive key is pressed
|
|
var hasActiveDriveKey = false;
|
|
for (var i in OVERRIDEN_DRIVE_KEYS) {
|
|
if (MyAvatar.getRawDriveKey(OVERRIDEN_DRIVE_KEYS[i]) != 0.0) {
|
|
hasActiveDriveKey = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// Only standup if user has been pushing a drive key for RELEASE_TIME
|
|
if (hasActiveDriveKey) {
|
|
var elapsed = now - this.lastTimeNoDriveKeys;
|
|
shouldStandUp = elapsed > RELEASE_TIME;
|
|
} else {
|
|
this.lastTimeNoDriveKeys = Date.now();
|
|
}
|
|
|
|
// Allow some time for the IK to settle
|
|
if (ikError > MAX_IK_ERROR && now > this.sitDownSettlePeriod) {
|
|
shouldStandUp = true;
|
|
}
|
|
|
|
if (MyAvatar.sessionUUID !== this.getSeatUser()) {
|
|
shouldStandUp = true;
|
|
}
|
|
|
|
if (shouldStandUp || avatarDistance > RELEASE_DISTANCE) {
|
|
print("IK error: " + ikError + ", distance from chair: " + avatarDistance);
|
|
|
|
// Move avatar in front of the chair to avoid getting stuck in collision hulls
|
|
if (avatarDistance < MAX_RESET_DISTANCE) {
|
|
var offset = { x: 0, y: 1.0, z: -0.5 - properties.dimensions.z * properties.registrationPoint.z };
|
|
var position = Vec3.sum(properties.position, Vec3.multiplyQbyV(properties.rotation, offset));
|
|
MyAvatar.position = position;
|
|
print("Moving Avatar in front of the chair.");
|
|
// Delay standing up by 1 cycle.
|
|
// This leaves times for the avatar to actually move since a lot
|
|
// of the stand up operations are threaded
|
|
return;
|
|
}
|
|
|
|
this.standUp();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
this.canSitDesktop = function() {
|
|
var properties = Entities.getEntityProperties(this.entityID, ["position"]);
|
|
var distanceFromSeat = Vec3.distance(MyAvatar.position, properties.position);
|
|
return distanceFromSeat < DESKTOP_MAX_DISTANCE && !this.checkSeatForAvatar();
|
|
}
|
|
|
|
// This part is used to fade out the overlay over time
|
|
this.lerpTransparency = function() {
|
|
var startAlpha = ALPHA_START;
|
|
var changeAlpha = 0.01;
|
|
var that = this;
|
|
this.transparencyInterval = Script.setInterval(function(){
|
|
startAlpha = startAlpha - changeAlpha; // My new alpha
|
|
Overlays.editOverlay(that.overlay, {alpha : startAlpha}); // Edit the existing overlay
|
|
if(startAlpha <= 0){
|
|
Script.clearInterval(that.transparencyInterval); // Stop my interval when it's faded out
|
|
that.transparencyInterval = null;
|
|
|
|
Overlays.editOverlay(that.overlay, {
|
|
ignoreRayIntersection: true
|
|
});
|
|
}
|
|
}, 50);
|
|
}
|
|
|
|
this.showOverlays = function() { // Show overlays when I'm close to the seat
|
|
if (isInEditMode() || this.interval !== null) {
|
|
return;
|
|
}
|
|
|
|
|
|
if (this.overlay === null) { // Make an overlay if there isn't one
|
|
if (this.canSitDesktop()) {
|
|
this.createOverlay();
|
|
if(this.transparencyInterval === null){
|
|
this.lerpTransparency();
|
|
}
|
|
}
|
|
} else if (!this.canSitDesktop()) {
|
|
this.cleanupOverlay();
|
|
}
|
|
}
|
|
|
|
var that = this; // Run my method to check if we've encountered a chair
|
|
checkForHover = Script.setInterval(function(){
|
|
that.showOverlays();
|
|
}, DESKTOP_UI_CHECK_INTERVAL);
|
|
|
|
this.clickDownOnEntity = function (id, event) {
|
|
if (isInEditMode()) {
|
|
return;
|
|
}
|
|
if (event.isPrimaryButton && this.canSitDesktop()) {
|
|
this.sitDown();
|
|
}
|
|
}
|
|
|
|
}); |