public IRenderRequest CreateInstancedRequest(IRenderContext renderContext, RasterizerState rasterizerState,
     BlendState blendState, DepthStencilState depthStencilState, IEffect effect, IEffectParameterSet effectParameterSet,
     VertexBuffer meshVertexBuffer, IndexBuffer meshIndexBuffer, PrimitiveType primitiveType,
     Matrix[] instanceWorldTransforms, Action<List<Matrix>, VertexBuffer, IndexBuffer> computeCombinedBuffers)
 {
     throw new NotImplementedException();
 }

        public Transition(Effect cEffectSource, Effect cEffectTarget)
            : this()
        {
			try
            {
                if (null == cEffectSource) // TODO проверять видео или только аудио.....
                    _cEffectSource = new Composite(1, 1);
                else
                    _cEffectSource = cEffectSource;
                if (null == cEffectTarget)
                    _cEffectTarget = new Composite(1, 1);
                else
                    _cEffectTarget = cEffectTarget;
                #region z-layer
                if (_cEffectSource.nLayer > _cEffectTarget.nLayer)
                    ((IEffect)this).nLayer = _cEffectTarget.nLayer;
                else
					((IEffect)this).nLayer = _cEffectSource.nLayer;
				#endregion
			}
			catch
			{
				Fail();
				throw;
			}
		}

        public void Render(IEffect effect)
        {
            effect.SetTexture("tex0", _noTexture);
            effect.CommitChanges();

            _vertexRenderer.RenderForShader(PrimitiveType.LineList, 0, 3);
        }

        public Sprite( ITexture2D texture, IEffect effect )
        {
            if ( effect == null )
            {
                if ( baseSpriteEffect == null )
                    baseSpriteEffect = new SpriteEffect ();
                effect = baseSpriteEffect;
            }

            if ( projectionMatrix == null )
                projectionMatrix = new OrthographicOffCenterProjection ( 0, 800, 600, 0, 0.001f, 1000.0f );

            Effect = effect;

            if ( vertexDeclaration == null )
            {
                vertexDeclaration = Core.GraphicsDevice.CreateVertexDeclaration ( Utilities.CreateVertexElementArray<SpriteVertex> () );
            }
            indexReference++;

            vertexBuffer = Core.GraphicsDevice.CreateBuffer ( BufferType.VertexBuffer, typeof ( SpriteVertex ), 4 );

            textureArgument = new SamplerState ( texture, Graphics.TextureFilter.Nearest, TextureAddressing.Clamp, 0 );
            Reset ( texture );

            innerWorld = new World2();
        }

        public Sprite( ITexture2D texture, IEffect effect )
        {
            if ( effect == null )
            {
                if ( baseSpriteEffect == null )
                    baseSpriteEffect = new SpriteEffect ();
                effect = baseSpriteEffect;
            }

            Texture = texture;
            Effect = effect;

            int width = 1, height = 1;
            if ( texture != null ) { width = texture.Width; height = texture.Height; }

            vertexBuffer = LiqueurSystem.GraphicsDevice.CreateVertexBuffer<SpriteVertex> ( SpriteVertexFormat, new SpriteVertex []
            {
                new SpriteVertex ( new Vector2 ( 0.001f, 0.001f ), Color.White, new Vector2 ( 0.001f, 0.001f ) ),
                new SpriteVertex ( new Vector2 ( width, 0.001f ), Color.White, new Vector2 ( 1, 0.001f ) ),
                new SpriteVertex ( new Vector2 ( 0.001f, height ), Color.White, new Vector2 ( 0.001f, 1 ) ),
                new SpriteVertex ( new Vector2 ( width, height ), Color.White, new Vector2 ( 1, 1 ) ),
            } );
            if ( indexBuffer == null )
                indexBuffer = LiqueurSystem.GraphicsDevice.CreateIndexBuffer ( new int [] { 0, 1, 2, 1, 3, 2 } );
            indexReference++;

            clippingArea = new Rectangle ( 0, 0, width, height );

            TextureFilter = Liqueur.Graphics.TextureFilter.Nearest;
        }

        public void Render(ModelInstance modelInstance, IEffect effect)
        {
            foreach (var meshInstance in modelInstance.MeshInstances)
            {
                var renderer = GetRendererFor(meshInstance);

                var dataStream = renderer.LockVertexBuffer();
                dataStream.WriteRange(meshInstance.VertexBuffer);
                renderer.UnlockVertexBuffer();

                if (meshInstance.TextureArea == null)
                {
                    meshInstance.TextureArea = _graphicsContext.GetTexture(meshInstance.TextureName);
                }

                if (meshInstance.TextureName != _lastTextureName)
                {
                    _lastTextureName = meshInstance.TextureName;

                    effect.SetTexture("tex0", meshInstance.TextureArea);
                    effect.CommitChanges();
                }

                renderer.RenderForShader(PrimitiveType.TriangleList, 0, meshInstance.TriangleCount);
            }
        }

 private bool IsEffectPrevented(IEffect effect)
 {
     foreach (EffectSupport support in effectSupports)
         if (support(effect))
             return true;
     return false;
 }

 public void RenderText(IRenderContext context, IEffect effect, IEffectParameterSet effectParameterSet, Matrix matrix,
     string text, FontAsset font, HorizontalAlignment horizontalAlignment = HorizontalAlignment.Left,
     VerticalAlignment verticalAlignment = VerticalAlignment.Top, Color? textColor = null, bool renderShadow = true,
     Color? shadowColor = null)
 {
     throw new NotSupportedException();
 }

        public void AddEffect(IEffect effect)
        {
            if (effect == null)
                throw new ArgumentNullException("effect");

            game.AddEffect(effect);
        }

            public Item(IEffect iEffect, Transition.TypeVideo cTransitionVideo, Transition.TypeAudio cTransitionAudio, ushort nTransitionDuration)
            {
                this.iEffect = iEffect;
				this.bIsActive = true;
				this.cTransitionVideo = cTransitionVideo;
				this.cTransitionAudio = cTransitionAudio;
				this.nTransitionDuration = nTransitionDuration;
            }

 public void Setup()
 {
     stubWeapons = MockRepository.GenerateStub<IWeapons>();
     stubWeapons.Stub(me => me[WeaponType.RocketLauncher]).Return(new RocketLauncher(null));
     ((RocketLauncher)stubWeapons[WeaponType.RocketLauncher]).Rockets.Add(new Rocket(Vector2.Zero, Vector2.Zero, new Frenetic.Physics.DummyPhysicsComponent()));
     mockEffects = MockRepository.GenerateStub<IEffect>();
     view = new RocketLauncherView(mockEffects);
 }

		public void Raise(IEffect effect)
		{
			effect.TimeToStart= mCurrentTime + effect.Delay;
			effect.TimeToEnd = effect.TimeToStart + effect.Length;

			mQueuedEffects.Add(effect);
			++mNoOfQueuedEffects;
		}

        public EffectHandle(IEffect effect, IChoice choice, ILimit limit)
        {
            if (effect == null)
                throw new ArgumentNullException("effect");

            this.effect = effect;
            this.choice = choice;
            this.limit = limit;
        }

        public override bool Equals(IEffect other)
        {
            var otherEffect = other as RestoreEnergyEffect;
            if (otherEffect == null)
            {
                return false;
            }

            return Magnitude.Equals(otherEffect.Magnitude);
        }

 public override bool AddEffect(IEffect effect)
 {
     if (IsEffectPrevented(effect))
         return false;
     effectList.AddEffect(effect);
     Invalidate();
     if (effect.ID.Priority == EffectPriority.IMMEDIATE)
         Validate();
     return true;
 }

        public bool Equals(IEffect other)
        {
            var otherEffect = other as DamageHealthEffect;
            if (otherEffect == null)
            {
                return false;
            }

            return Magnitude.Equals(otherEffect.Magnitude);
        }

        /// <summary>
        /// パラメータ無しの画像処理をおこなう
        /// </summary>
        /// <param name="bmp">元になるWriteableBitmapオブジェクト</param>
        /// <param name="effector">処理させるIEffectオブジェクト</param>
        /// <returns>処理後のWriteableBitmapオブジェクト</returns>
        private static WriteableBitmap ProcessEffect(WriteableBitmap bmp, IEffect effector)
        {
            // WriteableBitmapのピクセルデータをバイト配列に変換する
            var srcPixels = bmp.GetPixels();

            // パラメータ無しの画像処理をおこなう
            var dstPixels = effector.Effect(bmp.PixelWidth, bmp.PixelHeight, srcPixels);

            // バイト配列からピクセルを作成する
            return WriteableBitmapLoadExtensions.FromArray(bmp.PixelWidth, bmp.PixelHeight, dstPixels);
        }

 private Ability(IEffect effect, bool isActivatable, string name, bool isUnique, string description,
                 TimeSpan? cooldown = null)
 {
     Effect = effect;
     IsActivatable = isActivatable;
     Name = name;
     IsUnique = isUnique;
     Description = description;
     Cooldown = cooldown;
     CooldownTimer = Cooldown.HasValue ? new Stopwatch() : null;
 }

 public void AddEffect(IEffect effect)
 {
     if (effect != null)
     {
         if (listEffect.ContainsKey(effect.GetType())) // If effect exist
         {
             listEffect.Remove(effect.GetType());
         }
         effect.Owner = this;
         listEffect.Add(effect.GetType(), effect);
     }
 }

 public void Attach( IEffect effect )
 {
     GL.AttachShader ( ( effect as Effect ).programId, shaderId );
     if ( Option != null )
     {
         int count = 0;
         foreach ( ShaderOption.AttributeOrder attr in from a in Option.AttributeOrdering orderby a.VertexType select a )
         {
             GL.BindAttribLocation ( ( int ) effect.Handle, count, attr.Name );
             count++;
         }
     }
 }