Layer.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Jypeli.Effects;

using XnaRectangle = Microsoft.Xna.Framework.Rectangle;
using XnaColor = Microsoft.Xna.Framework.Color;

namespace Jypeli
{
    public enum DrawOrder
    {
        Irrelevant,

        FirstToLast,
    }

    
    public class Layer : Updatable
    {
        static readonly Vector[] squareVertices =
        {
            new Vector( -0.5, -0.5 ),
            new Vector( -0.5, 0.5 ),
            new Vector( 0.5, -0.5 ),
            new Vector( 0.5, 0.5 )
        };

        static readonly Int16[] squareIndices =
        {
            0, 1, 2,
            2, 1, 3
        };

        static readonly Vector[] triangleVertices =
        {
            new Vector( 0f, 0.5f ),
            new Vector( 0.5f, -0.5f ),
            new Vector( -0.5f, -0.5f ),
        };

        static readonly Int16[] triangleIndices = { 0, 1, 2 };

        static readonly TextureCoordinates defaultCoords = new TextureCoordinates()
        {
            TopLeft = new Vector2(0.0f, 0.0f),
            TopRight = new Vector2(1.0f, 0.0f),
            BottomLeft = new Vector2(0.0f, 1.0f),
            BottomRight = new Vector2(1.0f, 1.0f),
        };

        internal SynchronousList<IGameObject> Objects = new SynchronousList<IGameObject>();
        private List<ParticleSystem> effects = new List<ParticleSystem>();

        private List<IGameObject> objectsWithImage = new List<IGameObject>();
        private List<IGameObject> objectsWithoutImage = new List<IGameObject>();
        private List<IGameObject> objectsWithDrawMethod = new List<IGameObject>();

        private Vector _relativeTransition = new Vector(1, 1);

        public bool IsUpdated
        {
            get { return true; }
        }

        public DrawOrder DrawOrder { get; set; }

#if DEBUG
        [EditorBrowsable(EditorBrowsableState.Never)]
        internal DoubleMeter ObjectCount = new DoubleMeter(0.0) { MaxValue = 10000 };
#endif

        public Vector RelativeTransition
        {
            get { return _relativeTransition; }
            set { _relativeTransition = value; }
        }

        public bool IgnoresZoom { get; set; }

        public Grid Grid { get; set; }


        public Layer()
        {
            DrawOrder = DrawOrder.Irrelevant;
            Objects.ItemAdded += ObjectAdded;
            Objects.ItemRemoved += ObjectRemoved;
        }

        public static Layer CreateStaticLayer()
        {
            return new Layer() { RelativeTransition = Vector.Zero, IgnoresZoom = true };
        }

        private void ObjectAdded( IGameObject obj )
        {
            if ( obj is ParticleSystem )
                effects.Add( (ParticleSystem)obj );

            if ( obj is CustomDrawable )
            {
                objectsWithDrawMethod.Add( obj );
            }
            else if ( obj.Image != null )
            {
                var hash = obj.Image.GetHashCode();
                var index = objectsWithImage.FindLastIndex( o => o.Image.GetHashCode() == hash );

                if ( index == -1 )
                {
                    objectsWithImage.Add( obj );
                }
                else
                {
                    // Optimize drawing by inserting after the last same image
                    objectsWithImage.Insert( index + 1, obj );
                }
            }
            else
            {
                objectsWithoutImage.Add( obj );
            }

            ( (IGameObjectInternal)obj ).Layer = this;
        }

        private void ObjectRemoved( IGameObject obj )
        {
            if ( obj is ParticleSystem )
                effects.Remove( (ParticleSystem)obj );
            objectsWithDrawMethod.Remove( obj );
            objectsWithImage.Remove( obj );
            objectsWithoutImage.Remove( obj );
            ( (IGameObjectInternal)obj ).Layer = null;
        }

        internal void Add(IGameObject o)
        {
            Objects.Add(o);
        }

        internal void Remove( IGameObject o )
        {
            Objects.Remove( o );
        }

        public void Clear()
        {
            Objects.Clear();
            effects.Clear();
            objectsWithImage.Clear();
            objectsWithoutImage.Clear();
            objectsWithDrawMethod.Clear();
        }

