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(); }