CUObstacleWorld.h

//
//  CUObstacleWorld.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a wrapper to Box2d that for use with CUGL obstacle
//  heirarchy.  Obstacles provide a simple and direct way to create physics
//  objects that does not require the multi-step approach of Box2D.  It also
//  supports shared pointers for simply memory management.
//
//  However, this class is not as flexible as Box2D.  Therefore, it may be
//  necessary to access Box2D directly at times.
//
//  This class uses our standard shared-pointer architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//  CUGL MIT License:
//      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.
//
//  Author: Walker White
//  Version: 11/1/16
#ifndef __CU_PHYSICS_WORLD_H__
#define __CU_PHYSICS_WORLD_H__
 
#include <vector>
#include <Box2D/Dynamics/b2WorldCallbacks.h>
#include <cugl/math/cu_math.h>
class b2World;
 
namespace cugl {
 
// Forward declaration of the Obstacle class
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 ObstacleWorld : public b2ContactListener, b2DestructionListener, b2ContactFilter {
protected:
    b2World* _world;
    bool _lockstep;
    float _stepssize;
    int _itvelocity;
    int _itposition;
    Vec2 _gravity;
    
    std::vector<std::shared_ptr<Obstacle>> _objects;
    
    Rect _bounds;
    
    bool _collide;
    bool _filters;
    bool _destroy;
    
    
#pragma mark -
#pragma mark Constructors
public:
    ObstacleWorld();
    
    ~ObstacleWorld() { dispose(); }
 
    void dispose();
 
    bool init(const Rect& bounds);
    
    bool init(const Rect& bounds, const Vec2& gravity);
 
    
#pragma mark -
#pragma mark Static Constructors
 
    static std::shared_ptr<ObstacleWorld> alloc(const Rect& bounds) {
        std::shared_ptr<ObstacleWorld> result = std::make_shared<ObstacleWorld>();
        return (result->init(bounds) ? result : nullptr);
    }
    
    static std::shared_ptr<ObstacleWorld> alloc(const Rect& bounds, const Vec2& gravity) {
        std::shared_ptr<ObstacleWorld> result = std::make_shared<ObstacleWorld>();
        return (result->init(bounds,gravity) ? result : nullptr);
    }
 
    
#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<std::shared_ptr<Obstacle>>& getObstacles() { return _objects; }
 
    void addObstacle(const std::shared_ptr<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;
    
};
 
}
#endif /* __CU_PHYSICS_WORLD_H__ */