        public void Update( Time time )
        {
#if DEBUG
            ObjectCount.Value = Objects.Count;
#endif
            Objects.Update( time );

            for (int i = 0; i < effects.Count; i++)
            {
                effects[i].Update(time);
            }

        }

        internal void Draw(Camera camera)
        {
            var zoomMatrix = IgnoresZoom ? Matrix.Identity : Matrix.CreateScale( (float)( camera.ZoomFactor ), (float)( camera.ZoomFactor ), 1f );
            var worldMatrix =
                Matrix.CreateTranslation((float)(-camera.Position.X * RelativeTransition.X), (float)(-camera.Position.Y * RelativeTransition.Y), 0)
                * zoomMatrix;

            switch (DrawOrder)
            {
                case DrawOrder.Irrelevant:
                    DrawEfficientlyInNoParticularOrder(ref worldMatrix);
                    break;
                case DrawOrder.FirstToLast:
                    DrawInOrderFromFirstToLast(ref worldMatrix);
                    break;
                default:
                    break;
            }

            for (int i = 0; i < effects.Count; i++)
            {
                effects[i].Draw(worldMatrix);
            }

            if ( Grid != null )
            {
                DrawGrid( ref worldMatrix );
            }
        }

        private void DrawGrid( ref Matrix matrix )
        {
            Graphics.LineBatch.Begin( ref matrix );

            var camera = Game.Instance.Camera;
            var screen = Game.Screen;
            Vector topLeft = camera.ScreenToWorld( new Vector( screen.Left, screen.Top ) );
            Vector topRight = camera.ScreenToWorld( new Vector( screen.Right, screen.Top ) );
            Vector bottomLeft = camera.ScreenToWorld( new Vector( screen.Left, screen.Bottom ) );
            Vector bottomRight = camera.ScreenToWorld( new Vector( screen.Right, screen.Bottom ) );

            int horizontalCount = (int)Math.Ceiling( ( topRight.X - topLeft.X ) / Grid.CellSize.X );
            int leftmostLine = (int)Math.Ceiling( topLeft.X / Grid.CellSize.X );
            double leftmostX = leftmostLine * Grid.CellSize.X;

            for ( int i = 0; i < horizontalCount; i++ )
            {
                double x = leftmostX + i * Grid.CellSize.X;
                Vector startPoint = new Vector( x, topLeft.Y );
                Vector endPoint = new Vector( x, bottomLeft.Y );
                Graphics.LineBatch.Draw( startPoint, endPoint, Grid.Color );
            }

            int verticalCount = (int)Math.Ceiling( ( topRight.Y - bottomRight.Y ) / Grid.CellSize.Y );
            int bottommostLine = (int)Math.Ceiling( bottomRight.Y / Grid.CellSize.Y );
            double bottommostY = bottommostLine * Grid.CellSize.Y;

            for ( int i = 0; i < verticalCount; i++ )
            {
                double y = bottommostY + i * Grid.CellSize.Y;

                // Doesn't draw the line when y is 0! Wonder why...
                if ( y == 0.0 ) y += 0.1;

                Vector startPoint = new Vector( bottomLeft.X, y );
                Vector endPoint = new Vector( bottomRight.X, y );
                Graphics.LineBatch.Draw( startPoint, endPoint, Grid.Color );
            }

            Graphics.LineBatch.End();
        }

        private void DrawInOrderFromFirstToLast(ref Matrix worldMatrix)
        {
            Renderer.LightingEnabled = true;

            for (int i = 0; i < Objects.Count; i++)
            {
                var o = Objects[i];

                if ( o is CustomDrawable )
                {
                    if ( o.IsVisible ) ( (CustomDrawable)o ).Draw( worldMatrix );
                }
                else
                {
                    Renderer.LightingEnabled = !o.IgnoresLighting;
                    Draw( o, ref worldMatrix );
                }
            }

            DrawChildObjects( worldMatrix );

            Renderer.LightingEnabled = false;
        }

        private void DrawEfficientlyInNoParticularOrder(ref Matrix worldMatrix)
        {
            Renderer.LightingEnabled = true;
            DrawObjectsWithoutImages( worldMatrix );
            DrawObjectsWithImages( worldMatrix );
            DrawCustomDrawables( worldMatrix );
            DrawChildObjects( worldMatrix );
            Renderer.LightingEnabled = false;
        }

