void JSONDataParser::parseTextureAtlasData(const char* rawData, TextureAtlasData& textureAtlasData, float scale) { if (rawData) { rapidjson::Document document; document.Parse(rawData); textureAtlasData.format = _getTextureFormat(_getString(document, FORMAT, "")); textureAtlasData.name = _getString(document, NAME, ""); textureAtlasData.imagePath = _getString(document, IMAGE_PATH, ""); if (scale > 0.f) { textureAtlasData.scale = scale; } else { scale = textureAtlasData.scale = _getNumber(document, SCALE, textureAtlasData.scale); } scale = 1.f / scale; if (document.HasMember(SUB_TEXTURE)) { for (const auto& textureObject : document[SUB_TEXTURE].GetArray()) { const auto textureData = textureAtlasData.generateTexture(); textureData->name = _getString(textureObject, NAME, ""); textureData->rotated = _getBoolean(textureObject, ROTATED, false); textureData->region.x = _getNumber(textureObject, X, 0.f) * scale; textureData->region.y = _getNumber(textureObject, Y, 0.f) * scale; textureData->region.width = _getNumber(textureObject, WIDTH, 0.f) * scale; textureData->region.height = _getNumber(textureObject, HEIGHT, 0.f) * scale; const auto frameWidth = _getNumber(textureObject, FRAME_WIDTH, -1.f); const auto frameHeight = _getNumber(textureObject, FRAME_HEIGHT, -1.f); if (frameWidth > 0.f && frameHeight > 0.f) { textureData->frame = TextureData::generateRectangle(); textureData->frame->x = _getNumber(textureObject, FRAME_X, 0.f) * scale; textureData->frame->y = _getNumber(textureObject, FRAME_Y, 0.f) * scale; textureData->frame->width = frameWidth * scale; textureData->frame->height = frameHeight * scale; } textureAtlasData.addTexture(textureData); } } } else { DRAGONBONES_ASSERT(false, "Argument error."); } }
SkinData * JSONDataParser::_parseSkin(const rapidjson::Value & rawData) { const auto skin = BaseObject::borrowObject<SkinData>(); skin->name = _getString(rawData, NAME, "__default"); if (skin->name.empty()) { skin->name = "__default"; } if (rawData.HasMember(SLOT)) { this->_skin = skin; for (const auto& slotObject : rawData[SLOT].GetArray()) { if (this->_isParentCooriinate) { this->_armature->addSlot(_parseSlot(slotObject)); } skin->addSlot(_parseSlotDisplaySet(slotObject)); } this->_skin = nullptr; } return skin; }
bool RedisClient::scriptLoad( string& values , const string& script ) { BuildCommand cmd("SCRIPT"); cmd << "LOAD" << script; return _getString(cmd, values); }
BoneFrameData * JSONDataParser::_parseBoneFrame(const rapidjson::Value& rawData, unsigned frameStart, unsigned frameCount) const { const auto frame = BaseObject::borrowObject<BoneFrameData>(); frame->parent = this->_armature->getBone(_getString(rawData, PARENT, "")); frame->tweenRotate = _getNumber(rawData, TWEEN_ROTATE, (int)0); frame->tweenScale = _getBoolean(rawData, TWEEN_SCALE, true); _parseTweenFrame<BoneFrameData>(rawData, *frame, frameStart, frameCount); if (rawData.HasMember(TRANSFORM)) { _parseTransform(rawData[TRANSFORM], frame->transform); } const auto bone = static_cast<BoneTimelineData*>(this->_timeline)->bone; if ((rawData.HasMember(EVENT) || rawData.HasMember(SOUND))) { _parseEventData(rawData, frame->events, bone, nullptr); this->_animation->hasBoneTimelineEvent = true; } if (rawData.HasMember(ACTION)) { const auto slot = this->_armature->getSlot(bone->name); _parseActionData(rawData, frame->actions, bone, slot); this->_animation->hasBoneTimelineEvent = true; } return frame; }
BoneTimelineData * JSONDataParser::_parseBoneTimeline(const rapidjson::Value& rawData) const { const auto timeline = BaseObject::borrowObject<BoneTimelineData>(); timeline->bone = this->_armature->getBone(_getString(rawData, NAME, "")); _parseTimeline<BoneFrameData>(rawData, *timeline, std::bind(&JSONDataParser::_parseBoneFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); auto& originTransform = timeline->originTransform; BoneFrameData* prevFrame = nullptr; for (const auto frame : timeline->frames) { const auto boneFrame = static_cast<BoneFrameData*>(frame); if (!prevFrame) { originTransform = boneFrame->transform; // copy boneFrame->transform.identity(); } else if (prevFrame != frame) { boneFrame->transform.minus(originTransform); } prevFrame = boneFrame; } if (timeline->scale != 1.f || timeline->offset != 0.f) { this->_animation->hasAsynchronyTimeline = true; } return timeline; }
double CRedisClient::hincrbyfloat(const string &key, const string &field, float increment) { Command cmd( "HINCRBYFLOAT" ); cmd << key << field << increment; string value; _getString( cmd , value ); return _valueFromString<double>( value ); }
bool CRedisClient::spop(const string &key, string &member) { member.clear(); Command cmd( "SPOP" ); cmd << key; return ( _getString( cmd, member ) ); }
// ERR packet (see http://dev.mysql.com/doc/internals/en/packet-ERR_Packet.html) static void _responseError(mysql_t *mysql) { mysql->state = MySQL_Error; mysql->response.data.error.code = _getUInt2(&mysql->response); if (mysql->capabilities & CLIENT_PROTOCOL_41) _getPadding(&mysql->response, 6); // skip sql_state_marker and sql_state which we don't use mysql->response.data.error.message = _getString(&mysql->response); THROW(IOException, "Server returned error code %d -- %s", mysql->response.data.error.code, mysql->response.data.error.message); }
/* void CRedisClient::clientList(CResult& result) { Command cmd( "CLIENT" ); cmd<<"LIST"; _socket.clearBuffer(); _sendCommand(cmd); _getReply(result); } */ uint64_t CRedisClient::clientList(CRedisClient::VecString & reply) { Command cmd( "CLIENT" ); cmd<<"LIST"; string str; _getString(cmd,str); return stringToVecString(str,reply); }
string CRedisClient::clientGetname() { Command cmd( "CLIENT" ); cmd<<"GETNAME"; string str; _getString(cmd,str); return str; }
string CRedisClient::debugObject(const string& key) { Command cmd( "DEBUG" ); cmd<<"OBJECT"; cmd<<key; string str; _getString(cmd,str); return str; }
DragonBonesData * JSONDataParser::parseDragonBonesData(const char* rawData, float scale) { if (rawData) { rapidjson::Document document; document.Parse(rawData); std::string version = _getString(document, VERSION, ""); this->_isParentCooriinate = version == DATA_VERSION_2_3 || version == DATA_VERSION_3_0; this->_armatureScale = scale; if (version == DATA_VERSION || version == DATA_VERSION_4_0 || this->_isParentCooriinate) { const auto data = BaseObject::borrowObject<DragonBonesData>(); data->name = _getString(document, NAME, ""); data->frameRate = _getNumber(document, FRAME_RATE, (unsigned)24); if (document.HasMember(ARMATURE)) { this->_data = data; for (const auto& armatureObject : document[ARMATURE].GetArray()) { data->addArmature(_parseArmature(armatureObject)); } this->_data = nullptr; } return data; } else { DRAGONBONES_ASSERT(false, "Nonsupport data version."); } } else { DRAGONBONES_ASSERT(false, "Argument error."); } return nullptr; }
// Initial handshake packet (see http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::Handshake) static void _responseHandshake(mysql_t *mysql) { mysql->state = MySQL_Handshake; // Protocol is 10 for MySQL 5.x if (mysql->response.header != 10) THROW(IOException, "Invalid protocol version %d", mysql->response.header); mysql->response.data.handshake.version = _getString(&mysql->response); mysql->response.data.handshake.connectionid = _getUInt4(&mysql->response); snprintf(mysql->response.data.handshake.authdata, 9, "%s", _getString(&mysql->response)); // auth_plugin_data_part_1 mysql->response.data.handshake.capabilities = _getUInt2(&mysql->response); // capability flags (lower 2 bytes) mysql->response.data.handshake.characterset = _getUInt1(&mysql->response); mysql->response.data.handshake.status = _getUInt2(&mysql->response); mysql->response.data.handshake.capabilities |= _getUInt2(&mysql->response) << 16; // merge capability flags (lower 2 bytes + upper 2 bytes) mysql->response.data.handshake.authdatalen = _getUInt1(&mysql->response); _getPadding(&mysql->response, 10); // reserved bytes if (mysql->response.data.handshake.capabilities & CLIENT_SECURE_CONNECTION) snprintf(mysql->response.data.handshake.authdata + 8, 13, "%s", _getString(&mysql->response)); // auth_plugin_data_part_2 mysql->capabilities = mysql->response.data.handshake.capabilities; // Save capabilities DEBUG("MySQL Server: Protocol: %d, Version: %s, Connection ID: %d\n", mysql->response.header, mysql->response.data.handshake.version, mysql->response.data.handshake.connectionid); }
string RedisClient::randomKey( ) { BuildCommand cmd("RANDOMKEY"); string retKey; if ( _getString(cmd, retKey) ) return retKey; else return REDIS_NIL; }
void CRedisClient::info(CRedisClient::VecString& reply,const string& section) { Command cmd( "INFO" ); string str; if(""!=section) cmd << section; _getString(cmd,str); stringToVecString(str,reply); }
SlotData * JSONDataParser::_parseSlot(const rapidjson::Value & rawData) { const auto slot = BaseObject::borrowObject<SlotData>(); slot->name = _getString(rawData, NAME, ""); slot->parent = this->_armature->getBone(_getString(rawData, PARENT, "")); slot->displayIndex = _getNumber(rawData, DISPLAY_INDEX, (int)0); slot->zOrder = _getNumber(rawData, Z_ORDER, (unsigned)this->_armature->getSortedSlots().size()); if (rawData.HasMember(COLOR)) { slot->color = SlotData::generateColor(); _parseColorTransform(rawData[COLOR], *slot->color); } else { slot->color = &SlotData::DEFAULT_COLOR; } if (rawData.HasMember(BLEND_MODE) && rawData[BLEND_MODE].IsString()) { slot->blendMode = _getBlendMode(rawData[BLEND_MODE].GetString()); } else { slot->blendMode = (BlendMode)_getNumber(rawData, BLEND_MODE, (int)BlendMode::Normal); } if (this->_isParentCooriinate) { if (rawData.HasMember(COLOR_TRANSFORM)) { slot->color = SlotData::generateColor(); _parseColorTransform(rawData[COLOR_TRANSFORM], *slot->color); } else { slot->color = &SlotData::DEFAULT_COLOR; } } return slot; }
DisplayData * JSONDataParser::_parseDisplay(const rapidjson::Value & rawData) { const auto display = BaseObject::borrowObject<DisplayData>(); display->name = _getString(rawData, NAME, ""); if (rawData.HasMember(TYPE) && rawData[TYPE].IsString()) { display->type = _getDisplayType(rawData[TYPE].GetString()); } else { display->type = (DisplayType)_getNumber(rawData, TYPE, (int)DisplayType::Image); } display->isRelativePivot = true; if (rawData.HasMember(PIVOT)) { const auto& pivotObject = rawData[PIVOT]; display->pivot.x = _getNumber(pivotObject, X, 0.f); display->pivot.y = _getNumber(pivotObject, Y, 0.f); } else if (this->_isParentCooriinate) { const auto& transformObject = rawData[TRANSFORM]; display->isRelativePivot = false; display->pivot.x = _getNumber(transformObject, PIVOT_X, 0.f) * this->_armatureScale; display->pivot.y = _getNumber(transformObject, PIVOT_Y, 0.f) * this->_armatureScale; } else { display->pivot.x = 0.5f; display->pivot.y = 0.5f; } if (rawData.HasMember(TRANSFORM)) { _parseTransform(rawData[TRANSFORM], display->transform); } switch (display->type) { case DisplayType::Image: break; case DisplayType::Armature: break; case DisplayType::Mesh: display->meshData = _parseMesh(rawData); break; } return display; }
SlotTimelineData * JSONDataParser::_parseSlotTimeline(const rapidjson::Value& rawData) const { const auto timeline = BaseObject::borrowObject<SlotTimelineData>(); timeline->slot = this->_armature->getSlot(_getString(rawData, NAME, "")); _parseTimeline<SlotFrameData>(rawData, *timeline, std::bind(&JSONDataParser::_parseSlotFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); if (timeline->scale != 1.f || timeline->offset != 0.f) { this->_animation->hasAsynchronyTimeline = true; } return timeline; }
void JSONDataParser::_parseIK(const rapidjson::Value & rawData) { const auto bone = this->_armature->getBone(_getString(rawData, rawData.HasMember(BONE) ? BONE : NAME, "")); if (bone) { bone->ik = this->_armature->getBone(_getString(rawData, TARGET, "")); bone->bendPositive = _getBoolean(rawData, BEND_POSITIVE, true); bone->chain = _getNumber(rawData, CHAIN, (unsigned)0); bone->weight = _getNumber(rawData, WEIGHT, 1.f); if (bone->chain > 0 && bone->parent && !bone->parent->ik) { bone->parent->ik = bone->ik; bone->parent->chainIndex = 0; bone->parent->chain = 0; bone->chainIndex = 1; } else { bone->chain = 0; bone->chainIndex = 0; } } }
FFDTimelineData * JSONDataParser::_parseFFDTimeline(const rapidjson::Value& rawData) const { const auto timeline = BaseObject::borrowObject<FFDTimelineData>(); timeline->skin = this->_armature->getSkin(_getString(rawData, SKIN, "")); timeline->slot = timeline->skin->getSlot(_getString(rawData, SLOT, "")); const auto meshName = _getString(rawData, NAME, ""); for (std::size_t i = 0, l = timeline->slot->displays.size(); i < l; ++i) { const auto displayData = timeline->slot->displays[i]; if (displayData->meshData && displayData->name == meshName) { timeline->displayIndex = i; this->_mesh = displayData->meshData; break; } } _parseTimeline<ExtensionFrameData>(rawData, *timeline, std::bind(&JSONDataParser::_parseFFDFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); this->_mesh = nullptr; return timeline; }
BoneData * JSONDataParser::_parseBone(const rapidjson::Value & rawData) { const auto bone = BaseObject::borrowObject<BoneData>(); bone->name = _getString(rawData, NAME, ""); bone->inheritTranslation = _getBoolean(rawData, INHERIT_TRANSLATION, true); bone->inheritRotation = _getBoolean(rawData, INHERIT_ROTATION, true); bone->inheritScale = _getBoolean(rawData, INHERIT_SCALE, true); bone->length = _getNumber(rawData, LENGTH, 0.f) * _armatureScale; if (rawData.HasMember(TRANSFORM)) { _parseTransform(rawData[TRANSFORM], bone->transform); } if (this->_isParentCooriinate) { bone->inheritRotation = true; bone->inheritScale = false; } return bone; }
string RedisClient::object( const EobjSubCommand& subcommand , const string& key ) { BuildCommand cmd("OBJECT"); SInt64 num = 0; string retStr; std::stringstream ss; switch ( subcommand ) { case REFCOUNT : cmd << "REFCOUNT" << key; if ( _getInt(cmd, num) ) { ss << num; return ss.str(); } break; case IDLETIME : cmd << "IDLETIME" << key; if ( _getInt(cmd, num) ) { ss << num; return ss.str(); } break; case ENCODING : cmd << "ENCODING" << key; if ( _getString(cmd, retStr) ) { return retStr; } break; } return REDIS_NIL; }
SlotDisplayDataSet * JSONDataParser::_parseSlotDisplaySet(const rapidjson::Value & rawData) { const auto slotDisplayDataSet = BaseObject::borrowObject<SlotDisplayDataSet>(); slotDisplayDataSet->slot = this->_armature->getSlot(_getString(rawData, NAME, "")); if (rawData.HasMember(DISPLAY)) { const auto& displayObjectSet = rawData[DISPLAY].GetArray(); auto& displayDataSet = slotDisplayDataSet->displays; displayDataSet.reserve(displayObjectSet.Size()); this->_slotDisplayDataSet = slotDisplayDataSet; for (const auto& displayObject : displayObjectSet) { displayDataSet.push_back(_parseDisplay(displayObject)); } this->_slotDisplayDataSet = nullptr; } return slotDisplayDataSet; }
void PViewDataList::getString3D(int i, int step, std::string &str, double &x, double &y, double &z, double &style) { _getString(3, i, step, str, x, y, z, style); }
void PViewDataList::getString2D(int i, int step, std::string &str, double &x, double &y, double &style) { double z; _getString(2, i, step, str, x, y, z, style); }
bool CRedisClient::srandmember(const string &key, string &member) { Command cmd ( "SRANDMEMBER" ); cmd << key; return ( _getString( cmd, member) ); }
bool CRedisClient::hget( const std::string &key, const std::string &field, string &value ) { Command cmd( "HGET" ); cmd << key << field; return _getString( cmd , value ); }
bool RedisClient::dump( const string& key , string& retStr ) { BuildCommand cmd("DUMP"); cmd << key; return _getString(cmd, retStr); }
AnimationData * JSONDataParser::_parseAnimation(const rapidjson::Value & rawData) const { const auto animation = BaseObject::borrowObject<AnimationData>(); animation->name = _getString(rawData, NAME, "__default"); if (animation->name.empty()) { animation->name = "__default"; } animation->frameCount = std::max(_getNumber(rawData, DURATION, (unsigned)1), (unsigned)1); animation->position = _getNumber(rawData, POSITION, 0.f) / this->_armature->frameRate; animation->duration = (float)animation->frameCount / this->_armature->frameRate; animation->playTimes = _getNumber(rawData, PLAY_TIMES, (unsigned)1); animation->fadeInTime = _getNumber(rawData, FADE_IN_TIME, 0.f); this->_animation = animation; std::string animationName = _getString(rawData, ANIMATION, ""); if (!animationName.empty()) { animation->animation = this->_armature->getAnimation(animationName); if (!animation->animation) { } return animation; } _parseTimeline<AnimationFrameData>(rawData, *animation, std::bind(&JSONDataParser::_parseAnimationFrame, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); if (rawData.HasMember(BONE)) { for (const auto& boneTimelineObject : rawData[BONE].GetArray()) { animation->addBoneTimeline(_parseBoneTimeline(boneTimelineObject)); } } if (rawData.HasMember(SLOT)) { for (const auto& slotTimelineObject : rawData[SLOT].GetArray()) { animation->addSlotTimeline(_parseSlotTimeline(slotTimelineObject)); } } if (rawData.HasMember(FFD)) { for (const auto& ffdTimelineObject : rawData[FFD].GetArray()) { animation->addFFDTimeline(_parseFFDTimeline(ffdTimelineObject)); } } if (this->_isParentCooriinate) { this->_isAutoTween = _getBoolean(rawData, AUTO_TWEEN, true); this->_animationTweenEasing = _getNumber(rawData, TWEEN_EASING, 0.f) || 0.f; animation->playTimes = _getNumber(rawData, LOOP, (unsigned)1); if (rawData.HasMember(TIMELINE)) { const auto timelines = rawData[TIMELINE].GetArray(); for (const auto& timeline : timelines) { animation->addBoneTimeline(_parseBoneTimeline(timeline)); } for (const auto& timeline : timelines) { animation->addSlotTimeline(_parseSlotTimeline(timeline)); } } } else { this->_isAutoTween = false; this->_animationTweenEasing = 0.f; } for (const auto& pair : this->_armature->bones) { if (!animation->getBoneTimeline(pair.second->name)) { const auto boneTimeline = BaseObject::borrowObject<BoneTimelineData>(); const auto boneFrame = BaseObject::borrowObject<BoneFrameData>(); boneTimeline->bone = pair.second; boneTimeline->frames.reserve(1); boneTimeline->frames.push_back(boneFrame); animation->addBoneTimeline(boneTimeline); } } for (const auto& pair : this->_armature->slots) { if (!animation->getSlotTimeline(pair.second->name)) { const auto slotTimeline = BaseObject::borrowObject<SlotTimelineData>(); const auto slotFrame = BaseObject::borrowObject<SlotFrameData>(); slotTimeline->slot = pair.second; slotFrame->displayIndex = pair.second->displayIndex; if (pair.second->color == &SlotData::DEFAULT_COLOR) { slotFrame->color = &SlotFrameData::DEFAULT_COLOR; } else { slotFrame->color = SlotFrameData::generateColor(); *slotFrame->color = *pair.second->color; // copy } slotTimeline->frames.reserve(1); slotTimeline->frames.push_back(slotFrame); animation->addSlotTimeline(slotTimeline); if (this->_isParentCooriinate) { slotFrame->displayIndex = -1; } } } this->_animation = nullptr; return animation; }
ArmatureData * JSONDataParser::_parseArmature(const rapidjson::Value & rawData) { const auto armature = BaseObject::borrowObject<ArmatureData>(); armature->name = _getString(rawData, NAME, ""); armature->frameRate = _getNumber(rawData, FRAME_RATE, this->_data->frameRate); if (rawData.HasMember(TYPE) && rawData[TYPE].IsString()) { armature->type = _getArmatureType(rawData[TYPE].GetString()); } else { armature->type = (ArmatureType)_getNumber(rawData, TYPE, (int)ArmatureType::Armature); } this->_armature = armature; this->_rawBones.clear(); if (rawData.HasMember(BONE)) { for (const auto& boneObject : rawData[BONE].GetArray()) { const auto bone = _parseBone(boneObject); armature->addBone(bone, _getString(boneObject, PARENT, "")); this->_rawBones.push_back(bone); } } if (rawData.HasMember(IK)) { for (const auto& ikObject : rawData[IK].GetArray()) { _parseIK(ikObject); } } if (rawData.HasMember(SLOT)) { for (const auto& slotObject : rawData[SLOT].GetArray()) { armature->addSlot(_parseSlot(slotObject)); } } if (rawData.HasMember(SKIN)) { for (const auto& skinObject : rawData[SKIN].GetArray()) { armature->addSkin(_parseSkin(skinObject)); } } if (rawData.HasMember(ANIMATION)) { for (const auto& animationObject : rawData[ANIMATION].GetArray()) { armature->addAnimation(_parseAnimation(animationObject)); } } this->_armature = nullptr; this->_rawBones.clear(); if (this->_isParentCooriinate && _getBoolean(rawData, IS_GLOBAL, true)) { this->_globalToLocal(armature); } return armature; }