private void AddItem(TransformComponent item)
{
if (item.Parent != null)
throw new InvalidOperationException("This TransformComponent already has a Parent, detach it first.");
item.parent = this;
}
private void RemoveItem(TransformComponent item)
{
if (item.Parent != this)
throw new InvalidOperationException("This TransformComponent's parent is not the expected value.");
item.parent = null;
}
internal void Update(TransformComponent transformComponent, ref Matrix worldMatrix)
{
if (!Enabled || model == null)
return;
// Check if scaling is negative
bool isScalingNegative = false;
{
Vector3 scale, translation;
Matrix rotation;
if (worldMatrix.Decompose(out scale, out rotation, out translation))
isScalingNegative = scale.X*scale.Y*scale.Z < 0.0f;
}
// Make sure skeleton is up to date
CheckSkeleton();
if (skeleton != null)
{
// Update model view hierarchy node matrices
skeleton.NodeTransformations[0].LocalMatrix = worldMatrix;
skeleton.NodeTransformations[0].IsScalingNegative = isScalingNegative;
skeleton.UpdateMatrices();
}
// Update the bounding sphere / bounding box in world space
var meshes = Model.Meshes;
var modelBoundingSphere = BoundingSphere.Empty;
var modelBoundingBox = BoundingBox.Empty;
bool hasBoundingBox = false;
Matrix world;
foreach (var mesh in meshes)
{
var meshBoundingSphere = mesh.BoundingSphere;
if (skeleton != null)
skeleton.GetWorldMatrix(mesh.NodeIndex, out world);
else
world = worldMatrix;
Vector3.TransformCoordinate(ref meshBoundingSphere.Center, ref world, out meshBoundingSphere.Center);
BoundingSphere.Merge(ref modelBoundingSphere, ref meshBoundingSphere, out modelBoundingSphere);
var boxExt = new BoundingBoxExt(mesh.BoundingBox);
boxExt.Transform(world);
var meshBox = (BoundingBox)boxExt;
if (hasBoundingBox)
{
BoundingBox.Merge(ref modelBoundingBox, ref meshBox, out modelBoundingBox);
}
else
{
modelBoundingBox = meshBox;
}
hasBoundingBox = true;
}
// Update the bounds
BoundingBox = modelBoundingBox;
BoundingSphere = modelBoundingSphere;
}
public RenderUIElement(UIComponent uiComponent, TransformComponent transformComponent)
{
UIComponent = uiComponent;
TransformComponent = transformComponent;
}
internal void Update(TransformComponent transformComponent, ref Matrix worldMatrix)
{
if (!Enabled || model == null)
return;
// Check if scaling is negative
var up = Vector3.Cross(worldMatrix.Right, worldMatrix.Forward);
bool isScalingNegative = Vector3.Dot(worldMatrix.Up, up) < 0.0f;
// Make sure skeleton is up to date
CheckSkeleton();
if (skeleton != null)
{
// Update model view hierarchy node matrices
skeleton.NodeTransformations[0].LocalMatrix = worldMatrix;
skeleton.NodeTransformations[0].IsScalingNegative = isScalingNegative;
skeleton.UpdateMatrices();
}
// Update the bounding sphere / bounding box in world space
BoundingSphere = BoundingSphere.Empty;
BoundingBox = BoundingBox.Empty;
bool modelHasBoundingBox = false;
for (int meshIndex = 0; meshIndex < Model.Meshes.Count; meshIndex++)
{
var mesh = Model.Meshes[meshIndex];
var meshInfo = meshInfos[meshIndex];
meshInfo.BoundingSphere = BoundingSphere.Empty;
meshInfo.BoundingBox = BoundingBox.Empty;
if (mesh.Skinning != null && skeleton != null)
{
bool meshHasBoundingBox = false;
var bones = mesh.Skinning.Bones;
// For skinned meshes, bounding box is union of the bounding boxes of the unskinned mesh, transformed by each affecting bone.
for (int boneIndex = 0; boneIndex < bones.Length; boneIndex++)
{
var nodeIndex = bones[boneIndex].NodeIndex;
Matrix.Multiply(ref bones[boneIndex].LinkToMeshMatrix, ref skeleton.NodeTransformations[nodeIndex].WorldMatrix, out meshInfos[meshIndex].BlendMatrices[boneIndex]);
BoundingBox skinnedBoundingBox;
BoundingBox.Transform(ref mesh.BoundingBox, ref meshInfos[meshIndex].BlendMatrices[boneIndex], out skinnedBoundingBox);
BoundingSphere skinnedBoundingSphere;
BoundingSphere.Transform(ref mesh.BoundingSphere, ref meshInfos[meshIndex].BlendMatrices[boneIndex], out skinnedBoundingSphere);
if (meshHasBoundingBox)
{
BoundingBox.Merge(ref meshInfo.BoundingBox, ref skinnedBoundingBox, out meshInfo.BoundingBox);
BoundingSphere.Merge(ref meshInfo.BoundingSphere, ref skinnedBoundingSphere, out meshInfo.BoundingSphere);
}
else
{
meshHasBoundingBox = true;
meshInfo.BoundingSphere = skinnedBoundingSphere;
meshInfo.BoundingBox = skinnedBoundingBox;
}
}
}
else
{
// If there is a skeleton, use the corresponding node's transform. Otherwise, fall back to the model transform.
var transform = skeleton != null ? skeleton.NodeTransformations[mesh.NodeIndex].WorldMatrix : worldMatrix;
BoundingBox.Transform(ref mesh.BoundingBox, ref transform, out meshInfo.BoundingBox);
BoundingSphere.Transform(ref mesh.BoundingSphere, ref transform, out meshInfo.BoundingSphere);
}
if (modelHasBoundingBox)
{
BoundingBox.Merge(ref BoundingBox, ref meshInfo.BoundingBox, out BoundingBox);
BoundingSphere.Merge(ref BoundingSphere, ref meshInfo.BoundingSphere, out BoundingSphere);
}
else
{
BoundingBox = meshInfo.BoundingBox;
BoundingSphere = meshInfo.BoundingSphere;
modelHasBoundingBox = true;
}
}
}
/// <inheritdoc/>
public override void Process(TransformComponent transformComponent)
{
ModelComponent.Update(transformComponent);
}
internal void Update(TransformComponent transformComponent, ref Matrix worldMatrix)
{
if (!Enabled || model == null)
{
return;
}
// Check if scaling is negative
var up = Vector3.Cross(worldMatrix.Right, worldMatrix.Forward);
bool isScalingNegative = Vector3.Dot(worldMatrix.Up, up) < 0.0f;
// Make sure skeleton is up to date
CheckSkeleton();
if (skeleton != null)
{
// Update model view hierarchy node matrices
skeleton.NodeTransformations[0].LocalMatrix = worldMatrix;
skeleton.NodeTransformations[0].IsScalingNegative = isScalingNegative;
skeleton.UpdateMatrices();
}
// Update the bounding sphere / bounding box in world space
BoundingSphere = BoundingSphere.Empty;
BoundingBox = BoundingBox.Empty;
bool modelHasBoundingBox = false;
for (int meshIndex = 0; meshIndex < Model.Meshes.Count; meshIndex++)
{
var mesh = Model.Meshes[meshIndex];
var meshInfo = meshInfos[meshIndex];
meshInfo.BoundingSphere = BoundingSphere.Empty;
meshInfo.BoundingBox = BoundingBox.Empty;
if (mesh.Skinning != null && skeleton != null)
{
bool meshHasBoundingBox = false;
var bones = mesh.Skinning.Bones;
// For skinned meshes, bounding box is union of the bounding boxes of the unskinned mesh, transformed by each affecting bone.
for (int boneIndex = 0; boneIndex < bones.Length; boneIndex++)
{
var nodeIndex = bones[boneIndex].NodeIndex;
Matrix.Multiply(ref bones[boneIndex].LinkToMeshMatrix, ref skeleton.NodeTransformations[nodeIndex].WorldMatrix, out meshInfos[meshIndex].BlendMatrices[boneIndex]);
BoundingBox skinnedBoundingBox;
BoundingBox.Transform(ref mesh.BoundingBox, ref meshInfos[meshIndex].BlendMatrices[boneIndex], out skinnedBoundingBox);
BoundingSphere skinnedBoundingSphere;
BoundingSphere.Transform(ref mesh.BoundingSphere, ref meshInfos[meshIndex].BlendMatrices[boneIndex], out skinnedBoundingSphere);
if (meshHasBoundingBox)
{
BoundingBox.Merge(ref meshInfo.BoundingBox, ref skinnedBoundingBox, out meshInfo.BoundingBox);
BoundingSphere.Merge(ref meshInfo.BoundingSphere, ref skinnedBoundingSphere, out meshInfo.BoundingSphere);
}
else
{
meshHasBoundingBox = true;
meshInfo.BoundingSphere = skinnedBoundingSphere;
meshInfo.BoundingBox = skinnedBoundingBox;
}
}
}
else
{
// If there is a skeleton, use the corresponding node's transform. Otherwise, fall back to the model transform.
var transform = skeleton != null ? skeleton.NodeTransformations[mesh.NodeIndex].WorldMatrix : worldMatrix;
BoundingBox.Transform(ref mesh.BoundingBox, ref transform, out meshInfo.BoundingBox);
BoundingSphere.Transform(ref mesh.BoundingSphere, ref transform, out meshInfo.BoundingSphere);
}
if (modelHasBoundingBox)
{
BoundingBox.Merge(ref BoundingBox, ref meshInfo.BoundingBox, out BoundingBox);
BoundingSphere.Merge(ref BoundingSphere, ref meshInfo.BoundingSphere, out BoundingSphere);
}
else
{
BoundingBox = meshInfo.BoundingBox;
BoundingSphere = meshInfo.BoundingSphere;
modelHasBoundingBox = true;
}
}
}
/// <inheritdoc/>
public override void Process(TransformComponent transformComponent)
{
// Waiting for roslyn ref locals to avoid having to pass world matrix
modelComponent.Update(transformComponent, ref transformComponent.WorldMatrix);
}
internal void Update(TransformComponent transformComponent, ref Matrix worldMatrix)
{
if (!Enabled || model == null)
{
return;
}
// Check if scaling is negative
bool isScalingNegative = false;
{
Vector3 scale, translation;
Matrix rotation;
if (worldMatrix.Decompose(out scale, out rotation, out translation))
{
isScalingNegative = scale.X * scale.Y * scale.Z < 0.0f;
}
}
// Make sure skeleton is up to date
CheckSkeleton();
if (skeleton != null)
{
// Update model view hierarchy node matrices
skeleton.NodeTransformations[0].LocalMatrix = worldMatrix;
skeleton.NodeTransformations[0].IsScalingNegative = isScalingNegative;
skeleton.UpdateMatrices();
}
// Update the bounding sphere / bounding box in world space
var meshes = Model.Meshes;
var modelBoundingSphere = BoundingSphere.Empty;
var modelBoundingBox = BoundingBox.Empty;
bool hasBoundingBox = false;
Matrix world;
foreach (var mesh in meshes)
{
var meshBoundingSphere = mesh.BoundingSphere;
if (skeleton != null)
{
skeleton.GetWorldMatrix(mesh.NodeIndex, out world);
}
else
{
world = worldMatrix;
}
Vector3.TransformCoordinate(ref meshBoundingSphere.Center, ref world, out meshBoundingSphere.Center);
BoundingSphere.Merge(ref modelBoundingSphere, ref meshBoundingSphere, out modelBoundingSphere);
var boxExt = new BoundingBoxExt(mesh.BoundingBox);
boxExt.Transform(world);
var meshBox = (BoundingBox)boxExt;
if (hasBoundingBox)
{
BoundingBox.Merge(ref modelBoundingBox, ref meshBox, out modelBoundingBox);
}
else
{
modelBoundingBox = meshBox;
}
hasBoundingBox = true;
}
// Update the bounds
BoundingBox = modelBoundingBox;
BoundingSphere = modelBoundingSphere;
}