Ejemplo n.º 1
0
        public override void ReadFromStream(Stream stream)
        {
            EndianBinaryReader reader = new EndianBinaryReader(stream, Program.Endianness);

            /* Read header */
            FileSize                = reader.ReadUInt32();
            Unknown0x04             = reader.ReadUInt32();
            UnknownPointer          = reader.ReadUInt32();
            AssetListPointer        = reader.ReadUInt32();
            ModelListPointer        = reader.ReadUInt32();
            NodeListPointer         = reader.ReadUInt32();
            TransformIndicesPointer = reader.ReadUInt32();
            TransformDataPointer    = reader.ReadUInt32();
            GroupListPointer        = reader.ReadUInt32();
            PrimitiveListPointer    = reader.ReadUInt32();
            VertexDataPointer       = reader.ReadUInt32();
            TextureListPointer      = reader.ReadUInt32();

            /* Read data */
            Assets     = BinaryHelpers.GetMultiDictionary <short, short>(stream, AssetListPointer);
            Models     = BinaryHelpers.GetArray <Model>(stream, ModelListPointer);
            Nodes      = BinaryHelpers.GetArray <Node>(stream, NodeListPointer);
            Groups     = BinaryHelpers.GetArray <Group>(stream, GroupListPointer);
            Primitives = BinaryHelpers.GetArray <Primitive>(stream, PrimitiveListPointer);
            Vertices   = GetVertices(stream, VertexDataPointer, (int)Primitives.Max(x => x.VertexIndices.Max()) + 1);
            Textures   = BinaryHelpers.GetArray <Texture>(stream, TextureListPointer);

            /* Generate textures */
            convTextures = new Cobalt.Texture.Texture[Textures.Length];
            for (int i = 0; i < Textures.Length; i++)
            {
                convTextures[i] = new Cobalt.Texture.Texture(Textures[i].Image, OpenTK.Graphics.OpenGL.TextureWrapMode.Repeat, OpenTK.Graphics.OpenGL.TextureWrapMode.Repeat, OpenTK.Graphics.OpenGL.TextureMinFilter.Linear, OpenTK.Graphics.OpenGL.TextureMagFilter.Linear);
            }

            /* Generate transforms */
            nodeTransforms = new NodeTransformData[Nodes.Length][];
            for (int i = 0; i < Nodes.Length; i++)
            {
                nodeTransforms[i] = new NodeTransformData[Nodes[i].NumTransformIndices];
                for (int j = 0; j < nodeTransforms[i].Length; j++)
                {
                    TransformIndices indices = GetTransformIndices(stream, TransformIndicesPointer, Nodes[i].TransformIndices[j]);

                    NodeTransformData nodeTransform = new NodeTransformData(
                        GetTransformData(stream, TransformDataPointer, indices.TranslationXIndex),
                        GetTransformData(stream, TransformDataPointer, indices.TranslationYIndex),
                        GetTransformData(stream, TransformDataPointer, indices.TranslationZIndex),
                        GetTransformData(stream, TransformDataPointer, indices.RotationXIndex),
                        GetTransformData(stream, TransformDataPointer, indices.RotationYIndex),
                        GetTransformData(stream, TransformDataPointer, indices.RotationZIndex),
                        GetTransformData(stream, TransformDataPointer, indices.ScaleXIndex),
                        GetTransformData(stream, TransformDataPointer, indices.ScaleYIndex),
                        GetTransformData(stream, TransformDataPointer, indices.ScaleZIndex));

                    nodeTransforms[i][j] = nodeTransform;
                }
            }

            primitiveMeshes = new Dictionary <Primitive, Mesh>();
        }
Ejemplo n.º 2
0
        // garbage test

        private Matrix4 GetTransformationMatrix(int baseNodeIdx, int nodeIdx)
        {
            Node node = Nodes[nodeIdx];

            Vector3[] scales       = new Vector3[2];
            Vector3[] rotations    = new Vector3[2];
            Vector3[] translations = new Vector3[2];

            for (int i = 0; i < 2; i++)
            {
                int transformIdx = (int)((Core.DeltaTime / 16.0f) + i);

                transformIdx = tmpTransformIdx + i;

                if (transformIdx >= nodeTransforms[nodeIdx].Length)
                {
                    transformIdx %= nodeTransforms[nodeIdx].Length;
                }

                NodeTransformData nodeTransform = nodeTransforms[nodeIdx][transformIdx];

                scales[i]       = new Vector3(nodeTransform.ScaleX.Value0x00, nodeTransform.ScaleY.Value0x00, nodeTransform.ScaleZ.Value0x00);
                rotations[i]    = new Vector3(nodeTransform.RotationX.Value0x00, nodeTransform.RotationY.Value0x00, nodeTransform.RotationZ.Value0x00);
                translations[i] = new Vector3(nodeTransform.TranslationX.Value0x00, nodeTransform.TranslationY.Value0x00, -nodeTransform.TranslationZ.Value0x00) * 10.0f;
            }

            // garbage test
            OpenTK.Input.KeyboardState tmpKbd = OpenTK.Input.Keyboard.GetState();
            if (tmpKbd[OpenTK.Input.Key.KeypadPlus])
            {
                blend += 0.000005f;
            }
            if (tmpKbd[OpenTK.Input.Key.KeypadMinus])
            {
                blend -= 0.000005f;
            }
            if (blend < 0.0f)
            {
                blend = 0.0f;
            }
            if (blend > 1.0f)
            {
                blend = 1.0f;
            }
            if (tmpKbd[OpenTK.Input.Key.Keypad7] && !tmpLastKbd[OpenTK.Input.Key.Keypad7])
            {
                tmpTransformIdx--;
            }
            if (tmpKbd[OpenTK.Input.Key.Keypad9] && !tmpLastKbd[OpenTK.Input.Key.Keypad9])
            {
                tmpTransformIdx++;
            }
            tmpLastKbd = tmpKbd;
            // garbage test

            Matrix4 localMatrix = Matrix4.Identity;

            localMatrix *= Matrix4.CreateScale(Vector3.Lerp(scales[0], scales[1], blend));
            localMatrix *= Matrix4.CreateRotationX(Vector3.Lerp(rotations[0], rotations[1], blend).X);
            localMatrix *= Matrix4.CreateRotationY(Vector3.Lerp(rotations[0], rotations[1], blend).Y);
            localMatrix *= Matrix4.CreateRotationZ(Vector3.Lerp(rotations[0], rotations[1], blend).Z);
            localMatrix *= Matrix4.CreateTranslation(Vector3.Lerp(translations[0], translations[1], blend));

            if (node.RelatedNodeIndex != -1)
            {
                int relativeNodeIdx = baseNodeIdx + node.RelatedNodeIndex;
                if (relativeNodeIdx != nodeIdx)
                {
                    localMatrix *= GetTransformationMatrix(baseNodeIdx, relativeNodeIdx);
                }
            }

            return(localMatrix);
        }