예제 #1
0
파일: TileView.cs 프로젝트: broem/ClassicUO
        public override bool Draw(SpriteBatch3D spriteBatch, Vector3 position, MouseOverList objectList)
        {
            if (!AllowedToDraw || GameObject.IsDisposed)
            {
                return(false);
            }
            Tile tile = (Tile)GameObject;

            if (Texture == null || Texture.IsDisposed)
            {
                if (tile.IsStretched)
                {
                    Texture = TextmapTextures.GetTextmapTexture(tile.TileData.TexID);
                }
                else
                {
                    Texture = Art.GetLandTexture(GameObject.Graphic);
                    Bounds  = new Rectangle(0, 0, 44, 44);
                }
            }

            if (tile.IsStretched)
            {
                HueVector = GetHueVector(GameObject.Hue, true);

                return(Draw3DStretched(spriteBatch, position, objectList));
            }

            HueVector = GetHueVector(GameObject.Hue, false);

            return(base.Draw(spriteBatch, position, objectList));
        }
예제 #2
0
        public override bool Draw(SpriteBatch3D spriteBatch, Vector3 position, MouseOverList objectList)
        {
            if (!AllowedToDraw || GameObject.IsDisposed)
            {
                return(false);
            }
            Tile tile = (Tile)GameObject;

            if (_needUpdateStrechedTile)
            {
                UpdateStreched(World.Map);
                _needUpdateStrechedTile = false;
            }

            if (Texture == null || Texture.IsDisposed)
            {
                if (tile.IsStretched)
                {
                    Texture = TextmapTextures.GetTextmapTexture(tile.TileData.TexID);
                }
                else
                {
                    Texture = Art.GetLandTexture(GameObject.Graphic);
                    Bounds  = new Rectangle(0, GameObject.Position.Z * 4, 44, 44);
                }
            }



            HueVector = RenderExtentions.GetHueVector(GameObject.Hue);

            return(!tile.IsStretched ? base.Draw(spriteBatch, position, objectList) : Draw3DStretched(spriteBatch, position, objectList));
        }
예제 #3
0
 private void CleaningResources()
 {
     Art.ClearUnusedTextures();
     IO.Resources.Gumps.ClearUnusedTextures();
     TextmapTextures.ClearUnusedTextures();
     Animations.ClearUnusedTextures();
     World.Map?.ClearUnusedBlocks();
 }
예제 #4
0
파일: TileView.cs 프로젝트: broem/ClassicUO
        public void UpdateStreched(Facet map)
        {
            Tile tile = (Tile)GameObject;

            if (tile.IsStretched || TextmapTextures.GetTextmapTexture(tile.TileData.TexID) == null || !TestStretched(tile.Position.X, tile.Position.Y, tile.Position.Z, true))
            {
                tile.IsStretched = false;
                tile.MinZ        = tile.Position.Z;
            }
            else
            {
                tile.IsStretched = true;
                tile.UpdateZ(map.GetTileZ(tile.Position.X, tile.Position.Y + 1), map.GetTileZ(tile.Position.X + 1, tile.Position.Y + 1), map.GetTileZ(tile.Position.X + 1, tile.Position.Y));
                Vector3[,,] vec = new Vector3[3, 3, 4];
                int i;
                int j;

                for (i = -1; i < 2; i++)
                {
                    int curX = GameObject.Position.X + i;
                    int curI = i + 1;

                    for (j = -1; j < 2; j++)
                    {
                        int   curY     = GameObject.Position.Y + j;
                        int   curJ     = j + 1;
                        sbyte currentZ = map.GetTileZ(curX, curY);
                        sbyte leftZ    = map.GetTileZ(curX, curY + 1);
                        sbyte rightZ   = map.GetTileZ(curX + 1, curY);
                        sbyte bottomZ  = map.GetTileZ(curX + 1, curY + 1);

                        if (currentZ == leftZ && currentZ == rightZ && currentZ == bottomZ)
                        {
                            for (int k = 0; k < 4; k++)
                            {
                                vec[curI, curJ, k] = new Vector3(0, 0, 1);
                            }
                        }
                        else
                        {
                            vec[curI, curJ, 0] = new Vector3(-22.0f, 22.0f, (currentZ - rightZ) * 4);
                            Merge(ref vec[curI, curJ, 0], -22.0f, -22.0f, (leftZ - currentZ) * 4);
                            vec[curI, curJ, 0].Normalize();
                            vec[curI, curJ, 1] = new Vector3(22.0f, 22.0f, (rightZ - bottomZ) * 4);
                            Merge(ref vec[curI, curJ, 1], -22.0f, 22.0f, (currentZ - rightZ) * 4);
                            vec[curI, curJ, 1].Normalize();
                            vec[curI, curJ, 2] = new Vector3(22.0f, -22.0f, (bottomZ - leftZ) * 4);
                            Merge(ref vec[curI, curJ, 2], 22.0f, 22.0f, (rightZ - bottomZ) * 4);
                            vec[curI, curJ, 2].Normalize();
                            vec[curI, curJ, 3] = new Vector3(-22.0f, -22.0f, (leftZ - currentZ) * 4);
                            Merge(ref vec[curI, curJ, 3], 22.0f, -22.0f, (bottomZ - leftZ) * 4);
                            vec[curI, curJ, 3].Normalize();
                        }
                    }
                }

                i           = 1;
                j           = 1;
                _normals[0] = vec[i - 1, j - 1, 2] + vec[i - 1, j, 1] + vec[i, j - 1, 3] + vec[i, j, 0];
                _normals[0].Normalize();
                _normals[1] = vec[i, j - 1, 2] + vec[i, j, 1] + vec[i + 1, j - 1, 3] + vec[i + 1, j, 0];
                _normals[1].Normalize();
                _normals[2] = vec[i, j, 2] + vec[i, j + 1, 1] + vec[i + 1, j, 3] + vec[i + 1, j + 1, 0];
                _normals[2].Normalize();
                _normals[3] = vec[i - 1, j, 2] + vec[i - 1, j + 1, 1] + vec[i, j, 3] + vec[i, j + 1, 0];
                _normals[3].Normalize();
                _vertex[0].Normal = _normals[0];
                _vertex[1].Normal = _normals[1];
                _vertex[3].Normal = _normals[2];
                _vertex[2].Normal = _normals[3];
                _vertex0_yOffset  = new Vector3(22, -tile.Rectangle.Left, 0);
                _vertex1_yOffset  = new Vector3(44, 22 - tile.Rectangle.Bottom, 0);
                _vertex2_yOffset  = new Vector3(0, 22 - tile.Rectangle.Top, 0);
                _vertex3_yOffset  = new Vector3(22, 44 - tile.Rectangle.Right, 0);
            }

            Vector3 hue = RenderExtentions.GetHueVector(GameObject.Hue);

            if (_vertex[0].Hue != hue)
            {
                _vertex[0].Hue = _vertex[1].Hue = _vertex[2].Hue = _vertex[3].Hue = hue;
            }
        }
