internal override void UpdateSweepRadius(Vec2 center) { // Update the sweep radius (maximum radius) as measured from // a local center point. Vec2 d = _localPosition - center; _sweepRadius = d.Length() + _radius - Settings.ToiSlop; }
public override void DrawSolidCircle(Vec2 center, float radius, Vec2 axis, Color color) { float k_segments = 16.0f; float k_increment = 2.0f * Box2DX.Common.Settings.Pi / k_segments; float theta = 0.0f; Gl.glEnable(Gl.GL_BLEND); Gl.glBlendFunc(Gl.GL_SRC_ALPHA, Gl.GL_ONE_MINUS_SRC_ALPHA); Gl.glColor4f(0.5f * color.R, 0.5f * color.G, 0.5f * color.B, 0.5f); Gl.glBegin(Gl.GL_TRIANGLE_FAN); for (int i = 0; i < k_segments; ++i) { Vec2 v = center + radius * new Vec2((float)SysMath.Cos(theta), (float)SysMath.Sin(theta)); Gl.glVertex2f(v.X, v.Y); theta += k_increment; } Gl.glEnd(); Gl.glDisable(Gl.GL_BLEND); theta = 0.0f; Gl.glColor4f(color.R, color.G, color.B, 1.0f); Gl.glBegin(Gl.GL_LINE_LOOP); for (int i = 0; i < k_segments; ++i) { Vec2 v = center + radius * new Vec2((float)SysMath.Cos(theta), (float)SysMath.Sin(theta)); Gl.glVertex2f(v.X, v.Y); theta += k_increment; } Gl.glEnd(); Vec2 p = center + radius * axis; Gl.glBegin(Gl.GL_LINES); Gl.glVertex2f(center.X, center.Y); Gl.glVertex2f(p.X, p.Y); Gl.glEnd(); }
public World(AABB worldAABB, Vec2 gravity, bool doSleep) { this._destructionListener = null; this._boundaryListener = null; this._contactFilter = WorldCallback.DefaultFilter; this._contactListener = null; this._debugDraw = null; this._bodyList = null; this._contactList = null; this._jointList = null; this._bodyCount = 0; this._contactCount = 0; this._jointCount = 0; this._warmStarting = true; this._continuousPhysics = true; this._allowSleep = doSleep; this._gravity = gravity; this._lock = false; this._inv_dt0 = 0f; this._contactManager = new ContactManager(); this._contactManager._world = this; this._broadPhase = new BroadPhase(worldAABB, this._contactManager); BodyDef def = new BodyDef(); this._groundBody = this.CreateBody(def); }
public override void DrawSolidCircle(Vec2 center, float radius, Box2DX.Common.Vec2 axis, Color color) { float k_segments = 16.0f; float k_increment = 2.0f * (float)System.Math.PI / k_segments; float theta = 0.0f; GL.Color3(0.5f * color.R, 0.5f * color.G, 0.5f * color.B); GL.Disable(EnableCap.Texture2D); GL.Begin(BeginMode.TriangleFan); for (int i = 0; i < k_segments; ++i) { Vec2 v = center + radius * new Vec2((float)System.Math.Cos(theta), (float)System.Math.Sin(theta)); GL.Vertex3(v.X, v.Y, ZLayer); theta += k_increment; } GL.End(); theta = 0.0f; GL.Color4(color.R, color.G, color.B, 1.0f); GL.Begin(BeginMode.LineLoop); for (int i = 0; i < k_segments; ++i) { Vec2 v = center + radius * new Vec2((float)System.Math.Cos(theta), (float)System.Math.Sin(theta)); GL.Vertex3(v.X, v.Y, ZLayer); theta += k_increment; } GL.End(); Vec2 p = center + radius * axis; GL.Begin(BeginMode.Lines); GL.Vertex3(center.X, center.Y, ZLayer); GL.Vertex3(p.X, p.Y, 0); GL.End(); GL.Enable(EnableCap.Texture2D); }
public void Set(Vec2 x1, float a1, Vec2 x2, float a2) { this.Linear1 = x1; this.Angular1 = a1; this.Linear2 = x2; this.Angular2 = a2; }
public bool TestSegment(out float lambda, out Vec2 normal, Segment segment, float maxLambda) { lambda = 0f; normal = default(Vec2); Vec2 p = segment.P1; Vec2 a = segment.P2 - p; Vec2 a2 = this.P2 - this.P1; Vec2 vec = Vec2.Cross(a2, 1f); float num = 100f * Settings.FLT_EPSILON; float num2 = -Vec2.Dot(a, vec); bool result; if (num2 > num) { Vec2 a3 = p - this.P1; float num3 = Vec2.Dot(a3, vec); if (0f <= num3 && num3 <= maxLambda * num2) { float num4 = -a.X * a3.Y + a.Y * a3.X; if (-num * num2 <= num4 && num4 <= num2 * (1f + num)) { num3 /= num2; vec.Normalize(); lambda = num3; normal = vec; result = true; return result; } } } result = false; return result; }
public override void Step(TimeStep step) { if (_bodyList == null) return; if (useWorldGravity) { gravity = _world.Gravity; } for (ControllerEdge i = _bodyList; i != null; i = i.nextBody) { Body body = i.body; if (body.IsSleeping()) { //Buoyancy force is just a function of position, //so unlike most forces, it is safe to ignore sleeping bodes continue; } Vec2 areac = new Vec2(0, 0); Vec2 massc = new Vec2(0, 0); float area = 0; float mass = 0; for (Shape shape = body.GetShapeList(); shape != null; shape = shape.GetNext()) { Vec2 sc; float sarea = shape.ComputeSubmergedArea(normal, offset, body.GetXForm(), out sc); area += sarea; areac.X += sarea * sc.X; areac.Y += sarea * sc.Y; float shapeDensity = 0; if (useDensity) { //TODO: Expose density publicly shapeDensity = shape.Density; } else { shapeDensity = 1; } mass += sarea * shapeDensity; massc.X += sarea * sc.X * shapeDensity; massc.Y += sarea * sc.Y * shapeDensity; } areac.X /= area; areac.Y /= area; massc.X /= mass; massc.Y /= mass; if (area < Box2DX.Common.Settings.FLT_EPSILON) continue; //Buoyancy Vec2 buoyancyForce = -density * area * gravity; body.ApplyForce(buoyancyForce, massc); //Linear drag Vec2 dragForce = body.GetLinearVelocityFromWorldPoint(areac) - velocity; dragForce *= -linearDrag * area; body.ApplyForce(dragForce, areac); //Angular drag //TODO: Something that makes more physical sense? body.ApplyTorque(-body.GetInertia() / body.GetMass() * area * body.GetAngularVelocity() * angularDrag); } }
public static void DrawSegment(Vec2 p1, Vec2 p2, Color color, params object[] p) { Gl.Color3(color.R, color.G, color.B); Gl.Begin(BeginMode.Lines); Gl.Vertex2(p1.X, p1.Y); Gl.Vertex2(p2.X, p2.Y); Gl.End(); }
public void Initialize(Body body1, Body body2, Vec2 anchor) { this.Body1 = body1; this.Body2 = body2; this.LocalAnchor1 = body1.GetLocalPoint(anchor); this.LocalAnchor2 = body2.GetLocalPoint(anchor); this.ReferenceAngle = body2.GetAngle() - body1.GetAngle(); }
public override float ReportFixture(Fixture fixture, Vec2 point, Vec2 normal, float fraction) { _fixture = fixture; _point = point; _normal = normal; return fraction; }
public void SetTarget(Vec2 target) { if (this._body2.IsSleeping()) { this._body2.WakeUp(); } this._target = target; }
public void Initialize(Body body1, Body body2, Vec2 anchor1, Vec2 anchor2) { this.Body1 = body1; this.Body2 = body2; this.LocalAnchor1 = body1.GetLocalPoint(anchor1); this.LocalAnchor2 = body2.GetLocalPoint(anchor2); this.Length = (anchor2 - anchor1).Length(); }
public void Initialize(Body body1, Body body2, Vec2 anchor, Vec2 axis) { this.Body1 = body1; this.Body2 = body2; this.localAnchor1 = body1.GetLocalPoint(anchor); this.localAnchor2 = body2.GetLocalPoint(anchor); this.localAxis1 = body1.GetLocalVector(axis); }
/// <summary> /// Initialize the bodies, anchors, axis, and reference angle using the world /// anchor and world axis. /// </summary> /// <param name="body1"></param> /// <param name="body2"></param> /// <param name="anchor"></param> /// <param name="axis"></param> public void Initialize(Body body1, Body body2, Vec2 anchor, Vec2 axis) { Body1 = body1; Body2 = body2; LocalAnchor1 = body1.GetLocalPoint(anchor); LocalAnchor2 = body2.GetLocalPoint(anchor); LocalAxis1 = body1.GetLocalVector(axis); ReferenceAngle = body2.GetAngle() - body1.GetAngle(); }
public static void DrawPoint(Vec2 p, float size, Color color) { Gl.glPointSize(size); Gl.glBegin(Gl.GL_POINTS); Gl.glColor3f(color.R, color.G, color.B); Gl.glVertex2f(p.X, p.Y); Gl.glEnd(); Gl.glPointSize(1.0f); }
/// <summary> /// Initialize the bodies, anchors, and length using the world anchors. /// </summary> public void Initialize(Body body1, Body body2, Vec2 anchor1, Vec2 anchor2) { Body1 = body1; Body2 = body2; LocalAnchor1 = body1.GetLocalPoint(anchor1); LocalAnchor2 = body2.GetLocalPoint(anchor2); Vec2 d = anchor2 - anchor1; Length = d.Length(); }
public static void DrawPoint(Vec2 p, float size, Color color) { Gl.PointSize(size); Gl.Begin(BeginMode.Points); Gl.Color3(color.R, color.G, color.B); Gl.Vertex2(p.X, p.Y); Gl.End(); Gl.PointSize(1.0f); }
internal CircleShape(ShapeDef def) : base(def) { Box2DXDebug.Assert(def.Type == ShapeType.CircleShape); CircleDef circleDef = (CircleDef)def; this._type = ShapeType.CircleShape; this._localPosition = circleDef.LocalPosition; this._radius = circleDef.Radius; }
public void Advance(float t) { if (this.T0 < t && 1f - this.T0 > Math.FLOAT32_EPSILON) { float num = (t - this.T0) / (1f - this.T0); this.C0 = (1f - num) * this.C0 + num * this.C; this.A0 = (1f - num) * this.A0 + num * this.A; this.T0 = t; } }
public float T0; //time interval = [T0,1], where T0 is in [0,1] #endregion Fields #region Methods /// <summary> /// Advance the sweep forward, yielding a new initial state. /// </summary> /// <param name="t">The new initial time.</param> public void Advance(float t) { if (T0 < t && 1.0f - T0 > Math.FLOAT32_EPSILON) { float alpha = (t - T0) / (1.0f - T0); C0 = (1.0f - alpha) * C0 + alpha * C; A0 = (1.0f - alpha) * A0 + alpha * A; T0 = t; } }
public override void DrawPolygon(Vec2[] vertices, int vertexCount, Color color) { Gl.glColor3f(color.R, color.G, color.B); Gl.glBegin(Gl.GL_LINE_LOOP); for (int i = 0; i < vertexCount; ++i) { Gl.glVertex2f(vertices[i].X, vertices[i].Y); } Gl.glEnd(); }
/// <summary> /// Advance the sweep forward, yielding a new initial state. /// </summary> /// <param name="t">The new initial time.</param> public void Advance(float t) { if (T0 < t && 1.0f - T0 > Settings.FLT_EPSILON) { float alpha = (t - T0) / (1.0f - T0); C0 = (1.0f - alpha) * C0 + alpha * C; A0 = (1.0f - alpha) * A0 + alpha * A; T0 = t; } }
public void SetAsBox(float hx, float hy, Vec2 center, float angle) { this.SetAsBox(hx, hy); XForm t = default(XForm); t.Position = center; t.R.Set(angle); for (int i = 0; i < this.VertexCount; i++) { this.Vertices[i] = Box2DX.Common.Math.Mul(t, this.Vertices[i]); } }
public override void DrawPolygon(Vec2[] vertices, int vertexCount, Color color) { GL.Color3(color.R, color.G, color.B); GL.Disable(EnableCap.Texture2D); GL.Begin(BeginMode.LineLoop); for (int i = 0; i < vertexCount; ++i) { GL.Vertex3(vertices[i].X, vertices[i].Y, ZLayer); } GL.End(); GL.Enable(EnableCap.Texture2D); }
/// <summary> /// Solve A * x = b, where b is a column vector. This is more efficient /// than computing the inverse in one-shot cases. Solve only the upper /// 2-by-2 matrix equation. /// </summary> public Vec2 Solve22(Vec2 b) { float a11 = Col1.X, a12 = Col2.X, a21 = Col1.Y, a22 = Col2.Y; float det = a11 * a22 - a12 * a21; Box2DXDebug.Assert(det != 0.0f); det = 1.0f / det; Vec2 x = new Vec2(); x.X = det * (a22 * b.X - a12 * b.Y); x.Y = det * (a11 * b.Y - a21 * b.X); return x; }
/// <summary> /// Build vertices to represent an oriented box. /// </summary> /// <param name="hx">The half-width</param> /// <param name="hy">The half-height.</param> /// <param name="center">The center of the box in local coordinates.</param> /// <param name="angle">The rotation of the box in local coordinates.</param> public void SetAsBox(float hx, float hy, Vec2 center, float angle) { SetAsBox(hx, hy); XForm xf = new XForm(); xf.Position = center; xf.R.Set(angle); for (int i = 0; i < VertexCount; ++i) { Vertices[i] = Common.Math.Mul(xf, Vertices[i]); } }
public BuoyancyController() { normal = new Vec2(0,1); offset = 0; density =0; velocity = new Vec2(0,0); linearDrag=0; angularDrag=0; useDensity = false; useWorldGravity = true; gravity = new Vec2(0,0); }
public DistanceJoint(DistanceJointDef def) : base(def) { _localAnchor1 = def.LocalAnchor1; _localAnchor2 = def.LocalAnchor2; _length = def.Length; _frequencyHz = def.FrequencyHz; _dampingRatio = def.DampingRatio; _impulse = 0.0f; _gamma = 0.0f; _bias = 0.0f; }
public void Set(Vec2 v1, Vec2 v2) { _v1 = v1; _v2 = v2; _direction = _v2 - _v1; _length = _direction.Normalize(); _normal = Vec2.Cross(_direction, 1.0f); _cornerDir1 = _normal; _cornerDir2 = -1.0f * _normal; }
public override void DrawSegment(Vec2 p1, Box2DX.Common.Vec2 p2, Color color) { GL.Color3(color.R, color.G, color.B); GL.Disable(EnableCap.Texture2D); GL.Begin(BeginMode.Lines); { GL.Vertex3(p1.X, p1.Y, ZLayer); GL.Vertex3(p2.X, p2.Y, ZLayer); } GL.End(); GL.Enable(EnableCap.Texture2D); }
/// <summary> /// Copy vertices. This assumes the vertices define a convex polygon. /// It is assumed that the exterior is the the right of each edge. /// </summary> public void Set(Vec2[] vertices, int count) { Box2DXDebug.Assert(3 <= count && count <= Settings.MaxPolygonVertices); _vertexCount = count; int i; // Copy vertices. for (i = 0; i < _vertexCount; ++i) { _vertices[i] = vertices[i]; } // Compute normals. Ensure the edges have non-zero length. for (i = 0; i < _vertexCount; ++i) { int i1 = i; int i2 = i + 1 < count ? i + 1 : 0; Vec2 edge = _vertices[i2] - _vertices[i1]; Box2DXDebug.Assert(edge.LengthSquared() > Settings.FLT_EPSILON_SQUARED); _normals[i] = Vec2.Cross(edge, 1.0f); _normals[i].Normalize(); } #if DEBUG // Ensure the polygon is convex and the interior // is to the left of each edge. for (i = 0; i < _vertexCount; ++i) { int i1 = i; int i2 = i + 1 < count ? i + 1 : 0; Vec2 edge = _vertices[i2] - _vertices[i1]; for (int j = 0; j < _vertexCount; ++j) { // Don't check vertices on the current edge. if (j == i1 || j == i2) { continue; } Vec2 r = _vertices[j] - _vertices[i1]; // Your polygon is non-convex (it has an indentation) or // has colinear edges. float s = Vec2.Cross(edge, r); Box2DXDebug.Assert(s > 0.0f); } } #endif // Compute the polygon centroid. _centroid = ComputeCentroid(_vertices, _vertexCount); }