// Start is called before the first frame update
void Start()
{
dataPose0 = new animationTransformData();
dataPose1 = new animationTransformData();
dataPose0.setTransform(pose0);
dataPose1.setTransform(pose1);
}
public static animationTransformData average(identity nIdentity, animationTransformData pose_0, animationTransformData pose_1, float parameter0, float parameter1, bool usingQuaternion)
{
animationTransformData newPose_0 = scale(new identity(), pose_0, parameter0, usingQuaternion);
animationTransformData newPose_1 = scale(new identity(), pose_1, parameter1, usingQuaternion);
return(add(newPose_0, newPose_1, usingQuaternion));
}
public void setData(AnimationClip clip, int keyIndex)
{
size = clip.animData.poseBase.Length;
poseData = new animationTransformData[size];
for (int i = 0; i < size; i++)
{
KeyFrame key = clip.getcurrentFrame(keyIndex, i);
animationTransformData newdata = new animationTransformData(key.keyPosition, Quaternion.Euler(key.keyRotation), key.scale);
poseData[i] = newdata;
}
}
public void setData(AnimationDataHierarchal animdata, int keyIndex)
{
size = animdata.poseBase.Length;
poseData = new animationTransformData[size];
for (int i = 0; i < size; i++)
{
KeyFrame key = animdata.poseBase[i].keyFrames[keyIndex];
animationTransformData newdata = new animationTransformData(key.keyPosition, Quaternion.Euler(key.keyRotation), key.scale);
poseData[i] = newdata;
}
}
private void Update()
{
for (int i = 0; i < animData.poseBase.Length; i++)
{
animationTransformData poseresult = new animationTransformData();
animationTransformData dataPose0 = new animationTransformData();
animationTransformData dataPose1 = new animationTransformData();
KeyFrame key0 = animData.poseBase[i].keyFrames[keyframe0];
KeyFrame key1 = animData.poseBase[i].keyFrames[keyframe1];
dataPose0.setTransformIndividual(key0.keyPosition, Quaternion.Euler(key0.keyRotation), new Vector3(1, 1, 1));
dataPose1.setTransformIndividual(key1.keyPosition, Quaternion.Euler(key1.keyRotation), new Vector3(1, 1, 1));
switch (blendMode)
{
case testBlendMode.LERP:
poseresult = blendStatic.lerp(dataPose0, dataPose1, parameter0, usingQuaternion);
break;
case testBlendMode.ADD:
poseresult = blendStatic.add(dataPose0, dataPose1, usingQuaternion);
break;
case testBlendMode.SCALE:
poseresult = blendStatic.scale(new identity(), dataPose0, parameter0, usingQuaternion);
break;
case testBlendMode.AVERAGE:
poseresult = blendStatic.average(new identity(), dataPose0, dataPose1, parameter0, parameter1, usingQuaternion);
break;
}
int parentIndex = animData.poseBase[i].parentNodeIndex;
Vector3 localPosition = animData.poseBase[i].getLocalPosition();
Vector3 localRotation = animData.poseBase[i].getLocalRotationEuler();
//find delta change from localpose
Matrix4x4 deltaMatrix = Matrix4x4.TRS(localPosition + poseresult.localPosition, Quaternion.Euler(localRotation + poseresult.localRotation.eulerAngles), new Vector4(1, 1, 1, 1));
if (parentIndex == -1)
{
//is root
animData.poseBase[i].currentTransform = deltaMatrix;
}
else
{
//current transform = take the parent index current transform and multiply with delta matrix
animData.poseBase[i].currentTransform = animData.poseBase[parentIndex].currentTransform * deltaMatrix;
}
animData.poseBase[i].updateNewPosition(gameObjectData.getObject(i));
}
}
//binds the objects in the object hierarchy to a pose, either current or base
void setPose(bool boundToCurrent)
{
for (int jointID = 0; jointID < animData.poseBase.Length; jointID++)
{
animationTransformData tData = new animationTransformData(0);
if (boundToCurrent)
{
KeyFrame currentKey = animData.poseBase[jointID].keyFrames[currentKeyFrame];
tData.setTransformIndividual(currentKey.keyPosition, currentKey.keyQRotation, currentKey.scale);
}
ForwardKinematics.setData(gameObjectHierarchy, animData, tData, jointID);
}
}
public static animationTransformData scale(identity nIdentity, animationTransformData pose_1, float parameter, bool usingQuaternion)
{
animationTransformData poseresult = new animationTransformData();
//translation: literal linear interpolation
poseresult.localPosition = Vector3.Lerp(nIdentity.position, pose_1.localPosition, parameter);
//scale: ditto
poseresult.localScale = Vector3.Lerp(nIdentity.scale, pose_1.localScale, parameter);
//rotation: slerp if quaternion (or NLERP) otherwise euler lerp
if (usingQuaternion)
{
poseresult.localRotation = Quaternion.Slerp(nIdentity.rotation, pose_1.localRotation, parameter);
}
else
{
poseresult.localEulerAnglesSet(Vector3.Lerp(nIdentity.rotation.eulerAngles, pose_1.localEulerAngles(), parameter));
}
return(poseresult);
}
private void Update()
{
switch (blendMode)
{
case testBlendMode.LERP:
poseresult = blendStatic.lerp(dataPose0, dataPose1, parameter0, usingQuaternion);
break;
case testBlendMode.ADD:
poseresult = blendStatic.add(dataPose0, dataPose1, usingQuaternion);
break;
case testBlendMode.SCALE:
poseresult = blendStatic.scale(new identity(), dataPose0, parameter0, usingQuaternion);
break;
case testBlendMode.AVERAGE:
poseresult = blendStatic.average(new identity(), dataPose0, dataPose1, parameter0, parameter1, usingQuaternion);
break;
}
poseresult.changeTransform(this.transform);
}
public static animationTransformData add(animationTransformData pose0, animationTransformData pose1, bool usingQuaternion)
{
animationTransformData poseresult = new animationTransformData();
//translation literal addition
poseresult.localPosition = pose0.localPosition + pose1.localPosition;
//scale component-wise multiplication
poseresult.localScale = pose0.localScale;
poseresult.localScale.Scale(pose1.localScale);
//rotation: quaternioni concatenation or Euler addition
if (usingQuaternion)
{
poseresult.localRotation = pose0.localRotation * pose1.localRotation;
}
else
{
poseresult.localEulerAnglesSet(pose0.localEulerAngles() + pose1.localEulerAngles());
}
return(poseresult);
}
void blendAnimation()
{
bool usingQuaternion = true;
for (int i = 0; i < currentAnim.poseBase.Length; i++)
{
animationTransformData poseresult = new animationTransformData();
animationTransformData dataPose0 = new animationTransformData();
animationTransformData dataPose1 = new animationTransformData();
KeyFrame key0 = prevAnim.poseBase[i].keyFrames[currentFrame];
KeyFrame key1 = currentAnim.poseBase[i].keyFrames[currentFrame];
dataPose0.setTransformIndividual(key0.keyPosition, Quaternion.Euler(key0.keyRotation), new Vector3(1, 1, 1));
dataPose1.setTransformIndividual(key1.keyPosition, Quaternion.Euler(key1.keyRotation), new Vector3(1, 1, 1));
poseresult = blendStatic.lerp(dataPose0, dataPose1, transitionParameter, usingQuaternion);
int parentIndex = currentAnim.poseBase[i].parentNodeIndex;
Vector3 localPosition = currentAnim.poseBase[i].getLocalPosition();
Vector3 localRotation = currentAnim.poseBase[i].getLocalRotationEuler();
//find delta change from localpose
Matrix4x4 deltaMatrix = Matrix4x4.TRS(localPosition + poseresult.localPosition, Quaternion.Euler(localRotation + poseresult.localRotation.eulerAngles), new Vector4(1, 1, 1, 1));
if (parentIndex == -1)
{
//is root
currentAnim.poseBase[i].currentTransform = deltaMatrix;
}
else
{
//current transform = take the parent index current transform and multiply with delta matrix
currentAnim.poseBase[i].currentTransform = currentAnim.poseBase[parentIndex].currentTransform * deltaMatrix;
}
currentAnim.poseBase[i].updateNewPosition(objectHierarchy.getObject(i));
}
}
public void setPoseData(animationTransformData data, int index)
{
poseData[index] = data;
}
//used for blending, given a joint with a transform data and the hierarchies do forward kinematics
public static void setData(gameObjectMain objHierarchy, AnimationDataHierarchal animData, animationTransformData transformData, int jointID)
{
int parentIndex = animData.poseBase[jointID].parentNodeIndex;
Vector3 localPosition = animData.poseBase[jointID].getLocalPosition();
Vector3 localRotation = animData.poseBase[jointID].getLocalRotationEuler();
//find delta change from localpose
Matrix4x4 deltaMatrix = Matrix4x4.TRS(localPosition + transformData.localPosition, Quaternion.Euler(localRotation + transformData.localRotation.eulerAngles), new Vector4(1, 1, 1, 1));
if (parentIndex == -1)
{
//is root
animData.poseBase[jointID].currentTransform = deltaMatrix;
}
else
{
//current transform = take the parent index current transform and multiply with delta matrix
animData.poseBase[jointID].currentTransform = animData.poseBase[parentIndex].currentTransform * deltaMatrix;
}
animData.poseBase[jointID].updateNewPosition(objHierarchy.ObjectHierarchy[jointID]);
}
public virtual blendPoseData blendOperation(BlendingTree parentTree, int currentFrameID)
{
blendPoseData firstPose = new blendPoseData();
blendPoseData secondPose = new blendPoseData();
int length = 0;
switch (nodeType)
{
case blendType.BLEND_LERP:
firstPose = parentTree.getIndexedNode(nextID1).blendOperation(parentTree, currentFrameID);
secondPose = parentTree.getIndexedNode(nextID2).blendOperation(parentTree, currentFrameID);
length = firstPose.size;
for (int i = 0; i < length; i++)
{
animationTransformData transformData;
transformData = blendStatic.lerp(firstPose.getPoseData(i), secondPose.getPoseData(i), parameter1, true);
firstPose.setPoseData(transformData, i);
}
return(firstPose);
case blendType.BLEND_ADD:
firstPose = parentTree.getIndexedNode(nextID1).blendOperation(parentTree, currentFrameID);
secondPose = parentTree.getIndexedNode(nextID2).blendOperation(parentTree, currentFrameID);
length = firstPose.size;
for (int i = 0; i < length; i++)
{
animationTransformData transformData;
transformData = blendStatic.add(firstPose.getPoseData(i), secondPose.getPoseData(i), true);
firstPose.setPoseData(transformData, i);
}
return(firstPose);
case blendType.BLEND_SCALE:
firstPose = parentTree.getIndexedNode(nextID1).blendOperation(parentTree, currentFrameID);
length = firstPose.size;
for (int i = 0; i < length; i++)
{
animationTransformData transformData = firstPose.getPoseData(i);
identity newIdentity = new identity();
transformData = blendStatic.scale(newIdentity, transformData, parameter1, true);
firstPose.setPoseData(transformData, i);
}
return(firstPose);
case blendType.BLEND_AVG:
firstPose = parentTree.getIndexedNode(nextID1).blendOperation(parentTree, currentFrameID);
secondPose = parentTree.getIndexedNode(nextID2).blendOperation(parentTree, currentFrameID);
length = firstPose.size;
for (int i = 0; i < length; i++)
{
animationTransformData transformData;
identity nIdentity = new identity();
transformData = blendStatic.average(nIdentity, firstPose.getPoseData(i), secondPose.getPoseData(i), parameter1, parameter2, true);
firstPose.setPoseData(transformData, i);
}
return(firstPose);
case blendType.BLEND_END:
blendPoseData newPoseData = new blendPoseData();
newPoseData.setData(clip, currentFrameID);
return(newPoseData);
default:
return(firstPose);
}
}
