CUAnimationNode.h

//
//  CUAnimationNode.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a straight-forward filmstrip API, similar to what we
//  use in the intro class.  Note that this class extends PolygonNode, as it
//  simply treats the node texture as a sprite sheet. Therefore, it is possible
//  to animate the filmstrip over polygons.  However, this can have undesirable
//  effects if the polygon coordinates extend beyond a single animation frame.
//
//  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: 12/1/16
//
#ifndef __CU_ANIMATION_NODE_H__
#define __CU_ANIMATION_NODE_H__
 
#include <cugl/2d/CUPolygonNode.h>
#include <cugl/math/CURect.h>
#include <cugl/renderer/CUTexture.h>
 
 
namespace cugl {
 
#pragma mark -
#pragma mark AnimationNode
 
class AnimationNode : public PolygonNode {
protected:
    int _cols;
    int _size;
    int _frame;
    Rect _bounds;
   
#pragma mark -
#pragma mark Constructors
public:
    AnimationNode();
    
    ~AnimationNode() { dispose(); }
 
    bool initWithFilmstrip(const std::shared_ptr<Texture>& texture, int rows, int cols) {
        return initWithFilmstrip(texture,rows,cols,rows*cols);
    }
    
    bool initWithFilmstrip(const std::shared_ptr<Texture>& texture, int rows, int cols, int size);
    
    virtual bool initWithData(const SceneLoader* loader, const std::shared_ptr<JsonValue>& data) override;
 
    
#pragma mark -
#pragma mark Static Constructors
 
    static std::shared_ptr<AnimationNode> alloc(const std::shared_ptr<Texture>& texture,
                                                int rows, int cols) {
        std::shared_ptr<AnimationNode> node = std::make_shared<AnimationNode>();
        return (node->initWithFilmstrip(texture,rows,cols) ? node : nullptr);
 
    }
    
    static std::shared_ptr<AnimationNode> alloc(const std::shared_ptr<Texture>& texture,
                                                int rows, int cols, int size) {
        std::shared_ptr<AnimationNode> node = std::make_shared<AnimationNode>();
        return (node->initWithFilmstrip(texture,rows,cols,size) ? node : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithData(const SceneLoader* loader,
                                               const std::shared_ptr<JsonValue>& data) {
        std::shared_ptr<AnimationNode> result = std::make_shared<AnimationNode>();
        if (!result->initWithData(loader,data)) { result = nullptr; }
        return std::dynamic_pointer_cast<Node>(result);
    }
 
    
#pragma mark -
#pragma mark Attribute Accessors
 
    int getSize() const { return _size; }
    
    unsigned int getFrame() const { return _frame; }
    
    void setFrame(int frame);
 
    
};
 
}
 
#endif /* __CU_ANIMATION_NODE_H__ */