CUWorldController.h

//
//  CUWorldController.h
//  Cornell Extensions to Cocos2D
//
//  This module provides a Cocos2d wrapper to Box2d that is superior to the one built into
//  Cocos2d.  The existing implementation is coupled with the scene graph, which is bad, bad
//  bad. This is a way to handle Box2d with proper reference counting and garbage collection
//  that does not require the scene graph.
//
//  Author: Walker White
//  Version: 12/5/15
//
#ifndef __CU_WORLD_CONTROLLER_H__
#define __CU_WORLD_CONTROLLER_H__

#include <cocos2d.h>
#include <vector>
#include <Box2D/Dynamics/b2WorldCallbacks.h>
class b2World;

NS_CC_BEGIN

// We need a lot of forward references to the classes used by this controller
class Obstacle;

#define DEFAULT_WORLD_STEP  1/60.0f

#define DEFAULT_WORLD_VELOC 6

#define DEFAULT_WORLD_POSIT 2


#pragma mark -
#pragma mark World Controller

class CC_DLL WorldController : public b2ContactListener, b2DestructionListener, b2ContactFilter, public Ref {
protected:
    b2World* _world;
    bool _lockstep;
    float _stepssize;
    int _itvelocity;
    int _itposition;
    Vec2 _gravity;
    
    std::vector<Obstacle*> _objects;
    
    Rect _bounds;
    
    bool _collide;
    bool _filters;
    bool _destroy;
    
    
public:
#pragma mark Static Constructors

    static WorldController* create(const Rect& bounds);
    
    static WorldController* create(const Rect& bounds, const Vec2& gravity);

    
#pragma mark -
#pragma mark Physics Handling
    
    b2World* getWorld() { return _world; }
    
    bool isLockStep() const { return _lockstep; }
    
    void setLockStep(bool flag) { _lockstep = flag; }
    
    float getStepsize() const { return _stepssize; }
    
    void setStepsize(float step) { _stepssize = step; }

    int getVelocityIterations() const { return _itvelocity; }

    void setVelocityIterations(int velocity) { _itvelocity = velocity; }

    int getPositionIterations() const { return _itposition; }
    
    void setPositionIterations(int position) { _itposition = position; }
    
    const Vec2& getGravity() const { return _gravity; }

    void setGravity(const Vec2& gravity);
    
    void update(float dt);
    
    const Rect& getBounds() const { return _bounds; }
    
    bool inBounds(Obstacle* obj);
    
    
#pragma mark -
#pragma mark Object Management

    const std::vector<Obstacle*>& getObstacles() { return _objects; }

    void addObstacle(Obstacle* obj);
    
    void removeObstacle(Obstacle* obj);
    
    void garbageCollect();

    void clear();

    
#pragma mark -
#pragma mark Collision Callback Functions
    
    void activateCollisionCallbacks(bool flag);
    
    bool enabledCollisionCallbacks() const { return _collide; }
    
    std::function<void(b2Contact* contact)> onBeginContact;
    
    std::function<void(b2Contact* contact)> onEndContact;
    
    std::function<void(b2Contact* contact, const b2Manifold* oldManifold)> beforeSolve;
    
    std::function<void(b2Contact* contact, const b2ContactImpulse* impulse)> afterSolve;
    
    void BeginContact(b2Contact* contact) override {
        if (onBeginContact != nullptr) {
            onBeginContact(contact);
        }
    }
    
    void EndContact(b2Contact* contact) override {
        if (onEndContact != nullptr) {
            onEndContact(contact);
        }
    }
    
    void PreSolve(b2Contact* contact, const b2Manifold* oldManifold) override {
        if (beforeSolve != nullptr) {
            beforeSolve(contact,oldManifold);
        }
    }
    
    void PostSolve(b2Contact* contact, const b2ContactImpulse* impulse) override {
        if (afterSolve != nullptr) {
            afterSolve(contact,impulse);
        }
    }

    
#pragma mark -
#pragma mark Filter Callback Functions
    
    void activateFilterCallbacks(bool flag);
    
    bool enabledFilterCallbacks() const { return _filters; }
    
    std::function<bool(b2Fixture* fixtureA, b2Fixture* fixtureB)> shouldCollide;
    
    bool ShouldCollide(b2Fixture* fixtureA, b2Fixture* fixtureB) override {
        if (shouldCollide != nullptr) {
            return shouldCollide(fixtureA,fixtureB);
        }
        return false;
    }

    
#pragma mark -
#pragma mark Destruction Callback Functions
    
    void activateDestructionCallbacks(bool flag);
    
    bool enabledDestructionCallbacks() const { return _destroy; }
    
    std::function<void(b2Fixture* fixture)> destroyFixture;

    std::function<void(b2Joint* joint)>     destroyJoint;

    void SayGoodbye(b2Joint* joint) override {
        if (destroyJoint != nullptr) {
            destroyJoint(joint);
        }
    }
    
    void SayGoodbye(b2Fixture* fixture) override {
        if (destroyFixture != nullptr) {
            destroyFixture(fixture);
        }
    }


#pragma mark -
#pragma mark Query Functions

    void queryAABB(std::function<bool(b2Fixture* fixture)> callback, const Rect& aabb) const;

    void rayCast(std::function<float(b2Fixture* fixture, const Vec2& point, const Vec2& normal, float fraction)> callback,
                 const Vec2& point1, const Vec2& point2) const;


    
CC_CONSTRUCTOR_ACCESS:
#pragma mark -
#pragma mark Initializers

    WorldController();
    
    ~WorldController();
    
    virtual bool init(const Rect& bounds);
    
    virtual bool init(const Rect& bounds, const Vec2& gravity);
    
};

NS_CC_END
#endif /* defined(__CU_WORLD_CONTROLLER_H__) */