예제 #1
0
        public             Vector2[] getMeshUvs(Vector2[] uvs)
        {
            TexturePos tilePos = this.texturePos;
            float      x       = TexturePos.ATLAS_TILE_SIZE * tilePos.x;
            float      y       = TexturePos.ATLAS_TILE_SIZE * tilePos.y;

            uvs[0] = new Vector2(x, y) + (this.uv0 * TexturePos.PIXEL_SIZE);
            uvs[1] = new Vector2(x, y + TexturePos.PIXEL_SIZE) + (this.uv1 * TexturePos.PIXEL_SIZE);
            uvs[2] = new Vector2(x + TexturePos.PIXEL_SIZE, y + TexturePos.PIXEL_SIZE) + (this.uv2 * TexturePos.PIXEL_SIZE);
            uvs[3] = new Vector2(x + TexturePos.PIXEL_SIZE, y) + (this.uv3 * TexturePos.PIXEL_SIZE);
            if (tilePos.rotation != 0)
            {
                UvHelper.rotateUVs(uvs, tilePos.rotation);
            }
            if (tilePos.mirrorFlags != 0)
            {
                if ((tilePos.mirrorFlags & 1) == 1)
                {
                    UvHelper.mirrorUvsX(uvs);
                }
                if ((tilePos.mirrorFlags >> 1) == 1)
                {
                    UvHelper.mirrorUvsY(uvs);
                }
            }
            return(uvs);
        }
예제 #2
0
        public Vector2[] generateUVsFromTP(TexturePos tilePos)
        {
            float x = TexturePos.ATLAS_TILE_SIZE * tilePos.x;
            float y = TexturePos.ATLAS_TILE_SIZE * tilePos.y;

            this.allocatedUvArray[0] = new Vector2(x, y);
            this.allocatedUvArray[1] = new Vector2(x, y + TexturePos.ATLAS_TILE_SIZE);
            this.allocatedUvArray[2] = new Vector2(x + TexturePos.ATLAS_TILE_SIZE, y + TexturePos.ATLAS_TILE_SIZE);
            this.allocatedUvArray[3] = new Vector2(x + TexturePos.ATLAS_TILE_SIZE, y);
            if (tilePos.rotation != 0)
            {
                UvHelper.rotateUVs(this.allocatedUvArray, tilePos.rotation);
            }
            return(this.allocatedUvArray);
        }
예제 #3
0
        public Mesh renderItem3d(Item item, int meta)
        {
            MeshBuilder meshBuilder = RenderManager.getMeshBuilder();

            meshBuilder.setMaxLight();
            TexturePos textPos       = item.getItemTexturePos(meta);
            float      halfPixelSize = 0.015625f;

            // Add the front and back.
            float zOffset = halfPixelSize;

            meshBuilder.addQuad(
                new Vector3(0.5f, -0.5f, zOffset),  // Bottom right
                new Vector3(0.5f, 0.5f, zOffset),   // Top right
                new Vector3(-0.5f, 0.5f, zOffset),  // Top left
                new Vector3(-0.5f, -0.5f, zOffset), // Bottom left
                UvHelper.mirrorUvsX(this.getUvs(textPos)),
                0);
            meshBuilder.addQuad(
                new Vector3(-0.5f, -0.5f, -zOffset),
                new Vector3(-0.5f, 0.5f, -zOffset),
                new Vector3(0.5f, 0.5f, -zOffset),
                new Vector3(0.5f, -0.5f, -zOffset),
                this.getUvs(textPos),
                0);

            // Add the side pixels
            int       pixelStartX = textPos.x * 32;
            int       pixelStartY = textPos.y * 32;
            Texture2D atlas       = References.list.textureAtlas;

            Vector2[] pixelUvs = new Vector2[4];
            float     pixelOrginX, pixelOrginY;

            for (int x = 1; x < 32; x++)
            {
                for (int y = 1; y < 32; y++)
                {
                    if (!(atlas.GetPixel(pixelStartX + x, pixelStartY + y).a == 0))  // Solid pixel.
                    {
                        pixelOrginX = (x - 15) * (halfPixelSize * 2) - halfPixelSize;
                        pixelOrginY = (y - 15) * (halfPixelSize * 2) - halfPixelSize;

                        // Right/+X
                        if (this.func(atlas, pixelStartX + x, pixelStartY + y, 1, 0, ref pixelUvs))
                        {
                            meshBuilder.addQuad(
                                new Vector3(pixelOrginX + halfPixelSize, pixelOrginY - halfPixelSize, 0 - halfPixelSize),
                                new Vector3(pixelOrginX + halfPixelSize, pixelOrginY + halfPixelSize, 0 - halfPixelSize),
                                new Vector3(pixelOrginX + halfPixelSize, pixelOrginY + halfPixelSize, 0 + halfPixelSize),
                                new Vector3(pixelOrginX + halfPixelSize, pixelOrginY - halfPixelSize, 0 + halfPixelSize),
                                pixelUvs,
                                0);
                        }
                        // Left/-X
                        if (this.func(atlas, pixelStartX + x, pixelStartY + y, -1, 0, ref pixelUvs))
                        {
                            meshBuilder.addQuad(
                                new Vector3(pixelOrginX - halfPixelSize, pixelOrginY - halfPixelSize, 0 + halfPixelSize),
                                new Vector3(pixelOrginX - halfPixelSize, pixelOrginY + halfPixelSize, 0 + halfPixelSize),
                                new Vector3(pixelOrginX - halfPixelSize, pixelOrginY + halfPixelSize, 0 - halfPixelSize),
                                new Vector3(pixelOrginX - halfPixelSize, pixelOrginY - halfPixelSize, 0 - halfPixelSize),
                                pixelUvs,
                                0);
                        }
                        // Up/+Y
                        if (this.func(atlas, pixelStartX + x, pixelStartY + y, 0, 1, ref pixelUvs))
                        {
                            meshBuilder.addQuad(
                                new Vector3(pixelOrginX - halfPixelSize, pixelOrginY + halfPixelSize, 0 - halfPixelSize),
                                new Vector3(pixelOrginX - halfPixelSize, pixelOrginY + halfPixelSize, 0 + halfPixelSize),
                                new Vector3(pixelOrginX + halfPixelSize, pixelOrginY + halfPixelSize, 0 + halfPixelSize),
                                new Vector3(pixelOrginX + halfPixelSize, pixelOrginY + halfPixelSize, 0 - halfPixelSize),
                                pixelUvs,
                                0);
                        }
                        // Down/-Y
                        if (this.func(atlas, pixelStartX + x, pixelStartY + y, 0, -1, ref pixelUvs))
                        {
                            meshBuilder.addQuad(
                                new Vector3(pixelOrginX - halfPixelSize, pixelOrginY - halfPixelSize, 0 + halfPixelSize),
                                new Vector3(pixelOrginX - halfPixelSize, pixelOrginY - halfPixelSize, 0 - halfPixelSize),
                                new Vector3(pixelOrginX + halfPixelSize, pixelOrginY - halfPixelSize, 0 - halfPixelSize),
                                new Vector3(pixelOrginX + halfPixelSize, pixelOrginY - halfPixelSize, 0 + halfPixelSize),
                                pixelUvs,
                                0);
                        }
                    }
                }
            }

            return(meshBuilder.getGraphicMesh());
        }