/// Compute the collision manifold between two circles. public static void b2CollideCircles(ref b2Manifold manifold, b2CircleShape circleA, ref b2Transform xfA, b2CircleShape circleB, ref b2Transform xfB) { manifold.pointCount = 0; b2Vec2 pA = b2Math.b2Mul(xfA, circleA.Position); b2Vec2 pB = b2Math.b2Mul(xfB, circleB.Position); b2Vec2 d;// = pB - pA; d.x = pB.x - pA.x; d.y = pB.y - pA.y; float distSqr = d.LengthSquared; float rA = circleA.Radius, rB = circleB.Radius; float radius = rA + rB; if (distSqr > radius * radius) { return; } manifold.type = b2ManifoldType.e_circles; manifold.localPoint = circleA.Position; manifold.localNormal.SetZero(); manifold.pointCount = 1; manifold.points[0].localPoint = circleB.Position; manifold.points[0].id.key = 0; }
private void scaleShape(b2Shape shape, bool isOnlyCenter = false) { if (shape is b2PolygonShape) { b2PolygonShape poly = shape as b2PolygonShape; List <b2Vec2> vertices = poly.GetVertices(); for (int i = 0; i < vertices.Count; i++) { vertices[i].x *= transform.lossyScale.x; vertices[i].y *= transform.lossyScale.y; } } else if (shape is b2CircleShape) { b2CircleShape circle = shape as b2CircleShape; if (!isOnlyCenter) { float scale = Mathf.Max(transform.lossyScale.x, transform.lossyScale.y); circle.SetRadius(circle.GetRadius() * scale); } var offset = circle.GetLocalPosition(); offset.x *= transform.lossyScale.x; offset.y *= transform.lossyScale.y; circle.SetLocalPosition(offset); } }
public SphereStack() { { b2BodyDef bd = new b2BodyDef(); b2Body ground = m_world.CreateBody(bd); b2EdgeShape shape = new b2EdgeShape(); shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f)); ground.CreateFixture(shape, 0.0f); } { b2CircleShape shape = new b2CircleShape(); shape.Radius = 1.0f; for (int i = 0; i < e_count; ++i) { b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.position.Set(0.0f, 4.0f + 3.0f * i); m_bodies[i] = m_world.CreateBody(bd); m_bodies[i].CreateFixture(shape, 1.0f); m_bodies[i].LinearVelocity = new b2Vec2(0.0f, -50.0f); } } }
public override void Keyboard(char key) { switch (key) { case ',': if (m_bullet != null) { m_world.DestroyBody(m_bullet); m_bullet = null; } { b2CircleShape shape = new b2CircleShape(); shape.Radius = 0.25f; b2FixtureDef fd = new b2FixtureDef(); fd.shape = shape; fd.density = 20.0f; fd.restitution = 0.05f; b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.bullet = true; bd.position.Set(-31.0f, 5.0f); m_bullet = m_world.CreateBody(bd); m_bullet.CreateFixture(fd); m_bullet.LinearVelocity = new b2Vec2(400.0f, 0.0f); } break; } }
public void Set(b2Shape shape, int index) { switch (shape.ShapeType) { case b2ShapeType.e_circle: { b2CircleShape circle = (b2CircleShape)shape; m_buffer[0] = circle.Position; m_vertices = m_buffer; m_count = 1; m_radius = circle.Radius; } break; case b2ShapeType.e_polygon: { b2PolygonShape polygon = (b2PolygonShape)shape; m_vertices = polygon.Vertices; m_count = polygon.VertexCount; m_radius = polygon.Radius; } break; case b2ShapeType.e_chain: { b2ChainShape chain = (b2ChainShape)shape; Debug.Assert(0 <= index && index < chain.Count); m_buffer[0] = chain.Vertices[index]; if (index + 1 < chain.Count) { m_buffer[1] = chain.Vertices[index + 1]; } else { m_buffer[1] = chain.Vertices[0]; } m_vertices = m_buffer; m_count = 2; m_radius = chain.Radius; } break; case b2ShapeType.e_edge: { b2EdgeShape edge = (b2EdgeShape)shape; m_buffer[0] = edge.Vertex1; m_buffer[1] = edge.Vertex2; m_vertices = m_buffer; m_count = 2; m_radius = edge.Radius; } break; default: Debug.Assert(false); break; } }
void MakeCircle(b2Vec2 pos, float radius) { // Define the dynamic body. We set its position and call the body factory. b2BodyDef bodyDef = new b2BodyDef(); bodyDef.type = b2BodyType.b2_dynamicBody; bodyDef.position = pos; var body = world.CreateBody(bodyDef); // Define another box shape for our dynamic body. b2CircleShape dynamicBox = new b2CircleShape(); dynamicBox.m_radius = radius; // Define the dynamic body fixture. b2FixtureDef fixtureDef = new b2FixtureDef(); fixtureDef.shape = dynamicBox; // Set the box density to be non-zero, so it will be dynamic. fixtureDef.density = 1.0f; // Override the default friction. fixtureDef.friction = 0.3f; // Add the shape to the body. body.CreateFixture(fixtureDef); }
public override void Keyboard(char key) { switch (key) { case 'c': if (m_fixture2 == null) { b2CircleShape shape = new b2CircleShape(); shape.Radius = 3.0f; shape.Position = new b2Vec2(0.5f, -4.0f); m_fixture2 = m_body.CreateFixture(shape, 10.0f); m_body.SetAwake(true); } break; case 'd': if (m_fixture2 != null) { m_body.DestroyFixture(m_fixture2); m_fixture2 = null; m_body.SetAwake(true); } break; case 's': if (m_fixture2 != null) { m_sensor = !m_sensor; m_fixture2.IsSensor = m_sensor; } break; } }
void CreateNinja() { spriteImageName = String.Format("{0}_standing", baseImageName); onGround = false; // Define the dynamic body. var bodyDef = new b2BodyDef(); bodyDef.type = b2BodyType.b2_staticBody; //or you could use b2DynamicBody to start the ninja as dynamic bodyDef.position.Set(initialLocation.X / Constants.PTM_RATIO, initialLocation.Y / Constants.PTM_RATIO); var shape = new b2CircleShape(); var radiusInMeters = (40 / Constants.PTM_RATIO) * 0.5f; //increase or decrease 40 for a different circle size definition shape.Radius = radiusInMeters; // Define the dynamic body fixture. var fixtureDef = new b2FixtureDef(); fixtureDef.shape = shape; fixtureDef.density = 1.0f; fixtureDef.friction = 1.0f; fixtureDef.restitution = 0.1f; CreateBodyWithSpriteAndFixture(theWorld, bodyDef, fixtureDef, spriteImageName); }
/// Compute the collision manifold between two circles. public static void b2CollideCircles(b2Manifold manifold, b2CircleShape circleA, ref b2Transform xfA, b2CircleShape circleB, ref b2Transform xfB) { manifold.pointCount = 0; float pAx = (xfA.q.c * circleA.Position.x - xfA.q.s * circleA.Position.y) + xfA.p.x; float pAy = (xfA.q.s * circleA.Position.x + xfA.q.c * circleA.Position.y) + xfA.p.y; float pBx = (xfB.q.c * circleB.Position.x - xfB.q.s * circleB.Position.y) + xfB.p.x; float pBy = (xfB.q.s * circleB.Position.x + xfB.q.c * circleB.Position.y) + xfB.p.y; float dx = pBx - pAx; float dy = pBy - pAy; float distSqr = dx * dx + dy * dy; float rA = circleA.Radius, rB = circleB.Radius; float radius = rA + rB; if (distSqr > radius * radius) { return; } manifold.type = b2ManifoldType.e_circles; manifold.localPoint = circleA.Position; manifold.localNormal = b2Vec2.Zero; manifold.pointCount = 1; manifold.points[0].localPoint = circleB.Position; manifold.points[0].id.key = 0; }
public override void Step(Settings settings) { base.Step(settings); // Traverse the contact results. Apply a force on shapes // that overlap the sensor. for (int i = 0; i < e_count; ++i) { if (m_touching[i] == false) { continue; } b2Body body = m_bodies[i]; b2Body ground = m_sensor.Body; b2CircleShape circle = (b2CircleShape)m_sensor.Shape; b2Vec2 center = ground.GetWorldPoint(circle.Position); b2Vec2 position = body.Position; b2Vec2 d = center - position; if (d.LengthSquared < float.Epsilon * float.Epsilon) { continue; } d.Normalize(); b2Vec2 F = 100.0f * d; body.ApplyForce(F, position); } }
/// Compute the collision manifold between two circles. public static void b2CollideCircles(ref b2Manifold manifold, b2CircleShape circleA, ref b2Transform xfA, b2CircleShape circleB, ref b2Transform xfB) { manifold.pointCount = 0; b2Vec2 pA = b2Math.b2Mul(xfA, circleA.Position); b2Vec2 pB = b2Math.b2Mul(xfB, circleB.Position); b2Vec2 d = pB - pA; float distSqr = b2Math.b2Dot(d, d); float rA = circleA.Radius, rB = circleB.Radius; float radius = rA + rB; if (distSqr > radius * radius) { return; } manifold.type = b2ManifoldType.e_circles; manifold.localPoint = circleA.Position; manifold.localNormal.SetZero(); manifold.pointCount = 1; manifold.points[0].localPoint = circleB.Position; manifold.points[0].id = b2ContactFeature.Zero; }
void AddBall() { int idx = (CCRandom.Float_0_1() > .5 ? 0 : 1); int idy = (CCRandom.Float_0_1() > .5 ? 0 : 1); var sprite = new CCPhysicsSprite(ballTexture, new CCRect(32 * idx, 32 * idy, 32, 32), PTM_RATIO); ballsBatch.AddChild(sprite); CCPoint p = GetRandomPosition(sprite.ContentSize); sprite.Position = new CCPoint(p.X, p.Y); var def = new b2BodyDef(); def.position = new b2Vec2(p.X / PTM_RATIO, p.Y / PTM_RATIO); def.linearVelocity = new b2Vec2(0.0f, -1.0f); def.type = b2BodyType.b2_dynamicBody; b2Body body = world.CreateBody(def); var circle = new b2CircleShape(); circle.Radius = 0.5f; var fd = new b2FixtureDef(); fd.shape = circle; fd.density = 1f; fd.restitution = 0.85f; fd.friction = 0f; body.CreateFixture(fd); sprite.PhysicsBody = body; Console.WriteLine("sprite batch node count = {0}", ballsBatch.ChildrenCount); }
public void DrawFixture(b2Fixture fixture) { b2Color color = new b2Color(0.95f, 0.95f, 0.6f); b2Transform xf = fixture.Body.Transform; switch (fixture.ShapeType) { case b2ShapeType.e_circle: { b2CircleShape circle = (b2CircleShape)fixture.Shape; b2Vec2 center = b2Math.b2Mul(xf, circle.Position); float radius = circle.Radius; m_debugDraw.DrawCircle(center, radius, color); } break; case b2ShapeType.e_polygon: { b2PolygonShape poly = (b2PolygonShape)fixture.Shape; int vertexCount = poly.VertexCount; Debug.Assert(vertexCount <= b2Settings.b2_maxPolygonVertices); b2Vec2[] vertices = new b2Vec2[b2Settings.b2_maxPolygonVertices]; for (int i = 0; i < vertexCount; ++i) { vertices[i] = b2Math.b2Mul(xf, poly.Vertices[i]); } m_debugDraw.DrawPolygon(vertices, vertexCount, color); } break; } }
public VaryingRestitution() { { b2BodyDef bd = new b2BodyDef(); b2Body ground = m_world.CreateBody(bd); b2EdgeShape shape = new b2EdgeShape(); shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f)); ground.CreateFixture(shape, 0.0f); } { b2CircleShape shape = new b2CircleShape(); shape.Radius = 1.0f; b2FixtureDef fd = new b2FixtureDef(); fd.shape = shape; fd.density = 1.0f; float[] restitution = { 0.0f, 0.1f, 0.3f, 0.5f, 0.75f, 0.9f, 1.0f }; for (int i = 0; i < 7; ++i) { b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.position.Set(-10.0f + 3.0f * i, 20.0f); b2Body body = m_world.CreateBody(bd); fd.restitution = restitution[i]; body.CreateFixture(fd); } } }
public static void b2CollideCircles(b2Manifold manifold, b2CircleShape circleA, b2Transform xfA, b2CircleShape circleB, b2Transform xfB) { Box2DPINVOKE.b2CollideCircles(b2Manifold.getCPtr(manifold), b2CircleShape.getCPtr(circleA), b2Transform.getCPtr(xfA), b2CircleShape.getCPtr(circleB), b2Transform.getCPtr(xfB)); if (Box2DPINVOKE.SWIGPendingException.Pending) { throw Box2DPINVOKE.SWIGPendingException.Retrieve(); } }
/// Implement b2Shape. public override b2Shape Clone() { b2CircleShape clone = new b2CircleShape(); clone.m_p = m_p; clone.m_radius = m_radius; return(clone); }
private void createWithCollider2d(Collider2D coll) { b2FixtureDef fixtureDef = new b2FixtureDef(); PhysicsMaterial2D material = coll.sharedMaterial; if (material != null) { fixtureDef.restitution = material.bounciness; fixtureDef.friction = material.friction; } fixtureDef.isSensor = coll.isTrigger; if (coll is BoxCollider2D) { BoxCollider2D boxColl = coll as BoxCollider2D; b2PolygonShape s = b2PolygonShape.AsOrientedBox(boxColl.size.x * 0.5f, boxColl.size.y * 0.5f, new b2Vec2(boxColl.offset.x, boxColl.offset.y), 0 /*transform.eulerAngles.z*Mathf.Deg2Rad*/); scaleShape(s); fixtureDef.shape = s; _fixtureDict[coll] = new b2Fixture[] { _body.CreateFixture(fixtureDef) }; } else if (coll is CircleCollider2D) { CircleCollider2D circleColl = coll as CircleCollider2D; b2CircleShape s = new b2CircleShape(circleColl.radius); s.SetLocalPosition(new b2Vec2(circleColl.offset.x, circleColl.offset.y)); scaleShape(s); fixtureDef.shape = s; _fixtureDict[coll] = new b2Fixture[] { _body.CreateFixture(fixtureDef) }; } else if (coll is PolygonCollider2D) { int i, j; PolygonCollider2D polyColl = coll as PolygonCollider2D; List <b2Fixture> fixtureList = new List <b2Fixture>(); int pathCount = polyColl.pathCount; for (i = 0; i < pathCount; i++) { Vector2[] path = polyColl.GetPath(i); b2Vec2[] vertices = new b2Vec2[path.Length]; for (j = 0; j < path.Length; j++) { vertices[j] = new b2Vec2(path[j].x, path[j].y); } b2Separator sep = new b2Separator(); b2Fixture[] fixtures = sep.Separate(_body, fixtureDef, vertices, 100, polyColl.offset.x, polyColl.offset.y); //必须放大100倍进行计算 for (j = 0; j < fixtures.Length; j++) { scaleShape(fixtures[j].GetShape()); } fixtureList.AddRange(fixtures); } _fixtureDict[coll] = fixtureList.ToArray(); } }
/// Initialize the proxy using the given shape. The shape /// must remain in scope while the proxy is in use. public void Set(b2Shape shape, int index) { switch (shape.GetType()) { case b2Shape.Type.e_circle: { b2CircleShape circle = (b2CircleShape)shape; m_vertices = new [] { circle.m_p }; m_count = 1; m_radius = circle.m_radius; } break; case b2Shape.Type.e_polygon: { b2PolygonShape polygon = (b2PolygonShape)shape; m_vertices = (b2Vec2[])polygon.m_vertices.Clone(); m_count = polygon.m_count; m_radius = polygon.m_radius; } break; case b2Shape.Type.e_chain: { b2ChainShape chain = (b2ChainShape)shape; Debug.Assert(0 <= index && index < chain.m_count); m_buffer[0] = chain.m_vertices[index]; if (index + 1 < chain.m_count) { m_buffer[1] = chain.m_vertices[index + 1]; } else { m_buffer[1] = chain.m_vertices[0]; } m_vertices = m_buffer; m_count = 2; m_radius = chain.m_radius; } break; case b2Shape.Type.e_edge: { b2EdgeShape edge = (b2EdgeShape)shape; m_vertices = new [] { edge.m_vertex1, edge.m_vertex2 }; m_count = 2; m_radius = edge.m_radius; } break; default: Debug.Assert(false); break; } }
public ContinuousTest() { { b2BodyDef bd = new b2BodyDef(); bd.position.Set(0.0f, 0.0f); b2Body body = m_world.CreateBody(bd); b2EdgeShape edge = new b2EdgeShape(); edge.Set(new b2Vec2(-10.0f, 0.0f), new b2Vec2(10.0f, 0.0f)); body.CreateFixture(edge, 0.0f); b2PolygonShape shape = new b2PolygonShape(); shape.SetAsBox(0.2f, 1.0f, new b2Vec2(0.5f, 1.0f), 0.0f); body.CreateFixture(shape, 0.0f); } #if true { b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.position.Set(0.0f, 20.0f); //bd.angle = 0.1f; b2PolygonShape shape = new b2PolygonShape(); shape.SetAsBox(2.0f, 0.1f); m_body = m_world.CreateBody(bd); m_body.CreateFixture(shape, 1.0f); m_angularVelocity = Rand.RandomFloat(-50.0f, 50.0f); //m_angularVelocity = 46.661274f; m_body.LinearVelocity = new b2Vec2(0.0f, -100.0f); m_body.AngularVelocity = m_angularVelocity; } #else { b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.position.Set(0.0f, 2.0f); b2Body body = m_world.CreateBody(bd); b2CircleShape shape = new b2CircleShape(); shape.Position = b2Vec2.Zero; shape.Radius = 0.5f; body.CreateFixture(shape, 1.0f); bd.bullet = true; bd.position.Set(0.0f, 10.0f); body = m_world.CreateBody(bd); body.CreateFixture(shape, 1.0f); body.LinearVelocity = new b2Vec2(0.0f, -100.0f); } #endif }
public Pulleys() { float y = 16.0f; float L = 12.0f; float a = 1.0f; float b = 2.0f; b2Body ground = null; { b2BodyDef bd = new b2BodyDef(); ground = m_world.CreateBody(bd); b2EdgeShape edge = new b2EdgeShape(); edge.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f)); //ground->CreateFixture(&shape, 0.0f); b2CircleShape circle = new b2CircleShape(); circle.Radius = 2.0f; circle.Position = new b2Vec2(-10.0f, y + b + L); ground.CreateFixture(circle, 0.0f); circle.Position = new b2Vec2(10.0f, y + b + L); ground.CreateFixture(circle, 0.0f); } { b2PolygonShape shape = new b2PolygonShape(); shape.SetAsBox(a, b); b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; //bd.fixedRotation = true; bd.position.Set(-10.0f, y); b2Body body1 = m_world.CreateBody(bd); body1.CreateFixture(shape, 5.0f); bd.position.Set(10.0f, y); b2Body body2 = m_world.CreateBody(bd); body2.CreateFixture(shape, 5.0f); b2PulleyJointDef pulleyDef = new b2PulleyJointDef(); b2Vec2 anchor1 = new b2Vec2(-10.0f, y + b); b2Vec2 anchor2 = new b2Vec2(10.0f, y + b); b2Vec2 groundAnchor1 = new b2Vec2(-10.0f, y + b + L); b2Vec2 groundAnchor2 = new b2Vec2(10.0f, y + b + L); pulleyDef.Initialize(body1, body2, groundAnchor1, groundAnchor2, anchor1, anchor2, 1.5f); m_joint1 = (b2PulleyJoint)m_world.CreateJoint(pulleyDef); } }
public Confined() { { b2BodyDef bd = new b2BodyDef(); b2Body ground = m_world.CreateBody(bd); b2EdgeShape shape = new b2EdgeShape(); // Floor shape.Set(new b2Vec2(-10.0f, 0.0f), new b2Vec2(10.0f, 0.0f)); ground.CreateFixture(shape, 0.0f); // Left wall shape.Set(new b2Vec2(-10.0f, 0.0f), new b2Vec2(-10.0f, 20.0f)); ground.CreateFixture(shape, 0.0f); // Right wall shape.Set(new b2Vec2(10.0f, 0.0f), new b2Vec2(10.0f, 20.0f)); ground.CreateFixture(shape, 0.0f); // Roof shape.Set(new b2Vec2(-10.0f, 20.0f), new b2Vec2(10.0f, 20.0f)); ground.CreateFixture(shape, 0.0f); } float radius = 0.5f; b2CircleShape shape1 = new b2CircleShape(); shape1.Position = b2Vec2.Zero; shape1.Radius = radius; b2FixtureDef fd = new b2FixtureDef(); fd.shape = shape1; fd.density = 1.0f; fd.friction = 0.1f; for (int j = 0; j < e_columnCount; ++j) { for (int i = 0; i < e_rowCount; ++i) { b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.position.Set(-10.0f + (2.1f * j + 1.0f + 0.01f * i) * radius, (2.0f * i + 1.0f) * radius); b2Body body = m_world.CreateBody(bd); body.CreateFixture(fd); } } m_world.Gravity = new b2Vec2(0.0f, 0.0f); }
public SensorTest() { { b2BodyDef bd = new b2BodyDef(); b2Body ground = m_world.CreateBody(bd); { b2EdgeShape shape = new b2EdgeShape(); shape.Set(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f)); ground.CreateFixture(shape, 0.0f); } #if false { b2FixtureDef sd = new b2FixtureDef(); sd.SetAsBox(10.0f, 2.0f, new b2Vec2(0.0f, 20.0f), 0.0f); sd.isSensor = true; m_sensor = ground.CreateFixture(sd); } #else { b2CircleShape shape = new b2CircleShape(); shape.Radius = 5.0f; shape.Position = new b2Vec2(0.0f, 10.0f); b2FixtureDef fd = new b2FixtureDef(); fd.shape = shape; fd.isSensor = true; m_sensor = ground.CreateFixture(fd); } #endif } { b2CircleShape shape = new b2CircleShape(); shape.Radius = 1.0f; for (int i = 0; i < e_count; ++i) { b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.position.Set(-10.0f + 3.0f * i, 20.0f); bd.userData = i; // m_touching[i]; m_touching[i] = false; m_bodies[i] = m_world.CreateBody(bd); m_bodies[i].CreateFixture(shape, 1.0f); } } }
public PhysicalShapeEditor(Rect frameRect) { InitializeComponent(); this.fixtureDef = new b2FixtureDef(IntPtr.Zero); this.propertyGrid.SelectedObject = this.fixtureDef; this.rect = frameRect; this.circleShape = new b2CircleShape(IntPtr.Zero); this.polygonShape = new b2PolygonShape(IntPtr.Zero); this.nBox_Rect_H_meter.Value = (decimal)(Math.Abs(rect.GetHeight()) / Scene.meterPixelRatio); this.nBox_Rect_W_meter.Value = (decimal)(Math.Abs(rect.GetWidth()) / Scene.meterPixelRatio); CreateMohitCircle(); this.fixtureDef.شکل = this.circleShape; }
/**在编辑器更改碰撞器Center时*/ public void onEditShapeCenter(object[] args) { Collider2D collider = (Collider2D)args [0]; float cx = (float)args [1]; float cy = (float)args [2]; float oldCX = (float)args[3]; float oldCY = (float)args[4]; b2Fixture[] fixtures = _fixtureDict [collider]; if (fixtures != null) { for (int i = 0; i < fixtures.Length; i++) { b2Fixture fixture = fixtures[i]; b2Shape s = fixture.GetShape(); if (collider is BoxCollider2D) { b2PolygonShape boxShape = s as b2PolygonShape; BoxCollider2D boxColl = collider as BoxCollider2D; boxShape.SetAsOrientedBox(boxColl.size.x * 0.5f, boxColl.size.y * 0.5f, new b2Vec2(cx, cy), 0); scaleShape(boxShape); _body.SetAwake(true); } else if (collider is CircleCollider2D) { b2CircleShape circleShape = s as b2CircleShape; circleShape.SetLocalPosition(new b2Vec2(cx, cy)); scaleShape(circleShape, true); _body.SetAwake(true); } else if (collider is PolygonCollider2D) { b2PolygonShape polyShape = s as b2PolygonShape; PolygonCollider2D polyColl = collider as PolygonCollider2D; List <b2Vec2> vertices = polyShape.GetVertices(); for (int j = 0; j < vertices.Count; j++) { b2Vec2 v = vertices[j]; v.x -= oldCX; v.y -= oldCY; v.x += cx; v.y += cy; } //scaleShape(polyShape); _body.SetAwake(true); } } } }
protected b2Body createCircle(float radius, float x, float y) { b2BodyDef bodyDef = new b2BodyDef(); bodyDef.type = b2Body.b2_dynamicBody; bodyDef.position.Set(x / ptm_ratio, y / ptm_ratio); b2Body body = _world.CreateBody(bodyDef); b2CircleShape s = new b2CircleShape(radius / ptm_ratio); b2FixtureDef fixtrureDef = new b2FixtureDef(); fixtrureDef.shape = s; body.CreateFixture(fixtrureDef); return(body); }
private void checkBounds() { for (int i = 0; i < liquid.Length; ++i) { if (liquid[i].WorldCenter.y < -10.0f) { m_world.DestroyBody(liquid[i]); float massPerParticle = totalMass / nParticles; var pd = new b2CircleShape(); var fd = new b2FixtureDef(); fd.shape = pd; fd.density = 1.0f; fd.filter.groupIndex = -10; pd.Radius = .05f; fd.restitution = 0.4f; fd.friction = 0.0f; float cx = 0.0f + Rand.RandomFloat(-0.6f, 0.6f); float cy = 15.0f + Rand.RandomFloat(-2.3f, 2.0f); var bd = new b2BodyDef(); bd.position = new b2Vec2(cx, cy); bd.fixedRotation = true; bd.type = b2BodyType.b2_dynamicBody; var b = m_world.CreateBody(bd); b.CreateFixture(fd).UserData = LIQUID_INT; var md = new b2MassData(); md.mass = massPerParticle; md.I = 1.0f; b.SetMassData(md); b.SetSleepingAllowed(false); liquid[i] = b; } } if (bod.WorldCenter.y < -15.0f) { m_world.DestroyBody(bod); var polyDef = new b2PolygonShape(); polyDef.SetAsBox(Rand.RandomFloat(0.3f, 0.7f), Rand.RandomFloat(0.3f, 0.7f)); var bodyDef = new b2BodyDef(); bodyDef.position = new b2Vec2(0.0f, 25.0f); bodyDef.type = b2BodyType.b2_dynamicBody; bod = m_world.CreateBody(bodyDef); bod.CreateFixture(polyDef, 1f); } }
private void AddBall() { //Ball float ballDiameter = _gameWidth * BALL_RADIUS_PERCENT; float ballCenterX = _gameWidth * BALL_X_PERCENT; float ballCenterY = ballDiameter / 2 + BALL_Y_MARGIN; var def = new b2BodyDef(); def.position = new b2Vec2(ballCenterX / App.PTM_RATIO, ballCenterY / App.PTM_RATIO); def.type = b2BodyType.b2_dynamicBody; b2Body physBody = _world.CreateBody(def); //Circle Physics Shape var shape = new b2CircleShape(); shape.Radius = ballDiameter / 2 / App.PTM_RATIO; var fd = new b2FixtureDef(); fd.shape = shape; fd.density = 1f; fd.restitution = BALL_RECOIL; fd.friction = BALL_FRICTION; physBody.CreateFixture(fd); _contactListener.Ball = physBody; CCTexture2D ballTex = null; if (string.IsNullOrWhiteSpace(_ballFilename)) { ballTex = new CCTexture2D("soccer"); } else { FileStream fs = new FileStream(_ballFilename, FileMode.Open); ballTex = new CCTexture2D(fs); } _ballN = new CCPhysicsSprite(ballTex, physBody) { PositionX = ballCenterX, PositionY = ballCenterY, ContentSize = new CCSize(ballDiameter, ballDiameter) }; AddChild(_ballN); }
public void createCircleWithDictionary(PlistDictionary dict, b2Body body, CCNode node, LHScene scene, CCSize size) { _shapeID = dict ["shapeID"].AsInt; _shapeName = dict ["name"].AsString; b2CircleShape shape = new b2CircleShape(); shape.Radius = size.Width * 0.5f; b2FixtureDef fixture = new b2FixtureDef(); LHSetupb2FixtureWithInfo(fixture, dict); fixture.userData = this; fixture.shape = shape; body.CreateFixture(fixture); }
public AddPair() { m_world.Gravity = new b2Vec2(0.0f, 0.0f); { b2CircleShape shape = new b2CircleShape(); shape.Position = b2Vec2.Zero; shape.Radius = 0.1f; float minX = -6.0f; float maxX = 0.0f; float minY = 4.0f; float maxY = 6.0f; for (int i = 0; i < 400; ++i) { b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.position = new b2Vec2(Rand.RandomFloat(minX, maxX), Rand.RandomFloat(minY, maxY)); b2Body body = m_world.CreateBody(bd); body.CreateFixture(shape, 0.01f); } } { b2Shape shape = null; if (_DoCircle) { shape = new b2CircleShape(); ((b2CircleShape)shape).Radius = 1.5f; } else { shape = new b2PolygonShape(); ((b2PolygonShape)shape).SetAsBox(1.6f, 1.6f); } b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.position = new b2Vec2(-40.0f, 5.0f); bd.bullet = true; b2Body body = m_world.CreateBody(bd); body.CreateFixture(shape, 1.0f); body.LinearVelocity = new b2Vec2(150.0f, 0.0f); } }
/** * Initialize the proxy using the given shape. The shape * must remain in scope while the proxy is in use. */ public void Set(b2Shape shape) { /*switch(shape.GetType()) * { * case b2Shape.e_circleShape: * { * b2CircleShape circle = shape as b2CircleShape; * m_vertices = new List<b2Vec2>(); * m_vertices[0] = circle.m_p; * m_count = 1; * m_radius = circle.m_radius; * } * break; * case b2Shape.e_polygonShape: * { * b2PolygonShape polygon = shape as b2PolygonShape; * m_vertices = polygon.m_vertices; * m_count = polygon.m_vertexCount; * m_radius = polygon.m_radius; * } * break; * default: * b2Settings.b2Assert(false); * }*/ if (shape.GetType() == b2Shape.e_circleShape) { b2CircleShape circle = shape as b2CircleShape; m_vertices = new List <b2Vec2>(); m_vertices.Add(circle.m_p); m_count = 1; m_radius = circle.m_radius; } else if (shape.GetType() == b2Shape.e_polygonShape) { b2PolygonShape polygon = shape as b2PolygonShape; m_vertices = polygon.m_vertices; m_count = polygon.m_vertexCount; m_radius = polygon.m_radius; } else { b2Settings.b2Assert(false); } }
private void Form1_Load(object sender, EventArgs e) { sogc = new SimpleOpenGlControl(); sogc.Dock = DockStyle.Fill; sogc.Paint += new PaintEventHandler(sogc_Paint); sogc.Resize += new EventHandler(sogc_Resize); Controls.Add(sogc); sogc.InitializeContexts(); InitOpenGL(sogc.Size, 1, PointF.Empty); // Define the gravity vector. b2Vec2 gravity = new b2Vec2(0.0f, -10.0f); // Do we want to let bodies sleep? bool doSleep = true; // Construct a world object, which will hold and simulate the rigid bodies. world = new b2World(gravity, doSleep); // world.SetWarmStarting(true); { b2BodyDef bd = new b2BodyDef(); b2Body ground = world.CreateBody(bd); b2PolygonShape shape = new b2PolygonShape(); shape.SetAsEdge(new b2Vec2(-40.0f, 0.0f), new b2Vec2(40.0f, 0.0f)); ground.CreateFixture(shape, 0.0f); } { float a = 0.5f; b2CircleShape shape = new b2CircleShape(); shape.m_radius = a; b2Vec2 x = new b2Vec2(-7.0f, 0.95f); b2Vec2 y; b2Vec2 deltaX = new b2Vec2(0, 1.25f); b2Vec2 deltaY = new b2Vec2(0, 1.25f); y= deltaY; for (int j = 0; j < 8; ++j) { b2BodyDef bd = new b2BodyDef(); bd.type = b2BodyType.b2_dynamicBody; bd.position = y; b2Body body = world.CreateBody(bd); body.CreateFixture(shape, 5.0f); y += deltaY; } } GDIDebugThing.instance.SetFlags(EDebugFlags.e_shapeBit); world.SetDebugDraw(GDIDebugThing.instance); System.Timers.Timer timer = new System.Timers.Timer(); timer.Interval = 85; timer.SynchronizingObject = this; timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed); timer.Start(); }