Exemple #1
0
 // Token: 0x0600208D RID: 8333 RVA: 0x0013EE78 File Offset: 0x0013D078
 public AppMain.NNS_VTXLIST_GL_DESC Assign(AppMain.NNS_VTXLIST_GL_DESC desc)
 {
     this.Type             = desc.Type;
     this.nVertex          = desc.nVertex;
     this.nArray           = desc.nArray;
     this.pArray           = desc.pArray;
     this.VertexBufferSize = desc.VertexBufferSize;
     this.pVertexBuffer    = desc.pVertexBuffer;
     this.nMatrix          = desc.nMatrix;
     this.pMatrixIndices   = desc.pMatrixIndices;
     this.BufferName       = desc.BufferName;
     return(this);
 }
Exemple #2
0
        // Token: 0x0600208C RID: 8332 RVA: 0x0013ECDC File Offset: 0x0013CEDC
        public static AppMain.NNS_VTXLIST_GL_DESC Read(BinaryReader reader, long data0Pos)
        {
            AppMain.NNS_VTXLIST_GL_DESC nns_VTXLIST_GL_DESC = new AppMain.NNS_VTXLIST_GL_DESC();
            nns_VTXLIST_GL_DESC.Type    = reader.ReadUInt32();
            nns_VTXLIST_GL_DESC.nVertex = reader.ReadInt32();
            nns_VTXLIST_GL_DESC.nArray  = reader.ReadInt32();
            uint num = reader.ReadUInt32();

            nns_VTXLIST_GL_DESC.VertexBufferSize = reader.ReadInt32();
            uint num2     = reader.ReadUInt32();
            long position = reader.BaseStream.Position;

            reader.BaseStream.Seek(data0Pos + ( long )(( ulong )num2), 0);
            byte[] array = new byte[nns_VTXLIST_GL_DESC.VertexBufferSize];
            reader.Read(array, 0, array.Length);
            nns_VTXLIST_GL_DESC.pVertexBuffer = ByteBuffer.Wrap(array);
            reader.BaseStream.Seek(position, 0);
            if (num != 0U)
            {
                position = reader.BaseStream.Position;
                reader.BaseStream.Seek(data0Pos + ( long )(( ulong )num), 0);
                nns_VTXLIST_GL_DESC.pArray = new AppMain.NNS_VTXARRAY_GL[nns_VTXLIST_GL_DESC.nArray];
                for (int i = 0; i < nns_VTXLIST_GL_DESC.nArray; i++)
                {
                    nns_VTXLIST_GL_DESC.pArray[i] = AppMain.NNS_VTXARRAY_GL.Read(reader, nns_VTXLIST_GL_DESC.pVertexBuffer, num2, nns_VTXLIST_GL_DESC.nVertex);
                }
                reader.BaseStream.Seek(position, 0);
            }
            nns_VTXLIST_GL_DESC.nMatrix = reader.ReadInt32();
            uint num3 = reader.ReadUInt32();

            if (num3 != 0U)
            {
                position = reader.BaseStream.Position;
                reader.BaseStream.Seek(data0Pos + ( long )(( ulong )num3), 0);
                nns_VTXLIST_GL_DESC.pMatrixIndices = new ushort[nns_VTXLIST_GL_DESC.nMatrix];
                for (int j = 0; j < nns_VTXLIST_GL_DESC.nMatrix; j++)
                {
                    nns_VTXLIST_GL_DESC.pMatrixIndices[j] = reader.ReadUInt16();
                }
                reader.BaseStream.Seek(position, 0);
            }
            nns_VTXLIST_GL_DESC.BufferName = reader.ReadUInt32();
            return(nns_VTXLIST_GL_DESC);
        }
        public static AppMain.NNS_VTXLIST_GL_DESC Read(BinaryReader reader, long data0Pos)
        {
            AppMain.NNS_VTXLIST_GL_DESC nnsVtxlistGlDesc = new AppMain.NNS_VTXLIST_GL_DESC();
            nnsVtxlistGlDesc.Type    = reader.ReadUInt32();
            nnsVtxlistGlDesc.nVertex = reader.ReadInt32();
            nnsVtxlistGlDesc.nArray  = reader.ReadInt32();
            uint num1 = reader.ReadUInt32();

            nnsVtxlistGlDesc.VertexBufferSize = reader.ReadInt32();
            uint vertexBufferOffset = reader.ReadUInt32();
            long position1          = reader.BaseStream.Position;

            reader.BaseStream.Seek(data0Pos + (long)vertexBufferOffset, SeekOrigin.Begin);
            byte[] numArray = new byte[nnsVtxlistGlDesc.VertexBufferSize];
            reader.Read(numArray, 0, numArray.Length);
            nnsVtxlistGlDesc.pVertexBuffer = ByteBuffer.Wrap(numArray);
            reader.BaseStream.Seek(position1, SeekOrigin.Begin);
            if (num1 != 0U)
            {
                long position2 = reader.BaseStream.Position;
                reader.BaseStream.Seek(data0Pos + (long)num1, SeekOrigin.Begin);
                nnsVtxlistGlDesc.pArray = new AppMain.NNS_VTXARRAY_GL[nnsVtxlistGlDesc.nArray];
                for (int index = 0; index < nnsVtxlistGlDesc.nArray; ++index)
                {
                    nnsVtxlistGlDesc.pArray[index] = AppMain.NNS_VTXARRAY_GL.Read(reader, nnsVtxlistGlDesc.pVertexBuffer, vertexBufferOffset, nnsVtxlistGlDesc.nVertex);
                }
                reader.BaseStream.Seek(position2, SeekOrigin.Begin);
            }
            nnsVtxlistGlDesc.nMatrix = reader.ReadInt32();
            uint num2 = reader.ReadUInt32();

            if (num2 != 0U)
            {
                long position2 = reader.BaseStream.Position;
                reader.BaseStream.Seek(data0Pos + (long)num2, SeekOrigin.Begin);
                nnsVtxlistGlDesc.pMatrixIndices = new ushort[nnsVtxlistGlDesc.nMatrix];
                for (int index = 0; index < nnsVtxlistGlDesc.nMatrix; ++index)
                {
                    nnsVtxlistGlDesc.pMatrixIndices[index] = reader.ReadUInt16();
                }
                reader.BaseStream.Seek(position2, SeekOrigin.Begin);
            }
            nnsVtxlistGlDesc.BufferName = reader.ReadUInt32();
            return(nnsVtxlistGlDesc);
        }
