File indexing completed on 2024-04-21 14:43:26

 /*
  * box2dworld.cpp
  * Copyright (c) 2010-2011 Thorbjørn Lindeijer <thorbjorn@lindeijer.nl>
  * Copyright (c) 2011 Joonas Erkinheimo <joonas.erkinheimo@nokia.com>
  * Copyright (c) 2012 Adriano Rezende <atdrez@gmail.com>
  *
  * This file is part of the Box2D QML plugin.
  *
  * This software is provided 'as-is', without any express or implied warranty.
  * In no event will the authors be held liable for any damages arising from
  * the use of this software.
  *
  * Permission is granted to anyone to use this software for any purpose,
  * including commercial applications, and to alter it and redistribute it
  * freely, subject to the following restrictions:
  *
  * 1. The origin of this software must not be misrepresented; you must not
  *    claim that you wrote the original software. If you use this software in
  *    a product, an acknowledgment in the product documentation would be
  *    appreciated but is not required.
  *
  * 2. Altered source versions must be plainly marked as such, and must not be
  *    misrepresented as being the original software.
  *
  * 3. This notice may not be removed or altered from any source distribution.
  */
 
 #include "box2dworld.h"
 
 #include "box2dbody.h"
 #include "box2dcontact.h"
 #include "box2dfixture.h"
 #include "box2djoint.h"
 #include "box2draycast.h"
 
 StepDriver::StepDriver(Box2DWorld *world)
     : QAbstractAnimation(world)
     , mWorld(world)
 {
     setLoopCount(-1); // loop forever
 }
 
 int StepDriver::duration() const
 {
     return 1000;
 }
 
 void StepDriver::updateCurrentTime(int)
 {
     mWorld->step();
 }
 
 
 class ContactEvent
 {
 public:
     enum Type {
         BeginContact,
         EndContact
     };
 
     Type type;
     Box2DFixture *fixtureA;
     Box2DFixture *fixtureB;
 };
 
 class ContactListener : public b2ContactListener
 {
 public:
     explicit ContactListener(Box2DWorld *world);
     void BeginContact(b2Contact *contact);
     void EndContact(b2Contact *contact);
     void PreSolve(b2Contact *contact, const b2Manifold *oldManifold);
     void PostSolve(b2Contact *contact, const b2ContactImpulse *impulse);
 
     void removeEvent(int index) { mEvents.removeAt(index); }
     void clearEvents() { mEvents.clear(); }
     const QList<ContactEvent> &events() { return mEvents; }
 
 private:
     QList<ContactEvent> mEvents;
     Box2DWorld *mWorld;
     Box2DContact mContact;
 };
 
 ContactListener::ContactListener(Box2DWorld *world) :
     mWorld(world)
 {
 }
 
 void ContactListener::BeginContact(b2Contact *contact)
 {
     ContactEvent event;
     event.type = ContactEvent::BeginContact;
     event.fixtureA = toBox2DFixture(contact->GetFixtureA());
     event.fixtureB = toBox2DFixture(contact->GetFixtureB());
     mEvents.append(event);
 }
 
 void ContactListener::EndContact(b2Contact *contact)
 {
     ContactEvent event;
     event.type = ContactEvent::EndContact;
     event.fixtureA = toBox2DFixture(contact->GetFixtureA());
     event.fixtureB = toBox2DFixture(contact->GetFixtureB());
     mEvents.append(event);
 }
 
 void ContactListener::PreSolve(b2Contact *contact, const b2Manifold *oldManifold)
 {
     Q_UNUSED(oldManifold)
     mContact.setContact(contact);
     emit mWorld->preSolve(&mContact);
 }
 
 void ContactListener::PostSolve(b2Contact *contact, const b2ContactImpulse *impulse)
 {
     Q_UNUSED(impulse)
     mContact.setContact(contact);
     emit mWorld->postSolve(&mContact);
 }
 
 static Box2DWorld * mDefaultWorld;
 
 Box2DWorld::Box2DWorld(QObject *parent) :
     QObject(parent),
     mWorld(b2Vec2(0.0f, -10.0f)),
     mContactListener(0),
     mTimeStep(1.0f / 60.0f),
     mVelocityIterations(8),
     mPositionIterations(3),
     mComponentComplete(false),
     mIsRunning(true),
     mSynchronizing(false),
     mStepDriver(new StepDriver(this)),
     mProfile(new Box2DProfile(&mWorld, this)),
     mEnableContactEvents(true),
     mPixelsPerMeter(32.0f)
 
 {
     mWorld.SetDestructionListener(this);
     if (!mDefaultWorld)
         mDefaultWorld = this;
 }
 
 Box2DWorld::~Box2DWorld()
 {
     // The bodies and joints will be deleted as part of the world, so it's
     // important that they are no longer referenced from the Box2DBody and
     // Box2DJoint instances.
     for (b2Body *body = mWorld.GetBodyList(); body; body = body->GetNext())
         toBox2DBody(body)->nullifyBody();
     for (b2Joint *joint = mWorld.GetJointList(); joint; joint = joint->GetNext())
         toBox2DJoint(joint)->nullifyJoint();
     enableContactListener(false);
     if (mDefaultWorld == this)
         mDefaultWorld = 0;
 }
 
 void Box2DWorld::setTimeStep(float timeStep)
 {
     if (mTimeStep != timeStep) {
         mTimeStep = timeStep;
         emit timeStepChanged();
     }
 }
 
 void Box2DWorld::setRunning(bool running)
 {
     if (mIsRunning == running)
         return;
 
     mIsRunning = running;
     emit runningChanged();
 
     if (mComponentComplete) {
         if (running)
             mStepDriver->start();
         else
             mStepDriver->stop();
     }
 }
 
 void Box2DWorld::setVelocityIterations(int iterations)
 {
     if (mVelocityIterations != iterations) {
         mVelocityIterations = iterations;
         emit velocityIterationsChanged();
     }
 }
 
 void Box2DWorld::setPositionIterations(int iterations)
 {
     if (mPositionIterations != iterations) {
         mPositionIterations = iterations;
         emit positionIterationsChanged();
     }
 }
 
 QPointF Box2DWorld::gravity() const
 {
     return invertY(mWorld.GetGravity());
 }
 
 void Box2DWorld::setGravity(const QPointF &gravity)
 {
     const b2Vec2 invertedGravity = invertY(gravity);
     if (mWorld.GetGravity() == invertedGravity)
         return;
 
     mWorld.SetGravity(invertedGravity);
     emit gravityChanged();
 }
 
 void Box2DWorld::setAutoClearForces(bool autoClearForces)
 {
     if (mWorld.GetAutoClearForces() == autoClearForces)
         return;
 
     mWorld.SetAutoClearForces(autoClearForces);
     emit autoClearForcesChanged();
 }
 
 void Box2DWorld::setEnableContactEvents(bool enableContactEvents)
 {
     if(enableContactEvents == mEnableContactEvents)
         return;
     mEnableContactEvents = enableContactEvents;
     enableContactListener(mEnableContactEvents);
 
     emit enableContactEventsChanged();
 }
 
 void Box2DWorld::enableContactListener(bool enable)
 {
     if (enable) {
         mContactListener = new ContactListener(this);
         mWorld.SetContactListener(mContactListener);
     } else {
         mWorld.SetContactListener(0);
         delete mContactListener;
     }
 }
 
 void Box2DWorld::setPixelsPerMeter(float pixelsPerMeter)
 {
     if (pixelsPerMeter <= 0.0f) {
         qWarning("World: pixelsPerMeter must be > 0.0f");
         return;
     }
 
     if (mPixelsPerMeter != pixelsPerMeter) {
         mPixelsPerMeter = pixelsPerMeter;
         pixelsPerMeterChanged();
     }
 }
 
 void Box2DWorld::classBegin()
 {
 }
 
 void Box2DWorld::componentComplete()
 {
     mComponentComplete = true;
 
     enableContactListener(mEnableContactEvents);
 
     if (mIsRunning)
         mStepDriver->start();
 }
 
 void Box2DWorld::SayGoodbye(b2Joint *joint)
 {
     if (Box2DJoint *temp = toBox2DJoint(joint)) {
         temp->nullifyJoint();
         delete temp;
     }
 }
 
 void Box2DWorld::SayGoodbye(b2Fixture *fixture)
 {
     if (mEnableContactEvents) {
         Box2DFixture *f = toBox2DFixture(fixture);
 
         QList<ContactEvent> events = mContactListener->events();
         for (int i = events.count() - 1; i >= 0; i--) {
             if(events.at(i).fixtureA == f || events.at(i).fixtureB == f)
                 mContactListener->removeEvent(i);
         }
     }
 }
 
 void Box2DWorld::step()
 {
     // Update Box2D state before stepping
     for (b2Body *body = mWorld.GetBodyList(); body; body = body->GetNext()) {
         Box2DBody *b = toBox2DBody(body);
         if (b->transformDirty() && b->isActive())
             b->updateTransform();
     }
 
     mWorld.Step(mTimeStep, mVelocityIterations, mPositionIterations);
 
     b2Timer timer;
 
     // Update QML state after stepping
     mSynchronizing = true;
     for (b2Body *body = mWorld.GetBodyList(); body; body = body->GetNext()) {
         Box2DBody *b = toBox2DBody(body);
         if (b->isActive() && b->bodyType() != Box2DBody::Static && b->target())
             b->synchronize();
     }
     mSynchronizing = false;
 
     mProfile->mSynchronize = timer.GetMilliseconds();
     timer.Reset();
 
     if (mEnableContactEvents) {
         // Emit contact signals
         foreach (const ContactEvent &event, mContactListener->events()) {
             switch (event.type) {
             case ContactEvent::BeginContact:
                 emit event.fixtureA->beginContact(event.fixtureB);
                 emit event.fixtureB->beginContact(event.fixtureA);
                 break;
             case ContactEvent::EndContact:
                 emit event.fixtureA->endContact(event.fixtureB);
                 emit event.fixtureB->endContact(event.fixtureA);
                 break;
             }
         }
     }
     mContactListener->clearEvents();
 
     mProfile->mEmitSignals = timer.GetMilliseconds();
 
     emit stepped();
 }
 
 void Box2DWorld::rayCast(Box2DRayCast *rayCast,
                          const QPointF &point1,
                          const QPointF &point2)
 {
     mWorld.RayCast(rayCast, toMeters(point1), toMeters(point2));
 }
 
 Box2DWorld *Box2DWorld::defaultWorld()
 {
     return mDefaultWorld;
 }