public static void ToTrAngle(WadKeyFrameRotation angle, List <short> outFrameData, bool isTr1, bool isTr4Or5)
{
bool xAbout0 = Math.Abs(angle.Rotations.X) <= (1.0f / 2048);
bool yAbout0 = Math.Abs(angle.Rotations.Y) <= (1.0f / 2048);
bool zAbout0 = Math.Abs(angle.Rotations.Z) <= (1.0f / 2048);
// Handle cases with only 1 axis
if (!isTr1)
{
if (yAbout0 && zAbout0) // Only rotation on first angle
{
int rot;
if (isTr4Or5)
{
rot = 0xfff & (int)Math.Round(-angle.Rotations.X * (4096.0f / 360.0f));
}
else
{
rot = 0x3ff & (int)Math.Round(-angle.Rotations.X * (1024.0f / 360.0f));
}
outFrameData.Add((short)(0x4000 | rot));
return;
}
else if (xAbout0 && zAbout0) // Only rotation on second angle
{
int rot;
if (isTr4Or5)
{
rot = 0xfff & (int)Math.Round(angle.Rotations.Y * (4096.0f / 360.0f));
}
else
{
rot = 0x3ff & (int)Math.Round(angle.Rotations.Y * (1024.0f / 360.0f));
}
outFrameData.Add((short)(0x8000 | rot));
return;
}
else if (xAbout0 && yAbout0) // Only rotation on third angle
{
int rot;
if (isTr4Or5)
{
rot = 0xfff & (int)Math.Round(-angle.Rotations.Z * (4096.0f / 360.0f));
}
else
{
rot = 0x3ff & (int)Math.Round(-angle.Rotations.Z * (1024.0f / 360.0f));
}
outFrameData.Add((short)(0xc000 | rot));
return;
}
}
// Handle general case
int rotX = 0x3ff & (int)Math.Round(-angle.Rotations.X * (1024.0f / 360.0f));
int rotY = 0x3ff & (int)Math.Round(angle.Rotations.Y * (1024.0f / 360.0f));
int rotZ = 0x3ff & (int)Math.Round(-angle.Rotations.Z * (1024.0f / 360.0f));
outFrameData.Add((short)((rotX << 4) | ((rotY & 0xfc0) >> 6)));
outFrameData.Add((short)(((rotY & 0x3f) << 10) | (rotZ & 0x3ff)));
}
private static bool LoadMoveables(ChunkReader chunkIO, ChunkId idOuter, Wad2 wad,
Dictionary <long, WadSoundInfo> soundInfos,
Dictionary <long, WadTexture> textures)
{
if (idOuter != Wad2Chunks.Moveables)
{
return(false);
}
chunkIO.ReadChunks((id, chunkSize) =>
{
if (id != Wad2Chunks.Moveable)
{
return(false);
}
uint objTypeId = LEB128.ReadUInt(chunkIO.Raw);
var mov = new WadMoveable(new WadMoveableId(objTypeId));
var meshes = new List <WadMesh>();
chunkIO.ReadChunks((id2, chunkSize2) =>
{
if (id2 == Wad2Chunks.Mesh)
{
var mesh = LoadMesh(chunkIO, chunkSize2, textures);
meshes.Add(mesh);
}
else if (id2 == Wad2Chunks.MoveableBone)
{
var skeleton = LoadBone(chunkIO, mov, meshes);
// Now convert the skeleton in the new (?) format. Ugly system but this is required for
// setting exact hardcoded ID for some moveables (i.e. gun mesh of an enemy, the engine
// has hardcoded mesh indices for effects)
var bones = new List <WadBone>();
var root = new WadBone();
root.Name = skeleton.Name;
root.Translation = Vector3.Zero;
root.Mesh = skeleton.Mesh;
bones.Add(root);
BuildNewMeshTree(skeleton, bones);
mov.Bones.AddRange(bones);
}
else if (id2 == Wad2Chunks.MoveableBoneNew)
{
var bone = new WadBone();
bone.OpCode = (WadLinkOpcode)LEB128.ReadByte(chunkIO.Raw);
bone.Name = chunkIO.Raw.ReadStringUTF8();
chunkIO.ReadChunks((id3, chunkSize3) =>
{
if (id3 == Wad2Chunks.MoveableBoneTranslation)
{
bone.Translation = chunkIO.ReadChunkVector3(chunkSize);
}
else if (id3 == Wad2Chunks.MoveableBoneMeshPointer)
{
bone.Mesh = meshes[chunkIO.ReadChunkInt(chunkSize)];
}
else
{
return(false);
}
return(true);
});
mov.Bones.Add(bone);
}
else if (id2 == Wad2Chunks.AnimationObsolete ||
id2 == Wad2Chunks.Animation ||
id2 == Wad2Chunks.Animation2)
{
var animation = new WadAnimation();
animation.StateId = LEB128.ReadUShort(chunkIO.Raw);
animation.EndFrame = LEB128.ReadUShort(chunkIO.Raw);
animation.FrameRate = LEB128.ReadByte(chunkIO.Raw);
if (id2 == Wad2Chunks.AnimationObsolete)
{
LEB128.ReadUShort(chunkIO.Raw);
LEB128.ReadUShort(chunkIO.Raw);
}
int oldSpeed, oldAccel, oldLatSpeed, oldLatAccel;
oldSpeed = oldAccel = oldLatSpeed = oldLatAccel = 0;
if (id2 != Wad2Chunks.Animation2)
{
// Use old speeds/accels for legacy chunk versions
oldSpeed = LEB128.ReadInt(chunkIO.Raw);
oldAccel = LEB128.ReadInt(chunkIO.Raw);
oldLatSpeed = LEB128.ReadInt(chunkIO.Raw);
oldLatAccel = LEB128.ReadInt(chunkIO.Raw);
// Correct EndFrame for legacy chunk versions
if (animation.EndFrame > 0)
{
animation.EndFrame--;
}
}
// Fix possibly corrupted EndFrame value which was caused by bug introduced in 1.2.9
if (animation.EndFrame == ushort.MaxValue)
{
animation.EndFrame = 0;
}
animation.NextAnimation = LEB128.ReadUShort(chunkIO.Raw);
animation.NextFrame = LEB128.ReadUShort(chunkIO.Raw);
bool foundNewVelocitiesChunk = false;
chunkIO.ReadChunks((id3, chunkSize3) =>
{
if (id3 == Wad2Chunks.AnimationName)
{
animation.Name = chunkIO.ReadChunkString(chunkSize3);
}
else if (id3 == Wad2Chunks.AnimationVelocities)
{
foundNewVelocitiesChunk = true;
var velocities = chunkIO.ReadChunkVector4(chunkSize);
animation.StartVelocity = velocities.X;
animation.EndVelocity = velocities.Y;
animation.StartLateralVelocity = velocities.Z;
animation.EndLateralVelocity = velocities.W;
}
else if (id3 == Wad2Chunks.KeyFrame)
{
var keyframe = new WadKeyFrame();
chunkIO.ReadChunks((id4, chunkSize4) =>
{
if (id4 == Wad2Chunks.KeyFrameOffset)
{
keyframe.Offset = chunkIO.ReadChunkVector3(chunkSize4);
}
else if (id4 == Wad2Chunks.KeyFrameBoundingBox)
{
var kfMin = Vector3.Zero;
var kfMax = Vector3.Zero;
chunkIO.ReadChunks((id5, chunkSize5) =>
{
if (id5 == Wad2Chunks.MeshBoundingBoxMin)
{
kfMin = chunkIO.ReadChunkVector3(chunkSize5);
}
else if (id5 == Wad2Chunks.MeshBoundingBoxMax)
{
kfMax = chunkIO.ReadChunkVector3(chunkSize5);
}
else
{
return(false);
}
return(true);
});
keyframe.BoundingBox = new BoundingBox(kfMin, kfMax);
}
else if (id4 == Wad2Chunks.KeyFrameAngle)
{
var angle = new WadKeyFrameRotation();
angle.Rotations = chunkIO.ReadChunkVector3(chunkSize4);
keyframe.Angles.Add(angle);
}
else
{
return(false);
}
return(true);
});
animation.KeyFrames.Add(keyframe);
}
else if (id3 == Wad2Chunks.StateChange)
{
var stateChange = new WadStateChange();
stateChange.StateId = LEB128.ReadUShort(chunkIO.Raw);
chunkIO.ReadChunks((id4, chunkSize4) =>
{
if (id4 == Wad2Chunks.Dispatch)
{
var dispatch = new WadAnimDispatch();
dispatch.InFrame = LEB128.ReadUShort(chunkIO.Raw);
dispatch.OutFrame = LEB128.ReadUShort(chunkIO.Raw);
dispatch.NextAnimation = LEB128.ReadUShort(chunkIO.Raw);
dispatch.NextFrame = LEB128.ReadUShort(chunkIO.Raw);
stateChange.Dispatches.Add(dispatch);
}
else
{
return(false);
}
return(true);
});
animation.StateChanges.Add(stateChange);
}
else if (id3 == Wad2Chunks.AnimCommand)
{
var command = new WadAnimCommand();
long offset = chunkIO.Raw.BaseStream.Position;
command.Type = (WadAnimCommandType)LEB128.ReadUShort(chunkIO.Raw);
command.Parameter1 = LEB128.ReadShort(chunkIO.Raw);
command.Parameter2 = LEB128.ReadShort(chunkIO.Raw);
command.Parameter3 = LEB128.ReadShort(chunkIO.Raw);
chunkIO.ReadChunks((id4, chunkSize4) =>
{
if (id4 == Wad2Chunks.AnimCommandSoundInfo)
{
var info = chunkIO.ReadChunkInt(chunkSize4);
if (info != -1)
{
command.SoundInfoObsolete = soundInfos[info];
}
return(true);
}
else
{
return(false);
}
});
animation.AnimCommands.Add(command);
}
else
{
return(false);
}
return(true);
});
// Legacy code for calculating start and end velocities
if (!foundNewVelocitiesChunk)
{
float acceleration = oldAccel / 65536.0f;
animation.StartVelocity = oldSpeed / 65536.0f;
animation.EndVelocity = animation.StartVelocity + acceleration *
(animation.KeyFrames.Count - 1) * animation.FrameRate;
float lateralAcceleration = oldLatAccel / 65536.0f;
animation.StartLateralVelocity = oldLatSpeed / 65536.0f;
animation.EndLateralVelocity = animation.StartLateralVelocity + lateralAcceleration *
(animation.KeyFrames.Count - 1) * animation.FrameRate;
}
mov.Animations.Add(animation);
}
else
{
return(false);
}
return(true);
});
wad.Moveables.Add(mov.Id, mov);
return(true);
});
return(true);
}
