Exemple #1
0
        private bool Draw3DStretched(SpriteBatch3D spriteBatch, Vector3 drawPosition, MouseOverList mouseOverList, Map map)
        {
            // this is an isometric stretched tile and needs a specialized draw routine.
            m_vertexBufferAlternate[0].Position = drawPosition + m_vertex0_yOffset;
            m_vertexBufferAlternate[1].Position = drawPosition + m_vertex1_yOffset;
            m_vertexBufferAlternate[2].Position = drawPosition + m_vertex2_yOffset;
            m_vertexBufferAlternate[3].Position = drawPosition + m_vertex3_yOffset;

            if (!spriteBatch.DrawSprite(DrawTexture, m_vertexBufferAlternate, s_Technique))
            {
                return(false);
            }

            if ((mouseOverList.PickType & PickType) == PickType)
            {
                if (mouseOverList.IsMouseInObjectIsometric(m_vertexBufferAlternate))
                {
                    MouseOverItem item = new MouseOverItem(DrawTexture, m_vertexBufferAlternate[0].Position, Entity);
                    item.Vertices = new Vector3[4] {
                        m_vertexBufferAlternate[0].Position, m_vertexBufferAlternate[1].Position, m_vertexBufferAlternate[2].Position, m_vertexBufferAlternate[3].Position
                    };
                    mouseOverList.Add2DItem(item);
                }
            }

            return(true);
        }
Exemple #2
0
        private unsafe bool Draw3DStretched(SpriteBatch3D spriteBatch, Vector3 position, MouseOverList objectList)
        {
            Texture.Ticks = CoreGame.Ticks;

            fixed(SpriteVertex *ptr = _vertex)
            {
                ptr[0].Position = position + _vertex0_yOffset;
                ptr[1].Position = position + _vertex1_yOffset;
                ptr[2].Position = position + _vertex2_yOffset;
                ptr[3].Position = position + _vertex3_yOffset;
            }

            int z = GameObject.Position.Z * 4;

            for (int i = 0; i < 4; i++)
            {
                _vertex[i].Position.Y += z;
            }

            if (IsSelected)
            {
                if (_storedHue == Vector3.Zero)
                {
                    _storedHue = HueVector;
                }
                HueVector = ShaderHuesTraslator.SelectedHue;
            }
            else if (_storedHue != Vector3.Zero)
            {
                HueVector  = _storedHue;
                _storedHue = Vector3.Zero;
            }

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

            if (!spriteBatch.DrawSprite(Texture, _vertex))
            {
                return(false);
            }

            if (objectList.IsMouseInObjectIsometric(_vertex))
            {
                objectList.Add(GameObject, _vertex[0].Position);
            }

            return(true);
        }
Exemple #3
0
 bool Draw3DStretched(SpriteBatch3D spriteBatch, Vector3 drawPosition, MouseOverList mouseOver, Map map)
 {
     // this is an isometric stretched tile and needs a specialized draw routine.
     m_vertexBufferAlternate[0].Position = drawPosition + m_vertex0_yOffset;
     m_vertexBufferAlternate[1].Position = drawPosition + m_vertex1_yOffset;
     m_vertexBufferAlternate[2].Position = drawPosition + m_vertex2_yOffset;
     m_vertexBufferAlternate[3].Position = drawPosition + m_vertex3_yOffset;
     if (!spriteBatch.DrawSprite(DrawTexture, m_vertexBufferAlternate, Technique))
     {
         return(false);
     }
     if ((mouseOver.PickType & PickType) == PickType)
     {
         if (mouseOver.IsMouseInObjectIsometric(m_vertexBufferAlternate))
         {
             mouseOver.AddItem(Entity, m_vertexBufferAlternate[0].Position);
         }
     }
     return(true);
 }
Exemple #4
0
        private bool Draw3DStretched(SpriteBatch3D spriteBatch, Vector3 position, MouseOverList objectList)
        {
            Texture.Ticks       = CoreGame.Ticks;
            _vertex[0].Position = position + _vertex0_yOffset;
            _vertex[1].Position = position + _vertex1_yOffset;
            _vertex[2].Position = position + _vertex2_yOffset;
            _vertex[3].Position = position + _vertex3_yOffset;

            if (IsSelected)
            {
                if (_storedHue == Vector3.Zero)
                {
                    _storedHue = HueVector;
                }
                HueVector = RenderExtentions.SelectedHue;
            }
            else if (_storedHue != Vector3.Zero)
            {
                HueVector  = _storedHue;
                _storedHue = Vector3.Zero;
            }

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

            if (!spriteBatch.DrawSprite(Texture, _vertex, Techniques.Hued))
            {
                return(false);
            }

            if (objectList.IsMouseInObjectIsometric(_vertex))
            {
                objectList.Add(GameObject, _vertex[0].Position);
            }

            return(true);
        }
