// pxlNav Camera manager
// Written by Kevin Edzenga 2020; 2024
// Note : Since item implementation was done rather hastily,
// Triggering full screen overlays occures in the Camera class currently.
// This include LizardKing, StarField and InfiniteZoom
// The Low-Gravity Jump is triggered through the `User` class
//
// TODO : Move item functions from Camera and User to an `Item` class
import {
Vector2,
Vector3,
Quaternion,
Object3D,
Euler
} from "../../libs/three/three.module.min.js";
import { pxlUserSettings } from "../core/Options.js";
import { VERBOSE_LEVEL, COLLIDER_TYPE, CAMERA_EVENT } from "../core/Enums.js";
// TODO : Extend this damn monolith of a chunky boy
// Camera, Player Controller, Force Influence / Collision
/**
* Camera or pxlCamera class
* @alias pxlCamera
* @class
* @description Camera or pxlCamera class
*/
export class Camera{
constructor(){
// -- -- -- -- -- -- -- -- -- -- --
// -- Default Camera Settings -- -- --
// -- -- -- -- -- -- -- -- -- -- -- -- --
// User Height
this.standingHeight=1.75; // ~5'9" in meters
// Movement Speed Scalar
this.movementScalar=1.0;
// Max Movement Settings
this.hasMovementLimit=true;
this.movementMax = 100.0; // Meters per second
// Jump Height Scalar
this.jumpScalar=1.0;
// Scale of the User & Settings
// Standing Height, Jumping Height, Walking Speed, etc.
this.userScale=1.0;
// Max distance (Meters) up or down, like walking up and down stairs.
this.maxStepHeight=5;
// Once click/tap is done, how much does the last velocity ease out
// Velocity * this.cameraEasing
this.cameraEasing = [ .55, .45 ]; // [ PC, Mobile ]
// Touch screen sensitivity settings
this.touchMaxSensitivity = 800;
// The jumping impulse per frame
//this.cameraJumpImpulse= [ 0.045, 0.085 ];// [.035,.075]; // [ Grav, Low Grav ]
this.cameraJumpImpulse= [ .75, 1.5 ];// [.035,.075]; // [ Grav, Low Grav ]
this.cameraMaxJumpHold=[ 2.85, 2.0 ]; // Second; [ Grav, Low Grav ]
this.gravityCount=0;
this.gravityRate=0;
this.gravityMax=15.5; // Gravity at scale of 1 / avg human(1.8 meters) * 9.8mms = 5.44; But this is digital here, lower is lighter
this.gravityUPS=[.3,.15]; // Units Per Step(); Influence of M/S^2 .. I guess haha; [ Grav, Low Grav ]
// -- -- -- //
// -- -- -- //
// -- -- -- //
this.pxlAudio=null;
this.pxlTimer=null;
this.pxlAutoCam=null;
this.pxlEnv=null;
this.pxlColliders=null;
this.pxlUser=null;
this.pxlUtils=null;
this.pxlDevice=null;
this.pxlGuiDraws=null;
this.pxlQuality=null;
this.pxlOptions=null;
this.socket=null;
this.camera=null;
this.canMove=true;
this.HDRView=false;
// Run updateCamera
this.camUpdated=true;
this.cameraBooted=false;
// Calculation triggers
this.hasMoved = false; // Player has moved camera, WASD or Arrow Keys
this.hasRotated = false; // Player clicked and dragged mouse/touch to rotate camera
this.hasJumped = false; // Initial Jump Trigger
this.hasJumpLock = false; // Held jump upon landing, jump again after delay, this is the delay notification
this.hasGravity = false; // Player isn't on the ground; due to jump or running off a ledge
// -- -- --
// User-Input Movement & Look Scalars
// Only set when there is analog / float input; like gamepad thumbstick or touch 'joysticks'
this.userInputMoveScalar = {x:1,y:1};
this.userInputLookScalar = 1;
this.roomStandingHeight = { 'default' : this.standingHeight };
this.standingHeightGravInfluence=0;
this.standingMaxGravityOffset=.5; // Usage - ( standingHeight / standingHeightGravInfluence ) * standingMaxGravityOffset
this.walkBounceSeed=230;
this.walkBounceHeight = .3; // sin(walkBounce) * walkBounceHeight
this.walkBounce=0;
this.walkBouncePerc=0;
this.walkBounceRate=.025; // Bounce rate per frame; walkBounce + walkBounceRate
this.walkBounceEaseIn=.03; // Ease in bouncePerc rate up to 1; perc + easeIn
this.walkBounceEaseOut=.95; // Ease out bouncePerc scalar; perc * easeOut
this.posRotEasingThreshold=.01; // Velocity based calculations with any per frame scalar cut off value; val<posRotEasingThreshold ? 0
this.cameraMovement=[0,0]; // Left/Right, Forward/Back, Jump
this.cameraMovementEase=.85; // After key up, pre-frame rate to 0
this.cameraMoveLength=0;
this.cameraMoveLengthMult=.1; // cameraMoveLength scalar // ## check adding multiplier to keydown movement calculations
this.camPosBlend=.65; // Blend to previous position, easing movement
this.camRotXYZ=new Vector3(0,0,0);//new Vector3(0,0,0);
this.camRotPitch=new Vector2(0,0);
this.cameraJumpActive=false;
this.cameraAllowJump=true;
this.cameraJumpHeight=0;
this.cameraJumpVelocity=0;
this.cameraJumpVelocityEaseOut=.90; // Ease out Jump Button Influence after Button Released
this.cameraJumpInAir=false;
this.floorColliderInitialHit=false;
this.colliderValidityChecked=true; // Value shouldn't matter, but should Room Environments not set colliderValidity, assume checked initially
this.nearestFloorHit=new Vector3(0,0,0);
this.nearestFloorObjName=null;
this.nearestFloorHitPrev=new Vector3(0,0,0);
this.nearestFloorObjNamePrev=null;
this.gravitySourceActive=false;
this.gravityDirection=new Vector3( 0, -1, 0 );
this.gravityEaseOutRate=.50;
this.jump=0;
// TODO : Unsure if I'd rather a contant timer for all "allowed" jumps or not
// For now, this lock holds that the player should jump again when the timer is up
this.releaseJumpLockTime = 0;
this.releaseJumpLockDelay = .08; // Seconds dely between repeated jumping, its less jaring with a slight delay
this.runMain=true;
this.workerActive=false;
this.worker=null;
this.workerTransfers=false;
this.workerMessage=()=>{}; // Browser Compatibility
this.workerFunc=()=>{}; // Browser Compatibility
this.deviceKey=()=>{}; // Browser Compatibility
this.portalList={};
this.roomWarpZone=[];
this.colliderCurObjHit=null;
this.colliderPrevObjHit=null;
this.colliderValid=false;
this.colliderFail=false;
this.warpActive=false;
this.warpType=0;
this.warpObj=null;
this.warpTarget=null;
this.hotKeyTriggered=false;
this.eventCheckStatus=false;
this.proximityScaleTrigger=false;
this.colliderShiftActive=true;
this.colliderAdjustPerc=0;
this.colliderAdjustRate=.020;
// ## Move to Device.js
this.gyroGravity=[0,0,0];
this.cameraPose={
alpha:null,
beta:null,
gamma:null,
alphaOffset:0,
betaOffset:0,
gammaOffset:0,
orientation:window.orientation||0,
pos:[0,0,0],
posOffset:[0,0,0],
rx:()=>{return this.beta},
ry:()=>{return this.alpha},
rz:()=>{return this.gamma},
accelZeroed:[0,0,0],
accelCalibration:10,
accelCalDiv:1/10,
accelCalCount:0,
accelTotal:[0,0,0],
accelPrev:null,
accelDelta:[0,0,0],
accelClearDelta:()=>{this.accelDelta=[0,0,0];},
};
this.uniformScalars={
curExp:1.0,
darkBase:.1,
brightBase:0.5,
exposureUniformBase:1.0,
}
// TODO : This needs to be moved and integrated into fileIO and RoomClass
this.cameraPosLookAtNames = {
"default":{
pos:"position",
lookAt:"lookat",
},
"mobile":{
pos:"positionmobile",
lookAt:"lookatmobile",
},
"vr":{
pos:"positionvr",
lookAt:"lookatvr",
}
};
this.cameraPos=new Vector3(0,0,0);
this.cameraPrevPos=new Vector3(0,0,0);;
this.cameraPrevLookAt=new Vector3(0,0,0);;
this.cameraAim=new Vector3(0,0,1);
this.cameraAimTarget=new Vector3(0,0,0);;
this.cameraCross=new Vector3(1,0,0); // For Audio API faux 3d audio; UNUSED CURRENTLY
this.lookAtTargetActive=new Vector3(0,0,0);;
this.lookAtPerc=new Vector2(1,0);
this.lookAtLockPerc=0;
this.lookAtLockFader=0;
this.lookAtLockFadeRate=.01;
this.prevQuaternion=new Quaternion(); // Used in motionBlur shader calculations only
//this.prevWorldMatrix= new Matrix4(); // Only used if running higher quality motionBlur calculations, not needed
this.pi=3.141592653589793238462643383279;
this.touchSensitivityLimits = this.touchMaxSensitivity * this.pi;
// Event callbacks
this.callbacks={};
this.init();
}
/**
* Sets dependencies for the Camera class.
* @param {Object} pxlNav - The navigation object containing dependencies.
* @private
*/
setDependencies( pxlNav ){
this.pxlAudio=pxlNav.pxlAudio;
this.pxlTimer=pxlNav.pxlTimer;
this.pxlAutoCam=pxlNav.pxlAutoCam;
this.pxlEnv=pxlNav.pxlEnv;
this.pxlColliders=pxlNav.pxlColliders;
this.pxlUser=pxlNav.pxlUser;
this.pxlUtils=pxlNav.pxlUtils;
this.pxlDevice=pxlNav.pxlDevice;
this.pxlGuiDraws=pxlNav.pxlGuiDraws;
this.pxlQuality=pxlNav.pxlQuality;
this.pxlOptions=pxlNav.pxlOptions;
this.socket=pxlNav.socket;
}
// -- -- --
log( msg ){
if( this.verbose >= VERBOSE_LEVEL.INFO ){
console.log( msg );
}
}
warn( msg ){
if( this.verbose >= VERBOSE_LEVEL.WARN ){
console.warn( msg );
}
}
error( msg ){
if( this.verbose >= VERBOSE_LEVEL.ERROR ){
console.error( msg );
}
}
// -- -- --
/**
* Initializes the Camera class and Camera Worker.
*/
// TODO : Get worker implemented for whole of camera scripts
init(){
// Camera Service Worker - Ray Intersect Collision Detector
// TODO : Finish adding workers to monitor the Collider class and raycasting
var worker;
if( false && Worker ){
worker = new Worker("js/pxlBase/webWorkers/CameraWorker.js");
this.worker=worker;
//this.workerList.push( worker );
let tmpThis=this;
worker.onmessage= (event) => {
tmpThis.workerMessage(event.data);
};
worker.onerror= (event)=>{
tmpThis.workerMessage({type:"err", data:event.data});
};
// Transferables Status
let ab= new ArrayBuffer(1);
worker.postMessage(ab, [ab]); // ab.byteLength -> If transfer successful
this.workerTransfers=ab.byteLength==0; // Can transfer ArrayBuffers directly
// Message Functions
this.workerMessage= async ( msg )=>{
if( msg.type == "update" ){
tmpThis.updateMainValues( msg );
}
}
this.workerFunc= async ( type, state=null )=>{
tmpThis.worker.postMessage({type, state})
}
this.deviceKey= async ( key=false, state=false )=>{
if( typeof key == "number"){
}else if( typeof key == "string"){
let type="key";
tmpThis.worker.postMessage({type, key, state})
}
}
this.workerActive=true;
this.runMain=false;
this.workerFunc("init");
}
}
/**
* Updates main values from worker data.
* UNUSED CURRENTLY
* @param {Object} data - The data from the worker.
* @private
*/
updateMainValues( data ){
let {gravityRate, standingHeightGravInfluence, cameraJumpImpulse}=data;
if( gravityRate != null ){
this.gravityRate = gravityRate;
}
if( standingHeightGravInfluence != null ){
this.standingHeightGravInfluence = standingHeightGravInfluence;
}
if( cameraJumpImpulse != null ){
this.cameraJumpVelocity+=cameraJumpImpulse;
}
this.camUpdated=true;
}
////////////////////////////////////////////
// Update settings externally of Camera //
//////////////////////////////////////////
// Allow access to alter the Camera's internal settings
// Run these updates during the Room's `init()`, `start()`, or `build()` functions
// TODO : Allow per-Room settings to be set in the Room's FBX file or Room Class
// TODO : Move these to the User class when updated for pxlNav
// User is currently as it was for Antibody.club, so it needs to be updated for the pxlNav module
// Default is 1.75
/**
* Sets the user's standing height.
* @method
* @memberof pxlCamera
* @param {number} val - The user's standing height.
* @param {string} [roomName='default'] - The name of the room.
* @example
* // Set the user's standing height to 1.75 meters.
* this.pxlCamera.setUserHeight( 1.75 );
*/
setUserHeight( val, roomName="default" ){
val = Math.max( val, 0.01 );
if( !this.roomStandingHeight.hasOwnProperty(roomName) ){
this.roomStandingHeight[roomName]=this.standingHeight;
}
if( roomName=="default" ){
this.standingHeight=val;
}
this.roomStandingHeight[roomName]=val;
}
// Default is 5
/**
* Sets the user's maximum step height.
* @method
* @memberof pxlCamera
* @param {number} val - The user's maximum step height.
* @example
* // Set the user's maximum step height to 5 meters.
* this.pxlCamera.setMaxStepHeight( 5 );
*/
setMaxStepHeight( val ){
val = Math.max( val, 0.01 );
this.maxStepHeight=val;
}
// Default is 1
/**
* Sets the user's scale.
* @method
* @memberof pxlCamera
* @param {number} val - The user's scale.
* @example
* // Set the user's scale to 1.
* this.pxlCamera.setUserScale( 1 );
*/
setUserScale( val ){
val = Math.max( val, 0.01 );
this.userScale=val;
}
// Default is 1
/**
* Sets the user's movement scalar.
* @method
* @memberof pxlCamera
* @param {number} val - The user's movement scalar.
* @example
* // Set the user's movement scalar to 1.
* this.pxlCamera.setMovementScalar( 1 );
*/
setMovementScalar( val ){
val = Math.max( val, 0.01 );
this.movementScalar=val;
}
// Default is 10
/**
* Sets the user's maximum movement speed.
* @method
* @memberof pxlCamera
* @param {number} val - The user's maximum movement speed.
* @example
* // Set the user's maximum movement speed to 10 meters per second.
* this.pxlCamera.setMovementMax( 10 );
*/
setMovementMax( val ){
val = Math.max( val, 0.01 );
this.movementMax=val;
}
// Default is 0.85
/**
* Sets the user's movement easing rate.
* @method
* @memberof pxlCamera
* @param {number} val - The user's movement easing rate.
* @example
* // Set the user's movement easing rate to 0.85.
* this.pxlCamera.setMovementEase( 0.85 );
*/
setMovementEase( val ){
val = Math.min( 1, Math.max( val, 0.01 ) );
this.cameraMovementEase=val;
}
// Default is 0.75
/**
* Sets the jump scalar.
* @method
* @memberof pxlCamera
* @param {number} val - The jump scalar.
* @example
* // Set the jump scalar to 0.75.
* this.pxlCamera.setJumpScalar( 0.75 );
*/
setPositionBlend( val ){
val = Math.min( 1, Math.max( val, 0.01 ) );
this.camPosBlend=val;
}
// Default is 0.1
/**
* Sets the user's movement multiplier.
* @method
* @memberof pxlCamera
* @param {number} val - The user's movement multiplier.
* @example
* // Set the user's movement multiplier to 0.1.
* this.pxlCamera.setInputMovementMult( 0.1 );
*/
setInputMovementMult( val ){
val = Math.max( val, 0.01 );
this.cameraMoveLengthMult=val;
}
// -- -- --
// Default is 1
/**
* Sets the user's jump scalar.
* @method
* @memberof pxlCamera
* @param {number} val - The user's jump scalar.
* @example
* // Set the user's jump scalar to 1.
* this.pxlCamera.setJumpScalar( 1 );
*/
setJumpScalar( val ){
val = Math.max( val, 0.01 );
this.jumpScalar=val;
}
// Default is 0.75
/**
* Sets the user's jump impulse.
* @method
* @memberof pxlCamera
* @param {number} val - The user's jump impulse.
* @example
* // Set the user's jump impulse to 0.75.
* this.pxlCamera.setJumpImpulse( 0.75 );
*/
setJumpImpulse( val ){
val = Math.max( val, 0.01 );
this.cameraJumpImpulse[0]=val;
}
// Default is 2.85
/**
* Sets the user's maximum jump hold.
* @method
* @memberof pxlCamera
* @param {number} val - The user's maximum jump hold.
* @example
* // Set the user's maximum jump hold to 2.85.
* this.pxlCamera.setJumpHoldMax( 2.85 );
*/
setJumpHoldMax( val ){
val = Math.max( val, 0.01 );
this.cameraMaxJumpHold[0]=val;
}
// Default is 0.08
/**
* Sets the user's jump repeat delay.
* @method
* @memberof pxlCamera
* @param {number} val - The user's jump repeat delay.
* @example
* // Set the user's jump repeat delay to 0.08.
* this.pxlCamera.setJumpRepeatDelay( 0.08 );
*/
setJumpRepeatDelay( val ){
val = Math.max( val, 0.01 );
this.releaseJumpLockDelay=val;
}
// -- -- --
// Default is 0.85
/**
* Sets the user's camera movement easing.
* @method
* @memberof pxlCamera
* @param {number} val - The user's camera movement easing.
* @example
* // Set the user's camera movement easing to 0.85.
* this.pxlCamera.setCameraMoveEasing( 0.85 );
*/
setCameraRotateEasing( val ){
if( !Array.isArray(val) ){
if( typeof val == "number" ){
val=[val,val];
this.warn("Warning : Camera.setCameraEasing() expects an array of two numeric values, [PC Easing 0-1, Mobile Easing 0-1]; Default is [.55,.45]");
}else{
this.error("Error : Camera.setCameraEasing() unexpected values type; expecting an array of two numeric values, [PC Easing 0-1, Mobile Easing 0-1]; Default is [.55,.45]");
}
}
this.cameraEasing=val;
}
// Touch Sensitivity should be a pixel-to-device reasonable value
// Default is 500, being 500 pixels dragging range to look around
/**
* Sets the user's touch sensitivity.
* @method
* @memberof pxlCamera
* @param {number} val - The user's touch sensitivity.
* @example
* // Set the user's touch sensitivity to 500.
* this.pxlCamera.setTouchSensitivity( 500 );
*/
setTouchSensitivity( val ){
if(val<=0){
val=1;
}
this.touchMaxSensitivity=val;
this.touchSensitivityLimits = this.touchMaxSensitivity * this.pi;
}
/**
* Sets the user's gravity rate.
* @method
* @memberof pxlCamera
* @param {number} val - The user's gravity rate.
* @example
* // Set the user's gravity rate to 0.3
* this.pxlCamera.setGravityRate( 0.3 );
*/
setGravityRate( val ){
if(val<=0){
val=1;
}
this.gravityRate=val;
}
// Assume 1 unit is 1 meter/second^2
// But default is 2.5, so it's a bit lighter than Earth's gravity
/**
* Sets the user's gravity rate.
* @method
* @memberof pxlCamera
* @param {number} val - The user's gravity rate.
* @example
* // Set the user's gravity rate to 2.5
* this.pxlCamera.setGravityRate( 2.5 );
*/
setGravityMax( val ){
if(val<=0){
val=1;
}
this.gravityMax=val;
}
// Set walking bounce settings
// Default is 230
/**
* Sets the user's walk bounce seed.
* @method
* @memberof pxlCamera
* @param {number} val - The user's walk bounce seed.
* @example
* // Set the user's walk bounce seed to 230.
* this.pxlCamera.setWalkBounceSeed( 230 );
*/
setWalkBounceHeight( val ){
if(val<=0){
val=0;
}
this.walkBounceHeight=val;
}
// Default is 0.025
/**
* Sets the user's walk bounce rate.
* @method
* @memberof pxlCamera
* @param {number} val - The user's walk bounce rate.
* @example
* // Set the user's walk bounce rate to 0.025.
* this.pxlCamera.setWalkBounceRate( 0.025 );
*/
setWalkBounceRate( val ){
if(val<=0){
val=0.0001;
}
this.walkBounceRate=val;
}
// Default is 0.03
/**
* Sets the user's walk bounce ease in.
* @method
* @memberof pxlCamera
* @param {number} val - The user's walk bounce ease in.
* @example
* // Set the user's walk bounce ease in to 0.03
* this.pxlCamera.setWalkBounceEaseIn( 0.03 );
*/
setWalkBounceEaseIn( val ){
val = Math.min( 1, Math.max( val, 0.0001 ) );
this.walkBounceEaseIn=val;
}
// Default is 0.95
/**
* Sets the user's walk bounce ease out.
* @method
* @memberof pxlCamera
* @param {number} val - The user's walk bounce ease out.
* @example
* // Set the user's walk bounce ease out to 0.95
* this.pxlCamera.setWalkBounceEaseOut( 0.95 );
*/
setWalkBounceEaseOut( val ){
val = Math.min( 1, Math.max( val, 0.01 ) );
this.walkBounceEaseOut=val;
}
// -- -- --
// Set camera values from `pxlUserSettings` structure
// Should custom entries have been added, they wont be processed
// TODO : This is a bit messy at the moment
// TODO : Add a per-room userSettings with lookup into the `pxlUserSettings` structure
// Since with this set structure, it doesn't need to be individual variables
/**
* Sets the user's settings.
* @method
* @memberof pxlCamera
* @param {Object} userSettingsObject - The user's settings object.
* @example
* // Set the user's settings.
* import { pxlUserSettings } from "../core/Options.js";
* let userSettingsObject = Object.assign({}, pxlUserSettings);
* this.pxlCamera.setUserSettings( userSettingsObject );
*/
setUserSettings( userSettingsObject ){
// User & collider step height settings
if( userSettingsObject.hasOwnProperty("height") ){
if( userSettingsObject.height.hasOwnProperty("standing") ){
this.setUserHeight( userSettingsObject.height.standing );
}
if( userSettingsObject.height.hasOwnProperty("stepSize") ){
this.setMaxStepHeight( userSettingsObject.height.stepSize );
}
}
// -- -- --
// Camera movement settings
if( userSettingsObject.hasOwnProperty("movement") ){
if( userSettingsObject.movement.hasOwnProperty("scalar") ){
this.setMovementScalar( userSettingsObject.movement.scalar );
}
if( userSettingsObject.movement.hasOwnProperty("max") ){
this.setMovementMax( userSettingsObject.movement.max );
}
if( userSettingsObject.movement.hasOwnProperty("easing") ){
this.setMovementEase( userSettingsObject.movement.easing );
}
}
// -- -- --
// Head bounce settings
if( userSettingsObject.hasOwnProperty("headBounce") ){
if( userSettingsObject.headBounce.hasOwnProperty("height") ){
this.setWalkBounceHeight( userSettingsObject.headBounce.height );
}
if( userSettingsObject.headBounce.hasOwnProperty("rate") ){
this.setWalkBounceRate( userSettingsObject.headBounce.rate );
}
if( userSettingsObject.headBounce.hasOwnProperty("easeIn") ){
this.setWalkBounceEaseIn( userSettingsObject.headBounce.easeIn );
}
if( userSettingsObject.headBounce.hasOwnProperty("easeOut") ){
this.setWalkBounceEaseOut( userSettingsObject.headBounce.easeOut );
}
}
// -- -- --
// Jump settings
if( userSettingsObject.hasOwnProperty("jump") ){
if( userSettingsObject.jump.hasOwnProperty("impulse") ){
this.setJumpScalar( userSettingsObject.jump.impulse );
}
if( userSettingsObject.jump.hasOwnProperty("holdMax") ){
this.setJumpHoldMax( userSettingsObject.jump.holdMax );
}
if( userSettingsObject.jump.hasOwnProperty("repeatDelay") ){
this.setJumpRepeatDelay( userSettingsObject.jump.repeatDelay );
}
}
// -- -- --
// Gravity settings
// From a Jump or running off a ledge
if( userSettingsObject.hasOwnProperty("gravity") ){
if( userSettingsObject.gravity.hasOwnProperty("ups") ){
this.setGravityRate( userSettingsObject.gravity.ups );
}
if( userSettingsObject.gravity.hasOwnProperty("max") ){
this.setGravityMax( userSettingsObject.gravity.max );
}
}
}
/////////////////////////
// Main runtime loop //
///////////////////////
/**
* Main step function to update camera state.
* @private
*/
step(){
// Update camera position with out gravity, jump, or collider influences.
// Simply apply initial frame movement vectors
if(this.pxlDevice.directionKeyDown){
this.updateMovement(this.pxlTimer.prevMS);
}
if( this.runMain ){
if( this.hasJumpLock && this.pxlTimer.runtime > this.releaseJumpLockTime ){
this.hasJumpLock = false;
this.hasGravity = false;
this.cameraAllowJump = true;
this.camInitJump();
}
if( this.hasGravity && this.cameraJumpActive ){
this.camJump(this.pxlTimer.prevMS);
}else if(this.cameraJumpVelocity>0 ){
this.killJumpImpulse();
}
}
// Check if camera calculations should be ran
this.camUpdated= this.camUpdated || this.hasMoved || this.hasRotated || this.hasGravity || this.cameraMovement[0]!=0 || this.cameraMovement[1]!=0 ;// || this.pxlDevice.cursorLockActive;
this.updateCamera();
// Update Shaders to Camera Position / Rotation changes
this.lowQualityUpdates();
this.midQualityUpdates();
this.eventCheck();
}
/**
* Checks for events based on environment triggers.
* Currently only checking for Ground Collider, Room Warps, and Portals
* @private
*/
eventCheck(){
if( this.colliderValid && this.eventCheckStatus){
// Camera Translate Events don't need further calculatons; Room Warps and Portals
if( this.eventTrigger(this.nearestFloorObjName) ){
this.warpEventTriggered(1, this.nearestFloorObjName);
//return;
}
}
}
/**
* Updates device values based on velocity easing magnitude.
* @param {number} velEaseMag - The current velocity magnitude.
* @private
*/
updateDeviceValues( velEaseMag ){
if(!this.pxlQuality.settings.leftRight){
let tankRotate=-this.cameraMovement[0];
if(!this.pxlDevice.touchMouseData.active){
this.pxlDevice.touchMouseData.velocity.x+=tankRotate;
//this.pxlDevice.touchMouseData.velocityEase.x+=tankRotate;
}
this.pxlDevice.touchMouseData.netDistance.x+=tankRotate*4.0;
}
//let stillMoving=false;
// PC Mouse Movement
if(this.pxlDevice.touchMouseData.velocity!=null && this.pxlDevice.mobile==0){
if(velEaseMag<this.posRotEasingThreshold){
this.pxlDevice.touchMouseData.velocity.multiplyScalar(0);
//this.pxlDevice.touchMouseData.velocityEase.multiplyScalar(0);
}else{
let curEasing = this.cameraEasing[ (this.pxlDevice.mobile?1:0) ];
this.pxlDevice.touchMouseData.velocity.multiplyScalar( curEasing );
//this.pxlDevice.touchMouseData.velocityEase.multiplyScalar( curEasing );
}
this.pxlDevice.touchMouseData.netDistance.add( this.pxlDevice.touchMouseData.velocity.clone().multiply( this.pxlDevice.touchMouseData.moveMult ) );
}
}
//////////////////////////////////////////
// Gyroscope Enabled Device Functions //
////////////////////////////////////////
/**
* Builds device-pose monitors for gyroscope-enabled devices.
* CURRENTLY UNWORKING
* NOTE : Development in-progress through 'Device.js'
* @private
*/
buildDeviceMonitors(){
let camObject=this;
//window.addEventListener('deviceorientation', (e)=>{camObject.devicePoseData(camObject,e)} );
//window.addEventListener('orientationchange', (e)=>{camObject.deviceOrientationData(camObject,e)} );
//window.addEventListener('devicemotion', (e)=>{camObject.deviceMotionData(camObject,e)} );
//%=
//gyroscope=new Gyroscope({frequency:10});
//gyroscope.addEventListener('reading',gyroPoseData);
//gyroscope.start();
//window.addEventListener('devicemotion', deviceMotionData);
//window.addEventListener('orientationchange', devicePoseChange); // Don't know when this ever fires, docs seem like it should run tho
// Based around w3.org's Accelerometer builder
/* navigator.permissions.query({ name: 'accelerometer' }).then(result => {
if (result.state === 'denied') {
console.log('Permission to use accelerometer sensor is denied.');
return;
}
let acl = new Accelerometer({frequency: 10});
let max_magnitude = 0;
acl.addEventListener('activate', () => console.log('Ready to measure.'));
acl.addEventListener('error', error => console.log(`Error: ${error.name}`));
acl.addEventListener('reading', () => {
let magnitude = Math.hypot(acl.x, acl.y, acl.z);
if (magnitude > max_magnitude) {
max_magnitude = magnitude;
console.log(`Max magnitude: ${max_magnitude} m/s2`);
}
});
acl.start();
});*/
//%
}
/*
gyroPoseData(camObj,e){
let x=gyroscope.x;
let y=gyroscope.y;
let z=gyroscope.z;
let prevGyro=[...this.pxlDevice.gyroGravity];
this.pxlDevice.gyroGravity=[x,y,z];
accumGravity=[accumGravity[0]+x-prevGyro[0],accumGravity[1]+y-prevGyro[1],accumGravity[2]+z-prevGyro[2]];
}
deviceMotionData(camObj,e){
let acc=e.acceleration;//IncludingGravity;
//let ag=e.accelerationIncludingGravity;
if(camObj.cameraPose.accelCalCount<camObj.cameraPose.accelCalibration){
camObj.cameraPose.accelCalCount+=1;
camObj.cameraPose.accelZeroed[0]+=acc.x;
camObj.cameraPose.accelZeroed[1]+=acc.y;
camObj.cameraPose.accelZeroed[2]+=acc.z;
if(camObj.cameraPose.accelCalCount==camObj.cameraPose.accelCalibration){
camObj.cameraPose.accelZeroed[0]*=camObj.cameraPose.accelCalDiv;
camObj.cameraPose.accelZeroed[1]*=camObj.cameraPose.accelCalDiv;
camObj.cameraPose.accelZeroed[2]*=camObj.cameraPose.accelCalDiv;
}
}
camObj.cameraPose.accelDelta[0]=acc.x-camObj.cameraPose.accelZeroed[0];
camObj.cameraPose.accelDelta[1]=acc.y-camObj.cameraPose.accelZeroed[1];
camObj.cameraPose.accelDelta[2]=acc.z-camObj.cameraPose.accelZeroed[2];
camObj.cameraPose.accelTotal[0]+=acc.x-camObj.cameraPose.accelZeroed[0];
camObj.cameraPose.accelTotal[1]+=acc.y-camObj.cameraPose.accelZeroed[1];
camObj.cameraPose.accelTotal[2]+=acc.z-camObj.cameraPose.accelZeroed[2];
}
devicePoseData(camObj,e){
if(e.alpha!==null){
camObj.abs=e.absolute;
camObj.cameraPose.gamma=e.gamma; // Yaw
camObj.cameraPose.beta=e.beta; // Pitch
camObj.cameraPose.alpha=e.alpha; // Roll
camObj.cameraPose.alphaOffset=e.alphaOffset||0; // Roll
}
}
deviceOrientationData(camObj,e){
camObj.cameraPose.orientation=window.orientation||0;
}
*/
/////////////////////////////////////////////////////////////////////
// Set Camera Position / Look At Functions; Room Warps & Portals //
///////////////////////////////////////////////////////////////////
/**
* Updates camera matrices.
* Updates - Projection Matrix, Matrix World, & World Matrix
* @example
* import { Object3D } from "three";
* let emptyObject=new Object3D();
*
* emptyObject.position.set(10,10,0);
*
* this.pxlCamera.setTransform(emptyObject.position);
*
* // Update camera matrices.
* this.pxlCamera.updateCameraMatrices();
*/
updateCameraMatrices(){
this.camera.updateProjectionMatrix();
this.camera.updateMatrixWorld();
this.camera.updateWorldMatrix();
}
/**
* Resets camera calculations to a Vector3.
* @param {Vector3} newPosition - The new position for the camera.
* @example
* import { Vector3 } from "three";
* let newPos=new Vector3(20,5,15);
* this.pxlCamera.resetCameraCalculations(newPos);
*/
resetCameraCalculations( newPosition ){
this.cameraMovement[0] = 0;
this.cameraMovement[1] = 0;
this.pxlDevice.touchMouseData.curFadeOut.multiplyScalar(0);
this.pxlDevice.touchMouseData.velocity.multiplyScalar(0);
this.pxlDevice.touchMouseData.netDistance.set(0,0);
this.camera.position.copy( newPosition );
this.updateCameraMatrices();
this.cameraPos.copy( newPosition );
this.cameraPrevPos.copy( newPosition );
// Force collision detection
this.colliderCurObjHit=null;
this.colliderPrevObjHit=null;
this.camUpdated=true; // Forces next frame update
this.hasMoved=true; // Forces next frame update
}
/**
* Sets the field-of-view for the camera.
* @param {number} fov - The field-of-view.
* @example
* // Set the field-of-view to 75.
* this.pxlCamera.setFOV( 75 );
*/
setFOV( fov ){
this.camera.fov=fov;
this.camera.updateProjectionMatrix();
this.camUpdated=true;
}
/**
* Sets camera stats including FOV, aspect ratio, near and far clipping planes.
* Used when changing Rooms
* @param {number} fov - The field of view.
* @param {number} aspect - The aspect ratio.
* @param {number} near - The near clipping plane.
* @param {number} far - The far clipping plane.
* @example
* // Set the camera stats.
* // FOV: 75, Aspect: 1.33, Near: 0.1, Far: 1000
* this.pxlCamera.setStats( 75, 1.33, 0.1, 1000 );
*/
setStats( fov, aspect, near, far ){
// TODO : Aspect is weird, I need to work out better calculations for this
//this.camera.aspect=aspect;
this.camera.near=near;
this.camera.far=far;
this.setFOV(fov);
}
setAspect( aspect ){
this.camera.aspect=aspect;
this.camera.updateProjectionMatrix();
//this.camUpdated=true;
}
/**
* Sets the camera transform to a specific position and lookAt target.
* For camera position changes, portals, and room warps
* @param {Vector3} pos - The position to set the camera.
* @param {Vector3} [lookAt=null] - The lookAt target.
* @example
* import { Vector3 } from "three";
* let pos=new Vector3(10,15,15);
* let lookAt=new Vector3(0,5,0);
*
* this.pxlCamera.setTransform(pos, lookAt);
*/
setTransform(pos, lookAt=null){ // Vector3, Vector3
this.resetCameraCalculations(pos); // Reinitiates Camera; Forces collision detection, Kills user inputs
if(lookAt){
this.cameraAimTarget.position.copy( lookAt );
this.camera.lookAt(lookAt);
this.cameraPrevLookAt.copy( lookAt );
this.updateCameraMatrices();
this.pxlDevice.touchMouseData.initialQuat=this.camera.quaternion.clone();
}
this.resetGravity();
this.camUpdated=true; // Forces next frame update
}
/**
* Best used without a `lookAt` target to allow the object's rotation to be adopted.
* If you just want to move the camera without rotational changes -or- to an object with a lookAt, it's better to use `setTransform`
* @param {Object3D} obj - The object to set the camera to.
* @param {Object3D|string} [lookAt=null] - The lookAt Camera Position Name or target object.
* If a string is provided, it checks for the camera position if it exists in the Room,
* Ussuall set in your FBX file.
* @example
* import { Object3D } from "three";
* let obj=new Object3D();
* obj.position.set(10,15,15);
*
* this.pxlCamera.setToObj(obj);
*/
setToObj(obj, lookAt=null){ // Object3D, Object3D
this.resetCameraCalculations( obj.position ); // Reinitiates Camera; Forces collision detection, Kills user inputs
// If no lookat, adopt Object rotation
if(lookAt){
let toLookAt=lookAt.position.clone();
this.cameraAimTarget.position.copy( toLookAt );
this.camera.lookAt(toLookAt);
this.cameraPrevLookAt.copy( toLookAt );
this.updateCameraMatrices();
this.pxlDevice.touchMouseData.initialQuat=this.camera.quaternion.clone();
}else{
this.pxlDevice.touchMouseData.initialQuat=obj.quaternion.clone();
this.camera.setRotationFromQuaternion(this.pxlDevice.touchMouseData.initialQuat);
this.updateCameraMatrices();
}
this.resetGravity();
this.camUpdated=true; // Forces next frame update
this.hasMoved=true;
this.hasRotated=true;
this.colliderCheck( obj.position );
this.nearestFloorObjName=null;
}
/**
* Warps the camera to a specific room.
* @param {string} roomName - The name of the room to warp to.
* @param {boolean} [start=false] - Whether to run the room's `start()` function.
* @param {Object3D} [objTarget=null] - The target object in the room.
* @example
* // Warp the camera to the default location in "OutletEnvironment" room.
* this.pxlCamera.warpToRoom( "OutletEnvironment", true );
*
* // Warp to the 'aboutMe' camera position in "CampfireEnvironment" room.
* // Note, camera positions are set in your FBX by the camera's group name.
* this.pxlCamera.warpToRoom( "CampfireEnvironment", true, "aboutMe" );
*/
warpToRoom(roomName, start=false, objTarget=null){
let roomKeys = Object.keys(this.pxlEnv.roomSceneList);
let roomEnv = this.pxlEnv.roomSceneList[this.pxlEnv.currentRoom]
objTarget = objTarget || roomEnv.defaultCamLocation || "";
objTarget = objTarget.toLowerCase()
let camLocName = roomName.toLowerCase();
let hasCurrentRoom = this.pxlEnv.roomSceneList.hasOwnProperty( this.pxlEnv.currentRoom );
if( roomEnv && !roomKeys.includes(roomName) && roomEnv.camLocation.hasOwnProperty(camLocName) ){
objTarget = camLocName;
roomName = this.pxlEnv.currentRoom;
}else{
if( hasCurrentRoom){
this.pxlEnv.roomSceneList[this.pxlEnv.currentRoom].stop();
}
roomEnv = this.pxlEnv.roomSceneList[roomName];
};
let prevRoom=this.pxlEnv.currentRoom;
let holdCamera=false;
if( hasCurrentRoom && this.pxlEnv.roomSceneList[this.pxlEnv.currentRoom].hasOwnProperty( "camHoldWarpPos" )){
holdCamera = this.pxlEnv.roomSceneList[this.pxlEnv.currentRoom].camHoldWarpPos;
}
this.pxlEnv.currentRoom=roomName;
this.pxlAutoCam.curRoom=roomName;
let isMainRoom=roomName==this.pxlEnv.mainRoom;
//this.pxlEnv.delayPass.uniforms.roomComposer.value= isMainRoom ? 0 : 1;
if( this.pxlUser.iZoom ){
let tDiff= isMainRoom ? this.pxlEnv.roomComposer : this.pxlEnv.mapComposer;
let tDiffPrev= isMainRoom ? this.pxlEnv.mapComposer: this.pxlEnv.roomComposer;
this.pxlEnv.delayPass.uniforms.tDiffusePrev.value= tDiff.renderTarget1.texture;
this.pxlEnv.delayPass.uniforms.tDiffusePrevRoom.value= tDiffPrev.renderTarget1.texture;
setTimeout( ()=>{
if( prevRoom != roomName ){
if( isMainRoom ){
this.pxlEnv.roomComposer.reset();
}else{
this.pxlEnv.mapComposer.reset();
}
}
setTimeout( ()=>{
this.pxlEnv.mapComposerWarpPass.needsSwap=false;
},500);
},100);
}
//this.pxlEnv.delayPass.uniforms.tDiffusePrev.value= roomName==this.pxlEnv.mainRoom ? this.pxlEnv.mapComposer.renderTarget1.texture : this.pxlEnv.roomComposer.renderTarget1.texture;
//if(roomName!=this.pxlEnv.mainRoom || start){
if( start ){
if( !roomEnv ){
this.warn("pxlCamera.warpToRoom(); pxlRoom not found - "+this.pxlEnv.currentRoom);
return;
}
if( roomName != prevRoom ){
roomEnv.start();
}
this.pxlEnv.roomRenderPass.scene=roomEnv.scene;
let camLocName = objTarget.toLowerCase();
if( roomEnv.camLocation.hasOwnProperty( camLocName ) ){
let posName = this.cameraPosLookAtNames["default"].pos;
let lookAtName = this.cameraPosLookAtNames["default"].lookAt;
if( this.pxlDevice.mobile ){
if( roomEnv.camLocation[ camLocName ].hasOwnProperty( this.cameraPosLookAtNames["mobile"].pos ) ){
posName=this.cameraPosLookAtNames["mobile"].pos;
}
if( roomEnv.camLocation[ camLocName ].hasOwnProperty( this.cameraPosLookAtNames["mobile"].lookAt ) ){
lookAtName=this.cameraPosLookAtNames["mobile"].lookAt;
}
}
let toPos = roomEnv.camLocation[ camLocName ][ posName ];
let toLookAt = roomEnv.camLocation[ camLocName ][ lookAtName ];
this.setTransform( toPos, toLookAt );
}else if( roomEnv.camInitPos && roomEnv.camInitLookAt && ( !holdCamera || !this.pxlEnv.postIntro || this.hotKeyTriggered ) ){
this.setTransform( roomEnv.camInitPos, roomEnv.camInitLookAt );
this.hotKeyTriggered=false;
}
}else{
if( !holdCamera || !this.pxlEnv.postIntro || this.hotKeyTriggered ){
if(objTarget!=null){
this.setToObj(objTarget);
}else{
this.setTransform( roomEnv.camReturnPos, roomEnv.camReturnLookAt );
}
this.hotKeyTriggered=false;
}
}
this.pxlGuiDraws.prepArtistInfo( roomEnv.getArtistInfo() );
this.camUpdated=true;
/*this.pxlEnv.mapComposerWarpPass.enabled=!this.pxlEnv.mapComposerWarpPass.enabled;
this.pxlEnv.mapComposer.render();
this.pxlEnv.mapComposerWarpPass.enabled=!this.pxlEnv.mapComposerWarpPass.enabled;
this.pxlEnv.mapComposer.render();*/
let curFOV = roomEnv.pxlCamFOV[ this.pxlDevice.mobile ? 'MOBILE' : 'PC' ];
this.camera.fov=curFOV;
this.camera.zoom=roomEnv.pxlCamZoom;
this.camera.aspect=roomEnv.pxlCamAspect;
this.camera.near=roomEnv.pxlCamNearClipping;
this.camera.far=roomEnv.pxlCamFarClipping;
this.camera.updateProjectionMatrix();
let standingHeight=this.getUserHeight();
this.emitCameraTransforms( this.camera.position.clone(), standingHeight, true );
// Camera assumes the player is warping to safe ground
// So it will treat the position as the nearest floor hit
// This was causing initial jumping and movement to use the camera position as the floor
// This will drop the player from any height to the nearest floor using gravity when warping to a room
// TODO : Move this to be Room specific
if( this.canMove ){
this.colliderValid=false;
this.hasGravity=true;
}
this.pxlAutoCam.checkStatus();
}
/**
* Get a snapshot of the room to use as the diffuse texture for the warp effect.
* @private
*
*/
warpToRoomSnapshot(roomName){
this.pxlEnv.currentRoom=roomName;
let roomEnv=this.pxlEnv.roomSceneList[this.pxlEnv.currentRoom];
let curFOV = roomEnv.pxlCamFOV[ this.pxlDevice.mobile ? 'MOBILE' : 'PC' ];
this.camera.fov=curFOV;
this.camera.zoom=roomEnv.pxlCamZoom;
this.camera.aspect=roomEnv.pxlCamAspect;
this.camera.near=roomEnv.pxlCamNearClipping;
this.camera.far=roomEnv.pxlCamFarClipping;
this.camera.updateProjectionMatrix();
this.setTransform( roomEnv.camThumbPos, roomEnv.camThumbLookAt );
let standingHeight=this.getUserHeight();
this.emitCameraTransforms( this.camera.position.clone(), standingHeight, true );
}
// -- -- -- -- -- -- -- -- -- -- -- -- -- -- //
//
/**
* Initiates fast travel to a specific location.
* This begins the warp effect process,
* It doesn't affect camera upon triggering, just queuing the warp event
*
* *Implementation has been disabled until further development*
*
* @param {number} [hotkey=0] - The hotkey for the fast travel location.
*
*/
fastTravel(hotkey=0){
if( this.pxlAutoCam.enabled ){
return;
}
if( this.pxlAutoCam.active || this.pxlAutoCam.autoCamActive ){
this.pxlAutoCam.preAutoCamToggle();
}
this.hotKeyTriggered=true;
if( hotkey == 0 ){ // Lobby
//this.warpEventTriggered( 1, this.pxlEnv.mainRoom, 'init' );
this.warpEventTriggered( 1, this.pxlEnv.currentRoom, 'init' );
}
// Hotkeys are set for a specific scene, make 3d scene file dependant
return;
if( hotkey == 1 ){ // Canyon
//this.warpEventTriggered( 1, this.pxlEnv.mainRoom, this.portalList['Portal_8'] );
}else if( hotkey == 2 ){ // Dance Hall
//this.warpEventTriggered( 1, "ShadowPlanet", 'init' );
}else if( hotkey == 3 ){ // Sunflower Room
//this.warpEventTriggered( 1, this.pxlEnv.mainRoom, this.portalList['Portal_0'] );
}
}
////////////////////////////////////
// Camera Jumping Functions //
//////////////////////////////////
/**
* Handles the camera jump key press or release.
* @param {boolean} [jumpKeyIsDown=false] - Whether the jump (Default : Space) key is pressed.
* @example
* // Handle the camera jump key press or release.
* // Player has pressed the jump key
* this.pxlCamera.camJumpKey( true );
*
* // Player has released the jump key
* this.pxlCamera.camJumpKey( false );
*/
camJumpKey( jumpKeyIsDown=false ){
if( jumpKeyIsDown ){ // Space is down
this.camInitJump();
}else{ // Space is up
if(this.cameraJumpActive){ // Space
this.cameraJumpActive=false;
}
this.cameraAllowJump=true;
this.hasJumpLock=false; // Prevent repeated jumping if Space held down after landing
}
}
/**
* Initializes the jump values for the camera.
* @private
*/
camInitJump(){
// Link static camera to prevent jumping as well
if( !this.canMove ){return;}
if( !this.hasGravity && this.cameraAllowJump ){
this.pxlDevice.keyDownCount[2]=this.pxlTimer.prevMS;
this.cameraAllowJump=false; // Prevent jump spamming up stacked colliders; this may be desired for ladders
this.cameraJumpActive=true;
this.cameraJumpInAir=true;
this.hasGravity=true;
this.gravityRate=0;
this.cameraJumpVelocity=this.cameraJumpImpulse[this.pxlUser.lowGrav] * this.userScale;
if( this.hasJumpLock ){
this.hasJumpLock=false;
this.nearestFloorHit=this.nearestFloorHitPrev;
}
}
}
/**
* Handles the camera jump step.
* Step the jump while impulse isn't 0.
* @param {number} curTime - The current time.
* @private
*/
camJump(curTime){
let timeDelta= (curTime-this.pxlDevice.keyDownCount[2]) ;
let fpsRateAdjust=1;//Math.min(1, 1/(20*this.pxlTimer.msRunner.y));
// let jumpPerc=Math.min(1, timeDelta/(this.cameraMaxJumpHold[this.pxlUser.lowGrav]*fpsRateAdjust) );
let jumpPerc=Math.min(1, timeDelta / (this.cameraMaxJumpHold[this.pxlUser.lowGrav] ) ) ;
if(this.cameraJumpActive){
let jumpRate=jumpPerc ;
if(jumpRate==1){
this.cameraJumpActive=false;
}else{
jumpRate=(1-jumpRate)*(1-jumpRate);
jumpRate=jumpRate* ( jumpRate*.5+.5);
}
this.cameraJumpVelocity+=Math.max(0, jumpRate) * this.cameraJumpImpulse[this.pxlUser.lowGrav] * this.jumpScalar * this.pxlTimer.deltaTime;
}
this.cameraJumpVelocity*=(1-jumpPerc);//*.5+.5;
if( jumpPerc==1 ){
this.cameraJumpActive=false;
}
}
/**
* Kills the jump impulse.
* Space released before max jump
* @example
* // Kill the jump impulse.
* this.pxlCamera.killJumpImpulse();
*/
killJumpImpulse( scalar=1){
let toImpulse=this.cameraJumpVelocity * scalar * this.cameraJumpVelocityEaseOut;
this.cameraJumpVelocity= toImpulse>.1 ? toImpulse : 0;
this.workerFunc( "killJumpImpulse" );
}
/////////////////////////
// Gravity Functions //
///////////////////////
/**
* Updates the gravity for the camera.
* Gravity is updated and offset landing height with an ease back to standing upright
* Ran internally during the main loop, but revealed for external access
* @param {number} deltaTime - The time since the last frame.
* @example
* // Update the gravity for the camera.
* this.pxlCamera.updateGravity( this.pxlTimer.deltaTime );
*/
updateGravity( deltaTime ){
if( this.runMain ){
this.gravityRate = Math.max(0, this.gravityRate-this.cameraJumpVelocity );
let gravityRate = this.gravityUPS[ this.pxlUser.lowGrav ];
if( this.hasGravity ){
this.gravityCount += (gravityRate * 2.5) * deltaTime;
//this.gravityRate = Math.min( 1, ((this.gravityRate+this.gravityMax)*deltaTime)) * gravityRate;
this.gravityRate = Math.min( 1, ((this.gravityRate+this.gravityMax))) * this.gravityCount;
//this.gravityRate += this.gravityRate * this.gravityCount;
}
if( this.gravityRate != 0 ){
// gMult not used, testing for need
let gMult=1;
if( !this.hasGravity ){
this.gravityRate=this.gravityRate>.01 ? this.gravityRate*this.gravityEaseOutRate*gravityRate * deltaTime : 0;
gMult= this.gravityRate;
}else{
//gMult=this.gravityRate*.08*gravityRate;
gMult=this.gravityRate;
}
gMult=Math.min(1, gMult);
this.standingHeightGravInfluence = Math.min(1, this.gravityRate / this.gravityMax ) * this.standingMaxGravityOffset;
//this.standingHeightGravInfluence = Math.min(1, gMult / this.gravityMax ) * this.standingMaxGravityOffset;
//this.standingHeightGravInfluence = Math.min(this.gravityMax, this.gravityRate * deltaTime ) * this.standingMaxGravityOffset;
//this.standingHeightGravInfluence = Math.min(this.gravityMax, this.gravityRate * deltaTime ) * this.standingMaxGravityOffset;
}
}
}
/**
* Resets the gravity for the camera.
* Ran during Jump Landing, Room & Portal Warps currently
* @example
* // Reset the gravity for the camera.
* this.pxlCamera.resetGravity();
*/
resetGravity(){
this.gravityCount=0;
this.gravityRate=0;
this.workerFunc( "resetGravity" );
this.jumpLanding( false ); // resetGravity runs jumpLanding on Worker
}
/**
* Handles the jump landing, stopping the camera jump.
* @param {boolean} [send=true] - Whether to send the landing event.
* @example
* // Force the camera to "land" from a jump
* // Player will still be in the air, but gravity will be active
* this.pxlCamera.jumpLanding();
*/
jumpLanding( send=true ){
// Is space held down?
// Trigger short delay before triggering a jump again
if( this.cameraJumpActive ){
this.hasJumpLock=true;
this.releaseJumpLockTime = this.pxlTimer.runtime + this.releaseJumpLockDelay;
}
this.gravityCount=0;
this.hasGravity=false; // Should probably name it cameraInAir
this.cameraJumpVelocity=0;
this.cameraJumpInAir=false; // hasGravity should indicate this value; residual from logic rework
this.cameraJumpActive=false; // Stop running camJump function
// Leave outside if for external access
if( send ){
this.workerFunc( "jumpLanding" );
}
}
//////////////////////////////////////////////
// Collision Objects and Ground Functions //
////////////////////////////////////////////
/**
* Checks for main collider interactions.
* Ground plane, obstacles, and no terrain (If there are colliders in scene)
* @param {Vector3} curCamPos - The current camera position.
* @returns {Vector3} - The updated camera position.
* @example
* // Check for main collider interactions.
* let curPos=this.pxlCamera.colliderCheck( this.camera.position );
* // Update the camera position.
* this.setTransform( curPos );
*/
// TODO : gravitySource should probably originate from Room's object list, but for now...
// TODO : Collision check shouldn't run if no cam movement length aside from gravity, store floor name and collision position from prior run
colliderCheck( curCamPos ){
// Check if camera is in Roam or Static mode
if( !this.canMove ){
return curCamPos;
}
// Floor Collider
// geoList["floorCollider"] Collision Detection
let objHit=null;
this.movementBlocked=false;
if( (this.cameraMoveLength>0 || this.colliderPrevObjHit==null || this.nearestFloorObjName==null) &&
this.cameraBooted && this.pxlEnv.roomSceneList[this.pxlEnv.currentRoom].collidersExist
){
this.colliderValidityChecked=true; // Prevent doublechecking object validity post collision detection
let curRoomObj = this.pxlEnv.roomSceneList[ this.pxlEnv.currentRoom ];
let castDir=new Vector3(0,-1,0);
let castPos=curCamPos.clone();//.add(new Vector3(0,100,0));
let castHeight= 150*this.maxStepHeight ;
castPos.y += castHeight + this.maxStepHeight;
let resetKeyDown=false;
var rayHits=[];
let curQuadrant= ( ~~(castPos.x>0)+"" ) + ( ~~(castPos.z>0)+"" );
if( curRoomObj.hasColliderType( COLLIDER_TYPE.WALL ) ){
rayHits = this.pxlColliders.castRay( this.pxlEnv.currentRoom, castPos, castDir, COLLIDER_TYPE.WALL );
}
if(rayHits.length > 0){ // Hit a wall, check if you are standing on the wall
// this.floorColliderInitialHit=true;
curRoomObj.hitColliders( rayHits, COLLIDER_TYPE.WALL );
if(curRoomObj.hasColliderType( COLLIDER_TYPE.WALL_TOP )){
let rayTopHits=this.pxlColliders.castRay( this.pxlEnv.currentRoom, castPos, castDir, COLLIDER_TYPE.WALL_TOP );
if( rayTopHits.length > 0 ){
curRoomObj.hitColliders( rayTopHits, COLLIDER_TYPE.WALL_TOP );
}
let closestDist=-99999;
let yPrevRef=curCamPos.y;
let curName;
let curCollisionPos=this.nearestFloorHit;
let validHitCheck=false;
for(var x=0; x<rayTopHits.length;++x){
var obj=rayTopHits[x];
curName=obj.object.name;
let curHit=obj.pos;
let curDist=obj.dist;
let camDist=curHit.y;//- curCamPos.y; // ## Why??
let validHit=camDist < this.maxStepHeight;
validHitCheck = validHitCheck ? validHitCheck : validHit;
if( (curDist<closestDist && valid) || objHit==null){
objHit=curName;
closestDist=curDist;
curCollisionPos=curHit;
}
}
// Check if camera is on top of wall
let pullBack;
if( !validHitCheck || ((curCamPos.y) < curCollisionPos.y && (this.nearestFloorHitPrev.y-curCollisionPos.y > (this.maxStepHeight+this.getStandingHeight()) && !this.hasGravity) && ( (curCamPos.y+this.maxStepHeight+this.getStandingHeight()) < curCollisionPos.y && this.hasGravity) ) ){
//objHit=this.nearestFloorObjName;
if(this.cameraMovement[0] != 0 || this.cameraMovement[1] != 0 ){
validHitCheck=true;
this.hasGravity=false;
this.hasJumpLock=true;
}
pullBack=this.cameraPos.clone();
pullBack.y=Math.min(curCamPos.y,pullBack.y);//+this.cameraJumpVelocity;
curCamPos=pullBack;
curCollisionPos=curCamPos;
if(this.hasGravity){
curCollisionPos.y=this.nearestFloorHitPrev.y;
}else{
curCollisionPos.y=this.cameraPos.y;
}
this.cameraJumpActive=false;
this.cameraAllowJump=true;
this.cameraJumpInAir=false;
this.cameraMovement[0] = 0;
this.cameraMovement[1] = 0;
this.pxlDevice.touchMouseData.curFadeOut.multiplyScalar(0);
this.pxlDevice.touchMouseData.velocity.multiplyScalar(0);
//this.pxlDevice.touchMouseData.velocityEase.multiplyScalar(0);
}
//this.colliderValid=validHitCheck;
if( validHitCheck ){
if( objHit == null ){
this.nearestFloorHit = this.nearestFloorHitPrev;
this.nearestFloorObjName = this.nearestFloorObjNamePrev;
if( Math.abs(curCamPos.y-this.nearestFloorHit.y) > (this.maxStepHeight+this.getStandingHeight()) ){
this.colliderValid = false;
this.hasGravity = true;
}
}else{
this.nearestFloorHitPrev = this.nearestFloorHit;
this.nearestFloorObjNamePrev = this.nearestFloorObjName;
this.nearestFloorHit = curCollisionPos;
this.nearestFloorObjName = objHit;
}
}
}else{
this.colliderFail=true;
this.movementBlocked=true;
}
}else{
// ## Find orientation to gravitational source if any exist in Room Environment
let stepUpDist=this.maxStepHeight;//+this.cameraJumpVelocity;
let validDistRange=stepUpDist+this.getStandingHeight();
//castPos.y=curCamPos.y+stepUpDist;
castPos=curCamPos.clone(); //.add(new Vector3(0,100,0));
castPos.y += castHeight + this.maxStepHeight;
if( this.pxlEnv.roomSceneList[this.pxlEnv.currentRoom].hasColliders() ){
rayHits=this.pxlColliders.castRay( this.pxlEnv.currentRoom, castPos, castDir, COLLIDER_TYPE.FLOOR );
}else{
return curCamPos; // No colliders
}
if(rayHits.length > 0){
if(rayHits.length > 1){
let firstDist = Math.abs( rayHits[0].pos.y-curCamPos.y );
if( firstDist<stepUpDist ){
rayHits = [ rayHits[0] ];
}else if( firstDist>stepUpDist && rayHits[0].pos.y > rayHits[1].pos.y && rayHits[1].pos.y > curCamPos.y-this.maxStepHeight ){
return curCamPos;
}
}
this.floorColliderInitialHit=true;
let closestDist=-99999;
let curName;
let curCollisionPos=this.nearestFloorHit;
for(let x=0; x<rayHits.length;++x){
let obj=rayHits[x];
let curHit=obj.pos;
//let curHit=castPos.y-obj.dist;
//let curDist=obj.dist;
let validHit=false;
curName=obj.object.name;
let camDist=curHit.distanceTo( curCamPos );
validHit=camDist<this.maxStepHeight;
//console.log(stepUpDist,camDist, obj.dist, validHit);
if( ( this.portalList[curName] || this.roomWarpZone.includes(curName) ) && validHit){
objHit=curName;
curCollisionPos=curHit;
break;
}else if( !this.itemCheck(curName, validHit) ){
if(camDist<closestDist || objHit==null){
objHit=curName;
closestDist=camDist;
curCollisionPos=curHit;
}
}
}
if( this.nearestFloorObjName==null && objHit!=null){
this.nearestFloorHitPrev=curCollisionPos;
this.nearestFloorObjNamePrev=objHit;
this.nearestFloorHit=curCollisionPos;
this.nearestFloorObjName=objHit;
}
//console.log(this.nearestFloorHitPrev.y-curCollisionPos.y, this.maxStepHeight+this.getStandingHeight() );
if( (this.nearestFloorHitPrev.y-curCollisionPos.y) > (this.maxStepHeight+this.getStandingHeight()) && !this.hasGravity){
this.nearestFloorHit=this.nearestFloorHitPrev;
this.nearestFloorObjName=this.nearestFloorObjNamePrev;
//this.cameraMovement[0] = Math.abs(this.cameraMovement[0])<this.posRotEasingThreshold ? 0 : this.cameraMovement[0]*this.cameraMovementEase;
//this.cameraMovement[1] = Math.abs(this.cameraMovement[1])<this.posRotEasingThreshold ? 0 : this.cameraMovement[1]*this.cameraMovementEase;
if( !objHit ){
curCamPos=this.cameraPrevPos.clone();
}else{
curCamPos=this.cameraPos.clone();
}
objHit=this.nearestFloorObjName;
this.cameraMovement[0] = 0;
this.cameraMovement[1] = 0;
this.pxlDevice.touchMouseData.curFadeOut.multiplyScalar(0);
this.pxlDevice.touchMouseData.velocity.multiplyScalar(0);
//this.pxlDevice.touchMouseData.velocityEase.multiplyScalar(0);
}else{ // Player is jumping or falling
this.nearestFloorHitPrev=this.nearestFloorHit;
this.nearestFloorObjNamePrev=this.nearestFloorObjName;
this.nearestFloorHit=curCollisionPos;
this.nearestFloorObjName=objHit;
if( objHit == null ){
this.colliderValid=false;
this.hasGravity=true;
}
}
}else{
// If this runs, means the user ran off the edge of the collider and there is no floor below them.
this.colliderFail=true;
this.movementBlocked=true;
this.colliderValidityChecked=false;
curCamPos=this.cameraPos.clone();
}
}
}else{
// User didn't move, may be falling from gravity
// Call valid object check within distance from camera location
this.colliderValidityChecked=false;
}
this.colliderValidityChecked=false;
return curCamPos;
}
///////////////////////////////
// Collider Event Triggers //
/////////////////////////////
// Should only run when this.colliderValid==false
// ##
/**
* Checks if the collider is valid.
* For GravitySource, make sure to get vector delta magnitude, not just Y delta
* @param {Vector3} curCamPos - The current camera position.
* @returns {number} - The distance to the collider.
* @example
* // Check if the collider is valid, within the max step height.
* let dist=this.pxlCamera.checkColliderValid( this.camera.position );
* // Update the camera position.
*/
checkColliderValid( curCamPos ){
this.colliderValidityChecked=true;
let validDist=this.maxStepHeight+this.gravityRate;
let curDist = curCamPos.distanceTo( this.nearestFloorHit );
let checkValid= curDist < validDist;// && (curCamPos.y+validDist)<this.nearestFloorHit.y;
this.colliderValid=checkValid;
return curDist;
//return checkValid; // Currently not needed, pre-emptive
}
/**
* Triggers an event based on the collider object.
* Currently supports inta-room portals, extra-room warp zones, and only 2 audio triggers.
* Custom triggers haven't been implemented yet,
* For any custom Collider Events, use the `castray()`
* @param {string} [checkObject=null] - The collider object to check.
* @returns {boolean} - Whether an event was triggered.
* @example
* // Trigger an event based on the collider object.
* this.pxlCamera.eventTrigger( "AudioTrigger_1" );
* // Update the camera position.
* this.setTransform( curPos );
*/
eventTrigger( checkObject=null ){
// Check if camera is in Roam or Static mode
if( !this.canMove ){ return false; }
// No collider, might be in a Room Environment with no colliders
if(!checkObject){ return false; }
// -- Check for Portals -- //
// -- Within Room Environment position/rotation updates -- //
if(this.portalList[checkObject]){
this.warpEventTriggered( 0, this.portalList[checkObject]);
this.eventCheckStatus=false;
return true;
}
// -- Check for between Room Warp Zones -- //
// -- Separate ThreeJS Scene position/rotation updates -- //
if( this.roomWarpZone.includes(checkObject) ){ // ## Should live in the Room Environment
this.warpEventTriggered( 1, checkObject );
this.eventCheckStatus=false;
return true; // Room warp, kill camera calculations
}
// -- Check for change between different Collider objects -- //
// -- Changes may trigger Audio and Screen Visual Effects -- //
this.colliderShiftActive=this.colliderCurObjHit!=checkObject || this.colliderShiftActive ;
this.colliderPrevObjHit= this.colliderCurObjHit;
this.colliderCurObjHit=checkObject;
// If the volume adjust is mid transition, keep the fade rolling
this.colliderShiftActive=this.colliderShiftActive || !(this.colliderAdjustPerc==1 || this.colliderAdjustPerc==0);
// Fade Up/Down Audio/Video effects per room names
// ## These should be handled by the Room Environment itself
if(this.colliderShiftActive && this.colliderCurObjHit){
let volMult= 1;
let audioTriggerCur = this.colliderCurObjHit.includes("AudioTrigger")
//let audioTriggerPrev = (this.colliderPrevObjHit || "").includes("AudioTrigger")
//let audioTrigger= ( audioTriggerCur || audioTriggerPrev ) && ( audioTriggerCur != audioTriggerPrev);
if( audioTriggerCur ){
volMult=-1;
}
this.colliderAdjustPerc=Math.min(1, Math.max(0, this.colliderAdjustPerc + this.colliderAdjustRate * volMult ));
let curExposure=(1-this.colliderAdjustPerc);
let curExp=1.0;
// ## Convert to function dictionary per Room Environment's Collider[objName]
if(this.colliderCurObjHit == "AudioTrigger_1"){ // Sunflower Room
this.pxlEnv.currentAudioZone=1;
curExp= curExp - curExposure*this.uniformScalars.darkBase; // ## Don't do it this way... blend, don't add offset
this.uniformScalars.exposureUniformBase=curExp;
}else if(this.colliderCurObjHit == "AudioTrigger_2"){ // Lobby
this.pxlEnv.currentAudioZone=2;
let animPerc=1;
curExp= this.uniformScalars.curExp + curExposure*this.uniformScalars.brightBase*animPerc; // ## Don't do it this way... blend, don't add offset
this.uniformScalars.exposureUniformBase=curExp;
this.proximityScaleTrigger=true; // Fade Out proximity range
this.pxlAudio.setFadeActive(-1);
//}else if(){ } // TODO : Add camera location warp pad check
}else{
this.pxlEnv.currentAudioZone=0;
curExp= curExp*(1-curExposure) + this.uniformScalars.exposureUniformBase*curExposure; // ## Don't do it this way... blend, don't add offset
}
// Transition has completed when True
this.colliderShiftActive=!(this.colliderAdjustPerc==1 || this.colliderAdjustPerc==0);
// If Lobby geomtry is visible, but no longer in the Lobby, toggle visiblity
// Runs once, at the moment of collider change
if( this.colliderPrevObjHit=="AudioTrigger_2" && this.colliderCurObjHit!=this.colliderPrevObjHit){
this.proximityScaleTrigger=true; // Fade In proximity range
this.pxlAudio.setFadeActive(1);
}
if( this.pxlDevice.mobile ){
curExp=this.colliderAdjustPerc;
}
// Set scene exposure on post-process composer passes
this.pxlEnv.updateCompUniforms(curExp);
// Scale proximity visual
if(this.proximityScaleTrigger && !this.pxlDevice.mobile && !this.pxlAutoCam.enabled ){
let proxMult=this.colliderAdjustPerc;
proxMult=1-(1-proxMult)*(1-proxMult);
this.pxlEnv.fogMult.x = proxMult;
if( !this.colliderShiftActive ){
this.proximityScaleTrigger=false;
}
}
this.eventCheckStatus=this.colliderShiftActive;
}
}
/**
* Checks if an item was triggered.
* Currently only used as - if( !this.itemCheck(validHit) ){}
* Preventing standing on the item collider plane
* @param {string} curNameBase - The base name of the item.
* @param {boolean} validHit - Whether the hit was valid.
* @returns {boolean} - Whether the item was triggered.
* @private
*/
itemCheck(curNameBase, validHit){
if(!validHit){ return false; }
let curName=curNameBase.split("_").shift();
if(this.pxlUser.itemListNames.includes(curNameBase)){
let itemPickup=this.pxlUser.checkItemPickUp(curName);
if(itemPickup){
return this.itemActive( curName, curNameBase );
}
}
return false; // Allowed to stand on object
}
/**
* Triggers a newly picked-up item.
* If no item is picked up, a random overlay-effect item is selected.
*/
itemTrigger(){
if( this.pxlUser.itemActiveTimer.length>0 ){
this.pxlUser.itemActiveTimer[0]=this.pxlTimer.curMS;
}else{
if( this.pxlUser.mPick.length==0){
this.pxlUser.mPick=this.pxlUtils.randomizeArray( ['LizardKing', 'StarField', 'InfinityZoom'] );
}
//this.pxlUser.mPick="LizardKing";
let setItem= this.pxlUser.mPick.pop();
this.pxlUser.checkItemPickUp(setItem);
this.itemActive( setItem );
}
}
/**
* Activates an item.
* @param {string} [curName=null] - The name of the item.
* @param {string} [curNameBase=null] - The base name of the item.
* @returns {boolean} - Whether the item was activated.
*/
itemActive( curName=null, curNameBase=null ){
if( curName==null ){
return false;
}
let timer=this.pxlTimer.prevMS+this.pxlUser.itemRunTime;
let finCmd="";
let text="";
if(curName=="LowGravity"){
text="Low Gravity";
finCmd="this.lowGrav=0;this.itemGroupList['"+curNameBase+"'].visible=true;";
timer=this.pxlTimer.prevMS+this.pxlUser.itemRunTime;
}else if(curName=="LizardKing"){
text="I am the Lizard King";
finCmd="this.lKing=0;this.lKingWarp.set(...this.lKingInactive);this.lizardKingPass.enabled=false;"+(!this.pxlDevice.mobile && "this.itemGroupList['"+curNameBase+"'].visible=true;");
timer=this.pxlTimer.prevMS+this.pxlUser.itemRunTime;
}else if(curName=="StarField"){
text="Major Tom";
finCmd="this.sField=0;this.starFieldPass.enabled=false;"+(!this.pxlDevice.mobile && "this.itemGroupList['"+curNameBase+"'].visible=true;");
timer=this.pxlTimer.prevMS+this.pxlUser.itemRunTime;
}else if(curName=="InfinityZoom"){
text="Fractal Substrate";
finCmd="this.iZoom=0;this.crystallinePass.enabled=false;"+(!this.pxlDevice.mobile && "this.itemGroupList['"+curNameBase+"'].visible=true;this.pxlEnv.mapComposerWarpPass.needsSwap=true;this.pxlEnv.mapComposerWarpPass.enabled=false;");
timer=this.pxlTimer.prevMS+this.pxlUser.itemRunTime;
//this.pxlEnv.mapComposerWarpPass.needsSwap=false;
this.pxlEnv.mapComposerWarpPass.needsSwap=true;
setTimeout(()=>{
/*if( this.pxlEnv.currentRoom==this.pxlEnv.mainRoom ){
this.pxlEnv.roomComposer.reset();
this.pxlEnv.mapComposer.render();
}else{
this.pxlEnv.mapComposer.reset();
this.pxlEnv.roomComposer.render();
}*/
this.pxlEnv.mapComposer.render();
this.pxlEnv.roomComposer.render();
setTimeout(()=>{
this.pxlEnv.mapComposerWarpPass.needsSwap=false;
this.pxlEnv.mapComposerWarpPass.enabled=true;
/*if( this.pxlEnv.currentRoom==this.pxlEnv.mainRoom ){
this.pxlEnv.roomComposer.reset();
}else{
this.pxlEnv.mapComposer.reset();
}*/
},500);
},500);
/*this.pxlEnv.mapComposer.render();
this.pxlEnv.mapComposerWarpPass.enabled=!this.pxlEnv.mapComposerWarpPass.enabled;
this.pxlEnv.mapComposer.render();*/
//this.pxlEnv.roomComposer.render();
//this.pxlEnv.mapComposer.render();
}else{
return false;
}
this.pxlGuiDraws.buildItemHud(curName,text);
if( !this.pxlDevice.mobile ){
this.pxlUser.itemGroupList[curNameBase].visible=false;
}
this.pxlUser.itemInactiveCmd.push( finCmd );
this.pxlUser.itemActiveTimer.push(timer);
this.pxlUser.itemActiveList.push(text);
return true; // Don't stand upon item collision object
}
////////////////////////////////////
// Camera Positional Functions //
//////////////////////////////////
// Flip between free roaming or static camera
// Run this through pxlNav's trigger system, trigger --
// pxlNav.trigger("Camera","Roam")
// -or-
// pxlNav.trigger("Camera","Static")
/**
* Toggles the camera movement.
* @param {boolean} [canMoveVal=null] - Whether the camera can move.
* @example
* // Toggle the camera to `Static` mode.
* this.pxlCamera.toggleMovement( false );
*
* // Toggle the camera to `Roam` mode.
* this.pxlCamera.toggleMovement( true );
*/
toggleMovement( canMoveVal=null ){
if(canMoveVal == null){
canMoveVal=!this.canMove;
}
this.canMove = canMoveVal;
this.hasGravity = canMoveVal;
}
/**
* Updates the movement based on the current time.
* Appling down directional key values to camera movement array
*
* Ran internally during the main loop, but revealed for external access
*
* @param {number} curTime - The current time.
* @example
* // Update the movement based on the current time.
* this.pxlCamera.updateMovement( this.pxlTimer.deltaTime );
*
* // Log the current camera movement direction in X and Z.
* console.log( this.pxlCamera.cameraMovement );
*/
updateMovement(curTime){
// Check if camera is in Roam or Static mode
if( !this.canMove ){ return; }
if( this.pxlDevice.mobile ){
return;
}
let rate=[0,0];//
let dir=[...this.pxlDevice.directionKeysPressed];
let strafe=0;
let dolly=0;
// Get millisecond time differences so camera movement is independant of FPS
let deltas=[ (curTime-this.pxlDevice.keyDownCount[0]), (curTime-this.pxlDevice.keyDownCount[1]) ]; // 1.000 seconds
//console.log( dir );
// Array entry
let easingMode = this.mobile ? 1 : 0;
// Check if either Left or Right direction keys are pressed
// Default: rate[0] is strafing movement
// If tank controls are enabled, rate[0] drives rotation rate
// this.pxlQuality.settings.leftRight == False : Tank Controls; True : Strafing
// TODO : Yeah, I know. There is a TODO in QualityController.js to decouple movement settings
if((dir[0]+dir[2])==1){
strafe=dir[2]-dir[0];
// Subtract forward/back from strafing movement to reduce diagonal super-speed
let turnRate=this.pxlQuality.settings.leftRight ? this.cameraEasing[ easingMode ] : ( 1 - Math.min(1, Math.abs(this.cameraMovement[1]*.3)) ) *.5 ;
rate[0]=( (this.pxlQuality.settings.leftRight ? 1.0 : 6.0) + (deltas[0]*(deltas[0])) * .1 ) * turnRate;
rate[0]= Math.min( this.pxlUser.moveSpeed, rate[0] ) * this.movementScalar * this.userInputMoveScalar.x;
}else{
// Bother Left AND Right direction keys are pressed, cancel movement
this.pxlDevice.keyDownCount[0]=curTime;
}
// Check if either Up or Down direction keys are pressed
if((dir[1]+dir[3])==1){
dolly=dir[3]-dir[1];
// Subtract strafing movement from dolly movement to reduce diagonal super-speed
let dollyRate=(1- Math.min(1, Math.abs(this.cameraMovement[0]*.07))) * this.cameraEasing[ easingMode ];
rate[1]=( ((deltas[1]*(deltas[1]*3+2+this.pxlUser.moveSpeed))*.5) ) * dollyRate;
rate[1]= Math.min( this.pxlUser.moveSpeed, rate[1] ) * this.movementScalar * this.userInputMoveScalar.y;
}else{
// Both Up AND Down direction keys are pressed, cancel movement
this.pxlDevice.keyDownCount[1]=curTime;
}
let moveSpeed = ( rate[0]**2 + rate[1]**2 ) ** 0.5;
this.hasMovementLimit=true;
this.movementMax = 10.0; // Meters per second
this.cameraMovement[0]+=strafe*rate[0];
this.cameraMovement[1]+=dolly*rate[1];
}
/**
* Initializes the starting camera position per-frame.
* This is ran in `updateCamera()`
* @returns {Vector3} - The initial camera position.
* @private
*/
initFrameCamPosition(){
let curCamPos=this.cameraPos.clone();
if(!this.cameraBooted){ // These should be set from Scene File, if not, initial values
this.cameraAimTarget.position.set(0, 0, 0);//.add(new Vector3(0,0,0));
this.cameraPrevPos = new Vector3(curCamPos.clone());
this.cameraPrevLookAt = new Vector3(0,0,1);
this.hasMoved = true;
this.hasRotated = true;
}else{
let userMovement;
/*if(this.pxlDevice.mobile){ // ## When Mobile is implemented, convert to this.cameraMovement
userMovement=new Vector3(-this.pxlDevice.touchMouseData.curDistance.x*.01,0,-this.pxlDevice.touchMouseData.curDistance.y*.01);
this.cameraMoveLength=userMovement.length();
}else{*/
//userMovement=new Vector3(this.cameraMovement[0],0,this.cameraMovement[1]);
userMovement=new Vector3((this.pxlQuality.settings.leftRight?this.cameraMovement[0]*.5:0),0,this.cameraMovement[1]);
this.cameraMoveLength=userMovement.length();
//}
userMovement.applyQuaternion(this.camera.quaternion);
let moveScalar = this.cameraMoveLength*this.cameraMoveLengthMult;
// Give some base movement to the camera
// This way it doesn't ramp up from 0, but from the minimum movement speed
if( moveScalar!=0 ){
let minimumMoveSpeed=0.1;
moveScalar = moveScalar>0 ? Math.max(minimumMoveSpeed,moveScalar) : Math.min(-minimumMoveSpeed,moveScalar);
userMovement.normalize().multiply(new Vector3(1,0,1)).multiplyScalar(moveScalar);
curCamPos.add(userMovement);
this.cameraMovement[0] = Math.abs(this.cameraMovement[0])<this.posRotEasingThreshold ? 0 : this.cameraMovement[0]*this.cameraMovementEase;
this.cameraMovement[1] = Math.abs(this.cameraMovement[1])<this.posRotEasingThreshold ? 0 : this.cameraMovement[1]*this.cameraMovementEase;
if( this.cameraMovement[0] == 0 ){
this.userInputMoveScalar.x=1;
}
if( this.cameraMovement[1] == 0 ){
this.userInputMoveScalar.y=1;
}
this.hasMoved=true;
}
//curCamPos=curCamPos.clone().multiplyScalar(this.camPosBlend).add(this.cameraPrevPos.clone().multiplyScalar(1-this.camPosBlend));
// ## When GravitySource exists, apply cameraMovement offset
// Cam movement to Vector3( cm[0], 0, cm[1] ), rotated by Quaternion from Euler Normalize Vector (camPos - collider hit)
// DO NOT USE CAMERA QUATERNION, movement doesn't align to camera orientation
curCamPos.y=this.cameraPos.y + this.cameraJumpVelocity;
if( this.workerActive ){
this.cameraJumpVelocity=0; // Additive from the worker thread
}
}
this.cameraCross=new Vector3(1,0,0).applyQuaternion( this.camera.quaternion );
return curCamPos;
}
/**
* Updates the camera position based on gravity and collisions.
* Delta ( camPos + gravity direction * gravity rate ) > ( Distance camPos to Collider Hit )
*
* Handled internally during the main loop, but revealed for external access
*
* @param {Vector3} curCamPos - The current camera position.
* @returns {Vector3} - The updated camera position.
* @example
* // Update the camera position based on gravity and collisions.
* let curPos=this.pxlCamera.updateCamera( this.camera.position );
* curPos = this.pxlCamera.applyGravity( curPos );
*
* // Check if the collider is valid, within the max step height.
* let dist=this.pxlCamera.checkColliderValid( curPos );
*
* if( this.colliderValid ){
* // Update the camera position.
* this.setTransform( curPos );
* }
*/
applyGravity( curCamPos ){
if( this.canMove && this.hasGravity ){
//curCamPos=this.checkColliderFail( curCamPos );
let validDist=this.maxStepHeight+this.gravityRate;
let jumpUpState=(curCamPos.y)<this.nearestFloorHit.y;
/*if( jumpUpState || this.colliderFail ){
//curCamPos.x = nPrev.x;
//curCamPos.y = Math.max( nPrev.y, curCamPos.y-this.gravityRate );
curCamPos.y = Math.max( 100, curCamPos.y-this.gravityRate );
//curCamPos.z = nPrev.z;
if( curCamPos.y == 100 ){//nPrev.y){
let nPrev=this.nearestFloorHitPrev;
curCamPos=nPrev.clone();
this.resetGravity();
}
}*/
if( jumpUpState ){
let nPrev=this.nearestFloorHitPrev;//.nearestFloorHit;//this.nearestFloorHitPrev;
//curCamPos.x = nPrev.x;
curCamPos.y = Math.max( nPrev.y, curCamPos.y);//-this.gravityRate );
//curCamPos.z = nPrev.z;
if( curCamPos.y < 0 ){//nPrev.y){
curCamPos.x=nPrev.x;//clone();
curCamPos.z=nPrev.z;//clone();
//this.resetGravity();
//this.jumpLanding();
}
}else{
curCamPos.y = Math.max( this.nearestFloorHit.y, curCamPos.y - this.gravityRate );
if( curCamPos.y == this.nearestFloorHit.y && curCamPos.y<this.cameraPrevPos.y ){
this.jumpLanding();
}
}
}else{
let distToFloor=curCamPos.distanceTo( this.nearestFloorHit );
if( distToFloor < this.maxStepHeight){
curCamPos.y = this.nearestFloorHit.y;
}else{
curCamPos=this.cameraPos.clone();
let fallStatus=curCamPos.y > this.nearestFloorHit.y;
this.hasGravity=fallStatus;
this.hasMoved = this.hasMoved || fallStatus;
this.colliderFail= !fallStatus;
this.workerFunc("jumpLanding");
//curCamPos=this.checkColliderFail( curCamPos );
}
}
return curCamPos;
}
/**
* Gets the standing height of the user.
* Head to Foot only - No landing, gravity, or walk-bounce
* @returns {number} - The standing height.
* @example
* // Get the standing height of the user.
* let standingHeight=this.pxlCamera.getStandingHeight();
* console.log( "getStandingHeight()", standingHeight );
*/
getStandingHeight(){
let retHeight = this.standingHeight;
if( this.roomStandingHeight.hasOwnProperty(this.pxlEnv.currentRoom) ){
retHeight = this.roomStandingHeight[this.pxlEnv.currentRoom];
}
return retHeight * this.userScale;
}
/**
* Gets the user height including jump and walking-bounce offsets.
* @returns {number} - The user height.
* @example
* // Get the user height including jump and walking-bounce offsets.
* let userHeight=this.pxlCamera.getUserHeight();
* console.log( "getUserHeight()", userHeight );
*/
getUserHeight(){
// Add bob to movement to appear as taking steps
let walkBounceAdd=Math.min(1, Math.abs(this.cameraMovement[1]));
this.walkBouncePerc=this.walkBouncePerc>=1?1:this.walkBouncePerc + this.walkBounceEaseIn * walkBounceAdd;
this.walkBounce+=walkBounceAdd * this.walkBounceRate;
this.walkBouncePerc=this.walkBouncePerc * this.walkBounceEaseOut + walkBounceAdd;
if(this.walkBouncePerc<.03){
this.walkBouncePerc=0;
this.walkBounce=0;
this.walkBounceSeed=Math.random()*2351.3256;
}
//let walkBounceOffset=Math.sin(this.walkBounce*.4+this.walkBounceSeed+this.cameraMovement[1]*.2)*this.walkBouncePerc*.3;
let walkBounceOffset=Math.sin(this.walkBounce+this.walkBounceSeed) * this.walkBouncePerc * this.walkBounceHeight;
let curStandingHeight=this.getStandingHeight() - this.standingHeightGravInfluence + walkBounceOffset;
return curStandingHeight;
}
////////////////////////////////////
// Camera Rotational Functions //
//////////////////////////////////
/**
* Applies mobile rotation to the camera.
* Mobile currently doesn't support movement in Rooms
*
* Currently unused; awaiting mobile-gyroscope implementation
*/
camApplyMobileRotation(){
if(this.cameraPose.alpha!=null){
let dtor=0.017453292519943278; // PI/180
let halfSqrt=2.23606797749979; // Sqrt(5)
let camPoseQuat=new Quaternion();
let a=this.cameraPose.alpha*dtor+this.cameraPose.alphaOffset+2.1;
let b=this.cameraPose.beta*dtor;
let g=this.cameraPose.gamma*dtor;
let viewNormal=new Vector3(0,0,1);
let poseQuat=new Quaternion();
let initPoseQuat=new Quaternion(-halfSqrt,0,0,halfSqrt);
let euler=new Euler();
euler.set(b,a,-g,'YXZ'); // Device returns YXZ for deviceOrientation
camPoseQuat.setFromEuler(euler);
camPoseQuat.multiply(initPoseQuat);
camPoseQuat.multiply(poseQuat.setFromAxisAngle(viewNormal,-this.cameraPose.orientation));
camPoseQuat.normalize();
let smoothedQuat=new Quaternion();
Quaternion.slerp(this.camera.quaternion,camPoseQuat,smoothedQuat,0.35);
let cameraLimit = new Euler().setFromQuaternion(smoothedQuat);
cameraLimit.x = Math.max(-0.95 * Math.PI / 2, Math.min(0.95 * Math.PI / 2, cameraLimit.x));
smoothedQuat.setFromEuler(cameraLimit);
this.camera.setRotationFromQuaternion(smoothedQuat);
this.hasRotated=true;
}
}
/**
* Updates the camera rotation; Look At(Aim) Target
*
* Note: Known bug, static camera rotation is based on the current camera rotation
* This causes an inate rotation when the camera is moved to a new position
*/
updateRoamRotation(){
if(this.cameraPose.alpha==null){ // ## Should gyro exist, don't run. But need to allow controlled look around on mobile
let xGrav=this.pxlDevice.gyroGravity[2];//*this.gravityRate;//*PI;
let viewNormal=new Vector3(0,0,1);
let poseQuat=new Quaternion();
// ## Theres a better place for this....
this.pxlDevice.touchMouseData.velocity.y=Math.min(this.touchSensitivityLimits, Math.max(-this.touchSensitivityLimits, this.pxlDevice.touchMouseData.velocity.y));
let euler=new Euler();
let camPoseQuat;
if( this.pxlDevice.mobile ){
let invertLookBool = this.pxlOptions.userSettings.look.mobile.invert || false;
let invertLook = invertLookBool ? -1 : 1;
euler.set(
this.pxlDevice.touchMouseData.netDistance.y/this.pxlDevice.sH*4 * invertLook,
this.pxlDevice.touchMouseData.netDistance.x/this.pxlDevice.sW*7 * invertLook + xGrav,
0,
'YXZ'
); // Device returns YXZ for deviceOrientation
camPoseQuat=new Quaternion();
camPoseQuat.setFromEuler(euler);
camPoseQuat=this.pxlDevice.touchMouseData.initialQuat.clone().multiply(camPoseQuat);
//camPoseQuat.multiply(poseQuat.setFromAxisAngle(viewNormal,-this.cameraPose.orientation));
}else{
let invertLookBool = this.pxlOptions.userSettings.look.pc.invert || false;
let invertLook = invertLookBool ? -1 : 1;
euler.set(
this.pxlDevice.touchMouseData.velocity.y*.005 * invertLook,
this.pxlDevice.touchMouseData.velocity.x*.008 * invertLook + xGrav,
0,
'YXZ'// Device returns YXZ for deviceOrientation
);
camPoseQuat=new Quaternion();
camPoseQuat.setFromEuler(euler);
//camPoseQuat=this.pxlDevice.touchMouseData.initialQuat.clone().multiply(camPoseQuat);
camPoseQuat=this.camera.quaternion.clone().multiply(camPoseQuat);
}
camPoseQuat.normalize();
let lookAt= new Vector3(0,0,-10).applyQuaternion( camPoseQuat ).add( this.camera.position );
this.camera.setRotationFromQuaternion(camPoseQuat);
this.camera.lookAt(lookAt);
this.camera.up.set( 0,1,0 );
this.hasRotated=true;
}
}
updateStaticRotation(){
// this.pxlDevice.touchMouseData.startPos;
// this.pxlDevice.touchMouseData.endPos;
// this.pxlDevice.touchMouseData.netDistance;
let blendOut=1;
if( this.touchBlender ){
// Camera rotation easing logic-
blendOut=Math.min(1, Math.max(0, this.pxlTimer.curMS - this.pxlDevice.touchMouseData.releaseTime ));
blendOut*=blendOut;
this.pxlDevice.touchMouseData.netDistance.multiplyScalar(1-blendOut);
this.touchBlender=blendOut<1;
}else{
this.pxlDevice.touchMouseData.netDistance.multiplyScalar(.5);
}
let euler=new Euler();
euler.set(
(this.pxlDevice.touchMouseData.netDistance.y/this.pxlDevice.sH*2),
(this.pxlDevice.touchMouseData.netDistance.x/this.pxlDevice.sW*2),
0,
'YXZ'
); // Device returns YXZ for deviceOrientation
// Limit Up/Down looking
let camPoseQuat=new Quaternion().clone( this.camera.quaternion );
camPoseQuat.setFromEuler(euler);
camPoseQuat=this.camera.quaternion.clone().multiply(camPoseQuat);
//camPoseQuat.multiply(poseQuat.setFromAxisAngle(viewNormal,-this.cameraPose.orientation));
camPoseQuat.normalize();
// let smoothedQuat=new Quaternion();
if( this.touchBlender ){
camPoseQuat.slerp(this.camera.quaternion.clone(),blendOut).normalize();
}
let lookAt= new Vector3(0,0,-10).applyQuaternion( camPoseQuat ).add( this.camera.position );
this.camera.setRotationFromQuaternion(camPoseQuat);//smoothedQuat);
this.camera.lookAt(lookAt);
this.camera.up.set( 0,1,0 );
this.hasRotated=true;
}
/**
* Locks the camera to look at a target.
* @example
* // Lock the camera to look at a target.
* let targetObj = new Object3D();
* targetObj.position.set( 10, 15, 5 );
*
* this.lookAtLockPerc=1;
* this.pxlCamera.lookAtTarget( targetObj );
*/
lookAtTargetLock(){
if(!this.lookAtTargetActive){ return; }
if(this.lookAtTargetActive){
if(this.lookAtLockFader!=0){
this.lookAtLockPerc+=(this.lookAtLockFader+Math.min(1,this.pxlDevice.touchMouseData.velocity.length()*.001))*this.lookAtLockFadeRate;
if(this.lookAtLockPerc<0 || this.lookAtLockPerc>1){
this.lookAtLockPerc=this.lookAtLockPerc<0?0:1;
this.lookAtLockFader=0;
}
this.lookAtPerc.x = this.lookAtLockPerc;
}
// If Look At is locked
// set the offset in rotation
// slerpin some quats!
if(this.lookAtLockPerc>0){
let origCamQuat=this.camera.quaternion.clone();
this.camera.lookAt(this.cameraAimTarget.position);
let targetCamQuat=this.camera.quaternion.clone();
if(this.lookAtLockPerc==1){
this.camera.setRotationFromQuaternion( targetCamQuat );
}else{
this.camera.setRotationFromQuaternion( targetCamQuat.slerp(origCamQuat,Math.cos(this.lookAtLockPerc*pi)*.5+.5) );
}
this.hasRotated=true;
}
}
}
///////////////////////////////////////////
// Render Effects / Quality Functions //
/////////////////////////////////////////
/**
* Triggers a Room Warp / Portal Screen Effect event.
* This will initiate the visual effect and set the end warp object and target.
* The actual warp will be run in the `warpCamRun()` function on following frames.
* @param {number} [visualType=0] - The type of visual effect.
* @param {Object} [warpObj=null] - The warp object.
* @param {string} [target='init'] - The target of the warp.
* @example
* // Trigger a Room Warp / Portal Screen Effect event.
* this.pxlCamera.warpEventTriggered( 1, warpObj, 'init' );
*/
warpEventTriggered( visualType=0, warpObj=null, target='init' ){
if( !this.warpActive ){
this.pxlEnv.mapComposerWarpPass.needsSwap=true;
this.warpType=visualType;
this.warpObj=warpObj;
this.warpTarget=target;
this.warpActive=true;
this.pxlEnv.initWarpVisual( visualType );
}
}
/**
* Runs the room warping camera effects.
*/
warpCamRun(){
if(this.warpType==0){
this.setToObj( this.warpObj );
}else if(this.warpType==1){
let init=this.warpTarget=='init';
this.warpToRoom( this.warpObj, init, this.warpTarget );
}
this.pxlEnv.setExposure( this.uniformScalars.exposureUniformBase );
this.warpObj=null;
this.warpTarget=null;
this.warpActive=false;
}
/**
* Updates low-quality render events.
* @private
*/
lowQualityUpdates(){
if(this.HDRView){
let uPitch=new Vector3(0,0,-1).applyQuaternion( this.camera.quaternion );
let uRot=uPitch.clone().multiply(new Vector3(1,0,1)).normalize();
let ptr=0.1591549430918955;
// Update shader uniforms -
this.camRotPitch.set(
-Math.atan2(uRot.x,uRot.z)*ptr,
uPitch.y*.5 );
}
}
/**
* Updates mid-quality render events.
* @private
*/
midQualityUpdates(){
// Trailing Effects; Fake Motion Blur
if( this.pxlQuality.settings.motion ){ // Don't run blur pass if the quality setting is under 50%
let shaderCamRot=new Vector3(0,0,0);
shaderCamRot.applyQuaternion(this.camera.quaternion);//.add(camOrigQuat).multiplyScalar(.5);
this.camRotXYZ.multiplyScalar(.8).add( shaderCamRot.multiplyScalar(.2) );
let viewDirection;
if(this.pxlDevice.mobile){
let sWHalf = sW*.5
let sHHalf= sH*.5;
let fromWorldPos=new Vector3(0,0,10);
let toWorldPos=new Vector3(0,0,10);
//fromWorldPos.applyMatrix4( this.camera.matrixWorld.clone() ).project(this.camera);
//toWorldPos.applyMatrix4( this.prevWorldMatrix ).project(this.camera);
fromWorldPos.applyQuaternion( this.camera.quaternion.clone() ).project(this.camera);
toWorldPos.applyQuaternion( this.prevQuaternion ).project(this.camera);
fromWorldPos.x=(fromWorldPos.x+1)*sWHalf;
fromWorldPos.y=-(fromWorldPos.y-1)*sHHalf;
toWorldPos.x=(toWorldPos.x+1)*sWHalf;
toWorldPos.y=-(toWorldPos.y-1)*sHHalf;
viewDirection=toWorldPos.clone().sub(fromWorldPos.clone()).multiplyScalar(.6).multiply(new Vector3(this.pxlDevice.screenRes.x,this.pxlDevice.screenRes.y,0));
let motionBlurMaxDist=.1;
if(viewDirection.length>motionBlurMaxDist){
viewDirection.normalize().multiplyScalar(motionBlurMaxDist);
}
//viewDirection=this.pxlDevice.touchMouseData.velocityEase.clone().multiplyScalar( Math.max(this.screenRes[1],this.screenRes[0]) );
}else{
//viewDirection=this.pxlDevice.touchMouseData.velocityEase.clone().multiplyScalar( Math.max(this.pxlDevice.screenRes.x,this.pxlDevice.screenRes.y) );
viewDirection=this.pxlDevice.touchMouseData.velocity.clone().multiplyScalar( Math.max(this.pxlDevice.screenRes.x,this.pxlDevice.screenRes.y) );
}
let toDir=new Vector2( viewDirection.x, -viewDirection.y);
let blurDir=new Vector2(0,0).lerpVectors( this.pxlEnv.blurDirPrev, toDir, .85 );
// Update motionBlur direction uniforms -
this.pxlEnv.blurDirPrev.set( this.pxlEnv.blurDirCur );
this.pxlEnv.blurDirCur.set( blurDir );
}
}
///////////////////////////////////////////////////////
// WebSocket Emit for Position and Rotation Changes //
/////////////////////////////////////////////////////
// Notify Server of Position / Rotation Changes
/**
* Emits camera transforms to the server.
* NETWORKING HAS BEEN REMOVED, you'll need to implement your own server-side logic.
* @param {Vector3} cameraPos - The camera position.
* @param {number} standingHeight - The standing height.
* @param {boolean} [force=false] - Whether to force the emission.
* @private
*/
emitCameraTransforms( cameraPos, standingHeight, force=false ){
this.emit("cameraTransforms",{
cameraPos:cameraPos,
standingHeight:standingHeight,
force:force
});
// Networking scripting removed
}
/**
* Jog the server memory with the current camera position.
* Originally the server would use this event to update remote client's positions of the local user.
* Also as a server-side sanity check that the user is in the correct "chat" room and other data that may have gone stale.
* You'll need to implement your own usage of this function with server-side logic.
* CURRENTLY UNUSED
* @private
*/
jogServerMemory(){
let curCamPos=this.cameraPos.clone();
let standingHeight=this.getUserHeight();
this.emitCameraTransforms( curCamPos, standingHeight, true );
}
///////////////////////////////////
// Main Camera Update Function //
/////////////////////////////////
/**
* Main update function for the camera.
*/
updateCamera(){
//this.updateStaticRotation();
//let velEaseMag=this.pxlDevice.touchMouseData.velocityEase.length();
let velEaseMag = this.pxlDevice.touchMouseData.velocity.length();
this.hasRotated = this.hasRotated || velEaseMag > 0;
this.camUpdated = this.camUpdated || this.hasRotated;
// Fade out touchMouseData, likely to be removed in later versions
this.pxlDevice.touchMouseData.curFadeOut.multiplyScalar( .7 );
// Check if the camera has been updated; step camera values, apply gravity, check for colliders, and interact with objects
if( this.camUpdated ){ // || this.pxlDevice.touchMouseData.active){// || this.lookAtLockPerc>0 ){ // ## Not using any cam locking yet
// Camera checks are initiating
this.camUpdated=false;
let didUpdate=false;
this.updateDeviceValues( velEaseMag );
// TODO : Enable when User class is updated
//this.pxlUser.localUserTurned=this.pxlDevice.touchMouseData.velocity.length() == 0;
this.prevQuaternion.copy( this.camera.quaternion );
//this.prevWorldMatrix.set( this.camera.matrixWorld ); // Only used if running higher quality motion blur, not needed
// For Gyro enabled devices; Mobile / Tablet / Surface devices
// ## Work in progress, waste of calculations acurrently
//this.camApplyMobileRotation();
let cameraPos=this.initFrameCamPosition();
// Appy Gravity Height Offset
let standingHeight=this.getUserHeight();
if( this.pxlOptions.staticCamera ){// Static Camera Mode
this.hasGravity = false;
this.hasMoved = false;
if( this.pxlOptions.allowStaticRotation && this.hasRotated ){ // Static Camera Mode
this.updateStaticRotation();
this.camera.updateMatrixWorld();
}
this.hasRotated = false;
return;
}
// Movement checks
if( this.hasMoved || this.hasGravity ){//&& this.canMove ){
// Check if the camera is in a valid position
cameraPos=this.colliderCheck( cameraPos );
// If in air, gravity grows
// This only updates gravity prior to jump calculations
// User vertical based calculations are ran in `applyGravity()`
this.updateGravity( this.pxlTimer.deltaTime );
// When Jumping / Falling, Collion Hit Position and Object are marked as Invalid
if( !this.colliderValid && !this.colliderValidityChecked ){
// Check if within maxStepHeight+gravityRate distance of collider hit position
this.jump=this.checkColliderValid( cameraPos ); // Sets colliderValid
}else{
this.jump=0;
}
this.eventCheckStatus=true;
// Apply gravity rate to current camera position
cameraPos=this.applyGravity(cameraPos);
// Check length of Camera Movement, `**.5` is the square root of the sum of the squares
// TODO : Implement when User class is updated
//this.pxlUser.localUserMoved= this.hasGravity || ((this.cameraMovement[0]**2 + this.cameraMovement[1]**2) ** .5) > 0;
this.cameraPrevPos=this.cameraPos.clone();
this.cameraPos=cameraPos.clone();
didUpdate = this.cameraPos.distanceTo(this.cameraPrevPos) > 0;
cameraPos.y+=standingHeight+this.cameraJumpHeight;
this.camera.position.copy(cameraPos);
}
// Performing different rotation logic based on if the camera is in Roam or Static mode
// Roaming orients the camera up in Y
// Static keeps the camera oriented with Camera Position -to- LookAt cross product
// `cross( cross( normalized(LookAt-Pos), Up), Up )`
if( this.hasRotated && this.canMove ){ // Roam Camera Mode
this.updateRoamRotation();
didUpdate = didUpdate || this.hasRotated;
}else if( this.hasRotated ){ // Static Camera Mode
this.updateStaticRotation();
didUpdate = didUpdate || this.hasRotated;
}
//this.lookAtTargetLock(); // Camera lookAt target locking
if( didUpdate ){
this.camera.updateMatrixWorld(); // ## Only needed for lobby geo... Fix
this.emitCameraTransforms( cameraPos, standingHeight );
}
// Calculations completed, reset flags
this.hasMoved = false;
this.hasRotated = false;
this.cameraBooted=true;
}/*else{
// TODO : User class still not updated to utilize these
this.pxlUser.localUserMoved=false;
this.pxlUser.localUserTurned=false;
}*/
}
// -- -- --
// pxlNav Callbacks
// `event` should be of `pxlEnum.CAMERA_EVENT` type
/**
* Subscribes to a camera event.
* @param {string} event - The camera event.
* @param {function} callback - The callback function.
* @example
* // Subscribe to a camera event.
* this.pxlCamera.subscribe( "cameraTransforms", (data) => {
* console.log( data );
* }
*/
subscribe( event, callback ){
if( !this.callbacks.hasOwnProperty(event) ){
this.callbacks[event] = [];
}
this.callbacks[event].push( callback );
}
/**
* Emits a camera event.
* @private
*/
emit( event, data ){
if( this.callbacks.hasOwnProperty(event) ){
this.callbacks[event].forEach( (callback) => {
callback( data );
});
}
}
// -- -- --
}