Luis Gonzalez
1065 lines
37 KiB
C#
1065 lines
37 KiB
C#
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using Rukhanka.Toolbox;
|
|
using Unity.Burst;
|
|
using Unity.Burst.CompilerServices;
|
|
using Unity.Burst.Intrinsics;
|
|
using Unity.Collections;
|
|
using Unity.Collections.LowLevel.Unsafe;
|
|
using Unity.Entities;
|
|
using Unity.Jobs;
|
|
using Unity.Mathematics;
|
|
using Unity.Transforms;
|
|
using UnityEngine;
|
|
|
|
//=================================================================================================================//
|
|
|
|
[assembly: InternalsVisibleTo("Rukhanka.Tests")]
|
|
|
|
namespace Rukhanka
|
|
{
|
|
partial struct AnimationProcessSystem
|
|
{
|
|
|
|
[BurstCompile]
|
|
public struct ComputeBoneAnimationJob: IJobParallelForDefer
|
|
{
|
|
[NativeDisableParallelForRestriction]
|
|
public NativeList<BoneTransform> animatedBonesBuffer;
|
|
[NativeDisableParallelForRestriction]
|
|
public NativeList<ulong> boneTransformFlagsArr;
|
|
[ReadOnly]
|
|
public NativeList<int3> boneToEntityArr;
|
|
[ReadOnly]
|
|
public BufferLookup<AnimationToProcessComponent> animationsToProcessLookup;
|
|
[ReadOnly]
|
|
public NativeList<RigDefinitionComponent> rigDefs;
|
|
[ReadOnly]
|
|
public NativeList<Entity> entityArr;
|
|
|
|
[NativeDisableParallelForRestriction]
|
|
public BufferLookup<RootMotionAnimationStateComponent> rootMotionAnimStateBufferLookup;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
[SkipLocalsInit]
|
|
public void Execute(int globalBoneIndex)
|
|
{
|
|
var boneToEntityIndex = boneToEntityArr[globalBoneIndex];
|
|
var (rigBoneIndex, entityIndex, rigBoneCount) = (boneToEntityIndex.y & 0xffff, boneToEntityIndex.x, boneToEntityIndex.y >> 16);
|
|
var e = entityArr[entityIndex];
|
|
|
|
var rigDef = rigDefs[entityIndex];
|
|
var rigBlobAsset = rigDef.rigBlob;
|
|
ref var rb = ref rigBlobAsset.Value.bones[rigBoneIndex];
|
|
var animationsToProcess = animationsToProcessLookup[e];
|
|
|
|
// Early exit if no animations
|
|
if (animationsToProcess.IsEmpty)
|
|
return;
|
|
|
|
var transformFlags = RuntimeAnimationData.GetAnimationTransformFlagsRW(boneToEntityArr, boneTransformFlagsArr, globalBoneIndex, rigBoneCount);
|
|
GetHumanRotationDataForSkeletonBone(out var humanBoneInfo, ref rigBlobAsset.Value.humanData, rigBoneIndex);
|
|
|
|
// There are separate tracks for root motion
|
|
var boneNameHash = rb.hash;
|
|
if (rigDef.applyRootMotion && (rigBlobAsset.Value.rootBoneIndex == rigBoneIndex || rigBoneIndex == 0))
|
|
boneNameHash = ModifyBoneHashForRootMotion(boneNameHash);
|
|
|
|
var rootMotionDeltaBone = rigDef.applyRootMotion && rigBoneIndex == 0;
|
|
PrepareRootMotionStateBuffers(e, animationsToProcess, out var curRootMotionState, out var newRootMotionState, rootMotionDeltaBone);
|
|
|
|
// Reference pose for root motion delta should be identity
|
|
var refPose = Hint.Unlikely(rootMotionDeltaBone) ? BoneTransform.Identity() : rb.refPose;
|
|
|
|
var blendedBonePose = refPose;
|
|
var layerPose = new BoneTransform();
|
|
var weightSum = 0.0f;
|
|
float3 layerFlags = 0;
|
|
float3 totalFlags = 0;
|
|
LayerInfo layerInfo = default;
|
|
|
|
for (int ai = 0; ai < animationsToProcess.Length; ++ai)
|
|
{
|
|
var atp = animationsToProcess[ai];
|
|
// Root bone should be always included in animation computation
|
|
var inAvatarMask = IsBoneInAvatarMask(rigBoneIndex, rb.humanBodyPart, atp.avatarMask) || rootMotionDeltaBone;
|
|
if (atp.animation == BlobAssetReference<AnimationClipBlob>.Null || atp.weight == 0 || atp.layerWeight == 0 || !inAvatarMask)
|
|
continue;
|
|
|
|
var curLayerInfo = GetLayerInfoFromAnimation(atp);
|
|
|
|
// Apply layer animations
|
|
if (layerInfo.index != curLayerInfo.index)
|
|
{
|
|
blendedBonePose = BlendLayerPose(blendedBonePose, layerPose, refPose, layerInfo, weightSum, layerFlags);
|
|
weightSum = 0;
|
|
layerFlags = 0;
|
|
layerPose = new BoneTransform();
|
|
}
|
|
layerInfo = curLayerInfo;
|
|
|
|
var animTime = NormalizeAnimationTime(atp.time, ref atp.animation.Value);
|
|
ref var clipTracks = ref atp.animation.Value.clipTracks;
|
|
|
|
var boneHasAnimation = SampleAnimation
|
|
(
|
|
ref atp.animation.Value,
|
|
animTime,
|
|
rigBoneIndex,
|
|
boneNameHash,
|
|
atp.blendMode,
|
|
humanBoneInfo,
|
|
out var bonePose,
|
|
out var flags,
|
|
out var trackRange
|
|
);
|
|
|
|
if (boneHasAnimation)
|
|
{
|
|
if (Hint.Unlikely(rootMotionDeltaBone))
|
|
ProcessRootMotionDeltas(ref bonePose, ref clipTracks, trackRange, atp, curRootMotionState, ref newRootMotionState);
|
|
weightSum += atp.weight;
|
|
layerFlags += flags;
|
|
totalFlags += flags;
|
|
layerPose = AppendScaledPose(layerPose, bonePose, atp.weight);
|
|
}
|
|
}
|
|
|
|
// Apply top layer pose
|
|
blendedBonePose = BlendLayerPose(blendedBonePose, layerPose, refPose, layerInfo, weightSum, layerFlags);
|
|
|
|
SetTransformFlags(totalFlags, transformFlags, rigBoneIndex);
|
|
animatedBonesBuffer[globalBoneIndex] = blendedBonePose;
|
|
if (rootMotionDeltaBone)
|
|
SetRootMotionStateToComponentBuffer(newRootMotionState, e);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BoneTransform BlendLayerPose(in BoneTransform curPose, BoneTransform layerPose, in BoneTransform refPose, in LayerInfo layerInfo, float weightSum, float3 layerFlags)
|
|
{
|
|
BoneTransform rv = curPose;
|
|
if (Hint.Likely(layerInfo.blendMode == AnimationBlendingMode.Override))
|
|
{
|
|
// For override layers we need to apply reminder from the reference pose if layer total animation weight is not equal to one
|
|
if (Hint.Unlikely(weightSum < 1))
|
|
layerPose = AppendScaledPose(layerPose, refPose, math.max(0, 1 - weightSum));
|
|
|
|
if (Hint.Likely(layerFlags.x > 0))
|
|
{
|
|
rv.pos = math.lerp(curPose.pos, layerPose.pos, layerInfo.weight);
|
|
}
|
|
if (Hint.Likely(layerFlags.y > 0))
|
|
{
|
|
layerPose.rot = math.normalizesafe(layerPose.rot);
|
|
layerPose.rot = MathUtils.ShortestRotation(curPose.rot, layerPose.rot);
|
|
rv.rot = math.nlerp(curPose.rot.value, layerPose.rot.value, layerInfo.weight);
|
|
}
|
|
if (Hint.Likely(layerFlags.z > 0))
|
|
{
|
|
rv.scale = math.lerp(curPose.scale, layerPose.scale, layerInfo.weight);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Hint.Likely(layerFlags.x > 0))
|
|
{
|
|
rv.pos = curPose.pos + layerPose.pos * layerInfo.weight;
|
|
}
|
|
if (Hint.Likely(layerFlags.y > 0))
|
|
{
|
|
quaternion layerRot = math.normalizesafe(new float4(layerPose.rot.value.xyz * layerInfo.weight, layerPose.rot.value.w));
|
|
layerRot = MathUtils.ShortestRotation(curPose.rot, layerRot);
|
|
rv.rot = math.mul(curPose.rot, layerRot);
|
|
}
|
|
if (Hint.Likely(layerFlags.z > 0))
|
|
{
|
|
rv.scale = curPose.scale * math.lerp(1, layerPose.scale, layerInfo.weight);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BoneTransform AppendScaledPose(in BoneTransform curPose, BoneTransform addedPose, float weight)
|
|
{
|
|
addedPose.rot = MathUtils.ShortestRotation(curPose.rot, addedPose.rot);
|
|
BoneTransform rv = new BoneTransform()
|
|
{
|
|
pos = curPose.pos + addedPose.pos * weight,
|
|
rot = new quaternion(curPose.rot.value + addedPose.rot.value * weight),
|
|
scale = curPose.scale + addedPose.scale * weight
|
|
};
|
|
return rv;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public static uint ModifyBoneHashForRootMotion(uint h)
|
|
{
|
|
var rv = math.hash(new uint2(h, h * 2));
|
|
return rv;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void PrepareRootMotionStateBuffers
|
|
(
|
|
Entity e,
|
|
in DynamicBuffer<AnimationToProcessComponent> atps,
|
|
out NativeArray<RootMotionAnimationStateComponent> curRootMotionState,
|
|
out NativeList<RootMotionAnimationStateComponent> newRootMotionState,
|
|
bool isRootMotionBone
|
|
)
|
|
{
|
|
curRootMotionState = default;
|
|
newRootMotionState = default;
|
|
|
|
if (Hint.Likely(!isRootMotionBone)) return;
|
|
|
|
if (rootMotionAnimStateBufferLookup.HasBuffer(e))
|
|
curRootMotionState = rootMotionAnimStateBufferLookup[e].AsNativeArray();
|
|
|
|
newRootMotionState = new NativeList<RootMotionAnimationStateComponent>(atps.Length, Allocator.Temp);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void ProcessRootMotionDeltas
|
|
(
|
|
ref BoneTransform bonePose,
|
|
ref TrackSet trackSet,
|
|
int2 trackRange,
|
|
in AnimationToProcessComponent atp,
|
|
in NativeArray<RootMotionAnimationStateComponent> curRootMotionState,
|
|
ref NativeList<RootMotionAnimationStateComponent> newRootMotionState
|
|
)
|
|
{
|
|
// Special care for root motion animation loops
|
|
HandleRootMotionLoops(ref bonePose, ref trackSet, trackRange, atp);
|
|
|
|
BoneTransform rootMotionPrevPose = bonePose;
|
|
|
|
// Find animation history in history buffer
|
|
var historyBufferIndex = 0;
|
|
for (; curRootMotionState.IsCreated && historyBufferIndex < curRootMotionState.Length && curRootMotionState[historyBufferIndex].uniqueMotionId != atp.motionId; ++historyBufferIndex){ }
|
|
|
|
var initialFrame = historyBufferIndex >= curRootMotionState.Length;
|
|
|
|
if (Hint.Unlikely(!initialFrame))
|
|
{
|
|
rootMotionPrevPose = curRootMotionState[historyBufferIndex].animationState;
|
|
}
|
|
|
|
var rmasc = new RootMotionAnimationStateComponent() { uniqueMotionId = atp.motionId, animationState = bonePose };
|
|
newRootMotionState.Add(rmasc);
|
|
|
|
var invPrevPose = BoneTransform.Inverse(rootMotionPrevPose);
|
|
var deltaPose = BoneTransform.Multiply(invPrevPose, bonePose);
|
|
|
|
bonePose = deltaPose;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void SetRootMotionStateToComponentBuffer(in NativeList<RootMotionAnimationStateComponent> newRootMotionData, Entity e)
|
|
{
|
|
rootMotionAnimStateBufferLookup[e].CopyFrom(newRootMotionData.AsArray());
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void SetTransformFlags(float3 flags, in AnimationTransformFlags flagArr, int boneIndex)
|
|
{
|
|
if (flags.x > 0)
|
|
flagArr.SetTranslationFlag(boneIndex);
|
|
if (flags.y > 0)
|
|
flagArr.SetRotationFlag(boneIndex);
|
|
if (flags.z > 0)
|
|
flagArr.SetScaleFlag(boneIndex);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void GetHumanRotationDataForSkeletonBone(out HumanRotationData rv, ref BlobPtr<HumanData> hd, int rigBoneIndex)
|
|
{
|
|
rv = default;
|
|
if (hd.IsValid)
|
|
{
|
|
rv = hd.Value.humanRotData[rigBoneIndex];
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
internal static float3 MuscleRangeToRadians(float3 minA, float3 maxA, float3 muscle)
|
|
{
|
|
// Map [-1; +1] range into [minRot; maxRot]
|
|
var negativeRange = math.min(muscle, 0);
|
|
var positiveRange = math.max(0, muscle);
|
|
var negativeRot = math.lerp(0, minA, -negativeRange);
|
|
var positiveRot = math.lerp(0, maxA, +positiveRange);
|
|
|
|
var rv = negativeRot + positiveRot;
|
|
return rv;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void MuscleValuesToQuaternion(in HumanRotationData humanBoneInfo, ref BoneTransform bt)
|
|
{
|
|
var r = MuscleRangeToRadians(humanBoneInfo.minMuscleAngles, humanBoneInfo.maxMuscleAngles, bt.rot.value.xyz);
|
|
r *= humanBoneInfo.sign;
|
|
|
|
var qx = quaternion.AxisAngle(math.right(), r.x);
|
|
var qy = quaternion.AxisAngle(math.up(), r.y);
|
|
var qz = quaternion.AxisAngle(math.forward(), r.z);
|
|
var qzy = math.mul(qz, qy);
|
|
qzy.value.x = 0;
|
|
bt.rot = math.mul(math.normalize(qzy), qx);
|
|
|
|
ApplyHumanoidPostTransform(humanBoneInfo, ref bt);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public static float2 NormalizeAnimationTime(float at, ref AnimationClipBlob ac)
|
|
{
|
|
at += ac.cycleOffset;
|
|
if (at < 0) at = 1 + at;
|
|
var normalizedTime = ac.looped ? math.frac(at) : math.saturate(at);
|
|
var rv = normalizedTime * ac.length;
|
|
return new (rv, normalizedTime);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void CalculateLoopPose(ref TrackSet trackSet, int2 trackRange, ref BoneTransform bonePose, in HumanRotationData hrd, float normalizedTime)
|
|
{
|
|
var lerpFactor = normalizedTime;
|
|
var rootPoseStart = GetTransformFrame(ref trackSet, trackRange, hrd, TrackFrame.First);
|
|
var rootPoseEnd = GetTransformFrame(ref trackSet, trackRange, hrd, TrackFrame.Last);
|
|
|
|
var dPos = rootPoseEnd.pos - rootPoseStart.pos;
|
|
var dRot = math.mul(math.conjugate(rootPoseEnd.rot), rootPoseStart.rot);
|
|
bonePose.pos -= dPos * lerpFactor;
|
|
bonePose.rot = math.mul(bonePose.rot, math.slerp(quaternion.identity, dRot, lerpFactor));
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void HandleRootMotionLoops(ref BoneTransform bonePose, ref TrackSet ts, int2 trackRange, in AnimationToProcessComponent atp)
|
|
{
|
|
ref var animBlob = ref atp.animation.Value;
|
|
if (!animBlob.looped)
|
|
return;
|
|
|
|
var numLoopCycles = (int)math.floor(atp.time + atp.animation.Value.cycleOffset);
|
|
var cycleSign = math.sign(numLoopCycles);
|
|
numLoopCycles = math.abs(numLoopCycles);
|
|
if (numLoopCycles < 1)
|
|
return;
|
|
|
|
var endFramePose = GetTransformFrame(ref ts, trackRange, default, TrackFrame.Last);
|
|
var startFramePose = GetTransformFrame(ref ts, trackRange, default, TrackFrame.First);
|
|
|
|
var deltaPose = BoneTransform.Multiply(endFramePose, BoneTransform.Inverse(startFramePose));
|
|
if (cycleSign < 0)
|
|
deltaPose = BoneTransform.Inverse(deltaPose);
|
|
|
|
BoneTransform accumCyclePose = BoneTransform.Identity();
|
|
for (var c = numLoopCycles; c > 0; c >>= 1)
|
|
{
|
|
if ((c & 1) == 1)
|
|
accumCyclePose = BoneTransform.Multiply(accumCyclePose, deltaPose);
|
|
deltaPose = BoneTransform.Multiply(deltaPose, deltaPose);
|
|
}
|
|
bonePose = BoneTransform.Multiply(accumCyclePose, bonePose);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BoneTransform MixPoses(in BoneTransform curPose, BoneTransform inPose, float3 flags, float weight, AnimationBlendingMode blendMode)
|
|
{
|
|
BoneTransform rv = curPose;
|
|
if (Hint.Likely(blendMode == AnimationBlendingMode.Override))
|
|
{
|
|
if (Hint.Likely(flags.x > 0))
|
|
{
|
|
rv.pos = math.lerp(curPose.pos, inPose.pos, weight);
|
|
}
|
|
if (Hint.Likely(flags.y > 0))
|
|
{
|
|
inPose.rot = MathUtils.ShortestRotation(curPose.rot, inPose.rot);
|
|
rv.rot = math.nlerp(curPose.rot.value, inPose.rot.value, weight);
|
|
}
|
|
if (Hint.Likely(flags.z > 0))
|
|
{
|
|
rv.scale = math.lerp(curPose.scale, inPose.scale, weight);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (Hint.Likely(flags.x > 0))
|
|
{
|
|
rv.pos = curPose.pos + inPose.pos * weight;
|
|
}
|
|
if (Hint.Likely(flags.y > 0))
|
|
{
|
|
quaternion layerRot = math.normalizesafe(new float4(inPose.rot.value.xyz * weight, inPose.rot.value.w));
|
|
layerRot = MathUtils.ShortestRotation(curPose.rot, layerRot);
|
|
rv.rot = math.mul(curPose.rot, layerRot);
|
|
}
|
|
if (Hint.Likely(flags.z > 0))
|
|
{
|
|
rv.scale = curPose.scale * math.lerp(1, inPose.scale, weight);
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void ApplyHumanoidPostTransform(HumanRotationData hrd, ref BoneTransform bt)
|
|
{
|
|
bt.rot = math.mul(math.mul(hrd.preRot, bt.rot), hrd.postRot);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public static bool IsBoneInAvatarMask(int boneIndex, AvatarMaskBodyPart humanAvatarMaskBodyPart, BlobAssetReference<AvatarMaskBlob> am)
|
|
{
|
|
// If no avatar mask defined or bone hash is all zeroes assume that bone included
|
|
if (!am.IsCreated || boneIndex < 0)
|
|
return true;
|
|
|
|
return (int)humanAvatarMaskBodyPart >= 0 ?
|
|
IsBoneInHumanAvatarMask(humanAvatarMaskBodyPart, am) :
|
|
am.Value.IsBoneIncluded(boneIndex);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public static bool IsBoneInHumanAvatarMask(AvatarMaskBodyPart humanBoneAvatarMaskIndex, BlobAssetReference<AvatarMaskBlob> am)
|
|
{
|
|
var rv = (am.Value.humanBodyPartsAvatarMask & 1 << (int)humanBoneAvatarMaskIndex) != 0;
|
|
return rv;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool SampleAnimation
|
|
(
|
|
ref AnimationClipBlob acb,
|
|
float2 animTime,
|
|
int rigBoneIndex,
|
|
uint boneHash,
|
|
AnimationBlendingMode blendMode,
|
|
in HumanRotationData hrd,
|
|
out BoneTransform animatedPose,
|
|
out float3 flags,
|
|
out int2 clipTrackRange
|
|
)
|
|
{
|
|
animatedPose = BoneTransform.Identity();
|
|
flags = 0;
|
|
clipTrackRange = 0;
|
|
|
|
var trackIndex = acb.clipTracks.GetTrackGroupIndex(boneHash);
|
|
if (Hint.Unlikely(trackIndex < 0))
|
|
return false;
|
|
|
|
var time = animTime.x;
|
|
var timeNrm = animTime.y;
|
|
|
|
clipTrackRange = new int2(acb.clipTracks.trackGroups[trackIndex], acb.clipTracks.trackGroups[trackIndex + 1]); // This is safe because of trailing trackGroup
|
|
(animatedPose, flags) = ProcessAnimationCurves(ref acb.clipTracks, clipTrackRange, hrd, time);
|
|
|
|
// Make additive animation if requested
|
|
var isAnimationAdditive = blendMode == AnimationBlendingMode.Additive;
|
|
if (Hint.Unlikely(isAnimationAdditive))
|
|
{
|
|
// Get separate additive frame if requested
|
|
ref var additiveTrackSet = ref Hint.Unlikely(acb.additiveReferencePoseFrame.keyframes.Length > 0) ? ref acb.additiveReferencePoseFrame : ref acb.clipTracks;
|
|
var additiveTrackIndex = additiveTrackSet.trackGroupPHT.Query(boneHash);
|
|
if (additiveTrackIndex >= 0)
|
|
{
|
|
var additivePoseTrackRange = new int2(additiveTrackSet.trackGroups[additiveTrackIndex], additiveTrackSet.trackGroups[additiveTrackIndex + 1]);
|
|
var additiveFramePose = GetTransformFrame(ref additiveTrackSet, additivePoseTrackRange, hrd, TrackFrame.First);
|
|
MakeAdditiveAnimation(ref animatedPose, additiveFramePose);
|
|
}
|
|
}
|
|
|
|
// Loop Pose calculus for all bones except root motion
|
|
var calculateLoopPose = acb.loopPoseBlend && rigBoneIndex != 0;
|
|
if (Hint.Unlikely(calculateLoopPose))
|
|
{
|
|
CalculateLoopPose(ref acb.clipTracks, clipTrackRange, ref animatedPose, hrd, timeNrm);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void MakeAdditiveAnimation(ref BoneTransform rv, in BoneTransform zeroFramePose)
|
|
{
|
|
// If additive layer make difference between reference pose and current animated pose
|
|
rv.pos = rv.pos - zeroFramePose.pos;
|
|
var conjugateZFRot = math.normalizesafe(math.conjugate(zeroFramePose.rot));
|
|
conjugateZFRot = MathUtils.ShortestRotation(rv.rot, conjugateZFRot);
|
|
rv.rot = math.mul(conjugateZFRot, rv.rot);
|
|
rv.scale = rv.scale / zeroFramePose.scale;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
BoneTransform GetTransformFrame(ref TrackSet ts, int2 trackRange, HumanRotationData hrd, TrackFrame tf)
|
|
{
|
|
var rv = BoneTransform.Identity();
|
|
|
|
bool eulerToQuaternion = false;
|
|
var isHumanMuscle = false;
|
|
for (int i = trackRange.x; i < trackRange.y; ++i)
|
|
{
|
|
var track = ts.tracks[i];
|
|
|
|
var kfIndex = track.keyFrameRange.x;
|
|
if (tf == TrackFrame.Last)
|
|
kfIndex += track.keyFrameRange.y - 1;
|
|
|
|
var trackValue = ts.keyframes[kfIndex].v;
|
|
|
|
var ci = (int)track.channelIndex;
|
|
switch (track.bindingType)
|
|
{
|
|
case BindingType.Translation:
|
|
rv.pos[ci] = trackValue;
|
|
break;
|
|
case BindingType.Quaternion:
|
|
rv.rot.value[ci] = trackValue;
|
|
break;
|
|
case BindingType.EulerAngles:
|
|
rv.rot.value[ci] = trackValue;
|
|
eulerToQuaternion = true;
|
|
break;
|
|
case BindingType.HumanMuscle:
|
|
rv.rot.value[ci] = trackValue;
|
|
isHumanMuscle = true;
|
|
break;
|
|
case BindingType.Scale:
|
|
rv.scale[ci] = trackValue;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we have got Euler angles instead of quaternion, convert them here
|
|
if (eulerToQuaternion)
|
|
{
|
|
rv.rot = quaternion.EulerZXY(math.radians(rv.rot.value.xyz));
|
|
}
|
|
|
|
if (isHumanMuscle)
|
|
{
|
|
MuscleValuesToQuaternion(hrd, ref rv);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
(BoneTransform, float3) ProcessAnimationCurves(ref TrackSet ts, int2 trackRange, HumanRotationData hrd, float time)
|
|
{
|
|
var rv = BoneTransform.Identity();
|
|
|
|
bool eulerToQuaternion = false;
|
|
|
|
float3 flags = 0;
|
|
var isHumanMuscle = false;
|
|
for (int i = trackRange.x; i < trackRange.y; ++i)
|
|
{
|
|
var track = ts.tracks[i];
|
|
var interpolatedCurveValue = BlobCurve.SampleAnimationCurve(ref ts, i, time);
|
|
|
|
var ci = (int)track.channelIndex;
|
|
switch (track.bindingType)
|
|
{
|
|
case BindingType.Translation:
|
|
rv.pos[ci] = interpolatedCurveValue;
|
|
flags.x = 1;
|
|
break;
|
|
case BindingType.Quaternion:
|
|
rv.rot.value[ci] = interpolatedCurveValue;
|
|
flags.y = 1;
|
|
break;
|
|
case BindingType.EulerAngles:
|
|
eulerToQuaternion = true;
|
|
rv.rot.value[ci] = interpolatedCurveValue;
|
|
flags.y = 1;
|
|
break;
|
|
case BindingType.HumanMuscle:
|
|
rv.rot.value[ci] = interpolatedCurveValue;
|
|
isHumanMuscle = true;
|
|
flags.y = 1;
|
|
break;
|
|
case BindingType.Scale:
|
|
rv.scale[ci] = interpolatedCurveValue;
|
|
flags.z = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// If we have got Euler angles instead of quaternion, convert them here
|
|
if (eulerToQuaternion)
|
|
{
|
|
rv.rot = quaternion.EulerZXY(math.radians(rv.rot.value.xyz));
|
|
}
|
|
|
|
if (isHumanMuscle)
|
|
{
|
|
MuscleValuesToQuaternion(hrd, ref rv);
|
|
}
|
|
|
|
return (rv, flags);
|
|
}
|
|
}
|
|
|
|
//=================================================================================================================//
|
|
|
|
[BurstCompile]
|
|
[WithNone(typeof(GPUAnimationEngineTag))]
|
|
partial struct ProcessAnimatorParameterCurveJob: IJobEntity
|
|
{
|
|
void Execute(in DynamicBuffer<AnimationToProcessComponent> animationsToProcess, ref DynamicBuffer<AnimatorControllerParameterComponent> acpc)
|
|
{
|
|
if (animationsToProcess.IsEmpty) return;
|
|
|
|
for (var i = 0; i < acpc.Length; ++i)
|
|
{
|
|
ref var p = ref acpc.ElementAt(i);
|
|
var parameterNameHash = Track.CalculateHash(p.hash);
|
|
p.value.floatValue = ComputeAnimatedProperty(p.value.floatValue, animationsToProcess.AsNativeArray(), SpecialBones.AnimatorTypeNameHash, parameterNameHash);
|
|
}
|
|
}
|
|
}
|
|
|
|
//=================================================================================================================//
|
|
|
|
[BurstCompile]
|
|
[WithNone(typeof(GPUAnimationEngineTag))]
|
|
partial struct AnimateBlendShapeWeightsJob: IJobEntity
|
|
{
|
|
[ReadOnly]
|
|
public BufferLookup<AnimationToProcessComponent> animationToProcessLookup;
|
|
[ReadOnly]
|
|
public ComponentLookup<CullAnimationsTag> cullAnimationsLookup;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void Execute(DynamicBuffer<BlendShapeWeight> blendShapeWeights, in SkinnedMeshRendererComponent asm)
|
|
{
|
|
if (IsAnimationsCulled(asm.animatedRigEntity) || !animationToProcessLookup.TryGetBuffer(asm.animatedRigEntity, out var animationsToProcess))
|
|
return;
|
|
|
|
if (animationsToProcess.IsEmpty) return;
|
|
|
|
for (var i = 0; i < blendShapeWeights.Length; ++i)
|
|
{
|
|
ref var p = ref blendShapeWeights.ElementAt(i);
|
|
var bsi = asm.smrInfoBlob.Value.blendShapes[i].hash;
|
|
var parameterNameHash = Track.CalculateHash(bsi);
|
|
|
|
p.Value = ComputeAnimatedProperty(0, animationsToProcess.AsNativeArray(), asm.nameHash, parameterNameHash);
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
bool IsAnimationsCulled(Entity animatedEntity)
|
|
{
|
|
return cullAnimationsLookup.HasComponent(animatedEntity) && cullAnimationsLookup.IsComponentEnabled(animatedEntity);
|
|
}
|
|
}
|
|
|
|
//=================================================================================================================//
|
|
|
|
[BurstCompile]
|
|
struct CalculateBoneOffsetsJob: IJobChunk
|
|
{
|
|
[ReadOnly]
|
|
public ComponentTypeHandle<RigDefinitionComponent> rigDefinitionTypeHandle;
|
|
[ReadOnly]
|
|
public ComponentLookup<CullAnimationsTag> cullAnimationsTagLookup;
|
|
[ReadOnly]
|
|
public NativeArray<int> chunkBaseEntityIndices;
|
|
[ReadOnly]
|
|
public NativeList<Entity> entities;
|
|
|
|
[WriteOnly, NativeDisableContainerSafetyRestriction]
|
|
public NativeList<int2> bonePosesOffsets;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public void Execute(in ArchetypeChunk chunk, int unfilteredChunkIndex, bool useEnabledMask, in v128 chunkEnabledMask)
|
|
{
|
|
var rigDefAccessor = chunk.GetNativeArray(ref rigDefinitionTypeHandle);
|
|
int baseEntityIndex = chunkBaseEntityIndices[unfilteredChunkIndex];
|
|
int validEntitiesInChunk = 0;
|
|
|
|
var cee = new ChunkEntityEnumerator(useEnabledMask, chunkEnabledMask, chunk.Count);
|
|
bonePosesOffsets[0] = 0;
|
|
|
|
while (cee.NextEntityIndex(out var i))
|
|
{
|
|
var rigDef = rigDefAccessor[i];
|
|
|
|
int entityInQueryIndex = baseEntityIndex + validEntitiesInChunk;
|
|
++validEntitiesInChunk;
|
|
|
|
var e = entities[entityInQueryIndex];
|
|
var boneCount = GetRigBoneCountWithRespectToCulling(e, rigDef, cullAnimationsTagLookup);
|
|
|
|
var v = new int2
|
|
(
|
|
// Bone count
|
|
boneCount,
|
|
// Number of ulong values that can hold bone transform flags
|
|
(boneCount * 4 >> 6) + 1
|
|
);
|
|
bonePosesOffsets[entityInQueryIndex + 1] = v;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
int GetRigBoneCountWithRespectToCulling(Entity e, in RigDefinitionComponent rdc, in ComponentLookup<CullAnimationsTag> cullAnimationsTagLookup)
|
|
{
|
|
if (!cullAnimationsTagLookup.HasComponent(e) || !cullAnimationsTagLookup.IsComponentEnabled(e))
|
|
return rdc.rigBlob.Value.bones.Length;
|
|
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
//=================================================================================================================//
|
|
|
|
[BurstCompile]
|
|
struct CalculatePerBoneInfoJob: IJobChunk
|
|
{
|
|
[ReadOnly]
|
|
public NativeArray<int> chunkBaseEntityIndices;
|
|
[ReadOnly]
|
|
public NativeList<int2> bonePosesOffsets;
|
|
|
|
[WriteOnly, NativeDisableContainerSafetyRestriction]
|
|
public NativeList<int3> boneToEntityIndices;
|
|
|
|
public ComponentTypeHandle<RigDefinitionComponent> rigDefinitionTypeHandle;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public void Execute(in ArchetypeChunk chunk, int unfilteredChunkIndex, bool useEnabledMask, in v128 chunkEnabledMask)
|
|
{
|
|
var rigDefArray = chunk.GetNativeArray(ref rigDefinitionTypeHandle);
|
|
int baseEntityIndex = chunkBaseEntityIndices[unfilteredChunkIndex];
|
|
int validEntitiesInChunk = 0;
|
|
|
|
var cee = new ChunkEntityEnumerator(useEnabledMask, chunkEnabledMask, chunk.Count);
|
|
|
|
while (cee.NextEntityIndex(out var i))
|
|
{
|
|
int entityInQueryIndex = baseEntityIndex + validEntitiesInChunk;
|
|
++validEntitiesInChunk;
|
|
var offset = bonePosesOffsets[entityInQueryIndex];
|
|
var nextOffset = bonePosesOffsets[entityInQueryIndex + 1]; // This is always valid because we have entities count + 1 array
|
|
|
|
var boneCount = nextOffset.x - offset.x;
|
|
|
|
var boneCountHighWORD = boneCount << 16;
|
|
for (int k = 0; k < boneCount; ++k)
|
|
{
|
|
var boneIndexAndBoneCount = k | boneCountHighWORD;
|
|
boneToEntityIndices[k + offset.x] = new int3(entityInQueryIndex, boneIndexAndBoneCount, offset.y);
|
|
}
|
|
|
|
var rigFrameData = new DynamicFrameData()
|
|
{
|
|
bonePoseOffset = offset.x,
|
|
boneFlagsOffset = offset.y,
|
|
rigBoneCount = boneCount,
|
|
};
|
|
var rigDef = rigDefArray[i];
|
|
rigDef.dynamicFrameData = rigFrameData;
|
|
rigDefArray[i] = rigDef;
|
|
}
|
|
}
|
|
}
|
|
|
|
//=================================================================================================================//
|
|
|
|
[BurstCompile]
|
|
struct DoPrefixSumJob: IJob
|
|
{
|
|
public NativeList<int2> boneOffsets;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public void Execute()
|
|
{
|
|
var sum = new int2(0);
|
|
for (int i = 0; i < boneOffsets.Length; ++i)
|
|
{
|
|
var v = boneOffsets[i];
|
|
sum += v;
|
|
boneOffsets[i] = sum;
|
|
}
|
|
}
|
|
}
|
|
|
|
//=================================================================================================================//
|
|
|
|
[BurstCompile]
|
|
struct ResizeDataBuffersJob: IJob
|
|
{
|
|
[ReadOnly]
|
|
public NativeList<int2> boneOffsets;
|
|
public RuntimeAnimationData runtimeData;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public void Execute()
|
|
{
|
|
var boneBufferLen = boneOffsets[^1];
|
|
runtimeData.animatedBonesBuffer.Resize(boneBufferLen.x, NativeArrayOptions.UninitializedMemory);
|
|
runtimeData.worldSpaceBonesBuffer.Resize(boneBufferLen.x, NativeArrayOptions.UninitializedMemory);
|
|
runtimeData.boneToEntityArr.Resize(boneBufferLen.x, NativeArrayOptions.UninitializedMemory);
|
|
|
|
// Clear flags by two resizes
|
|
runtimeData.boneTransformFlagsHolderArr.Resize(0, NativeArrayOptions.UninitializedMemory);
|
|
runtimeData.boneTransformFlagsHolderArr.Resize(boneBufferLen.y, NativeArrayOptions.ClearMemory);
|
|
}
|
|
}
|
|
|
|
//=================================================================================================================//
|
|
|
|
[BurstCompile]
|
|
partial struct CopyEntityBoneTransformsToAnimationBuffer: IJobEntity
|
|
{
|
|
[NativeDisableContainerSafetyRestriction]
|
|
public NativeList<BoneTransform> animatedBoneTransforms;
|
|
[ReadOnly]
|
|
public ComponentLookup<RigDefinitionComponent> rigDefComponentLookup;
|
|
[ReadOnly]
|
|
public ComponentLookup<GPUAnimationEngineTag> gpuAnimationEngineTagLookup;
|
|
[ReadOnly]
|
|
public ComponentLookup<Parent> parentComponentLookup;
|
|
[ReadOnly]
|
|
public ComponentLookup<PostTransformMatrix> ptmComponentLookup;
|
|
|
|
[NativeDisableContainerSafetyRestriction]
|
|
public NativeList<ulong> boneTransformFlags;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void Execute(Entity e, in AnimatorEntityRefComponent aer, in LocalTransform lt)
|
|
{
|
|
if (!rigDefComponentLookup.TryGetComponent(aer.animatorEntity, out var rdc))
|
|
return;
|
|
|
|
if (gpuAnimationEngineTagLookup.IsComponentEnabled(aer.animatorEntity))
|
|
return;
|
|
|
|
var entityBoneData = rdc.dynamicFrameData;
|
|
if (entityBoneData.bonePoseOffset < 0)
|
|
return;
|
|
|
|
// If animation calculation was culled, we need operate only on valid bone range
|
|
if (aer.boneIndexInAnimationRig >= entityBoneData.rigBoneCount)
|
|
return;
|
|
|
|
var bonePoses = RuntimeAnimationData.GetAnimationDataForRigRW(animatedBoneTransforms, entityBoneData.bonePoseOffset, entityBoneData.rigBoneCount);
|
|
var transformFlags = AnimationTransformFlags.CreateFromBufferRW(boneTransformFlags, entityBoneData.boneFlagsOffset, entityBoneData.rigBoneCount);
|
|
var boneFlags = new bool3
|
|
(
|
|
transformFlags.IsTranslationSet(aer.boneIndexInAnimationRig),
|
|
transformFlags.IsRotationSet(aer.boneIndexInAnimationRig),
|
|
transformFlags.IsScaleSet(aer.boneIndexInAnimationRig)
|
|
);
|
|
|
|
if (!math.any(boneFlags))
|
|
{
|
|
var entityPose = new BoneTransform(lt);
|
|
if (ptmComponentLookup.TryGetComponent(e, out var ptm))
|
|
entityPose = new BoneTransform(lt, ptm);
|
|
|
|
// Root motion delta should be zero
|
|
if (rdc.applyRootMotion && aer.boneIndexInAnimationRig == 0)
|
|
entityPose = BoneTransform.Identity();
|
|
|
|
ref var bonePose = ref bonePoses[aer.boneIndexInAnimationRig];
|
|
|
|
if (!boneFlags.x)
|
|
bonePose.pos = entityPose.pos;
|
|
if (!boneFlags.y)
|
|
bonePose.rot = entityPose.rot;
|
|
if (!boneFlags.z)
|
|
bonePose.scale = entityPose.scale;
|
|
|
|
// For entities without parent we indicate that bone pose is in world space
|
|
if (!parentComponentLookup.HasComponent(e))
|
|
transformFlags.SetAbsoluteTransformFlag(aer.boneIndexInAnimationRig);
|
|
}
|
|
}
|
|
}
|
|
|
|
//=================================================================================================================//
|
|
|
|
[BurstCompile]
|
|
struct MakeAbsoluteTransformsJob: IJobChunk
|
|
{
|
|
[ReadOnly]
|
|
public ComponentTypeHandle<RigDefinitionComponent> rigDefTypeHandle;
|
|
[NativeDisableContainerSafetyRestriction]
|
|
public NativeList<BoneTransform> localBoneTransforms;
|
|
[NativeDisableContainerSafetyRestriction]
|
|
public NativeList<BoneTransform> worldBoneTransforms;
|
|
[ReadOnly]
|
|
public NativeList<ulong> boneTransformFlags;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
public void Execute(in ArchetypeChunk chunk, int unfilteredChunkIndex, bool useEnabledMask, in v128 chunkEnabledMask)
|
|
{
|
|
var rigDefArray = chunk.GetNativeArray(ref rigDefTypeHandle);
|
|
|
|
var cee = new ChunkEntityEnumerator(useEnabledMask, chunkEnabledMask, chunk.Count);
|
|
var flagsHolder = new NativeBitArray(0xff, Allocator.Temp, NativeArrayOptions.UninitializedMemory);
|
|
|
|
while (cee.NextEntityIndex(out var i))
|
|
{
|
|
var rigDef = rigDefArray[i];
|
|
|
|
ref var rigBones = ref rigDef.rigBlob.Value.bones;
|
|
var rigFrameData = rigDef.dynamicFrameData;
|
|
var rigBonesCount = rigFrameData.rigBoneCount;
|
|
flagsHolder.Resize(rigBonesCount);
|
|
flagsHolder.Clear();
|
|
|
|
var localBoneTransformsForRig = localBoneTransforms.GetSpan(rigFrameData.bonePoseOffset, rigBonesCount);
|
|
var worldBoneTransformsForRig = worldBoneTransforms.GetSpan(rigFrameData.bonePoseOffset, rigBonesCount);
|
|
var boneFlags = AnimationTransformFlags.CreateFromBufferRO(boneTransformFlags, rigFrameData.boneFlagsOffset, rigBonesCount);
|
|
|
|
// Iterate over all animated bones and calculate absolute transform in-place
|
|
for (int animationBoneIndex = 0; animationBoneIndex < rigBonesCount; ++animationBoneIndex)
|
|
{
|
|
if (boneFlags.IsAbsoluteTransform(animationBoneIndex))
|
|
{
|
|
flagsHolder.Set(animationBoneIndex, true);
|
|
worldBoneTransformsForRig[animationBoneIndex] = localBoneTransformsForRig[animationBoneIndex];
|
|
}
|
|
|
|
MakeAbsoluteTransform(flagsHolder, animationBoneIndex, localBoneTransformsForRig, worldBoneTransformsForRig, rigDef.rigBlob);
|
|
}
|
|
|
|
// For all initially absolute bones calculate local transforms
|
|
for (int animationBoneIndex = 0; animationBoneIndex < rigBonesCount; ++animationBoneIndex)
|
|
{
|
|
var parentBoneIndex = rigBones[animationBoneIndex].parentBoneIndex;
|
|
if (!boneFlags.IsAbsoluteTransform(animationBoneIndex) || parentBoneIndex < 0)
|
|
continue;
|
|
|
|
var parentWorldTransform = worldBoneTransformsForRig[parentBoneIndex];
|
|
var worldTransform = worldBoneTransformsForRig[animationBoneIndex];
|
|
|
|
var localTransform = BoneTransform.Multiply(BoneTransform.Inverse(parentWorldTransform), worldTransform);
|
|
localBoneTransformsForRig[animationBoneIndex] = localTransform;
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void MakeAbsoluteTransform
|
|
(
|
|
NativeBitArray absTransformFlags,
|
|
int boneIndex,
|
|
Span<BoneTransform> localBoneTransformsForRig,
|
|
Span<BoneTransform> worldBoneTransformsForRig,
|
|
in BlobAssetReference<RigDefinitionBlob> rigBlob
|
|
)
|
|
{
|
|
var resultBoneTransform = BoneTransform.Identity();
|
|
var myBoneIndex = boneIndex;
|
|
ref var rigBones = ref rigBlob.Value.bones;
|
|
bool absTransformFlag;
|
|
|
|
do
|
|
{
|
|
absTransformFlag = absTransformFlags.IsSet(boneIndex);
|
|
var animatedBoneTransform = absTransformFlag ? worldBoneTransformsForRig[boneIndex] : localBoneTransformsForRig[boneIndex];
|
|
resultBoneTransform = BoneTransform.Multiply(animatedBoneTransform, resultBoneTransform);
|
|
|
|
boneIndex = rigBones[boneIndex].parentBoneIndex;
|
|
}
|
|
while (boneIndex >= 0 && !absTransformFlag);
|
|
|
|
worldBoneTransformsForRig[myBoneIndex] = resultBoneTransform;
|
|
absTransformFlags.Set(myBoneIndex, true);
|
|
}
|
|
}
|
|
|
|
//=================================================================================================================//
|
|
|
|
[BurstCompile]
|
|
[WithDisabled(typeof(GPUAnimationEngineTag))]
|
|
partial struct ComputeRootMotionJob: IJobEntity
|
|
{
|
|
[NativeDisableContainerSafetyRestriction]
|
|
public NativeList<BoneTransform> animatedBonePoses;
|
|
[ReadOnly]
|
|
public ComponentLookup<Parent> parentLookup;
|
|
[ReadOnly]
|
|
public ComponentLookup<PostTransformMatrix> ptmLookup;
|
|
[ReadOnly]
|
|
public ComponentLookup<LocalTransform> localTransformLookup;
|
|
|
|
public float deltaTime;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
void Execute(Entity e, in RigDefinitionComponent rdc, ref RootMotionVelocityComponent rmvc, in LocalTransform lt)
|
|
{
|
|
if (!rdc.applyRootMotion)
|
|
return;
|
|
|
|
var boneData = RuntimeAnimationData.GetAnimationDataForRigRW(animatedBonePoses, rdc);
|
|
if (boneData.IsEmpty)
|
|
return;
|
|
|
|
var motionDeltaPose = boneData[0];
|
|
var curEntityTransform = new BoneTransform(lt);
|
|
|
|
if (rmvc.removeBuiltinEntityMovement)
|
|
{
|
|
boneData[0] = curEntityTransform;
|
|
}
|
|
else
|
|
{
|
|
var newEntityPose = BoneTransform.Multiply(curEntityTransform, motionDeltaPose);
|
|
boneData[0] = newEntityPose;
|
|
}
|
|
|
|
rmvc.deltaPos = motionDeltaPose.pos;
|
|
rmvc.deltaRot = motionDeltaPose.rot;
|
|
rmvc.worldVelocity = motionDeltaPose.pos / deltaTime;
|
|
TransformHelpers.ComputeWorldTransformMatrix(e, out var localTransformMatrix, ref localTransformLookup, ref parentLookup, ref ptmLookup);
|
|
rmvc.worldVelocity = math.rotate(localTransformMatrix, rmvc.worldVelocity);
|
|
}
|
|
}
|
|
}
|
|
}
|