// Decompiled by DJ v3.11.11.95 Copyright 2009 Atanas Neshkov  Date: 06.11.2010 20:34:34
// Home Page: http://members.fortunecity.com/neshkov/dj.html  http://www.neshkov.com/dj.html - Check often for new version!
// Decompiler options: packimports(3) 
// Source File Name:   VTXFile.java

package mdl2smd;


// Referenced classes of package mdl2smd:
//            ReadFile, Triangle

public class VTXFile
{

    public VTXFile(String path, int type)
    {
        numberOfModelsOffset = 28;
        modelOffsetOffset = 32;
        modelSize = 8;
        subModelSize = 8;
        partSize = 12;
        subPartSize = 8;
        meshSize = 20;
        subMeshSize = 16;
        dataSize = 2;
        largeHeaderSize = 12;
        smallHeaderSize = 2;
        file = new ReadFile(path);
        if(type == 16 || type == 17 || type == 21 || type == 25)
        {
            refSize = smallHeaderSize;
            refPos = 0;
        } else
        {
            refSize = largeHeaderSize;
            refPos = 10;
        }
        read();
    }

    public void read()
    {
        int cNumberOfModels = file.bytesToInt(numberOfModelsOffset);
        int cModelOffset = file.bytesToInt(modelOffsetOffset);
        triangles = new Triangle[cNumberOfModels][][][][][][];
        for(int i = 0; i < cNumberOfModels; i++)
        {
            int cNumberOfSubModels = file.bytesToInt(cModelOffset);
            int cSubModelOffset = cModelOffset + file.bytesToInt(cModelOffset + 4);
            triangles[i] = new Triangle[cNumberOfSubModels][][][][][];
            for(int j = 0; j < cNumberOfSubModels; j++)
            {
                int cNumberOfParts = file.bytesToInt(cSubModelOffset);
                int cPartOffset = cSubModelOffset + file.bytesToInt(cSubModelOffset + 4);
                triangles[i][j] = new Triangle[cNumberOfParts][][][][];
                for(int k = 0; k < cNumberOfParts; k++)
                {
                    int cNumberOfSubParts = file.bytesToInt(cPartOffset);
                    int cSubPartOffset = cPartOffset + file.bytesToInt(cPartOffset + 4);
                    triangles[i][j][k] = new Triangle[cNumberOfSubParts][][][];
                    for(int l = 0; l < cNumberOfSubParts; l++)
                    {
                        int cNumberOfMeshes = file.bytesToShort(cSubPartOffset);
                        int cMeshOffset = cSubPartOffset + file.bytesToInt(cSubPartOffset + 4);
                        triangles[i][j][k][l] = new Triangle[cNumberOfMeshes][][];
                        for(int m = 0; m < cNumberOfMeshes; m++)
                        {
                            int cNumberOfSubMeshes = file.unsignedShortToInt(file.bytesToShort(cMeshOffset + 4));
                            int cHeaderOffset = cMeshOffset + file.bytesToInt(cMeshOffset + 8);
                            int cDataOffset = cMeshOffset + file.bytesToInt(cMeshOffset + 12);
                            int cSubMeshOffset = cMeshOffset + file.bytesToInt(cMeshOffset + 16);
                            triangles[i][j][k][l][m] = new Triangle[cNumberOfSubMeshes][];
                            for(int n = 0; n < cNumberOfSubMeshes; n++)
                            {
                                int cNumberOfDataSubSets = file.unsignedShortToInt(file.bytesToShort(cSubMeshOffset));
                                int cDataSubSetStart = file.unsignedShortToInt(file.bytesToShort(cSubMeshOffset + 2));
                                triangles[i][j][k][l][m][n] = new Triangle[cNumberOfDataSubSets / 3];
                                for(int o = 0; o < cNumberOfDataSubSets; o += 3)
                                {
                                    int cData = file.unsignedShortToInt(file.bytesToShort(cDataOffset + dataSize * (cDataSubSetStart + o)));
                                    int cVertexA = file.unsignedShortToInt(file.bytesToShort(cHeaderOffset + cData * refSize + refPos));
                                    cData = file.unsignedShortToInt(file.bytesToShort(cDataOffset + dataSize * (cDataSubSetStart + o + 1)));
                                    int cVertexB = file.unsignedShortToInt(file.bytesToShort(cHeaderOffset + cData * refSize + refPos));
                                    cData = file.unsignedShortToInt(file.bytesToShort(cDataOffset + dataSize * (cDataSubSetStart + o + 2)));
                                    int cVertexC = file.unsignedShortToInt(file.bytesToShort(cHeaderOffset + cData * refSize + refPos));
                                    triangles[i][j][k][l][m][n][o / 3] = new Triangle((short)l, cVertexA, cVertexC, cVertexB);
                                }

                                cSubMeshOffset += subMeshSize;
                            }

                            cMeshOffset += meshSize;
                        }

                        cSubPartOffset += subPartSize;
                    }

                    cPartOffset += partSize;
                }

                cSubModelOffset += subModelSize;
            }

            cModelOffset += modelSize;
        }

    }

    public Triangle[][][][][][][] getTriangles()
    {
        return triangles;
    }

    public boolean isValid()
    {
        return file.bytesToInt(0) == 107 && file.bytesToInt(4) == 24;
    }

    private ReadFile file;
    private int numberOfModelsOffset;
    private int modelOffsetOffset;
    private int modelSize;
    private int subModelSize;
    private int partSize;
    private int subPartSize;
    private int meshSize;
    private int subMeshSize;
    private int dataSize;
    private int largeHeaderSize;
    private int smallHeaderSize;
    private int refSize;
    private int refPos;
    private Triangle triangles[][][][][][][];
}
