public static NPVoxBoneModel Transform(NPVoxBoneModel sourceModel, NPVoxBox affectedArea, uint boneMask, Matrix4x4 transformMatrix, ResolveConflictMethodType resolveConflictMethod = ResolveConflictMethodType.CLOSEST, NPVoxModel reuse = null, byte markColor = 0)
{
NPVoxBox clampedBox = sourceModel.Clamp(affectedArea);
// calculate size & offset for new model
NPVoxCoord size = sourceModel.Size;
NPVoxCoord offset = NPVoxCoord.ZERO;
{
NPVoxBox parentBounds = sourceModel.BoundingBox;
UnityEngine.Assertions.Assert.AreEqual(size, parentBounds.Size);
NPVoxBox thisBounds = parentBounds.Clone();
// transform voxels
foreach (NPVoxCoord coord in clampedBox.Enumerate())
{
Vector3 saveCoord = transformMatrix.MultiplyPoint(NPVoxCoordUtil.ToVector(coord));
NPVoxCoord newCoord = NPVoxCoordUtil.ToCoord(saveCoord);
if (!sourceModel.IsInside(newCoord))
{
thisBounds.EnlargeToInclude(newCoord);
}
}
// transform sockets
foreach (NPVoxSocket socket in sourceModel.Sockets)
{
NPVoxCoord newCoord = NPVoxCoordUtil.ToCoord(transformMatrix.MultiplyPoint(NPVoxCoordUtil.ToVector(socket.Anchor)));
if (clampedBox.Contains(socket.Anchor) && !sourceModel.IsInside(newCoord))
{
thisBounds.EnlargeToInclude(newCoord);
}
}
CalculateResizeOffset(parentBounds, thisBounds, out offset, out size);
}
bool hasVoxelGroups = sourceModel.HasVoxelGroups();
NPVoxBoneModel transformedModel = (NPVoxBoneModel)NPVoxModel.NewInstance(sourceModel, size, reuse);
if (hasVoxelGroups)
{
transformedModel.InitVoxelGroups();
transformedModel.NumVoxelGroups = sourceModel.NumVoxelGroups;
}
transformedModel.AllBones = NPVoxBone.CloneBones(sourceModel.AllBones);
// 1. copy all voxels over that are not affected by the transformation
transformedModel.NumVoxels = sourceModel.NumVoxels;
transformedModel.Colortable = sourceModel.Colortable;
foreach (NPVoxCoord coord in sourceModel.EnumerateVoxels())
{
NPVoxCoord movedCoord = coord + offset;
if (!sourceModel.IsInBoneMask(coord, boneMask))
{
transformedModel.SetVoxel(movedCoord, sourceModel.GetVoxel(coord), sourceModel.GetBoneMask(coord));
if (hasVoxelGroups)
{
transformedModel.SetVoxelGroup(movedCoord, sourceModel.GetVoxelGroup(coord));
}
}
}
// 2. copy all voxels that can be tranformed without conflict,
Dictionary <NPVoxCoord, Vector3> conflictVoxels = new Dictionary <NPVoxCoord, Vector3>();
foreach (NPVoxCoord sourceCoord in clampedBox.Enumerate())
{
if (sourceModel.IsInBoneMask(sourceCoord, boneMask))
{
Vector3 saveCoord = transformMatrix.MultiplyPoint(NPVoxCoordUtil.ToVector(sourceCoord));
Vector3 targetCoordSave = saveCoord + NPVoxCoordUtil.ToVector(offset);
NPVoxCoord targetCoord = NPVoxCoordUtil.ToCoord(targetCoordSave);
if (!transformedModel.HasVoxelFast(targetCoord))
{
transformedModel.SetVoxel(targetCoord, markColor == 0 ? sourceModel.GetVoxel(sourceCoord) : markColor, sourceModel.GetBoneMask(sourceCoord));
if (hasVoxelGroups)
{
transformedModel.SetVoxelGroup(targetCoord, sourceModel.GetVoxelGroup(sourceCoord));
}
}
else
{
conflictVoxels[sourceCoord] = targetCoordSave;
}
}
}
// 3. try to fit in voxels that had conflicts
int numberOfConflictsSolved = 0;
if (resolveConflictMethod != ResolveConflictMethodType.NONE)
{
foreach (NPVoxCoord sourceCoord in conflictVoxels.Keys)
{
if (sourceModel.IsInBoneMask(sourceCoord, boneMask))
{
Vector3 targetSaveCoord = conflictVoxels[sourceCoord];
NPVoxCoord nearbyCoord = GetNearbyCoord(transformedModel, targetSaveCoord, resolveConflictMethod);
if (!nearbyCoord.Equals(NPVoxCoord.INVALID))
{
transformedModel.SetVoxel(nearbyCoord, markColor == 0 ? sourceModel.GetVoxel(sourceCoord) : markColor, sourceModel.GetBoneMask(sourceCoord));
if (hasVoxelGroups)
{
transformedModel.SetVoxelGroup(nearbyCoord, sourceModel.GetVoxelGroup(sourceCoord));
}
numberOfConflictsSolved++;
}
}
}
if (numberOfConflictsSolved != conflictVoxels.Count)
{
// Debug.Log(string.Format("transformation has resolved {0}/{1} conflicting voxels", numberOfConflictsSolved, conflictVoxels.Count));
}
}
// 4. transform all sockets
NPVoxSocket[] sockets = new NPVoxSocket[sourceModel.Sockets.Length];
for (int i = 0; i < sockets.Length; i++)
{
NPVoxSocket socket = sourceModel.Sockets[i];
if (clampedBox.Contains(socket.Anchor))
{
// transform anchor
Vector3 saveOriginalAnchor = NPVoxCoordUtil.ToVector(socket.Anchor);
Vector3 saveTargetAnchor = transformMatrix.MultiplyPoint(saveOriginalAnchor) + NPVoxCoordUtil.ToVector(offset);
socket.Anchor = NPVoxCoordUtil.ToCoord(saveTargetAnchor);
// transform Quaternion
Quaternion originalRotation = Quaternion.Euler(socket.EulerAngles);
Matrix4x4 rotated = (Matrix4x4.TRS(Vector3.zero, originalRotation, Vector3.one) * transformMatrix);
socket.EulerAngles = Matrix4x4Util.GetRotation(rotated).eulerAngles;
}
else
{
socket.Anchor = socket.Anchor + offset;
}
sockets[i] = socket;
}
transformedModel.Sockets = sockets;
// 5. count all voxels
// transformedModel.RecalculateNumVoxels();
transformedModel.NumVoxels = transformedModel.NumVoxels - (conflictVoxels.Count - numberOfConflictsSolved);
return(transformedModel);
}