Exemple #5
0
        public virtual unsafe bool Draw(SpriteBatch3D spriteBatch, Vector3 position, MouseOverList list)
        {
            if (Texture == null || Texture.IsDisposed || !AllowedToDraw || GameObject.IsDisposed)
            {
                return(false);
            }
            Texture.Ticks = CoreGame.Ticks;
            SpriteVertex[] vertex;

            if (Rotation != 0.0f)
            {
                float   w      = Bounds.Width / 2f;
                float   h      = Bounds.Height / 2f;
                Vector3 center = position - new Vector3(Bounds.X - 44 + w, Bounds.Y + h, 0);
                float   sinx   = (float)Math.Sin(Rotation) * w;
                float   cosx   = (float)Math.Cos(Rotation) * w;
                float   siny   = (float)Math.Sin(Rotation) * h;
                float   cosy   = (float)Math.Cos(Rotation) * h;
                vertex = SpriteVertex.PolyBufferFlipped;

                fixed(SpriteVertex *ptr = vertex)
                {
                    ptr[0].Position    = center;
                    ptr[0].Position.X += cosx - -siny;
                    ptr[0].Position.Y -= sinx + -cosy;
                    ptr[1].Position    = center;
                    ptr[1].Position.X += cosx - siny;
                    ptr[1].Position.Y += -sinx + -cosy;
                    ptr[2].Position    = center;
                    ptr[2].Position.X += -cosx - -siny;
                    ptr[2].Position.Y += sinx + cosy;
                    ptr[3].Position    = center;
                    ptr[3].Position.X += -cosx - siny;
                    ptr[3].Position.Y += sinx + -cosy;
                }
            }
            else if (IsFlipped)
            {
                vertex = SpriteVertex.PolyBufferFlipped;

                fixed(SpriteVertex *ptr = vertex)
                {
                    ptr[0].Position            = position;
                    ptr[0].Position.X         += Bounds.X + 44f;
                    ptr[0].Position.Y         -= Bounds.Y;
                    ptr[0].TextureCoordinate.Y = 0;
                    ptr[1].Position            = vertex[0].Position;
                    ptr[1].Position.Y         += Bounds.Height;
                    ptr[2].Position            = vertex[0].Position;
                    ptr[2].Position.X         -= Bounds.Width;
                    ptr[2].TextureCoordinate.Y = 0;
                    ptr[3].Position            = vertex[1].Position;
                    ptr[3].Position.X         -= Bounds.Width;
                }
            }
            else
            {
                vertex = SpriteVertex.PolyBuffer;

                fixed(SpriteVertex *ptr = vertex)
                {
                    ptr[0].Position            = position;
                    ptr[0].Position.X         -= Bounds.X;
                    ptr[0].Position.Y         -= Bounds.Y;
                    ptr[0].TextureCoordinate.Y = 0;
                    ptr[1].Position            = vertex[0].Position;
                    ptr[1].Position.X         += Bounds.Width;
                    ptr[1].TextureCoordinate.Y = 0;
                    ptr[2].Position            = vertex[0].Position;
                    ptr[2].Position.Y         += Bounds.Height;
                    ptr[3].Position            = vertex[1].Position;
                    ptr[3].Position.Y         += Bounds.Height;
                }
            }

            if (IsSelected)
            {
                if (_storedHue == Vector3.Zero)
                {
                    _storedHue = HueVector;
                }
                HueVector = ShaderHuesTraslator.SelectedHue;
            }
            else if (_storedHue != Vector3.Zero)
            {
                HueVector  = _storedHue;
                _storedHue = Vector3.Zero;
            }

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

            //if (HasShadow)
            //{
            //    SpriteVertex[] vertexS = new SpriteVertex[4]
            //    {
            //        vertex[0],
            //        vertex[1],
            //        vertex[2],
            //        vertex[3]
            //    };

            //    spriteBatch.DrawShadow(Texture, vertexS, new Vector2(position.X + 22, position.Y + GameObject.Offset.Y - GameObject.Offset.Z + 22), IsFlipped, ShadowZDepth);
            //}

            if (!spriteBatch.DrawSprite(Texture, vertex))
            {
                return(false);
            }
            MousePick(list, vertex);

            return(true);
        }
        public virtual bool Draw(SpriteBatch3D spriteBatch, Vector3 drawPosition, MouseOverList mouseOver, Map map, bool roofHideFlag)
        {
            VertexPositionNormalTextureHue[] vertexBuffer;
            if (Rotation != 0)
            {
                float   w      = DrawArea.Width / 2f;
                float   h      = DrawArea.Height / 2f;
                Vector3 center = drawPosition - new Vector3(DrawArea.X - IsometricRenderer.TILE_SIZE_INTEGER + w, DrawArea.Y + h, 0);
                float   sinx   = (float)Math.Sin(Rotation) * w;
                float   cosx   = (float)Math.Cos(Rotation) * w;
                float   siny   = -(float)Math.Sin(Rotation) * h;
                float   cosy   = -(float)Math.Cos(Rotation) * h;
                // 2   0
                // |\  |
                // |  \|
                // 3   1
                vertexBuffer                = VertexPositionNormalTextureHue.PolyBufferFlipped;
                vertexBuffer[0].Position    = center;
                vertexBuffer[0].Position.X += cosx - -siny;
                vertexBuffer[0].Position.Y -= sinx + -cosy;
                vertexBuffer[1].Position    = center;
                vertexBuffer[1].Position.X += cosx - siny;
                vertexBuffer[1].Position.Y += -sinx + -cosy;
                vertexBuffer[2].Position    = center;
                vertexBuffer[2].Position.X += -cosx - -siny;
                vertexBuffer[2].Position.Y += sinx + cosy;
                vertexBuffer[3].Position    = center;
                vertexBuffer[3].Position.X += -cosx - siny;
                vertexBuffer[3].Position.Y += sinx + -cosy;
            }
            else if (DrawFlip)
            {
                // 2   0
                // |\  |
                // |  \|
                // 3   1
                vertexBuffer                        = VertexPositionNormalTextureHue.PolyBufferFlipped;
                vertexBuffer[0].Position            = drawPosition;
                vertexBuffer[0].Position.X         += DrawArea.X + IsometricRenderer.TILE_SIZE_FLOAT;
                vertexBuffer[0].Position.Y         -= DrawArea.Y;
                vertexBuffer[0].TextureCoordinate.Y = 0;
                vertexBuffer[1].Position            = vertexBuffer[0].Position;
                vertexBuffer[1].Position.Y         += DrawArea.Height;
                vertexBuffer[2].Position            = vertexBuffer[0].Position;
                vertexBuffer[2].Position.X         -= DrawArea.Width;
                vertexBuffer[2].TextureCoordinate.Y = 0;
                vertexBuffer[3].Position            = vertexBuffer[1].Position;
                vertexBuffer[3].Position.X         -= DrawArea.Width;

                /*if (m_YClipLine != 0)
                 * {
                 *  if (m_YClipLine > vertexBuffer[3].Position.Y)
                 *      return false;
                 *  else if (m_YClipLine > vertexBuffer[0].Position.Y)
                 *  {
                 *      float uvStart = (m_YClipLine - vertexBuffer[0].Position.Y) / DrawTexture.Height;
                 *      vertexBuffer[0].Position.Y = vertexBuffer[2].Position.Y = m_YClipLine;
                 *      vertexBuffer[0].TextureCoordinate.Y = vertexBuffer[2].TextureCoordinate.Y = uvStart;
                 *  }
                 * }*/
            }
            else
            {
                // 0---1
                //    /
                //  /
                // 2---3
                vertexBuffer                        = VertexPositionNormalTextureHue.PolyBuffer;
                vertexBuffer[0].Position            = drawPosition;
                vertexBuffer[0].Position.X         -= DrawArea.X;
                vertexBuffer[0].Position.Y         -= DrawArea.Y;
                vertexBuffer[0].TextureCoordinate.Y = 0;
                vertexBuffer[1].Position            = vertexBuffer[0].Position;
                vertexBuffer[1].Position.X         += DrawArea.Width;
                vertexBuffer[1].TextureCoordinate.Y = 0;
                vertexBuffer[2].Position            = vertexBuffer[0].Position;
                vertexBuffer[2].Position.Y         += DrawArea.Height;
                vertexBuffer[3].Position            = vertexBuffer[1].Position;
                vertexBuffer[3].Position.Y         += DrawArea.Height;

                /*if (m_YClipLine != 0)
                 * {
                 *  if (m_YClipLine >= vertexBuffer[3].Position.Y)
                 *      return false;
                 *  else if (m_YClipLine > vertexBuffer[0].Position.Y)
                 *  {
                 *      float uvStart = (m_YClipLine - vertexBuffer[0].Position.Y) / DrawTexture.Height;
                 *      vertexBuffer[0].Position.Y = vertexBuffer[1].Position.Y = m_YClipLine;
                 *      vertexBuffer[0].TextureCoordinate.Y = vertexBuffer[1].TextureCoordinate.Y = uvStart;
                 *  }
                 * }*/
            }
            if (vertexBuffer[0].Hue != HueVector)
            {
                vertexBuffer[0].Hue = vertexBuffer[1].Hue = vertexBuffer[2].Hue = vertexBuffer[3].Hue = HueVector;
            }
            if (!spriteBatch.DrawSprite(DrawTexture, vertexBuffer, Technique))
            {
                // the vertex buffer was not on screen, return false (did not draw)
                return(false);
            }
            Pick(mouseOver, vertexBuffer);
            if (IsShadowCastingView)
            {
                spriteBatch.DrawShadow(DrawTexture, vertexBuffer, new Vector2(
                                           drawPosition.X + IsometricRenderer.TILE_SIZE_FLOAT_HALF,
                                           drawPosition.Y + (Entity.Position.Offset.X + Entity.Position.Offset.Y) * IsometricRenderer.TILE_SIZE_FLOAT_HALF - ((Entity.Position.Z_offset + Entity.Z) * 4) + IsometricRenderer.TILE_SIZE_FLOAT_HALF),
                                       DrawFlip, DrawShadowZDepth);
            }
            return(true);
        }
