Silverlight 5

WinRT

	public sealed class AsyncActionCompletedHandler
	: MulticastDelegate, ICloneable, ISerializable
	public virtual void Invoke(IAsyncAction asyncInfo);

	public sealed class AsyncActionProgressHandler`1<TProgress>
	: MulticastDelegate, ICloneable, ISerializable
	public virtual void Invoke(IAsyncActionWithProgress`1<TProgress> asyncInfo, TProgress progressInfo);

	public sealed class AsyncActionWithProgressCompletedHandler`1<TProgress>
	: MulticastDelegate, ICloneable, ISerializable
	public virtual void Invoke(IAsyncActionWithProgress`1<TProgress> asyncInfo);

	public sealed class AsyncOperationCompletedHandler`1<TResult>
	: MulticastDelegate, ICloneable, ISerializable
	public virtual void Invoke(IAsyncOperation`1<TResult> asyncInfo);

	public sealed class AsyncOperationProgressHandler`2<TResult, TProgress>
	: MulticastDelegate, ICloneable, ISerializable
	public virtual void Invoke(IAsyncOperationWithProgress`2<TResult, TProgress> asyncInfo, TProgress progressInfo);

	public sealed class AsyncOperationWithProgressCompletedHandler`2<TResult, TProgress>
	: MulticastDelegate, ICloneable, ISerializable
	public virtual void Invoke(IAsyncOperationWithProgress`2<TResult, TProgress> asyncInfo);

	public sealed enum AsyncStatus
	: IComparable, IFormattable, IConvertible
	{ Canceled, Completed, Created, Error, Started }

public sealed struct BoundingBox
: ValueType, IEquatable`1<BoundingBox>
public ContainmentType Contains(BoundingBox box);
public void Contains(BoundingBox& box, out ContainmentType& result);
public ContainmentType Contains(BoundingFrustum frustum);
public ContainmentType Contains(Vector3 point);
public void Contains(Vector3& point, out ContainmentType& result);
public ContainmentType Contains(BoundingSphere sphere);
public void Contains(BoundingSphere& sphere, out ContainmentType& result);
static public BoundingBox CreateFromPoints(IEnumerable`1<Vector3> points);
static public BoundingBox CreateFromSphere(BoundingSphere sphere);
static public void CreateFromSphere(BoundingSphere& sphere, out BoundingBox& result);
static public BoundingBox CreateMerged(BoundingBox original, BoundingBox additional);
static public void CreateMerged(BoundingBox& original, BoundingBox& additional, out BoundingBox& result);
public virtual Boolean Equals(BoundingBox other);
public virtual Boolean Equals(Object obj);
public Vector3 GetCorners();
public void GetCorners(Vector3 corners);
public virtual Int32 GetHashCode();
public Boolean Intersects(BoundingBox box);
public void Intersects(BoundingBox& box, out Boolean& result);
public Boolean Intersects(BoundingFrustum frustum);
public PlaneIntersectionType Intersects(Plane plane);
public void Intersects(Plane& plane, out PlaneIntersectionType& result);
public Nullable`1<Single> Intersects(Ray ray);
public void Intersects(Ray& ray, out Nullable`1& result);
public Boolean Intersects(BoundingSphere sphere);
public void Intersects(BoundingSphere& sphere, out Boolean& result);
static public Boolean op_Equality(BoundingBox a, BoundingBox b);
static public Boolean op_Inequality(BoundingBox a, BoundingBox b);
public virtual String ToString();