예제 #5
0
        public void UpdateStreched(int x, int y, sbyte z)
        {
            Land tile = (Land)GameObject;

            Map.Map map = World.Map;

            if (tile.IsStretched || TextmapTextures.GetTextmapTexture(tile.TileData.TexID) == null || !TestStretched(x, y, z, true))
            {
                tile.IsStretched = false;
                tile.MinZ        = z;
            }
            else
            {
                tile.IsStretched = true;
                tile.UpdateZ(map.GetTileZ(x, y + 1), map.GetTileZ(x + 1, y + 1), map.GetTileZ(x + 1, y), z);

                Vector3[,,] vec = new Vector3[3, 3, 4];
                int i;
                int j;

                for (i = -1; i < 2; i++)
                {
                    int curX = x + i;
                    int curI = i + 1;

                    for (j = -1; j < 2; j++)
                    {
                        int   curY     = y + j;
                        int   curJ     = j + 1;
                        sbyte currentZ = map.GetTileZ(curX, curY);
                        sbyte leftZ    = map.GetTileZ(curX, curY + 1);
                        sbyte rightZ   = map.GetTileZ(curX + 1, curY);
                        sbyte bottomZ  = map.GetTileZ(curX + 1, curY + 1);

                        if (currentZ == leftZ && currentZ == rightZ && currentZ == bottomZ)
                        {
                            for (int k = 0; k < 4; k++)
                            {
                                vec[curI, curJ, k] = new Vector3(0, 0, 1);
                            }
                        }
                        else
                        {
                            vec[curI, curJ, 0] = new Vector3(-22.0f, 22.0f, (currentZ - rightZ) * 4);
                            Merge(ref vec[curI, curJ, 0], -22.0f, -22.0f, (leftZ - currentZ) * 4);
                            vec[curI, curJ, 0].Normalize();
                            vec[curI, curJ, 1] = new Vector3(22.0f, 22.0f, (rightZ - bottomZ) * 4);
                            Merge(ref vec[curI, curJ, 1], -22.0f, 22.0f, (currentZ - rightZ) * 4);
                            vec[curI, curJ, 1].Normalize();
                            vec[curI, curJ, 2] = new Vector3(22.0f, -22.0f, (bottomZ - leftZ) * 4);
                            Merge(ref vec[curI, curJ, 2], 22.0f, 22.0f, (rightZ - bottomZ) * 4);
                            vec[curI, curJ, 2].Normalize();
                            vec[curI, curJ, 3] = new Vector3(-22.0f, -22.0f, (leftZ - currentZ) * 4);
                            Merge(ref vec[curI, curJ, 3], 22.0f, -22.0f, (bottomZ - leftZ) * 4);
                            vec[curI, curJ, 3].Normalize();
                        }
                    }
                }

                i           = 1;
                j           = 1;
                _normals[0] = vec[i - 1, j - 1, 2] + vec[i - 1, j, 1] + vec[i, j - 1, 3] + vec[i, j, 0];
                _normals[0].Normalize();
                _normals[1] = vec[i, j - 1, 2] + vec[i, j, 1] + vec[i + 1, j - 1, 3] + vec[i + 1, j, 0];
                _normals[1].Normalize();
                _normals[2] = vec[i, j, 2] + vec[i, j + 1, 1] + vec[i + 1, j, 3] + vec[i + 1, j + 1, 0];
                _normals[2].Normalize();
                _normals[3] = vec[i - 1, j, 2] + vec[i - 1, j + 1, 1] + vec[i, j, 3] + vec[i, j + 1, 0];
                _normals[3].Normalize();
                _vertex[0].Normal = _normals[0];
                _vertex[1].Normal = _normals[1];
                _vertex[3].Normal = _normals[2];
                _vertex[2].Normal = _normals[3];
                _vertex0_yOffset  = new Vector3(22, -tile.Rectangle.Left, 0);
                _vertex1_yOffset  = new Vector3(44, 22 - tile.Rectangle.Bottom, 0);
                _vertex2_yOffset  = new Vector3(0, 22 - tile.Rectangle.Top, 0);
                _vertex3_yOffset  = new Vector3(22, 44 - tile.Rectangle.Right, 0);
            }

            Vector3 hue = ShaderHuesTraslator.GetHueVector(GameObject.Hue);

            if (_vertex[0].Hue != hue)
            {
                _vertex[0].Hue = _vertex[1].Hue = _vertex[2].Hue = _vertex[3].Hue = hue;
            }
        }