Beispiel #1
0
    public void setFloorType(int newType)
    {
        if (newType == this.m_floorType)
        {
            return;
        }
        SimWorld simWorld = AppEngine.getCanvas().getSimWorld();

        GeomStrip.remapTexCoords(this.m_compositeMesh, simWorld.getFloorTexCoords(this.m_floorType), simWorld.getFloorTexCoords(newType), 24);
        this.m_floorType = newType;
    }
Beispiel #2
0
    public static Mesh createMesh(GeomStrip[] subGeomStrips)
    {
        int length1 = subGeomStrips.Length;

        IndexBuffer[] submeshes   = new IndexBuffer[length1];
        int           vertexCount = 0;

        for (int index = 0; index < length1; ++index)
        {
            GeomStrip subGeomStrip = subGeomStrips[index];
            if (subGeomStrip != null)
            {
                int num = subGeomStrip.m_posCoords.Length / 3;
                vertexCount += num;
            }
        }
        VertexArray arr1        = new VertexArray(vertexCount, 3, 2);
        VertexArray arr2        = new VertexArray(vertexCount, 2, 2);
        VertexArray arr3        = new VertexArray(vertexCount, 4, 1);
        int         firstVertex = 0;

        for (int index1 = 0; index1 < length1; ++index1)
        {
            GeomStrip subGeomStrip = subGeomStrips[index1];
            if (subGeomStrip != null)
            {
                int numVertices = subGeomStrip.m_posCoords.Length / 3;
                arr1.set(firstVertex, numVertices, subGeomStrip.m_posCoords);
                arr2.set(firstVertex, numVertices, subGeomStrip.m_texCoords);
                arr3.set(firstVertex, numVertices, subGeomStrip.m_colCoords);
                int   length2 = subGeomStrip.m_indices.Length;
                int[] indices = new int[length2];
                for (int index2 = 0; index2 < length2; ++index2)
                {
                    indices[index2] = subGeomStrip.m_indices[index2] + firstVertex;
                }
                IndexBuffer indexBuffer = new IndexBuffer(8, length2 / 3, indices);
                submeshes[index1] = indexBuffer;
                firstVertex      += numVertices;
            }
        }
        VertexBuffer vertices = new VertexBuffer();

        float[] bias = (float[])null;
        vertices.setPositions(arr1, 1f, bias);
        vertices.setTexCoords(0, arr2, 0.0001220703f, (float[])null);
        vertices.setColors(arr3);
        Appearance[] appearances = new Appearance[0];
        return(new Mesh(vertices, ref submeshes, ref appearances));
    }
Beispiel #3
0
    public void setWallType(int newType)
    {
        if (newType == this.m_wallType)
        {
            return;
        }
        SimWorld simWorld = AppEngine.getCanvas().getSimWorld();

        int[] wallTexCoords1 = simWorld.getWallTexCoords(this.m_wallType);
        int[] wallTexCoords2 = simWorld.getWallTexCoords(newType);
        for (int index = 0; index < 4; ++index)
        {
            int submeshIndex = index * 6;
            GeomStrip.remapTexCoords(this.m_compositeMesh, wallTexCoords1, wallTexCoords2, submeshIndex);
            GeomStrip.remapTexCoords(this.m_compositeMesh, wallTexCoords1, wallTexCoords2, submeshIndex + 2);
        }
        this.m_wallType = newType;
    }
Beispiel #4
0
    public void setTintOutside(int tint)
    {
        this.m_dayNightTint = tint;
        int tintInside = this.getTintInside();

        for (int index = 0; index < this.m_corners.Length; ++index)
        {
            this.m_corners[index].setTintOutside(tint);
        }
        for (int index = 0; index < 4; ++index)
        {
            int submeshIndex = index * 6;
            GeomStrip.setTint(tintInside, this.m_compositeMesh, submeshIndex);
            GeomStrip.setTint(tintInside, this.m_compositeMesh, submeshIndex + 1);
            GeomStrip.setTint(tintInside, this.m_compositeMesh, submeshIndex + 2);
            GeomStrip.setTint(tint, this.m_compositeMesh, submeshIndex + 3);
            GeomStrip.setTint(tint, this.m_compositeMesh, submeshIndex + 4);
            GeomStrip.setTint(tint, this.m_compositeMesh, submeshIndex + 5);
        }
        GeomStrip.setTint(tintInside, this.m_compositeMesh, 24);
    }
