public class CoroutinesManager
{
	private readonly List<IEnumerator> _coroutines = new List<IEnumerator> ();
 
	public void Start(IEnumerator enumerator)
	{
		_coroutines.Add (enumerator);
	}
 
	public void Update()
	{
		for (int i = _coroutines.Count - 1; i >= 0; i--) 
		{
			IEnumerator enumerator = _coroutines[i];
 
			if(!enumerator.MoveNext())
				_coroutines.RemoveAt(i);
		}
	}
}
 
class Game1 : Game
{
	...
	CoroutinesManager _coroutinesManager = new CoroutinesManager();
 
	...
	protected override void Update (GameTime gameTime)
       {
		...
		coroutinesManager .Update();
	}
}
 
Добавлено за 0.010 секунд, используя GeSHi 1.0.8.2

 
private IEnumerator CoroutineTest(GameTime gameTime)
{
	float time = 0;
 
	while (time < 10) 
	{
		time += (float)gameTime.ElapsedGameTime.TotalSeconds;
 
		_color = Color.Lerp(Color.CornflowerBlue, Color.Green, time / 10);
 
		yield return null;
	}
}
 
protected override void Update (GameTime gameTime)
{
	...
	if (Keyboard.GetState ().IsKeyDown (Keys.R))
				manager.Start (CoroutineTest(gameTime));
	...
}
 
Добавлено за 0.008 секунд, используя GeSHi 1.0.8.2

private IEnumerator CoroutineTest2(Unit unit, AnimationSet dieAnimation)
{
	unit.StartAnimation (dieAnimation);
 
	while (!unit.Animation.IsFinished) 
	{
		yield return null;
	}
 
	_units.Remove (unit); 
}
Добавлено за 0.005 секунд, используя GeSHi 1.0.8.2

float buttonPosition = MathHelper.Lerp(oldPosition, newPosition, currentTime / animationTime );
Добавлено за 0.005 секунд, используя GeSHi 1.0.8.2

Curve mCurve = Content.Load<Curve>("SlideCurve");
...
float t = mCurve.Evaluate(currentTime / animationTime);
float buttonPosition = MathHelper.Lerp(oldPosition, newPosition, t);
Добавлено за 0.008 секунд, используя GeSHi 1.0.8.2

class Camera
{
	public Matrix View { get; private set; }
	public Matrix Projection { get; private set; }
 
	public Vector3 Position { get; set; }
	public Vector3 Direction { get; set; }
	public Vector3 Up { get; set; }
	public Vector3 Right { get; private set; }
 
	public float FieldOfView { get; set; }
	public float Near { get; set; }
	public float Far { get; set; }
 
	public Game Game { get; private set; }
 
	public Camera(Game game)
	{
		this.Game = game;
	}
 
	public void Update()
	{
		this.View = Matrix.CreateLookAt(this.Position, this.Position + this.Direction, this.Up);
		this.Projection = Matrix.CreatePerspectiveFieldOfView(this.FieldOfView, 
this.Game.GraphicsDevice.Viewport.AspectRatio, this.Near, this.Far);
		this.Right = Vector3.Normalize(Vector3.Cross(this.Direction, this.Up));
	}
}
Добавлено за 0.009 секунд, используя GeSHi 1.0.8.2

abstract class AbsCameraController
{
	public Camera Camera { get; set; }
 
	public AbsCameraController(Camera camera)
	{
		this.Camera = camera;
	}
 
	public abstract void Update(float seconds);
}
Добавлено за 0.004 секунд, используя GeSHi 1.0.8.2

class TargetCameraController : AbsCameraController
{
	public Vector3 Target { get; set; }
	public float Distance { get; set; }
 
	public TargetCameraController(Camera camera)
		: base(camera)
	{ 
	}
 
	public override void Update(float seconds)
	{
		this.Camera.Position = this.Target - this.Distance * this.Camera.Direction;
	}
}
Добавлено за 0.005 секунд, используя GeSHi 1.0.8.2

class KeyboardCameraController : AbsCameraController
{
	public float Velocity { get; set; }
 
	public KeyboardCameraController(Camera camera)
		: base(camera)
	{ 
	}
 
	public override void Update(float seconds)
	{
		KeyboardState kState = Keyboard.GetState();
 
		if (kState.IsKeyDown(Keys.Up))
			this.Camera.Position += this.Velocity * this.Camera.Direction;
		if (kState.IsKeyDown(Keys.Down))
			this.Camera.Position -= this.Velocity * this.Camera.Direction;
		if (kState.IsKeyDown(Keys.Right))
			this.Camera.Position += this.Velocity * this.Camera.Right;
		if (kState.IsKeyDown(Keys.Left))
			this.Camera.Position -= this.Velocity * this.Camera.Right;
	}
}
Добавлено за 0.007 секунд, используя GeSHi 1.0.8.2

float4x4 World;
float4x4 View;
float4x4 Projection;
float4 ClipPlane; // наша плоскость
 
struct VertexShaderInput
{
    float4 Position : POSITION0;
};
 
struct VertexShaderOutput
{
    float4 Position : POSITION0;
    float clipDepth : TEXCOORD0; // DotProduct для роботи с отсечением
};
 
VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
    VertexShaderOutput output;
    float4 worldPosition = mul(input.Position, World);
 
    output.clipDepth = dot(worldPosition, ClipPlane); // считаем DotProduct 
    output.Position = mul(mul(worldPosition, View), Projection);
    return output;
}
 
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
    clip(input.clipDepth); // проверка отсечения
 
    // дальше ваш код
    return float4(1,1,0,1);
}
Добавлено за 0.014 секунд, используя GeSHi 1.0.8.2

effect.Parameters["ClipPlane"].SetValue(new Vector4(0, -1, 0, 0));
Добавлено за 0.004 секунд, используя GeSHi 1.0.8.2

technique Technique1
{
    pass Pass1
    {
        VertexShader = compile vs_2_0 VertexShaderFunction();
        PixelShader = compile ps_2_0 PixelShaderFunction(); // "нормальный" шейдер
 
	ZWRITEENABLE = TRUE;
	ZFUNC = LESSEQUAL; //
    }
 
    pass Pass2
    {
        VertexShader = compile vs_2_0 VertexShaderFunction();
        PixelShader = compile ps_2_0 PixelShaderFunctionHL(); //  шейдер подсветки
 
	ZWRITEENABLE = FALSE;
	ZFUNC = GREATER;
    }
}
 
Добавлено за 0.009 секунд, используя GeSHi 1.0.8.2

public struct Angle
{
    public readonly float radians;
    public readonly float sin;
    public readonly float cos;
 
    public Angle(float value)
    {
        this.radians = value;
        this.sin = (float)Math.Sin(value);
        this.cos = (float)Math.Cos(value);
    }
 
    public static implicit operator float (Angle angle)
    {
        return angle.radians;
    }
 
    public static implicit operator Angle(float angle)
    {
        return new Angle(angle);
    }
}
Добавлено за 0.006 секунд, используя GeSHi 1.0.8.2