public void LoadResources()
		{
			if (m_Disposed == true)
			{
				Buffer = new Texture2D(GameEnvironment.Device, new Texture2DDescription()
				{
					Format = m_Format,
					Width = m_Width,
					Height = m_Height,
					OptionFlags = ResourceOptionFlags.None,
					MipLevels = 1,
					ArraySize = 1,
					BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
					CpuAccessFlags = CpuAccessFlags.None,
					SampleDescription = new SampleDescription(1, 0),
					Usage = ResourceUsage.Default
				});

				View = new RenderTargetView(GameEnvironment.Device, Buffer);
				ResourceView = new ShaderResourceView(GameEnvironment.Device, Buffer);
				Viewport = new Viewport(0, 0, Buffer.Description.Width, Buffer.Description.Height);

				m_Disposed = false;
			}
		}

        public void AddTextureAsset(String path, Object user, Int32 u, Int32 v)
        {
            if (String.IsNullOrWhiteSpace(path))
                throw new ArgumentException();

            if (user == null)
                throw new ArgumentNullException();

            Vector2i tiles = new Vector2i(u, v);

            if (TextureAssetsByUsers.ContainsKey(path))
            {
                if (TextureAssetsByUsers[path].TextureInfo.NumTiles != tiles)
                    throw new ArgumentException("Duplicate texture asset with different tiles: " + path);

                TextureAssetsByUsers[path].AddUser(user);
            }
            else
            {
                Texture2D t = new Texture2D(path, false);
                TextureInfo ti = new TextureInfo(t, tiles);

                TextureAssetsByUsers[path] = new TextureUsers(ti, user);
            }
        }

        public TitleScene()
        {
            this.Camera.SetViewFromViewport();
            _texture = new Texture2D("Application/images/title.png",false);
            _ti = new TextureInfo(_texture);
            SpriteUV titleScreen = new SpriteUV(_ti);
            titleScreen.Scale = _ti.TextureSizef;
            titleScreen.Pivot = new Vector2(0.5f,0.5f);
            titleScreen.Position = new Vector2(Director.Instance.GL.Context.GetViewport().Width/2,
                                              Director.Instance.GL.Context.GetViewport().Height/2);
            this.AddChild(titleScreen);

            Vector4 origColor = titleScreen.Color;
            titleScreen.Color = new Vector4(0,0,0,0);
            var tintAction = new TintTo(origColor,10.0f);
            ActionManager.Instance.AddAction(tintAction,titleScreen);
            tintAction.Run();

            _titleSong = new Bgm("/Application/audio/titlesong.mp3");

            if(_songPlayer != null)
            _songPlayer.Dispose();
            _songPlayer = _titleSong.CreatePlayer();

            Scheduler.Instance.ScheduleUpdateForTarget(this,0,false);

            // Clear any queued clicks so we dont immediately exit if coming in from the menu
            Touch.GetData(0).Clear();
        }

 public static Texture2D MakePixel(Color color)
 {
     Texture2D tex = new Texture2D(1, 1, TextureFormat.RGBA32, false);
     tex.SetPixel(0, 0, color);
     tex.Apply();
     return tex;
 }

        public Sprite(GraphicsContext graphics, Texture2D texture)
        {
            if(shaderProgram == null)
            {
                shaderProgram = new ShaderProgram("/Application/shaders/Sprite.cgx");
                shaderProgram.SetUniformBinding(0, "u_WorldMatrix");
            }

            if (texture == null)
            {
                throw new Exception("ERROR: texture is null.");
            }

            this.graphics = graphics;
            this.texture = texture;
            this.width = texture.Width;
            this.height = texture.Height;

            indices = new ushort[indexSize];
            indices[0] = 0;
            indices[1] = 1;
            indices[2] = 2;
            indices[3] = 3;

            vertexBuffer = new VertexBuffer(4, indexSize, VertexFormat.Float3,
                                            VertexFormat.Float2, VertexFormat.Float4);
        }

        public TextureAtlas(string filename)
        {
            sprites = new Dictionary<string, Bounds2>();
            sizes = new Dictionary<string, Vector2i>();

            XDocument doc = XDocument.Load(filename + ".xml");

            var lines = from sprite in doc.Root.Elements("sprite")
                select new
                {
                    Name = sprite.Attribute("n").Value,
                    X1 = (float)sprite.Attribute("x"),
                    Y1 = (float)sprite.Attribute("y"),
                    Height = (float)sprite.Attribute("h"),
                    Width = (float)sprite.Attribute("w")
                };

            texAtlas = new Texture2D(filename + ".png", false);
            texAtlasInfo = new TextureInfo(texAtlas);

            foreach (var curLine in lines)
            {
                sprites.Add(curLine.Name, new Bounds2(new Vector2(curLine.X1 / texAtlas.Width, 1 - (curLine.Y1 / texAtlas.Height)), new Vector2((curLine.X1 + curLine.Width) / texAtlas.Width, 1 -((curLine.Y1 + curLine.Height) / texAtlas.Height))));
                sizes.Add(curLine.Name, new Vector2i((int)curLine.Width, (int)curLine.Height));
            }
        }

 protected override void LoadContent()
 {
     tex = Content.Load<Texture2D>("Logo.jpg");
     mouse = Content.Load<Texture2D>("Mouse.png");
     BasicFont = this.Content.Load<SpriteFont>("wryh");
     base.LoadContent();
 }

        public FighterCarrier(Texture2D texture, Vector2 location, SpriteBatch spriteBatch, Texture2D droneTexture, bool isAlly)
            : base(texture, location, spriteBatch, isAlly)
        {
            //UseCenterAsOrigin = true;

            //Init drones
            if (!StateManager.NetworkData.IsMultiplayer)
            {
                Drones.Add(new Drone(droneTexture, location, spriteBatch, this) { DroneState = CoreTypes.DroneState.Stowed });
                Drones[0].Rotation.Radians = MathHelper.Pi;

                Drones.Add(new Drone(droneTexture, location, spriteBatch, this) { DroneState = CoreTypes.DroneState.Stowed });
                Drones[1].Rotation.Radians = MathHelper.TwoPi;

                StateManager.InputManager.DebugControlManager.DroneSuicide += new EventHandler<DroneEventArgs>(DebugControlManager_DroneSuicide);
            }
            //BulletTexture = GameContent.Assets.Images.Ships.Bullets[ShipType.FighterCarrier, ShipTier.Tier1];
            DelayBetweenShots = TimeSpan.FromMilliseconds(100);
            DamagePerShot = 2;
            _initHealth = 100;
            MovementSpeed = Vector2.One * 2f;
            this.TierChanged += new EventHandler(FighterCarrier_TierChanged);
            DamagePerShot = 2;
            this.PlayerType = PlayerType.Ally;
            ShootSound = GameContent.Assets.Sound[SoundEffectType.FighterCarrierFire];
        }

		/// <summary>
		/// Creates texture from file in memory 
		/// </summary>
		/// <param name="rs"></param>
		/// <param name="texture"></param>
		public UserTexture ( RenderSystem rs, byte[] data, bool forceSRgb )
		{
			this.texture	=	new Texture2D( rs.Device, data, forceSRgb );
			this.Width		=	texture.Width;
			this.Height		=	texture.Height;
			this.Srv		=	texture;
		}

        protected override void OnInit(object sender, EventArgs e)
        {
            //OdysseyUI.RemoveHooks(Global.FormOwner);

            ImageLoadInformation imageLoadInfo = new ImageLoadInformation()
            {
                BindFlags = BindFlags.None,
                CpuAccessFlags = CpuAccessFlags.Read,
                FilterFlags = FilterFlags.None,
                Format = SlimDX.DXGI.Format.R8G8B8A8_UNorm,
                MipFilterFlags = FilterFlags.None,
                OptionFlags = ResourceOptionFlags.None,
                Usage = ResourceUsage.Staging,
                MipLevels = 1
            };

            // Make texture 3D
            Texture2D sourceTexture = Texture2D.FromFile(Game.Context.Device, "medusa.jpg", imageLoadInfo);
            stereoTexture = Stereo.Make3D(sourceTexture);
            backBuffer = Game.Context.GetBackBuffer();

            stereoSourceBox = new ResourceRegion
                                  {
                                      Front = 0,
                                      Back = 1,
                                      Top = 0,
                                      Bottom = Game.Context.Settings.ScreenHeight,
                                      Left = 0,
                                      Right = Game.Context.Settings.ScreenWidth
                                  };
        }

        /// <summary>コンストラクタ。</summary>
        public SimpleSprite(GraphicsContext graphics, Texture2D texture)
        {
            if(shaderProgram == null)
            {
                shaderProgram=CreateSimpleSpriteShader();
            }

            if (texture == null)
            {
                throw new Exception("ERROR: texture is null.");
            }

            this.graphics = graphics;
            this.texture = texture;
            this.width = texture.Width;
            this.height = texture.Height;

            indices = new ushort[indexSize];
            indices[0] = 0;
            indices[1] = 1;
            indices[2] = 2;
            indices[3] = 3;

            //@e                                                Vertex coordinate,               Texture coordinate,     Vertex color
            //@j                                                頂点座標,                テクスチャ座標,     頂点色
            vertexBuffer = new VertexBuffer(4, indexSize, VertexFormat.Float3, VertexFormat.Float2, VertexFormat.Float4);
        }

		/// <summary>
		///
		/// </summary>
		/// <param name="rs"></param>
		/// <param name="texture"></param>
		private DiscTexture ( RenderSystem rs, Texture2D texture )
		{
			this.texture	=	texture;
			this.Width		=	texture.Width;
			this.Height		=	texture.Height;
			this.Srv		=	texture;
		}

        public Skybox(GraphicsDevice device)
        {
            float x = 0.525731f;
            float z = 0.850651f;

            var vertices = new SkyboxVertex[12]
            {
                new SkyboxVertex(-x, 0f, z), new SkyboxVertex(x, 0f, z),
                new SkyboxVertex(-x, 0f, -z), new SkyboxVertex(x, 0f, -z),
                new SkyboxVertex(0f, z, x), new SkyboxVertex(0f, z, -x),
                new SkyboxVertex(0f, -z, x), new SkyboxVertex(0f, -z, -x),
                new SkyboxVertex(z, x, 0f), new SkyboxVertex(-z, x, 0f),
                new SkyboxVertex(z, -x, 0f), new SkyboxVertex(-z, -x, 0f),
            };

            var indices = new int[60]
            {
                1,4,0,  4,9,0,  4,5,9,  8,5,4,  1,8,4,
                1,10,8, 10,3,8, 8,3,5,  3,2,5,  3,7,2,
                3,10,7, 10,6,7, 6,11,7, 6,0,11, 6,1,0,
                10,1,6, 11,0,9, 2,11,9, 5,2,9,  11,2,7
            };

            vertexBuffer = Buffer<SkyboxVertex>.New(device, vertices, BufferFlags.VertexBuffer);
            indexBuffer = Buffer<int>.New(device, indices, BufferFlags.IndexBuffer);
            skyboxEffect = EffectLoader.Load(@"Graphics/Shaders/Skybox.fx");
            skyboxTex = Texture2D.Load(device, @"G:\Users\Athrun\Documents\Stratum\trunk\src\Stratum\WorldEngine\Earth\milkyWay.tif");
        }

 public TextureFactory(Engine engine)
 {
     _missingTexture = engine.Content.Load<Texture2D>("Textures\\missing-texture");
     _landCache = new Cache<int, Texture2D>(TimeSpan.FromMinutes(5), 0x1000);
     _lastCacheClean = DateTime.MinValue;
     _textures = new Textures(engine);
 }

 protected override void LoadContent()
 {
     texture = game.Content.Load<Texture2D>(textureFilename);
     origin.X = texture.Width / 2;
     origin.Y = texture.Height / 2;
     base.LoadContent();
 }

		public void LoadResources()
		{
			if (m_Disposed == true)
			{
				if (m_Filename != null)
				{
					m_ImposterTexture = Texture2D.FromFile(GameEnvironment.Device, Helper.ResolvePath(m_Filename));
					TextureView = new ShaderResourceView(GameEnvironment.Device, m_ImposterTexture);
				}

				m_Vertices = new SlimDX.Direct3D11.Buffer(GameEnvironment.Device, new BufferDescription()
				{
					BindFlags = BindFlags.VertexBuffer,
					CpuAccessFlags = CpuAccessFlags.Write,
					OptionFlags = ResourceOptionFlags.None,
					SizeInBytes = 4 * Marshal.SizeOf(typeof(Vertex2D)),
					Usage = ResourceUsage.Dynamic
				});

				m_VerticesBindings = new VertexBufferBinding(m_Vertices, Marshal.SizeOf(typeof(Vertex2D)), 0);

				WriteRectangle(); 		

				m_Disposed = false;
			}
		}

        /// <summary>
        /// Constructor
        /// Creates the texture we will render to based on the supplied width and height
        /// </summary>
        /// <param name="device">The device we will create the texture with</param>
        /// <param name="texWidth"></param>
        /// <param name="texHeight"></param>
        public RenderTexture(Device device, int texWidth, int texHeight)
        {
            Texture2DDescription textureDescription = new Texture2DDescription()
                {
                    Width = texWidth,
                    Height = texHeight,
                    MipLevels = 1,
                    ArraySize = 1,
                    Format = SlimDX.DXGI.Format.R32G32B32A32_Float,
                    SampleDescription = new SlimDX.DXGI.SampleDescription(1, 0),
                    BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
                    CpuAccessFlags = CpuAccessFlags.None,
                    OptionFlags = ResourceOptionFlags.None,
                    Usage = ResourceUsage.Default,
                };
            Texture = new Texture2D(device, textureDescription);
            RenderTargetViewDescription renderTargetViewDescription = new RenderTargetViewDescription()
            {
                Format = textureDescription.Format,
                Dimension = RenderTargetViewDimension.Texture2D,
                MipSlice = 0,
            };

            renderTargetView = new RenderTargetView(device, Texture, renderTargetViewDescription);

            ShaderResourceViewDescription shaderResourceViewDescription = new ShaderResourceViewDescription()
            {
                Format = textureDescription.Format,
                Dimension = ShaderResourceViewDimension.Texture2D,
                MostDetailedMip = 0,
                MipLevels = 1
            };

            shaderResourceView = new ShaderResourceView(device, Texture, shaderResourceViewDescription);
        }

 public Saucer(GraphicsContext g, Texture2D t, Vector3 p, Player pl)
     : base(g,t,p, pl)
 {
     player = pl;
     vel= (new Vector3(.5f*(float)gen.Next(3,5),.7f*(float)gen.Next(3,5),0));
     graphics=g;
 }

        public void Render( Texture2D texture, Scene scene)
        {
            TextureInfo ti1 = new TextureInfo();

            //if(flip)
                ti1.Texture = texture;
            //	else
            //		ti1.Texture = texture1;

               		SpriteUV sprite1 = new SpriteUV();
               		sprite1.TextureInfo = ti1;

               		if(type==0)
            sprite1.Quad.S = ti1.TextureSizef.Multiply(.3f);

            if(type==1)
            sprite1.Quad.S = ti1.TextureSizef.Multiply(.05f);

               		sprite1.CenterSprite();
               		sprite1.Position = position;// scene.Camera.CalcBounds().Center;

            sprite1.Rotate(-rotation);//*Sce.PlayStation.HighLevel.GameEngine2D.Base.Math.Pi/180);

               		scene.AddChild(sprite1);
        }

        public static Texture2D TextureFromBitmap(Bitmap image)
        {
            BitmapData data = image.LockBits(new Rectangle(0, 0, image.Width, image.Height),
                                             ImageLockMode.ReadWrite, image.PixelFormat);
            int bytes = data.Stride*image.Height;
            DataStream stream = new DataStream(bytes, true, true);
            stream.WriteRange(data.Scan0, bytes);
            stream.Position = 0;
            DataRectangle dRect = new DataRectangle(data.Stride, stream);

            Texture2DDescription texDesc = new Texture2DDescription
                                               {
                                                   ArraySize = 1,
                                                   MipLevels = 1,
                                                   SampleDescription = new SampleDescription(1, 0),
                                                   Format = Format.B8G8R8A8_UNorm,
                                                   CpuAccessFlags = CpuAccessFlags.None,
                                                   BindFlags = BindFlags.ShaderResource,
                                                   Usage = ResourceUsage.Immutable,
                                                   Height = image.Height,
                                                   Width = image.Width
                                               };

            image.UnlockBits(data);
            image.Dispose();
            Texture2D texture = new Texture2D(Game.Context.Device, texDesc, dRect);
            stream.Dispose();
            return texture;
        }