public void DrawToDynamicQueue(ref CoordinateSpace target,
ref FillType type,
ref Colour colour,
ref Vertex2D[] vertices,
ref int[] indices,
ref ulong texture0,
ref ulong texture1,
ref TextureCoordinateMode texMode0,
ref TextureCoordinateMode texMode1,
ref float depth,
ref int layer,
bool validate = false)
{
AddToQueue(_queues.DynamicQueue.Queue,
ref target,
ref type,
ref colour,
ref vertices,
ref indices,
ref texture0,
ref texture1,
ref texMode0,
ref texMode1,
ref depth,
ref layer,
ref validate);
}
public Vector3 GetLinearVelocity
(CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
Vector3 globalResult = _rigidBody.WrappedRigidBody.LinearVelocity.ToStandard();
return(FromGlobalToCorrectSpace(velocitySpace, globalResult));
}
public TextureFixin( string name
, string textureName
, bool treatAsAssetUri = true
, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace )
: this(name, textureName, null, treatAsAssetUri, coordinateSpace)
{
}
public TextureFixin(string name
, string textureName
, bool treatAsAssetUri = true
, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace)
: this(name, textureName, null, treatAsAssetUri, coordinateSpace)
{
}
public void SetPose(Matrix4x4 pose, CoordinateSpace space = CoordinateSpace.Local)
{
if (space == CoordinateSpace.Global)
_rigidBody.WrappedRigidBody.PoseCenterOfMass = pose.ToDigitalRune();
else
_rigidBody.WrappedRigidBody.MassFrame.Pose = pose.ToDigitalRune();
}
public Vector3 GetLinearVelocity(CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
Vector3 result = _rigidBody.WrappedRigidBody.LinearVelocity.ToStandard();
return velocitySpace == CoordinateSpace.Global
? result
: _rigidBody.Pose.ToLocalPosition(result);
}
public void DrawDistortion(ulong stage,
CoordinateSpace target,
FillType type,
Vertex2D[] vertices,
int[] indices,
Colour colour,
ulong texture0,
ulong texture1,
TextureCoordinateMode texWrap0,
TextureCoordinateMode texWrap1,
float intensity,
bool validate = false)
{
var request = new DistortionDrawRequest
{
CoordinateSpace = target,
FillType = type,
Vertices = vertices,
Indices = indices,
Colour = new Colour(colour.R * intensity,
colour.G * intensity,
colour.B * intensity,
colour.A * intensity),
Texture0 = WrapTextureId(texture0),
Texture1 = WrapTextureId(texture1),
TextureWrap0 = texWrap0,
TextureWrap1 = texWrap1
};
DrawDistortion(stage, ref request, validate);
}
/// <summary>
/// Set the position of this form.
/// </summary>
/// <param name="position"></param>
/// <param name="coordinateSpace"></param>
public virtual void SetPosition(Vector2 position, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace)
{
switch (coordinateSpace)
{
case CoordinateSpace.TargetSpace:
TargetPosition = position;
break;
case CoordinateSpace.ScreenSpace:
ScreenPosition = position;
break;
case CoordinateSpace.RelativeTargetSpace:
RelativeTargetPosition = position;
break;
case CoordinateSpace.WorldSpace:
throw new FormException(
String.Format(
"Cannot set the WorldPosition on PositionalForm '{0}'.",
Anonymous ? (object)this : Name));
default:
throw new FormException(String.Format("Unknown CoordinateSpace '{0}'.", coordinateSpace));
}
}
public void DrawString(ulong stage,
CoordinateSpace target,
string text,
Colour colour,
float fontSize,
Vector2 position,
TextJustify justify,
float depth,
int layer,
bool usKerningsWhereAvaliable = true)
{
var fntFamily = _fontManager.SystemFont;
DrawString(stage,
ref target,
ref text,
colour,
ref fontSize,
ref position,
ref justify,
ref depth,
ref layer,
fntFamily,
ref usKerningsWhereAvaliable);
}
public void DrawString(IDrawStage stage,
CoordinateSpace target,
string text,
Colour colour,
float fontSize,
Vector2 position,
TextJustify justify,
float depth,
int layer,
IFont font = null,
bool usKerningsWhereAvaliable = true)
{
var fntFamily = font == null ? _fontManager.SystemFont : _fontManager.RetrieveFont(font.Id);
DrawString(stage.Id,
ref target,
ref text,
colour,
ref fontSize,
ref position,
ref justify,
ref depth,
ref layer,
fntFamily,
ref usKerningsWhereAvaliable);
}
public void Draw(ulong stage,
CoordinateSpace target,
FillType type,
Vertex2D[] vertices,
int[] indices,
Colour colour,
ulong texture0,
ulong texture1,
TextureCoordinateMode texWrap0,
TextureCoordinateMode texWrap1,
float depth,
int layer,
bool validate = false)
{
var request = new DrawRequest
{
CoordinateSpace = target,
FillType = type,
Vertices = vertices,
Indices = indices,
Colour = colour,
Texture0 = WrapTextureId(texture0),
Texture1 = WrapTextureId(texture1),
TextureWrap0 = texWrap0,
TextureWrap1 = texWrap1,
Depth = depth,
Layer = layer
};
Draw(stage, ref request, validate);
}
public MotionClonerParam(bool worldOffset, bool localOffset, CoordinateSpace masterSpace, CoordinateSpace localSpace)
{
applyWorldOffset = worldOffset;
applyLocalOffset = localOffset;
masterSpace = CoordinateSpace.World;
localSpace = CoordinateSpace.World;
}
public static void GenerateSpaceTranslations(
NeededCoordinateSpace neededSpaces,
InterpolatorType type,
CoordinateSpace from,
InputType inputType,
ShaderStringBuilder pixelShader,
Dimension dimension)
{
if ((neededSpaces & NeededCoordinateSpace.Object) > 0 && from != CoordinateSpace.Object)
{
pixelShader.AppendLine("float{0} {1} = {2};", DimensionToString(dimension),
CoordinateSpace.Object.ToVariableName(type), ConvertBetweenSpace(from.ToVariableName(type), from, CoordinateSpace.Object, inputType, from));
}
if ((neededSpaces & NeededCoordinateSpace.World) > 0 && from != CoordinateSpace.World)
{
pixelShader.AppendLine("float{0} {1} = {2};", DimensionToString(dimension),
CoordinateSpace.World.ToVariableName(type), ConvertBetweenSpace(from.ToVariableName(type), from, CoordinateSpace.World, inputType, from));
}
if ((neededSpaces & NeededCoordinateSpace.View) > 0 && from != CoordinateSpace.View)
{
pixelShader.AppendLine("float{0} {1} = {2};", DimensionToString(dimension),
CoordinateSpace.View.ToVariableName(type),
ConvertBetweenSpace(from.ToVariableName(type), from, CoordinateSpace.View, inputType, from));
}
if ((neededSpaces & NeededCoordinateSpace.Tangent) > 0 && from != CoordinateSpace.Tangent)
{
pixelShader.AppendLine("float{0} {1} = {2};", DimensionToString(dimension),
CoordinateSpace.Tangent.ToVariableName(type),
ConvertBetweenSpace(from.ToVariableName(type), from, CoordinateSpace.Tangent, inputType, from));
}
}
public Vector3 GetVelocity(Vector3 position, CoordinateSpace positionSpace = CoordinateSpace.Global, CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
Vector3 result = positionSpace == CoordinateSpace.Global
? _rigidBody.WrappedActor.GetPointVelocity(position.ToPhysX()).ToStandard()
: _rigidBody.WrappedActor.GetLocalPointVelocity(position.ToPhysX()).ToStandard();
return ToCorrectSpace(velocitySpace, result);
}
public Vector3 GetVelocity(Vector3 position, CoordinateSpace positionSpace = CoordinateSpace.Global, CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
Vector3 globalResult = positionSpace == CoordinateSpace.Global
? _rigidBody.WrappedRigidBody.GetVelocityOfWorldPoint(position.ToDigitalRune()).ToStandard()
: _rigidBody.WrappedRigidBody.GetVelocityOfLocalPoint(position.ToDigitalRune()).ToStandard();
return FromGlobalToCorrectSpace(velocitySpace, globalResult);
}
/// <summary>
/// Import an STL file.
/// </summary>
/// <param name="path">The path to load STL file from.</param>
/// <returns></returns>
public static Mesh[] Import(string path, CoordinateSpace space = CoordinateSpace.Right, UpAxis axis = UpAxis.Y, bool smooth = false, IndexFormat indexFormat = IndexFormat.UInt16)
{
IEnumerable <Facet> facets = null;
if (IsBinary(path))
{
try
{
facets = ImportBinary(path);
}
catch (System.Exception e)
{
UnityEngine.Debug.LogWarning(string.Format("Failed importing mesh at path {0}.\n{1}", path, e.ToString()));
return(null);
}
}
else
{
facets = ImportAscii(path);
}
if (smooth)
{
return(ImportSmoothNormals(facets, space, axis, indexFormat));
}
return(ImportHardNormals(facets, space, axis, indexFormat));
}
public Rectangle TransformRectangle(Rectangle rect, CoordinateSpace dest = CoordinateSpace.Page, CoordinateSpace source = CoordinateSpace.Device)
{
Point[] points = new Point[] { rect.Location, new Point(rect.Width, rect.Height) };
Graph.TransformPoints(dest, source, points);
return(new Rectangle(points[0], new Size(points[1].X, points[1].Y)));
}
public Size TransformSize(Size size, CoordinateSpace dest = CoordinateSpace.Page, CoordinateSpace source = CoordinateSpace.Device)
{
Point[] points = new Point[] { Point.Empty, new Point(size.Width, size.Height) };
Graph.TransformPoints(dest, source, points);
return(new Size(points[1].X, points[1].Y));
}
public Matrix4x4 GetPose(CoordinateSpace space = CoordinateSpace.Local)
{
if (space == CoordinateSpace.Global)
return _rigidBody.WrappedRigidBody.PoseCenterOfMass.ToStandard();
else
return _rigidBody.WrappedRigidBody.MassFrame.Pose.ToStandard();
}
public Point TransformPoint(Point point, CoordinateSpace dest = CoordinateSpace.Page, CoordinateSpace source = CoordinateSpace.Device)
{
Point[] points = new Point[] { point };
Graph.TransformPoints(dest, source, points);
return(points[0]);
}
public Matrix4x4 GetPose(CoordinateSpace space = CoordinateSpace.Local)
{
if (space == CoordinateSpace.Local)
return _rigidBody.WrappedActor.CenterOfMassLocalPose.ToStandard();
else
return _rigidBody.WrappedActor.CenterOfMassGlobalPose.ToStandard();
}
public Vector3 GetLinearVelocity(CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
Vector3 result = _rigidBody.WrappedRigidBody.LinearVelocity.ToStandard();
return(velocitySpace == CoordinateSpace.Global
? result
: _rigidBody.Pose.ToLocalPosition(result));
}
public void ApplyLinearImpulse(Vector3 impulse, CoordinateSpace impulseSpace = CoordinateSpace.Global)
{
if (impulseSpace == CoordinateSpace.Local)
{
impulse = _rigidBody.Pose.ToGlobalDirection(impulse);
}
_rigidBody.WrappedRigidBody.ApplyLinearImpulse(impulse.ToDigitalRune());
}
public void AddTorque(Vector3 torque, CoordinateSpace torqueSpace = CoordinateSpace.Global)
{
if (torqueSpace == CoordinateSpace.Local)
{
torque = _rigidBody.Pose.ToGlobalDirection(torque);
}
_rigidBody.WrappedRigidBody.AddTorque(torque.ToDigitalRune());
}
public void AddForce(Vector3 force, CoordinateSpace forceSpace = CoordinateSpace.Global)
{
if (forceSpace == CoordinateSpace.Local)
{
force = _rigidBody.Pose.ToGlobalDirection(force);
}
_rigidBody.WrappedRigidBody.AddForce(force.ToDigitalRune());
}
public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts)
{
if (pts == null)
{
throw new ArgumentNullException("pts");
}
throw new NotImplementedException();
}
public TextureFixin( string name
, string textureName
, PositionalForm form
, bool treatAsAssetUri = true
, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace )
: this(name, AssetLoader.Load<Texture2D>(textureName, treatAsAssetUri), form, coordinateSpace)
{
}
public void SetPose(Matrix4x4 pose, CoordinateSpace space = CoordinateSpace.Local)
{
if (space == CoordinateSpace.Local)
_rigidBody.WrappedActor.SetCenterOfMassOffsetLocalPose(pose.ToPhysX());
else
_rigidBody.WrappedActor.SetCenterOfMassOffsetGlobalPose(pose.ToPhysX());
}
public void AddForce(Vector3 force, CoordinateSpace forceSpace = CoordinateSpace.Global)
{
if (forceSpace == CoordinateSpace.Local)
{
force = _rigidBody.Pose.ToGlobalDirection(force);
}
_rigidBody.WrappedActor.AddForce(force.ToPhysX(), ForceMode.Force);
}
public TextureFixin(string name
, string textureName
, PositionalForm form
, bool treatAsAssetUri = true
, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace)
: this(name, AssetLoader.Load <Texture2D>(textureName, treatAsAssetUri), form, coordinateSpace)
{
}
public void ApplyLinearImpulse(Vector3 impulse, CoordinateSpace impulseSpace = CoordinateSpace.Global)
{
if (impulseSpace == CoordinateSpace.Local)
{
impulse = _rigidBody.Pose.ToGlobalDirection(impulse);
}
_rigidBody.WrappedActor.AddForce(impulse.ToPhysX(), ForceMode.Impulse);
}
/// <summary>
/// Get the position of this form in the given coordinate space.
/// </summary>
/// <param name="coordinateSpace"></param>
/// <returns></returns>
public sealed override Vector2 GetPosition(CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace)
{
if (coordinateSpace == CoordinateSpace.WorldSpace)
{
return(WorldPosition);
}
return(base.GetPosition(coordinateSpace));
}
public static string GenerateTangentTransform(ShaderStringBuilder sb, CoordinateSpace tangentTransformSpace)
{
sb.AddLine("$precision3x3 tangentTransform = $precision3x3(IN.",
tangentTransformSpace.ToString(), "SpaceTangent, IN.",
tangentTransformSpace.ToString(), "SpaceBiTangent, IN.",
tangentTransformSpace.ToString(), "SpaceNormal);");
return("tangentTransform");
}
public void SetAngularVelocity(Vector3 velocity, CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
if (velocitySpace == CoordinateSpace.Local)
{
velocity = _rigidBody.Pose.ToGlobalDirection(velocity);
}
_rigidBody.WrappedActor.AngularVelocity = velocity.ToPhysX();
}
public void SetLinearVelocity(Vector3 velocity, CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
if (velocitySpace == CoordinateSpace.Local)
{
velocity = _rigidBody.Pose.ToGlobalDirection(velocity);
}
_rigidBody.WrappedRigidBody.LinearVelocity = velocity.ToDigitalRune();
}
public Vector3 GetVelocity(Vector3 position, CoordinateSpace positionSpace = CoordinateSpace.Global, CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
Vector3 globalResult = positionSpace == CoordinateSpace.Global
? _rigidBody.WrappedRigidBody.GetVelocityOfWorldPoint(position.ToDigitalRune()).ToStandard()
: _rigidBody.WrappedRigidBody.GetVelocityOfLocalPoint(position.ToDigitalRune()).ToStandard();
return(FromGlobalToCorrectSpace(velocitySpace, globalResult));
}
public SpaceTransform(CoordinateSpace from, CoordinateSpace to, ConversionType type, bool normalize = false, int version = kLatestVersion)
{
this.from = from;
this.to = to;
this.type = type;
this.normalize = normalize;
this.version = version;
}
public Vector3 GetVelocity(Vector3 position, CoordinateSpace positionSpace = CoordinateSpace.Global, CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
Vector3 result = positionSpace == CoordinateSpace.Global
? _rigidBody.WrappedActor.GetPointVelocity(position.ToPhysX()).ToStandard()
: _rigidBody.WrappedActor.GetLocalPointVelocity(position.ToPhysX()).ToStandard();
return(ToCorrectSpace(velocitySpace, result));
}
public void AddTorque(Vector3 torque, CoordinateSpace torqueSpace = CoordinateSpace.Global)
{
if (torqueSpace == CoordinateSpace.Local)
{
torque = _rigidBody.Pose.ToGlobalDirection(torque);
}
_rigidBody.WrappedActor.AddTorque(torque.ToPhysX(), ForceMode.Force);
}
/// <summary>
/// Space the given objects horizontally, starting at the given initial position and
/// with the given amount of space between each object.
/// </summary>
/// <param name="spacing"></param>
/// <param name="initialPosition"></param>
/// <param name="direction"></param>
/// <param name="coordinateSpace"></param>
/// <param name="positionals"></param>
public static void SpaceHorizontally( float spacing
, Vector2 initialPosition
, HorizontalSpacingDirection direction = HorizontalSpacingDirection.Left
, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace
, params IPositional[] positionals )
{
Vector2 dir = new Vector2(1, 0) * (direction == HorizontalSpacingDirection.Right ? 1 : -1);
SpaceInDirection(spacing, initialPosition, dir, coordinateSpace, positionals);
}
public Vector3 GetVelocity(Vector3 position, CoordinateSpace positionSpace = CoordinateSpace.Global, CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
Vector3 result = positionSpace == CoordinateSpace.Global
? _rigidBody.WrappedRigidBody.GetVelocityOfWorldPoint(position.ToDigitalRune()).ToStandard()
: _rigidBody.WrappedRigidBody.GetVelocityOfLocalPoint(position.ToDigitalRune()).ToStandard();
return velocitySpace == CoordinateSpace.Global
? result
: _rigidBody.Pose.ToLocalPosition(result);
}
public TextureFixin( string name
, Texture2D texture
, PositionalForm form
, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace )
: base(name, form)
{
Texture = texture;
RequiredRenderer += RenderTexture;
}
/// <summary>
/// Space the given objects using the given AbstractLayoutSpacingProvider and the initial position.
/// </summary>
/// <param name="spacer"></param>
/// <param name="initialPosition"></param>
/// <param name="coordinateSpace"></param>
/// <param name="positionals"></param>
public static void Space( AbstractLayoutSpacingProvider spacer
, Vector2 initialPosition
, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace
, params IPositional[] positionals )
{
var index = 0;
var total = positionals.Length;
foreach (var positional in positionals)
{
var position = spacer.GetPositionOf(index, total, initialPosition);
positional.SetPosition(position, coordinateSpace);
index++;
}
}
internal static RectangleF transformRect(Graphics g,
RectangleF r, CoordinateSpace destSpace, CoordinateSpace srcSpace)
{
PointF[] pts = new PointF[4];
// get the corner points
pts[0].X = r.Left;
pts[0].Y = r.Top;
pts[1].X = r.Right;
pts[1].Y = r.Top;
pts[2].X = r.Right;
pts[2].Y = r.Bottom;
pts[3].X = r.Left;
pts[3].Y = r.Bottom;
// get the device coordinates
g.TransformPoints(destSpace, srcSpace, pts);
// return rectangle in world coordinates
return RectangleF.FromLTRB(pts[0].X, pts[0].Y, pts[2].X, pts[2].Y);
}
public void AddForce(Vector3 force, CoordinateSpace forceSpace = CoordinateSpace.Global)
{
if (forceSpace == CoordinateSpace.Local) force = _rigidBody.Pose.ToGlobalDirection(force);
_rigidBody.WrappedRigidBody.AddForce(force.ToDigitalRune());
}
public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point [] pts)
{
if (pts == null)
throw new ArgumentNullException ("pts");
Matrix transform = new Matrix();
ConversionHelpers.GetGraphicsTransform (this, destSpace, srcSpace, ref transform);
transform.TransformPoints (pts);
}
public void AddTorque(Vector3 torque, CoordinateSpace torqueSpace = CoordinateSpace.Global)
{
if (torqueSpace == CoordinateSpace.Local) torque = _rigidBody.Pose.ToGlobalDirection(torque);
_rigidBody.WrappedRigidBody.AddTorque(torque.ToDigitalRune());
}
public void ApplyImpulse(Vector3 impulse, Vector3 position, CoordinateSpace impulseSpace = CoordinateSpace.Global, CoordinateSpace positionSpace = CoordinateSpace.Global)
{
if (impulseSpace == CoordinateSpace.Local) impulse = _rigidBody.Pose.ToGlobalDirection(impulse);
if (positionSpace == CoordinateSpace.Local) position = _rigidBody.Pose.ToGlobalPosition(position);
_rigidBody.WrappedRigidBody.ApplyImpulse(impulse.ToDigitalRune(), position.ToDigitalRune());
}
public void ApplyLinearImpulse(Vector3 impulse, CoordinateSpace impulseSpace = CoordinateSpace.Global)
{
if (impulseSpace == CoordinateSpace.Local) impulse = _rigidBody.Pose.ToGlobalDirection(impulse);
_rigidBody.WrappedRigidBody.ApplyLinearImpulse(impulse.ToDigitalRune());
}
/// <summary>
/// Space the given objects in the given direction, starting at the given initial position
/// and with the given amount of space between each object.
/// </summary>
/// <param name="spacing"></param>
/// <param name="initialPosition"></param>
/// <param name="direction"></param>
/// <param name="coordinateSpace"></param>
/// <param name="positionals"></param>
public static void SpaceInDirection( float spacing
, Vector2 initialPosition
, Vector2 direction
, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace
, params IPositional[] positionals )
{
var delta = spacing * direction;
var position = initialPosition;
foreach (var positional in positionals)
{
positional.SetPosition(position, coordinateSpace);
position += delta;
}
}
/// <summary>
/// Space the given objects vertically, starting at the given initial position and
/// with the given amount of space between each object.
/// </summary>
/// <param name="spacing"></param>
/// <param name="initialPosition"></param>
/// <param name="direction"></param>
/// <param name="coordinateSpace"></param>
/// <param name="positionals"></param>
public static void SpaceVertically( float spacing
, Vector2 initialPosition
, VerticalSpacingDirection direction = VerticalSpacingDirection.Down
, CoordinateSpace coordinateSpace = CoordinateSpace.TargetSpace
, params IPositional[] positionals )
{
// NOTE: Should this really be "world down" (i.e. decreasing the y coordinates), which is
// visually moving up, or "visual down" (i.e. increasing the y coordinate)?
Vector2 dir = new Vector2(0, 1) * (direction == VerticalSpacingDirection.Down ? 1 : -1);
SpaceInDirection(spacing, initialPosition, dir, coordinateSpace, positionals);
}
/// <summary>
/// Not implemented.
/// </summary>
public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, Point[] pts)
{
throw new SvgGdiNotImpl("TransformPoints (CoordinateSpace destSpace, CoordinateSpace srcSpace, Point[] pts)");
}
public InternalLineDrawer(LineDrawerConfig config)
: base(config)
{
_config = config;
config.Cleared += Config_Cleared;
_persistentVertices3D = new VertexPositionColor[MaxLineCount * 2];
_persistentVertices2D = new VertexPositionColor[MaxLineCount * 2];
_singleFrameVertices2D = new VertexPositionColor[MaxLineCount * 2];
_singleFrameVertices3D = new VertexPositionColor[MaxLineCount * 2];
CoordinateSpace = CoordinateSpace.ScreenSpace;
_freeSpots3D = new Queue<int>();
_freeSpots2D = new Queue<int>();
}
internal static extern Status GdipTransformPointsI(IntPtr graphics, CoordinateSpace destSpace,
CoordinateSpace srcSpace, IntPtr points, int count);
public void TransformPoints(CoordinateSpace destSpace,
CoordinateSpace srcSpace,
Point[] pts) {
if (pts == null){
throw new ArgumentNullException("pts");
}
IntPtr buf = SafeNativeMethods.Gdip.ConvertPointToMemory(pts);
int status = SafeNativeMethods.Gdip.GdipTransformPointsI(new HandleRef(this, this.NativeGraphics), unchecked((int)destSpace),
unchecked((int)srcSpace), buf, pts.Length);
try {
if (status != SafeNativeMethods.Gdip.Ok) {
throw SafeNativeMethods.Gdip.StatusException(status);
}
Point[] newPts = SafeNativeMethods.Gdip.ConvertGPPOINTArray(buf, pts.Length);
for (int i=0; i<pts.Length; i++) {
pts[i] = newPts[i];
}
}
finally {
Marshal.FreeHGlobal(buf);
}
}
public void SetLinearVelocity(Vector3 velocity, CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
if (velocitySpace == CoordinateSpace.Local) velocity = _rigidBody.Pose.ToGlobalDirection(velocity);
_rigidBody.WrappedRigidBody.LinearVelocity = velocity.ToDigitalRune();
}
public Vector3 GetLinearVelocity
(CoordinateSpace velocitySpace = CoordinateSpace.Global)
{
Vector3 globalResult = _rigidBody.WrappedRigidBody.LinearVelocity.ToStandard();
return FromGlobalToCorrectSpace(velocitySpace, globalResult);
}
public void AddForce(Vector3 force, Vector3 position, CoordinateSpace forceSpace = CoordinateSpace.Global, CoordinateSpace positionSpace = CoordinateSpace.Global)
{
if (forceSpace == CoordinateSpace.Local) force = _rigidBody.Pose.ToGlobalDirection(force);
if (positionSpace == CoordinateSpace.Local) position = _rigidBody.Pose.ToGlobalPosition(position);
_rigidBody.WrappedRigidBody.AddForce(force.ToDigitalRune(),position.ToDigitalRune());
}
private Vector3 FromGlobalToCorrectSpace(CoordinateSpace velocitySpace, Vector3 globalResult)
{
return velocitySpace == CoordinateSpace.Global
? globalResult
: _rigidBody.Pose.ToLocalPosition(globalResult);
}
public void TransformPoints(CoordinateSpace destSpace, CoordinateSpace srcSpace, PointF[] pts)
{
throw new NotImplementedException();
}
