Mirrors/overte-thingvellir
3
0
Fork 0
mirror of https://thingvellir.net/git/overte synced 2025-03-27 23:52:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add comments and connect update signal only when is necessary

Browse source
This commit is contained in:
luiscuenca 2019-11-20 16:42:33 -07:00
parent 37a46d91fa
commit fbd6fd8703
No known key found for this signature in database
GPG key ID: 2387ECD129A6961D
1 changed files with 142 additions and 61 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

203
scripts/simplifiedUI/clickToZoom/clickToZoom.js
View file

@ -9,11 +9,11 @@
(function() {
var ZoomStatus = {
"zoomingIn" : 0,
"zoomingOut" : 1,
"zoomedIn" : 2,
"zoomedOut" : 4,
"consumed" : 5
"zoomingIn" : 0, // The camera is moving towards the selected entity
"zoomingOut" : 1, // The camera is moving away from the selected entity
"zoomedIn" : 2, // The camera is locked looking at the selected entity
"zoomedOut" : 4, // The camera is on its initial position and mode
"consumed" : 5 // The zooming loop has been completed
}
var FocusType = {
@ -42,32 +42,36 @@
// acceleration until halfway, then deceleration
easeInOutQuint: function (t) { return t<.5 ? 16*t*t*t*t*t : 1+16*(--t)*t*t*t*t }
};
// Class that manages the zoom effect
var ZoomData = function(type, lookAt, focusNormal, focusDimensions, velocity, maxDuration) {
var self = this;
this.focusType = type;
this.lookAt = lookAt;
this.focusDimensions = focusDimensions;
this.focusNormal = focusNormal;
this.velocity = velocity;
this.maxDuration = maxDuration;
this.lookAt = lookAt; // Look at 3d point in world coordinates
this.focusDimensions = focusDimensions; // 2d dimensions of the bounding box projection approximation of the selected entity
this.focusNormal = focusNormal; // The normal vector provided by the ray intersection used to initialize the zoom
this.velocity = velocity; // Max velocity of the camera zoom effect
this.maxDuration = maxDuration; // Max duration of the camera zoom effect
this.initialPos = Camera.getPosition();
this.initialRot = Camera.getOrientation();
this.interpolatedPos = this.initialPos;
this.interpolatedRot = this.initialRot;
this.initialMode = Camera.mode;
this.initialOffset = Vec3.distance(self.initialPos, MyAvatar.getDefaultEyePosition());
this.initialOffset = Vec3.distance(self.initialPos, MyAvatar.getDefaultEyePosition()); // Save the offset distance from the camera to the avatar eyes (boom)
this.finalPos = Vec3.ZERO;
this.finalRot = Quat.IDENTITY;
this.direction = Vec3.ZERO;
this.distance = Vec3.ZERO;
this.totalTime = 0.0;
this.direction = Vec3.ZERO; // Direction vector for the camera path
this.distance = Vec3.ZERO; // Total distance that the camera needs to cover to zoom in along the path
this.totalTime = 0.0; // Total time needed to cover the zoom path
this.elapsedTime = 0.0;
this.maxZoomInAmount = 0.6;
this.maxZoomOutAmount = 0.2;
var MAX_ZOOM_IN_AMOUNT = 0.6; // Maximum percentage of camera proximity to the selected entity from the look at point
var MAX_ZOOM_OUT_AMOUNT = 0.2; // Maximum percentage of camera remoteness to the selected entity from the look at point
this.maxZoomInAmount = MAX_ZOOM_IN_AMOUNT;
this.maxZoomOutAmount = MAX_ZOOM_OUT_AMOUNT;
this.currentZoomAmount = 0.0;
this.zoomPanOffset = {x: 0.5 * Window.innerWidth, y: 0.5 * Window.innerHeight};
@ -76,14 +80,17 @@
this.status = ZoomStatus.zoomedOut;
var OWN_CAMERA_CHANGE_MAX_FRAMES = 30;
this.ownCameraChangeElapseTime = 0.0;
this.ownCameraChange = false;
this.ownCameraChangeElapseTime = 0.0; // Variables used to track if the camera mode change is triggered by this script
this.ownCameraChange = false; // or by user input, since the later needs to abort the zoom loop
// Function called when the user release the mouse while panning the camera when using the secondary zoom
this.applyZoomPan = function() {
self.zoomPanOffset.x += self.zoomPanDelta.x;
self.zoomPanOffset.y += self.zoomPanDelta.y;
}
// Function called when the user moves the mouse while panning the camera when using the secondary zoom
this.setZoomPanDelta = function(x, y) {
self.zoomPanDelta.x = x;
self.zoomPanDelta.y = y;
@ -96,6 +103,7 @@
self.updateSuperPan(totalX, totalY);
}
// This function computes the correct distance to the selected entity so it ends up fitted on the screen
this.getFocusDistance = function(zoomDims) {
var objAspect = zoomDims.x / zoomDims.y;
var camAspect = Camera.frustum.aspectRatio;
@ -110,9 +118,13 @@
return (0.5 * m) / Math.tan(0.5 * fov);
}
this.finalPos = Vec3.sum(this.lookAt, Vec3.multiply(this.getFocusDistance(this.focusDimensions), this.focusNormal));
this.finalRot = Quat.lookAtSimple(this.finalPos, this.lookAt);
// This function computes the final camera position and rotation
this.computeFinalForm = function() {
self.finalPos = Vec3.sum(self.lookAt, Vec3.multiply(self.getFocusDistance(self.focusDimensions), self.focusNormal));
self.finalRot = Quat.lookAtSimple(self.finalPos, self.lookAt);
}
// Function that computes the time and path information for the camera zoom in
this.computeRouteIn = function() {
var railVector = Vec3.subtract(self.finalPos, self.initialPos);
self.direction = Vec3.normalize(railVector);
@ -121,6 +133,9 @@
self.totalTime = self.totalTime > self.maxDuration ? self.maxDuration : self.totalTime;
}
// Function that computes the time and path information for the camera zoom out
// Since the camera orientation and position gets reset when changing camera modes,
// the camera path while zooming out is different from the path zooming in.
this.computeRouteOut = function() {
self.finalPos = Camera.getPosition();
var camOffset = Vec3.ZERO;
@ -137,6 +152,7 @@
self.computeRouteIn();
}
// This function initiate the camera zoom in
this.initZoomIn = function() {
if (self.status === ZoomStatus.zoomedOut) {
self.computeRouteIn();
@ -146,6 +162,7 @@
}
}
// This function initiate the camera zoom in
this.initZoomOut = function() {
if (self.status === ZoomStatus.zoomedIn) {
self.computeRouteOut();
@ -155,10 +172,12 @@
}
}
// This function checks if the zoom loop needs update
this.needsUpdate = function() {
return self.status === ZoomStatus.zoomingIn || self.status === ZoomStatus.zoomingOut;
}
// This function connects to the update signal only when zoom in or zoom out is needed
this.updateZoom = function(deltaTime) {
if (self.ownCameraChange) {
self.ownCameraChange = self.ownCameraChangeElapseTime < OWN_CAMERA_CHANGE_MAX_FRAMES * deltaTime;
@ -194,11 +213,14 @@
}
}
// This function recomputes the camera distance to the selected item in order to fit it on the screen
this.resetZoomAspect = function() {
self.computeFinalForm();
self.computeRouteIn();
Camera.setPosition(self.finalPos);
}
// This function updates the secondary zoom distance to the selected entity according to the mouse wheel event
this.updateSuperZoom = function(delta) {
var ZOOM_STEP = 0.1;
self.currentZoomAmount = self.currentZoomAmount + (delta < 0.0 ? -1 : 1) * ZOOM_STEP;
@ -206,6 +228,7 @@
self.updateSuperPan(self.zoomPanOffset.x, self.zoomPanOffset.y);
}
// This function updates the secondary zoom panning according to the mouse move event
this.updateSuperPan = function(x, y) {
var zoomOffset = Vec3.multiply(self.currentZoomAmount, Vec3.subtract(self.lookAt, self.finalPos));
var xRatio = 0.5 - x / Window.innerWidth;
@ -220,28 +243,34 @@
Camera.setPosition(Vec3.sum(self.finalPos, zoomOffset));
}
// This function aborts the zoom loop when the user changes the camera mode
this.abort = function() {
self.changeCameraMode(self.initialMode);
}
// This function changes the camera mode
this.changeCameraMode = function(mode) {
self.ownCameraChange = true;
self.ownCameraChangeElapseTime = 0.0;
Camera.mode = mode;
}
this.computeFinalForm();
}
// Class that manages the mouse events and computes the 3d structure data of the selected entity or avatar
var ZoomOnAnything = function() {
var self = this;
this.zoomEntityID;
this.zoomEntityData;
this.zoomEntityData; // The selected entity's data
this.zoomCameraPos;
var ZOOM_MAX_VELOCITY = 15.0; // meters per second
var ZOOM_MAX_DURATION = 1.0;
this.zoomDelta = {x: 0.0, y: 0.0};
var ZOOM_MAX_DURATION = 1.0; // seconds
this.zoomDelta = {x: 0.0, y: 0.0}; // mouse move delta while panning
this.isPanning = false;
this.screenPointRef = {x: 0.0, y: 0.0};
this.screenPointRef = {x: 0.0, y: 0.0}; // Screen pixels reference used to compute the zoomDelta
this.connected = false;
// This function estimates the projection axis and the dimensions along that axis of the selected entity
this.getEntityDimsFromNormal = function(dims, rot, normal) {
var zoomXNormal = Vec3.multiplyQbyV(rot, Vec3.UNIT_X);
var zoomYNormal = Vec3.multiplyQbyV(rot, Vec3.UNIT_Y);
@ -257,6 +286,7 @@
return affinities[0];
}
// This function estimates the appropriate focus point when the selected entity is an avatar
this.getAvatarFocusPoint = function(avatar) {
var rEyeIndex = avatar.getJointIndex("RightEye");
var lEyeIndex = avatar.getJointIndex("LeftEye");
@ -288,8 +318,9 @@
return Vec3.multiply(1.0/count, focusPoint);
}
// This function sets the data needed to zoom in on an avatar
this.getZoomDataFromAvatar = function(avatarID, skinToBoneDist, zoomVelocity, maxDuration) {
var headDiam = 2.0 * skinToBoneDist;
var headDiam = 2.0 * skinToBoneDist; // Head diameter is estimated based on the distance to the bone
headDiam = headDiam < 0.5 ? 0.5 : headDiam;
var avatar = AvatarList.getAvatar(avatarID);
var focusPoint = self.getAvatarFocusPoint(avatar);
@ -299,6 +330,7 @@
return zoomData;
}
// This function sets the data needed to zoom in on an entity
this.getZoomDataFromEntity = function(intersection, objectProps, zoomVelocity, maxDuration) {
var position = objectProps.position;
var dimensions = objectProps.dimensions;
@ -312,40 +344,61 @@
return zoomData;
}
// This function initiate the zoom loop on the selected entity
this.zoomOnEntity = function(intersection, objectProps) {
self.zoomEntityData = self.getZoomDataFromEntity(intersection, objectProps, ZOOM_MAX_VELOCITY, ZOOM_MAX_DURATION);
self.zoomEntityData.initZoomIn();
}
// This function initiates the zoom loop on the selected avatar
this.zoomOnAvatar = function(avatarID, skinToBoneDist) {
self.zoomEntityData = self.getZoomDataFromAvatar(avatarID, skinToBoneDist, ZOOM_MAX_VELOCITY, ZOOM_MAX_DURATION);
self.zoomEntityData.initZoomIn();
}
// This function connects to the Script.update signal
this.connect = function() {
self.connected = true;
Script.update.connect(self.updateZoom);
}
// This function disconnects to the Script.update signal
this.disconnect = function() {
self.connected = false;
Script.update.disconnect(self.updateZoom);
}
// This function get connected to the Script.update signal
this.updateZoom = function(deltaTime) {
if (self.zoomEntityData && self.zoomEntityData.needsUpdate()) {
self.zoomEntityData.updateZoom(deltaTime);
if (self.zoomEntityData.status === ZoomStatus.consumed) {
self.zoomEntityData = undefined;
if (self.zoomEntityData) {
if (self.zoomEntityData.needsUpdate()) {
self.zoomEntityData.updateZoom(deltaTime);
if (self.zoomEntityData.status === ZoomStatus.consumed) {
self.disconnect();
self.zoomEntityData = undefined;
}
} else {
self.disconnect();
}
} else if (self.connected) {
self.disconnect();
}
}
// This function listen to the mouse double click that evaluates the selected entity and the intersection data that initiates the zoom loop
this.mouseDoublePressEvent = function(event) {
if (event.isLeftButton) {
self.connect();
if (!self.zoomEntityData) {
var pickRay = Camera.computePickRay(event.x, event.y);
var intersection = AvatarManager.findRayIntersection({origin: pickRay.origin, direction: pickRay.direction}, [], [MyAvatar.sessionUUID], false);
zoomingAtAvatarID = intersection.intersects ? intersection.avatarID : undefined;
if (!zoomingAtAvatarID) {
if (!intersection.intersects) {
intersection = Entities.findRayIntersection({origin: pickRay.origin, direction: pickRay.direction}, true);
self.zoomEntityID = intersection.entityID;
var entityProps = Entities.getEntityProperties(intersection.entityID);
if (entityProps.type === "Shape") {
var FIND_SHAPES_DISTANCE = 10.0;
var shapes = Entities.findEntitiesByType("Shape", intersection.intersection, FIND_SHAPES_DISTANCE);
intersection = Entities.findRayIntersection({origin: pickRay.origin, direction: pickRay.direction}, true, [], shapes);
self.zoomEntityID = intersection.entityID;
entityProps = Entities.getEntityProperties(intersection.entityID);
}
if (!entityProps.dimensions) {
@ -353,9 +406,9 @@
}
self.zoomOnEntity(intersection, entityProps);
} else {
var avatar = AvatarList.getAvatar(zoomingAtAvatarID);
var avatar = AvatarList.getAvatar(intersection.avatarID);
var skinToBoneDist = Vec3.distance(intersection.intersection, avatar.getJointPosition(intersection.jointIndex));
self.zoomOnAvatar(zoomingAtAvatarID, skinToBoneDist);
self.zoomOnAvatar(intersection.avatarID, skinToBoneDist);
}
} else if (!self.zoomEntityData.needsUpdate()){
self.zoomEntityData.initZoomOut();
@ -363,6 +416,7 @@
}
}
// This function listen to the mouse press event to initiate panning while on secondary zoom
this.mousePressEvent = function(event) {
if (event.isRightButton) {
self.isPanning = true;
@ -370,6 +424,7 @@
}
}
// This function listen to the mouse release event to apply the pan delta while on secondary zoom
this.mouseReleaseEvent = function(event) {
if (event.isRightButton) {
if (self.zoomEntityData) {
@ -380,6 +435,7 @@
}
}
// This function listen to the mouse move event to modify the pan delta coordenates while on secondary zoom
this.mouseMoveEvent = function(event) {
if (event.isRightButton) {
if (self.isPanning && self.zoomEntityData) {
@ -388,41 +444,66 @@
}
}
// This function listen to the mouse wheel event to modify the ammount of secondary zoom
this.mouseWheel = function(event) {
if (self.zoomEntityData) {
self.zoomEntityData.updateSuperZoom(event.delta);
}
}
// This function aborts the zoom loop
this.abort = function() {
self.zoomEntityData.abort();
self.zoomEntityData = undefined;
if (self.connected) {
self.disconnect();
}
}
// This function refits the selected entity on the screen when the screen dimensions change
this.geometryChanged = function() {
if (self.zoomEntityData !== undefined){
self.zoomEntityData.resetZoomAspect();
}
}
// This function aborts the zoom loop if the camera mode is set by the user
this.modeUpdated = function(mode) {
if (self.zoomEntityData && !self.zoomEntityData.ownCameraChange) {
self.abort();
}
}
// This function initiate the connections
this.init = function() {
// Connect signals
Window.geometryChanged.connect(self.geometryChanged);
Camera.modeUpdated.connect(self.modeUpdated);
Controller.mousePressEvent.connect(self.mousePressEvent);
Controller.mouseDoublePressEvent.connect(self.mouseDoublePressEvent);
Controller.mouseMoveEvent.connect(self.mouseMoveEvent);
Controller.mouseReleaseEvent.connect(self.mouseReleaseEvent);
Controller.wheelEvent.connect(self.mouseWheel);
}
// This function finish the connections
this.scriptEnding = function() {
// Disconnect on exit
Window.geometryChanged.disconnect(self.geometryChanged);
Camera.modeUpdated.disconnect(self.modeUpdated);
Controller.mousePressEvent.disconnect(self.mousePressEvent);
Controller.mouseDoublePressEvent.disconnect(self.mouseDoublePressEvent);
Controller.mouseMoveEvent.disconnect(self.mouseMoveEvent);
Controller.mouseReleaseEvent.disconnect(self.mouseReleaseEvent);
Controller.wheelEvent.disconnect(self.mouseWheel);
if (self.zoomEntityData) {
self.abort();
}
}
}
var zoomOE = new ZoomOnAnything();
zoomOE.init();
Script.scriptEnding.connect(zoomOE.scriptEnding);
Window.geometryChanged.connect(function() {
if (zoomOE.zoomEntityData){
zoomOE.zoomEntityData.resetZoomAspect();
}
});
Camera.modeUpdated.connect(function(mode) {
if (zoomOE.zoomEntityData && !zoomOE.zoomEntityData.ownCameraChange) {
zoomOE.abort();
}
});
Controller.mousePressEvent.connect(zoomOE.mousePressEvent);
Controller.mouseDoublePressEvent.connect(zoomOE.mouseDoublePressEvent);
Controller.mouseMoveEvent.connect(zoomOE.mouseMoveEvent);
Controller.mouseReleaseEvent.connect(zoomOE.mouseReleaseEvent);
Controller.wheelEvent.connect(zoomOE.mouseWheel);
Script.update.connect(zoomOE.updateZoom);
Script.scriptEnding.connect(function() {
if (zoomOE.zoomEntityData) {
zoomOE.abort();
}
});
})();
})();