384 lines
13 KiB
JavaScript
Executable File
384 lines
13 KiB
JavaScript
Executable File
/*
|
|
3DHOP - 3D Heritage Online Presenter
|
|
Copyright (c) 2014-2023, Visual Computing Lab, ISTI - CNR
|
|
All rights reserved.
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/**
|
|
* Constructs a PanTiltTrackball object.
|
|
* @class Interactor which implements a pan-tilt trackball controller with bounds.
|
|
*/
|
|
function PanTiltTrackball() {
|
|
}
|
|
|
|
PanTiltTrackball.prototype = {
|
|
|
|
setup : function (options,myPresenter) {
|
|
options = options || {};
|
|
var opt = sglGetDefaultObject({
|
|
startCenter : [ 0.0, 0.0, 0.0 ],
|
|
startPanX : 0.0,
|
|
startPanY : 0.0,
|
|
startAngleX : 0.0,
|
|
startAngleY : 0.0,
|
|
startDistance : 2.0,
|
|
minMaxDist : [0.2, 4.0],
|
|
minMaxPanX : [-0.7, 0.7],
|
|
minMaxPanY : [-0.7, 0.7],
|
|
minMaxAngleX : [-70.0, 70.0],
|
|
minMaxAngleY : [-70.0, 70.0],
|
|
pathStates : [ ], // path points array
|
|
animationLocked : false,// if true disable trackball interactions during animation
|
|
animationTime : null // when single position navigation, each to point navigation is # seconds (if null, automatically computed)
|
|
}, options);
|
|
|
|
this._action = SGL_TRACKBALL_NO_ACTION;
|
|
this._new_action = true;
|
|
this._matrix = SglMat4.identity();
|
|
|
|
this.myPresenter = myPresenter;// parent presenter
|
|
|
|
// path
|
|
this._pathStates = opt.pathStates;
|
|
this._animationLocked = opt.animationLocked;
|
|
this._pathPosNum = 0;
|
|
|
|
// trackball center
|
|
this._center = opt.startCenter;
|
|
|
|
// starting/default parameters
|
|
this._startPanX = opt.startPanX; //pan X
|
|
this._startPanY = opt.startPanY; //pan Y
|
|
this._startAngleX = sglDegToRad(opt.startAngleX); //angle X
|
|
this._startAngleY = sglDegToRad(opt.startAngleY); //angle Y
|
|
this._startDistance = opt.startDistance; //distance
|
|
|
|
// current parameters
|
|
this._panX = this._startPanX;
|
|
this._panY = this._startPanY;
|
|
this._angleX = this._startAngleX;
|
|
this._angleY = this._startAngleY;
|
|
this._distance = this._startDistance;
|
|
|
|
// target paramenters
|
|
this._targetPanX = this._startPanX;
|
|
this._targetPanY = this._startPanY;
|
|
this._targetAngleX = this._startAngleX;
|
|
this._targetAngleY = this._startAngleY;
|
|
this._targetDistance = this._startDistance;
|
|
|
|
//animation data
|
|
this._isAnimating = false;
|
|
this._speedPanX = 0.0;
|
|
this._speedPanY = 0.0;
|
|
this._speedAngleX = 0.0;
|
|
this._speedAngleY = 0.0;
|
|
this._speedDistance = 0.0;
|
|
this._isAutoWalking = false;
|
|
this._animationTime = opt.animationTime;
|
|
|
|
//limits
|
|
this._minMaxDist = opt.minMaxDist;
|
|
this._minMaxPanX = opt.minMaxPanX;
|
|
this._minMaxPanY = opt.minMaxPanY;
|
|
this._minMaxAngleX = opt.minMaxAngleX;
|
|
this._minMaxAngleX[0] = sglDegToRad(this._minMaxAngleX[0]);
|
|
this._minMaxAngleX[1] = sglDegToRad(this._minMaxAngleX[1]);
|
|
this._minMaxAngleY = opt.minMaxAngleY;
|
|
this._minMaxAngleY[0] = sglDegToRad(this._minMaxAngleY[0]);
|
|
this._minMaxAngleY[1] = sglDegToRad(this._minMaxAngleY[1]);
|
|
|
|
this._start = [0.0, 0.0];
|
|
this.reset();
|
|
},
|
|
|
|
_clamp : function(value, low, high) {
|
|
if(value < low) return low;
|
|
if(value > high) return high;
|
|
return value;
|
|
},
|
|
|
|
_computeMatrix: function() {
|
|
var m = SglMat4.identity();
|
|
|
|
// centering
|
|
m = SglMat4.mul(m, SglMat4.translation([-this._center[0], -this._center[1], -this._center[2]]));
|
|
// zoom
|
|
m = SglMat4.mul(m, SglMat4.translation([0.0, 0.0, -this._distance]));
|
|
// tilt
|
|
m = SglMat4.mul(m, SglMat4.rotationAngleAxis(this._angleY, [1.0, 0.0, 0.0]));
|
|
m = SglMat4.mul(m, SglMat4.rotationAngleAxis(this._angleX, [0.0, -1.0, 0.0]));
|
|
// pan
|
|
m = SglMat4.mul(m, SglMat4.translation([this._panX, this._panY, 0.0]));
|
|
|
|
this._matrix = m;
|
|
|
|
if(typeof onTrackballUpdate != "undefined")
|
|
onTrackballUpdate(this.getState());
|
|
},
|
|
|
|
getState : function () {
|
|
return [this._panX, this._panY, sglRadToDeg(this._angleX), sglRadToDeg(this._angleY), this._distance];
|
|
},
|
|
|
|
setState : function (newstate) {
|
|
// stop animation
|
|
this._isAnimating = this._isAutoWalking = false;
|
|
|
|
this._panX = newstate[0];
|
|
this._panY = newstate[1];
|
|
this._angleX = sglDegToRad(newstate[2]);
|
|
this._angleY = sglDegToRad(newstate[3]);
|
|
this._distance = newstate[4];
|
|
|
|
//check limits
|
|
this._panX = this._clamp(this._panX, this._minMaxPanX[0], this._minMaxPanX[1]);
|
|
this._panY = this._clamp(this._panY, this._minMaxPanY[0], this._minMaxPanY[1]);
|
|
this._angleX = this._clamp(this._angleX, this._minMaxAngleX[0], this._minMaxAngleX[1]);
|
|
this._angleY = this._clamp(this._angleY, this._minMaxAngleY[0], this._minMaxAngleY[1]);
|
|
this._distance = this._clamp(this._distance, this._minMaxDist[0], this._minMaxDist[1]);
|
|
|
|
this._computeMatrix();
|
|
},
|
|
|
|
animateToState : function (newstate, newtime) {
|
|
// stop animation
|
|
this._isAnimating = false;
|
|
|
|
if(newstate)
|
|
{
|
|
// stop autoWalking
|
|
this._isAutoWalking = false;
|
|
|
|
// setting targets
|
|
this._targetPanX = newstate[0];
|
|
this._targetPanY = newstate[1];
|
|
this._targetAngleX = sglDegToRad(newstate[2]);
|
|
this._targetAngleY = sglDegToRad(newstate[3]);
|
|
this._targetDistance = newstate[4];
|
|
|
|
//check limits
|
|
this._targetPanX = this._clamp(this._targetPanX, this._minMaxPanX[0], this._minMaxPanX[1]);
|
|
this._targetPanY = this._clamp(this._targetPanY, this._minMaxPanY[0], this._minMaxPanY[1]);
|
|
this._targetAngleX = this._clamp(this._targetAngleX, this._minMaxAngleX[0], this._minMaxAngleX[1]);
|
|
this._targetAngleY = this._clamp(this._targetAngleY, this._minMaxAngleY[0], this._minMaxAngleY[1]);
|
|
this._targetDistance = this._clamp(this._targetDistance, this._minMaxDist[0], this._minMaxDist[1]);
|
|
|
|
// setting base velocities
|
|
this._speedPanX = 2.0;
|
|
this._speedPanY = 2.0;
|
|
this._speedAngleX = Math.PI;
|
|
this._speedAngleY = Math.PI;
|
|
this._speedDistance = 2.0;
|
|
|
|
// find max animation time to set a time limit and then synchronize all movements
|
|
var timePanX = Math.abs((this._targetPanX - this._panX) / this._speedPanX);
|
|
var timePanY = Math.abs((this._targetPanY - this._panY) / this._speedPanY);
|
|
var timeAngleX = Math.abs((this._targetAngleX - this._angleX) / this._speedAngleX);
|
|
var timeAngleY = Math.abs((this._targetAngleY - this._angleY) / this._speedAngleY);
|
|
var timeDistance = Math.abs((this._targetDistance - this._distance) / this._speedDistance);
|
|
|
|
var maxtime = Math.max( timePanX, Math.max( timePanY, Math.max( timeAngleX, Math.max( timeAngleY, timeDistance ) ) ));
|
|
var animationtime = this._clamp(maxtime, 0.5, 2.0);
|
|
|
|
if(newtime) animationtime = newtime;
|
|
else if (this._animationTime) animationtime = this._animationTime;
|
|
|
|
this._speedPanX *= timePanX / animationtime;
|
|
this._speedPanY *= timePanY / animationtime;
|
|
this._speedAngleX *= timeAngleX / animationtime;
|
|
this._speedAngleY *= timeAngleY / animationtime;
|
|
this._speedDistance *= timeDistance / animationtime;
|
|
}
|
|
else
|
|
{
|
|
if(this._pathPosNum == this._pathStates.length){
|
|
this._isAutoWalking = false;
|
|
this._pathPosNum = 0;
|
|
}
|
|
else {
|
|
var state = this._pathStates[this._pathPosNum][0];
|
|
var time = this._animationTime;
|
|
if(!Array.isArray(state)) state = this._pathStates[this._pathPosNum];
|
|
else if (this._pathStates[this._pathPosNum][1]) time = this._pathStates[this._pathPosNum][1];
|
|
if(!this._isAutoWalking) this.animateToState(state, time);
|
|
this._isAutoWalking = true;
|
|
}
|
|
}
|
|
|
|
// start animation
|
|
this._isAnimating = true;
|
|
},
|
|
|
|
recenter : function (newpoint) {
|
|
// stop animation
|
|
this._isAnimating = this._isAutoWalking = false;
|
|
|
|
var newpanX = -(newpoint[0]-this.myPresenter.sceneCenter[0]) * this.myPresenter.sceneRadiusInv;
|
|
var newpanY = -(newpoint[1]-this.myPresenter.sceneCenter[1]) * this.myPresenter.sceneRadiusInv;
|
|
|
|
this.animateToState([newpanX, newpanY, sglRadToDeg(this._angleX), sglRadToDeg(this._angleY), (this._distance * 0.6)]);
|
|
},
|
|
|
|
tick : function (dt) {
|
|
if(!this._isAnimating) return false;
|
|
|
|
var deltaPanX = this._speedPanX * dt;
|
|
var deltaPanY = this._speedPanY * dt;
|
|
var deltaAngleX = this._speedAngleX * dt;
|
|
var deltaAngleY = this._speedAngleY * dt;
|
|
var deltaDistance = this._speedDistance * dt;
|
|
|
|
var diffPanX = this._targetPanX - this._panX;
|
|
var diffPanY = this._targetPanY - this._panY;
|
|
var diffAngleX = this._targetAngleX - this._angleX;
|
|
var diffAngleY = this._targetAngleY - this._angleY;
|
|
var diffDistance = this._targetDistance - this._distance;
|
|
|
|
if (diffPanX > deltaPanX)
|
|
this._panX += deltaPanX;
|
|
else if (diffPanX < -deltaPanX)
|
|
this._panX -= deltaPanX;
|
|
else
|
|
this._panX = this._targetPanX;
|
|
|
|
if (diffPanY > deltaPanY)
|
|
this._panY += deltaPanY;
|
|
else if (diffPanY < -deltaPanY)
|
|
this._panY -= deltaPanY;
|
|
else
|
|
this._panY = this._targetPanY;
|
|
|
|
if (diffAngleX > deltaAngleX)
|
|
this._angleX += deltaAngleX;
|
|
else if (diffAngleX < -deltaAngleX)
|
|
this._angleX -= deltaAngleX;
|
|
else
|
|
this._angleX = this._targetAngleX;
|
|
|
|
if (diffAngleY > deltaAngleY)
|
|
this._angleY += deltaAngleY;
|
|
else if (diffAngleY < -deltaAngleY)
|
|
this._angleY -= deltaAngleY;
|
|
else
|
|
this._angleY = this._targetAngleY;
|
|
|
|
if (diffDistance > deltaDistance)
|
|
this._distance += deltaDistance;
|
|
else if (diffDistance < -deltaDistance)
|
|
this._distance -= deltaDistance;
|
|
else
|
|
this._distance = this._targetDistance;
|
|
|
|
if(this._panX == this._targetPanX)
|
|
if(this._panY == this._targetPanY)
|
|
if(this._angleX == this._targetAngleX)
|
|
if(this._angleY == this._targetAngleY)
|
|
if(this._distance == this._targetDistance){
|
|
this._isAnimating = false;
|
|
if(typeof onTrackballArrived != "undefined")
|
|
onTrackballArrived(this.getState());
|
|
if(this._isAutoWalking) { this._pathPosNum++; this._isAutoWalking = false; this.animateToState(); }
|
|
}
|
|
|
|
this._computeMatrix();
|
|
return true;
|
|
},
|
|
|
|
set action(a) { if(this._action != a) { this._new_action = true; this._action = a; } },
|
|
|
|
get action() { return this._action; },
|
|
|
|
get matrix() { this._computeMatrix(); return this._matrix; },
|
|
|
|
get distance() { return this._distance; },
|
|
|
|
reset : function () {
|
|
this._matrix = SglMat4.identity();
|
|
this._action = SGL_TRACKBALL_NO_ACTION;
|
|
this._new_action = true;
|
|
|
|
this._panX = this._startPanX;
|
|
this._panY = this._startPanY;
|
|
this._angleX = this._startAngleX;
|
|
this._angleY = this._startAngleY;
|
|
this._distance = this._startDistance;
|
|
|
|
this._pathPosNum = 0;
|
|
|
|
this._isAutoWalking = false;
|
|
this._isAnimating = false;
|
|
|
|
this._computeMatrix();
|
|
},
|
|
|
|
track : function(m, x, y, z) {
|
|
if(this._animationLocked && this._isAnimating) this._action = SGL_TRACKBALL_NO_ACTION;
|
|
if(this._new_action) {
|
|
this._start[0] = x;
|
|
this._start[1] = y;
|
|
this._new_action = false;
|
|
}
|
|
|
|
var dx = this._start[0] - x;
|
|
var dy = this._start[1] - y;
|
|
this._start[0] = x;
|
|
this._start[1] = y;
|
|
|
|
switch (this._action) {
|
|
case SGL_TRACKBALL_ROTATE:
|
|
this._isAnimating = this._isAutoWalking = false; //stopping animation
|
|
this.rotate(m, dx, dy);
|
|
break;
|
|
|
|
case SGL_TRACKBALL_PAN:
|
|
this._isAnimating = this._isAutoWalking = false; //stopping animation
|
|
this.pan(m, dx, dy);
|
|
break;
|
|
|
|
case SGL_TRACKBALL_SCALE:
|
|
this._isAnimating = this._isAutoWalking = false; //stopping animation
|
|
this.scale(m, z);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return this._computeMatrix();
|
|
},
|
|
|
|
rotate: function(m, dx, dy) {
|
|
this._angleX += dx;
|
|
this._angleY += dy;
|
|
this._angleX = this._clamp(this._angleX, this._minMaxAngleX[0], this._minMaxAngleX[1]);
|
|
this._angleY = this._clamp(this._angleY, this._minMaxAngleY[0], this._minMaxAngleY[1]);
|
|
},
|
|
|
|
pan: function(m, dx, dy) {
|
|
var panSpeed = Math.max(Math.min(1.5, this._distance),0.05);
|
|
this._panX -= dx/2.0 * panSpeed;
|
|
this._panY -= dy/2.0 * panSpeed;
|
|
this._panX = this._clamp(this._panX, this._minMaxPanX[0], this._minMaxPanX[1]);
|
|
this._panY = this._clamp(this._panY, this._minMaxPanY[0], this._minMaxPanY[1]);
|
|
},
|
|
|
|
scale : function(m, s) {
|
|
this._distance *= s;
|
|
this._distance = this._clamp(this._distance, this._minMaxDist[0], this._minMaxDist[1]);
|
|
}
|
|
};
|
|
/***********************************************************************/
|