IAPDemo/Libraries/redream/CCNodeLoader.cpp

#include "CCNodeLoader.h"
#include "REDSelectorResolver.h"
#include "REDMemberVariableAssigner.h"
#include "REDAnimationManager.h"
#include "CCNode+REDRelativePositioning.h"
#include "deprecated/CCArray.h"
#include "deprecated/CCString.h"
#include "base/CCDirector.h"
#include "renderer/CCTextureCache.h"
#include "2d/CCSpriteFrameCache.h"
#include "2d/CCAnimationCache.h"
#include "platform/CCFileUtils.h"
#include "rparticle/Datas/EditorDatas.h"
#include "ui/UISlider.h"
#include "RPRedAudio.hpp"
#include "common/CocosConfig.h"

using namespace std;
using namespace cocos2d;
using namespace cocos2d::ui;
using namespace cocos2d::extension;

namespace redream {

Vec2 getAbsoluteScale(float mainScale, float additionalScale, float scaleX, float scaleY, unsigned int type)
{

    float scaleXCoef = 1.0;
    float scaleYCoef = 1.0;

    if (type & static_cast<int>(ScaleType::MULTIPLY_RESOURCES_SCALE))
    {
        scaleXCoef *= REDReader::getResolutionScale();
        scaleYCoef *= REDReader::getResolutionScale();
    }

    if (type & static_cast<int>(ScaleType::MULTIPLY_MAIN_SCALE))
    {
        scaleXCoef *= mainScale;
        scaleYCoef *= mainScale;
    }

    if (type & static_cast<int>(ScaleType::MULTIPLY_ADDITION_SCALE_X))
    {
        scaleXCoef *= additionalScale;
    }

    if (type & static_cast<int>(ScaleType::MULTIPLY_ADDITION_SCALE_Y))
    {
        scaleYCoef *= additionalScale;
    }

    if (type & static_cast<int>(ScaleType::INVERT_SCALE))
    {
        scaleXCoef = 1.0f/scaleXCoef;
        scaleYCoef = 1.0f/scaleYCoef;
    }

    return Vec2(scaleX*scaleXCoef,scaleY*scaleYCoef);
}

float getAbsoluteScale(float mainScale, float additionalScale, float scale, unsigned int type)
{

    float scaleCoef = REDReader::getResolutionScale();

    if (type & static_cast<int>(ScaleType::MULTIPLY_RESOURCES_SCALE))
    {
        scaleCoef *= REDReader::getResolutionScale();
    }

    if (type & static_cast<int>(ScaleType::MULTIPLY_MAIN_SCALE))
    {
        scaleCoef *= mainScale;
    }

    if (type & static_cast<int>(ScaleType::INVERT_SCALE))
    {
        scaleCoef = 1.0f/scaleCoef;
    }

    return scale * scaleCoef;
}

Vec2 getAbsolutePosition(float mainScale, float additionalScale, const Point &pt, PositionReferenceCorner corner, PositionUnit xUnit, PositionUnit yUnit, const Size &containerSize)
{
    Point positionInPoints=Point(0,0);
    float x = 0;
    float y = 0;

    // Convert position to points
    if (xUnit == PositionUnit::POINTS) x = pt.x * REDReader::getResolutionScale();
    else if (xUnit == PositionUnit::UIPOINTS) x = pt.x * mainScale * REDReader::getResolutionScale();
    else if (xUnit == PositionUnit::NORMALIZED) x = pt.x * containerSize.width / 100;

    if (yUnit == PositionUnit::POINTS) y = pt.y * REDReader::getResolutionScale();
    else if (yUnit == PositionUnit::UIPOINTS) y = pt.y * mainScale * REDReader::getResolutionScale();
    else if (yUnit == PositionUnit::NORMALIZED) y = pt.y * containerSize.height / 100;

    // Account for reference corner
    //CCPositionReferenceCorner corner = type.corner;
    if (corner == PositionReferenceCorner::BOTTOMLEFT)
    {
        // Nothing needs to be done
    }
    else if (corner == PositionReferenceCorner::TOPLEFT)
    {
        // Reverse y-axis
        y = containerSize.height - y;
    }
    else if (corner == PositionReferenceCorner::TOPRIGHT)
    {
        // Reverse x-axis and y-axis
        x = containerSize.width - x;
        y = containerSize.height - y;
    }
    else if (corner == PositionReferenceCorner::BOTTOMRIGHT)
    {
        // Reverse x-axis
        x = containerSize.width - x;
    }

    positionInPoints.x = x;
    positionInPoints.y = y;

    return positionInPoints;
}

Size getAbsoluteSize(float mainScale, float additionalScale, const Size &contentSize, SizeUnit widthUnit, SizeUnit heightUnit, const Size &containerSize)
{
    Size size = Size::ZERO;

    // Width
    if (widthUnit == SizeUnit::POINTS)
    {
        size.width = REDReader::getResolutionScale() * contentSize.width;
    }
    else if (widthUnit == SizeUnit::UIPOINTS)
    {
        size.width = REDReader::getResolutionScale() * mainScale * contentSize.width;
    }
    else if (widthUnit == SizeUnit::NORMALIZED)
    {
        size.width = contentSize.width * containerSize.width / 100;
    }
    else if (widthUnit == SizeUnit::INSETPOINTS)
    {
        size.width = containerSize.width - contentSize.width * REDReader::getResolutionScale();
    }
    else if (widthUnit == SizeUnit::INSETUIPOINTS)
    {
        size.width = containerSize.width - contentSize.width * REDReader::getResolutionScale() * mainScale;
    }

    // Height
    if (heightUnit == SizeUnit::POINTS)
    {
        size.height = REDReader::getResolutionScale() * contentSize.height;
    }
    else if (heightUnit == SizeUnit::UIPOINTS)
    {
        size.height = REDReader::getResolutionScale() * mainScale * contentSize.height;
    }
    else if (heightUnit == SizeUnit::NORMALIZED)
    {
        size.height = contentSize.height * containerSize.height / 100;
    }
    else if (heightUnit == SizeUnit::INSETPOINTS)
    {
        size.height = containerSize.height - contentSize.height * REDReader::getResolutionScale();
    }
    else if (heightUnit == SizeUnit::INSETUIPOINTS)
    {
        size.height = containerSize.height - contentSize.height * REDReader::getResolutionScale() * mainScale;
    }

    return size;
}

NodeLoader::NodeLoader()
{
}

NodeLoader::~NodeLoader()
{
}

ValueMap& NodeLoader::getCustomProperties()
{
    return _customProperties;
}

Node * NodeLoader::loadNode(Node * pParent, REDReader * ccbReader)
{
    Node * ccNode = this->createNode(pParent, ccbReader);

    //clear _customProperties, ready for load next node.
    _customProperties.clear();

    return ccNode;
}

void NodeLoader::parseProperties(Node * pNode, Node * pParent, REDReader * ccbReader, const RedreamInfo::Node& nodeProtobuf, std::string &reboltName, std::string &reboltId)
{
//    int numRegularProps = ccbReader->readInt(false);
//    int numExturaProps = ccbReader->readInt(false);
//    int propertyCount = numRegularProps + numExturaProps;
	int numRegularProps = nodeProtobuf.property_size();
    for(int i = 0; i < numRegularProps; i++) {
//        bool isExtraProp = (i >= numRegularProps);
//        REDReader::PropertyType type = (REDReader::PropertyType)ccbReader->readInt(false);
//        std::string propertyName = ccbReader->readCachedString();
		auto& propertyProtobuf = nodeProtobuf.property(i);
		REDReader::PropertyType type = (REDReader::PropertyType)propertyProtobuf.type();
		std::string propertyName = ccbReader->readCachedString(propertyProtobuf.name());
		bool setProp = true;
		handleProperties(pNode, pParent, ccbReader, propertyName, type, propertyProtobuf.value(), setProp, reboltName, reboltId);
	}
	
	int numExturaProps = nodeProtobuf.customproperty_size();
	for (int i = 0; i < numExturaProps; i++) {
		auto& propertyProtobuf = nodeProtobuf.customproperty(i);
		REDReader::PropertyType type = (REDReader::PropertyType)propertyProtobuf.type();
		std::string propertyName = ccbReader->readCachedString(propertyProtobuf.name());
		bool setProp = true;
		// Forward properties for sub ccb files
		if (dynamic_cast<REDFile*>(pNode) != nullptr)
		{
			REDFile *ccbNode = (REDFile*)pNode;
			if (ccbNode->getREDFileNode())
			{
				pNode = ccbNode->getREDFileNode();
				
				// Skip properties that doesn't have a value to override
				__Array *extraPropsNames = (__Array*)pNode->getUserObject();
				Ref* pObj = nullptr;
				bool bFound = false;
				CCARRAY_FOREACH(extraPropsNames, pObj)
				{
					__String* pStr = static_cast<__String*>(pObj);
					if (0 == pStr->compare(propertyName.c_str()))
					{
						bFound = true;
						break;
					}
				}
				setProp &= bFound;
			}
		}
		else if (pNode == ccbReader->getAnimationManager()->getRootNode())
		{
			__Array *extraPropsNames = static_cast<__Array*>(pNode->getUserObject());
			if (! extraPropsNames)
			{
				extraPropsNames = __Array::create();
				pNode->setUserObject(extraPropsNames);
			}
			
			extraPropsNames->addObject(__String::create(propertyName));
		}
		handleProperties(pNode, pParent, ccbReader, propertyName, type, propertyProtobuf.value(), setProp, reboltName, reboltId);
	}
}
        
void NodeLoader::handleProperties(Node * pNode, Node * pParent, REDReader * ccbReader, const string& propertyName, REDReader::PropertyType type, const RedreamInfo::Value& valueProtobuf, bool setProp, std::string &reboltName, std::string &reboltId){
	switch(type)
	{
		case REDReader::PropertyType::POSITION:
		{
			Vec2 position = this->parsePropTypePosition(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
			if (setProp)
			{
				this->onHandlePropTypePosition(pNode, pParent, propertyName.c_str(), position, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::POINT:
		{
			Vec2 point = this->parsePropTypePoint(pNode, pParent, ccbReader, valueProtobuf);
			if (setProp)
			{
				this->onHandlePropTypePoint(pNode, pParent, propertyName.c_str(), point, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::POINT_LOCK:
		{
			Vec2 pointLock = this->parsePropTypePointLock(pNode, pParent, ccbReader, valueProtobuf);
			if (setProp)
			{
				this->onHandlePropTypePointLock(pNode, pParent, propertyName.c_str(), pointLock, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::SIZE:
		{
			Size size = this->parsePropTypeSize(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp) {
				this->onHandlePropTypeSize(pNode, pParent, propertyName.c_str(), size, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::SCALE_LOCK:
		{
			float * scaleLock = this->parsePropTypeScaleLock(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeScaleLock(pNode, pParent, propertyName.c_str(), scaleLock, ccbReader);
			}
			CC_SAFE_DELETE_ARRAY(scaleLock);
			break;
		}
		case REDReader::PropertyType::FLOAT:
		{
			float f = this->parsePropTypeFloat(pNode, pParent, ccbReader,valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeFloat(pNode, pParent, propertyName.c_str(), f, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::FLOAT_XY:
		{
			float * xy =  this->parsePropTypeFloatXY(pNode, pParent, ccbReader,valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeFloatXY(pNode, pParent, propertyName.c_str(), xy, ccbReader);
			}
			CC_SAFE_DELETE_ARRAY(xy);
			break;
		}
			
		case REDReader::PropertyType::DEGREES:
		{
			float degrees = this->parsePropTypeDegrees(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeDegrees(pNode, pParent, propertyName.c_str(), degrees, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::FLOAT_SCALE:
		{
			float floatScale = this->parsePropTypeFloatScale(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeFloatScale(pNode, pParent, propertyName.c_str(), floatScale, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::INTEGER:
		{
			int integer = this->parsePropTypeInteger(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeInteger(pNode, pParent, propertyName.c_str(), integer, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::INTEGER_LABELED:
		{
			int integerLabeled = this->parsePropTypeIntegerLabeled(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeIntegerLabeled(pNode, pParent, propertyName.c_str(), integerLabeled, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::FLOAT_VAR:
		{
			float * floatVar = this->parsePropTypeFloatVar(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeFloatVar(pNode, pParent, propertyName.c_str(), floatVar, ccbReader);
			}
			CC_SAFE_DELETE_ARRAY(floatVar);
			break;
		}
		case REDReader::PropertyType::CHECK:
		{
			bool check = this->parsePropTypeCheck(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeCheck(pNode, pParent, propertyName.c_str(), check, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::SPRITEFRAME:
		{
			SpriteFrame * ccSpriteFrame = this->parsePropTypeSpriteFrame(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeSpriteFrame(pNode, pParent, propertyName.c_str(), ccSpriteFrame, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::ANIMATION:
		{
			int integer = this->parsePropTypeInteger(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeInteger(pNode, pParent, propertyName.c_str(), integer, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::TEXTURE:
		{
			//modify by djd 粒子支持plist大纹理,优先走大纹理找不到就走小图.
			SpriteFrame * ccSpriteFrame = this->parsePropTypeTexture2(pNode, pParent, ccbReader, valueProtobuf);
			if (ccSpriteFrame) {
				if(setProp)
				{
					this->onHandlePropTypeSpriteFrame(pNode, pParent, propertyName.c_str(), ccSpriteFrame, ccbReader);
				}
			}else{
				Texture2D * ccTexture2D = this->parsePropTypeTexture(pNode, pParent, ccbReader, valueProtobuf);
				if(setProp)
				{
					this->onHandlePropTypeTexture(pNode, pParent, propertyName.c_str(), ccTexture2D, ccbReader);
				}
			}
			break;
		}
		case REDReader::PropertyType::BYTE:
		{
			unsigned char byte = this->parsePropTypeByte(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeByte(pNode, pParent, propertyName.c_str(), byte, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::COLOR3:
		{
			Color3B color3B = this->parsePropTypeColor3(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeColor3(pNode, pParent, propertyName.c_str(), color3B, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::COLOR4F_VAR:
		{
			Color4F * color4FVar = this->parsePropTypeColor4FVar(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeColor4FVar(pNode, pParent, propertyName.c_str(), color4FVar, ccbReader);
			}
			CC_SAFE_DELETE_ARRAY(color4FVar);
			break;
		}
		case REDReader::PropertyType::FLIP:
		{
			bool * flip = this->parsePropTypeFlip(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp) {
				this->onHandlePropTypeFlip(pNode, pParent, propertyName.c_str(), flip, ccbReader);
			}
			CC_SAFE_DELETE_ARRAY(flip);
			break;
		}
		case REDReader::PropertyType::BLEND_MODE:
		{
			BlendFunc blendFunc = this->parsePropTypeBlendFunc(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeBlendFunc(pNode, pParent, propertyName.c_str(), blendFunc, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::FNT_FILE:
		{
			std::string fntFile = ccbReader->getREDRootPath() + this->parsePropTypeFntFile(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp)
			{
				this->onHandlePropTypeFntFile(pNode, pParent, propertyName.c_str(), fntFile.c_str(), ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::FONT_TTF:
		{
			std::string fontTTF = this->parsePropTypeFontTTF(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp) {
				this->onHandlePropTypeFontTTF(pNode, pParent, propertyName.c_str(), fontTTF.c_str(), ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::STRING:
		{
			std::string string = this->parsePropTypeString(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp) {
				this->onHandlePropTypeString(pNode, pParent, propertyName.c_str(), string.c_str(), ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::TEXT:
		{
			std::string text = this->parsePropTypeText(pNode, pParent, propertyName.c_str(), ccbReader, valueProtobuf);
			if(setProp) {
				this->onHandlePropTypeText(pNode, pParent, propertyName.c_str(), text.c_str(), ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::BLOCK:
		{
			BlockData * blockData = this->parsePropTypeBlock(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp) {
				this->onHandlePropTypeBlock(pNode, pParent, propertyName.c_str(), blockData, ccbReader);
			}
			CC_SAFE_DELETE(blockData);
			break;
		}
		case REDReader::PropertyType::BLOCK_CONTROL:
		{
			BlockControlData * blockControlData = this->parsePropTypeBlockControl(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp && blockControlData != nullptr) {
				this->onHandlePropTypeBlockControl(pNode, pParent, propertyName.c_str(), blockControlData, ccbReader);
			}
			CC_SAFE_DELETE(blockControlData);
			break;
		}
		case REDReader::PropertyType::RED_FILE:
		{
			Node * ccbFileNode = this->parsePropTypeREDFile(pNode, pParent, ccbReader, valueProtobuf, reboltName, reboltId);
			if(setProp) {
				this->onHandlePropTypeREDFile(pNode, pParent, propertyName.c_str(), ccbFileNode, ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::SPINE_SKEL:
		{
			std::string skelFile = this->parsePropTypeSpineSkel(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp) {
				this->onHandlePropTypeSpineSkel(pNode, pParent, propertyName.c_str(), skelFile.c_str(), ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::SPINE_ATLAS:
		{
			std::string atlasFile = this->parsePropTypeSpineAtlas(pNode, pParent, ccbReader, valueProtobuf);
			if(setProp) {
				this->onHandlePropTypeSpineAtlas(pNode, pParent, propertyName.c_str(), atlasFile.c_str(), ccbReader);
			}
			break;
		}
		case REDReader::PropertyType::SPINE_SKELFRAME:
		{
			spine::SkeletonFrame frame = this->parsePropTypeSkelFrame(pNode, pParent, ccbReader,propertyName.c_str(), valueProtobuf);
			if(setProp) {
				this->onHandlePropTypeSkelFrame(pNode, pParent, propertyName.c_str(), frame, ccbReader);
			}
			break;
		}
        case REDReader::PropertyType::FRAME_SET:
        {
            vector<FramePath> frameSet = this->parsePropTypeFrameSet(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
            if (setProp) {
                this->onHandlePropTypeFrameSet(pNode, pParent, propertyName.c_str(), frameSet, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::PERCENT:
        {
            int value = this->parsePropTypePercent(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
            if (setProp) {
                this->onHandlePropTypePercent(pNode, pParent, propertyName.c_str(), value, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::COLOR4:
        {
            Color4B color4 = this->parsePropTypeColor4(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
            if (setProp) {
                this->onHandlePropTypeColor4(pNode, pParent, propertyName.c_str(), color4, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::CALLBACKS:
        {
            CallbacksData * callbacksData = this->parsePropTypeCallbacks(pNode, pParent, ccbReader, valueProtobuf);
            if (setProp) {
                this->onHandlePropTypeCallbacks(pNode, pParent, propertyName.c_str(), callbacksData, ccbReader);
            }
            CC_SAFE_DELETE(callbacksData);
            break;
        }
        case REDReader::PropertyType::LOCALIZATION:
        {
            LocalizationModel model = this->parsePropTypeLocalization(pNode, pParent, ccbReader,propertyName.c_str(), valueProtobuf);
            if(setProp) {
                this->onHandlePropTypeLocalization(pNode, pParent, propertyName.c_str(), model, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::TABLE_VIEW_RED_FILE:
        {
            // 默认为3个
            vector<Node*> nodes;
            for (int i = 0; i < 3; i++) {
                Node * ccbFileNode = this->parsePropTypeREDFile(pNode, pParent, ccbReader, valueProtobuf, reboltName, reboltId);
                nodes.push_back(ccbFileNode);
            }
            if(setProp) {
                this->onHandlePropTypeTableviewRedFile(pNode, pParent, propertyName.c_str(), nodes, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::PB_VERTS_FILE:
        {
            std::string filePath = ccbReader->readCachedString(valueProtobuf.intvalue());
            if (setProp) {
                this->onHandlePropTypePbVertsFile(pNode, pParent, propertyName.c_str(), filePath, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::SeparatorCheck:
        {
            bool value = this->parsePropTypeSeparatorCheck(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
            if(setProp)
            {
                this->onHandlePropTypeSeparatorCheck(pNode, pParent, propertyName.c_str(), value, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::MinMaxGradientData:
        {
            auto value = this->parsePropTypeMinMaxGradientData(pNode, pParent, ccbReader,propertyName.c_str(), valueProtobuf);
            if(setProp) {
                this->onHandlePropTypeMinMaxGradientData(pNode, pParent, propertyName.c_str(), value, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::MinMaxCurveData:
        {
            auto value = this->parsePropTypeMinMaxCurveData(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
            if(setProp) {
                this->onHandlePropTypeMinMaxCurveData(pNode, pParent, propertyName.c_str(), value, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::EmissionData:
        {
            auto value = this->parsePropTypeEmissionData(pNode, pParent, ccbReader, propertyName.c_str(), valueProtobuf);
            if(setProp) {
                this->onHandlePropTypeEmissionData(pNode, pParent, propertyName.c_str(), value, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::FloatXYZ:
        {
            auto value = this->parsePropTypeFloatXYZ(pNode, pParent, ccbReader, valueProtobuf);
            if(setProp) {
                this->onHandlePropTypeFloatXYZ(pNode, pParent, propertyName.c_str(), value, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::MaterialFile:
        {
            auto value = this->parsePropTypeMaterialFile(pNode, pParent, ccbReader, valueProtobuf);
            if(setProp) {
                this->onHandlePropTypeMaterialFile(pNode, pParent, propertyName.c_str(), value.c_str(), ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::MATERIAL_BALL:
        {
            auto value = this->parsePropTypeMaterialBall(pNode, pParent, ccbReader, valueProtobuf);
            if (setProp) {
                this->onHandlePropTypeMaterialBall(pNode, pParent, propertyName.c_str(), value.materialPath.c_str(), value.params, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::BAKE_DATA_FILE:
        {
            std::string dateFile = ccbReader->readCachedString(valueProtobuf.intvalue());
            if (setProp) {
                this->onHandlePropTypeBakeDataFile(pNode, pParent, propertyName.c_str(), dateFile.c_str(), ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::BAKE_ANIMATION:
        {
            auto bakeAnimation = this->parsePropTypeBakeAnimation(pNode, pParent, ccbReader, valueProtobuf);
            if (setProp) {
                this->onHandlePropTypeBakeAnimation(pNode, pParent, propertyName.c_str(), bakeAnimation.animationName.c_str(), bakeAnimation.elapsedTime, bakeAnimation.loop, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::POLYGON_FILE:
        {
            std::string filePath = ccbReader->readCachedString(valueProtobuf.intvalue());
            if (setProp) {
                this->onHandlePropTypePolygonFile(pNode, pParent, propertyName.c_str(), filePath, ccbReader);
            }
            break;
        }
        case REDReader::PropertyType::WISE:
        {
            WiseEventData wiseEventData = this->parsePropTypeWise(pNode, pParent, ccbReader, valueProtobuf);
            if (setProp) {
                this->onHandlePropTypeWise(pNode, pParent, propertyName.c_str(), wiseEventData, ccbReader);
            }
            break;
        }
        default:
        {
            string redFileName = ccbReader->getAnimationManager()->getREDFileName();
            string err = StringUtils::format("文件【%s】reboltName【%s】无法解析的属性类型【%d】",redFileName.c_str(), reboltName.c_str(), (int)type);
            throw err;
			ASSERT_FAIL_UNEXPECTED_PROPERTYTYPE(static_cast<int>(type));
			break;
        }
	}
}

Vec2 NodeLoader::parsePropTypePosition(Node * pNode, Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
    auto& containerSize = ccbReader->getAnimationManager()->getContainerSize(pParent);
	auto& positionProtobuf =  valueProtobuf.position();
	PositionDescription position;
	position.pos.x = positionProtobuf.x();
	position.pos.y = positionProtobuf.y();

	position.referenceCorner = static_cast<PositionReferenceCorner>(positionProtobuf.referencecorner());
	position.xUnits = static_cast<PositionUnit>(positionProtobuf.xunits());
	position.yUnits = static_cast<PositionUnit>(positionProtobuf.yunits());
	
    Vec2 pos = getAbsolutePosition(1.0f, 1.0f, position.pos, position.referenceCorner, position.xUnits, position.yUnits, containerSize);

    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ValueVector vec;
        vec.push_back(Value(position.pos.x));
        vec.push_back(Value(position.pos.y));
        vec.push_back(Value((int)position.referenceCorner));
        vec.push_back(Value((int)position.xUnits));
        vec.push_back(Value((int)position.yUnits));
        ccbReader->getAnimationManager()->setBaseValue(Value(vec), pNode, pPropertyName);
    }
    return pos;
}

Vec2 NodeLoader::parsePropTypePoint(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
    
//	float x = ccbReader->readFloat();
//    float y = ccbReader->readFloat();
	auto& vec2 = valueProtobuf.vec2();
	float x = vec2.x();
	float y = vec2.y();

    return Vec2(x, y);
}

Vec2 NodeLoader::parsePropTypePointLock(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    float x = ccbReader->readFloat();
//    float y = ccbReader->readFloat();
	auto& vec2 = valueProtobuf.vec2();
	float x = vec2.x();
	float y = vec2.y();

    return Vec2(x, y);
}

//SizeDescription parsePropTypeSizeInner(REDReader * ccbReader)
//{
//    SizeDescription ret;
//    ret.size.width = ccbReader->readFloat();
//    ret.size.height = ccbReader->readFloat();
//    ret.widthUnits = static_cast<SizeUnit>(ccbReader->readInt(false));
//    ret.heightUnits = static_cast<SizeUnit>(ccbReader->readInt(false));
//
//    return ret;
//}

Size NodeLoader::parsePropTypeSize(Node * /*pNode*/, Node * pParent, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
    auto& containerSize = ccbReader->getAnimationManager()->getContainerSize(pParent);
	auto& sizeProtobuf = valueProtobuf.size();
    SizeDescription size;
	size.size.width = sizeProtobuf.width();
	size.size.height = sizeProtobuf.height();
	size.widthUnits = static_cast<SizeUnit>(sizeProtobuf.widthunits());
	size.heightUnits = static_cast<SizeUnit>(sizeProtobuf.heightunits());
    Size sizeAb = getAbsoluteSize(1.0f, 1.0f, size.size, size.widthUnits, size.heightUnits, containerSize);
    return sizeAb;// Size(width, height);
}



float * NodeLoader::parsePropTypeFloatXY(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    float x = ccbReader->readFloat();
//    float y = ccbReader->readFloat();
	auto& vec2 = valueProtobuf.vec2();
	float x = vec2.x();
	float y = vec2.y();

    float * floatXY = new (std::nothrow) float[2];
    floatXY[0] = x;
    floatXY[1] = y;

    return floatXY;
}

float * NodeLoader::parsePropTypeScaleLock(Node * pNode, Node * /*pParent*/, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf) {
//    float x = ccbReader->readFloat();
//    float y = ccbReader->readFloat();
	auto& vec2 = valueProtobuf.vec2();
	float x = vec2.x();
	float y = vec2.y();
    
    REDReader::ScaleType type = REDReader::ScaleType::ABSOLUTE;
    
    setRelativeScale(pNode, x, y, type, pPropertyName);
    
    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ValueVector baseValue;
        baseValue.push_back(Value(x));
        baseValue.push_back(Value(y));
        baseValue.push_back(Value((int)type));
        
        ccbReader->getAnimationManager()->setBaseValue(Value(baseValue), pNode, pPropertyName);
    }
    
//    if (type == REDReader::ScaleType::MULTIPLY_RESOLUTION)
//    {
//        x *= ccbReader->getResolutionScale();
//        y *= ccbReader->getResolutionScale();
//    }
    
    float * scaleLock = new (std::nothrow) float[2];
    scaleLock[0] = x;
    scaleLock[1] = y;

    return scaleLock;
}

float NodeLoader::parsePropTypeFloat(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    return ccbReader->readFloat();
	return valueProtobuf.floatvalue();
}

float NodeLoader::parsePropTypeDegrees(Node * pNode, Node * /*pParent*/, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf) {
//    float ret = ccbReader->readFloat();
	float ret = valueProtobuf.floatvalue();
    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ccbReader->getAnimationManager()->setBaseValue(Value(ret), pNode, pPropertyName);
    }
    
    return ret;
}

float NodeLoader::parsePropTypeFloatScale(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//    float f = ccbReader->readFloat();
	float f = valueProtobuf.floatvalue();

//    REDReader::ScaleType type = static_cast<REDReader::ScaleType>(ccbReader->readInt(false));
    
//    if(type == REDReader::ScaleType::MULTIPLY_RESOLUTION)
//    {
//        f *= ccbReader->getResolutionScale();
//    }

    return f;
}

int NodeLoader::parsePropTypeInteger(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//    return ccbReader->readInt(true);
	return valueProtobuf.intvalue();
}

int NodeLoader::parsePropTypeIntegerLabeled(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//    return ccbReader->readInt(true);
	return valueProtobuf.intvalue();
}

float * NodeLoader::parsePropTypeFloatVar(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//    float f = ccbReader->readFloat();
//    float fVar = ccbReader->readFloat();
	auto& vec2 = valueProtobuf.vec2();
	float f = vec2.x();
	float fVar = vec2.y();
    
    float * arr = new (std::nothrow) float[2];
    arr[0] = f;
    arr[1] = fVar;
    
    return arr;
}

bool NodeLoader::parsePropTypeCheck(Node * pNode, Node * /*pParent*/, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
//    bool ret = ccbReader->readBool();
	bool ret = valueProtobuf.boolvalue();
    
    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ccbReader->getAnimationManager()->setBaseValue(Value(ret), pNode, pPropertyName);
    }
    
    return ret;
}


SpriteFrame * NodeLoader::parsePropTypeSpriteFrame(Node * pNode, Node * /*pParent*/, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
//    std::string spriteSheet = ccbReader->readCachedString();
//    std::string spriteFile = ccbReader->readCachedString();
	auto& spriteFrameProtobuf = valueProtobuf.spriteframe();
	std::string spriteSheet = ccbReader->readCachedString(spriteFrameProtobuf.spritesheet());
	std::string spriteFile = ccbReader->readCachedString(spriteFrameProtobuf.spritefile());
    
    SpriteFrame *spriteFrame = nullptr;
    if (!spriteFile.empty())
    {
        spriteFrame = ccbReader->getSpriteFrameByName(spriteFile, spriteSheet,true);
        if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
        {
            ccbReader->getAnimationManager()->setObject(spriteFrame, pNode, pPropertyName);
            ccbReader->getAnimationManager()->addSpriteFrameForNode(pNode, pPropertyName,spriteFile,spriteSheet);
        }
    }
    
    return spriteFrame;
}

Texture2D * NodeLoader::parsePropTypeTexture(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    std::string spriteFile = ccbReader->getREDRootPath() + ccbReader->readCachedString();
	std::string spriteFile = ccbReader->getREDRootPath() + ccbReader->readCachedString(valueProtobuf.intvalue());
    
    if (!spriteFile.empty())
    {
        return Director::getInstance()->getTextureCache()->addImage(spriteFile);
    }
    else 
    {
        return nullptr;
    }
}
    
SpriteFrame * NodeLoader::parsePropTypeTexture2(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    std::string spriteFile = ccbReader->readCachedString();
	std::string spriteFile = ccbReader->readCachedString(valueProtobuf.intvalue());
    SpriteFrame *spriteFrame = nullptr;
    if (!spriteFile.empty())
    {
        spriteFrame = ccbReader->getSpriteFrameByName(spriteFile, "",true);
    }
    return spriteFrame;
}

unsigned char NodeLoader::parsePropTypeByte(Node * pNode, Node * /*pParent*/, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
//    unsigned char ret = ccbReader->readByte();
	unsigned char ret = valueProtobuf.intvalue();
    
    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ccbReader->getAnimationManager()->setBaseValue(Value(ret), pNode, pPropertyName);
    }
    
    return ret;
}

Color3B NodeLoader::parsePropTypeColor3(Node * pNode, Node * /*pParent*/, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf) {
//    unsigned char r = ccbReader->readByte();
//    unsigned char g = ccbReader->readByte();
//    unsigned char b = ccbReader->readByte();
	
	auto& color3 = valueProtobuf.color3();
	unsigned char r = color3.r();
	unsigned char g = color3.g();
	unsigned char b = color3.b();
	Color3B color(r, g, b);
    
    ValueMap colorMap;
    colorMap["r"] = r;
    colorMap["g"] = g;
    colorMap["b"] = b;

    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ccbReader->getAnimationManager()->setBaseValue(Value(colorMap), pNode, pPropertyName);
    }
    return color;
}

Color4F * NodeLoader::parsePropTypeColor4FVar(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    float red = ccbReader->readFloat();
//    float green = ccbReader->readFloat();
//    float blue = ccbReader->readFloat();
//    float alpha = ccbReader->readFloat();
//    float redVar = ccbReader->readFloat();
//    float greenVar = ccbReader->readFloat();
//    float blueVar = ccbReader->readFloat();
//    float alphaVar = ccbReader->readFloat();
	auto& color4var = valueProtobuf.color4fvar();
	float red = color4var.red();
	float green = color4var.green();
	float blue = color4var.blue();
	float alpha = color4var.alpha();
	float redVar = color4var.redvar();
	float greenVar = color4var.greenvar();
	float blueVar = color4var.bluevar();
	float alphaVar = color4var.alphavar();
    
    Color4F * colors = new (std::nothrow) Color4F[2];
    colors[0].r = red;
    colors[0].g = green;
    colors[0].b = blue;
    colors[0].a = alpha;
    
    colors[1].r = redVar;
    colors[1].g = greenVar;
    colors[1].b = blueVar;
    colors[1].a = alphaVar;
    
    return colors;
}

bool * NodeLoader::parsePropTypeFlip(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    bool flipX = ccbReader->readBool();
//    bool flipY = ccbReader->readBool();
	auto& flipProtobuf = valueProtobuf.flip();
	bool flipX = flipProtobuf.flipx();
	bool flipY = flipProtobuf.flipy();

    bool * arr = new (std::nothrow) bool[2];
    arr[0] = flipX;
    arr[1] = flipY;

    return arr;
}

BlendFunc NodeLoader::parsePropTypeBlendFunc(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//    int source = ccbReader->readInt(false);
//    int destination = ccbReader->readInt(false);
	auto& blendmodeProtobuf = valueProtobuf.mode();
	int source = blendmodeProtobuf.source();
	int destination = blendmodeProtobuf.destination();
	
    BlendFunc blendFunc;
    blendFunc.src = source;
    blendFunc.dst = destination;
    
    return blendFunc;
}

std::string NodeLoader::parsePropTypeFntFile(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//    return ccbReader->readCachedString();
	return ccbReader->readCachedString(valueProtobuf.intvalue());
}

std::string NodeLoader::parsePropTypeString(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    return ccbReader->readCachedString();
	return ccbReader->readCachedString(valueProtobuf.intvalue());
}

std::string NodeLoader::parsePropTypeText(Node *pNode, Node * /*pParent*/, const char *pPropertyName, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    return ccbReader->readCachedString();
	std::string ret = ccbReader->readCachedString(valueProtobuf.intvalue());
    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ccbReader->getAnimationManager()->setBaseValue(Value(ret), pNode, pPropertyName);
    }
    return ret;
}

std::string NodeLoader::parsePropTypeFontTTF(Node * /*pNode*/, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
//    std::string fontTTF = ccbReader->readCachedString();
	std::string fontTTF = ccbReader->readCachedString(valueProtobuf.intvalue());

    // String * ttfEnding = String::create(".ttf");

    // TODO: Fix me if it is wrong
    /* If the fontTTF comes with the ".ttf" extension, prepend the absolute path. 
     * System fonts come without the ".ttf" extension and do not need the path prepended. */
    /*
    if(REDReader::endsWith(REDReader::toLowerCase(fontTTF), ttfEnding)){
        fontTTF = REDReader::concat(ccbReader->getREDRootPath(), fontTTF);
    }
     */

    return fontTTF;
}

BlockData * NodeLoader::parsePropTypeBlock(Node * pNode, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//    std::string selectorName = ccbReader->readCachedString();
//	REDReader::TargetType selectorTarget = static_cast<REDReader::TargetType>(ccbReader->readInt(false));
	
	auto& blockProtobuf = valueProtobuf.block();
	std::string selectorName = ccbReader->readCachedString(blockProtobuf.selectorname());
	REDReader::TargetType selectorTarget = static_cast<REDReader::TargetType>(blockProtobuf.selectortarget());

    if(selectorTarget != REDReader::TargetType::NONE)
    {
        Ref*  target = nullptr;
        if(!ccbReader->isJSControlled())
        {
            if(selectorTarget == REDReader::TargetType::DOCUMENT_ROOT)
            {
                target = ccbReader->getAnimationManager()->getRootNode();
            }
            else if(selectorTarget == REDReader::TargetType::OWNER)
            {
                target = ccbReader->getOwner();
            }
            
            if(target != nullptr)
            {
                if(!selectorName.empty())
                {
                    SEL_MenuHandler selMenuHandler = 0;
                    
                    REDSelectorResolver * targetAsREDSelectorResolver = dynamic_cast<REDSelectorResolver *>(target);
                    
                    if(targetAsREDSelectorResolver != nullptr)
                    {
                        selMenuHandler = targetAsREDSelectorResolver->onResolveREDCCMenuItemSelector(target, selectorName.c_str());
                    }
                    
                    if(selMenuHandler == 0)
                    {
                        REDSelectorResolver * ccbSelectorResolver = ccbReader->getREDSelectorResolver();
                        if(ccbSelectorResolver != nullptr)
                        {
                            selMenuHandler = ccbSelectorResolver->onResolveREDCCMenuItemSelector(target, selectorName.c_str());
                        }
                    }
                    
                    if(selMenuHandler == 0) {
                        CCLOG("Skipping selector '%s' since no REDSelectorResolver is present.", selectorName.c_str());
                    } else {
                        BlockData * blockData = new (std::nothrow) BlockData();
                        blockData->mSELMenuHandler = selMenuHandler;
                        
                        blockData->_target = target;
                        
                        return blockData;
                    }
                } else {
                    CCLOG("Unexpected empty selector.");
                }
            } else {
                CCLOG("Unexpected nullptr target for selector.");
            }
        }
        else
        {
            if (selectorTarget == REDReader::TargetType::DOCUMENT_ROOT)
            {
                ccbReader->addDocumentCallbackNode(pNode);
                ccbReader->addDocumentCallbackName(selectorName);
                // Since there isn't a Control::EventType::NONE, add a TOUCH_DOWN type as a placeholder.
                ccbReader->addDocumentCallbackControlEvents(Control::EventType::TOUCH_DOWN);
            }
            else if (selectorTarget == REDReader::TargetType::OWNER)
            {
                ccbReader->addOwnerCallbackNode(pNode);
                ccbReader->addOwnerCallbackName(selectorName);
                // Since there isn't a Control::EventType::NONE, add a TOUCH_DOWN type as a placeholder.
                ccbReader->addOwnerCallbackControlEvents(Control::EventType::TOUCH_DOWN);
            }
        }
    }

    return nullptr;
}

BlockControlData * NodeLoader::parsePropTypeBlockControl(Node * pNode, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//	std::string selectorName = ccbReader->readCachedString();
//	REDReader::TargetType selectorTarget = static_cast<REDReader::TargetType>(ccbReader->readInt(false));
//	int controlEvents = ccbReader->readInt(false);
	auto& blockControlProtobuf = valueProtobuf.block_control();
	std::string selectorName = ccbReader->readCachedString(blockControlProtobuf.selectorname());
    REDReader::TargetType selectorTarget = static_cast<REDReader::TargetType>(blockControlProtobuf.selectortarget());
    int controlEvents = blockControlProtobuf.controlevents();

    if(selectorTarget != REDReader::TargetType::NONE)
    {
		Ref*  target = nullptr;
		if(selectorTarget == REDReader::TargetType::DOCUMENT_ROOT)
		{
			target = ccbReader->getAnimationManager()->getRootNode();
		}
		else if(selectorTarget == REDReader::TargetType::OWNER)
		{
			target = ccbReader->getOwner();
		}
		
		if(target != nullptr)
		{
			if(!selectorName.empty())
			{
				Control::Handler selControlHandler = 0;
				
				REDSelectorResolver * targetAsREDSelectorResolver = dynamic_cast<REDSelectorResolver *>(target);
				
				if(targetAsREDSelectorResolver != nullptr)
				{
					selControlHandler = targetAsREDSelectorResolver->onResolveREDCCControlSelector(target, selectorName.c_str());
				}
				
				if(selControlHandler == 0)
				{
					REDSelectorResolver * ccbSelectorResolver = ccbReader->getREDSelectorResolver();
					if(ccbSelectorResolver != nullptr)
					{
						selControlHandler = ccbSelectorResolver->onResolveREDCCControlSelector(target, selectorName.c_str());
					}
				}
				
				if(selControlHandler == 0)
				{
					CCLOG("Skipping selector '%s' since no REDSelectorResolver is present.", selectorName.c_str());
				}
				else
				{
					BlockControlData * blockControlData = new (std::nothrow) BlockControlData();
					blockControlData->mSELControlHandler = selControlHandler;
					
					blockControlData->_target = target;
					blockControlData->mControlEvents = (Control::EventType)controlEvents;
					
					return blockControlData;
				}
			} else {
				CCLOG("Unexpected empty selector.");
			}
		} else {
			CCLOG("Unexpected nullptr target for selector.");
		}
    }
    return nullptr;
}

Node * NodeLoader::parsePropTypeREDFile(Node * /*pNode*/, Node * pParent, REDReader * pREDReader, const RedreamInfo::Value& valueProtobuf, std::string &reboltName, std::string &reboltId) {
//    std::string ccbFileName = pREDReader->getREDRootPath() + pREDReader->readCachedString();
	std::string ccbFileName = pREDReader->getREDRootPath() + pREDReader->readCachedString(valueProtobuf.intvalue());

    /* Change path extension to .ccbi. */
    std::string ccbFileWithoutPathExtension = REDReader::deletePathExtension(ccbFileName.c_str());
    ccbFileName = ccbFileWithoutPathExtension + ".redream";
    
    // Load sub file
    std::string path = FileUtils::getInstance()->fullPathForFilename(ccbFileName);
    //add by songqingyu
    bool isBatchRedream = false;
    //如果是batchredream则加载batchredream
    if (path.empty()) {
        ccbFileName = ccbFileWithoutPathExtension + ".batchredream";
        path = FileUtils::getInstance()->fullPathForFilename(ccbFileName);
        isBatchRedream = true;
    }
    auto dataPtr = std::make_shared<Data>(FileUtils::getInstance()->getDataFromFile(path));
    
    REDReader * reader = new (std::nothrow) REDReader(pREDReader);
    // reader->autorelease();
    reader->getAnimationManager()->setRootContainerSize(pParent->getContentSize());
    reader->_isBatchNode = isBatchRedream;
    //add by djd
    reader->getAnimationManager()->setREDFileName(ccbFileName);
    
    reader->_data = dataPtr;
    reader->_bytes = dataPtr->getBytes();
    reader->_currentByte = 0;
    reader->_currentBit = 0;
    CC_SAFE_RETAIN(pREDReader->_owner);
    reader->_owner = pREDReader->_owner;
    
    reader->getAnimationManager()->_owner = reader->_owner;

    // The assignments below are done in the REDReader constructor.
//     reader->_ownerOutletNames = pREDReader->_ownerOutletNames;
//     reader->_ownerOutletNodes = pREDReader->_ownerOutletNodes;
//     reader->_ownerOutletNodes->retain();
//     reader->_ownerCallbackNames = pREDReader->_ownerCallbackNames;
//     reader->_ownerCallbackNodes = pREDReader->_ownerCallbackNodes;
//     reader->_ownerCallbackNodes->retain();

    
    Node * ccbFileNode = reader->readFileWithCleanUp(false, pREDReader->getAnimationManagers(), pREDReader->getReboltRedManagerMapPtr(), [pREDReader, reader, reboltId, pParent](){
        // 开始处理rebolt相关的逻辑，设置路径
        ReboltRedManager* selfReboltManger = reader->getReboltRedManager();
        vector<RootReboltManger> selfRootReboltMangetVec;
        selfRootReboltMangetVec.clear();
        if(selfReboltManger != nullptr){
            ReboltRedManager* pReboltManger = pREDReader->getReboltRedManager();
            if(pReboltManger != nullptr){
                vector<RootReboltManger> pRootReboltMangetVec = pReboltManger->getRootRedMangers();
//                CCLOG("zml ------");
                for(int i = 0 ; i < pRootReboltMangetVec.size(); i++){
                    RootReboltManger rrm = pRootReboltMangetVec[i];
                    RootReboltManger retRrm;
                    retRrm.rootRedManger = rrm.rootRedManger;
//                    CCLOG("zml--------- %s---%s", rrm.selfPath.c_str(), reboltId.c_str());
                    if(rrm.rootRedManger->getRootNode() == pREDReader->getAnimationManager()->getRootNode()){
                        retRrm.selfPath = reboltId;
//                        CCLOG("zml %s", retRrm.selfPath.c_str());
                    } else {
                        retRrm.selfPath = rrm.selfPath + "::" + reboltId;
//                        CCLOG("zml %s", retRrm.selfPath.c_str());
                    }
                    selfRootReboltMangetVec.push_back(retRrm);
                    rrm.rootRedManger->onAssignREDReboltRedManagerReboltPath(rrm.rootRedManger, retRrm.selfPath.c_str(), selfReboltManger);
                }
            }
            selfReboltManger->setRootRedMangers(selfRootReboltMangetVec);
        }
        // 结束处理rebolt相关的逻辑，设置路径
    });
    
    
    
    if (ccbFileNode && reader->getAnimationManager()->getAutoPlaySequenceId() != -1)
    {
        // Auto play animations
        reader->getAnimationManager()->runAnimationsForSequenceIdTweenDuration(reader->getAnimationManager()->getAutoPlaySequenceId(), 0);
    }
    
   
    reader->release();
    return ccbFileNode;
}

std::string NodeLoader::parsePropTypeSpineSkel(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//    std::string file = ccbReader->readCachedString();
//    return file;
	return ccbReader->readCachedString(valueProtobuf.intvalue());
}

std::string NodeLoader::parsePropTypeSpineAtlas(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
//    std::string file = ccbReader->readCachedString();
//    return file;
	return ccbReader->readCachedString(valueProtobuf.intvalue());
}

spine::SkeletonFrame NodeLoader::parsePropTypeSkelFrame(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
//    std::string animation = ccbReader->readCachedString();
//    float progress = ccbReader->readFloat();
//    bool loop = ccbReader->readBool();
	auto& skelFrameProtobuf = valueProtobuf.skelframe();
	std::string animation = ccbReader->readCachedString(skelFrameProtobuf.animation());
	float progress = skelFrameProtobuf.progress();
	bool loop = skelFrameProtobuf.loop();
    
    spine::SkeletonFrame frame;
    frame.animation = animation;
    frame.progress = progress;
    frame.loop = loop;
    
    ValueMap frameMap;
    frameMap["animation"] = animation;
    frameMap["progress"] = progress;
    frameMap["loop"] = loop;

    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ccbReader->getAnimationManager()->setBaseValue(Value(frameMap), pNode, pPropertyName);
    }
    
    return frame;
}

vector<FramePath> NodeLoader::parsePropTypeFrameSet(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf) {
    vector<FramePath> frameSet;
    auto& frameSetProtobuf = valueProtobuf.frameset();
    
    for (int i = 0; i < frameSetProtobuf.frames_size(); ++i)
    {
        auto& frameProtobuf = frameSetProtobuf.frames(i);
        std::string spriteSheet = ccbReader->readCachedString(frameProtobuf.spritesheet());
        std::string spriteFile = ccbReader->readCachedString(frameProtobuf.spritefile());
        
        FramePath framePath;
        if (!spriteFile.empty())
        {
            if (CocosConfig::getIgnoreCCBPath())
            {
                framePath.path      = spriteFile;
                framePath.texType   = FramePath::TextureResType::LOCAL;
            }
            else
            {
                if (spriteSheet.empty())
                {
                    framePath.path      = ccbReader->getREDRootPath() + spriteFile;
                    framePath.texType   = FramePath::TextureResType::LOCAL;
                }
                else
                {
                    SpriteFrameCache * frameCache = SpriteFrameCache::getInstance();
                    spriteSheet = ccbReader->getREDRootPath() + spriteSheet;
                    // Load the sprite sheet only if it is not loaded
                    if (ccbReader->getLoadedSpriteSheet().find(spriteSheet) == ccbReader->getLoadedSpriteSheet().end())
                    {
                        frameCache->addSpriteFramesWithFile(spriteSheet);
                        ccbReader->getLoadedSpriteSheet().insert(spriteSheet);
                    }
                    
                    framePath.path      = spriteFile;
                    framePath.texType   = FramePath::TextureResType::PLIST;
                }
            }
        }
        else
        {
            framePath.path      = "";
            framePath.texType   = FramePath::TextureResType::LOCAL;
        }
        
        frameSet.push_back(framePath);
    }
    
    return frameSet;
}

int NodeLoader::parsePropTypePercent(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf) {
    return valueProtobuf.percent().value();
}

CallbacksData * NodeLoader::parsePropTypeCallbacks(Node * pNode, Node * /*pParent*/, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
    auto& blockControlProtobuf = valueProtobuf.callbacks();
    std::string selectorName = ccbReader->readCachedString(blockControlProtobuf.selectorname());
    REDReader::TargetType selectorTarget = static_cast<REDReader::TargetType>(blockControlProtobuf.selectortarget());
    
    if(selectorTarget != REDReader::TargetType::NONE)
    {
        if(!ccbReader->isJSControlled())
        {
            Ref* target = nullptr;
            if(selectorTarget == REDReader::TargetType::DOCUMENT_ROOT)
            {
                target = ccbReader->getAnimationManager()->getRootNode();
            }
            else if(selectorTarget == REDReader::TargetType::OWNER)
            {
                target = ccbReader->getOwner();
            }
            
            if(target != nullptr)
            {
                if(!selectorName.empty())
                {
                    CallbacksData * callbacksData = new (std::nothrow) CallbacksData();
                    
                    callbacksData->selectorName = selectorName;
                    callbacksData->_target = target;
                    
                    return callbacksData;
                } else {
                    CCLOG("Unexpected empty selector.");
                }
            } else {
                CCLOG("Unexpected nullptr target for selector.");
            }
        }
        else
        {
            if(selectorTarget == REDReader::TargetType::DOCUMENT_ROOT)
            {
                ccbReader->addDocumentCallbackNode(pNode);
                ccbReader->addDocumentCallbackName(selectorName);
            }
            else
            {
                ccbReader->addOwnerCallbackNode(pNode);
                ccbReader->addOwnerCallbackName(selectorName);
            }
        }
    }
    
    return nullptr;
}

LocalizationModel NodeLoader::parsePropTypeLocalization(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf) {
    LocalizationModel ret;
    auto localization = valueProtobuf.localization();
    ret.isLocalization = localization.islocalization();
    ret.isCustom = localization.iscustom();
    ret.customFilePath = localization.customfilepath();
    ret.key = localization.key();
    return ret;
}
static cocos2d::Color3B readColor3(const RedreamInfo::Color3& color3)
{
    return Color3B(color3.r(), color3.g(), color3.b());
}

static cocos2d::Color4B readColor4(const RedreamInfo::Color4& color4)
{
    return Color4B(color4.r(), color4.g(), color4.b(), color4.a());
}

static RRP::AnimationCurveData readAnimationCurveData(const RedreamInfo::AnimationCurveData& dataProtobuf)
{
    RRP::AnimationCurveData data(dataProtobuf.preinfinity(), dataProtobuf.postinfinity());
    
    for (auto& kf : dataProtobuf.curve())
    {
        data.m_Curve.push_back(RRP::KeyframeData(kf.time(), kf.value(), kf.inslope(), kf.outslope()));
    }
    
    return data;
}

static RRP::GradientNEWData readGradientNEWData(const RedreamInfo::GradientNEWData& dataProtobuf)
{
    RRP::GradientNEWData data;

    for (auto& colorProtobuf : dataProtobuf.color()){
        data.m_Color.push_back(RRP::Color3BData(colorProtobuf.time(), readColor3(colorProtobuf.color())));
    }

    for (auto& alphaProtobuf : dataProtobuf.alpha()){
        data.m_Alpha.push_back(RRP::AlphaData(alphaProtobuf.time(), alphaProtobuf.alpha()));
    }

    return data;
}

cocos2d::Color4B NodeLoader::parsePropTypeColor4(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
    auto color = readColor4(valueProtobuf.color4());
    
    ValueMap colorMap;
    colorMap["r"] = color.r;
    colorMap["g"] = color.g;
    colorMap["b"] = color.b;
    colorMap["a"] = color.a;

    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ccbReader->getAnimationManager()->setBaseValue(Value(colorMap), pNode, pPropertyName);
    }
    return color;
}

bool NodeLoader::parsePropTypeSeparatorCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
    bool ret = valueProtobuf.boolvalue();
    
    if (ccbReader->getAnimatedProperties()->find(pPropertyName) != ccbReader->getAnimatedProperties()->end())
    {
        ccbReader->getAnimationManager()->setBaseValue(Value(ret), pNode, pPropertyName);
    }
    
    return ret;
}

RRP::MinMaxGradientData NodeLoader::parsePropTypeMinMaxGradientData(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
    auto& data = valueProtobuf.minmaxgradientdata();
    return RRP::MinMaxGradientData((RRP::MinMaxGradientState) data.minmaxstate(), readColor4(data.mincolor()), readColor4(data.maxcolor()), readGradientNEWData(data.mingradient()), readGradientNEWData(data.maxgradient()));
}

RRP::MinMaxCurveData NodeLoader::parsePropTypeMinMaxCurveData(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
    auto& data = valueProtobuf.minmaxcurvedata();
    return RRP::MinMaxCurveData((RRP::MinMaxCurveState) data.minmaxstate(), data.scalar(), readAnimationCurveData(data.mincurve()), readAnimationCurveData(data.maxcurve()));
}

RRP::EmissionData NodeLoader::parsePropTypeEmissionData(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf)
{
    auto& data = valueProtobuf.emissiondata();
    RRP::EmissionData emissionData;
    
    for (auto& burstData : data.burstdata()) {
        emissionData.burstData.push_back(RRP::BurstData(burstData.bursttime(), burstData.burstparticlecount()));
    }
    
    return emissionData;
}

float * NodeLoader::parsePropTypeFloatXYZ(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
    auto& vec3 = valueProtobuf.vec3();

    float * floatXYZ = new (std::nothrow) float[3];
    floatXYZ[0] = vec3.x();
    floatXYZ[1] = vec3.y();
    floatXYZ[2] = vec3.z();

    return floatXYZ;
}

std::string NodeLoader::parsePropTypeMaterialFile(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf)
{
    return ccbReader->readCachedString(valueProtobuf.intvalue());
}

MaterialBall NodeLoader::parsePropTypeMaterialBall(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
    MaterialBall ball;
    ball.materialPath = valueProtobuf.materialball().materialballpath();
    auto params = valueProtobuf.materialball().params();
    for (auto it = params.begin(); it != params.end(); it++) {
        auto key = it->first;
        auto value = it->second;
        ball.params.insert({key, value});
    }
    return ball;
}

BakeAnimation NodeLoader::parsePropTypeBakeAnimation(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf) {
    BakeAnimation bakeAnimation;
    bakeAnimation.animationName = valueProtobuf.bakeanimation().animationname();
    bakeAnimation.elapsedTime = valueProtobuf.bakeanimation().elapsedtime();
    bakeAnimation.loop = valueProtobuf.bakeanimation().loop();
    return bakeAnimation;
}

WiseEventData NodeLoader::parsePropTypeWise(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const RedreamInfo::Value& valueProtobuf){
    WiseEventData wiseEventData;
    
    wiseEventData.wiseBnkPath = valueProtobuf.wise().bnkfile();
    wiseEventData.wiseEventName = valueProtobuf.wise().eventname();
    wiseEventData.wiseForcePost = valueProtobuf.wise().forcepost();
    if (wiseEventData.wiseEventName.size()) {
        const auto & param_vec = valueProtobuf.wise().params();
        for(auto param : param_vec){
            redprotocol::AudioParam param_obj_tmp;
            param_obj_tmp.name = param.key();
            param_obj_tmp.fValue1 = param.value();
            param_obj_tmp.fValue2 = 0.f;
            param_obj_tmp.fValue3 = 100.f;
            wiseEventData.audioParams.push_back(std::move(param_obj_tmp));
        }
    }
    return wiseEventData;
}

void NodeLoader::onHandlePropTypePosition(Node * pNode, Node * /*pParent*/, const char* pPropertyName, Vec2 pPosition, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_POSITION) == 0) {
        pNode->setPosition(pPosition);
    } else {
        ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    }
}

void NodeLoader::onHandlePropTypePoint(Node * pNode, Node * /*pParent*/, const char* pPropertyName, Vec2 pPoint, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_ANCHORPOINT) == 0) {
        pNode->setAnchorPoint(pPoint);
    } else {
        ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    }
}

void NodeLoader::onHandlePropTypePointLock(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, Vec2 /*pPointLock*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeSize(Node * pNode, Node * /*pParent*/, const char* pPropertyName, Size pSize, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_CONTENTSIZE) == 0) {
        pNode->setContentSize(pSize);
    } else {
        ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    }
}

void NodeLoader::onHandlePropTypeFloatXY(Node * pNode, Node * /*pParent*/, const char* pPropertyName, float * pFloat, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_SKEW) == 0) {
        pNode->setSkewX(pFloat[0]);
        pNode->setSkewY(pFloat[1]);
    } else {
        ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    }
}


void NodeLoader::onHandlePropTypeScaleLock(Node * pNode, Node * /*pParent*/, const char* pPropertyName, float * pScaleLock, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_SCALE) == 0) {
        pNode->setScaleX(pScaleLock[0]);
        pNode->setScaleY(pScaleLock[1]);
    } else {
        ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    }
}

void NodeLoader::onHandlePropTypeFloat(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, float pFloat, REDReader * /*ccbReader*/) {
//    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    // It may be a custom property, add it to custom property dictionary.
    _customProperties[pPropertyName] = Value(pFloat);
}


void NodeLoader::onHandlePropTypeDegrees(Node * pNode, Node * /*pParent*/, const char* pPropertyName, float pDegrees, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_ROTATION) == 0) {
        pNode->setRotation(pDegrees);
    } else if(strcmp(pPropertyName, PROPERTY_ROTATIONX) == 0) {
        pNode->setRotationSkewX(pDegrees);
    } else if(strcmp(pPropertyName, PROPERTY_ROTATIONY) == 0) {
        pNode->setRotationSkewY(pDegrees);
    }
    else {
        ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    }
}

void NodeLoader::onHandlePropTypeFloatScale(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, float /*pFloatScale*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeInteger(Node * pNode, Node * /*pParent*/, const char* pPropertyName, int pInteger, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_TAG) == 0) {
        pNode->setTag(pInteger);
    } else {
 //       ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
        // It may be a custom property, add it to custom property dictionary.
        _customProperties[pPropertyName] = Value(pInteger);
    }
}

void NodeLoader::onHandlePropTypeIntegerLabeled(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, int /*pIntegerLabeled*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeFloatVar(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, float * /*pFloatVar*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeCheck(Node * pNode, Node * /*pParent*/, const char* pPropertyName, bool pCheck, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_VISIBLE) == 0) {
        pNode->setVisible(pCheck);
    } else if(strcmp(pPropertyName, PROPERTY_IGNOREANCHORPOINTFORPOSITION) == 0) {
        pNode->setIgnoreAnchorPointForPosition(pCheck);
    }else if(strcmp(pPropertyName, PROPERTY_CASCADEOPACITYENABLED) == 0){
        pNode->setCascadeOpacityEnabled(pCheck);
    }else if(strcmp(pPropertyName, PROPERTY_CASCADECOLORENABLED) == 0){
        pNode->setCascadeColorEnabled(pCheck);
    } else {
        //ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
        // It may be a custom property, add it to custom property dictionary.
        _customProperties[pPropertyName] = Value(pCheck);
    }
}

void NodeLoader::onHandlePropTypeSpriteFrame(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, SpriteFrame * /*pSpriteFrame*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeAnimation(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, Animation * /*pAnimation*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeTexture(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, Texture2D * /*pTexture2D*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeByte(Node * pNode, Node * /*pParent*/, const char* pPropertyName, unsigned char pByte, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_OPACITY) == 0) {
        pNode->setOpacity(pByte);
    }else{
        ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    }
}

void NodeLoader::onHandlePropTypeColor3(Node * pNode, Node * /*pParent*/, const char* pPropertyName, Color3B pColor3B, REDReader * /*ccbReader*/) {
    if(strcmp(pPropertyName, PROPERTY_COLOR) == 0) {
        pNode->setColor(pColor3B);
    } else {
        ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    }
    
}

void NodeLoader::onHandlePropTypeColor4FVar(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, Color4F * /*pColor4FVar*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeFlip(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, bool * /*pFlip*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeBlendFunc(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, BlendFunc /*pBlendFunc*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeFntFile(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, const char* /*pFntFile*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeString(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, const char * pString, REDReader * /*ccbReader*/) {
//    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
    // It may be a custom property, add it to custom property dictionary.
    _customProperties[pPropertyName] = Value(pString);
}

void NodeLoader::onHandlePropTypeText(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, const char * /*pText*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeFontTTF(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, const char * /*pFontTTF*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeBlock(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, BlockData * /*pBlockData*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeBlockControl(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, BlockControlData * /*pBlockControlData*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeREDFile(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, Node * /*pREDFileNode*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeSpineSkel(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, const char * /*pSkel*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeSpineAtlas(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, const char * /*pAtlas*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeSkelFrame(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, spine::SkeletonFrame /*pSkeFrame*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeFrameSet(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, vector<FramePath> /*pFrameSet*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypePercent(cocos2d::Node * /*pNode*/, cocos2d::Node * /*pParent*/, const char* pPropertyName, int /*pValue*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeColor4(cocos2d::Node * /*pNode*/, cocos2d::Node * /*pParent*/, const char* pPropertyName, Color4B /*pColor4*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeCallbacks(Node * /*pNode*/, Node * /*pParent*/, const char* pPropertyName, CallbacksData * /*pCallbacksData*/, REDReader * /*ccbReader*/) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeLocalization(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, LocalizationModel pModel, REDReader * ccbReader) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeSeparatorCheck(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, bool check, REDReader * ccbReader)
{
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeMinMaxGradientData(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, RRP::MinMaxGradientData& minMaxGradientData, REDReader * ccbReader)
{
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeMinMaxCurveData(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, RRP::MinMaxCurveData& minMaxCurveData, REDReader * ccbReader)
{
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeEmissionData(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, RRP::EmissionData& emissionData, REDReader * ccbReader)
{
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeFloatXYZ(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, float * pFloatVar, REDReader * ccbReader)
{
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeMaterialFile(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, const char * materialFile, REDReader * ccbReader)
{
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeTableviewRedFile(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, std::vector<cocos2d::Node*> pREDFileNodes, REDReader * ccbReader) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypePbVertsFile(cocos2d::Node * pNode, cocos2d::Node * pParent, const char * pPropertyName, const std::string& filePath, REDReader * ccbReader) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeMaterialBall(cocos2d::Node * pNode, cocos2d::Node * pParent, const char* pPropertyName, const char * materialPath, std::map<std::string, float> params, REDReader * ccbReader) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeBakeDataFile(cocos2d::Node *pNode, cocos2d::Node *pParent, const char *pPropertyName, const char *dataFile, REDReader *ccbReader) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeBakeAnimation(cocos2d::Node *pNode, cocos2d::Node *pParent, const char *pPropertyName, const char *animationName, float elapsedTime, bool loop, REDReader *ccbReader) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypePolygonFile(cocos2d::Node* pNode, cocos2d::Node* pParent, const char* pPropertyName, const std::string& filePath, REDReader* ccbReader) {
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}

void NodeLoader::onHandlePropTypeWise(cocos2d::Node* pNode, cocos2d::Node* pParent, const char* pPropertyName, const WiseEventData& wiseEventData, REDReader* ccbReader){
    ASSERT_FAIL_UNEXPECTED_PROPERTY(pPropertyName);
}
}//namespace