IAPDemo/Libraries/redream/RParticleSystemLoader.cpp

#include "RParticleSystemLoader.h"

using namespace cocos2d;
using namespace RRP;

#define PROPERTY_BLENDFUNC "blendFunc"
#define PROPERTY_TEXTURE "texture"
#define PROPERTY_DISPLAYFRAME "displayFrame"

typedef std::function<void(Node*, void*)> Setter;

template <class C, class V>
class Accessor {
    public:
    typedef void (C::*SetFuncV)(V v);
    typedef void (C::*SetFuncR)(const V& v);
    
    static Setter New(SetFuncV fn)
    {
        return [fn](Node* node, void* ptr) {
            (((C*)node)->*fn)(*((V*)ptr));
        };
    }
    
    static Setter New(SetFuncR fn)
    {
        return [fn](Node* node, void* ptr) {
            (((C*)node)->*fn)(*((V*)ptr));
        };
    }
};

#define VAR(NAME, TYPENAME, TYPE, FUNC) {NAME, Accessor<RParticleSystem, TYPE>::New(&RParticleSystem::set##FUNC) },

static std::map<std::string, Setter> s_setters({
#include "rparticle/RParticleSystemProps.h"
});

namespace redream {
    
    void RParticleSystemLoader::onHandlePropTypeFloat(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float pFloat, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            it->second(pNode, &pFloat);
        } else {
            NodeLoader::onHandlePropTypeFloat(pNode, pParent, pPropertyName, pFloat, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeInteger(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, int pInteger, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            it->second(pNode, &pInteger);
        } else {
            NodeLoader::onHandlePropTypeInteger(pNode, pParent, pPropertyName, pInteger, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeIntegerLabeled(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, int pInteger, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            it->second(pNode, &pInteger);
        } else {
            NodeLoader::onHandlePropTypeInteger(pNode, pParent, pPropertyName, pInteger, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeFloatXY(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float * pFloatVar, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            Vec2 vec(pFloatVar[0], pFloatVar[1]);
            it->second(pNode, &vec);
        } else {
            NodeLoader::onHandlePropTypeFloatXY(pNode, pParent, pPropertyName, pFloatVar, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, bool pCheck, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            it->second(pNode, &pCheck);
        } else {
            NodeLoader::onHandlePropTypeCheck(pNode, pParent, pPropertyName, pCheck, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeSpriteFrame(Node * pNode, Node * pParent, const char * pPropertyName, SpriteFrame * pFrame, REDReader * ccbReader) {
        if(strcmp(pPropertyName, PROPERTY_DISPLAYFRAME) == 0) {
            static_cast<RParticleSystem*>(pNode)->setDisplayFrame(pFrame);
        } else {
            NodeLoader::onHandlePropTypeSpriteFrame(pNode, pParent, pPropertyName, pFrame, ccbReader);
        }
        //static_cast<ParticleSystemQuad*>(pNode)->setPositionType(ParticleSystem::PositionType::GROUPED);
    }

    void RParticleSystemLoader::onHandlePropTypeTexture(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::Texture2D * pTexture2D, REDReader * ccbReader)
    {
        if(strcmp(pPropertyName, PROPERTY_TEXTURE) == 0) {
            static_cast<RParticleSystem*>(pNode)->setTexture(pTexture2D);
        } else {
            NodeLoader::onHandlePropTypeTexture(pNode, pParent, pPropertyName, pTexture2D, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeBlendFunc(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, cocos2d::BlendFunc pBlendFunc, REDReader * ccbReader)
    {
        if(strcmp(pPropertyName, PROPERTY_BLENDFUNC) == 0) {
            static_cast<RParticleSystem*>(pNode)->setBlendFunc(pBlendFunc);
        } else {
            NodeLoader::onHandlePropTypeBlendFunc(pNode, pParent, pPropertyName, pBlendFunc, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeSeparatorCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, bool check, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            it->second(pNode, &check);
        } else {
            NodeLoader::onHandlePropTypeSeparatorCheck(pNode, pParent, pPropertyName, check, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeMinMaxGradientData(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, RRP::MinMaxGradientData& minMaxGradientData, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            it->second(pNode, &minMaxGradientData);
        } else {
            NodeLoader::onHandlePropTypeMinMaxGradientData(pNode, pParent, pPropertyName, minMaxGradientData, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeMinMaxCurveData(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, RRP::MinMaxCurveData& minMaxCurveData, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            it->second(pNode, &minMaxCurveData);
        } else {
            NodeLoader::onHandlePropTypeMinMaxCurveData(pNode, pParent, pPropertyName, minMaxCurveData, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeEmissionData(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, RRP::EmissionData& emissionData, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            it->second(pNode, &emissionData);
        } else {
            NodeLoader::onHandlePropTypeEmissionData(pNode, pParent, pPropertyName, emissionData, ccbReader);
        }
    }
    
    void RParticleSystemLoader::onHandlePropTypeFloatXYZ(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float * pFloatVar, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            Vec3 vec(pFloatVar[0], pFloatVar[1], pFloatVar[2]);
            it->second(pNode, &vec);
        } else {
            NodeLoader::onHandlePropTypeFloatXYZ(pNode, pParent, pPropertyName, pFloatVar, ccbReader);
        }
    }

    void RParticleSystemLoader::onHandlePropTypeMaterialFile(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, const char * materialFile, REDReader * ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            std::string str = materialFile;
            it->second(pNode, &str);
        } else {
            NodeLoader::onHandlePropTypeMaterialFile(pNode, pParent, pPropertyName, materialFile, ccbReader);
        }
    }
    void RParticleSystemLoader::onHandlePropTypeString(cocos2d::Node *pNode, cocos2d::Node *pParent, const char *pPropertyName, const char *pString, REDReader *ccbReader) {
        auto it = s_setters.find(pPropertyName);
        if (it != s_setters.end()) {
            std::string str = pString;
            it->second(pNode, &str);
        } else {
            NodeLoader::onHandlePropTypeString(pNode, pParent, pPropertyName, pString, ccbReader);
        }
    }
}