Background.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009-2011 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion

/*
 * Authors: Tomi Karppinen, Tero Jäntti
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework;
using Jypeli;

namespace Jypeli.Widgets
{
    public class Background : Widget
    {
        private const int MAX_TEXTURE_RESOLUTION = 2048;

        public override Animation Animation
        {
            get { return base.Animation; }
            set
            {
                base.Animation = value;
                if ( value != null )
                    Size = new Vector( value.Width, value.Height );
            }
        }
        
        public bool MovesWithCamera { get; set; }

        public double Scale { get; set; }

        public void FitToLevel()
        {
            Level level = Game.Instance.Level;
            Size = new Vector( level.Width, level.Height );
            TextureWrapSize = Vector.Diagonal;
        }

        public void TileToLevel()
        {
            Level level = Game.Instance.Level;
            Size = level.Size;
            TextureWrapSize = new Vector( level.Width / Image.Width, level.Height / Image.Height );
        }

        public void ScaleToLevel()
        {
            Level level = Game.Instance.Level;
            Size *= Math.Min( level.Width / this.Width, level.Height / this.Height );
            TextureWrapSize = Vector.Diagonal;
        }

        public void ScaleToLevelFull()
        {
            Level level = Game.Instance.Level;
            Size *= Math.Max( level.Width / this.Width, level.Height / this.Height );
            TextureWrapSize = Vector.Diagonal;
        }

        public void ScaleToLevelByWidth()
        {
            Level level = Game.Instance.Level;
            Size *= level.Width / this.Width;
            TextureWrapSize = Vector.Diagonal;
        }

        public void ScaleToLevelByHeight()
        {
            Level level = Game.Instance.Level;
            Size *= level.Height / this.Height;
            TextureWrapSize = Vector.Diagonal;
        }
        
        public Background( double width, double height )
            : base( width, height )
        {
            this.Color = Color.LightBlue;
            this.Size = new Vector( width, height );
            this.Scale = 1.0f;
            this.MovesWithCamera = true;
        }
        
        public Background( Vector size )
            : this( size.X, size.Y )
        {
        }
        
        public Image CreateStars( int amount )
        {
            int imageWidth = (int)Game.Screen.Width;
            int imageHeight = (int)Game.Screen.Height;

            Image image = Image.CreateStarSky( imageWidth, imageHeight, amount );

            Image = image;
            MovesWithCamera = false;

            return image;
        }

        public Image CreateStars()
        {
            int textureWidth = (int)Game.Screen.Width;
            int textureHeight = (int)Game.Screen.Height;
            int amount = ( textureWidth * textureHeight ) / 1000;

            Image image = this.CreateStars( amount );

            Image = image;
            MovesWithCamera = false;

            return image;
        }

        public Image CreateGradient( Color lowerColor, Color upperColor )
        {
            int textureWidth = (int)Game.Screen.Width;
            int textureHeight = (int)Game.Screen.Height;

#if WINDOWS
            // DirectX9 ei tue tekstuureita, joiden koko on suurempi kuin 2048 pikseliä
            // Ja koska DX9 ei tue niitä, niin myöskään XNA ei tue niitä
            textureWidth = Math.Min(textureWidth, MAX_TEXTURE_RESOLUTION);
            textureHeight = Math.Min(textureHeight, MAX_TEXTURE_RESOLUTION);
#endif

            int amount = ( textureWidth * textureHeight ) / 800;

            Image image = Image.FromGradient( textureWidth, textureHeight, lowerColor, upperColor );

            Image = image;
            MovesWithCamera = false;

            return image;
        }

        public void Draw( Matrix parentTransformation, Matrix transformation )
        {
            if ( Image == null ) return;

            if ( MovesWithCamera )
            {
                Matrix matrix =
                    Matrix.CreateScale( (float)Size.X, (float)Size.Y, 1f )
                    * transformation
                    * parentTransformation;
                Renderer.DrawImage( Image, ref matrix, TextureWrapSize );
            }
        }
    }
}