Beispiel #1
0
        public WadBone Clone()
        {
            WadBone newBone = new WadBone();

            newBone.Name        = Name;
            newBone.Mesh        = Mesh;
            newBone.Translation = Translation;
            newBone.OpCode      = OpCode;

            return(newBone);
        }
Beispiel #2
0
 private static void WriteBone(ChunkWriter chunkIO, WadBone bone, List <WadBone> bones)
 {
     chunkIO.WriteChunkWithChildren(Wad2Chunks.MoveableBone, () =>
     {
         chunkIO.WriteChunkString(Wad2Chunks.MoveableBoneName, bone.Name);
         chunkIO.WriteChunkInt(Wad2Chunks.MoveableBoneMeshPointer, bones.IndexOf(bone));
         chunkIO.WriteChunkVector3(Wad2Chunks.MoveableBoneTranslation, bone.Translation);
         foreach (var childBone in bone.Children)
         {
             WriteBone(chunkIO, childBone, bones);
         }
     });
 }
Beispiel #3
0
        public WadBone Clone(WadBone parentBone)
        {
            WadBone newBone = new WadBone();

            newBone.Name        = Name;
            newBone.Mesh        = Mesh;
            newBone.Translation = Translation;
            newBone.Parent      = parentBone;

            foreach (var childBone in Children)
            {
                newBone.Children.Add(childBone.Clone(newBone));
            }

            return(newBone);
        }
Beispiel #4
0
        private static void BuildNewMeshTree(WadBone bone, List <WadBone> meshTrees)
        {
            var newBone = new WadBone();

            newBone.Translation = bone.Translation;
            newBone.Mesh        = bone.Mesh;
            newBone.Name        = bone.Name;

            if (bone.Parent == null)
            {
                newBone.OpCode = WadLinkOpcode.Push;
            }
            else
            {
                if (bone.Parent.Children.Count == 1)
                {
                    newBone.OpCode = WadLinkOpcode.NotUseStack;
                }
                else
                {
                    int childrenCount = bone.Parent.Children.Count;
                    if (bone.Parent.Children.IndexOf(bone) == 0)
                    {
                        newBone.OpCode = WadLinkOpcode.Push;
                    }
                    else if (bone.Parent.Children.IndexOf(bone) == childrenCount - 1)
                    {
                        newBone.OpCode = WadLinkOpcode.Pop;
                    }
                    else
                    {
                        newBone.OpCode = WadLinkOpcode.Read;
                    }
                }
            }

            if (bone.Parent != null)
            {
                meshTrees.Add(newBone);
            }

            for (int i = 0; i < bone.Children.Count; i++)
            {
                BuildNewMeshTree(bone.Children[i], meshTrees);
            }
        }
Beispiel #5
0
        private static WadBone LoadBone(ChunkReader chunkIO, WadMoveable mov, List <WadMesh> meshes)
        {
            WadBone bone = new WadBone();

            chunkIO.ReadChunks((id, chunkSize) =>
            {
                if (id == Wad2Chunks.MoveableBoneName)
                {
                    bone.Name = chunkIO.ReadChunkString(chunkSize);
                    //Console.WriteLine("Processing " + bone.Name);
                }
                else if (id == Wad2Chunks.MoveableBoneTranslation)
                {
                    bone.Translation = chunkIO.ReadChunkVector3(chunkSize);
                }
                else if (id == Wad2Chunks.MoveableBoneMeshPointer)
                {
                    bone.Mesh = meshes[chunkIO.ReadChunkInt(chunkSize)];
                }
                else if (id == Wad2Chunks.MoveableBone)
                {
                    bone.Children.Add(LoadBone(chunkIO, mov, meshes));
                }
                else
                {
                    return(false);
                }
                return(true);
            });

            foreach (var childBone in bone.Children)
            {
                childBone.Parent = bone;
            }

            return(bone);
        }
Beispiel #6
0
        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);
        }