Exemple #1
0
        public void MakeTexture(NsbmdModel mod, List <NsbmdModel.MatTexPalStruct> matList, int idActualMaterial, Boolean modeSingular)
        {
            if (matList == null)
            {
                matList = mod.matTexPalList;
            }
            if (matList[idActualMaterial].format == 0)
            {
                return;
            }

            actualMat = matList[idActualMaterial];
            if (actualMat.palData == null)
            {
                return;
            }

            checkFormat();

            checkImageFlipRotated();

            //MapEditor.Console.AppendText("\nFinish create image " + image.Length);
            List <byte> list = new List <byte>();

            for (int j = 0; j < image.Length; j++)
            {
                list.Add(image[j].R);
                list.Add(image[j].G);
                list.Add(image[j].B);
                list.Add(image[j].A);
            }
            byte[] pixels = list.ToArray();

            if (isOneMaterialMap(matList, idActualMaterial))
            {
                Gl.glBindTexture(Gl.GL_TEXTURE_2D, (int)0);
            }
            if (modeSingular == true)
            {
                Gl.glBindTexture(Gl.GL_TEXTURE_2D, (int)1);
            }
            else
            {
                Gl.glBindTexture(Gl.GL_TEXTURE_2D, (int)idActualMaterial + 1);
            }

            Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, 0x1908, actualMat.width, actualMat.heigth, 0, 0x1908, 0x1401, pixels);
            Gl.glTexParameteri(Gl.GL_TEXTURE_2D, 0x2801, 0x2600);
            Gl.glTexParameteri(Gl.GL_TEXTURE_2D, 0x2800, 0x2600);
        }
Exemple #2
0
 private void makeMatTex()
 {
     tex0.matTexPalList = new List <NsbmdModel.MatTexPalStruct>();
     for (int texCounter = 0; texCounter < tex0.texNum; texCounter++)
     {
         var actualTexInfo = tex0.texInfoArray[texCounter];
         NsbmdModel.MatTexPalStruct actualMatTex = new NsbmdModel.MatTexPalStruct
         {
             heigth = actualTexInfo.heigth,
             format = actualTexInfo.format
         };
         if (actualMatTex.format == 5)
         {
             actualMatTex.texOffset = (uint)(actualTexInfo.vramOffset + tex0.spTexOff);
         }
         else
         {
             actualMatTex.texOffset = ((uint)actualTexInfo.vramOffset) + tex0.texDataOffset;
         }
         actualMatTex.width         = actualTexInfo.width;
         actualMatTex.flipS         = actualTexInfo.flipS;
         actualMatTex.flipT         = actualTexInfo.flipT;
         actualMatTex.repeatS       = actualTexInfo.repeatS;
         actualMatTex.repeatT       = actualTexInfo.repeatT;
         actualMatTex.transFlag     = actualTexInfo.transFlag;
         actualMatTex.texDataOffset = tex0.texDataOffset;
         actualMatTex.texName       = tex0.texNameArray[texCounter];
         actualMatTex.palName       = tex0.palNameArray[texCounter];
         actualMatTex.palMatId      = (uint)actualTexInfo.palId;
         if (texCounter < tex0.palInfoArray.Length)
         {
             actualMatTex.palOffset = (uint)tex0.palInfoArray[texCounter];
         }
         actualMatTex.colorBase = actualTexInfo.colorBase;
         int[] dimList = new int[] { 0, 8, 2, 4, 8, 2, 8, 0x10 };
         actualMatTex.texSize = (uint)(((actualMatTex.width * actualMatTex.heigth) * dimList[actualMatTex.format]) / 8);
         actualMatTex.palSize = ((uint)tex0.endOffset) - actualMatTex.palOffset;
         tex0.matTexPalList.Add(actualMatTex);
     }
 }
Exemple #3
0
        private void processObjects(int idActualPol, int isTextured, ref NsbmdModel.ShapeInfoStruct actualPolygon, ref NsbmdModel.MatTexPalStruct actualMaterials, int num_obj, int idActualMateria)
        {
            NsbmdModel.NodeInfoStruct actualNodeInfo = modelList[idModel].getMDL0at(0).nodeInfoList[num_obj];

            if (actualNodeInfo.restoreId != -1)
            {
                Gl.glLoadMatrixf(MatrixStack[actualNodeInfo.restoreId].Floats);
            }
            if (actualNodeInfo.stackId != -1)
            {
                Gl.glGetFloatv(Gl.GL_MODELVIEW_MATRIX, MatrixStack[actualNodeInfo.stackId].Floats);
                stackID = actualNodeInfo.stackId;
            }

            Gl.glLoadIdentity();

            actualPolygon = modelList[idModel].getMDL0at(0).shapeInfo.shapeList[idActualPol];
            var actualMaterial = modelList[idModel].getMaterials()[idActualMaterial];

            if (isTextured == 0)
            {
                Gl.glPolygonMode(0x408, 0x1b01);
            }
            else
            {
                Gl.glPolygonMode(0x408, 0x1b02);
            }

            Gl.glBindTexture(Gl.GL_TEXTURE_2D, idActualMaterial + 1);
            Gl.glMatrixMode(Gl.GL_TEXTURE);
            Gl.glLoadIdentity();
            if ((actualMaterials.flipS == 1) && (actualMaterials.repeatS > 0))
            {
                Gl.glScalef(2f / ((float)actualMaterials.width), 1f / ((float)actualMaterials.heigth), 1f);
            }
            else if ((actualMaterials.flipT == 1) && (actualMaterials.repeatT > 0))
            {
                Gl.glScalef(1f / ((float)actualMaterials.width), 2f / ((float)actualMaterials.heigth), 1f);
            }
            else
            {
                Gl.glScalef(1f / ((float)actualMaterials.width), 1f / ((float)actualMaterials.heigth), 1f);
            }

            Gl.glColor3f(1f, 1f, 1f);
            stackID = actualPolygon.stackId;
            modelList[idModel].getMDL0at(0).shapeInfo.shapeList[idActualPol] = process3DCommand(actualPolygon.polygonData, actualPolygon);
        }