Beispiel #5
0
    public void createGeometry()
    {
        ModelManager instance    = ModelManager.getInstance();
        Appearance   appearance1 = instance.getAppearance(0);
        Appearance   appearance2 = instance.getAppearance(1);

        this.m_appWallAlpha   = instance.getAppearance(2);
        this.m_appWallReplace = appearance2;
        SimWorld simWorld = AppEngine.getCanvas().getSimWorld();
        int      length1  = JMath.min(6, this.m_sizeX >> 1);
        int      length2  = JMath.min(6, this.m_sizeZ >> 1);

        this.m_wallWindows[0] = new MapObject[length1];
        this.m_wallWindows[2] = new MapObject[length1];
        this.m_wallWindows[1] = new MapObject[length2];
        this.m_wallWindows[3] = new MapObject[length2];
        for (int index = 0; index <= this.m_sizeX; ++index)
        {
            int tileX = this.m_posX + index;
            int posZ  = this.m_posZ;
            AppEngine.appendUnique(simWorld.registerWall(this, 0, tileX, posZ), this.m_wallWindows[0], (MapObject)null);
            int tileZ = this.m_posZ + this.m_sizeZ;
            AppEngine.appendUnique(simWorld.registerWall(this, 2, tileX, tileZ), this.m_wallWindows[2], (MapObject)null);
        }
        for (int index = 0; index <= this.m_sizeZ; ++index)
        {
            int tileZ = this.m_posZ + index;
            int posX  = this.m_posX;
            AppEngine.appendUnique(simWorld.registerWall(this, 3, posX, tileZ), this.m_wallWindows[3], (MapObject)null);
            int tileX = this.m_posX + this.m_sizeX;
            AppEngine.appendUnique(simWorld.registerWall(this, 1, tileX, tileZ), this.m_wallWindows[1], (MapObject)null);
        }
        GeomStrip[] geomStripArray = new GeomStrip[25];
        for (int index = 0; index < geomStripArray.Length; ++index)
        {
            geomStripArray[index] = new GeomStrip();
        }
        GeomStrip geomStrip1 = geomStripArray[24];

        this.m_group = new Group();
        int[] floorTexCoords = simWorld.getFloorTexCoords(this.m_floorType);
        int[] wallTexCoords1 = simWorld.getWallTexCoords(this.m_wallType);
        int[] wallTexCoords2 = simWorld.getWallTexCoords(46);
        int[] wallTexCoords3 = simWorld.getWallTexCoords(27);
        int   panelX1        = this.m_posX * 32;
        int   panelZ1        = this.m_posZ * 32;
        int   panelW1        = this.m_sizeX * 32;
        int   panelH1        = this.m_sizeZ * 32;
        int   num1           = 18;

        geomStrip1.addFloor(panelX1, panelZ1, panelW1, panelH1, floorTexCoords, num1, num1, num1, num1);
        geomStrip1.addFloor(panelX1, panelZ1, 32, 32, floorTexCoords, 2, 14, 2, 14, 5);
        geomStrip1.addFloor(panelX1, panelZ1, panelW1, 32, floorTexCoords, 18, 18, 2, 14, 4);
        geomStrip1.addFloor(panelX1 + panelW1 - 32, panelZ1, 32, 32, floorTexCoords, 14, 2, 2, 14, 6);
        geomStrip1.addFloor(panelX1 + panelW1 - 32, panelZ1, 32, panelH1, floorTexCoords, 14, 2, 18, 18, 2);
        geomStrip1.addFloor(panelX1 + panelW1 - 32, panelZ1 + panelH1 - 32, 32, 32, floorTexCoords, 14, 2, 14, 2, 10);
        geomStrip1.addFloor(panelX1, panelZ1 + panelH1 - 32, panelW1, 32, floorTexCoords, 18, 18, 14, 2, 8);
        geomStrip1.addFloor(panelX1, panelZ1 + panelH1 - 32, 32, 32, floorTexCoords, 2, 14, 14, 2, 9);
        geomStrip1.addFloor(panelX1, panelZ1, 32, panelH1, floorTexCoords, 2, 14, 18, 18, 1);
        for (int index1 = 0; index1 < 4; ++index1)
        {
            int           index2     = index1 * 6;
            GeomStrip     geomStrip2 = geomStripArray[index2 + 2];
            GeomStrip     geomStrip3 = geomStripArray[index2];
            GeomStrip     geomStrip4 = geomStripArray[index2 + 1];
            GeomStrip     geomStrip5 = geomStripArray[index2 + 5];
            GeomStrip     geomStrip6 = geomStripArray[index2 + 3];
            GeomStrip     geomStrip7 = geomStripArray[index2 + 4];
            int           num2       = 0;
            int           num3       = 0;
            int           num4       = 0;
            int           num5       = 0;
            int           num6       = 0;
            GeomStrip.Dir dir1       = GeomStrip.Dir.DIR_X_POS;
            int           num7       = 0;
            int           num8       = 0;
            GeomStrip.Dir dir2       = GeomStrip.Dir.DIR_X_POS;
            switch (index1)
            {
            case 0:
                num2 = this.m_posX;
                num3 = this.m_posZ;
                num6 = this.m_sizeX;
                dir1 = GeomStrip.Dir.DIR_X_POS;
                num7 = 1;
                num4 = this.m_posX * 32;
                num5 = this.m_posZ * 32 + 2;
                dir2 = GeomStrip.Dir.DIR_X_NEG;
                break;

            case 1:
                num2 = this.m_posX + this.m_sizeX;
                num3 = this.m_posZ;
                num6 = this.m_sizeZ;
                dir1 = GeomStrip.Dir.DIR_Z_POS;
                num8 = 1;
                num4 = this.m_posX * 32 + this.m_sizeX * 32 - 2;
                num5 = this.m_posZ * 32;
                dir2 = GeomStrip.Dir.DIR_Z_NEG;
                break;

            case 2:
                num2 = this.m_posX + this.m_sizeX - 1;
                num3 = this.m_posZ + this.m_sizeZ;
                num6 = this.m_sizeX;
                dir1 = GeomStrip.Dir.DIR_X_NEG;
                num7 = -1;
                num4 = this.m_posX * 32 + this.m_sizeX * 32;
                num5 = this.m_posZ * 32 + this.m_sizeZ * 32 - 2;
                dir2 = GeomStrip.Dir.DIR_X_POS;
                break;

            case 3:
                num2 = this.m_posX;
                num3 = this.m_posZ + this.m_sizeZ - 1;
                num6 = this.m_sizeZ;
                dir1 = GeomStrip.Dir.DIR_Z_NEG;
                num8 = -1;
                num4 = this.m_posX * 32 + 2;
                num5 = this.m_posZ * 32 + this.m_sizeZ * 32;
                dir2 = GeomStrip.Dir.DIR_Z_POS;
                break;
            }
            int  num9    = -num8;
            int  num10   = num7;
            int  tileX   = num2;
            int  tileZ   = num3;
            int  panelX2 = num4;
            int  panelZ2 = num5;
            bool flag1   = false;
            bool flag2   = false;
            bool flag3   = false;
            bool flag4   = false;
            bool flag5   = false;
            bool flag6   = false;
            bool flag7   = false;
            bool flag8   = false;
            int  num11   = 0;
            int  num12   = 0;
            int  panelW2 = 0;
            int  num13   = 0;
            int  num14   = 0;
            int  num15   = 0;
            int  num16   = 0;
            int  num17   = 0;
            int  panelW3 = 0;
            for (int index3 = 0; index3 < num6; ++index3)
            {
                int  attribute = simWorld.getAttribute(tileX, tileZ);
                bool flag9     = (attribute & 3840) != 0;
                bool flag10    = (attribute & 64) != 0;
                bool flag11    = !flag10 && (attribute & 32) != 0;
                bool flag12    = (attribute & 128) != 0;
                bool flag13    = (simWorld.getAttribute(tileX - num9, tileZ - num10) & 16) == 0;
                bool flag14    = flag9 && flag13;
                if (flag9 && !flag1 || (flag5 || flag4))
                {
                    num11   = panelX2;
                    num12   = panelZ2;
                    panelW2 = 0;
                }
                if (!flag9 && flag1)
                {
                    num13 = panelX2;
                    num14 = panelZ2;
                    num15 = 0;
                }
                if (flag14 && !flag2 || (flag5 || flag4))
                {
                    num16   = panelX2;
                    num17   = panelZ2;
                    panelW3 = 0;
                    flag6   = flag3;
                    flag7   = flag4;
                    flag8   = flag5;
                }
                if (flag9)
                {
                    panelW2 += 32;
                }
                else
                {
                    num15 += 32;
                }
                if (flag14)
                {
                    panelW3 += 32;
                }
                if (flag10)
                {
                    geomStrip2.addDoorWall(panelX2, panelZ2, 32, dir1, wallTexCoords1, 0, 0);
                    geomStrip2.addTallWallTop(panelX2, panelZ2, 32, dir1, wallTexCoords2, 0, 0);
                    if (flag13)
                    {
                        int num18   = num16 + num7 * panelW3 - num9 * 4;
                        int num19   = num17 + num8 * panelW3 - num10 * 4;
                        int panelX3 = num18 + num7 * 32;
                        int panelZ3 = num19 + num8 * 32;
                        geomStrip5.addDoorWall(panelX3, panelZ3, 32, dir2, wallTexCoords3, 0, 0);
                        geomStrip5.addTallWallTop(panelX3, panelZ3, 32, dir2, wallTexCoords2, 0, 0);
                    }
                }
                if (panelW2 > 0 && (flag12 && flag9 || !flag9 && flag1 || index3 == num6 - 1))
                {
                    int panelX3   = num11;
                    int panelZ3   = num12;
                    int flags     = 0;
                    int trimStart = 0;
                    int trimEnd   = 0;
                    if (num11 == num4 && num12 == num5)
                    {
                        trimStart = 2;
                        flags    |= 1;
                    }
                    if (index3 == num6 - 1)
                    {
                        trimEnd = 2;
                        flags  |= 2;
                    }
                    if (flag12)
                    {
                        geomStrip2.addWindowWall(panelX2, panelZ2, 32, dir1, wallTexCoords1, 0, 0);
                        geomStrip2.addTallWallTop(panelX2, panelZ2, 32, dir1, wallTexCoords2, 0, 0);
                        geomStrip3.addShortWall(panelX2, panelZ2, 32, dir1, wallTexCoords1, 0, 0);
                        geomStrip4.addShortWallTop(panelX2, panelZ2, 32, dir1, wallTexCoords2, 0, 0);
                        panelW2 -= 32;
                    }
                    if (panelW2 > 0)
                    {
                        geomStrip2.addTallWall(panelX3, panelZ3, panelW2, dir1, wallTexCoords1, trimStart, trimEnd, flags);
                        geomStrip2.addTallWallTop(panelX3, panelZ3, panelW2, dir1, wallTexCoords2, trimStart, trimEnd);
                        geomStrip3.addShortWall(panelX3, panelZ3, panelW2, dir1, wallTexCoords1, trimStart, trimEnd, flags);
                        geomStrip4.addShortWallTop(panelX3, panelZ3, panelW2, dir1, wallTexCoords2, trimStart, trimEnd);
                        if (!flag8 && !flag7)
                        {
                            int panelX4 = panelX3 + num7 * trimStart;
                            int panelZ4 = panelZ3 + num8 * trimStart;
                            geomStrip2.addTallCap(panelX4, panelZ4, dir1, wallTexCoords2);
                            geomStrip4.addShortCap(panelX4, panelZ4, dir1, wallTexCoords2);
                        }
                        if (!flag12 && !flag10)
                        {
                            int panelX4 = panelX3 + -num9 * 2 + num7 * (panelW2 - trimEnd);
                            int panelZ4 = panelZ3 + -num10 * 2 + num8 * (panelW2 - trimEnd);
                            geomStrip2.addTallCap(panelX4, panelZ4, dir2, wallTexCoords2);
                            geomStrip4.addShortCap(panelX4, panelZ4, dir2, wallTexCoords2);
                        }
                    }
                }
                if (num15 > 0 && flag9 && !flag1)
                {
                    int panelX3    = 0;
                    int panelZ3    = 0;
                    int panelW4    = 0;
                    int panelH2    = 0;
                    int trimStartX = 0;
                    int trimEndX   = 0;
                    int trimStartZ = 0;
                    int trimEndZ   = 0;
                    switch (dir1)
                    {
                    case GeomStrip.Dir.DIR_X_POS:
                        panelX3    = num13;
                        panelZ3    = num14 - 2;
                        panelW4    = num15;
                        panelH2    = 32;
                        trimStartZ = 0;
                        trimEndZ   = 30;
                        break;

                    case GeomStrip.Dir.DIR_Z_POS:
                        panelX3    = num13 - 32 + 2;
                        panelZ3    = num14;
                        panelW4    = 32;
                        panelH2    = num15;
                        trimStartX = 30;
                        trimEndX   = 0;
                        break;

                    case GeomStrip.Dir.DIR_X_NEG:
                        panelX3    = num13 - num15;
                        panelZ3    = num14 - 32 + 2;
                        panelW4    = num15;
                        panelH2    = 32;
                        trimStartZ = 30;
                        trimEndZ   = 0;
                        break;

                    case GeomStrip.Dir.DIR_Z_NEG:
                        panelX3    = num13 - 2;
                        panelZ3    = num14 - num15;
                        panelW4    = 32;
                        panelH2    = num15;
                        trimStartX = 0;
                        trimEndX   = 30;
                        break;
                    }
                    geomStrip1.addFloor(panelX3, panelZ3, panelW4, panelH2, floorTexCoords, trimStartX, trimEndX, trimStartZ, trimEndZ, 15);
                }
                if (panelW3 > 0 && ((flag12 || flag10) && flag14 || (!flag14 && flag2 || flag14 && index3 == num6 - 1)))
                {
                    int panelX3   = num16 + num7 * panelW3 - num9 * 4;
                    int panelZ3   = num17 + num8 * panelW3 - num10 * 4;
                    int trimEnd   = flag6 || flag8 || flag7 ? 0 : 2;
                    int trimStart = flag11 || flag12 || flag10 ? 0 : 2;
                    if (flag12)
                    {
                        geomStrip5.addWindowWall(panelX3, panelZ3, 32, dir2, wallTexCoords3, 0, 0);
                        geomStrip5.addTallWallTop(panelX3, panelZ3, 32, dir2, wallTexCoords2, 0, 0);
                        geomStrip6.addShortWall(panelX3, panelZ3, 32, dir2, wallTexCoords3, 0, 0);
                        geomStrip7.addShortWallTop(panelX3, panelZ3, 32, dir2, wallTexCoords2, 0, 0);
                        panelW3 -= 32;
                        panelX3 += -num7 * 32;
                        panelZ3 += -num8 * 32;
                    }
                    if (panelW3 > 0)
                    {
                        geomStrip5.addTallWall(panelX3, panelZ3, panelW3, dir2, wallTexCoords3, trimStart, trimEnd);
                        geomStrip5.addTallWallTop(panelX3, panelZ3, panelW3, dir2, wallTexCoords2, trimStart, trimEnd);
                        geomStrip6.addShortWall(panelX3, panelZ3, panelW3, dir2, wallTexCoords3, trimStart, trimEnd);
                        geomStrip7.addShortWallTop(panelX3, panelZ3, panelW3, dir2, wallTexCoords2, trimStart, trimEnd);
                        if (!flag12 && !flag10)
                        {
                            int panelX4 = panelX3 - num7 * trimStart;
                            int panelZ4 = panelZ3 - num8 * trimStart;
                            geomStrip5.addTallCap(panelX4, panelZ4, dir2, wallTexCoords2);
                            geomStrip6.addShortCap(panelX4, panelZ4, dir2, wallTexCoords2);
                        }
                        if (!flag8 && !flag7)
                        {
                            int panelX4 = panelX3 + num9 * 2 + -num7 * (panelW3 - trimEnd);
                            int panelZ4 = panelZ3 + num10 * 2 + -num8 * (panelW3 - trimEnd);
                            geomStrip5.addTallCap(panelX4, panelZ4, dir1, wallTexCoords2);
                            geomStrip6.addShortCap(panelX4, panelZ4, dir1, wallTexCoords2);
                        }
                    }
                }
                flag1    = flag9;
                flag2    = flag14;
                flag3    = flag11;
                flag4    = flag10;
                flag5    = flag12;
                tileX   += num7;
                tileZ   += num8;
                panelX2 += num7 * 32;
                panelZ2 += num8 * 32;
            }
        }
        GeomStrip[] subGeomStrips = new GeomStrip[25];
        for (int index = 0; index < 25; ++index)
        {
            subGeomStrips[index] = (GeomStrip)null;
            if (geomStripArray[index].getQuadCount() > 0)
            {
                subGeomStrips[index] = geomStripArray[index];
            }
        }
        this.m_compositeMesh = GeomStrip.createMesh(subGeomStrips);
        this.m_compositeMesh.setAppearance(24, appearance1);
        this.m_group.addChild((Node)this.m_compositeMesh);
        for (int wall = 0; wall < 4; ++wall)
        {
            this.m_wallAlphasF8[wall] = 0;
            this.updateWallAlpha(wall, (int)byte.MaxValue, 0);
        }
    }
