#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(ScaleType::MULTIPLY_RESOURCES_SCALE)) { scaleXCoef *= REDReader::getResolutionScale(); scaleYCoef *= REDReader::getResolutionScale(); } if (type & static_cast(ScaleType::MULTIPLY_MAIN_SCALE)) { scaleXCoef *= mainScale; scaleYCoef *= mainScale; } if (type & static_cast(ScaleType::MULTIPLY_ADDITION_SCALE_X)) { scaleXCoef *= additionalScale; } if (type & static_cast(ScaleType::MULTIPLY_ADDITION_SCALE_Y)) { scaleYCoef *= additionalScale; } if (type & static_cast(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(ScaleType::MULTIPLY_RESOURCES_SCALE)) { scaleCoef *= REDReader::getResolutionScale(); } if (type & static_cast(ScaleType::MULTIPLY_MAIN_SCALE)) { scaleCoef *= mainScale; } if (type & static_cast(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(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 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 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(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(positionProtobuf.referencecorner()); position.xUnits = static_cast(positionProtobuf.xunits()); position.yUnits = static_cast(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(ccbReader->readInt(false)); // ret.heightUnits = static_cast(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(sizeProtobuf.widthunits()); size.heightUnits = static_cast(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(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(ccbReader->readInt(false)); auto& blockProtobuf = valueProtobuf.block(); std::string selectorName = ccbReader->readCachedString(blockProtobuf.selectorname()); REDReader::TargetType selectorTarget = static_cast(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(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(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(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(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(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 selfRootReboltMangetVec; selfRootReboltMangetVec.clear(); if(selfReboltManger != nullptr){ ReboltRedManager* pReboltManger = pREDReader->getReboltRedManager(); if(pReboltManger != nullptr){ vector 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 NodeLoader::parsePropTypeFrameSet(cocos2d::Node * pNode, cocos2d::Node * pParent, REDReader * ccbReader, const char *pPropertyName, const RedreamInfo::Value& valueProtobuf) { vector 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(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 /*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 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 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