/// Construct this matrix using scalars.
public b2Mat22(float a11, float a12, float a21, float a22)
{
ex = b2Vec2.Zero;
ey = b2Vec2.Zero;
ex.x = a11; ex.y = a21;
ey.x = a12; ey.y = a22;
}
public Rope()
{
const int N = 40;
b2Vec2[] vertices = new b2Vec2[N];
float[] masses = new float[N];
for (int i = 0; i < N; ++i)
{
vertices[i].Set(0.0f, 20.0f - 0.25f * i);
masses[i] = 1.0f;
}
masses[0] = 0.0f;
masses[1] = 0.0f;
b2RopeDef def = new b2RopeDef();
def.vertices = vertices;
def.count = N;
def.gravity.Set(0.0f, -10.0f);
def.masses = masses;
def.damping = 0.1f;
def.k2 = 1.0f;
def.k3 = 0.5f;
m_rope.Initialize(def);
m_angle = 0.0f;
m_rope.SetAngle(m_angle);
}
public virtual void Set(b2Vec2 v1, b2Vec2 v2)
{
Vertex1 = v1;
Vertex2 = v2;
HasVertex0 = false;
HasVertex3 = false;
}
/// Construct this matrix using scalars.
public b2Mat22(float a11, float a12, float a21, float a22)
{
_ex = new b2Vec2();
_ey = new b2Vec2();
_ex.x = a11; _ex.y = a21;
_ey.x = a12; _ey.y = a22;
}
void InitPhysics()
{
var gravity = new b2Vec2(0.0f, -10.0f);
world = new b2World(gravity);
world.SetAllowSleeping(true);
world.SetContinuousPhysics(true);
var def = new b2BodyDef();
def.allowSleep = true;
def.position = b2Vec2.Zero;
def.type = b2BodyType.b2_staticBody;
b2Body groundBody = world.CreateBody(def);
groundBody.SetActive(true);
b2EdgeShape groundBox = new b2EdgeShape();
groundBox.Set(b2Vec2.Zero, new b2Vec2(900, 100));
b2FixtureDef fd = new b2FixtureDef();
fd.friction = 0.3f;
fd.restitution = 0.1f;
fd.shape = groundBox;
groundBody.CreateFixture(fd);
}
public void Initialize(b2Body bA, b2Body bB, b2Vec2 anchor)
{
BodyA = bA;
BodyB = bB;
localAnchorA = BodyA.GetLocalPoint(anchor);
localAnchorB = BodyB.GetLocalPoint(anchor);
}
public JumpPad(b2Vec2 JumpImpuls, CCPoint Position, b2World gameWorld)
{
this.Texture = new CCTexture2D ("jumppad");
this.Scale = SpriteScale;
this.Position = Position;
this.IsAntialiased = false;
jumpImpuls = JumpImpuls;
totalJumps = 0;
//box2d
b2BodyDef jumpPadDef = new b2BodyDef ();
jumpPadDef.type = b2BodyType.b2_kinematicBody;
jumpPadDef.position = new b2Vec2 ((Position.X + this.ScaledContentSize.Width/2)/PhysicsHandler.pixelPerMeter, (Position.Y + this.ScaledContentSize.Height/4) / PhysicsHandler.pixelPerMeter);
JumpPadBody = gameWorld.CreateBody (jumpPadDef);
b2PolygonShape jumpPadShape = new b2PolygonShape ();
jumpPadShape.SetAsBox ((float)this.ScaledContentSize.Width / PhysicsHandler.pixelPerMeter / 2, (float)this.ScaledContentSize.Height / PhysicsHandler.pixelPerMeter / 4);// /4 weil die hitbox nur die hälfte der textur ist
b2FixtureDef jumpPadFixture = new b2FixtureDef ();
jumpPadFixture.shape = jumpPadShape;
jumpPadFixture.density = 0.0f; //Dichte
jumpPadFixture.restitution = 0f; //Rückprall
jumpPadFixture.friction = 0f;
jumpPadFixture.userData = WorldFixtureData.jumppad;
JumpPadBody.CreateFixture (jumpPadFixture);
//
}
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 virtual void Set(b2Vec2 v1, b2Vec2 v2)
{
m_vertex1 = v1;
m_vertex2 = v2;
m_hasVertex0 = false;
m_hasVertex3 = false;
}
/// Clipping for contact manifolds.
public static int b2ClipSegmentToLine(b2ClipVertex[] vOut, b2ClipVertex[] vIn,
b2Vec2 normal, float offset, byte vertexIndexA)
{
// Start with no output points
int numOut = 0;
// Calculate the distance of end points to the line
float distance0 = b2Math.b2Dot(normal, vIn[0].v) - offset;
float distance1 = b2Math.b2Dot(normal, vIn[1].v) - offset;
// If the points are behind the plane
if (distance0 <= 0.0f) vOut[numOut++] = vIn[0];
if (distance1 <= 0.0f) vOut[numOut++] = vIn[1];
// If the points are on different sides of the plane
if (distance0 * distance1 < 0.0f)
{
// Find intersection point of edge and plane
float interp = distance0 / (distance0 - distance1);
vOut[numOut].v = vIn[0].v + interp * (vIn[1].v - vIn[0].v);
// VertexA is hitting edgeB.
vOut[numOut].id.indexA = vertexIndexA;
vOut[numOut].id.indexB = vIn[0].id.indexB;
vOut[numOut].id.typeA = b2ContactFeatureType.e_vertex;
vOut[numOut].id.typeB = b2ContactFeatureType.e_face;
++numOut;
}
return numOut;
}
protected override void Draw(Settings settings)
{
base.Draw(settings);
b2Manifold manifold = new b2Manifold();
b2Collision.b2CollidePolygons(manifold, m_polygonA, ref m_transformA, m_polygonB, ref m_transformB);
b2WorldManifold worldManifold = new b2WorldManifold();
worldManifold.Initialize(manifold, ref m_transformA, m_polygonA.Radius, ref m_transformB, m_polygonB.Radius);
m_debugDraw.DrawString(5, m_textLine, "point count = {0}", manifold.pointCount);
m_textLine += 15;
{
b2Color color = new b2Color(0.9f, 0.9f, 0.9f);
b2Vec2[] v = new b2Vec2[b2Settings.b2_maxPolygonVertices];
for (int i = 0; i < m_polygonA.VertexCount; ++i)
{
v[i] = b2Math.b2Mul(m_transformA, m_polygonA.Vertices[i]);
}
m_debugDraw.DrawPolygon(v, m_polygonA.VertexCount, color);
for (int i = 0; i < m_polygonB.VertexCount; ++i)
{
v[i] = b2Math.b2Mul(m_transformB, m_polygonB.Vertices[i]);
}
m_debugDraw.DrawPolygon(v, m_polygonB.VertexCount, color);
}
for (int i = 0; i < manifold.pointCount; ++i)
{
m_debugDraw.DrawPoint(worldManifold.points[i], 4.0f, new b2Color(0.9f, 0.3f, 0.3f));
}
}
public b2PolygonShape(b2PolygonShape copy)
: base((b2Shape)copy)
{
Centroid = copy.Centroid;
Array.Copy(copy.Vertices, Vertices, copy.Vertices.Length);
Array.Copy(copy.Normals, Normals, copy.Normals.Length);
m_vertexCount = copy.m_vertexCount;
}
public void DrawPoint(b2Vec2 aP, float aSize, b2Color aColor)
{
CCDrawingPrimitives.Begin();
CCDrawingPrimitives.DrawPoint(new CCPoint(mRatio * aP.x, mRatio * aP.y), 1, new CCColor4B(aColor.r, aColor.g, aColor.b, 1));
CCDrawingPrimitives.End();
}
/// Initialize the bodies, anchors, and reference angle using a world
/// anchor point.
public void Initialize(b2Body bA, b2Body bB, b2Vec2 anchor)
{
BodyA = bA;
BodyB = bB;
localAnchorA = BodyA.GetLocalPoint(anchor);
localAnchorB = BodyB.GetLocalPoint(anchor);
referenceAngle = BodyB.Angle - BodyA.Angle;
}
public virtual void CreateChain(b2Vec2[] vertices, int count)
{
Count = count;
Vertices = new b2Vec2[count];
Array.Copy(vertices, Vertices, count);
HasPrevVertex = false;
HasNextVertex = false;
}
public virtual void CreateChain(b2Vec2[] vertices, int count)
{
m_count = count;
m_vertices = new b2Vec2[count];
Array.Copy(m_vertices, vertices, count);
m_hasPrevVertex = false;
m_hasNextVertex = false;
}
/// Advance the sweep forward, yielding a new initial state.
/// @param alpha the new initial time.
public void Advance(float alpha)
{
Debug.Assert(alpha0 < 1.0f);
float beta = (alpha - alpha0) / (1.0f - alpha0);
c0 = (1.0f - beta) * c0 + beta * c;
a0 = (1.0f - beta) * a0 + beta * a;
alpha0 = alpha;
}
public static CCPoint WorldToScreen(b2Vec2 worldPos, CCPoint actualPosition, float actualScale, CCSize wSize)
{
worldPos *= actualScale;
CCPoint layerOffset = actualPosition;
CCPoint p = new CCPoint(worldPos.x + layerOffset.X, worldPos.y + layerOffset.Y);
p.Y = wSize.Height - p.Y;
return p;
}
public virtual void SetTarget(b2Vec2 target)
{
if (m_bodyB.IsAwake() == false)
{
m_bodyB.SetAwake(true);
}
m_targetA = target;
}
public void Defaults()
{
localCenter = new b2Vec2();
c0 = new b2Vec2();
c = new b2Vec2();
a0 = 0f;
a = 0f;
alpha0 = 0f;
}
public override void DrawPolygon(b2Vec2[] vertices, int vertexCount, b2Color color)
{
b2Vec2[] alt = new b2Vec2[vertexCount];
for (int i = 0; i < vertexCount; i++)
{
alt[i] = vertices[i] * PTMRatio + _Center;
}
CCDrawingPrimitives.DrawPoly(alt, vertexCount, true, color);
}
public b2ChainShape(b2ChainShape clone)
: base((b2Shape)clone)
{
CreateChain(clone.Vertices, clone.Count);
PrevVertex = clone.PrevVertex;
NextVertex = clone.NextVertex;
HasPrevVertex = clone.HasPrevVertex;
HasNextVertex = clone.HasNextVertex;
}
public b2EdgeShape(b2EdgeShape e)
: base((b2Shape)e)
{
m_vertex1 = e.m_vertex1;
m_vertex2 = e.m_vertex2;
m_vertex3 = e.m_vertex3;
m_vertex0 = e.m_vertex0;
m_hasVertex0 = e.m_hasVertex0;
m_hasVertex3 = e.m_hasVertex3;
}
public override void DrawSolidPolygon(b2Vec2[] vertices, int vertexCount, b2Color color)
{
_list.Count = vertexCount;
var alt = _list.Elements;
for (int i = 0; i < vertexCount; i++)
{
alt[i] = vertices[i] * PTMRatio + _Center;
}
CCDrawingPrimitives.DrawSolidPoly(alt, vertexCount, color);
}
public override void DrawCircle(b2Vec2 aCenter, float aRadius, b2Color aColor)
{
CCDrawingPrimitives.Begin();
CCDrawingPrimitives.DrawCircle(new CCPoint(mRatio * aCenter.x, mRatio * aCenter.y),
aRadius, 0, DEBUG_DRAW_CIRCLE_SEGMENTS, false,
new CCColor4B(aColor.r, aColor.g, aColor.b, 1));
CCDrawingPrimitives.End();
}
public void Initialize(b2Body b1, b2Body b2,
b2Vec2 anchor1, b2Vec2 anchor2)
{
BodyA = b1;
BodyB = b2;
localAnchorA = BodyA.GetLocalPoint(anchor1);
localAnchorB = BodyB.GetLocalPoint(anchor2);
b2Vec2 d = anchor2 - anchor1;
length = d.Length;
}
public b2EdgeShape(b2EdgeShape e)
: base((b2Shape)e)
{
Vertex1 = e.Vertex1;
Vertex2 = e.Vertex2;
Vertex3 = e.Vertex3;
Vertex0 = e.Vertex0;
HasVertex0 = e.HasVertex0;
HasVertex3 = e.HasVertex3;
}
public b2WeldJoint(b2WeldJointDef def)
: base(def)
{
m_localAnchorA = def.localAnchorA;
m_localAnchorB = def.localAnchorB;
m_referenceAngle = def.referenceAngle;
m_frequencyHz = def.frequencyHz;
m_dampingRatio = def.dampingRatio;
m_impulse.SetZero();
}
public virtual void CreateLoop(b2Vec2[] vertices, int count)
{
m_count = count + 1;
m_vertices = new b2Vec2[m_count];
Array.Copy(vertices, m_vertices, count);
m_vertices[count] = m_vertices[0];
PrevVertex = m_vertices[m_count - 2];
NextVertex = m_vertices[1];
m_hasPrevVertex = true;
m_hasNextVertex = true;
}
public virtual void CreateLoop(b2Vec2[] vertices, int count)
{
Count = count + 1;
Vertices = new b2Vec2[Count];
Array.Copy(vertices, Vertices, count);
Vertices[count] = Vertices[0];
PrevVertex = Vertices[Count - 2];
NextVertex = Vertices[1];
HasPrevVertex = true;
HasNextVertex = true;
}
public static float b2Cross(b2Vec2 a, b2Vec2 b)
{
return(a.x * b.y - a.y * b.x);
}
public static void b2Max(ref b2Vec2 a, ref b2Vec2 b, out b2Vec2 output)
{
output.x = Math.Max(a.x, b.x);
output.y = Math.Max(a.y, b.y);
}
public static b2Vec2 b2Clamp(b2Vec2 a, b2Vec2 low, b2Vec2 high)
{
return(b2Max(low, b2Min(a, high)));
}
public static float b2Dot(ref b2Vec2 a, ref b2Vec2 b)
{
return(a.x * b.x + a.y * b.y);
}
public static float b2Distance(b2Vec2 a, b2Vec2 b)
{
b2Vec2 c = a - b;
return(c.Length);
}
