1163 lines
35 KiB
JavaScript
1163 lines
35 KiB
JavaScript
|
/**
|
||
|
|
* System takes care of updating all the entities (based on their component data)
|
||
|
|
* @param apiSystem R3.API.System
|
||
|
|
* @constructor
|
||
|
|
*/
|
||
|
|
R3.System.Animation = function(
|
||
|
|
apiSystem
|
||
|
|
) {
|
||
|
|
R3.System.call(
|
||
|
|
this,
|
||
|
|
apiSystem
|
||
|
|
);
|
||
|
|
|
||
|
|
this.animations = [];
|
||
|
|
// this.textures = [];
|
||
|
|
// this.textureIds = [];
|
||
|
|
|
||
|
|
// this.latest = {};
|
||
|
|
this.textures = {};
|
||
|
|
this.textureIds = [];
|
||
|
|
|
||
|
|
// this.animationMeshAddedSubscription = null;
|
||
|
|
// this.animationMeshRemovedSubscription = null;
|
||
|
|
this.instanceCreatedSubscription = null;
|
||
|
|
this.removeComponentSubscription = null;
|
||
|
|
this.textureAnimatedSubscription = null;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sometimes we want to animate texture instances directly, without the overhead of a R3.Texture
|
||
|
|
*/
|
||
|
|
this.animateTextureInstanceSubscription = null;
|
||
|
|
};
|
||
|
|
|
||
|
|
R3.System.Animation.prototype = Object.create(R3.System.prototype);
|
||
|
|
R3.System.Animation.prototype.constructor = R3.System.Animation;
|
||
|
|
|
||
|
|
R3.System.Animation.prototype.start = function() {
|
||
|
|
|
||
|
|
R3.System.prototype.start.call(this);
|
||
|
|
|
||
|
|
this.beforeRenderSubscription = R3.Event.Subscribe(
|
||
|
|
R3.Event.BEFORE_RENDER,
|
||
|
|
this.beforeRender.bind(this)
|
||
|
|
);
|
||
|
|
|
||
|
|
this.animations = R3.EntityManager.Instance.queryComponents(R3.Component.ANIMATION);
|
||
|
|
|
||
|
|
//
|
||
|
|
// animations.map(function(animation){
|
||
|
|
// animation.meshes.map(
|
||
|
|
// function(mesh) {
|
||
|
|
// this.attachAnimation(animation, mesh);
|
||
|
|
// }.bind(this)
|
||
|
|
// );
|
||
|
|
// this.animations[animation.id] = animation;
|
||
|
|
// }.bind(this));
|
||
|
|
|
||
|
|
// this.animationMeshAddedSubscription = R3.Event.Subscribe(
|
||
|
|
// R3.Event.ANIMATION_MESH_ADDED,
|
||
|
|
// function(data) {
|
||
|
|
// this.attachAnimation(data.animation, data.mesh);
|
||
|
|
// }.bind(this)
|
||
|
|
// );
|
||
|
|
//
|
||
|
|
// this.animationMeshRemovedSubscription = R3.Event.Subscribe(
|
||
|
|
// R3.Event.ANIMATION_MESH_REMOVED,
|
||
|
|
// function(data) {
|
||
|
|
// this.detachAnimation(data.mesh);
|
||
|
|
// }.bind(this)
|
||
|
|
// );
|
||
|
|
|
||
|
|
this.instanceCreatedSubscription = R3.Event.Subscribe(
|
||
|
|
R3.Event.INSTANCE_CREATED,
|
||
|
|
this.instanceCreated.bind(this)
|
||
|
|
);
|
||
|
|
|
||
|
|
this.removeComponentSubscription = R3.Event.Subscribe(
|
||
|
|
R3.Event.REMOVE_COMPONENT,
|
||
|
|
this.removeComponent.bind(this)
|
||
|
|
);
|
||
|
|
|
||
|
|
this.textureAnimatedSubscription = R3.Event.Subscribe(
|
||
|
|
R3.Event.TEXTURE_ANIMATED_CHANGE,
|
||
|
|
this.textureAnimatedChange.bind(this)
|
||
|
|
);
|
||
|
|
|
||
|
|
this.animateTextureInstanceSubscription = R3.Event.Subscribe(
|
||
|
|
R3.Event.ANIMATE_TEXTURE_INSTANCE,
|
||
|
|
this.animateTextureInstance.bind(this)
|
||
|
|
)
|
||
|
|
};
|
||
|
|
|
||
|
|
R3.System.Animation.prototype.instanceCreated = function(data) {
|
||
|
|
|
||
|
|
if (
|
||
|
|
data.component instanceof R3.D3.Texture &&
|
||
|
|
data.component.animated
|
||
|
|
) {
|
||
|
|
|
||
|
|
if (data.component.repeat.x > 1 || data.component.repeat.x < 0) {
|
||
|
|
console.warn('cannot animate a texture with repeat.x greater than 1 or less than 0');
|
||
|
|
data.component.animated = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (data.component.repeat.y > 1 || data.component.repeat.y < 0) {
|
||
|
|
console.warn('cannot animate a texture with repeat.y greater than 1 or less than 0');
|
||
|
|
data.component.animated = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.textures[data.component.id] = data.component;
|
||
|
|
this.textureIds = Object.keys(this.textures);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (data.component instanceof R3.D3.Animation) {
|
||
|
|
|
||
|
|
R3.Utils.PushUnique(this.animations, data.component);
|
||
|
|
//
|
||
|
|
// this.animations[data.component.id] = data.component;
|
||
|
|
// data.component.meshes.map(
|
||
|
|
// function(mesh){
|
||
|
|
// this.attachAnimation(data.component, mesh)
|
||
|
|
// }.bind(this)
|
||
|
|
// );
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
R3.System.Animation.prototype.removeComponent = function(data) {
|
||
|
|
|
||
|
|
if (
|
||
|
|
data.component instanceof R3.D3.Texture &&
|
||
|
|
data.component.animated
|
||
|
|
) {
|
||
|
|
if (R3.Utils.UndefinedOrNull(this.textures[data.component.id])) {
|
||
|
|
console.warn('tried to remove an animated texture, which should have been in the list but isnt: ' + data.component.name);
|
||
|
|
} else {
|
||
|
|
delete this.textures[data.component.id];
|
||
|
|
this.textureIds = Object.keys(this.textures);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (data.component instanceof R3.D3.Animation) {
|
||
|
|
|
||
|
|
var index = this.animations.indexOf(data.component);
|
||
|
|
|
||
|
|
if (index === -1) {
|
||
|
|
console.warn('animation index out of sync');
|
||
|
|
} else {
|
||
|
|
this.animations.splice(index, 1);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (data.component instanceof R3.D3.Mesh) {
|
||
|
|
this.animations.map(
|
||
|
|
function(animation) {
|
||
|
|
|
||
|
|
var index = animation.meshes.indexOf(data.component);
|
||
|
|
|
||
|
|
if (index !== -1) {
|
||
|
|
animation.meshes.splice(index, 1);
|
||
|
|
animation.updateInstance('meshes');
|
||
|
|
}
|
||
|
|
}
|
||
|
|
)
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
R3.System.Animation.prototype.textureAnimatedChange = function(data) {
|
||
|
|
|
||
|
|
if (data.texture.animated) {
|
||
|
|
|
||
|
|
if (data.texture.repeat.x > 1 || data.texture.repeat.x < 0) {
|
||
|
|
console.warn('cannot animate a texture with repeat.x greater than 1 or less than 0');
|
||
|
|
data.texture.animated = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (data.texture.repeat.y > 1 || data.texture.repeat.y < 0) {
|
||
|
|
console.warn('cannot animate a texture with repeat.y greater than 1 or less than 0');
|
||
|
|
data.texture.animated = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
this.textures[data.texture.id] = data.texture;
|
||
|
|
this.textureIds = Object.keys(this.textures);
|
||
|
|
|
||
|
|
} else {
|
||
|
|
|
||
|
|
if (R3.Utils.UndefinedOrNull(this.textures[data.texture.id])) {
|
||
|
|
console.warn('tried to remove an animated texture, which should have been in the list but isnt: ' + data.texture.name);
|
||
|
|
} else {
|
||
|
|
delete this.textures[data.texture.id];
|
||
|
|
this.textureIds = Object.keys(this.textures);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This adds a texture instance directly on our textures to be animated - to bypass our R3 component and linking
|
||
|
|
* system, which adds too much overhead for managing textures
|
||
|
|
* @param data
|
||
|
|
*/
|
||
|
|
R3.System.Animation.prototype.animateTextureInstance = function(data) {
|
||
|
|
|
||
|
|
if (data.texture.repeat.x > 1 || data.texture.repeat.x < 0) {
|
||
|
|
console.warn('cannot animate a texture with repeat.x greater than 1 or less than 0');
|
||
|
|
data.texture.userData.animated = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (data.texture.repeat.y > 1 || data.texture.repeat.y < 0) {
|
||
|
|
console.warn('cannot animate a texture with repeat.y greater than 1 or less than 0');
|
||
|
|
data.texture.userData.animated = false;
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
data.texture.userData.animated = true;
|
||
|
|
|
||
|
|
this.textures[data.texture.id] = data.texture;
|
||
|
|
this.textureIds = Object.keys(this.textures);
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Performs a slight change on object[property][subProperty] from instance towards object
|
||
|
|
* @param object
|
||
|
|
* @param property
|
||
|
|
* @param subProperty
|
||
|
|
* @param increment
|
||
|
|
* @returns {boolean}
|
||
|
|
*/
|
||
|
|
R3.System.Animation.prototype.slightChange = function(object, property, subProperty, increment) {
|
||
|
|
|
||
|
|
var current = object.instance[property][subProperty];
|
||
|
|
var target = object[property][subProperty];
|
||
|
|
|
||
|
|
if (Math.abs(target - current) < increment) {
|
||
|
|
object.instance[property][subProperty] = object[property][subProperty];
|
||
|
|
return false;
|
||
|
|
} else if (current > target) {
|
||
|
|
object.instance[property][subProperty] -= increment;
|
||
|
|
} else {
|
||
|
|
object.instance[property][subProperty] += increment;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
};
|
||
|
|
|
||
|
|
R3.System.Animation.prototype.beforeRender = function(data) {
|
||
|
|
|
||
|
|
if (this.paused) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
var increment = 0;
|
||
|
|
|
||
|
|
this.animations.map(
|
||
|
|
function(animation) {
|
||
|
|
animation.meshes.map(
|
||
|
|
function(mesh) {
|
||
|
|
|
||
|
|
if (animation.rotationSpeed) {
|
||
|
|
/**
|
||
|
|
* Apply slight rotation to mesh
|
||
|
|
*/
|
||
|
|
increment = animation.rotationSpeed * data.delta;
|
||
|
|
|
||
|
|
this.slightChange(mesh, 'rotation', 'x', increment);
|
||
|
|
this.slightChange(mesh, 'rotation', 'y', increment);
|
||
|
|
this.slightChange(mesh, 'rotation', 'z', increment);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (animation.translationSpeed) {
|
||
|
|
/**
|
||
|
|
* Apply slight translation to mesh
|
||
|
|
*/
|
||
|
|
increment = animation.translationSpeed * data.delta;
|
||
|
|
|
||
|
|
this.slightChange(mesh, 'position', 'x', increment);
|
||
|
|
this.slightChange(mesh, 'position', 'y', increment);
|
||
|
|
this.slightChange(mesh, 'position', 'z', increment);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (animation.scaleSpeed) {
|
||
|
|
/**
|
||
|
|
* Apply slight scale to mesh
|
||
|
|
*/
|
||
|
|
increment = animation.scaleSpeed * data.delta;
|
||
|
|
|
||
|
|
this.slightChange(mesh, 'scale', 'x', increment);
|
||
|
|
this.slightChange(mesh, 'scale', 'y', increment);
|
||
|
|
this.slightChange(mesh, 'scale', 'z', increment);
|
||
|
|
}
|
||
|
|
}.bind(this)
|
||
|
|
)
|
||
|
|
}.bind(this)
|
||
|
|
);
|
||
|
|
|
||
|
|
this.textureIds.map(
|
||
|
|
|
||
|
|
function(textureId) {
|
||
|
|
|
||
|
|
var texture = this.textures[textureId];
|
||
|
|
|
||
|
|
if (texture.reverseAnimation || (texture.userData && texture.userData.reverseAnimation)) {
|
||
|
|
|
||
|
|
if (texture.forward === true || (texture.userData && texture.userData.forward === true)) {
|
||
|
|
texture.offset.x += texture.repeat.x;
|
||
|
|
if (texture.offset.x >= (1 - texture.repeat.x)) {
|
||
|
|
if (texture.offset.y >= (1 - texture.repeat.y)) {
|
||
|
|
texture.offset.x = (1 - texture.repeat.x);
|
||
|
|
texture.offset.y = (1 - texture.repeat.y);
|
||
|
|
|
||
|
|
if (texture.userData) {
|
||
|
|
texture.userData.forward = false;
|
||
|
|
} else {
|
||
|
|
texture.forward = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
texture.offset.x = 0;
|
||
|
|
texture.offset.y += texture.repeat.y;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (texture.forward === false || (texture.userData && texture.userData.forward === false)) {
|
||
|
|
texture.offset.x -= texture.repeat.x;
|
||
|
|
if (texture.offset.x <= 0) {
|
||
|
|
texture.offset.x = 0;
|
||
|
|
if (texture.offset.y < texture.repeat.y) {
|
||
|
|
texture.offset.x = texture.repeat.x;
|
||
|
|
texture.offset.y = 0;
|
||
|
|
if (texture.userData) {
|
||
|
|
texture.userData.forward = true;
|
||
|
|
} else {
|
||
|
|
texture.forward = true;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
texture.offset.x = (1 - texture.repeat.x);
|
||
|
|
texture.offset.y -= texture.repeat.y;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} else {
|
||
|
|
|
||
|
|
texture.offset.x += texture.repeat.x;
|
||
|
|
|
||
|
|
if (texture.offset.x >= (1 - texture.repeat.x)) {
|
||
|
|
if (texture.offset.y >= (1 - texture.repeat.y)) {
|
||
|
|
texture.offset.x = 0;
|
||
|
|
texture.offset.y = 0;
|
||
|
|
} else {
|
||
|
|
texture.offset.x = 0;
|
||
|
|
texture.offset.y += texture.repeat.y;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!texture.userData) {
|
||
|
|
texture.updateInstance('offset');
|
||
|
|
}
|
||
|
|
|
||
|
|
}.bind(this)
|
||
|
|
)
|
||
|
|
};
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Stop Animation System
|
||
|
|
*/
|
||
|
|
R3.System.Animation.prototype.stop = function() {
|
||
|
|
|
||
|
|
R3.System.prototype.stop.call(this);
|
||
|
|
|
||
|
|
this.beforeRenderSubscription.remove();
|
||
|
|
|
||
|
|
// this.animationMeshAddedSubscription.remove();
|
||
|
|
//
|
||
|
|
// this.animationMeshRemovedSubscription.remove();
|
||
|
|
//
|
||
|
|
this.animations = [];
|
||
|
|
|
||
|
|
this.instanceCreatedSubscription.remove();
|
||
|
|
|
||
|
|
this.removeComponentSubscription.remove();
|
||
|
|
|
||
|
|
this.textureAnimatedSubscription.remove();
|
||
|
|
|
||
|
|
this.animateTextureInstanceSubscription.remove();
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
R3.System.Animation.prototype.detachAnimation = function(mesh) {
|
||
|
|
|
||
|
|
var detached = false;
|
||
|
|
|
||
|
|
if (mesh.backupQuaternionAngleDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.quaternion,
|
||
|
|
'angle',
|
||
|
|
mesh.backupQuaternionAngleDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupQuaternionAngleDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupQuaternionAxisXDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.quaternion.axis,
|
||
|
|
'x',
|
||
|
|
mesh.backupQuaternionAxisXDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupQuaternionAxisXDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupQuaternionAxisYDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.quaternion.axis,
|
||
|
|
'y',
|
||
|
|
mesh.backupQuaternionAxisYDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupQuaternionAxisYDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupQuaternionAxisZDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.quaternion.axis,
|
||
|
|
'z',
|
||
|
|
mesh.backupQuaternionAxisZDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupQuaternionAxisXDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupRotationXDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.rotation,
|
||
|
|
'x',
|
||
|
|
mesh.backupRotationXDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupRotationXDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupRotationYDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.rotation,
|
||
|
|
'y',
|
||
|
|
mesh.backupRotationYDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupRotationYDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupRotationZDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.rotation,
|
||
|
|
'z',
|
||
|
|
mesh.backupRotationZDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupRotationZDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupPositionXDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.position,
|
||
|
|
'x',
|
||
|
|
mesh.backupPositionXDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupPositionXDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupPositionYDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.position,
|
||
|
|
'y',
|
||
|
|
mesh.backupPositionYDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupPositionYDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupPositionZDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.position,
|
||
|
|
'z',
|
||
|
|
mesh.backupPositionZDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupPositionZDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupScaleXDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.scale,
|
||
|
|
'x',
|
||
|
|
mesh.backupScaleXDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupScaleXDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupScaleYDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.scale,
|
||
|
|
'y',
|
||
|
|
mesh.backupScaleYDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupScaleYDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mesh.backupScaleZDescriptor) {
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.scale,
|
||
|
|
'z',
|
||
|
|
mesh.backupScaleZDescriptor
|
||
|
|
);
|
||
|
|
|
||
|
|
delete mesh.backupScaleZDescriptor;
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.latest[mesh.id]) {
|
||
|
|
|
||
|
|
mesh.rotation.x = this.latest[mesh.id].rotation.x;
|
||
|
|
mesh.rotation.y = this.latest[mesh.id].rotation.y;
|
||
|
|
mesh.rotation.z = this.latest[mesh.id].rotation.z;
|
||
|
|
|
||
|
|
mesh.position.x = this.latest[mesh.id].position.x;
|
||
|
|
mesh.position.y = this.latest[mesh.id].position.y;
|
||
|
|
mesh.position.z = this.latest[mesh.id].position.z;
|
||
|
|
|
||
|
|
mesh.scale.x = this.latest[mesh.id].scale.x;
|
||
|
|
mesh.scale.y = this.latest[mesh.id].scale.y;
|
||
|
|
mesh.scale.z = this.latest[mesh.id].scale.z;
|
||
|
|
|
||
|
|
mesh.quaternion.axis.x = this.latest[mesh.id].quaternion.axis.x;
|
||
|
|
mesh.quaternion.axis.y = this.latest[mesh.id].quaternion.axis.y;
|
||
|
|
mesh.quaternion.axis.z = this.latest[mesh.id].quaternion.axis.z;
|
||
|
|
|
||
|
|
mesh.quaternion.angle = this.latest[mesh.id].quaternion.angle;
|
||
|
|
|
||
|
|
delete this.latest[mesh.id];
|
||
|
|
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (this.animations[mesh.id]) {
|
||
|
|
delete this.animations[mesh.id];
|
||
|
|
detached = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (detached) {
|
||
|
|
mesh.updateInstance('position');
|
||
|
|
mesh.updateInstance('rotation');
|
||
|
|
mesh.updateInstance('scale');
|
||
|
|
}
|
||
|
|
|
||
|
|
};
|
||
|
|
*/
|
||
|
|
|
||
|
|
//R3.System.Animation.prototype.attachAnimation = function(animation, mesh) {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Initialize the property with the original mesh z value
|
||
|
|
*/
|
||
|
|
/* this.latest[mesh.id] = {
|
||
|
|
rotation : {
|
||
|
|
x : mesh.rotation.x,
|
||
|
|
y : mesh.rotation.y,
|
||
|
|
z : mesh.rotation.z
|
||
|
|
},
|
||
|
|
position : {
|
||
|
|
x : mesh.position.x,
|
||
|
|
y : mesh.position.y,
|
||
|
|
z : mesh.position.z
|
||
|
|
},
|
||
|
|
scale : {
|
||
|
|
x : mesh.scale.x,
|
||
|
|
y : mesh.scale.y,
|
||
|
|
z : mesh.scale.z
|
||
|
|
},
|
||
|
|
quaternion : {
|
||
|
|
axis : {
|
||
|
|
x : mesh.quaternion.axis.x,
|
||
|
|
y : mesh.quaternion.axis.y,
|
||
|
|
z : mesh.quaternion.axis.z
|
||
|
|
},
|
||
|
|
angle : mesh.quaternion.angle
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
this.animations[mesh.id] = [];
|
||
|
|
|
||
|
|
if (mesh.backupRotationXDescriptor) {
|
||
|
|
throw new Error('already a backed up x descriptor');
|
||
|
|
}
|
||
|
|
|
||
|
|
mesh.backupQuaternionAngleDescriptor = Object.getOwnPropertyDescriptor(mesh.quaternion, 'angle');
|
||
|
|
mesh.backupQuaternionAxisXDescriptor = Object.getOwnPropertyDescriptor(mesh.quaternion.axis, 'x');
|
||
|
|
mesh.backupQuaternionAxisYDescriptor = Object.getOwnPropertyDescriptor(mesh.quaternion.axis, 'y');
|
||
|
|
mesh.backupQuaternionAxisZDescriptor = Object.getOwnPropertyDescriptor(mesh.quaternion.axis, 'z');
|
||
|
|
mesh.backupRotationXDescriptor = Object.getOwnPropertyDescriptor(mesh.rotation, 'x');
|
||
|
|
mesh.backupRotationYDescriptor = Object.getOwnPropertyDescriptor(mesh.rotation, 'y');
|
||
|
|
mesh.backupRotationZDescriptor = Object.getOwnPropertyDescriptor(mesh.rotation, 'z');
|
||
|
|
mesh.backupPositionXDescriptor = Object.getOwnPropertyDescriptor(mesh.position, 'x');
|
||
|
|
mesh.backupPositionYDescriptor = Object.getOwnPropertyDescriptor(mesh.position, 'y');
|
||
|
|
mesh.backupPositionZDescriptor = Object.getOwnPropertyDescriptor(mesh.position, 'z');
|
||
|
|
mesh.backupScaleXDescriptor = Object.getOwnPropertyDescriptor(mesh.scale, 'x');
|
||
|
|
mesh.backupScaleYDescriptor = Object.getOwnPropertyDescriptor(mesh.scale, 'y');
|
||
|
|
mesh.backupScaleZDescriptor = Object.getOwnPropertyDescriptor(mesh.scale, 'z');
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.quaternion,
|
||
|
|
'angle',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'angle', 'quaternion'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'angle', 'quaternion'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.quaternion.axis,
|
||
|
|
'x',
|
||
|
|
{
|
||
|
|
'get': this.getSubProperty(mesh, 'x', 'quaternion', 'axis'),
|
||
|
|
'set': this.setSubProperty(mesh, animation, 'x', 'quaternion', 'axis'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.quaternion.axis,
|
||
|
|
'y',
|
||
|
|
{
|
||
|
|
'get': this.getSubProperty(mesh, 'y', 'quaternion', 'axis'),
|
||
|
|
'set': this.setSubProperty(mesh, animation, 'y', 'quaternion', 'axis'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.quaternion.axis,
|
||
|
|
'z',
|
||
|
|
{
|
||
|
|
'get': this.getSubProperty(mesh, 'z', 'quaternion', 'axis'),
|
||
|
|
'set': this.setSubProperty(mesh, animation, 'z', 'quaternion', 'axis'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.rotation,
|
||
|
|
'x',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'x', 'rotation'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'x', 'rotation'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.rotation,
|
||
|
|
'y',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'y', 'rotation'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'y', 'rotation'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.rotation,
|
||
|
|
'z',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'z', 'rotation'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'z', 'rotation'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.scale,
|
||
|
|
'x',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'x', 'scale'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'x', 'scale'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.scale,
|
||
|
|
'y',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'y', 'scale'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'y', 'scale'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.scale,
|
||
|
|
'z',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'z', 'scale'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'z', 'scale'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.position,
|
||
|
|
'x',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'x', 'position'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'x', 'position'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.position,
|
||
|
|
'y',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'y', 'position'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'y', 'position'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
|
||
|
|
Object.defineProperty(
|
||
|
|
mesh.position,
|
||
|
|
'z',
|
||
|
|
{
|
||
|
|
'get': this.getProperty(mesh, 'z', 'position'),
|
||
|
|
'set': this.setProperty(mesh, animation, 'z', 'position'),
|
||
|
|
'configurable': true
|
||
|
|
}
|
||
|
|
);
|
||
|
|
};
|
||
|
|
*/
|
||
|
|
// R3.System.Animation.prototype.getQuaternionAngle = function(mesh, animation) {
|
||
|
|
//
|
||
|
|
// return function() {
|
||
|
|
// return;
|
||
|
|
// /**
|
||
|
|
// * TODO: fix this shit..
|
||
|
|
// * Back up the current property descriptor
|
||
|
|
// */
|
||
|
|
// mesh.animationObject = {
|
||
|
|
// backupAngleDescriptor: Object.getOwnPropertyDescriptor(mesh.quaternion, 'angle'),
|
||
|
|
// targetAngle: mesh.quaternion.angle,
|
||
|
|
// angleIncrement: true,
|
||
|
|
// intermediateAngle: mesh.quaternion.angle,
|
||
|
|
// subscription: null,
|
||
|
|
// inProcess: false,
|
||
|
|
// blocking: animation.blocking//,
|
||
|
|
// // callbacks : [],
|
||
|
|
// // storedValues : []
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// var getIntermediateAngle = function () {
|
||
|
|
// return mesh.animationObject.intermediateAngle;
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// var getTargetAngle = function () {
|
||
|
|
//
|
||
|
|
// // if (mesh.animationObject.storedValues.length > 0) {
|
||
|
|
// // return mesh.animationObject.storedValues[mesh.animationObject.storedValues.length - 1];
|
||
|
|
// // }
|
||
|
|
//
|
||
|
|
// return mesh.animationObject.targetAngle;
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// var animateRotation = function (value) {
|
||
|
|
//
|
||
|
|
// mesh.animationObject.intermediateAngle += value;
|
||
|
|
//
|
||
|
|
// var done = false;
|
||
|
|
//
|
||
|
|
// if (mesh.animationObject.angleIncrement) {
|
||
|
|
// /**
|
||
|
|
// * We are rotating upwards
|
||
|
|
// */
|
||
|
|
// if (mesh.animationObject.intermediateAngle >= mesh.animationObject.targetAngle) {
|
||
|
|
// /**
|
||
|
|
// * We need to stop
|
||
|
|
// */
|
||
|
|
// done = true;
|
||
|
|
// }
|
||
|
|
// } else {
|
||
|
|
// /**
|
||
|
|
// * We are rotating downwards
|
||
|
|
// */
|
||
|
|
// if (mesh.animationObject.intermediateAngle <= mesh.animationObject.targetAngle) {
|
||
|
|
// /**
|
||
|
|
// * We need to stop
|
||
|
|
// */
|
||
|
|
// done = true;
|
||
|
|
// }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// if (done) {
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * We clamp to our target angle
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.intermediateAngle = mesh.animationObject.targetAngle;
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * We limit our intermediate angle between values of -pi and pi
|
||
|
|
// */
|
||
|
|
// while (mesh.animationObject.intermediateAngle > Math.PI) {
|
||
|
|
// mesh.animationObject.intermediateAngle -= (Math.PI * 2);
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// while (mesh.animationObject.intermediateAngle < -(Math.PI)) {
|
||
|
|
// mesh.animationObject.intermediateAngle += (Math.PI * 2);
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * We apply our new intermediate angle to our target
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.targetAngle = mesh.animationObject.intermediateAngle;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Apply the actual rotation to the mesh
|
||
|
|
// */
|
||
|
|
// mesh.updateInstanceRotationFromAxisAngle(mesh.quaternion.axis, mesh.animationObject.intermediateAngle);
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Check again if we are done, we need to do some additional work -
|
||
|
|
// */
|
||
|
|
// if (done) {
|
||
|
|
//
|
||
|
|
// if (!mesh.animationObject.subscription) {
|
||
|
|
// var message = 'mesh animation object subscription went missing for ';
|
||
|
|
// message += mesh.name + ': ';
|
||
|
|
// message += animation.name;
|
||
|
|
// console.warn(message);
|
||
|
|
// throw new Error(message);
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Stop subscribing to before render events
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.subscription.remove();
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * @type {null}
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.subscription = null;
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * For some meshes, when we are done with the animation, we want to apply
|
||
|
|
// * the current state of the mesh to the object data itself (i.e. update
|
||
|
|
// * its vertices etc)
|
||
|
|
// */
|
||
|
|
// if (animation.applyToMeshWhenDone) {
|
||
|
|
// /**
|
||
|
|
// * Now we say that our intermediate angle is zero, because we will apply our rotation
|
||
|
|
// * and this will prevent us from re-registering a new 'animationRender' event
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.targetAngle = 0;
|
||
|
|
// mesh.animationObject.intermediateAngle = 0;
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Apply our position, rotation and scale to the mesh
|
||
|
|
// */
|
||
|
|
// mesh.applyPositionRotationScale();
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Tell our animation component that it is no longer in process...
|
||
|
|
// * @type {boolean}
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.inProcess = false;
|
||
|
|
//
|
||
|
|
// // if (mesh.animationObject.callbacks.length > 0) {
|
||
|
|
// // var callback = mesh.animationObject.callbacks[0];
|
||
|
|
// // mesh.animationObject.callbacks.splice(0,1);
|
||
|
|
// // callback();
|
||
|
|
// // }
|
||
|
|
//
|
||
|
|
// // mesh.animationObject.storedValues = [];
|
||
|
|
// }
|
||
|
|
// };
|
||
|
|
// }
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// R3.System.Animation.prototype.setQuaternionAngle = function(mesh, animation) {
|
||
|
|
//
|
||
|
|
// return function(value) {
|
||
|
|
// return;
|
||
|
|
// /**
|
||
|
|
// * TODO: update this shit
|
||
|
|
// */
|
||
|
|
// /**
|
||
|
|
// * Check if we have work to do
|
||
|
|
// */
|
||
|
|
// if (mesh.animationObject.intermediateAngle === value) {
|
||
|
|
//
|
||
|
|
// mesh.animationObject.inProcess = false;
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Nothing to do
|
||
|
|
// */
|
||
|
|
// return;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Check if we have another animation in process
|
||
|
|
// */
|
||
|
|
// if (mesh.animationObject.inProcess && mesh.animationObject.blocking) {
|
||
|
|
//
|
||
|
|
// console.log('another animation is already in process');
|
||
|
|
//
|
||
|
|
// // setTargetAngle(value);
|
||
|
|
//
|
||
|
|
// // R3.Utils.PushUnique(mesh.animationObject.storedValues, value);
|
||
|
|
// //
|
||
|
|
// // mesh.animationObject.callbacks.push(
|
||
|
|
// // function(__value) {
|
||
|
|
// // return function(){
|
||
|
|
// // mesh.quaternion.angle = __value;
|
||
|
|
// // }
|
||
|
|
// // }(value)
|
||
|
|
// // );
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Respond that our angle is actually our target angle (it will be that soon)
|
||
|
|
// */
|
||
|
|
// return;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * We indicate that we now have an animation in process
|
||
|
|
// * @type {boolean}
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.inProcess = true;
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Ok - all good - lets start the animation
|
||
|
|
// */
|
||
|
|
// if (mesh.animationObject.intermediateAngle > value) {
|
||
|
|
// /**
|
||
|
|
// * We will rotate towards by decrementing
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.angleIncrement = false;
|
||
|
|
// } else {
|
||
|
|
// /**
|
||
|
|
// * We will rotate towards by incrementing
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.angleIncrement = true;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * We say what our target angle is - when we reach our target angle, we want
|
||
|
|
// * to stop our animation
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.targetAngle = value;
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * Now we subscribe to 'before render' events, and slowly increment the value
|
||
|
|
// * @type {{fn, remove}}
|
||
|
|
// */
|
||
|
|
// mesh.animationObject.subscription = R3.Event.Subscribe(
|
||
|
|
// R3.Event.BEFORE_RENDER,
|
||
|
|
// function(data) {
|
||
|
|
//
|
||
|
|
// var increment = Math.abs(animation.rotationSpeed);
|
||
|
|
//
|
||
|
|
// if (!mesh.animationObject.angleIncrement) {
|
||
|
|
// increment *= -1;
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// animateRotation(data.delta * increment);
|
||
|
|
// }
|
||
|
|
// );
|
||
|
|
// }
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// R3.System.Animation.prototype.getQuaternionAxisX = function(mesh, animation) {
|
||
|
|
// return function() {
|
||
|
|
// return this.latest[mesh.id].quaternion.axis.x;
|
||
|
|
// }.bind(this);
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// R3.System.Animation.prototype.setQuaternionAxisX = function(mesh, animation) {
|
||
|
|
// return function(value) {
|
||
|
|
// this.latest[mesh.id].quaternion.axis.x = value;
|
||
|
|
// }.bind(this);
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// R3.System.Animation.prototype.getQuaternionAxisY = function(mesh, animation) {
|
||
|
|
// return function() {
|
||
|
|
// return this.latest[mesh.id].quaternion.axis.y;
|
||
|
|
// }.bind(this);
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// R3.System.Animation.prototype.setQuaternionAxisY = function(mesh, animation) {
|
||
|
|
// return function(value) {
|
||
|
|
// this.latest[mesh.id].quaternion.axis.y = value;
|
||
|
|
// }.bind(this);
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// R3.System.Animation.prototype.getQuaternionAxisZ = function(mesh, animation) {
|
||
|
|
// return function() {
|
||
|
|
// return this.latest[mesh.id].quaternion.axis.z;
|
||
|
|
// }.bind(this);
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// R3.System.Animation.prototype.setQuaternionAxisZ = function(mesh, animation) {
|
||
|
|
// return function(value) {
|
||
|
|
// this.latest[mesh.id].quaternion.axis.z = value;
|
||
|
|
// }.bind(this);
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// R3.System.Animation.prototype.getSubProperty = function(mesh, axis, property, subProperty) {
|
||
|
|
// return function() {
|
||
|
|
// return this.latest[mesh.id][property][subProperty][axis];
|
||
|
|
// }.bind(this);
|
||
|
|
// };
|
||
|
|
|
||
|
|
// R3.System.Animation.prototype.setSubProperty = function(mesh, animation, axis, property, subProperty) {
|
||
|
|
// return function(value) {
|
||
|
|
//
|
||
|
|
// var from = Number(this.latest[mesh.id][property][subProperty][axis]);
|
||
|
|
//
|
||
|
|
// this.latest[mesh.id][property][subProperty][axis] = value;
|
||
|
|
//
|
||
|
|
// if (property === 'position') {
|
||
|
|
// /**
|
||
|
|
// * Look for other position animations
|
||
|
|
// * TODO:check when not super exausted
|
||
|
|
// */
|
||
|
|
// // var positionAnimationObject = this.animations[mesh.id].reduce(
|
||
|
|
// // function(result, animationObject) {
|
||
|
|
// //
|
||
|
|
// // if (animationObject.type === 'position') {
|
||
|
|
// // result = animationObject;
|
||
|
|
// // }
|
||
|
|
// //
|
||
|
|
// // return result;
|
||
|
|
// // },
|
||
|
|
// // null
|
||
|
|
// // );
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * We found another position animation - just update the 'to' property
|
||
|
|
// */
|
||
|
|
// // if (positionAnimationObject) {
|
||
|
|
// // positionAnimationObject.to = value;
|
||
|
|
// // return;
|
||
|
|
// // }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// this.animations[mesh.id].push(
|
||
|
|
// {
|
||
|
|
// type : property,
|
||
|
|
// axis : axis,
|
||
|
|
// from : from,
|
||
|
|
// to : value,
|
||
|
|
// animation : animation,
|
||
|
|
// mesh : mesh
|
||
|
|
// }
|
||
|
|
// );
|
||
|
|
//
|
||
|
|
// }.bind(this)
|
||
|
|
// };
|
||
|
|
|
||
|
|
// R3.System.Animation.prototype.getProperty = function(mesh, axis, property) {
|
||
|
|
// return function() {
|
||
|
|
// return this.latest[mesh.id][property][axis];
|
||
|
|
// }.bind(this);
|
||
|
|
// };
|
||
|
|
//
|
||
|
|
// R3.System.Animation.prototype.setProperty = function(mesh, animation, axis, property) {
|
||
|
|
// return function(value) {
|
||
|
|
//
|
||
|
|
// var from = Number(this.latest[mesh.id][property][axis]);
|
||
|
|
//
|
||
|
|
// this.latest[mesh.id][property][axis] = value;
|
||
|
|
//
|
||
|
|
// if (property === 'position') {
|
||
|
|
// /**
|
||
|
|
// * Look for other position animations
|
||
|
|
// * TODO:check when not super exausted
|
||
|
|
// */
|
||
|
|
// // var positionAnimationObject = this.animations[mesh.id].reduce(
|
||
|
|
// // function(result, animationObject) {
|
||
|
|
// //
|
||
|
|
// // if (animationObject.type === 'position') {
|
||
|
|
// // result = animationObject;
|
||
|
|
// // }
|
||
|
|
// //
|
||
|
|
// // return result;
|
||
|
|
// // },
|
||
|
|
// // null
|
||
|
|
// // );
|
||
|
|
//
|
||
|
|
// /**
|
||
|
|
// * We found another position animation - just update the 'to' property
|
||
|
|
// */
|
||
|
|
// // if (positionAnimationObject) {
|
||
|
|
// // positionAnimationObject.to = value;
|
||
|
|
// // return;
|
||
|
|
// // }
|
||
|
|
// }
|
||
|
|
//
|
||
|
|
// this.animations[mesh.id].push(
|
||
|
|
// {
|
||
|
|
// type : property,
|
||
|
|
// axis : axis,
|
||
|
|
// from : from,
|
||
|
|
// to : value,
|
||
|
|
// animation : animation,
|
||
|
|
// mesh : mesh
|
||
|
|
// }
|
||
|
|
// );
|
||
|
|
//
|
||
|
|
// }.bind(this)
|
||
|
|
// };
|
||
|
|
|