CUScaleAction.h

//
//  CUScaleAction.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for the scaling actions.  Scaling can specified
//  as either the final magnification or multiplicative factor.
//
//  These classes use 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: Sophie Huang and Walker White
//  Version: 3/12/17
//
#ifndef __CU_SCALE_ACTION_H__
#define __CU_SCALE_ACTION_H__
 
#include "CUAction.h"
 
namespace cugl {
    
#pragma mark -
#pragma mark ScaleBy
 
class ScaleBy : public Action {
protected:
    Vec2 _delta;
 
public:
#pragma mark Constructors
 
    ScaleBy() { _delta = Vec2::ONE; }
 
    ~ScaleBy() { dispose(); }
    
    void dispose() { _delta = Vec2::ONE; }
    
    bool init() {
        return init(Vec2(1.0, 1.0), 0.0f);
    }
    
    bool init(const Vec2& factor) {
        return init(factor,0.0f);
    }
    
    bool init(const Vec2& factor, float time);
 
#pragma mark Static Constructors
 
    static std::shared_ptr<ScaleBy> alloc() {
        std::shared_ptr<ScaleBy> result = std::make_shared<ScaleBy>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<ScaleBy> alloc(const Vec2& factor) {
        std::shared_ptr<ScaleBy> result = std::make_shared<ScaleBy>();
        return (result->init(factor) ? result : nullptr);
    }
    
    static std::shared_ptr<ScaleBy> alloc(const Vec2& factor, float time) {
        std::shared_ptr<ScaleBy> result = std::make_shared<ScaleBy>();
        return (result->init(factor,time) ? result : nullptr);
    }
 
#pragma mark Attributes
 
    const Vec2& getFactor() const { return _delta; }
    
    void setFactor(const Vec2& factor) { _delta = factor; }
 
    
#pragma mark Animation Methods
 
    virtual std::shared_ptr<Action> clone() override;
    
    virtual void load(const std::shared_ptr<Node>& target, Uint64* state) override;
    
    virtual void update(const std::shared_ptr<Node>& target, Uint64* state, float dt) override;
    
#pragma mark Debugging Methods
 
    virtual std::string toString(bool verbose = false) const override;
};
 
    
#pragma mark -
 
class ScaleTo : public Action {
protected:
    Vec2 _scale;
 
public:
#pragma mark Constructors
 
    ScaleTo() { _scale = Vec2::ONE; }
 
    ~ScaleTo() { dispose(); }
    
    void dispose() { _scale = Vec2::ONE; }
    
    bool init() {
        return init(Vec2(1.0, 1.0), 0.0f);
    }
    
    bool init(const Vec2& scale) {
        return init(scale,0.0f);
    }
 
    bool init(const Vec2& scale, float time);
 
#pragma mark Static Constructors
 
    static std::shared_ptr<ScaleTo> alloc() {
        std::shared_ptr<ScaleTo> result = std::make_shared<ScaleTo>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<ScaleTo> alloc(const Vec2& scale) {
        std::shared_ptr<ScaleTo> result = std::make_shared<ScaleTo>();
        return (result->init(scale) ? result : nullptr);
    }
 
    static std::shared_ptr<ScaleTo> alloc(const Vec2& scale, float time) {
        std::shared_ptr<ScaleTo> result = std::make_shared<ScaleTo>();
        return (result->init(scale, time) ? result : nullptr);
    }
    
#pragma mark Attributes
 
    const Vec2& getScale() const { return _scale; }
    
    void setScale(const Vec2& scale) { _scale = scale; }
    
#pragma mark Animation Methods
 
    virtual std::shared_ptr<Action> clone() override;
    
    virtual void load(const std::shared_ptr<Node>& target, Uint64* state) override;
    
    virtual void update(const std::shared_ptr<Node>& target, Uint64* state, float dt) override;
    
#pragma mark Debugging Methods
 
    virtual std::string toString(bool verbose = false) const override;
};
 
}
#endif /* __CU_SCALE_ACTION_H__ */