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;
}
