CUPolygonObstacle.h

//
//  CUPolygonObstacle.h
//  Cornell Extensions to Cocos2D
//
//  This class implements a polygonal Physics object.  This is different from
//  PolygonNode, which is used for drawing.  This class is substantially more
//  complex than the other physics objects, but it will allow you to draw
//  arbitrary shapes.  Be careful modifying this file as there are a lot of
//  subtleties here.
//
//  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 zlib 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.
//
//  This file is based on the CS 3152 PhysicsDemo Lab by Don Holden, 2007
//
//  Author: Walker White
//  Version: 11/6/16
//
#ifndef __CU_POLYGON_OBSTACLE_H__
#define __CU_POLYGON_OBSTACLE_H__

#include "CUSimpleObstacle.h"
#include <cugl/math/CUPoly2.h>

namespace cugl {

#pragma mark -
#pragma mark Polygon Obstacle

class PolygonObstacle : public SimpleObstacle {
protected:
    Poly2 _polygon;
    b2PolygonShape* _shapes;
    b2Fixture** _geoms;
    Vec2 _anchor;
    int _fixCount;
    
    
#pragma mark -
#pragma mark Scene Graph Methods

    void resize(const Size& size);
    
    virtual void resetDebug() override;
    
    void resetShapes();
    
    
#pragma mark -
#pragma mark Constructors
public:
    PolygonObstacle(void) : SimpleObstacle(), _shapes(nullptr), _geoms(nullptr) { }
    
    virtual ~PolygonObstacle();
    
    // Turn off init warnings
    using SimpleObstacle::init;
    
    virtual bool init(const Poly2& poly) { return init(poly,Vec2(0.5,0.5)); }
    
    virtual bool init(const Poly2& poly, const Vec2& anchor);

    
#pragma mark -
#pragma mark Static Constructors

    static std::shared_ptr<PolygonObstacle> alloc(const Poly2& poly) {
        std::shared_ptr<PolygonObstacle> result = std::make_shared<PolygonObstacle>();
        return (result->init(poly) ? result : nullptr);
    }
    
    static std::shared_ptr<PolygonObstacle> alloc(const Poly2& poly, const Vec2& anchor) {
        std::shared_ptr<PolygonObstacle> result = std::make_shared<PolygonObstacle>();
        return (result->init(poly,anchor) ? result : nullptr);
    }
    
    
#pragma mark -
#pragma mark Dimensions

    const Size& getSize() const { return _polygon.getBounds().size; }
    
    void setSize(const Size& value)         { resize(value); markDirty(true); }
    
    void setSize(float width, float height) { setSize(Size(width, height)); }
    
    float getWidth() const { return _polygon.getBounds().size.width; }
    
    void setWidth(float value) { setSize(value,getHeight()); }
    
    float getHeight() const { return _polygon.getBounds().size.height; }
    
    void setHeight(float value) { setSize(getWidth(),value); }
    
    const Vec2& getAnchor() const { return _anchor; }
    
    void setAnchor(const Vec2& value) { setAnchor(value.x, value.y); }
    
    void setAnchor(float x, float y);
    
    const Poly2& getPolygon() const { return _polygon; }
    
    void setPolygon(const Poly2& value);
    
    
#pragma mark -
#pragma mark Physics Methods
    
    virtual void createFixtures() override;
    
    virtual void releaseFixtures() override;

    
};

}
#endif /* __CU_POLYGON_OBSTACLE_H__ */