static protected void MirrorMatrix(PieceTransform pieceTransform, ref float4x4 m)
{
byte mirror = (byte)((byte)pieceTransform & MirrorMask);
switch (mirror)
{
case (byte)PieceTransform.MirrorX: m.c0.x *= -1; m.c1.x *= -1; m.c2.x *= -1; break;
case (byte)PieceTransform.MirrorY: m.c0.y *= -1; m.c1.y *= -1; m.c2.y *= -1; break;
case (byte)PieceTransform.MirrorZ: m.c0.z *= -1; m.c1.z *= -1; m.c2.z *= -1; break;
}
}
static protected float4x4 ToRotationMatrix(PieceTransform pieceTransform)
{
byte rotation = (byte)((byte)pieceTransform & RotationMask);
switch (rotation)
{
case (byte)PieceTransform.Rotate90: return(float4x4.RotateY(math.radians(-90)));
case (byte)PieceTransform.Rotate180: return(float4x4.RotateY(math.radians(-180)));
case (byte)PieceTransform.Rotate270: return(float4x4.RotateY(math.radians(-270)));
}
return(float4x4.identity);
}
/// <summary>
/// can value configuration be transformed into target configuration
/// </summary>
/// <param name="value"></param>
/// <param name="target"></param>
/// <param name="mirrorDirection"></param>
/// <returns></returns>
static private bool FindTransform(byte value, byte target, out PieceTransform transform)
{
transform = PieceTransform.None;
if (value == target)
{
return(true);
}
byte value90 = RotateCW90(value);
byte value180 = RotateCW90(value90);
byte value270 = RotateCW90(value180);
byte valueMirX = MirrorX(value);
byte valueMirX90 = RotateCW90(valueMirX);
byte valueMirX180 = RotateCW90(valueMirX90);
byte valueMirX270 = RotateCW90(valueMirX180);
byte[] values = { value90, value180, value270, valueMirX, valueMirX90, valueMirX180, valueMirX270 };
PieceTransform[] dirs =
{
PieceTransform.Rotate90, PieceTransform.Rotate180, PieceTransform.Rotate270,
PieceTransform.MirrorX, PieceTransform.MirrorX | PieceTransform.Rotate90, PieceTransform.MirrorX | PieceTransform.Rotate180, PieceTransform.MirrorX | PieceTransform.Rotate270
};
for (int i = 0; i < values.Length; ++i)
{
if (values[i] == target)
{
transform = dirs[i];
return(true);
}
}
// this is handled separately because y mirroring will be optional,
// there will be tile sets where it is banned (and for 2d it wouldn't even make sense)
for (int i = 0; i < values.Length; ++i)
{
if (MirrorY(values[i]) == target)
{
transform = dirs[i] | PieceTransform.MirrorY;
return(true);
}
}
return(false);
}
static protected float4x4 CreateTransform(float3 pos, PieceTransform pieceTransform)
{
float4x4 transform = ToRotationMatrix(pieceTransform);
if (HasFlag(pieceTransform, PieceTransform.MirrorX))
{
MirrorMatrix(PieceTransform.MirrorX, ref transform);
}
if (HasFlag(pieceTransform, PieceTransform.MirrorY))
{
MirrorMatrix(PieceTransform.MirrorY, ref transform);
}
transform.c3.x = pos.x;
transform.c3.y = pos.y;
transform.c3.z = pos.z;
return(transform);
}
static protected bool HasFlag(PieceTransform transform, PieceTransform flag)
{
return((byte)(transform & flag) != 0);
}
public ConfigTransform(int baseMeshIndex, PieceTransform pieceTransform)
{
this.baseMeshIndex = baseMeshIndex;
this.pieceTransform = pieceTransform;
}
