CUNinePatch.h

//
//  CUNinePatch.h
//  Cornell University Game Library (CUGL)
//
//  This module implements a ninepatch for expandable UI elements.  A ninepatch
//  breaks up an image into nine parts.  It expands the middle elements while
//  preserving the corners.  This allows us to arbitrarily stretch an image
//  like a beveled button without distorting it. Ninepatches are used heavily
//  in mobile UI development.
//
//  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/8/17
//
#ifndef __CU_NINEPATCH_H__
#define __CU_NINEPATCH_H__
 
#include <string>
#include <cugl/math/CURect.h>
#include <cugl/2d/CUNode.h>
#include <cugl/renderer/CUTexture.h>
#include <cugl/renderer/CUVertex.h>
#include <cugl/renderer/CUSpriteBatch.h>
 
namespace cugl {
 
class NinePatch : public Node {
#pragma mark Values
protected:
    std::shared_ptr<Texture> _texture;
 
    Rect _interior;
    
    bool _rendered;
    std::vector<Vertex2> _vertices;
    std::vector<unsigned short> _indices;
    
    GLenum _blendEquation;
    GLenum _srcFactor;
    GLenum _dstFactor;
    
    
#pragma mark -
#pragma mark Constructors
public:
    NinePatch();
    
    ~NinePatch() { dispose(); }
    
    virtual void dispose() override;
    
    virtual bool init() override {
        return initWithTexture(SpriteBatch::getBlankTexture());
    }
 
    bool initWithFile(const std::string& filename);
    
    bool initWithFile(const std::string& filename, const Rect& interior);
    
    bool initWithTexture(const std::shared_ptr<Texture>& texture);
    
    bool initWithTexture(const std::shared_ptr<Texture>&  texture, const Rect& interior);
    
    virtual bool initWithData(const SceneLoader* loader, const std::shared_ptr<JsonValue>& data) override;
 
    
#pragma mark -
#pragma mark Static Constructors
 
    static std::shared_ptr<NinePatch> alloc() {
        std::shared_ptr<NinePatch> node = std::make_shared<NinePatch>();
        return (node->init() ? node : nullptr);
    }
    
    static std::shared_ptr<NinePatch> allocWithFile(const std::string& filename) {
        std::shared_ptr<NinePatch> node = std::make_shared<NinePatch>();
        return (node->initWithFile(filename) ? node : nullptr);
    }
    
    static std::shared_ptr<NinePatch> allocWithFile(const std::string& filename, const Rect& interior) {
        std::shared_ptr<NinePatch> node = std::make_shared<NinePatch>();
        return (node->initWithFile(filename,interior) ? node : nullptr);
    }
    
    static std::shared_ptr<NinePatch> allocWithTexture(const std::shared_ptr<Texture>& texture) {
        std::shared_ptr<NinePatch> node = std::make_shared<NinePatch>();
        return (node->initWithTexture(texture) ? node : nullptr);
    }
 
    static std::shared_ptr<NinePatch> allocWithTexture(const std::shared_ptr<Texture>& texture,
                                                       const Rect& interior) {
        std::shared_ptr<NinePatch> node = std::make_shared<NinePatch>();
        return (node->initWithTexture(texture,interior) ? node : nullptr);
    }
    
    static std::shared_ptr<Node> allocWithData(const SceneLoader* loader,
                                               const std::shared_ptr<JsonValue>& data) {
        std::shared_ptr<NinePatch> result = std::make_shared<NinePatch>();
        if (!result->initWithData(loader,data)) { result = nullptr; }
        return std::dynamic_pointer_cast<Node>(result);
    }
    
 
#pragma mark -
#pragma mark Attributes
 
    virtual void setContentSize(const Size& size) override;
    
    void setTexture(const std::string &filename) {
        std::shared_ptr<Texture> texture =  Texture::allocWithFile(filename);
        setTexture(texture);
    }
    
    void setTexture(const std::shared_ptr<Texture>& texture);
    
    std::shared_ptr<Texture>& getTexture() { return _texture; }
    
    const std::shared_ptr<Texture>& getTexture() const { return _texture; }
    
    void setInterior(const Rect& interior);
    
    const Rect& getInterior() const { return _interior; }
    
    void setBlendFunc(GLenum srcFactor, GLenum dstFactor) { _srcFactor = srcFactor; _dstFactor = dstFactor; }
    
    GLenum getSourceBlendFactor() const { return _srcFactor; }
    
    GLenum getDestinationBlendFactor() const { return _srcFactor; }
    
    void setBlendEquation(GLenum equation) { _blendEquation = equation; }
    
    GLenum getBlendEquation() const { return _blendEquation; }
 
    
#pragma mark -
#pragma mark Rendering
 
    virtual void draw(const std::shared_ptr<SpriteBatch>& batch,
                      const Mat4& transform, Color4 tint) override;
    
    void refresh() { clearRenderData(); generateRenderData(); }
    
    virtual std::string toString(bool verbose=false) const override;
    
#pragma mark -
#pragma mark Internal Helpers
protected:
    virtual void generateRenderData();
    
    void clearRenderData();
 
    unsigned short generatePatch(const Rect& src, const Rect& dst, unsigned short offset);
    
    CU_DISALLOW_COPY_AND_ASSIGN(NinePatch);
};
 
}
#endif /* __CU_NINEPATCH_H__ */