public void Add(Joint joint) { if (JointCount >= JointCapacity) return; // Debug.Assert(JointCount < JointCapacity); _joints[JointCount++] = joint; }
public static GearJoint CreateGearJoint(World world, Joint jointA, Joint jointB, float ratio) { GearJoint gearJoint = new GearJoint(jointA, jointB, ratio); world.AddJoint(gearJoint); return(gearJoint); }
internal void DestroyJoint() { if (this.joint == null) return; Scene.PhysicsWorld.RemoveJoint(this.joint); this.joint.Broke -= this.joint_Broke; this.joint = null; }
public ConstructElement(ScrapGame game, Segment entity, Construct construct, Point offSet, Joint rootJoint) { branchJoints = new List<Joint>(); this.rootJoint = rootJoint; this.segment = entity; this.game = game; this.construct = construct; this.offSet = offSet; }
public Balance(World worldFarseer, Vector2 posDepart, Texture2D tex) : base(worldFarseer, posDepart, tex) { objPhys.IsStatic = false; objPhys.BodyType = BodyType.Dynamic; objPhys.AngularDamping = 0.8f; objPhys.Inertia = 2; Body rotor = BodyFactory.CreateCircle(worldFarseer, 0.1f, 3f); pivot = JointFactory.CreateRevoluteJoint(worldFarseer,objPhys,rotor,objPhys.Position); }
public override void LoadContent() { base.LoadContent(); World.Gravity = new Vector2(0, 140); projection = Matrix.CreateOrthographicOffCenter(0f, ScreenManager.GraphicsDevice.Viewport.Width, ScreenManager.GraphicsDevice.Viewport.Height, 0f, 0f, 1f); hookpointmanager = new HookPointManager(World); MaterialType hookpointmaterial = MaterialType.Blank; swingerbody = BodyFactory.CreateBody(World, new Vector2(3, 10)); swinger = FixtureFactory.AttachCircle(1, 40, swingerbody); swinger.Body.BodyType = BodyType.Dynamic; swinger.Friction = 0; body3 = BodyFactory.CreateBody(World, new Vector2(-4, -10)); body3.IsStatic = true; CircleShape circleShape3 = new CircleShape(.4f, .3f); Fixture fixture3 = body3.CreateFixture(circleShape3, hookpointmaterial); body3.IgnoreGravity = true; fixture3.Body.BodyType = BodyType.Static; body2 = BodyFactory.CreateBody(World, new Vector2(-8, -10)); body2.IsStatic = true; CircleShape circleShape2 = new CircleShape(.4f, .3f); fixture2 = body2.CreateFixture(circleShape2, hookpointmaterial); body2.IgnoreGravity = true; fixture2.Body.BodyType = BodyType.Static; joint1 = JointFactory.CreateSliderJoint(World, swingerbody, fixture3.Body, Vector2.Zero, Vector2.Zero, 4, 5); _border = new Border(World, this, ScreenManager.GraphicsDevice.Viewport); //SetUserAgent(swingerbody, 100f, 100f); // create sprite based on body swingersprite = new Sprite(ScreenManager.Assets.TextureFromShape(swingerbody.FixtureList[0].Shape, MaterialType.Dots, Color.Red, 2f)); body3sprite = new Sprite(ScreenManager.Assets.TextureFromShape(swingerbody.FixtureList[0].Shape, MaterialType.Dots, Color.Red, 2f)); body2sprite = new Sprite(ScreenManager.Assets.TextureFromShape(swingerbody.FixtureList[0].Shape, MaterialType.Dots, Color.Red, 2f)); }
public Wheel(ScrapGame game, Vector2 position) : base(game) { texture = game.Content.Load<Texture2D>("wheel"); wheel = BodyFactory.CreateCircle(game.world, .49f, 1f, this); wheel.Restitution = .5f; wheel.BodyType = BodyType.Dynamic; wheel.Position = position; wheel.Friction = .9f; //wheel.CollisionCategories = new Category(); body = BodyFactory.CreateRectangle(game.world, .5f, .5f, .5f, this); body.Position = position; body.BodyType = BodyType.Dynamic; body.Restitution = .5f; body.Friction = .9f; bodyJoint = JointFactory.CreateRevoluteJoint(game.world, body, wheel, new Vector2(0, 0), new Vector2(0, 0)); }
public DriveWheel(ScrapGame game, Vector2 position) : base(game) { texture = game.Content.Load<Texture2D>("wheel"); wheel = BodyFactory.CreateCircle(game.world, .49f, 2f,this); wheel.Restitution = 1f; wheel.BodyType = BodyType.Dynamic; wheel.Position = position; wheel.Friction = 2f; wheel.UserData = this; body = BodyFactory.CreateRectangle(game.world, .1f, .1f, 2f); body.Position = position; body.BodyType = BodyType.Dynamic; //body.IgnoreCCD = true; wheelHubJoint = JointFactory.CreateRevoluteJoint(game.world, body, wheel, new Vector2(0, 0)); }
/// <summary> /// Create a joint to constrain bodies together. This may cause the connected bodies to cease colliding. /// </summary> /// <param name="joint">The joint.</param> public void AddJoint(Joint joint) { //You are adding the same joint twice? Debug.Assert(!_jointAddList.Contains(joint)); if (!_jointAddList.Contains(joint)) _jointAddList.Add(joint); }
private void RemoveJoint(Joint joint, bool doCheck) { if (doCheck) { Debug.Assert(!_jointRemoveList.Contains(joint), "The joint is already marked for removal. You are removing the joint more than once."); } if (!_jointRemoveList.Contains(joint)) _jointRemoveList.Add(joint); }
private void SerializeJoint(Joint joint) { if (joint.IsFixedType()) return; _writer.WriteStartElement("Joint"); _writer.WriteAttributeString("Type", joint.JointType.ToString()); WriteElement("BodyA", FindBodyIndex(joint.BodyA)); WriteElement("BodyB", FindBodyIndex(joint.BodyB)); WriteElement("CollideConnected", joint.CollideConnected); WriteElement("Breakpoint", joint.Breakpoint); if (joint.UserData != null) { _writer.WriteStartElement("UserData"); WriteDynamicType(joint.UserData.GetType(), joint.UserData); _writer.WriteEndElement(); } switch (joint.JointType) { case JointType.Distance: { DistanceJoint djd = (DistanceJoint)joint; WriteElement("DampingRatio", djd.DampingRatio); WriteElement("FrequencyHz", djd.Frequency); WriteElement("Length", djd.Length); WriteElement("LocalAnchorA", djd.LocalAnchorA); WriteElement("LocalAnchorB", djd.LocalAnchorB); } break; case JointType.Friction: { FrictionJoint fjd = (FrictionJoint)joint; WriteElement("LocalAnchorA", fjd.LocalAnchorA); WriteElement("LocalAnchorB", fjd.LocalAnchorB); WriteElement("MaxForce", fjd.MaxForce); WriteElement("MaxTorque", fjd.MaxTorque); } break; case JointType.Gear: throw new Exception("Gear joint not supported by serialization"); case JointType.Line: { LineJoint ljd = (LineJoint)joint; WriteElement("EnableMotor", ljd.MotorEnabled); WriteElement("LocalAnchorA", ljd.LocalAnchorA); WriteElement("LocalAnchorB", ljd.LocalAnchorB); WriteElement("MotorSpeed", ljd.MotorSpeed); WriteElement("DampingRatio", ljd.DampingRatio); WriteElement("MaxMotorTorque", ljd.MaxMotorTorque); WriteElement("FrequencyHz", ljd.Frequency); WriteElement("LocalXAxis", ljd.LocalXAxis); } break; case JointType.Prismatic: { PrismaticJoint pjd = (PrismaticJoint)joint; //NOTE: Does not conform with Box2DScene WriteElement("EnableLimit", pjd.LimitEnabled); WriteElement("EnableMotor", pjd.MotorEnabled); WriteElement("LocalAnchorA", pjd.LocalAnchorA); WriteElement("LocalAnchorB", pjd.LocalAnchorB); WriteElement("LocalXAxis1", pjd.LocalXAxis1); WriteElement("LowerTranslation", pjd.LowerLimit); WriteElement("UpperTranslation", pjd.UpperLimit); WriteElement("MaxMotorForce", pjd.MaxMotorForce); WriteElement("MotorSpeed", pjd.MotorSpeed); } break; case JointType.Pulley: { PulleyJoint pjd = (PulleyJoint)joint; WriteElement("GroundAnchorA", pjd.GroundAnchorA); WriteElement("GroundAnchorB", pjd.GroundAnchorB); WriteElement("LengthA", pjd.LengthA); WriteElement("LengthB", pjd.LengthB); WriteElement("LocalAnchorA", pjd.LocalAnchorA); WriteElement("LocalAnchorB", pjd.LocalAnchorB); WriteElement("MaxLengthA", pjd.MaxLengthA); WriteElement("MaxLengthB", pjd.MaxLengthB); WriteElement("Ratio", pjd.Ratio); } break; case JointType.Revolute: { RevoluteJoint rjd = (RevoluteJoint)joint; WriteElement("EnableLimit", rjd.LimitEnabled); WriteElement("EnableMotor", rjd.MotorEnabled); WriteElement("LocalAnchorA", rjd.LocalAnchorA); WriteElement("LocalAnchorB", rjd.LocalAnchorB); WriteElement("LowerAngle", rjd.LowerLimit); WriteElement("MaxMotorTorque", rjd.MaxMotorTorque); WriteElement("MotorSpeed", rjd.MotorSpeed); WriteElement("ReferenceAngle", rjd.ReferenceAngle); WriteElement("UpperAngle", rjd.UpperLimit); } break; case JointType.Weld: { WeldJoint wjd = (WeldJoint)joint; WriteElement("LocalAnchorA", wjd.LocalAnchorA); WriteElement("LocalAnchorB", wjd.LocalAnchorB); } break; // // Not part of Box2DScene // case JointType.Rope: { RopeJoint rjd = (RopeJoint)joint; WriteElement("LocalAnchorA", rjd.LocalAnchorA); WriteElement("LocalAnchorB", rjd.LocalAnchorB); WriteElement("MaxLength", rjd.MaxLength); } break; case JointType.Angle: { AngleJoint aj = (AngleJoint)joint; WriteElement("BiasFactor", aj.BiasFactor); WriteElement("MaxImpulse", aj.MaxImpulse); WriteElement("Softness", aj.Softness); WriteElement("TargetAngle", aj.TargetAngle); } break; case JointType.Slider: { SliderJoint sliderJoint = (SliderJoint)joint; WriteElement("DampingRatio", sliderJoint.DampingRatio); WriteElement("FrequencyHz", sliderJoint.Frequency); WriteElement("MaxLength", sliderJoint.MaxLength); WriteElement("MinLength", sliderJoint.MinLength); WriteElement("LocalAnchorA", sliderJoint.LocalAnchorA); WriteElement("LocalAnchorB", sliderJoint.LocalAnchorB); } break; default: throw new Exception("Joint not supported"); } _writer.WriteEndElement(); }
private void DrawJoint(Joint joint) { if (!joint.Enabled) return; Body b1 = joint.BodyA; Body b2 = joint.BodyB; Transform xf1; b1.GetTransform(out xf1); Vector2 x2 = Vector2.Zero; // WIP David if (!joint.IsFixedType()) { Transform xf2; b2.GetTransform(out xf2); x2 = xf2.p; } Vector2 p1 = joint.WorldAnchorA; Vector2 p2 = joint.WorldAnchorB; Vector2 x1 = xf1.p; Color color = Color.FromArgb(255, 128, 205, 205); switch (joint.JointType) { case JointType.Distance: DrawSegment(p1, p2, color); break; case JointType.Pulley: PulleyJoint pulley = (PulleyJoint)joint; Vector2 s1 = b1.GetWorldPoint(pulley.LocalAnchorA); Vector2 s2 = b2.GetWorldPoint(pulley.LocalAnchorB); DrawSegment(p1, p2, color); DrawSegment(p1, s1, color); DrawSegment(p2, s2, color); break; case JointType.FixedMouse: DrawPoint(p1, 0.5f, Color.FromArgb(255, 0, 255, 0)); DrawSegment(p1, p2, Color.FromArgb(255, 205, 205, 205)); break; case JointType.Revolute: DrawSegment(x1, p1, color); DrawSegment(p1, p2, color); DrawSegment(x2, p2, color); DrawSolidCircle(p2, 0.1f, Vector2.Zero, Colors.Red); DrawSolidCircle(p1, 0.1f, Vector2.Zero, Colors.Blue); break; case JointType.FixedAngle: //Should not draw anything. break; case JointType.FixedRevolute: DrawSegment(x1, p1, color); DrawSolidCircle(p1, 0.1f, Vector2.Zero, Colors.Purple); break; case JointType.FixedLine: DrawSegment(x1, p1, color); DrawSegment(p1, p2, color); break; case JointType.FixedDistance: DrawSegment(x1, p1, color); DrawSegment(p1, p2, color); break; case JointType.FixedPrismatic: DrawSegment(x1, p1, color); DrawSegment(p1, p2, color); break; case JointType.Gear: DrawSegment(x1, x2, color); break; default: DrawSegment(x1, p1, color); DrawSegment(p1, p2, color); DrawSegment(x2, p2, color); break; } }
/// <summary> /// Requires two existing revolute or prismatic joints (any combination will work). /// The provided joints must attach a dynamic body to a static body. /// </summary> /// <param name="joint1">The first joint.</param> /// <param name="joint2">The second joint.</param> /// <param name="ratio">The ratio.</param> public GearJoint(Joint joint1, Joint joint2, float ratio = 1f) { JointType = JointType.Gear; Joint1 = joint1; Joint2 = joint2; Ratio = ratio; _typeA = joint1.JointType; _typeB = joint2.JointType; Debug.Assert(_typeA == JointType.Revolute || _typeA == JointType.Prismatic || _typeA == JointType.FixedRevolute || _typeA == JointType.FixedPrismatic); Debug.Assert(_typeB == JointType.Revolute || _typeB == JointType.Prismatic || _typeB == JointType.FixedRevolute || _typeB == JointType.FixedPrismatic); float coordinateA, coordinateB; // TODO_ERIN there might be some problem with the joint edges in b2Joint. _bodyC = Joint1.BodyA; _bodyA = Joint1.BodyB; // Get geometry of joint1 Transform xfA = _bodyA.Xf; float aA = _bodyA.Sweep.A; Transform xfC = _bodyC.Xf; float aC = _bodyC.Sweep.A; if (_typeA == JointType.Revolute) { RevoluteJoint revolute = (RevoluteJoint)joint1; _localAnchorC = revolute.LocalAnchorA; _localAnchorA = revolute.LocalAnchorB; _referenceAngleA = revolute.ReferenceAngle; _localAxisC = Vector2.Zero; coordinateA = aA - aC - _referenceAngleA; } else { PrismaticJoint prismatic = (PrismaticJoint)joint1; _localAnchorC = prismatic.LocalAnchorA; _localAnchorA = prismatic.LocalAnchorB; _referenceAngleA = prismatic.ReferenceAngle; _localAxisC = prismatic.LocalXAxisA; Vector2 pC = _localAnchorC; Vector2 pA = MathUtils.MulT(xfC.q, MathUtils.Mul(xfA.q, _localAnchorA) + (xfA.p - xfC.p)); coordinateA = Vector2.Dot(pA - pC, _localAxisC); } _bodyD = Joint2.BodyA; _bodyB = Joint2.BodyB; // Get geometry of joint2 Transform xfB = _bodyB.Xf; float aB = _bodyB.Sweep.A; Transform xfD = _bodyD.Xf; float aD = _bodyD.Sweep.A; if (_typeB == JointType.Revolute) { RevoluteJoint revolute = (RevoluteJoint)joint2; _localAnchorD = revolute.LocalAnchorA; _localAnchorB = revolute.LocalAnchorB; _referenceAngleB = revolute.ReferenceAngle; _localAxisD = Vector2.Zero; coordinateB = aB - aD - _referenceAngleB; } else { PrismaticJoint prismatic = (PrismaticJoint)joint2; _localAnchorD = prismatic.LocalAnchorA; _localAnchorB = prismatic.LocalAnchorB; _referenceAngleB = prismatic.ReferenceAngle; _localAxisD = prismatic.LocalXAxisA; Vector2 pD = _localAnchorD; Vector2 pB = MathUtils.MulT(xfD.q, MathUtils.Mul(xfB.q, _localAnchorB) + (xfB.p - xfD.p)); coordinateB = Vector2.Dot(pB - pD, _localAxisD); } _ratio = ratio; _constant = coordinateA + _ratio * coordinateB; _impulse = 0.0f; }
protected override void JointRemoved(Joint joint) { for (int i = 0; i < 8; ++i) { if (_joints[i] == joint) { _joints[i] = null; break; } } base.JointRemoved(joint); }
protected virtual void JointRemoved(Joint joint) { if (_fixedMouseJoint == joint) _fixedMouseJoint = null; }
/// <summary> /// Requires two existing revolute or prismatic joints (any combination will work). /// The provided joints must attach a dynamic body to a static body. /// </summary> /// <param name="jointA">The first joint.</param> /// <param name="jointB">The second joint.</param> /// <param name="ratio">The ratio.</param> public GearJoint(Joint jointA, Joint jointB, float ratio) : base(jointA.BodyA, jointA.BodyB) { JointType = JointType.Gear; JointA = jointA; JointB = jointB; Ratio = ratio; JointType type1 = jointA.JointType; JointType type2 = jointB.JointType; // Make sure its the right kind of joint Debug.Assert(type1 == JointType.Revolute || type1 == JointType.Prismatic || type1 == JointType.FixedRevolute || type1 == JointType.FixedPrismatic); Debug.Assert(type2 == JointType.Revolute || type2 == JointType.Prismatic || type2 == JointType.FixedRevolute || type2 == JointType.FixedPrismatic); // In the case of a prismatic and revolute joint, the first body must be static. if (type1 == JointType.Revolute || type1 == JointType.Prismatic) Debug.Assert(jointA.BodyA.BodyType == BodyType.Static); if (type2 == JointType.Revolute || type2 == JointType.Prismatic) Debug.Assert(jointB.BodyA.BodyType == BodyType.Static); float coordinate1 = 0.0f, coordinate2 = 0.0f; switch (type1) { case JointType.Revolute: BodyA = jointA.BodyB; _revolute1 = (RevoluteJoint)jointA; LocalAnchor1 = _revolute1.LocalAnchorB; coordinate1 = _revolute1.JointAngle; break; case JointType.Prismatic: BodyA = jointA.BodyB; _prismatic1 = (PrismaticJoint)jointA; LocalAnchor1 = _prismatic1.LocalAnchorB; coordinate1 = _prismatic1.JointTranslation; break; case JointType.FixedRevolute: BodyA = jointA.BodyA; _fixedRevolute1 = (FixedRevoluteJoint)jointA; LocalAnchor1 = _fixedRevolute1.LocalAnchorA; coordinate1 = _fixedRevolute1.JointAngle; break; case JointType.FixedPrismatic: BodyA = jointA.BodyA; _fixedPrismatic1 = (FixedPrismaticJoint)jointA; LocalAnchor1 = _fixedPrismatic1.LocalAnchorA; coordinate1 = _fixedPrismatic1.JointTranslation; break; } switch (type2) { case JointType.Revolute: BodyB = jointB.BodyB; _revolute2 = (RevoluteJoint)jointB; LocalAnchor2 = _revolute2.LocalAnchorB; coordinate2 = _revolute2.JointAngle; break; case JointType.Prismatic: BodyB = jointB.BodyB; _prismatic2 = (PrismaticJoint)jointB; LocalAnchor2 = _prismatic2.LocalAnchorB; coordinate2 = _prismatic2.JointTranslation; break; case JointType.FixedRevolute: BodyB = jointB.BodyA; _fixedRevolute2 = (FixedRevoluteJoint)jointB; LocalAnchor2 = _fixedRevolute2.LocalAnchorA; coordinate2 = _fixedRevolute2.JointAngle; break; case JointType.FixedPrismatic: BodyB = jointB.BodyA; _fixedPrismatic2 = (FixedPrismaticJoint)jointB; LocalAnchor2 = _fixedPrismatic2.LocalAnchorA; coordinate2 = _fixedPrismatic2.JointTranslation; break; } _ant = coordinate1 + Ratio * coordinate2; }
protected int lookupJointIndex(Joint joint) { int? val = m_jointToIndexMap[joint]; if (null != val) return val.Value; else return -1; }
/// <summary> /// Requires two existing revolute or prismatic joints (any combination will work). /// The provided joints must attach a dynamic body to a static body. /// </summary> /// <param name="jointA">The first joint.</param> /// <param name="jointB">The second joint.</param> /// <param name="ratio">The ratio.</param> /// <param name="bodyA">The first body</param> /// <param name="bodyB">The second body</param> public GearJoint(Body bodyA, Body bodyB, Joint jointA, Joint jointB, float ratio = 1f) { JointType = JointType.Gear; BodyA = bodyA; BodyB = bodyB; JointA = jointA; JointB = jointB; Ratio = ratio; _typeA = jointA.JointType; _typeB = jointB.JointType; Debug.Assert(_typeA == JointType.Revolute || _typeA == JointType.Prismatic || _typeA == JointType.FixedRevolute || _typeA == JointType.FixedPrismatic); Debug.Assert(_typeB == JointType.Revolute || _typeB == JointType.Prismatic || _typeB == JointType.FixedRevolute || _typeB == JointType.FixedPrismatic); float coordinateA, coordinateB; // TODO_ERIN there might be some problem with the joint edges in b2Joint. _bodyC = JointA.BodyA; _bodyA = JointA.BodyB; // Get geometry of joint1 Transform xfA = _bodyA._xf; float aA = _bodyA._sweep.A; Transform xfC = _bodyC._xf; float aC = _bodyC._sweep.A; if (_typeA == JointType.Revolute) { RevoluteJoint revolute = (RevoluteJoint)jointA; _localAnchorC = revolute.LocalAnchorA; _localAnchorA = revolute.LocalAnchorB; _referenceAngleA = revolute.ReferenceAngle; _localAxisC = Vector2.Zero; coordinateA = aA - aC - _referenceAngleA; } else { PrismaticJoint prismatic = (PrismaticJoint)jointA; _localAnchorC = prismatic.LocalAnchorA; _localAnchorA = prismatic.LocalAnchorB; _referenceAngleA = prismatic.ReferenceAngle; _localAxisC = prismatic.LocalXAxis; Vector2 pC = _localAnchorC; Vector2 pA = Complex.Divide(Complex.Multiply(ref _localAnchorA, ref xfA.q) + (xfA.p - xfC.p), ref xfC.q); coordinateA = Vector2.Dot(pA - pC, _localAxisC); } _bodyD = JointB.BodyA; _bodyB = JointB.BodyB; // Get geometry of joint2 Transform xfB = _bodyB._xf; float aB = _bodyB._sweep.A; Transform xfD = _bodyD._xf; float aD = _bodyD._sweep.A; if (_typeB == JointType.Revolute) { RevoluteJoint revolute = (RevoluteJoint)jointB; _localAnchorD = revolute.LocalAnchorA; _localAnchorB = revolute.LocalAnchorB; _referenceAngleB = revolute.ReferenceAngle; _localAxisD = Vector2.Zero; coordinateB = aB - aD - _referenceAngleB; } else { PrismaticJoint prismatic = (PrismaticJoint)jointB; _localAnchorD = prismatic.LocalAnchorA; _localAnchorB = prismatic.LocalAnchorB; _referenceAngleB = prismatic.ReferenceAngle; _localAxisD = prismatic.LocalXAxis; Vector2 pD = _localAnchorD; Vector2 pB = Complex.Divide(Complex.Multiply(ref _localAnchorB, ref xfB.q) + (xfB.p - xfD.p), ref xfD.q); coordinateB = Vector2.Dot(pB - pD, _localAxisD); } _ratio = ratio; _constant = coordinateA + _ratio * coordinateB; _impulse = 0.0f; }
public static GearJoint CreateGearJoint(World world, Body bodyA, Body bodyB, Joint jointA, Joint jointB, float ratio) { GearJoint gearJoint = new GearJoint(bodyA, bodyB, jointA, jointB, ratio); world.Add(gearJoint); return(gearJoint); }
public String GetJointName(Joint joint) { if (m_jointToNameMap.ContainsKey(joint)) return m_jointToNameMap[joint]; return null; }
public void Add(Joint joint) { //Debug.Assert(JointCount < _jointCapacity); _joints[JointCount++] = joint; }
private void DrawJoint(Joint joint) { Body b1 = joint.BodyA; Body b2 = joint.BodyB; Transform xf1, xf2; b1.GetTransform(out xf1); Vector2 x2 = new Vector2(); // WIP David if (!joint.IsFixedType()) { b2.GetTransform(out xf2); x2 = xf2.Position; } Vector2 p2 = joint.WorldAnchorB; Vector2 x1 = xf1.Position; Vector2 p1 = joint.WorldAnchorA; Color color = new Color(0.5f, 0.8f, 0.8f); switch (joint.JointType) { case JointType.Distance: DrawSegment(p1, p2, color); break; case JointType.Pulley: { PulleyJoint pulley = (PulleyJoint) joint; Vector2 s1 = pulley.GroundAnchorA; Vector2 s2 = pulley.GroundAnchorB; DrawSegment(s1, p1, color); DrawSegment(s2, p2, color); DrawSegment(s1, s2, color); } break; case JointType.FixedMouse: FixedMouseJoint fixedMouseJoint = (FixedMouseJoint) joint; p1 = fixedMouseJoint.Target; DrawPoint(p2, 0.5f, new Color(0.0f, 1.0f, 0.0f)); DrawSegment(p1, p2, new Color(0.8f, 0.8f, 0.8f)); break; case JointType.Revolute: //DrawSegment(x2, p1, color); DrawSegment(p2, p1, color); DrawSolidCircle(p2, 0.1f, new Vector2(), Color.Red); DrawSolidCircle(p1, 0.1f, new Vector2(), Color.Blue); break; case JointType.FixedRevolute: DrawSolidCircle(p1, 0.1f, new Vector2(), Color.Pink); break; case JointType.FixedLine: DrawSegment(x1, p1, color); DrawSegment(p1, p2, color); break; case JointType.FixedDistance: DrawSegment(x1, p1, color); DrawSegment(p1, p2, color); break; case JointType.FixedPrismatic: DrawSegment(x1, p1, color); DrawSegment(p1, p2, color); break; case JointType.Gear: DrawSegment(x1, x2, color); //DrawSegment(x1, p1, color); //DrawSegment(p1, p2, color); break; default: DrawSegment(x1, p1, color); DrawSegment(p1, p2, color); DrawSegment(x2, p2, color); break; } }
public void Solve(ref TimeStep step, ref Vector2 gravity) { // Integrate velocities and apply damping. for (int i = 0; i < BodyCount; ++i) { Body b = Bodies[i]; if (b.BodyType != BodyType.Dynamic) { continue; } // Integrate velocities. // FPE 3 only - Only apply gravity if the body wants it. if (b.IgnoreGravity) { b.LinearVelocityInternal.x += step.dt * (b.InvMass * b.Force.x); b.LinearVelocityInternal.y += step.dt * (b.InvMass * b.Force.y); b.AngularVelocityInternal += step.dt * b.InvI * b.Torque; } else { b.LinearVelocityInternal.x += step.dt * (gravity.x + b.InvMass * b.Force.x); b.LinearVelocityInternal.y += step.dt * (gravity.y + b.InvMass * b.Force.y); b.AngularVelocityInternal += step.dt * b.InvI * b.Torque; } // Apply damping. // ODE: dv/dt + c * v = 0 // Solution: v(t) = v0 * exp(-c * t) // Time step: v(t + dt) = v0 * exp(-c * (t + dt)) = v0 * exp(-c * t) * exp(-c * dt) = v * exp(-c * dt) // v2 = exp(-c * dt) * v1 // Taylor expansion: // v2 = (1.0f - c * dt) * v1 b.LinearVelocityInternal *= MathUtils.Clamp(1.0f - step.dt * b.LinearDamping, 0.0f, 1.0f); b.AngularVelocityInternal *= MathUtils.Clamp(1.0f - step.dt * b.AngularDamping, 0.0f, 1.0f); } // Partition contacts so that contacts with static bodies are solved last. int i1 = -1; for (int i2 = 0; i2 < ContactCount; ++i2) { Fixture fixtureA = _contacts[i2].FixtureA; Fixture fixtureB = _contacts[i2].FixtureB; Body bodyA = fixtureA.Body; Body bodyB = fixtureB.Body; bool nonStatic = bodyA.BodyType != BodyType.Static && bodyB.BodyType != BodyType.Static; if (nonStatic) { ++i1; //TODO: Only swap if they are not the same? see http://code.google.com/p/box2d/issues/detail?id=162 Contact tmp = _contacts[i1]; _contacts[i1] = _contacts[i2]; _contacts[i2] = tmp; } } // Initialize velocity constraints. _contactSolver.Reset(_contacts, ContactCount, step.dtRatio, Settings.EnableWarmstarting); _contactSolver.InitializeVelocityConstraints(); if (Settings.EnableWarmstarting) { _contactSolver.WarmStart(); } #if (!SILVERLIGHT) if (Settings.EnableDiagnostics) { _watch.Start(); _tmpTime = 0; } #endif for (int i = 0; i < JointCount; ++i) { if (_joints[i].Enabled) { _joints[i].InitVelocityConstraints(ref step); } } #if (!SILVERLIGHT) if (Settings.EnableDiagnostics) { _tmpTime += _watch.ElapsedTicks; } #endif // Solve velocity constraints. for (int i = 0; i < Settings.VelocityIterations; ++i) { #if (!SILVERLIGHT) if (Settings.EnableDiagnostics) { _watch.Start(); } #endif for (int j = 0; j < JointCount; ++j) { Joint joint = _joints[j]; if (!joint.Enabled) { continue; } joint.SolveVelocityConstraints(ref step); joint.Validate(step.inv_dt); } #if (!SILVERLIGHT) if (Settings.EnableDiagnostics) { _watch.Stop(); _tmpTime += _watch.ElapsedTicks; _watch.Reset(); } #endif _contactSolver.SolveVelocityConstraints(); } // Post-solve (store impulses for warm starting). _contactSolver.StoreImpulses(); // Integrate positions. for (int i = 0; i < BodyCount; ++i) { Body b = Bodies[i]; if (b.BodyType == BodyType.Static) { continue; } // Check for large velocities. float translationX = step.dt * b.LinearVelocityInternal.x; float translationY = step.dt * b.LinearVelocityInternal.y; float result = translationX * translationX + translationY * translationY; if (result > Settings.MaxTranslationSquared) { float sq = Mathf.Sqrt(result); float ratio = Settings.MaxTranslation / sq; b.LinearVelocityInternal.x *= ratio; b.LinearVelocityInternal.y *= ratio; } float rotation = step.dt * b.AngularVelocityInternal; if (rotation * rotation > Settings.MaxRotationSquared) { float ratio = Settings.MaxRotation / Mathf.Abs(rotation); b.AngularVelocityInternal *= ratio; } // Store positions for continuous collision. b.Sweep.C0.x = b.Sweep.C.x; b.Sweep.C0.y = b.Sweep.C.y; b.Sweep.A0 = b.Sweep.A; // Integrate b.Sweep.C.x += step.dt * b.LinearVelocityInternal.x; b.Sweep.C.y += step.dt * b.LinearVelocityInternal.y; b.Sweep.A += step.dt * b.AngularVelocityInternal; // Compute new transform b.SynchronizeTransform(); // Note: shapes are synchronized later. } // Iterate over constraints. for (int i = 0; i < Settings.PositionIterations; ++i) { bool contactsOkay = _contactSolver.SolvePositionConstraints(Settings.ContactBaumgarte); bool jointsOkay = true; #if (!SILVERLIGHT) if (Settings.EnableDiagnostics) { _watch.Start(); } #endif for (int j = 0; j < JointCount; ++j) { Joint joint = _joints[j]; if (!joint.Enabled) { continue; } bool jointOkay = joint.SolvePositionConstraints(); jointsOkay = jointsOkay && jointOkay; } #if (!SILVERLIGHT) if (Settings.EnableDiagnostics) { _watch.Stop(); _tmpTime += _watch.ElapsedTicks; _watch.Reset(); } #endif if (contactsOkay && jointsOkay) { // Exit early if the position errors are small. break; } } #if (!SILVERLIGHT) if (Settings.EnableDiagnostics) { JointUpdateTime = _tmpTime; } #endif Report(_contactSolver.Constraints); if (Settings.AllowSleep) { float minSleepTime = Settings.MaxFloat; for (int i = 0; i < BodyCount; ++i) { Body b = Bodies[i]; if (b.BodyType == BodyType.Static) { continue; } if ((b.Flags & BodyFlags.AutoSleep) == 0 || b.AngularVelocityInternal * b.AngularVelocityInternal > AngTolSqr || Vector2.Dot(b.LinearVelocityInternal, b.LinearVelocityInternal) > LinTolSqr) { b.SleepTime = 0.0f; minSleepTime = 0.0f; } else { b.SleepTime += step.dt; minSleepTime = Mathf.Min(minSleepTime, b.SleepTime); } } if (minSleepTime >= Settings.TimeToSleep) { for (int i = 0; i < BodyCount; ++i) { Body b = Bodies[i]; b.Awake = false; } } } }
private void JointRemovedFired(Joint joint) { if (joint is DistanceJoint) _removedJoints++; }
protected void readCustomPropertiesFromJson(Joint item, JObject value) { if (null == item) return; if (value["customProperties"] != null) return; int i = 0; JArray propValues = (JArray)value["customProperties"]; if (null != propValues) { int numPropValues = propValues.Count; for (i = 0; i < numPropValues; i++) { JObject propValue = (JObject)propValues[i]; String propertyName = propValue["name"].ToString(); if (propValue["int"] != null) SetCustomInt(item, propertyName, (int)propValue["int"]); if (propValue["float"] != null) SetCustomFloat(item, propertyName, (float)propValue["float"]); if (propValue["string"] != null) SetCustomString(item, propertyName, propValue["string"].ToString()); if (propValue["vec2"] != null) SetCustomVector(item, propertyName, this.jsonToVec("vec2", propValue)); if (propValue["bool"] != null) SetCustomBool(item, propertyName, (bool)propValue["bool"]); } } }
/// <summary> /// Requires two existing revolute or prismatic joints (any combination will work). /// The provided joints must attach a dynamic body to a static body. /// </summary> /// <param name="jointA">The first joint.</param> /// <param name="jointB">The second joint.</param> /// <param name="ratio">The ratio.</param> public GearJoint(Joint jointA, Joint jointB, float ratio) : base(jointA.BodyA, jointA.BodyB) { JointType = JointType.Gear; JointA = jointA; JointB = jointB; Ratio = ratio; m_typeA = jointA.JointType; m_typeB = jointB.JointType; // Make sure its the right kind of joint Debug.Assert(m_typeA == JointType.Revolute || m_typeA == JointType.Prismatic || m_typeA == JointType.FixedRevolute || m_typeA == JointType.FixedPrismatic); Debug.Assert(m_typeB == JointType.Revolute || m_typeB == JointType.Prismatic || m_typeB == JointType.FixedRevolute || m_typeB == JointType.FixedPrismatic); float coordinateA = 0.0f, coordinateB = 0.0f; m_bodyC = m_joint1.BodyA; BodyA = m_joint1.BodyB; // Get geometry of joint1 Transform xfA = BodyA.Xf; float aA = BodyA.Sweep.A; Transform xfC = m_bodyC.Xf; float aC = m_bodyC.Sweep.A; if (m_typeA == JointType.Revolute) { RevoluteJoint revolute = (RevoluteJoint)jointA; m_localAnchorC = revolute.LocalAnchorA; m_localAnchorA = revolute.LocalAnchorB; m_referenceAngleA = revolute.ReferenceAngle; m_localAxisC = Vector2.Zero; coordinateA = aA - aC - m_referenceAngleA; } else { PrismaticJoint prismatic = (PrismaticJoint)jointA; m_localAnchorC = prismatic.LocalAnchorA; m_localAnchorA = prismatic.LocalAnchorB; m_referenceAngleA = prismatic.ReferenceAngle; m_localAxisC = prismatic.LocalXAxisA; Vector2 pC = m_localAnchorC; Vector2 pA = MathUtils.MulT(xfC.q, MathUtils.Mul(xfA.q, m_localAnchorA) + (xfA.p - xfC.p)); coordinateA = Vector2.Dot(pA - pC, m_localAxisC); } m_bodyD = m_joint2.BodyA; BodyB = m_joint2.BodyB; // Get geometry of joint2 Transform xfB = BodyB.Xf; float aB = BodyB.Sweep.A; Transform xfD = m_bodyD.Xf; float aD = m_bodyD.Sweep.A; if (m_typeB == JointType.Revolute) { RevoluteJoint revolute = (RevoluteJoint)jointB; m_localAnchorD = revolute.LocalAnchorA; m_localAnchorB = revolute.LocalAnchorB; m_referenceAngleB = revolute.ReferenceAngle; m_localAxisD = Vector2.Zero; coordinateB = aB - aD - m_referenceAngleB; } else { PrismaticJoint prismatic = (PrismaticJoint)jointB; m_localAnchorD = prismatic.LocalAnchorA; m_localAnchorB = prismatic.LocalAnchorB; m_referenceAngleB = prismatic.ReferenceAngle; m_localAxisD = prismatic.LocalXAxisA; Vector2 pD = m_localAnchorD; Vector2 pB = MathUtils.MulT(xfD.q, MathUtils.Mul(xfB.q, m_localAnchorB) + (xfB.p - xfD.p)); coordinateB = Vector2.Dot(pB - pD, m_localAxisD); } _ratio = ratio; m_constant = coordinateA + _ratio * coordinateB; }
public void SetCustomFloat(Joint item, String propertyName, float val) { m_jointsWithCustomProperties.Add(item); GetCustomPropertiesForItem(item, true).m_customPropertyMap_float.Add(propertyName, (float)val); }
/// <summary> /// Requires two existing revolute or prismatic joints (any combination will work). /// The provided joints must attach a dynamic body to a static body. /// </summary> /// <param name="joint1">The first joint.</param> /// <param name="joint2">The second joint.</param> /// <param name="ratio">The ratio.</param> public GearJoint(Joint joint1, Joint joint2, float ratio = 1f) { JointType = JointType.Gear; Joint1 = joint1; Joint2 = joint2; Ratio = ratio; _typeA = joint1.JointType; _typeB = joint2.JointType; Debug.Assert(_typeA == JointType.Revolute || _typeA == JointType.Prismatic || _typeA == JointType.FixedRevolute || _typeA == JointType.FixedPrismatic); Debug.Assert(_typeB == JointType.Revolute || _typeB == JointType.Prismatic || _typeB == JointType.FixedRevolute || _typeB == JointType.FixedPrismatic); float coordinateA, coordinateB; // TODO_ERIN there might be some problem with the joint edges in b2Joint. _bodyC = Joint1.BodyA; _bodyA = Joint1.BodyB; // Get geometry of joint1 Transform xfA = _bodyA.Xf; float aA = _bodyA.Sweep.A; Transform xfC = _bodyC.Xf; float aC = _bodyC.Sweep.A; if (_typeA == JointType.Revolute) { RevoluteJoint revolute = (RevoluteJoint)joint1; _localAnchorC = revolute.LocalAnchorA; _localAnchorA = revolute.LocalAnchorB; _referenceAngleA = revolute.ReferenceAngle; _localAxisC = Vector2.Zero; coordinateA = aA - aC - _referenceAngleA; } else { PrismaticJoint prismatic = (PrismaticJoint)joint1; _localAnchorC = prismatic.LocalAnchorA; _localAnchorA = prismatic.LocalAnchorB; _referenceAngleA = prismatic.ReferenceAngle; _localAxisC = prismatic.LocalXAxisA; Vector2 pC = _localAnchorC; Vector2 pA = MathUtils.MulT(xfC.q, MathUtils.Mul(xfA.q, _localAnchorA) + (xfA.p - xfC.p)); coordinateA = Vector2.Dot(pA - pC, _localAxisC); } _bodyD = Joint2.BodyA; _bodyB = Joint2.BodyB; // Get geometry of joint2 Transform xfB = _bodyB.Xf; float aB = _bodyB.Sweep.A; Transform xfD = _bodyD.Xf; float aD = _bodyD.Sweep.A; if (_typeB == JointType.Revolute) { RevoluteJoint revolute = (RevoluteJoint)joint2; _localAnchorD = revolute.LocalAnchorA; _localAnchorB = revolute.LocalAnchorB; _referenceAngleB = revolute.ReferenceAngle; _localAxisD = Vector2.Zero; coordinateB = aB - aD - _referenceAngleB; } else { PrismaticJoint prismatic = (PrismaticJoint)joint2; _localAnchorD = prismatic.LocalAnchorA; _localAnchorB = prismatic.LocalAnchorB; _referenceAngleB = prismatic.ReferenceAngle; _localAxisD = prismatic.LocalXAxisA; Vector2 pD = _localAnchorD; Vector2 pB = MathUtils.MulT(xfD.q, MathUtils.Mul(xfB.q, _localAnchorB) + (xfB.p - xfD.p)); coordinateB = Vector2.Dot(pB - pD, _localAxisD); } _ratio = ratio; _constant = coordinateA + _ratio * coordinateB; _impulse = 0.0f; }
public void SetCustomString(Joint item, String propertyName, String val) { m_jointsWithCustomProperties.Add(item); GetCustomPropertiesForItem(item, true).m_customPropertyMap_string.Add(propertyName, val); }
public void Add(Joint joint) { Debug.Assert(JointCount < _jointCapacity); _joints[JointCount++] = joint; }
public void SetCustomVector(Joint item, String propertyName, Vector2 val) { m_jointsWithCustomProperties.Add(item); GetCustomPropertiesForItem(item, true).m_customPropertyMap_vec2.Add(propertyName, val); }
/// <summary> /// Create a joint to constrain bodies together. This may cause the connected bodies to cease colliding. /// </summary> /// <param name="joint">The joint.</param> public void AddJoint(Joint joint) { Debug.Assert(!_jointAddList.Contains(joint), "You are adding the same joint more than once."); if (!_jointAddList.Contains(joint)) _jointAddList.Add(joint); }
public void SetCustomBool(Joint item, String propertyName, bool val) { m_jointsWithCustomProperties.Add(item); GetCustomPropertiesForItem(item, true).m_customPropertyMap_bool.Add(propertyName, val); }
/// <summary> /// Destroy a joint. This may cause the connected bodies to begin colliding. /// </summary> /// <param name="joint">The joint.</param> public void RemoveJoint(Joint joint) { RemoveJoint(joint, true); }
public JObject B2n(Joint joint) { JObject jointValue = new JObject(); String jointName = GetJointName(joint); if (null != jointName) jointValue["name"] = jointName; int bodyIndexA = lookupBodyIndex(joint.BodyA); int bodyIndexB = lookupBodyIndex(joint.BodyB); jointValue["bodyA"] = bodyIndexA; jointValue["bodyB"] = bodyIndexB; if (joint.CollideConnected) jointValue["collideConnected"] = true; Body bodyA = joint.BodyA; Body bodyB = joint.BodyB; // why do Joint.getAnchor methods need to take an argOut style // parameter!? Vector2 tmpAnchor = new Vector2(); switch (joint.JointType) { case JointType.Revolute: { jointValue["type"] = "revolute"; RevoluteJoint revoluteJoint = (RevoluteJoint)joint; tmpAnchor = revoluteJoint.WorldAnchorA; VecToJson("anchorA", bodyA.GetLocalPoint(tmpAnchor), jointValue); tmpAnchor = revoluteJoint.WorldAnchorA; VecToJson("anchorB", bodyB.GetLocalPoint(tmpAnchor), jointValue); FloatToJson("refAngle", bodyB.Rotation - bodyA.Rotation - revoluteJoint.JointAngle, jointValue); FloatToJson("jointSpeed", revoluteJoint.JointSpeed, jointValue); jointValue["enableLimit"] = revoluteJoint.LimitEnabled; FloatToJson("lowerLimit", revoluteJoint.LowerLimit, jointValue); FloatToJson("upperLimit", revoluteJoint.UpperLimit, jointValue); jointValue["enableMotor"] = revoluteJoint.Enabled; FloatToJson("motorSpeed", revoluteJoint.MotorSpeed, jointValue); FloatToJson("maxMotorTorque", revoluteJoint.MaxMotorTorque, jointValue); } break; case JointType.Prismatic: { jointValue["type"] = "prismatic"; PrismaticJoint prismaticJoint = (PrismaticJoint)joint; tmpAnchor = prismaticJoint.WorldAnchorA; VecToJson("anchorA", bodyA.GetLocalPoint(tmpAnchor), jointValue); tmpAnchor = prismaticJoint.WorldAnchorB; VecToJson("anchorB", bodyB.GetLocalPoint(tmpAnchor), jointValue); VecToJson("localAxisA", prismaticJoint.LocalXAxisA, jointValue); FloatToJson("refAngle", prismaticJoint.ReferenceAngle, jointValue); jointValue["enableLimit"] = prismaticJoint.LimitEnabled; FloatToJson("lowerLimit", prismaticJoint.LowerLimit, jointValue); FloatToJson("upperLimit", prismaticJoint.UpperLimit, jointValue); jointValue["enableMotor"] = prismaticJoint.MotorEnabled; FloatToJson("maxMotorForce", prismaticJoint.MaxMotorForce, jointValue); FloatToJson("motorSpeed", prismaticJoint.MotorSpeed, jointValue); } break; case JointType.Distance: { jointValue["type"] = "distance"; DistanceJoint distanceJoint = (DistanceJoint)joint; tmpAnchor = distanceJoint.WorldAnchorA; VecToJson("anchorA", bodyA.GetLocalPoint(tmpAnchor), jointValue); tmpAnchor = distanceJoint.WorldAnchorB; VecToJson("anchorB", bodyB.GetLocalPoint(tmpAnchor), jointValue); FloatToJson("length", distanceJoint.Length, jointValue); FloatToJson("frequency", distanceJoint.Frequency, jointValue); FloatToJson("dampingRatio", distanceJoint.DampingRatio, jointValue); } break; case JointType.Pulley: { jointValue["type"] = "pulley"; PulleyJoint pulleyJoint = (PulleyJoint)joint; VecToJson("groundAnchorA", pulleyJoint.GroundAnchorA, jointValue); VecToJson("groundAnchorB", pulleyJoint.GroundAnchorB, jointValue); tmpAnchor = pulleyJoint.WorldAnchorA; VecToJson("anchorA", bodyA.GetLocalPoint(tmpAnchor), jointValue); FloatToJson("lengthA", (pulleyJoint.GroundAnchorA - tmpAnchor).Length(), jointValue); tmpAnchor = pulleyJoint.WorldAnchorB; VecToJson("anchorB", bodyB.GetLocalPoint(tmpAnchor), jointValue); FloatToJson("lengthB", (pulleyJoint.GroundAnchorB - tmpAnchor).Length(), jointValue); FloatToJson("ratio", pulleyJoint.Ratio, jointValue); } break; case JointType.FixedMouse: { jointValue["type"] = "mouse"; FixedMouseJoint mouseJoint = (FixedMouseJoint)joint; VecToJson("target", mouseJoint.WorldAnchorB, jointValue); tmpAnchor = mouseJoint.WorldAnchorB; VecToJson("anchorB", tmpAnchor, jointValue); FloatToJson("maxForce", mouseJoint.MaxForce, jointValue); FloatToJson("frequency", mouseJoint.Frequency, jointValue); FloatToJson("dampingRatio", mouseJoint.DampingRatio, jointValue); } break; case JointType.Gear: { jointValue["type"] = "gear"; GearJoint gearJoint = (GearJoint)joint; int jointIndex1 = lookupJointIndex(gearJoint.Joint1); int jointIndex2 = lookupJointIndex(gearJoint.Joint2); jointValue["joint1"] = jointIndex1; jointValue["joint2"] = jointIndex2; jointValue["ratio"] = gearJoint.Ratio; } break; case JointType.Wheel: { jointValue["type"] = "wheel"; WheelJoint wheelJoint = (WheelJoint)joint; tmpAnchor = wheelJoint.LocalAnchorA; VecToJson("anchorA", tmpAnchor, jointValue); tmpAnchor = wheelJoint.LocalAnchorB; VecToJson("anchorB", tmpAnchor, jointValue); VecToJson("localAxisA", wheelJoint.LocalXAxisA , jointValue); jointValue["enableMotor"] = wheelJoint.MotorEnabled; FloatToJson("motorSpeed", wheelJoint.MotorSpeed, jointValue); FloatToJson("maxMotorTorque", wheelJoint.MaxMotorTorque, jointValue); FloatToJson("springFrequency", wheelJoint.SpringFrequencyHz, jointValue); FloatToJson("springDampingRatio", wheelJoint.SpringDampingRatio, jointValue); } break; case JointType.Weld: { jointValue["type"] = "weld"; WeldJoint weldJoint = (WeldJoint)joint; tmpAnchor = weldJoint.WorldAnchorA; VecToJson("anchorA", bodyA.GetLocalPoint(tmpAnchor), jointValue); tmpAnchor = weldJoint.WorldAnchorB; VecToJson("anchorB", bodyB.GetLocalPoint(tmpAnchor), jointValue); FloatToJson("refAngle", weldJoint.ReferenceAngle, jointValue); FloatToJson("frequency", weldJoint.FrequencyHz, jointValue); FloatToJson("dampingRatio", weldJoint.DampingRatio, jointValue); } break; case JointType.Friction: { jointValue["type"] = "friction"; FrictionJoint frictionJoint = (FrictionJoint)joint; tmpAnchor = frictionJoint.WorldAnchorA; VecToJson("anchorA", bodyA.GetLocalPoint(tmpAnchor), jointValue); tmpAnchor = frictionJoint.WorldAnchorB; VecToJson("anchorB", bodyB.GetLocalPoint(tmpAnchor), jointValue); FloatToJson("maxForce", frictionJoint.MaxForce, jointValue); FloatToJson("maxTorque", frictionJoint.MaxTorque, jointValue); } break; case JointType.Rope: { // Rope joints are apparently not implemented in JBox2D yet, but // when they are, commenting out the following section should work. jointValue["type"] = "rope"; RopeJoint ropeJoint = (RopeJoint)joint; tmpAnchor = ropeJoint.WorldAnchorA; VecToJson("anchorA", bodyA.GetLocalPoint(tmpAnchor), jointValue); tmpAnchor = ropeJoint.WorldAnchorB; VecToJson("anchorB", bodyB.GetLocalPoint(tmpAnchor), jointValue); FloatToJson("maxLength", ropeJoint.MaxLength, jointValue); } break; case JointType.Motor: { jointValue["type"] = "motor"; MotorJoint motor = (MotorJoint)joint; tmpAnchor = motor.WorldAnchorA; VecToJson("anchorA", motor.LinearOffset, jointValue); //tmpAnchor = motor.WorldAnchorB; //VecToJson("anchorB", bodyB.GetLocalPoint(tmpAnchor), jointValue); FloatToJson("maxForce", motor.MaxForce, jointValue); FloatToJson("maxTorque", motor.MaxTorque, jointValue); FloatToJson("refAngle", motor.AngularOffset, jointValue); } break; default: Console.WriteLine("Unknown joint type : " + joint.JointType); break; } JArray customPropertyValue = WriteCustomPropertiesToJson(joint); if (customPropertyValue.Count > 0) jointValue["customProperties"] = customPropertyValue; return jointValue; }
/// <summary> /// Destroy a joint. This may cause the connected bodies to begin colliding. /// </summary> /// <param name="joint">The joint.</param> public void RemoveJoint(Joint joint) { //You are removing a joint twice? Debug.Assert(!_jointRemoveList.Contains(joint)); if (!_jointRemoveList.Contains(joint)) _jointRemoveList.Add(joint); }
/// <summary> /// Requires two existing revolute or prismatic joints (any combination will work). /// The provided joints must attach a dynamic body to a static body. /// </summary> /// <param name="jointA">The first joint.</param> /// <param name="jointB">The second joint.</param> /// <param name="ratio">The ratio.</param> public GearJoint(Joint jointA, Joint jointB, float ratio) : base(jointA.BodyA, jointA.BodyA) { this.JointType = JointType.Gear; this.JointA = jointA; this.JointB = jointB; this.Ratio = ratio; JointType type1 = jointA.JointType; JointType type2 = jointB.JointType; // Make sure its the right kind of joint Debug.Assert(type1 == JointType.Revolute || type1 == JointType.Prismatic); Debug.Assert(type2 == JointType.Revolute || type2 == JointType.Prismatic); // In the case of a prismatic and revolute joint, the first body must be static. if (type1 == JointType.Revolute || type1 == JointType.Prismatic) { Debug.Assert(jointA.BodyB.BodyType == BodyType.Static); } if (type2 == JointType.Revolute || type2 == JointType.Prismatic) { Debug.Assert(jointB.BodyB.BodyType == BodyType.Static); } float coordinate1 = 0.0f, coordinate2 = 0.0f; switch (type1) { case JointType.Revolute: this.BodyA = jointA.BodyA; this._revolute1 = (RevoluteJoint)jointA; this.LocalAnchor1 = this._revolute1.LocalAnchorA; coordinate1 = this._revolute1.JointAngle; break; case JointType.Prismatic: this.BodyA = jointA.BodyA; this._prismatic1 = (PrismaticJoint)jointA; this.LocalAnchor1 = this._prismatic1.LocalAnchorA; coordinate1 = this._prismatic1.JointTranslation; break; } switch (type2) { case JointType.Revolute: this.BodyB = jointB.BodyA; this._revolute2 = (RevoluteJoint)jointB; this.LocalAnchor2 = this._revolute2.LocalAnchorA; coordinate2 = this._revolute2.JointAngle; break; case JointType.Prismatic: this.BodyB = jointB.BodyA; this._prismatic2 = (PrismaticJoint)jointB; this.LocalAnchor2 = this._prismatic2.LocalAnchorA; coordinate2 = this._prismatic2.JointTranslation; break; } this._ant = coordinate1 + this.Ratio * coordinate2; }