        private void DrawObjectsWithoutImages( Matrix worldMatrix )
        {
            Graphics.ShapeBatch.Begin( ref worldMatrix );
            for (int i = 0; i < objectsWithoutImage.Count; i++)
            {
                var o = objectsWithoutImage[i];

                if ( !o.IsVisible )
                    continue;

                bool hasChildObjects = o is GameObject && ( (GameObject)o )._childObjects != null;
                bool isSimple = !hasChildObjects && !o.TextureFillsShape;

                Renderer.LightingEnabled = !o.IgnoresLighting;

                if ( isSimple && ( o.Image == null ) && ( o.Shape == Shape.Rectangle || o.Shape == Shape.Triangle ) )
                {
                    DrawShape( o, ref worldMatrix );
                }
                else
                {
                    Draw( o, ref worldMatrix );
                }
            }
            Graphics.ShapeBatch.End();
        }

        private void DrawObjectsWithImages( Matrix worldMatrix )
        {
            // Passing null for image here does not hurt, because the first
            // ReferenceEquals-comparison calls End() without drawing a single
            // image.
            Graphics.ImageBatch.Begin( ref worldMatrix, null );

            Image previousImage = null;

            for (int i = 0; i < objectsWithImage.Count; i++)
            {
                var o = objectsWithImage[i];

                if ( !o.IsVisible )
                    continue;

                bool hasChildObjects = o is GameObject && ( (GameObject)o )._childObjects != null;
                bool isSimple = !hasChildObjects && !o.TextureFillsShape;

                Renderer.LightingEnabled = !o.IgnoresLighting;

                if ( isSimple && ( o.Image != null ) )
                {
                    if ( !Object.ReferenceEquals( o.Image, previousImage ) )
                    {
                        // Object o has different image than the previous one,
                        // so let's start a new batch with the new image. The objects
                        // should be sorted at this point.
                        Graphics.ImageBatch.End();
                        Graphics.ImageBatch.Begin( ref worldMatrix, o.Image.XNATexture );
                        previousImage = o.Image;
                    }
                    DrawTexture( o, ref worldMatrix );
                }
                else
                {
                    Draw( o, ref worldMatrix );
                }
            }

            Graphics.ImageBatch.End();
        }

        private void DrawCustomDrawables( Matrix worldMatrix )
        {
            for (int i = 0; i < objectsWithDrawMethod.Count; i++)
            {
                var o = (CustomDrawable)objectsWithDrawMethod[i];
                if ( o.IsVisible )
                {
                    o.Draw( worldMatrix );
                }
            }
        }

        private void DrawChildObjects( Matrix worldMatrix )
        {
            Vector drawScale = new Vector( 1, 1 );

            for ( int i = 0; i < Objects.Count; i++ )
            {
                var go = Objects[i] as GameObject;
                if ( go == null || go._childObjects == null || go is Jypeli.Widgets.Window )
                    continue;

                if ( go.Shape.IsUnitSize )
                    drawScale = go.Size;

                Vector2 position = new Vector2( (float)go.Position.X, (float)go.Position.Y );
                Vector2 scale = new Vector2( (float)drawScale.X, (float)drawScale.Y );
                float rotation = go.RotateImage ? (float)go.Angle.Radians : 0;

                Matrix childTransformation =
                    Matrix.CreateRotationZ( rotation )
                    * Matrix.CreateTranslation( position.X, position.Y, 0f )
                    * worldMatrix;

                // light positioning for child objects has not been implemented, so
                // let's not use it.
                Renderer.LightingEnabled = false;

                for ( int j = 0; j < go._childObjects.Count; j++ )
                {
                    Draw( go._childObjects[j], ref childTransformation );
                }

                Renderer.LightingEnabled = true;
            }
        }