Exemple #7
0
        public virtual bool Draw(SpriteBatch3D spriteBatch, Vector3 position, MouseOverList list)
        {
            if (Texture == null || Texture.IsDisposed || !AllowedToDraw || GameObject.IsDisposed)
            {
                return(false);
            }
            Texture.Ticks = CoreGame.Ticks;
            SpriteVertex[] vertex;

            if (Rotation != 0)
            {
                float   w      = Bounds.Width / 2f;
                float   h      = Bounds.Height / 2f;
                Vector3 center = position - new Vector3(Bounds.X - 44 + w, Bounds.Y + h, 0);
                float   sinx   = (float)Math.Sin(Rotation) * w;
                float   cosx   = (float)Math.Cos(Rotation) * w;
                float   siny   = (float)Math.Sin(Rotation) * h;
                float   cosy   = (float)Math.Cos(Rotation) * h;
                vertex                = SpriteVertex.PolyBufferFlipped;
                vertex[0].Position    = center;
                vertex[0].Position.X += cosx - -siny;
                vertex[0].Position.Y -= sinx + -cosy;
                vertex[1].Position    = center;
                vertex[1].Position.X += cosx - siny;
                vertex[1].Position.Y += -sinx + -cosy;
                vertex[2].Position    = center;
                vertex[2].Position.X += -cosx - -siny;
                vertex[2].Position.Y += sinx + cosy;
                vertex[3].Position    = center;
                vertex[3].Position.X += -cosx - siny;
                vertex[3].Position.Y += sinx + -cosy;
            }
            else if (IsFlipped)
            {
                vertex                        = SpriteVertex.PolyBufferFlipped;
                vertex[0].Position            = position;
                vertex[0].Position.X         += Bounds.X + 44f;
                vertex[0].Position.Y         -= Bounds.Y;
                vertex[0].TextureCoordinate.Y = 0;
                vertex[1].Position            = vertex[0].Position;
                vertex[1].Position.Y         += Bounds.Height;
                vertex[2].Position            = vertex[0].Position;
                vertex[2].Position.X         -= Bounds.Width;
                vertex[2].TextureCoordinate.Y = 0;
                vertex[3].Position            = vertex[1].Position;
                vertex[3].Position.X         -= Bounds.Width;
            }
            else
            {
                vertex                        = SpriteVertex.PolyBuffer;
                vertex[0].Position            = position;
                vertex[0].Position.X         -= Bounds.X;
                vertex[0].Position.Y         -= Bounds.Y;
                vertex[0].TextureCoordinate.Y = 0;
                vertex[1].Position            = vertex[0].Position;
                vertex[1].Position.X         += Bounds.Width;
                vertex[1].TextureCoordinate.Y = 0;
                vertex[2].Position            = vertex[0].Position;
                vertex[2].Position.Y         += Bounds.Height;
                vertex[3].Position            = vertex[1].Position;
                vertex[3].Position.Y         += Bounds.Height;
            }

            if (IsSelected)
            {
                if (_storedHue == Vector3.Zero)
                {
                    _storedHue = HueVector;
                }
                HueVector = RenderExtentions.SelectedHue;
            }
            else if (_storedHue != Vector3.Zero)
            {
                HueVector  = _storedHue;
                _storedHue = Vector3.Zero;
            }

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

            if (HasShadow)
            {
                SpriteVertex[] vertexS = new SpriteVertex[4]
                {
                    vertex[0],
                    vertex[1],
                    vertex[2],
                    vertex[3]
                };

                spriteBatch.DrawShadow(Texture, vertexS, new Vector2(position.X + 22f, position.Y + GameObject.Offset.Y - (GameObject.Offset.Z / 4 + GameObject.Position.Z) * 4 + 22f), IsFlipped, ShadowZDepth);
            }

            if (!spriteBatch.DrawSprite(Texture, vertex))
            {
                return(false);
            }
            MousePick(list, vertex);


            return(true);
        }