Beispiel #6
0
 public void setTintOutside(int tint)
 {
     GeomStrip.setTint(tint, this.m_compositeMesh);
 }
Beispiel #7
0
    public void createGeometry()
    {
        ModelManager instance   = ModelManager.getInstance();
        Appearance   appearance = instance.getAppearance(1);

        this.m_appWallAlpha   = instance.getAppearance(2);
        this.m_appWallReplace = appearance;
        Group group = new Group();

        this.m_group = group;
        SimWorld simWorld = AppEngine.getCanvas().getSimWorld();

        int[] numArray1 = new int[4];
        for (int index = 0; index < 4; ++index)
        {
            int tileX = this.m_posX + Room.ROOM_OFFSETS[index << 1];
            int tileZ = this.m_posZ + Room.ROOM_OFFSETS[(index << 1) + 1];
            numArray1[index] = simWorld.getRoomAt(tileX, tileZ);
        }
        int num1 = -1;

        for (int index1 = 0; index1 < Room.CONFIGURATIONS_COUNT && num1 == -1; ++index1)
        {
            int   num2      = index1 * 13;
            int[] numArray2 = new int[4] {
                -1, -1, -1, -1
            };
            bool flag = true;
            for (int index2 = 0; index2 < 4 && flag; ++index2)
            {
                int num3 = Room.CONFIGURATIONS[num2 + index2];
                int num4 = numArray1[index2];
                if (num3 != 0 || num4 != -1)
                {
                    if (num3 != 0 && num4 != -1)
                    {
                        int index3 = num3 - 1;
                        if (index3 != 9)
                        {
                            int num5 = numArray2[index3];
                            if (num5 == -1)
                            {
                                numArray2[index3] = num4;
                                continue;
                            }
                            if (num4 == num5)
                            {
                                continue;
                            }
                        }
                        else
                        {
                            continue;
                        }
                    }
                    flag = false;
                }
            }
            if (flag)
            {
                num1 = index1;
                break;
            }
        }
        if (num1 == -1)
        {
            return;
        }
        this.m_level       = -1;
        this.m_subDownWall = Room.CONFIGURATIONS[num1 * 13 + 12] == 1;
        int[] numArray3 = new int[Room.CONFIGURATIONS.Length - (num1 * 13 + 8)];
        midp.JSystem.arraycopy((Array)Room.CONFIGURATIONS, num1 * 13 + 8, (Array)numArray3, 0, Room.CONFIGURATIONS.Length - (num1 * 13 + 8));
        int[] numArray4 = new int[Room.CONFIGURATIONS.Length - (num1 * 13 + 4)];
        midp.JSystem.arraycopy((Array)Room.CONFIGURATIONS, num1 * 13 + 4, (Array)numArray4, 0, Room.CONFIGURATIONS.Length - (num1 * 13 + 4));
        int[]       wallTexCoords1 = simWorld.getWallTexCoords(46);
        int[]       wallTexCoords2 = simWorld.getWallTexCoords(46);
        int[]       wallTexCoords3 = simWorld.getWallTexCoords(27);
        GeomStrip[] geomStripArray = new GeomStrip[6];
        for (int index = 0; index < geomStripArray.Length; ++index)
        {
            geomStripArray[index] = new GeomStrip();
        }
        GeomStrip geomStrip1 = geomStripArray[3];
        GeomStrip geomStrip2 = geomStripArray[4];
        GeomStrip geomStrip3 = geomStripArray[5];
        GeomStrip geomStrip4 = geomStripArray[0];
        GeomStrip geomStrip5 = geomStripArray[1];
        GeomStrip geomStrip6 = geomStripArray[2];
        int       panelX1    = this.m_posX * 32;
        int       panelZ1    = this.m_posZ * 32;
        int       panelX2    = panelX1 - 2;
        int       panelZ2    = panelZ1 - 2;
        int       panelX3    = panelX1 + 2;
        int       panelZ3    = panelZ1 + 2;
        int       num6       = 30;

        if (numArray4[0] != 0 || numArray4[3] != 0)
        {
            int trimStart = numArray4[0] != 0 ? 0 : 2;
            int trimEnd   = numArray4[3] != 0 ? 0 : 2;
            geomStrip3.addTallWallTop(panelX2, panelZ2, 4, GeomStrip.Dir.DIR_Z_POS, wallTexCoords1, trimStart, trimEnd);
            geomStrip6.addShortWallTop(panelX2, panelZ2, 4, GeomStrip.Dir.DIR_Z_POS, wallTexCoords1, trimStart, trimEnd);
        }
        if (numArray4[1] != 0 || numArray4[2] != 0)
        {
            int trimStart = numArray4[1] != 0 ? 0 : 2;
            int trimEnd   = numArray4[2] != 0 ? 0 : 2;
            geomStrip3.addTallWallTop(panelX1, panelZ2, 4, GeomStrip.Dir.DIR_Z_POS, wallTexCoords1, trimStart, trimEnd);
            geomStrip6.addShortWallTop(panelX1, panelZ2, 4, GeomStrip.Dir.DIR_Z_POS, wallTexCoords1, trimStart, trimEnd);
        }
        if (numArray3[0] != 2)
        {
            if (numArray3[0] == 1)
            {
                geomStrip1.addTallWall(panelX1 + 32, panelZ2, 32, GeomStrip.Dir.DIR_X_NEG, wallTexCoords2, num6, 0);
                geomStrip4.addShortWall(panelX1 + 32, panelZ2, 32, GeomStrip.Dir.DIR_X_NEG, wallTexCoords2, num6, 0);
                geomStrip1.addTallWall(panelX1, panelZ2, 32, GeomStrip.Dir.DIR_X_NEG, wallTexCoords2, 0, num6);
                geomStrip4.addShortWall(panelX1, panelZ2, 32, GeomStrip.Dir.DIR_X_NEG, wallTexCoords2, 0, num6);
            }
            else
            {
                geomStrip2.addTallWall(panelX1 + 32, panelZ2, 32, GeomStrip.Dir.DIR_X_NEG, wallTexCoords3, num6, 0);
                geomStrip5.addShortWall(panelX1 + 32, panelZ2, 32, GeomStrip.Dir.DIR_X_NEG, wallTexCoords3, num6, 0);
                geomStrip2.addTallWall(panelX1, panelZ2, 32, GeomStrip.Dir.DIR_X_NEG, wallTexCoords3, 0, num6);
                geomStrip5.addShortWall(panelX1, panelZ2, 32, GeomStrip.Dir.DIR_X_NEG, wallTexCoords3, 0, num6);
            }
        }
        if (numArray3[3] != 2)
        {
            if (numArray3[3] == 1)
            {
                geomStrip1.addTallWall(panelX2, panelZ1, 32, GeomStrip.Dir.DIR_Z_POS, wallTexCoords2, 0, num6);
                geomStrip4.addShortWall(panelX2, panelZ1, 32, GeomStrip.Dir.DIR_Z_POS, wallTexCoords2, 0, num6);
                geomStrip1.addTallWall(panelX2, panelZ1 - 32, 32, GeomStrip.Dir.DIR_Z_POS, wallTexCoords2, num6, 0);
                geomStrip4.addShortWall(panelX2, panelZ1 - 32, 32, GeomStrip.Dir.DIR_Z_POS, wallTexCoords2, num6, 0);
            }
            else
            {
                geomStrip2.addTallWall(panelX2, panelZ1, 32, GeomStrip.Dir.DIR_Z_POS, wallTexCoords3, 0, num6);
                geomStrip5.addShortWall(panelX2, panelZ1, 32, GeomStrip.Dir.DIR_Z_POS, wallTexCoords3, 0, num6);
                geomStrip2.addTallWall(panelX2, panelZ1 - 32, 32, GeomStrip.Dir.DIR_Z_POS, wallTexCoords3, num6, 0);
                geomStrip5.addShortWall(panelX2, panelZ1 - 32, 32, GeomStrip.Dir.DIR_Z_POS, wallTexCoords3, num6, 0);
            }
        }
        if (numArray3[1] != 2)
        {
            if (numArray3[1] == 1)
            {
                geomStrip1.addTallWall(panelX3, panelZ1 + 32, 32, GeomStrip.Dir.DIR_Z_NEG, wallTexCoords2, num6, 0);
                geomStrip4.addShortWall(panelX3, panelZ1 + 32, 32, GeomStrip.Dir.DIR_Z_NEG, wallTexCoords2, num6, 0);
                geomStrip1.addTallWall(panelX3, panelZ1, 32, GeomStrip.Dir.DIR_Z_NEG, wallTexCoords2, 0, num6);
                geomStrip4.addShortWall(panelX3, panelZ1, 32, GeomStrip.Dir.DIR_Z_NEG, wallTexCoords2, 0, num6);
            }
            else
            {
                geomStrip2.addTallWall(panelX3, panelZ1 + 32, 32, GeomStrip.Dir.DIR_Z_NEG, wallTexCoords3, num6, 0);
                geomStrip5.addShortWall(panelX3, panelZ1 + 32, 32, GeomStrip.Dir.DIR_Z_NEG, wallTexCoords3, num6, 0);
                geomStrip2.addTallWall(panelX3, panelZ1, 32, GeomStrip.Dir.DIR_Z_NEG, wallTexCoords3, 0, num6);
                geomStrip5.addShortWall(panelX3, panelZ1, 32, GeomStrip.Dir.DIR_Z_NEG, wallTexCoords3, 0, num6);
            }
        }
        if (numArray3[2] != 2)
        {
            if (numArray3[2] == 1)
            {
                geomStrip1.addTallWall(panelX1 - 32, panelZ3, 32, GeomStrip.Dir.DIR_X_POS, wallTexCoords2, num6, 0);
                geomStrip4.addShortWall(panelX1 - 32, panelZ3, 32, GeomStrip.Dir.DIR_X_POS, wallTexCoords2, num6, 0);
                geomStrip1.addTallWall(panelX1, panelZ3, 32, GeomStrip.Dir.DIR_X_POS, wallTexCoords2, 0, num6);
                geomStrip4.addShortWall(panelX1, panelZ3, 32, GeomStrip.Dir.DIR_X_POS, wallTexCoords2, 0, num6);
            }
            else
            {
                geomStrip2.addTallWall(panelX1 - 32, panelZ3, 32, GeomStrip.Dir.DIR_X_POS, wallTexCoords3, num6, 0);
                geomStrip5.addShortWall(panelX1 - 32, panelZ3, 32, GeomStrip.Dir.DIR_X_POS, wallTexCoords3, num6, 0);
                geomStrip2.addTallWall(panelX1, panelZ3, 32, GeomStrip.Dir.DIR_X_POS, wallTexCoords3, 0, num6);
                geomStrip5.addShortWall(panelX1, panelZ3, 32, GeomStrip.Dir.DIR_X_POS, wallTexCoords3, 0, num6);
            }
        }
        GeomStrip[] subGeomStrips = new GeomStrip[6];
        for (int index = 0; index < 6; ++index)
        {
            subGeomStrips[index] = (GeomStrip)null;
            if (geomStripArray[index].getQuadCount() > 0)
            {
                subGeomStrips[index] = geomStripArray[index];
            }
        }
        this.m_compositeMesh = GeomStrip.createMesh(subGeomStrips);
        group.addChild((Node)this.m_compositeMesh);
    }