Extension methods
From XNAWiki
Contents |
Graphics
Viewport
- ToRectangle
public static Rectangle ToRectangle(this Viewport vp)
{
return new Rectangle(vp.X, vp.Y, vp.Width, vp.Height);
}
- GetCenter
public static Vector2 GetCenter(this Viewport viewPort)
{
return new Vector2(viewPort.Width / 2, viewPort.Height / 2);
}
Vector2
- ToPoint
public static Point ToPoint(this Vector2 v)
{
return new Point((int)v.X, (int)v.Y);
}
- ToVector3
public static Vector3 ToVector3(this Vector2 v)
{
return new Vector3(v.X, v.Y, 0);
}
Texture2D
- GetSourceRectangle
public static Rectangle GetSourceRectangle(this Texture2D entity)
{
return new Rectangle(0, 0, entity.Width, entity.Height);
}
- GetSize
public static Vector2 GetSize(this Texture2D texture)
{
return new Vector2(texture.Width, texture.Height);
}
Rectangle
- CenterRectangle
public static Rectangle CenterRectangle(this Rectangle r, int x, int y)
{
return new Rectangle(x - r.Center.X, y - r.Center.Y, r.Width, r.Height);
}
- GetSizeAsPoint
public static Point GetSizeAsPoint(this Rectangle r)
{
return new Point(r.Width, r.Height);
}
- GetSizeAsVector2
public static Vector2 GetSizeAsVector2(this Rectangle r)
{
return new Vector2(r.Width, r.Height);
}
- BottomRightAsPoint
public static Point BottomRightAsPoint(this Rectangle r)
{
return new Point(r.Right, r.Bottom);
}
- BottomRightAsVector2
public static Vector2 BottomRightAsVector2(this Rectangle r)
{
return new Vector2(r.Right, r.Bottom);
}
- Contains
public static bool Contains(this Rectangle r, float x, float y)
{
return x >= r.X && x <= r.X + r.Width && y >= r.Y && y <= r.Y + r.Height;
}
public static bool Contains(this Rectangle r, Vector2 pos)
{
return pos.X >= r.X && pos.X <= r.X + r.Width && pos.Y >= r.Y && pos.Y <= r.Y + r.Height;
}
- FromLTRB
public static Rectangle FromLTRB(this Rectangle src, float left, float top, float right, float bottom)
{
return new Rectangle(src.X, src.Y, src.Right - src.X, src.Bottom - src.Y);
}
Quaternion
- Yaw
public static Quaternion Yaw(this Quaternion q, float value)
{
return q * Quaternion.CreateFromYawPitchRoll(value, 0, 0);
}
public static void Yaw(this Quaternion q, float value, out Quaternion result)
{
result = q * Quaternion.CreateFromYawPitchRoll(value, 0, 0);
}
public static Quaternion Yaw(this Quaternion q, float value, bool normalize)
{
var ret = q * Quaternion.CreateFromYawPitchRoll(value, 0, 0);
if (normalize) ret.Normalize();
return ret;
}
public static void Yaw(this Quaternion q, float value, bool normalize, out Quaternion result)
{
result = q * Quaternion.CreateFromYawPitchRoll(value, 0, 0);
if (normalize) result.Normalize();
}
- Pitch
public static Quaternion Pitch(this Quaternion q, float value)
{
return q * Quaternion.CreateFromYawPitchRoll(0, value, 0);
}
public static void Pitch(this Quaternion q, float value, out Quaternion result)
{
result = q * Quaternion.CreateFromYawPitchRoll(0, value, 0);
}
public static Quaternion Pitch(this Quaternion q, float value, bool normalize)
{
var ret = q * Quaternion.CreateFromYawPitchRoll(0, value, 0);
if (normalize) ret.Normalize();
return ret;
}
public static void Pitch(this Quaternion q, float value, bool normalize, out Quaternion result)
{
result = q * Quaternion.CreateFromYawPitchRoll(0, value, 0);
if (normalize) result.Normalize();
}
- Roll
public static Quaternion Roll(this Quaternion q, float value)
{
return q * Quaternion.CreateFromYawPitchRoll(0, 0, value);
}
public static void Roll(this Quaternion q, float value, out Quaternion result)
{
result = q * Quaternion.CreateFromYawPitchRoll(0, 0, value);
}
public static Quaternion Roll(this Quaternion q, float value, bool normalize)
{
var ret = q * Quaternion.CreateFromYawPitchRoll(0, 0, value);
if (normalize) ret.Normalize();
return ret;
}
public static void Roll(this Quaternion q, float value, bool normalize, out Quaternion result)
{
result = q * Quaternion.CreateFromYawPitchRoll(0, 0, value);
if (normalize) result.Normalize();
}
- ToYawPitchRoll
public static void ToYawPitchRoll(this Quaternion q, out float yaw, out float pitch, out float roll)
{
var x = q.X;
var y = q.Y;
var z = q.Z;
var w = q.W;
yaw = (float) Math.Asin(-2f * (x * z - w * y));
pitch = (float) Math.Atan2(2f * (y * z + w * x),
w * w - x * x - y * y + z * z);
roll = (float) Math.Atan2(2f * (x * y + w * z),
w * w + x * x - y * y - z * z);
}
Matrix
- CreateRotationFromLine
static Random = ms_random = new Random();
public static Matrix CreateRotationFromLine(this Matrix math, Vector3 start, Vector3 end)
{
Vector3 p; // this vector should not be between start and end
p.X = (float)ms_random.NextDouble();
p.Y = (float)ms_random.NextDouble();
p.Z = (float)ms_random.NextDouble();
//
Vector3 r = Vector3.Cross(p - start, end - start);
Vector3 s = Vector3.Cross(r, end - start);
r.Normalize();
s.Normalize();
//
Vector3 forward = end - start;
forward.Normalize();
//
float theta = 0;
float rCosTheta = (float)Math.Cos(theta),
rSinTheta = (float)Math.Sin(theta);
//
Vector3 up = new Vector3()
{
X = start.X + rCosTheta * r.X + rSinTheta * s.X,
Y = start.Y + rCosTheta * r.Y + rSinTheta * s.Y,
Z = start.Z + rCosTheta * r.Z + rSinTheta * s.Z
};
return Matrix.CreateWorld(start, forward, up);
}
Model
- BuildBoundingSphere
public static BoundingSphere BuildBoundingSphere(this Model model)
{
BoundingSphere sphere=new BoundingSphere(Vector3.Zero,0);
foreach (var mesh in model.Meshes)
{
sphere = BoundingSphere.CreateMerged(sphere, mesh.BoundingSphere);
}
return sphere;
}
BoundingFrustum
- BoundingFrustum
public static BoundingFrustum BuildFrustum(this BoundingFrustum v, GraphicsDevice device,
Vector3 up,
float fov, float near, float far,
Vector3 position,
Vector3 target)
{
Matrix view = Matrix.CreateLookAt( position, target, up);
Quaternion rotation = Quaternion.CreateFromRotationMatrix(Matrix.Invert(view));
Matrix projection = Matrix.CreatePerspectiveFieldOfView(fov, device.Viewport.GetAspectRatio(), near, far);
Matrix matrix = Matrix.CreateFromQuaternion(rotation);
//Matrix matrix = Matrix.CreateFromYawPitchRoll(yaw, pitch, roll);
matrix.Translation = position;
view = Matrix.Invert(matrix);
var frustum = new BoundingFrustum(Matrix.Multiply(view, projection));
return frustum;
}
public static BoundingFrustum BuildFrustum(this BoundingFrustum v, GraphicsDevice device,
Vector3 up,
float fov, float near, float far,
float yaw, float pitch, float roll,
float x, float y, float z,
float tx, float ty, float tz)
{
Matrix view = Matrix.CreateLookAt(new Vector3(x, y, z), new Vector3(tx, ty, tz), up);
Quaternion rotation = Quaternion.CreateFromRotationMatrix(Matrix.Invert(view));
Matrix projection = Matrix.CreatePerspectiveFieldOfView(fov, device.Viewport.GetAspectRatio(), near, far);
Matrix matrix = Matrix.CreateFromQuaternion(rotation);
matrix.Translation = new Vector3(x, y, z);
view = Matrix.Invert(matrix);
var frustum = new BoundingFrustum(Matrix.Multiply(view, projection));
return frustum;
}
GameComponent
- GetService
public static T GetService<T>(this GameComponent component)
{
return (T) component.Game.Services.GetService(typeof (T));
}
GameServiceContainer
- GetService
public static T GetService<T>(this GameServiceContainer service)
{
return (T) service.GetService(typeof (T));
}
MouseState
- GetPosition
public static Vector2 GetPosition(this MouseState mouse)
{
return new Vector2(mouse.X, mouse.Y);
}
Generics
- Serialize
public static void Serialize<T>(this T obj, string filename) where T : IContentSerializable
{
using (XmlWriter writer = XmlWriter.Create(filename, new XmlWriterSettings() { Indent = true }))
{
IntermediateSerializer.Serialize(writer, obj, null);
}
}
- IContentSerializable
public interface IContentSerializable { }
float
- ToNearestInt
public static int ToNearestInt(this float f)
{
return (int)(f > 0 ? (f + 0.5f) : (f - 0.5f));
}
