private void mixJoints(IJoint result, IJoint joint1, double amount1, IJoint joint2, double amount2)
{
double enableJoint1 = 1.0;
double enableJoint2 = 1.0;
Vector3D p;
p = joint1.AnimationTransform * new Vector3D(1, 1, 1); // check, if AnimationTransform is Identity Matrix... for the lazy ones...
if (p.x == 1 && p.y == 1 && p.z == 1)
{
enableJoint1 = 0;
}
p = joint2.AnimationTransform * new Vector3D(1, 1, 1);
if (p.x == 1 && p.y == 1 && p.z == 1)
{
enableJoint2 = 0;
}
Matrix4x4 resultAnimationT = result.AnimationTransform;
Matrix4x4Utils.Blend(joint1.AnimationTransform, joint2.AnimationTransform, amount1 * enableJoint1, amount2 * enableJoint2, out resultAnimationT);
result.AnimationTransform = resultAnimationT;
for (int i = 0; i < result.Children.Count; i++)
{
mixJoints(result.Children[i], joint1.Children[i], amount1, joint2.Children[i], amount2);
}
}
void LateUpdate()
{
if (updateCameraCalibration)
{
updateCameraCalibration = false;
UpdateCameraCalibration();
}
if (reset)
{
reset = false;
projection = initialProjection;
theCamera.ResetProjectionMatrix();
theCamera.ResetWorldToCameraMatrix();
}
if (DoUpdate)
{
if (UpdateView)
{
Matrix4x4Utils.SetTransformFromMatrix(transform, ref cameraPosition);
}
//theCamera.worldToCameraMatrix = view;
//if (UpdateProjection)
theCamera.projectionMatrix = projection;
}
}
public bool CheckConstraint(Behaviors.ValidateFunctionArguments validateFunctionArguments, CheckConstraintArguments checkConstraintArguments)
{
if (this.UpstreamConstraint != null)
{
if (!this.UpstreamConstraint.CheckConstraint(validateFunctionArguments, checkConstraintArguments))
{
return(false);
}
}
if (!validateFunctionArguments.ActionsApplied.Contains(Behaviors.ActionsApplied.Translate))
{
// Ignore if no translate applied
return(true);
}
Vector3D rotation, scale, translation;
Matrix4x4Utils.Decompose(validateFunctionArguments.Transform
, out scale
, out rotation
, out translation);
var translation2 = new Vector2D(translation.x, translation.y);
var result = translation2.x >= this.Minimum.x &&
translation2.y >= this.Minimum.y &&
translation2.x <= this.Maximum.x &&
translation2.y <= this.Maximum.y;
return(result);
}
public bool CheckConstraint(Behaviors.ValidateFunctionArguments validateFunctionArguments, CheckConstraintArguments checkConstraintArguments)
{
if (this.UpstreamConstraint != null)
{
if (!this.UpstreamConstraint.CheckConstraint(validateFunctionArguments, checkConstraintArguments))
{
return(false);
}
}
if (!validateFunctionArguments.ActionsApplied.Contains(Behaviors.ActionsApplied.Rotate))
{
// Ignore if no rotation applied
return(true);
}
Vector3D rotation, scale, translation;
Matrix4x4Utils.Decompose(validateFunctionArguments.Transform
, out scale
, out rotation
, out translation);
return(rotation.z / (Math.PI * 2.0) >= this.Minimum && rotation.z / (Math.PI * 2.0) <= this.Maximum);
}
public override void World(World world)
{
_geometry = world.WorldObject.Model.Geometry;
var lightSourceView = Matrix4x4Utils.LookAt(new Vector3(0, 0, 0), world.LightDirection, new Vector3(0, 1, 0));
_transformation = world.ViewportTransform.Mul(world.ProjectionTransform.Mul(lightSourceView.Mul(world.WorldObject.ModelTransform)));
}
/// <summary>
/// Gets the rotation matrix such that the normal faces forwards.
/// </summary>
/// <returns>The rotation matrix.</returns>
/// <param name="pointA">Point a.</param>
/// <param name="pointB">Point b.</param>
/// <param name="pointC">Point c.</param>
public static Matrix4x4 GetRotationMatrix(Vector3 pointA, Vector3 pointB, Vector3 pointC)
{
Vector3 normal = GetNormal(pointA, pointB, pointC);
return(Matrix4x4Utils.Rotate(normal, pointB - pointA).inverse);
}
public void Evaluate(int SpreadMax)
{
if (Pins.InputPins.Count == 0 || Pins.InputSpreadMin == 0)
{
FOut.SliceCount = 0;
return;
}
if (Pins.InputPins.Values.Any(pin => pin.Spread[0] == null))
{
return;
}
if (Pins.InputChanged)
{
FOut.Stream.IsChanged = true;
var currposecount = Pins.InputPins.Count / 2;
for (int i = 0; i < FOut.SliceCount; i++)
{
if (FOut[i] == null)
{
FOut[i] = new Skeleton();
}
else
{
((ISkeleton)Pins.InputPins["Pose 0"].Spread[i]).CopyData(FOut[i]);
}
var outSkeleton = FOut[i];
var outAmount = (double)Pins.InputPins["Amount 0"].Spread[i];
var outAmDiv = 1;
for (int j = 1; j < currposecount; j++)
{
var currSkeleton = (ISkeleton)Pins.InputPins[$"Pose {j}"].Spread[i];
var currAmount = (double)Pins.InputPins[$"Amount {j}"].Spread[i];
foreach (var joint in outSkeleton.JointTable.Keys)
{
if (!currSkeleton.JointTable.ContainsKey(joint))
{
continue;
}
Matrix4x4 result;
if (!FAnimOnly[0])
{
var currBase = currSkeleton.JointTable[joint].BaseTransform;
var outBase = outSkeleton.JointTable[joint].BaseTransform;
Matrix4x4Utils.Blend(outBase, currBase, outAmount / outAmDiv, currAmount, out result);
outSkeleton.JointTable[joint].BaseTransform = result;
}
var currAnim = currSkeleton.JointTable[joint].AnimationTransform;
var outAnim = outSkeleton.JointTable[joint].AnimationTransform;
Matrix4x4Utils.Blend(outAnim, currAnim, outAmount / outAmDiv, currAmount, out result);
outSkeleton.JointTable[joint].AnimationTransform = result;
}
outAmount += currAmount;
outAmDiv++;
}
}
}
else
{
FOut.Stream.IsChanged = false;
}
}