        private void DrawTexture(IGameObject o, ref Matrix parentTransformation)
        {
            Vector2 position = new Vector2((float)o.Position.X, (float)o.Position.Y);
            Vector2 scale = new Vector2((float)o.Size.X, (float)o.Size.Y);
            float rotation = o.RotateImage ? (float)o.Angle.Radians : 0;

            if (o.IsVisible)
            {
                if ( o.TextureWrapSize == Vector.Diagonal )
                {
                    Graphics.ImageBatch.Draw( defaultCoords, position, scale, rotation );
                }
                else
                {
                    float wx = (float)( Math.Sign( o.TextureWrapSize.X ) );
                    float wy = (float)( Math.Sign( o.TextureWrapSize.Y ) );
                    float left = (float)( -wx / 2 + 0.5 );
                    float right = (float)( wx / 2 + 0.5 );
                    float top = (float)( -wy / 2 + 0.5 );
                    float bottom = (float)( wy / 2 + 0.5 );

                    TextureCoordinates customCoords = new TextureCoordinates()
                    {
                        TopLeft = new Vector2( left, top ),
                        TopRight = new Vector2( right, top ),
                        BottomLeft = new Vector2( left, bottom ),
                        BottomRight = new Vector2( right, bottom ),
                    };

                    if ( o.TextureWrapSize.X == wx && o.TextureWrapSize.Y == wy )
                    {
                        // Draw only once
                        Graphics.ImageBatch.Draw( customCoords, position, scale, rotation );
                        return;
                    }

                    float topLeftX = -(float)( o.TextureWrapSize.X - 1 ) / 2;
                    float topLeftY = -(float)( o.TextureWrapSize.Y - 1 ) / 2;

                    Vector2 newScale = new Vector2(
                        scale.X / ( wx * (float)o.TextureWrapSize.X ),
                        scale.Y / ( wy * (float)o.TextureWrapSize.Y ) );

                    for ( int y = 0; y < o.TextureWrapSize.Y; y++ )
                    {
                        for ( int x = 0; x < o.TextureWrapSize.X; x++ )
                        {
                            Vector2 newPosition = position + new Vector2( ( topLeftX + x ) * newScale.X, ( topLeftY + y ) * newScale.Y );
                            Graphics.ImageBatch.Draw( customCoords, newPosition, newScale, rotation );
                        }
                    }
                }
            }
        }

        private void DrawShape(IGameObject o, ref Matrix parentTransformation)
        {
            Vector2 position = new Vector2((float)o.Position.X, (float)o.Position.Y);
            Vector2 scale = new Vector2((float)o.Size.X, (float)o.Size.Y);
            float rotation = (float)o.Angle.Radians;

            if (o.IsVisible)
            {
                Vector[] vertices;
                Int16[] indices;

                if (o.Shape == Shape.Rectangle)
                {
                    vertices = squareVertices;
                    indices = squareIndices;
                }
                else if (o.Shape == Shape.Triangle)
                {
                    vertices = triangleVertices;
                    indices = triangleIndices;
                }
                else
                {
                    vertices = new Vector[] { };
                    indices = new Int16[] { };
                }

                Graphics.ShapeBatch.Draw(vertices, indices, o.Color, position, scale, rotation);
            }
        }

        private void Draw(IGameObject o, ref Matrix parentTransformation)
        {
            Vector drawScale = new Vector(1, 1);
            if (o.Shape.IsUnitSize)
                drawScale = o.Size;

            Vector2 position = new Vector2((float)o.Position.X, (float)o.Position.Y);
            Vector2 scale = new Vector2((float)drawScale.X, (float)drawScale.Y);
            float rotation = o.RotateImage ? (float)o.Angle.Radians : 0;

            if (o.IsVisible)
            {
                Matrix transformation =
                    Matrix.CreateScale(scale.X, scale.Y, 1f)
                    * Matrix.CreateRotationZ(rotation)
                    * Matrix.CreateTranslation(position.X, position.Y, 0f)
                    * parentTransformation;

                if (o is CustomDrawable)
                {
                    ((CustomDrawable)o).Draw(parentTransformation);
                }
                else if (o.Image != null && (!o.TextureFillsShape))
                {
                    Renderer.DrawImage(o.Image, ref transformation, o.TextureWrapSize);
                }
                else if (o.Image != null)
                {
                    Renderer.DrawShape(o.Shape, ref transformation, ref transformation, o.Image, o.TextureWrapSize, o.Color);
                }
                else
                {
                    Renderer.DrawShape(o.Shape, ref transformation, o.Color);
                }
            }
        }

        internal void GetObjectsAboutToBeAdded( List<IGameObject> result )
        {
            result.AddRange( Objects.GetObjectsAboutToBeAdded() );
        }
    }
}