public class BoundingFrustum
: IEquatable`1<BoundingFrustum>
public Plane Bottom { get; }
public Plane Far { get; }
public Plane Left { get; }
public Matrix Matrix { get; set; }
public Plane Near { get; }
public Plane Right { get; }
public Plane Top { get; }
public ContainmentType Contains(BoundingBox box);
public void Contains(BoundingBox& box, out ContainmentType& result);
public ContainmentType Contains(BoundingFrustum frustum);
public ContainmentType Contains(Vector3 point);
public void Contains(Vector3& point, out ContainmentType& result);
public ContainmentType Contains(BoundingSphere sphere);
public void Contains(BoundingSphere& sphere, out ContainmentType& result);
public virtual Boolean Equals(BoundingFrustum other);
public virtual Boolean Equals(Object obj);
public Vector3 GetCorners();
public void GetCorners(Vector3 corners);
public virtual Int32 GetHashCode();
public Boolean Intersects(BoundingBox box);
public void Intersects(BoundingBox& box, out Boolean& result);
public Boolean Intersects(BoundingFrustum frustum);
public PlaneIntersectionType Intersects(Plane plane);
public void Intersects(Plane& plane, out PlaneIntersectionType& result);
public Nullable`1<Single> Intersects(Ray ray);
public void Intersects(Ray& ray, out Nullable`1& result);
public Boolean Intersects(BoundingSphere sphere);
public void Intersects(BoundingSphere& sphere, out Boolean& result);
static public Boolean op_Equality(BoundingFrustum a, BoundingFrustum b);
static public Boolean op_Inequality(BoundingFrustum a, BoundingFrustum b);
public virtual String ToString();

public sealed struct BoundingSphere
: ValueType, IEquatable`1<BoundingSphere>
public ContainmentType Contains(BoundingBox box);
public void Contains(BoundingBox& box, out ContainmentType& result);
public ContainmentType Contains(BoundingFrustum frustum);
public ContainmentType Contains(Vector3 point);
public void Contains(Vector3& point, out ContainmentType& result);
public ContainmentType Contains(BoundingSphere sphere);
public void Contains(BoundingSphere& sphere, out ContainmentType& result);
static public BoundingSphere CreateFromBoundingBox(BoundingBox box);
static public void CreateFromBoundingBox(BoundingBox& box, out BoundingSphere& result);
static public BoundingSphere CreateFromFrustum(BoundingFrustum frustum);
static public BoundingSphere CreateFromPoints(IEnumerable`1<Vector3> points);
static public BoundingSphere CreateMerged(BoundingSphere original, BoundingSphere additional);
static public void CreateMerged(BoundingSphere& original, BoundingSphere& additional, out BoundingSphere& result);
public virtual Boolean Equals(BoundingSphere other);
public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();
public Boolean Intersects(BoundingBox box);
public void Intersects(BoundingBox& box, out Boolean& result);
public Boolean Intersects(BoundingFrustum frustum);
public PlaneIntersectionType Intersects(Plane plane);
public void Intersects(Plane& plane, out PlaneIntersectionType& result);
public Nullable`1<Single> Intersects(Ray ray);
public void Intersects(Ray& ray, out Nullable`1& result);
public Boolean Intersects(BoundingSphere sphere);
public void Intersects(BoundingSphere& sphere, out Boolean& result);
static public Boolean op_Equality(BoundingSphere a, BoundingSphere b);
static public Boolean op_Inequality(BoundingSphere a, BoundingSphere b);
public virtual String ToString();
public BoundingSphere Transform(Matrix matrix);
public void Transform(Matrix& matrix, out BoundingSphere& result);

public abstract sealed class ColorExtensions
static public Color FromVector3(Vector3 value);
static public Color FromVector4(Vector4 value);
static public Vector3 ToVector3(Color color);
static public Vector4 ToVector4(Color color);

public sealed enum ContainmentType
: IComparable, IFormattable, IConvertible
{ Disjoint, Contains, Intersects }

public class Curve
public Boolean IsConstant { get; }
public CurveKeyCollection Keys { get; }
public CurveLoopType PostLoop { get; set; }
public CurveLoopType PreLoop { get; set; }
public Curve Clone();
public void ComputeTangent(Int32 keyIndex, CurveTangent tangentType);
public void ComputeTangent(Int32 keyIndex, CurveTangent tangentInType, CurveTangent tangentOutType);
public void ComputeTangents(CurveTangent tangentType);
public void ComputeTangents(CurveTangent tangentInType, CurveTangent tangentOutType);
public Single Evaluate(Single position);

public sealed enum CurveContinuity
: IComparable, IFormattable, IConvertible
{ Smooth, Step }

public class CurveKey
: IEquatable`1<CurveKey>, IComparable`1<CurveKey>
public CurveContinuity Continuity { get; set; }
public Single Position { get; }
public Single TangentIn { get; set; }
public Single TangentOut { get; set; }
public Single Value { get; set; }
public CurveKey Clone();
public virtual Int32 CompareTo(CurveKey other);
public virtual Boolean Equals(CurveKey other);
public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();
static public Boolean op_Equality(CurveKey a, CurveKey b);
static public Boolean op_Inequality(CurveKey a, CurveKey b);

public class CurveKeyCollection
: ICollection`1<CurveKey>, IEnumerable`1<CurveKey>, IEnumerable
public virtual Int32 Count { get; }
public virtual Boolean IsReadOnly { get; }
public CurveKey Item { get; set; }
public virtual void Add(CurveKey item);
public virtual void Clear();
public CurveKeyCollection Clone();
public virtual Boolean Contains(CurveKey item);
public virtual void CopyTo(CurveKey array, Int32 arrayIndex);
public virtual IEnumerator`1<CurveKey> GetEnumerator();
public Int32 IndexOf(CurveKey item);
public virtual Boolean Remove(CurveKey item);
public void RemoveAt(Int32 index);

public sealed enum CurveLoopType
: IComparable, IFormattable, IConvertible
{ Constant, Cycle, CycleOffset, Oscillate, Linear }

public sealed enum CurveTangent
: IComparable, IFormattable, IConvertible
{ Flat, Linear, Smooth }

	public abstract interface IAsyncAction
	: IAsyncInfo
	public abstract virtual AsyncActionCompletedHandler Completed { get; set; }
	public abstract virtual void GetResults();

	public abstract interface IAsyncActionWithProgress`1<TProgress>
	: IAsyncInfo
	public abstract virtual AsyncActionWithProgressCompletedHandler`1<TProgress> Completed { get; set; }
	public abstract virtual AsyncActionProgressHandler`1<TProgress> Progress { get; set; }
	public abstract virtual void GetResults();

	public abstract interface IAsyncInfo
	public abstract virtual Exception ErrorCode { get; }
	public abstract virtual UInt32 Id { get; }
	public abstract virtual AsyncStatus Status { get; }
	public abstract virtual void Cancel();
	public abstract virtual void Close();
	public abstract virtual void Start();

	public abstract interface IAsyncOperation`1<TResult>
	: IAsyncInfo
	public abstract virtual AsyncOperationCompletedHandler`1<TResult> Completed { get; set; }
	public abstract virtual TResult GetResults();

	public abstract interface IAsyncOperationWithProgress`2<TResult, TProgress>
	: IAsyncInfo
	public abstract virtual AsyncOperationWithProgressCompletedHandler`2<TResult, TProgress> Completed { get; set; }
	public abstract virtual AsyncOperationProgressHandler`2<TResult, TProgress> Progress { get; set; }
	public abstract virtual TResult GetResults();

	public sealed class ImageResource
	: __ComObject, IRandomAccessStreamWithContentType, IRandomAccessStream, IContentTypeProvider
	public virtual String ContentType { get; }
	public virtual UInt64 Size { get; set; }
	public virtual IInputStream GetInputStreamAt(UInt64 position);
	public virtual IOutputStream GetOutputStreamAt(UInt64 position);

	public abstract interface IPropertyValue
	public abstract virtual Boolean IsNumericScalar { get; }
	public abstract virtual PropertyType Type { get; }
	public abstract virtual Boolean GetBoolean();
	public abstract virtual void GetBooleanArray(out Boolean& value);
	public abstract virtual Char GetChar16();
	public abstract virtual void GetChar16Array(out Char& value);
	public abstract virtual DateTimeOffset GetDateTime();
	public abstract virtual void GetDateTimeArray(out DateTimeOffset& value);
	public abstract virtual Double GetDouble();
	public abstract virtual void GetDoubleArray(out Double& value);
	public abstract virtual Guid GetGuid();
	public abstract virtual void GetGuidArray(out Guid& value);
	public abstract virtual Object GetInspectable();
	public abstract virtual void GetInspectableArray(out Object& value);
	public abstract virtual Int16 GetInt16();
	public abstract virtual void GetInt16Array(out Int16& value);
	public abstract virtual Int32 GetInt32();
	public abstract virtual void GetInt32Array(out Int32& value);
	public abstract virtual Int64 GetInt64();
	public abstract virtual void GetInt64Array(out Int64& value);
	public abstract virtual Point GetPoint();
	public abstract virtual void GetPointArray(out Point& value);
	public abstract virtual Rect GetRect();
	public abstract virtual void GetRectArray(out Rect& value);
	public abstract virtual Single GetSingle();
	public abstract virtual void GetSingleArray(out Single& value);
	public abstract virtual Size GetSize();
	public abstract virtual void GetSizeArray(out Size& value);
	public abstract virtual String GetString();
	public abstract virtual void GetStringArray(out String& value);
	public abstract virtual TimeSpan GetTimeSpan();
	public abstract virtual void GetTimeSpanArray(out TimeSpan& value);
	public abstract virtual UInt16 GetUInt16();
	public abstract virtual void GetUInt16Array(out UInt16& value);
	public abstract virtual UInt32 GetUInt32();
	public abstract virtual void GetUInt32Array(out UInt32& value);
	public abstract virtual UInt64 GetUInt64();
	public abstract virtual void GetUInt64Array(out UInt64& value);
	public abstract virtual Byte GetUInt8();
	public abstract virtual void GetUInt8Array(out Byte& value);

	public abstract interface IReferenceArray`1<T>
	: IPropertyValue
	public abstract virtual T Value { get; }

	public abstract interface IUriRuntimeClassFactory
	public abstract virtual Uri CreateUri(String hstrUri);
	public abstract virtual Uri CreateUri(String hstrBaseUri, String hstrRelativeUri);

public abstract sealed class MathHelper
static public Single Barycentric(Single value1, Single value2, Single value3, Single amount1, Single amount2);
static public Single CatmullRom(Single value1, Single value2, Single value3, Single value4, Single amount);
static public Single Clamp(Single value, Single min, Single max);
static public Single Distance(Single value1, Single value2);
static public Single Hermite(Single value1, Single tangent1, Single value2, Single tangent2, Single amount);
static public Single Lerp(Single value1, Single value2, Single amount);
static public Single Max(Single value1, Single value2);
static public Single Min(Single value1, Single value2);
static public Single SmoothStep(Single value1, Single value2, Single amount);
static public Single ToDegrees(Single radians);
static public Single ToRadians(Single degrees);
static public Single WrapAngle(Single angle);

public sealed struct Matrix	public sealed struct Matrix
: ValueType, IEquatable`1<Matrix>	: ValueType
public Vector3 Backward { get; set; }
public Vector3 Down { get; set; }
public Vector3 Forward { get; set; }
static public Matrix Identity { get; }
public Vector3 Left { get; set; }
public Vector3 Right { get; set; }
public Vector3 Translation { get; set; }
public Vector3 Up { get; set; }
static public Matrix Add(Matrix matrix1, Matrix matrix2);
static public void Add(Matrix& matrix1, Matrix& matrix2, out Matrix& result);
static public Matrix CreateBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 cameraUpVector, Nullable`1<Vector3> cameraForwardVector);
static public void CreateBillboard(Vector3& objectPosition, Vector3& cameraPosition, Vector3& cameraUpVector, Nullable`1<Vector3> cameraForwardVector, out Matrix& result);
static public Matrix CreateConstrainedBillboard(Vector3 objectPosition, Vector3 cameraPosition, Vector3 rotateAxis, Nullable`1<Vector3> cameraForwardVector, Nullable`1<Vector3> objectForwardVector);
static public void CreateConstrainedBillboard(Vector3& objectPosition, Vector3& cameraPosition, Vector3& rotateAxis, Nullable`1<Vector3> cameraForwardVector, Nullable`1<Vector3> objectForwardVector, out Matrix& result);
static public Matrix CreateFromAxisAngle(Vector3 axis, Single angle);
static public void CreateFromAxisAngle(Vector3& axis, Single angle, out Matrix& result);
static public Matrix CreateFromQuaternion(Quaternion quaternion);
static public void CreateFromQuaternion(Quaternion& quaternion, out Matrix& result);
static public Matrix CreateFromYawPitchRoll(Single yaw, Single pitch, Single roll);
static public void CreateFromYawPitchRoll(Single yaw, Single pitch, Single roll, out Matrix& result);
static public Matrix CreateLookAt(Vector3 cameraPosition, Vector3 cameraTarget, Vector3 cameraUpVector);
static public void CreateLookAt(Vector3& cameraPosition, Vector3& cameraTarget, Vector3& cameraUpVector, out Matrix& result);
static public Matrix CreateOrthographic(Single width, Single height, Single zNearPlane, Single zFarPlane);
static public void CreateOrthographic(Single width, Single height, Single zNearPlane, Single zFarPlane, out Matrix& result);
static public Matrix CreateOrthographicOffCenter(Single left, Single right, Single bottom, Single top, Single zNearPlane, Single zFarPlane);
static public void CreateOrthographicOffCenter(Single left, Single right, Single bottom, Single top, Single zNearPlane, Single zFarPlane, out Matrix& result);
static public Matrix CreatePerspective(Single width, Single height, Single nearPlaneDistance, Single farPlaneDistance);
static public void CreatePerspective(Single width, Single height, Single nearPlaneDistance, Single farPlaneDistance, out Matrix& result);
static public Matrix CreatePerspectiveFieldOfView(Single fieldOfView, Single aspectRatio, Single nearPlaneDistance, Single farPlaneDistance);
static public void CreatePerspectiveFieldOfView(Single fieldOfView, Single aspectRatio, Single nearPlaneDistance, Single farPlaneDistance, out Matrix& result);
static public Matrix CreatePerspectiveOffCenter(Single left, Single right, Single bottom, Single top, Single nearPlaneDistance, Single farPlaneDistance);
static public void CreatePerspectiveOffCenter(Single left, Single right, Single bottom, Single top, Single nearPlaneDistance, Single farPlaneDistance, out Matrix& result);
static public Matrix CreateReflection(Plane value);
static public void CreateReflection(Plane& value, out Matrix& result);
static public Matrix CreateRotationX(Single radians);
static public void CreateRotationX(Single radians, out Matrix& result);
static public Matrix CreateRotationY(Single radians);
static public void CreateRotationY(Single radians, out Matrix& result);
static public Matrix CreateRotationZ(Single radians);
static public void CreateRotationZ(Single radians, out Matrix& result);
static public Matrix CreateScale(Single xScale, Single yScale, Single zScale);
static public void CreateScale(Single xScale, Single yScale, Single zScale, out Matrix& result);
static public Matrix CreateScale(Vector3 scales);
static public void CreateScale(Vector3& scales, out Matrix& result);
static public Matrix CreateScale(Single scale);
static public void CreateScale(Single scale, out Matrix& result);
static public Matrix CreateShadow(Vector3 lightDirection, Plane plane);
static public void CreateShadow(Vector3& lightDirection, Plane& plane, out Matrix& result);
static public Matrix CreateTranslation(Vector3 position);
static public void CreateTranslation(Vector3& position, out Matrix& result);
static public Matrix CreateTranslation(Single xPosition, Single yPosition, Single zPosition);
static public void CreateTranslation(Single xPosition, Single yPosition, Single zPosition, out Matrix& result);
static public Matrix CreateWorld(Vector3 position, Vector3 forward, Vector3 up);
static public void CreateWorld(Vector3& position, Vector3& forward, Vector3& up, out Matrix& result);
public Boolean Decompose(out Vector3& scale, out Quaternion& rotation, out Vector3& translation);
public Single Determinant();
static public Matrix Divide(Matrix matrix1, Matrix matrix2);
static public void Divide(Matrix& matrix1, Matrix& matrix2, out Matrix& result);
static public Matrix Divide(Matrix matrix1, Single divider);
static public void Divide(Matrix& matrix1, Single divider, out Matrix& result);
public virtual Boolean Equals(Matrix other);
public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();
static public Matrix Invert(Matrix matrix);
static public void Invert(Matrix& matrix, out Matrix& result);
static public Matrix Lerp(Matrix matrix1, Matrix matrix2, Single amount);
static public void Lerp(Matrix& matrix1, Matrix& matrix2, Single amount, out Matrix& result);
static public Matrix Multiply(Matrix matrix1, Single scaleFactor);
static public void Multiply(Matrix& matrix1, Single scaleFactor, out Matrix& result);
static public Matrix Multiply(Matrix matrix1, Matrix matrix2);
static public void Multiply(Matrix& matrix1, Matrix& matrix2, out Matrix& result);
static public Matrix Negate(Matrix matrix);
static public void Negate(Matrix& matrix, out Matrix& result);
static public Matrix op_Addition(Matrix matrix1, Matrix matrix2);
static public Matrix op_Division(Matrix matrix1, Matrix matrix2);
static public Matrix op_Division(Matrix matrix1, Single divider);
static public Boolean op_Equality(Matrix matrix1, Matrix matrix2);
static public Boolean op_Inequality(Matrix matrix1, Matrix matrix2);
static public Matrix op_Multiply(Matrix matrix1, Matrix matrix2);
static public Matrix op_Multiply(Matrix matrix, Single scaleFactor);
static public Matrix op_Multiply(Single scaleFactor, Matrix matrix);
static public Matrix op_Subtraction(Matrix matrix1, Matrix matrix2);
static public Matrix op_UnaryNegation(Matrix matrix1);
static public Matrix Subtract(Matrix matrix1, Matrix matrix2);
static public void Subtract(Matrix& matrix1, Matrix& matrix2, out Matrix& result);
public virtual String ToString();
static public Matrix Transform(Matrix value, Quaternion rotation);
static public void Transform(Matrix& value, Quaternion& rotation, out Matrix& result);
static public Matrix Transpose(Matrix matrix);
static public void Transpose(Matrix& matrix, out Matrix& result);

public sealed struct Plane
: ValueType, IEquatable`1<Plane>
public Single Dot(Vector4 value);
public void Dot(Vector4& value, out Single& result);
public Single DotCoordinate(Vector3 value);
public void DotCoordinate(Vector3& value, out Single& result);
public Single DotNormal(Vector3 value);
public void DotNormal(Vector3& value, out Single& result);
public virtual Boolean Equals(Plane other);
public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();
public PlaneIntersectionType Intersects(BoundingBox box);
public void Intersects(BoundingBox& box, out PlaneIntersectionType& result);
public PlaneIntersectionType Intersects(BoundingFrustum frustum);
public PlaneIntersectionType Intersects(BoundingSphere sphere);
public void Intersects(BoundingSphere& sphere, out PlaneIntersectionType& result);
public void Normalize();
static public Plane Normalize(Plane value);
static public void Normalize(Plane& value, out Plane& result);
static public Boolean op_Equality(Plane lhs, Plane rhs);
static public Boolean op_Inequality(Plane lhs, Plane rhs);
public virtual String ToString();
static public Plane Transform(Plane plane, Matrix matrix);
static public void Transform(Plane& plane, Matrix& matrix, out Plane& result);
static public Plane Transform(Plane plane, Quaternion rotation);
static public void Transform(Plane& plane, Quaternion& rotation, out Plane& result);

public sealed enum PlaneIntersectionType
: IComparable, IFormattable, IConvertible
{ Front, Back, Intersecting }

public sealed struct Point	public sealed struct Point
: ValueType, IEquatable`1<Point>	: ValueType, IFormattable
static public Point Zero { get; }
	public Double X { get; set; }
	public Double Y { get; set; }
public virtual Boolean Equals(Point other);	public virtual Boolean Equals(Object o);
public virtual Boolean Equals(Object obj);	public Boolean Equals(Point value);
public virtual Int32 GetHashCode();	public virtual Int32 GetHashCode();
static public Boolean op_Equality(Point a, Point b);	static public Boolean op_Equality(Point point1, Point point2);
static public Boolean op_Inequality(Point a, Point b);	static public Boolean op_Inequality(Point point1, Point point2);
public virtual String ToString();	public virtual String ToString();

	public sealed enum PropertyType
	: IComparable, IFormattable, IConvertible
	{ Empty, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64, Single, Double, Char16, Boolean, String, Inspectable, DateTime, TimeSpan, Guid, Point, Size, Rect, OtherType, UInt8Array, Int16Array, UInt16Array, Int32Array, UInt32Array, Int64Array, UInt64Array, SingleArray, DoubleArray, Char16Array, BooleanArray, StringArray, InspectableArray, DateTimeArray, TimeSpanArray, GuidArray, PointArray, SizeArray, RectArray, OtherTypeArray }

	public sealed class PropertyValue
	: __ComObject, IPropertyValue
	public virtual Boolean IsNumericScalar { get; }
	public virtual PropertyType Type { get; }
	static public Object CreateBoolean(Boolean value);
	static public Object CreateBooleanArray(Boolean value);
	static public Object CreateChar16(Char value);
	static public Object CreateChar16Array(Char value);
	static public Object CreateDateTime(DateTimeOffset value);
	static public Object CreateDateTimeArray(DateTimeOffset value);
	static public Object CreateDouble(Double value);
	static public Object CreateDoubleArray(Double value);
	static public Object CreateEmpty();
	static public Object CreateGuid(Guid value);
	static public Object CreateGuidArray(Guid value);
	static public Object CreateInspectable(Object value);
	static public Object CreateInspectableArray(Object value);
	static public Object CreateInt16(Int16 value);
	static public Object CreateInt16Array(Int16 value);
	static public Object CreateInt32(Int32 value);
	static public Object CreateInt32Array(Int32 value);
	static public Object CreateInt64(Int64 value);
	static public Object CreateInt64Array(Int64 value);
	static public Object CreatePoint(Point value);
	static public Object CreatePointArray(Point value);
	static public Object CreateRect(Rect value);
	static public Object CreateRectArray(Rect value);
	static public Object CreateSingle(Single value);
	static public Object CreateSingleArray(Single value);
	static public Object CreateSize(Size value);
	static public Object CreateSizeArray(Size value);
	static public Object CreateString(String value);
	static public Object CreateStringArray(String value);
	static public Object CreateTimeSpan(TimeSpan value);
	static public Object CreateTimeSpanArray(TimeSpan value);
	static public Object CreateUInt16(UInt16 value);
	static public Object CreateUInt16Array(UInt16 value);
	static public Object CreateUInt32(UInt32 value);
	static public Object CreateUInt32Array(UInt32 value);
	static public Object CreateUInt64(UInt64 value);
	static public Object CreateUInt64Array(UInt64 value);
	static public Object CreateUInt8(Byte value);
	static public Object CreateUInt8Array(Byte value);
	public virtual Boolean GetBoolean();
	public virtual void GetBooleanArray(out Boolean& value);
	public virtual Char GetChar16();
	public virtual void GetChar16Array(out Char& value);
	public virtual DateTimeOffset GetDateTime();
	public virtual void GetDateTimeArray(out DateTimeOffset& value);
	public virtual Double GetDouble();
	public virtual void GetDoubleArray(out Double& value);
	public virtual Guid GetGuid();
	public virtual void GetGuidArray(out Guid& value);
	public virtual Object GetInspectable();
	public virtual void GetInspectableArray(out Object& value);
	public virtual Int16 GetInt16();
	public virtual void GetInt16Array(out Int16& value);
	public virtual Int32 GetInt32();
	public virtual void GetInt32Array(out Int32& value);
	public virtual Int64 GetInt64();
	public virtual void GetInt64Array(out Int64& value);
	public virtual Point GetPoint();
	public virtual void GetPointArray(out Point& value);
	public virtual Rect GetRect();
	public virtual void GetRectArray(out Rect& value);
	public virtual Single GetSingle();
	public virtual void GetSingleArray(out Single& value);
	public virtual Size GetSize();
	public virtual void GetSizeArray(out Size& value);
	public virtual String GetString();
	public virtual void GetStringArray(out String& value);
	public virtual TimeSpan GetTimeSpan();
	public virtual void GetTimeSpanArray(out TimeSpan& value);
	public virtual UInt16 GetUInt16();
	public virtual void GetUInt16Array(out UInt16& value);
	public virtual UInt32 GetUInt32();
	public virtual void GetUInt32Array(out UInt32& value);
	public virtual UInt64 GetUInt64();
	public virtual void GetUInt64Array(out UInt64& value);
	public virtual Byte GetUInt8();
	public virtual void GetUInt8Array(out Byte& value);

public sealed struct Quaternion
: ValueType, IEquatable`1<Quaternion>
static public Quaternion Identity { get; }
static public Quaternion Add(Quaternion quaternion1, Quaternion quaternion2);
static public void Add(Quaternion& quaternion1, Quaternion& quaternion2, out Quaternion& result);
static public Quaternion Concatenate(Quaternion value1, Quaternion value2);
static public void Concatenate(Quaternion& value1, Quaternion& value2, out Quaternion& result);
public void Conjugate();
static public Quaternion Conjugate(Quaternion value);
static public void Conjugate(Quaternion& value, out Quaternion& result);
static public Quaternion CreateFromAxisAngle(Vector3 axis, Single angle);
static public void CreateFromAxisAngle(Vector3& axis, Single angle, out Quaternion& result);
static public Quaternion CreateFromRotationMatrix(Matrix matrix);
static public void CreateFromRotationMatrix(Matrix& matrix, out Quaternion& result);
static public Quaternion CreateFromYawPitchRoll(Single yaw, Single pitch, Single roll);
static public void CreateFromYawPitchRoll(Single yaw, Single pitch, Single roll, out Quaternion& result);
static public Quaternion Divide(Quaternion quaternion1, Quaternion quaternion2);
static public void Divide(Quaternion& quaternion1, Quaternion& quaternion2, out Quaternion& result);
static public Single Dot(Quaternion quaternion1, Quaternion quaternion2);
static public void Dot(Quaternion& quaternion1, Quaternion& quaternion2, out Single& result);
public virtual Boolean Equals(Quaternion other);
public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();
static public Quaternion Inverse(Quaternion quaternion);
static public void Inverse(Quaternion& quaternion, out Quaternion& result);
public Single Length();
public Single LengthSquared();
static public Quaternion Lerp(Quaternion quaternion1, Quaternion quaternion2, Single amount);
static public void Lerp(Quaternion& quaternion1, Quaternion& quaternion2, Single amount, out Quaternion& result);
static public Quaternion Multiply(Quaternion quaternion1, Quaternion quaternion2);
static public void Multiply(Quaternion& quaternion1, Quaternion& quaternion2, out Quaternion& result);
static public Quaternion Multiply(Quaternion quaternion1, Single scaleFactor);
static public void Multiply(Quaternion& quaternion1, Single scaleFactor, out Quaternion& result);
static public Quaternion Negate(Quaternion quaternion);
static public void Negate(Quaternion& quaternion, out Quaternion& result);
public void Normalize();
static public Quaternion Normalize(Quaternion quaternion);
static public void Normalize(Quaternion& quaternion, out Quaternion& result);
static public Quaternion op_Addition(Quaternion quaternion1, Quaternion quaternion2);
static public Quaternion op_Division(Quaternion quaternion1, Quaternion quaternion2);
static public Boolean op_Equality(Quaternion quaternion1, Quaternion quaternion2);
static public Boolean op_Inequality(Quaternion quaternion1, Quaternion quaternion2);
static public Quaternion op_Multiply(Quaternion quaternion1, Quaternion quaternion2);
static public Quaternion op_Multiply(Quaternion quaternion1, Single scaleFactor);
static public Quaternion op_Subtraction(Quaternion quaternion1, Quaternion quaternion2);
static public Quaternion op_UnaryNegation(Quaternion quaternion);
static public Quaternion Slerp(Quaternion quaternion1, Quaternion quaternion2, Single amount);
static public void Slerp(Quaternion& quaternion1, Quaternion& quaternion2, Single amount, out Quaternion& result);
static public Quaternion Subtract(Quaternion quaternion1, Quaternion quaternion2);
static public void Subtract(Quaternion& quaternion1, Quaternion& quaternion2, out Quaternion& result);
public virtual String ToString();

public sealed struct Ray
: ValueType, IEquatable`1<Ray>
public virtual Boolean Equals(Ray other);
public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();
public Nullable`1<Single> Intersects(BoundingBox box);
public void Intersects(BoundingBox& box, out Nullable`1& result);
public Nullable`1<Single> Intersects(BoundingFrustum frustum);
public Nullable`1<Single> Intersects(Plane plane);
public void Intersects(Plane& plane, out Nullable`1& result);
public Nullable`1<Single> Intersects(BoundingSphere sphere);
public void Intersects(BoundingSphere& sphere, out Nullable`1& result);
static public Boolean op_Equality(Ray a, Ray b);
static public Boolean op_Inequality(Ray a, Ray b);
public virtual String ToString();

	public sealed class TypedEventHandler`2<TSender, TResult>
	: MulticastDelegate, ICloneable, ISerializable
	public virtual void Invoke(TSender sender, TResult args);

public sealed struct Vector2
: ValueType, IEquatable`1<Vector2>
static public Vector2 One { get; }
static public Vector2 UnitX { get; }
static public Vector2 UnitY { get; }
static public Vector2 Zero { get; }
static public Vector2 Add(Vector2 value1, Vector2 value2);
static public void Add(Vector2& value1, Vector2& value2, out Vector2& result);
static public Vector2 Barycentric(Vector2 value1, Vector2 value2, Vector2 value3, Single amount1, Single amount2);
static public void Barycentric(Vector2& value1, Vector2& value2, Vector2& value3, Single amount1, Single amount2, out Vector2& result);
static public Vector2 CatmullRom(Vector2 value1, Vector2 value2, Vector2 value3, Vector2 value4, Single amount);
static public void CatmullRom(Vector2& value1, Vector2& value2, Vector2& value3, Vector2& value4, Single amount, out Vector2& result);
static public Vector2 Clamp(Vector2 value1, Vector2 min, Vector2 max);
static public void Clamp(Vector2& value1, Vector2& min, Vector2& max, out Vector2& result);
static public Single Distance(Vector2 value1, Vector2 value2);
static public void Distance(Vector2& value1, Vector2& value2, out Single& result);
static public Single DistanceSquared(Vector2 value1, Vector2 value2);
static public void DistanceSquared(Vector2& value1, Vector2& value2, out Single& result);
static public Vector2 Divide(Vector2 value1, Vector2 value2);
static public void Divide(Vector2& value1, Vector2& value2, out Vector2& result);
static public Vector2 Divide(Vector2 value1, Single divider);
static public void Divide(Vector2& value1, Single divider, out Vector2& result);
static public Single Dot(Vector2 value1, Vector2 value2);
static public void Dot(Vector2& value1, Vector2& value2, out Single& result);
public virtual Boolean Equals(Vector2 other);
public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();
static public Vector2 Hermite(Vector2 value1, Vector2 tangent1, Vector2 value2, Vector2 tangent2, Single amount);
static public void Hermite(Vector2& value1, Vector2& tangent1, Vector2& value2, Vector2& tangent2, Single amount, out Vector2& result);
public Single Length();
public Single LengthSquared();
static public Vector2 Lerp(Vector2 value1, Vector2 value2, Single amount);
static public void Lerp(Vector2& value1, Vector2& value2, Single amount, out Vector2& result);
static public Vector2 Max(Vector2 value1, Vector2 value2);
static public void Max(Vector2& value1, Vector2& value2, out Vector2& result);
static public Vector2 Min(Vector2 value1, Vector2 value2);
static public void Min(Vector2& value1, Vector2& value2, out Vector2& result);
static public Vector2 Multiply(Vector2 value1, Vector2 value2);
static public void Multiply(Vector2& value1, Vector2& value2, out Vector2& result);
static public Vector2 Multiply(Vector2 value1, Single scaleFactor);
static public void Multiply(Vector2& value1, Single scaleFactor, out Vector2& result);
static public Vector2 Negate(Vector2 value);
static public void Negate(Vector2& value, out Vector2& result);
public void Normalize();
static public Vector2 Normalize(Vector2 value);
static public void Normalize(Vector2& value, out Vector2& result);
static public Vector2 op_Addition(Vector2 value1, Vector2 value2);
static public Vector2 op_Division(Vector2 value1, Vector2 value2);
static public Vector2 op_Division(Vector2 value1, Single divider);
static public Boolean op_Equality(Vector2 value1, Vector2 value2);
static public Boolean op_Inequality(Vector2 value1, Vector2 value2);
static public Vector2 op_Multiply(Vector2 value1, Vector2 value2);
static public Vector2 op_Multiply(Vector2 value, Single scaleFactor);
static public Vector2 op_Multiply(Single scaleFactor, Vector2 value);
static public Vector2 op_Subtraction(Vector2 value1, Vector2 value2);
static public Vector2 op_UnaryNegation(Vector2 value);
static public Vector2 Reflect(Vector2 vector, Vector2 normal);
static public void Reflect(Vector2& vector, Vector2& normal, out Vector2& result);
static public Vector2 SmoothStep(Vector2 value1, Vector2 value2, Single amount);
static public void SmoothStep(Vector2& value1, Vector2& value2, Single amount, out Vector2& result);
static public Vector2 Subtract(Vector2 value1, Vector2 value2);
static public void Subtract(Vector2& value1, Vector2& value2, out Vector2& result);
public virtual String ToString();
static public Vector2 Transform(Vector2 position, Matrix matrix);
static public void Transform(Vector2& position, Matrix& matrix, out Vector2& result);
static public Vector2 Transform(Vector2 value, Quaternion rotation);
static public void Transform(Vector2& value, Quaternion& rotation, out Vector2& result);
static public void Transform(Vector2 sourceArray, Matrix& matrix, Vector2[] destinationArray);
static public void Transform(Vector2 sourceArray, Int32 sourceIndex, Matrix& matrix, Vector2[] destinationArray, Int32 destinationIndex, Int32 length);
static public void Transform(Vector2 sourceArray, Quaternion& rotation, Vector2[] destinationArray);
static public void Transform(Vector2 sourceArray, Int32 sourceIndex, Quaternion& rotation, Vector2[] destinationArray, Int32 destinationIndex, Int32 length);
static public Vector2 TransformNormal(Vector2 normal, Matrix matrix);
static public void TransformNormal(Vector2& normal, Matrix& matrix, out Vector2& result);
static public void TransformNormal(Vector2 sourceArray, Matrix& matrix, Vector2[] destinationArray);
static public void TransformNormal(Vector2 sourceArray, Int32 sourceIndex, Matrix& matrix, Vector2[] destinationArray, Int32 destinationIndex, Int32 length);

public sealed struct Vector3
: ValueType, IEquatable`1<Vector3>
static public Vector3 Backward { get; }
static public Vector3 Down { get; }
static public Vector3 Forward { get; }
static public Vector3 Left { get; }
static public Vector3 One { get; }
static public Vector3 Right { get; }
static public Vector3 UnitX { get; }
static public Vector3 UnitY { get; }
static public Vector3 UnitZ { get; }
static public Vector3 Up { get; }
static public Vector3 Zero { get; }
static public Vector3 Add(Vector3 value1, Vector3 value2);
static public void Add(Vector3& value1, Vector3& value2, out Vector3& result);
static public Vector3 Barycentric(Vector3 value1, Vector3 value2, Vector3 value3, Single amount1, Single amount2);
static public void Barycentric(Vector3& value1, Vector3& value2, Vector3& value3, Single amount1, Single amount2, out Vector3& result);
static public Vector3 CatmullRom(Vector3 value1, Vector3 value2, Vector3 value3, Vector3 value4, Single amount);
static public void CatmullRom(Vector3& value1, Vector3& value2, Vector3& value3, Vector3& value4, Single amount, out Vector3& result);
static public Vector3 Clamp(Vector3 value1, Vector3 min, Vector3 max);
static public void Clamp(Vector3& value1, Vector3& min, Vector3& max, out Vector3& result);
static public Vector3 Cross(Vector3 vector1, Vector3 vector2);
static public void Cross(Vector3& vector1, Vector3& vector2, out Vector3& result);
static public Single Distance(Vector3 value1, Vector3 value2);
static public void Distance(Vector3& value1, Vector3& value2, out Single& result);
static public Single DistanceSquared(Vector3 value1, Vector3 value2);
static public void DistanceSquared(Vector3& value1, Vector3& value2, out Single& result);
static public Vector3 Divide(Vector3 value1, Vector3 value2);
static public void Divide(Vector3& value1, Vector3& value2, out Vector3& result);
static public Vector3 Divide(Vector3 value1, Single value2);
static public void Divide(Vector3& value1, Single value2, out Vector3& result);
static public Single Dot(Vector3 vector1, Vector3 vector2);
static public void Dot(Vector3& vector1, Vector3& vector2, out Single& result);
public virtual Boolean Equals(Vector3 other);
public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();
static public Vector3 Hermite(Vector3 value1, Vector3 tangent1, Vector3 value2, Vector3 tangent2, Single amount);
static public void Hermite(Vector3& value1, Vector3& tangent1, Vector3& value2, Vector3& tangent2, Single amount, out Vector3& result);
public Single Length();
public Single LengthSquared();
static public Vector3 Lerp(Vector3 value1, Vector3 value2, Single amount);
static public void Lerp(Vector3& value1, Vector3& value2, Single amount, out Vector3& result);
static public Vector3 Max(Vector3 value1, Vector3 value2);
static public void Max(Vector3& value1, Vector3& value2, out Vector3& result);
static public Vector3 Min(Vector3 value1, Vector3 value2);
static public void Min(Vector3& value1, Vector3& value2, out Vector3& result);
static public Vector3 Multiply(Vector3 value1, Vector3 value2);
static public void Multiply(Vector3& value1, Vector3& value2, out Vector3& result);
static public Vector3 Multiply(Vector3 value1, Single scaleFactor);
static public void Multiply(Vector3& value1, Single scaleFactor, out Vector3& result);
static public Vector3 Negate(Vector3 value);
static public void Negate(Vector3& value, out Vector3& result);
public void Normalize();
static public Vector3 Normalize(Vector3 value);
static public void Normalize(Vector3& value, out Vector3& result);
static public Vector3 op_Addition(Vector3 value1, Vector3 value2);
static public Vector3 op_Division(Vector3 value1, Vector3 value2);
static public Vector3 op_Division(Vector3 value, Single divider);
static public Boolean op_Equality(Vector3 value1, Vector3 value2);
static public Boolean op_Inequality(Vector3 value1, Vector3 value2);
static public Vector3 op_Multiply(Single scaleFactor, Vector3 value);
static public Vector3 op_Multiply(Vector3 value1, Vector3 value2);
static public Vector3 op_Multiply(Vector3 value, Single scaleFactor);
static public Vector3 op_Subtraction(Vector3 value1, Vector3 value2);
static public Vector3 op_UnaryNegation(Vector3 value);
static public Vector3 Reflect(Vector3 vector, Vector3 normal);
static public void Reflect(Vector3& vector, Vector3& normal, out Vector3& result);
static public Vector3 SmoothStep(Vector3 value1, Vector3 value2, Single amount);
static public void SmoothStep(Vector3& value1, Vector3& value2, Single amount, out Vector3& result);
static public Vector3 Subtract(Vector3 value1, Vector3 value2);
static public void Subtract(Vector3& value1, Vector3& value2, out Vector3& result);
public virtual String ToString();
static public Vector3 Transform(Vector3 position, Matrix matrix);
static public void Transform(Vector3& position, Matrix& matrix, out Vector3& result);
static public Vector3 Transform(Vector3 value, Quaternion rotation);
static public void Transform(Vector3& value, Quaternion& rotation, out Vector3& result);
static public void Transform(Vector3 sourceArray, Matrix& matrix, Vector3[] destinationArray);
static public void Transform(Vector3 sourceArray, Int32 sourceIndex, Matrix& matrix, Vector3[] destinationArray, Int32 destinationIndex, Int32 length);
static public void Transform(Vector3 sourceArray, Quaternion& rotation, Vector3[] destinationArray);
static public void Transform(Vector3 sourceArray, Int32 sourceIndex, Quaternion& rotation, Vector3[] destinationArray, Int32 destinationIndex, Int32 length);
static public Vector3 TransformNormal(Vector3 normal, Matrix matrix);
static public void TransformNormal(Vector3& normal, Matrix& matrix, out Vector3& result);
static public void TransformNormal(Vector3 sourceArray, Matrix& matrix, Vector3[] destinationArray);
static public void TransformNormal(Vector3 sourceArray, Int32 sourceIndex, Matrix& matrix, Vector3[] destinationArray, Int32 destinationIndex, Int32 length);

public sealed struct Vector4
: ValueType, IEquatable`1<Vector4>
static public Vector4 One { get; }
static public Vector4 UnitW { get; }
static public Vector4 UnitX { get; }
static public Vector4 UnitY { get; }
static public Vector4 UnitZ { get; }
static public Vector4 Zero { get; }
static public Vector4 Add(Vector4 value1, Vector4 value2);
static public void Add(Vector4& value1, Vector4& value2, out Vector4& result);
static public Vector4 Barycentric(Vector4 value1, Vector4 value2, Vector4 value3, Single amount1, Single amount2);
static public void Barycentric(Vector4& value1, Vector4& value2, Vector4& value3, Single amount1, Single amount2, out Vector4& result);
static public Vector4 CatmullRom(Vector4 value1, Vector4 value2, Vector4 value3, Vector4 value4, Single amount);
static public void CatmullRom(Vector4& value1, Vector4& value2, Vector4& value3, Vector4& value4, Single amount, out Vector4& result);
static public Vector4 Clamp(Vector4 value1, Vector4 min, Vector4 max);
static public void Clamp(Vector4& value1, Vector4& min, Vector4& max, out Vector4& result);
static public Single Distance(Vector4 value1, Vector4 value2);
static public void Distance(Vector4& value1, Vector4& value2, out Single& result);
static public Single DistanceSquared(Vector4 value1, Vector4 value2);
static public void DistanceSquared(Vector4& value1, Vector4& value2, out Single& result);
static public Vector4 Divide(Vector4 value1, Vector4 value2);
static public void Divide(Vector4& value1, Vector4& value2, out Vector4& result);
static public Vector4 Divide(Vector4 value1, Single divider);
static public void Divide(Vector4& value1, Single divider, out Vector4& result);
static public Single Dot(Vector4 vector1, Vector4 vector2);
static public void Dot(Vector4& vector1, Vector4& vector2, out Single& result);
public virtual Boolean Equals(Vector4 other);
public virtual Boolean Equals(Object obj);
public virtual Int32 GetHashCode();
static public Vector4 Hermite(Vector4 value1, Vector4 tangent1, Vector4 value2, Vector4 tangent2, Single amount);
static public void Hermite(Vector4& value1, Vector4& tangent1, Vector4& value2, Vector4& tangent2, Single amount, out Vector4& result);
public Single Length();
public Single LengthSquared();
static public Vector4 Lerp(Vector4 value1, Vector4 value2, Single amount);
static public void Lerp(Vector4& value1, Vector4& value2, Single amount, out Vector4& result);
static public Vector4 Max(Vector4 value1, Vector4 value2);
static public void Max(Vector4& value1, Vector4& value2, out Vector4& result);
static public Vector4 Min(Vector4 value1, Vector4 value2);
static public void Min(Vector4& value1, Vector4& value2, out Vector4& result);
static public Vector4 Multiply(Vector4 value1, Vector4 value2);
static public void Multiply(Vector4& value1, Vector4& value2, out Vector4& result);
static public Vector4 Multiply(Vector4 value1, Single scaleFactor);
static public void Multiply(Vector4& value1, Single scaleFactor, out Vector4& result);
static public Vector4 Negate(Vector4 value);
static public void Negate(Vector4& value, out Vector4& result);
public void Normalize();
static public Vector4 Normalize(Vector4 vector);
static public void Normalize(Vector4& vector, out Vector4& result);
static public Vector4 op_Addition(Vector4 value1, Vector4 value2);
static public Vector4 op_Division(Vector4 value1, Vector4 value2);
static public Vector4 op_Division(Vector4 value1, Single divider);
static public Boolean op_Equality(Vector4 value1, Vector4 value2);
static public Boolean op_Inequality(Vector4 value1, Vector4 value2);
static public Vector4 op_Multiply(Vector4 value1, Vector4 value2);
static public Vector4 op_Multiply(Vector4 value1, Single scaleFactor);
static public Vector4 op_Multiply(Single scaleFactor, Vector4 value1);
static public Vector4 op_Subtraction(Vector4 value1, Vector4 value2);
static public Vector4 op_UnaryNegation(Vector4 value);
static public Vector4 SmoothStep(Vector4 value1, Vector4 value2, Single amount);
static public void SmoothStep(Vector4& value1, Vector4& value2, Single amount, out Vector4& result);
static public Vector4 Subtract(Vector4 value1, Vector4 value2);
static public void Subtract(Vector4& value1, Vector4& value2, out Vector4& result);
public virtual String ToString();
static public Vector4 Transform(Vector2 position, Matrix matrix);
static public void Transform(Vector2& position, Matrix& matrix, out Vector4& result);
static public Vector4 Transform(Vector3 position, Matrix matrix);
static public void Transform(Vector3& position, Matrix& matrix, out Vector4& result);
static public Vector4 Transform(Vector4 vector, Matrix matrix);
static public void Transform(Vector4& vector, Matrix& matrix, out Vector4& result);
static public Vector4 Transform(Vector2 value, Quaternion rotation);
static public void Transform(Vector2& value, Quaternion& rotation, out Vector4& result);
static public Vector4 Transform(Vector3 value, Quaternion rotation);
static public void Transform(Vector3& value, Quaternion& rotation, out Vector4& result);
static public Vector4 Transform(Vector4 value, Quaternion rotation);
static public void Transform(Vector4& value, Quaternion& rotation, out Vector4& result);
static public void Transform(Vector4 sourceArray, Matrix& matrix, Vector4[] destinationArray);
static public void Transform(Vector4 sourceArray, Int32 sourceIndex, Matrix& matrix, Vector4[] destinationArray, Int32 destinationIndex, Int32 length);
static public void Transform(Vector4 sourceArray, Quaternion& rotation, Vector4[] destinationArray);
static public void Transform(Vector4 sourceArray, Int32 sourceIndex, Quaternion& rotation, Vector4[] destinationArray, Int32 destinationIndex, Int32 length);