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