Exemple #4
0
        // Token: 0x060022EC RID: 8940 RVA: 0x00147414 File Offset: 0x00145614
        public GLVertexBuffer_(AppMain.NNS_VTXLIST_GL_DESC pVtxDesc)
        {
            this.pVtxDesc_     = pVtxDesc;
            this.elementTypes_ = new OpenGL.GLVertexElementType[this.pVtxDesc_.nArray];
            for (int i = 0; i < this.pVtxDesc_.nArray; i++)
            {
                uint type = this.pVtxDesc_.pArray[i].Type;
                if (type <= 8U)
                {
                    switch (type)
                    {
                    case 1U:
                        this.posArray_        = this.pVtxDesc_.pArray[i];
                        this.elementTypes_[i] = OpenGL.GLVertexElementType.Position;
                        break;

                    case 2U:
                        this.blWeightArray_   = this.pVtxDesc_.pArray[i];
                        this.elementTypes_[i] = OpenGL.GLVertexElementType.BlendWeight;
                        break;

                    case 3U:
                        break;

                    case 4U:
                        this.blIndexArray_    = this.pVtxDesc_.pArray[i];
                        this.elementTypes_[i] = OpenGL.GLVertexElementType.BlendIndex;
                        break;

                    default:
                        if (type == 8U)
                        {
                            this.normArray_       = this.pVtxDesc_.pArray[i];
                            this.elementTypes_[i] = OpenGL.GLVertexElementType.Normal;
                        }
                        break;
                    }
                }
                else if (type != 16U)
                {
                    if (type != 256U)
                    {
                        if (type == 512U)
                        {
                            this.texCoord1Array_  = this.pVtxDesc_.pArray[i];
                            this.elementTypes_[i] = OpenGL.GLVertexElementType.TextureCoordinate1;
                        }
                    }
                    else
                    {
                        this.texCoord0Array_  = this.pVtxDesc_.pArray[i];
                        this.elementTypes_[i] = OpenGL.GLVertexElementType.TextureCoordinate0;
                    }
                }
                else
                {
                    this.colArray_        = this.pVtxDesc_.pArray[i];
                    this.elementTypes_[i] = OpenGL.GLVertexElementType.Color;
                }
            }
        }
Exemple #5
0
        public GLVertexBuffer_(AppMain.NNS_VTXLIST_GL_DESC pVtxDesc)
        {
            this.pVtxDesc_     = pVtxDesc;
            this.elementTypes_ = new OpenGL.GLVertexElementType[this.pVtxDesc_.nArray];
            for (int index = 0; index < this.pVtxDesc_.nArray; ++index)
            {
                uint type = this.pVtxDesc_.pArray[index].Type;
                if (type <= 8U)
                {
                    switch ((int)type - 1)
                    {
                    case 0:
                        this.posArray_            = this.pVtxDesc_.pArray[index];
                        this.elementTypes_[index] = OpenGL.GLVertexElementType.Position;
                        continue;

                    case 1:
                        this.blWeightArray_       = this.pVtxDesc_.pArray[index];
                        this.elementTypes_[index] = OpenGL.GLVertexElementType.BlendWeight;
                        continue;

                    case 2:
                        continue;

                    case 3:
                        this.blIndexArray_        = this.pVtxDesc_.pArray[index];
                        this.elementTypes_[index] = OpenGL.GLVertexElementType.BlendIndex;
                        continue;

                    default:
                        if (type == 8U)
                        {
                            this.normArray_           = this.pVtxDesc_.pArray[index];
                            this.elementTypes_[index] = OpenGL.GLVertexElementType.Normal;
                            continue;
                        }
                        continue;
                    }
                }
                else if (type != 16U)
                {
                    if (type != 256U)
                    {
                        if (type == 512U)
                        {
                            this.texCoord1Array_      = this.pVtxDesc_.pArray[index];
                            this.elementTypes_[index] = OpenGL.GLVertexElementType.TextureCoordinate1;
                        }
                    }
                    else
                    {
                        this.texCoord0Array_      = this.pVtxDesc_.pArray[index];
                        this.elementTypes_[index] = OpenGL.GLVertexElementType.TextureCoordinate0;
                    }
                }
                else
                {
                    this.colArray_            = this.pVtxDesc_.pArray[index];
                    this.elementTypes_[index] = OpenGL.GLVertexElementType.Color;
                }
            }
        }