2014-06-05 16:36:01 +08:00
|
|
|
/****************************************************************************
|
|
|
|
Copyright (c) 2014 Chukong Technologies Inc.
|
|
|
|
|
|
|
|
http://www.cocos2d-x.org
|
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
|
|
all copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
|
|
THE SOFTWARE.
|
|
|
|
****************************************************************************/
|
|
|
|
|
2014-06-17 10:49:52 +08:00
|
|
|
#include "3d/CCBundle3D.h"
|
2014-06-05 16:36:01 +08:00
|
|
|
|
|
|
|
#include "base/ccMacros.h"
|
|
|
|
#include "platform/CCFileUtils.h"
|
2014-06-17 15:31:45 +08:00
|
|
|
#include "renderer/CCGLProgram.h"
|
2014-06-19 15:43:02 +08:00
|
|
|
#include "CCBundleReader.h"
|
|
|
|
#include "base/CCData.h"
|
2014-06-25 09:13:24 +08:00
|
|
|
#include "json/document.h"
|
|
|
|
|
2014-06-19 15:43:02 +08:00
|
|
|
#define BUNDLE_TYPE_SCENE 1
|
|
|
|
#define BUNDLE_TYPE_NODE 2
|
|
|
|
#define BUNDLE_TYPE_ANIMATIONS 3
|
|
|
|
#define BUNDLE_TYPE_ANIMATION 4
|
|
|
|
#define BUNDLE_TYPE_ANIMATION_CHANNEL 5
|
|
|
|
#define BUNDLE_TYPE_MODEL 10
|
|
|
|
#define BUNDLE_TYPE_MATERIAL 16
|
|
|
|
#define BUNDLE_TYPE_EFFECT 18
|
|
|
|
#define BUNDLE_TYPE_CAMERA 32
|
|
|
|
#define BUNDLE_TYPE_LIGHT 33
|
|
|
|
#define BUNDLE_TYPE_MESH 34
|
|
|
|
#define BUNDLE_TYPE_MESHPART 35
|
|
|
|
#define BUNDLE_TYPE_MESHSKIN 36
|
2014-06-12 16:28:36 +08:00
|
|
|
|
2014-07-29 10:49:06 +08:00
|
|
|
static const char* VERSION = "version";
|
2014-06-20 22:38:09 +08:00
|
|
|
static const char* ID = "id";
|
|
|
|
|
|
|
|
static const char* MESHDATA_DEFAULTPART = "body";
|
|
|
|
static const char* MESHDATA_VERTEXSIZE = "vertexsize";
|
2014-07-29 10:49:06 +08:00
|
|
|
static const char* MESHDATA_VERTEX = "vertex";
|
2014-06-20 22:38:09 +08:00
|
|
|
static const char* MESHDATA_VERTICES = "vertices";
|
|
|
|
static const char* MESHDATA_INDEXNUM = "indexnum";
|
|
|
|
static const char* MESHDATA_INDICES = "indices";
|
2014-07-29 10:49:06 +08:00
|
|
|
static const char* MESHDATA_SUBMESH = "submesh";
|
2014-06-20 22:38:09 +08:00
|
|
|
static const char* MESHDATA_ATTRIBUTES = "attributes";
|
|
|
|
static const char* MESHDATA_SIZE = "size";
|
|
|
|
static const char* MESHDATA_TYPE = "type";
|
|
|
|
static const char* MESHDATA_ATTRIBUTE = "attribute";
|
|
|
|
|
|
|
|
static const char* SKINDATA_SKIN = "skin";
|
|
|
|
static const char* SKINDATA_BINDSHAPE = "bindshape";
|
2014-08-16 11:12:26 +08:00
|
|
|
|
|
|
|
static const char* MESH = "mesh";
|
|
|
|
static const char* MESHES = "meshes";
|
|
|
|
static const char* MESHPARTID = "meshpartid";
|
|
|
|
static const char* MATERIALID = "materialid";
|
|
|
|
static const char* NODE = "node";
|
|
|
|
static const char* NODES = "nodes";
|
|
|
|
static const char* CHILDREN = "children";
|
|
|
|
static const char* PARTS = "parts";
|
|
|
|
static const char* BONES = "bones";
|
|
|
|
static const char* MATERIALS = "materials";
|
|
|
|
static const char* ANIMATIONS = "animations";
|
|
|
|
static const char* TRANSFORM = "transform";
|
2014-06-20 22:38:09 +08:00
|
|
|
|
|
|
|
static const char* MATERIALDATA_MATERIAL = "material";
|
2014-08-15 15:32:15 +08:00
|
|
|
static const char* MATERIALDATA_MATERIALS = "materials";
|
2014-06-20 22:38:09 +08:00
|
|
|
static const char* MATERIALDATA_BASE = "base";
|
|
|
|
static const char* MATERIALDATA_FILENAME = "filename";
|
2014-07-29 10:49:06 +08:00
|
|
|
static const char* MATERIALDATA_TEXTURES = "textures";
|
2014-06-20 22:38:09 +08:00
|
|
|
|
|
|
|
static const char* ANIMATIONDATA_ANIMATION = "animation";
|
|
|
|
static const char* ANIMATIONDATA_LENGTH = "length";
|
|
|
|
static const char* ANIMATIONDATA_BONEID = "boneId";
|
|
|
|
static const char* ANIMATIONDATA_KEYFRAMES = "keyframes";
|
|
|
|
static const char* ANIMATIONDATA_TRANSLATION = "translation";
|
|
|
|
static const char* ANIMATIONDATA_ROTATION = "rotation";
|
|
|
|
static const char* ANIMATIONDATA_SCALE = "scale";
|
|
|
|
static const char* ANIMATIONDATA_KEYTIME = "keytime";
|
|
|
|
|
2014-06-05 16:36:01 +08:00
|
|
|
NS_CC_BEGIN
|
|
|
|
|
2014-06-13 19:26:46 +08:00
|
|
|
void getChildMap(std::map<int, std::vector<int> >& map, SkinData* skinData, const rapidjson::Value& val)
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-06-12 15:53:41 +08:00
|
|
|
if (!skinData)
|
|
|
|
return;
|
2014-06-24 14:10:03 +08:00
|
|
|
|
|
|
|
// get transform matrix
|
|
|
|
Mat4 transform;
|
2014-08-16 11:12:26 +08:00
|
|
|
const rapidjson::Value& parent_tranform = val[TRANSFORM];
|
2014-06-24 14:10:03 +08:00
|
|
|
for (rapidjson::SizeType j = 0; j < parent_tranform.Size(); j++)
|
|
|
|
{
|
|
|
|
transform.m[j] = parent_tranform[j].GetDouble();
|
|
|
|
}
|
|
|
|
|
|
|
|
// set origin matrices
|
2014-06-20 22:38:09 +08:00
|
|
|
std::string parent_name = val[ID].GetString();
|
2014-06-24 14:10:03 +08:00
|
|
|
int parent_name_index = skinData->getSkinBoneNameIndex(parent_name);
|
|
|
|
if (parent_name_index < 0)
|
|
|
|
{
|
|
|
|
skinData->addNodeBoneNames(parent_name);
|
|
|
|
skinData->nodeBoneOriginMatrices.push_back(transform);
|
2014-06-27 09:32:09 +08:00
|
|
|
parent_name_index = skinData->getBoneNameIndex(parent_name);
|
2014-06-24 14:10:03 +08:00
|
|
|
}
|
2014-06-24 23:33:30 +08:00
|
|
|
else if (parent_name_index < skinData->skinBoneNames.size())
|
2014-06-24 14:10:03 +08:00
|
|
|
{
|
2014-06-24 23:33:30 +08:00
|
|
|
skinData->skinBoneOriginMatrices[parent_name_index] = (transform);
|
2014-06-24 14:10:03 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// set root bone index
|
|
|
|
if(skinData->rootBoneIndex < 0)
|
|
|
|
skinData->rootBoneIndex = parent_name_index;
|
|
|
|
|
2014-08-16 11:12:26 +08:00
|
|
|
if (!val.HasMember(CHILDREN))
|
2014-06-24 23:33:30 +08:00
|
|
|
return;
|
|
|
|
|
2014-08-16 11:12:26 +08:00
|
|
|
const rapidjson::Value& children = val[CHILDREN];
|
2014-06-13 19:26:46 +08:00
|
|
|
for (rapidjson::SizeType i = 0; i < children.Size(); i++)
|
|
|
|
{
|
2014-06-24 14:10:03 +08:00
|
|
|
// get child bone name
|
2014-06-13 19:26:46 +08:00
|
|
|
const rapidjson::Value& child = children[i];
|
2014-06-24 14:10:03 +08:00
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
std::string child_name = child[ID].GetString();
|
2014-06-24 14:10:03 +08:00
|
|
|
int child_name_index = skinData->getSkinBoneNameIndex(child_name);
|
|
|
|
if (child_name_index < 0)
|
2014-06-13 19:26:46 +08:00
|
|
|
{
|
2014-06-24 14:10:03 +08:00
|
|
|
skinData->addNodeBoneNames(child_name);
|
|
|
|
child_name_index = skinData->getBoneNameIndex(child_name);
|
|
|
|
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
2014-06-24 14:10:03 +08:00
|
|
|
|
|
|
|
map[parent_name_index].push_back(child_name_index);
|
|
|
|
|
|
|
|
getChildMap(map, skinData, child);
|
|
|
|
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-05 16:36:01 +08:00
|
|
|
Bundle3D* Bundle3D::_instance = nullptr;
|
2014-06-06 19:12:08 +08:00
|
|
|
|
2014-07-30 18:32:34 +08:00
|
|
|
void Bundle3D::setBundleInstance(Bundle3D* bundleInstance)
|
|
|
|
{
|
|
|
|
CC_SAFE_DELETE(_instance);
|
|
|
|
_instance = bundleInstance;
|
|
|
|
}
|
|
|
|
|
2014-06-05 16:36:01 +08:00
|
|
|
Bundle3D* Bundle3D::getInstance()
|
|
|
|
{
|
|
|
|
if (_instance == nullptr)
|
|
|
|
_instance = new Bundle3D();
|
|
|
|
return _instance;
|
|
|
|
}
|
|
|
|
|
2014-06-17 19:18:56 +08:00
|
|
|
void Bundle3D::destroyInstance()
|
2014-06-05 16:36:01 +08:00
|
|
|
{
|
|
|
|
CC_SAFE_DELETE(_instance);
|
|
|
|
}
|
|
|
|
|
2014-06-25 09:13:24 +08:00
|
|
|
void Bundle3D::clear()
|
2014-06-05 16:36:01 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_isBinary)
|
|
|
|
{
|
|
|
|
CC_SAFE_DELETE(_binaryBuffer);
|
|
|
|
CC_SAFE_DELETE_ARRAY(_references);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CC_SAFE_DELETE_ARRAY(_jsonBuffer);
|
|
|
|
}
|
2014-06-20 15:30:08 +08:00
|
|
|
}
|
2014-06-19 15:43:02 +08:00
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
bool Bundle3D::load(const std::string& path)
|
|
|
|
{
|
2014-06-17 13:59:03 +08:00
|
|
|
if (_path == path)
|
|
|
|
return true;
|
2014-06-12 10:01:54 +08:00
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
getModelRelativePath(path);
|
|
|
|
|
|
|
|
bool ret = false;
|
|
|
|
std::string ext = path.substr(path.length() - 4, 4);
|
|
|
|
std::transform(ext.begin(), ext.end(), ext.begin(), tolower);
|
|
|
|
if (ext == ".c3t")
|
|
|
|
{
|
|
|
|
_isBinary = false;
|
|
|
|
ret = loadJson(path);
|
|
|
|
}
|
|
|
|
else if (ext == ".c3b")
|
|
|
|
{
|
|
|
|
_isBinary = true;
|
|
|
|
ret = loadBinary(path);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CCLOGINFO("%s is invalid file formate", path);
|
|
|
|
}
|
|
|
|
|
|
|
|
ret?(_path = path):(_path = "");
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Bundle3D::loadMeshData(const std::string& id, MeshData* meshdata)
|
|
|
|
{
|
2014-07-29 10:49:06 +08:00
|
|
|
meshdata->resetData();
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
if (_isBinary)
|
|
|
|
{
|
|
|
|
return loadMeshDataBinary(meshdata);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return loadMeshDataJson(meshdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Bundle3D::loadSkinData(const std::string& id, SkinData* skindata)
|
|
|
|
{
|
2014-07-29 10:49:06 +08:00
|
|
|
skindata->resetData();
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
if (_isBinary)
|
|
|
|
{
|
|
|
|
return loadSkinDataBinary(skindata);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return loadSkinDataJson(skindata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Bundle3D::loadMaterialData(const std::string& id, MaterialData* materialdata)
|
|
|
|
{
|
2014-07-29 10:49:06 +08:00
|
|
|
materialdata->resetData();
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
if (_isBinary)
|
|
|
|
{
|
|
|
|
return loadMaterialDataBinary(materialdata);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return loadMaterialDataJson(materialdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Bundle3D::loadAnimationData(const std::string& id, Animation3DData* animationdata)
|
|
|
|
{
|
2014-07-29 10:49:06 +08:00
|
|
|
animationdata->resetData();
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
if (_isBinary)
|
|
|
|
{
|
|
|
|
return loadAnimationDataBinary(animationdata);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return loadAnimationDataJson(animationdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-30 18:32:34 +08:00
|
|
|
bool Bundle3D::loadSkeletonData(const std::string& id, Skeleton3DData* skeletondata)
|
|
|
|
{
|
|
|
|
skeletondata->resetData();
|
|
|
|
|
|
|
|
//TODO
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-08-15 13:03:53 +08:00
|
|
|
//since 3.3, to support reskin
|
|
|
|
bool Bundle3D::loadMeshDatas(MeshDatas& meshdatas)
|
|
|
|
{
|
2014-08-15 18:27:28 +08:00
|
|
|
meshdatas.resetData();
|
2014-08-15 15:32:15 +08:00
|
|
|
if (_isBinary)
|
|
|
|
{
|
|
|
|
return loadMeshDatasBinary(meshdatas);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-08-16 14:14:37 +08:00
|
|
|
if (_version == "1.2")
|
|
|
|
{
|
|
|
|
return loadMeshDataJson_0_1(meshdatas);
|
|
|
|
}
|
|
|
|
else if(_version == "0.2")
|
|
|
|
{
|
|
|
|
return loadMeshDataJson_0_2(meshdatas);
|
|
|
|
}
|
|
|
|
else if(_version == "0.3")
|
|
|
|
{
|
|
|
|
return loadMeshDatasJson(meshdatas);
|
|
|
|
}
|
2014-08-15 15:32:15 +08:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool Bundle3D::loadMeshDatasBinary(MeshDatas& meshdatas)
|
|
|
|
{
|
2014-08-15 13:03:53 +08:00
|
|
|
return true;
|
|
|
|
}
|
2014-08-15 15:32:15 +08:00
|
|
|
bool Bundle3D::loadMeshDatasJson(MeshDatas& meshdatas)
|
|
|
|
{
|
2014-08-16 11:12:26 +08:00
|
|
|
const rapidjson::Value& mesh_data_array = _jsonReader[MESHES];
|
2014-08-15 15:32:15 +08:00
|
|
|
for (rapidjson::SizeType index = 0; index < mesh_data_array.Size(); index++)
|
|
|
|
{
|
|
|
|
MeshData* meshData = new MeshData();
|
|
|
|
const rapidjson::Value& mesh_data = mesh_data_array[index];
|
|
|
|
// mesh_vertex_attribute
|
|
|
|
const rapidjson::Value& mesh_vertex_attribute = mesh_data[MESHDATA_ATTRIBUTES];
|
|
|
|
MeshVertexAttrib tempAttrib;
|
|
|
|
meshData->attribCount=mesh_vertex_attribute.Size();
|
|
|
|
meshData->attribs.resize(meshData->attribCount);
|
|
|
|
for (int i = 0; i < mesh_vertex_attribute.Size(); i++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& mesh_vertex_attribute_val = mesh_vertex_attribute[i];
|
2014-08-15 13:03:53 +08:00
|
|
|
|
2014-08-15 15:32:15 +08:00
|
|
|
int size = mesh_vertex_attribute_val[MESHDATA_SIZE].GetInt();
|
|
|
|
std::string type = mesh_vertex_attribute_val[MESHDATA_TYPE].GetString();
|
|
|
|
std::string attribute = mesh_vertex_attribute_val[MESHDATA_ATTRIBUTE].GetString();
|
|
|
|
|
|
|
|
tempAttrib.size = size;
|
|
|
|
tempAttrib.attribSizeBytes = sizeof(float) * size;
|
|
|
|
tempAttrib.type = parseGLType(type);
|
|
|
|
tempAttrib.vertexAttrib = parseGLProgramAttribute(attribute);
|
|
|
|
meshData->attribs[i]=tempAttrib;
|
|
|
|
}
|
|
|
|
// mesh vertices
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
const rapidjson::Value& mesh_data_vertex_array = mesh_data[MESHDATA_VERTICES];
|
|
|
|
meshData->vertexSizeInFloat=mesh_data_vertex_array.Size();
|
|
|
|
for (rapidjson::SizeType i = 0; i < mesh_data_vertex_array.Size(); i++)
|
|
|
|
{
|
|
|
|
meshData->vertex.push_back(mesh_data_vertex_array[i].GetDouble());
|
|
|
|
}
|
|
|
|
// mesh part
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////
|
2014-08-16 11:12:26 +08:00
|
|
|
const rapidjson::Value& mesh_part_array = mesh_data[PARTS];
|
2014-08-15 15:32:15 +08:00
|
|
|
for (rapidjson::SizeType i = 0; i < mesh_part_array.Size(); i++)
|
|
|
|
{
|
|
|
|
std::vector<unsigned short> indexArray;
|
|
|
|
const rapidjson::Value& mesh_part = mesh_part_array[i];
|
|
|
|
meshData->subMeshIds.push_back(mesh_part[ID].GetString());
|
|
|
|
// index_number
|
|
|
|
const rapidjson::Value& indices_val_array = mesh_part[MESHDATA_INDICES];
|
|
|
|
for (rapidjson::SizeType j = 0; j < indices_val_array.Size(); j++)
|
|
|
|
indexArray.push_back((unsigned short)indices_val_array[j].GetUint());
|
|
|
|
|
|
|
|
meshData->subMeshIndices.push_back(indexArray);
|
|
|
|
meshData->numIndex=meshData->subMeshIndices.size();
|
|
|
|
}
|
|
|
|
meshdatas.meshDatas.push_back(meshData);
|
|
|
|
}
|
2014-08-16 11:12:26 +08:00
|
|
|
return true;
|
2014-08-15 15:32:15 +08:00
|
|
|
}
|
2014-08-15 13:03:53 +08:00
|
|
|
bool Bundle3D::loadNodes(NodeDatas& nodedatas)
|
|
|
|
{
|
2014-08-16 11:12:26 +08:00
|
|
|
if (_isBinary)
|
|
|
|
{
|
|
|
|
// TODO
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-08-16 14:44:41 +08:00
|
|
|
if (_version == "1.2" || _version == "0.2")
|
|
|
|
{
|
|
|
|
SkinData skinData;
|
|
|
|
loadSkinDataJson(&skinData);
|
|
|
|
auto nodeDatas = new NodeData*[skinData.skinBoneNames.size() + skinData.nodeBoneNames.size()];
|
|
|
|
int index = 0;
|
|
|
|
size_t i;
|
|
|
|
for (i = 0; i < skinData.skinBoneNames.size(); i++)
|
|
|
|
{
|
|
|
|
nodeDatas[index] = new NodeData();
|
|
|
|
nodeDatas[index]->id = skinData.skinBoneNames[i];
|
|
|
|
nodeDatas[index]->transform = skinData.skinBoneOriginMatrices[i];
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
for (i = 0; i < skinData.nodeBoneNames.size(); i++)
|
|
|
|
{
|
|
|
|
nodeDatas[index] = new NodeData();
|
|
|
|
nodeDatas[index]->id = skinData.nodeBoneNames[i];
|
|
|
|
nodeDatas[index]->transform = skinData.nodeBoneOriginMatrices[i];
|
|
|
|
index++;
|
|
|
|
}
|
|
|
|
for (const auto& it : skinData.boneChild)
|
|
|
|
{
|
|
|
|
const auto& children = it.second;
|
|
|
|
auto parent = nodeDatas[it.first];
|
|
|
|
for (const auto& child : children)
|
|
|
|
{
|
|
|
|
parent->children.push_back(nodeDatas[child]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
nodedatas.skeleton.push_back(nodeDatas[skinData.rootBoneIndex]);
|
2014-08-16 14:52:44 +08:00
|
|
|
auto modelnode = new ModelNodeData();
|
|
|
|
modelnode->matrialId = "";
|
|
|
|
modelnode->subMeshId = "";
|
|
|
|
modelnode->id = "";
|
|
|
|
modelnode->bones = skinData.skinBoneNames;
|
|
|
|
modelnode->invBindPose = skinData.inverseBindPoseMatrices;
|
|
|
|
nodedatas.nodes.push_back(modelnode);
|
2014-08-16 14:44:41 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return loadNodesJson(nodedatas);
|
|
|
|
}
|
|
|
|
|
2014-08-16 11:12:26 +08:00
|
|
|
}
|
2014-08-15 13:03:53 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool Bundle3D::loadMaterials(MaterialDatas& materialdatas)
|
|
|
|
{
|
2014-08-15 17:45:37 +08:00
|
|
|
materialdatas.resetData();
|
2014-08-15 15:32:15 +08:00
|
|
|
if (_isBinary)
|
|
|
|
{
|
|
|
|
return loadMaterialsBinary(materialdatas);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-08-16 14:14:37 +08:00
|
|
|
if (_version == "1.2")
|
|
|
|
{
|
|
|
|
return loadMaterialDataJson_0_1(materialdatas);
|
|
|
|
}
|
|
|
|
else if (_version == "0.2")
|
|
|
|
{
|
|
|
|
return loadMaterialDataJson_0_2(materialdatas);
|
|
|
|
}
|
|
|
|
else if (_version == "0.3")
|
|
|
|
{
|
|
|
|
return loadMaterialsJson(materialdatas);
|
|
|
|
}
|
2014-08-15 15:32:15 +08:00
|
|
|
}
|
2014-08-15 13:03:53 +08:00
|
|
|
return true;
|
|
|
|
}
|
2014-08-16 11:12:26 +08:00
|
|
|
bool Bundle3D::loadMaterialsBinary(MaterialDatas& materialdatas)
|
2014-08-15 15:32:15 +08:00
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool Bundle3D::loadMaterialsJson(MaterialDatas& materialdatas)
|
|
|
|
{
|
|
|
|
if (!_jsonReader.HasMember(MATERIALDATA_MATERIALS))
|
|
|
|
return false;
|
|
|
|
const rapidjson::Value& material_array = _jsonReader[MATERIALDATA_MATERIALS];
|
|
|
|
for (rapidjson::SizeType i = 0; i < material_array.Size(); i++)
|
|
|
|
{
|
2014-08-16 10:41:42 +08:00
|
|
|
NMaterialData materialData;
|
|
|
|
const rapidjson::Value& material_val = material_array[i];
|
|
|
|
materialData.id = material_val[ID].GetString();
|
|
|
|
if (material_val.HasMember(MATERIALDATA_TEXTURES))
|
|
|
|
{
|
|
|
|
const rapidjson::Value& testure_array = material_val[MATERIALDATA_TEXTURES];
|
|
|
|
for (rapidjson::SizeType j = 0; j < testure_array.Size(); j++)
|
|
|
|
{
|
|
|
|
NTextureData textureData;
|
|
|
|
const rapidjson::Value& texture_val = testure_array[j];
|
|
|
|
std::string filename = texture_val[MATERIALDATA_FILENAME].GetString();
|
2014-08-16 14:44:41 +08:00
|
|
|
textureData.filename = _modelPath + filename;
|
2014-08-16 10:41:42 +08:00
|
|
|
textureData.type = parseGLTextureType(texture_val["type"].GetString());
|
|
|
|
textureData.wrapS = parseGLType(texture_val["wrapModeU"].GetString());
|
|
|
|
textureData.wrapT = parseGLType(texture_val["wrapModeV"].GetString());
|
|
|
|
materialData.textures.push_back(textureData);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
materialdatas.materials.push_back(materialData);
|
2014-08-15 15:32:15 +08:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2014-06-20 15:30:08 +08:00
|
|
|
bool Bundle3D::loadJson(const std::string& path)
|
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
clear();
|
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
Data data = FileUtils::getInstance()->getDataFromFile(path);
|
|
|
|
ssize_t size = data.getSize();
|
2014-06-25 09:13:24 +08:00
|
|
|
|
|
|
|
// json need null-terminated string.
|
2014-06-20 15:30:08 +08:00
|
|
|
_jsonBuffer = new char[size + 1];
|
2014-06-20 22:38:09 +08:00
|
|
|
memcpy(_jsonBuffer, data.getBytes(), size);
|
2014-06-20 15:30:08 +08:00
|
|
|
_jsonBuffer[size] = '\0';
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_jsonReader.ParseInsitu<0>(_jsonBuffer).HasParseError())
|
2014-06-13 19:26:46 +08:00
|
|
|
{
|
2014-06-17 13:59:03 +08:00
|
|
|
assert(0);
|
2014-06-25 09:13:24 +08:00
|
|
|
clear();
|
2014-06-17 13:59:03 +08:00
|
|
|
return false;
|
2014-06-13 19:26:46 +08:00
|
|
|
}
|
2014-07-29 10:49:06 +08:00
|
|
|
|
|
|
|
const rapidjson::Value& mash_data_array = _jsonReader[VERSION];
|
|
|
|
_version = mash_data_array.GetString();
|
2014-06-05 16:36:01 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-08-16 14:14:37 +08:00
|
|
|
bool Bundle3D::loadMeshDataJson_0_1(MeshDatas& meshdatas)
|
2014-07-29 10:49:06 +08:00
|
|
|
{
|
2014-08-16 11:12:26 +08:00
|
|
|
const rapidjson::Value& mesh_data_array = _jsonReader[MESH];
|
2014-08-16 14:14:37 +08:00
|
|
|
MeshData* meshdata= new MeshData();
|
2014-07-29 10:49:06 +08:00
|
|
|
const rapidjson::Value& mesh_data_val = mesh_data_array[(rapidjson::SizeType)0];
|
2014-06-16 14:09:41 +08:00
|
|
|
|
2014-07-29 10:49:06 +08:00
|
|
|
const rapidjson::Value& mesh_data_body_array = mesh_data_val[MESHDATA_DEFAULTPART];
|
2014-06-12 10:01:54 +08:00
|
|
|
|
2014-06-16 19:08:43 +08:00
|
|
|
const rapidjson::Value& mesh_data_body_array_0 = mesh_data_body_array[(rapidjson::SizeType)0];
|
2014-06-12 10:01:54 +08:00
|
|
|
|
2014-07-29 10:49:06 +08:00
|
|
|
// mesh_vertex_attribute
|
|
|
|
const rapidjson::Value& mesh_vertex_attribute = mesh_data_val[MESHDATA_ATTRIBUTES];
|
|
|
|
meshdata->attribCount = mesh_vertex_attribute.Size();
|
|
|
|
meshdata->attribs.resize(meshdata->attribCount);
|
|
|
|
for (rapidjson::SizeType i = 0; i < mesh_vertex_attribute.Size(); i++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& mesh_vertex_attribute_val = mesh_vertex_attribute[i];
|
|
|
|
|
|
|
|
meshdata->attribs[i].size = mesh_vertex_attribute_val[MESHDATA_SIZE].GetUint();
|
|
|
|
meshdata->attribs[i].attribSizeBytes = meshdata->attribs[i].size * 4;
|
|
|
|
meshdata->attribs[i].type = parseGLType(mesh_vertex_attribute_val[MESHDATA_TYPE].GetString());
|
|
|
|
meshdata->attribs[i].vertexAttrib = parseGLProgramAttribute(mesh_vertex_attribute_val[MESHDATA_ATTRIBUTE].GetString());
|
|
|
|
}
|
|
|
|
|
2014-06-12 10:01:54 +08:00
|
|
|
// vertices
|
2014-07-29 10:49:06 +08:00
|
|
|
meshdata->vertexSizeInFloat = mesh_data_body_array_0[MESHDATA_VERTEXSIZE].GetInt();
|
2014-06-16 00:01:38 +08:00
|
|
|
meshdata->vertex.resize(meshdata->vertexSizeInFloat);
|
2014-07-29 10:49:06 +08:00
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
const rapidjson::Value& mesh_data_body_vertices = mesh_data_body_array_0[MESHDATA_VERTICES];
|
2014-06-16 19:08:43 +08:00
|
|
|
for (rapidjson::SizeType i = 0; i < mesh_data_body_vertices.Size(); i++)
|
|
|
|
meshdata->vertex[i] = mesh_data_body_vertices[i].GetDouble();
|
2014-07-29 10:49:06 +08:00
|
|
|
|
2014-06-12 10:01:54 +08:00
|
|
|
// index_number
|
2014-07-29 10:49:06 +08:00
|
|
|
unsigned int indexnum = mesh_data_body_array_0[MESHDATA_INDEXNUM].GetUint();
|
|
|
|
|
2014-06-12 10:01:54 +08:00
|
|
|
// indices
|
2014-07-29 10:49:06 +08:00
|
|
|
std::vector<unsigned short> indices;
|
|
|
|
indices.resize(indexnum);
|
|
|
|
|
|
|
|
const rapidjson::Value& indices_val_array = mesh_data_body_array_0[MESHDATA_INDICES];
|
|
|
|
for (rapidjson::SizeType i = 0; i < indices_val_array.Size(); i++)
|
|
|
|
indices[i] = (unsigned short)indices_val_array[i].GetUint();
|
|
|
|
|
|
|
|
meshdata->subMeshIndices.push_back(indices);
|
2014-08-16 14:14:37 +08:00
|
|
|
meshdatas.meshDatas.push_back(meshdata);
|
2014-07-29 10:49:06 +08:00
|
|
|
return true;
|
|
|
|
}
|
2014-06-12 10:01:54 +08:00
|
|
|
|
2014-08-16 14:14:37 +08:00
|
|
|
bool Bundle3D::loadMeshDataJson_0_2(MeshDatas& meshdatas)
|
2014-07-29 10:49:06 +08:00
|
|
|
{
|
2014-08-16 14:44:41 +08:00
|
|
|
MeshData* meshdata= new MeshData();
|
2014-08-16 11:12:26 +08:00
|
|
|
const rapidjson::Value& mesh_array = _jsonReader[MESH];
|
2014-07-29 10:49:06 +08:00
|
|
|
const rapidjson::Value& mesh_array_0 = mesh_array[(rapidjson::SizeType)0];
|
|
|
|
|
2014-06-12 10:01:54 +08:00
|
|
|
// mesh_vertex_attribute
|
2014-07-29 10:49:06 +08:00
|
|
|
const rapidjson::Value& mesh_vertex_attribute = mesh_array_0[MESHDATA_ATTRIBUTES];
|
2014-06-12 10:01:54 +08:00
|
|
|
meshdata->attribCount = mesh_vertex_attribute.Size();
|
2014-06-16 00:01:38 +08:00
|
|
|
meshdata->attribs.resize(meshdata->attribCount);
|
2014-06-12 10:01:54 +08:00
|
|
|
for (rapidjson::SizeType i = 0; i < mesh_vertex_attribute.Size(); i++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& mesh_vertex_attribute_val = mesh_vertex_attribute[i];
|
2014-07-29 10:49:06 +08:00
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
meshdata->attribs[i].size = mesh_vertex_attribute_val[MESHDATA_SIZE].GetUint();
|
2014-06-20 15:30:08 +08:00
|
|
|
meshdata->attribs[i].attribSizeBytes = meshdata->attribs[i].size * 4;
|
2014-06-20 22:38:09 +08:00
|
|
|
meshdata->attribs[i].type = parseGLType(mesh_vertex_attribute_val[MESHDATA_TYPE].GetString());
|
|
|
|
meshdata->attribs[i].vertexAttrib = parseGLProgramAttribute(mesh_vertex_attribute_val[MESHDATA_ATTRIBUTE].GetString());
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
2014-06-19 15:43:02 +08:00
|
|
|
|
2014-07-29 10:49:06 +08:00
|
|
|
// vertices
|
|
|
|
const rapidjson::Value& mesh_data_vertex = mesh_array_0[MESHDATA_VERTEX];
|
|
|
|
const rapidjson::Value& mesh_data_vertex_0 = mesh_data_vertex[(rapidjson::SizeType)0];
|
|
|
|
|
|
|
|
meshdata->vertexSizeInFloat = mesh_data_vertex_0[MESHDATA_VERTEXSIZE].GetInt();
|
|
|
|
meshdata->vertex.resize(meshdata->vertexSizeInFloat);
|
|
|
|
|
|
|
|
const rapidjson::Value& mesh_data_body_vertices = mesh_data_vertex_0[MESHDATA_VERTICES];
|
|
|
|
for (rapidjson::SizeType i = 0; i < mesh_data_body_vertices.Size(); i++)
|
|
|
|
meshdata->vertex[i] = mesh_data_body_vertices[i].GetDouble();
|
|
|
|
|
|
|
|
// submesh
|
|
|
|
const rapidjson::Value& mesh_submesh_array = mesh_array_0[MESHDATA_SUBMESH];
|
|
|
|
for (rapidjson::SizeType i = 0; i < mesh_submesh_array.Size(); i++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& mesh_submesh_val = mesh_submesh_array[i];
|
|
|
|
//std::string id = mesh_submesh_val[ID].GetString();
|
|
|
|
|
|
|
|
// index_number
|
|
|
|
unsigned int indexnum = mesh_submesh_val[MESHDATA_INDEXNUM].GetUint();
|
|
|
|
|
|
|
|
// indices
|
|
|
|
std::vector<unsigned short> indices;
|
|
|
|
indices.resize(indexnum);
|
|
|
|
|
|
|
|
const rapidjson::Value& indices_val_array = mesh_submesh_val[MESHDATA_INDICES];
|
|
|
|
for (rapidjson::SizeType j = 0; j < indices_val_array.Size(); j++)
|
|
|
|
indices[j] = (unsigned short)indices_val_array[j].GetUint();
|
|
|
|
|
|
|
|
meshdata->subMeshIndices.push_back(indices);
|
|
|
|
}
|
2014-08-16 14:14:37 +08:00
|
|
|
meshdatas.meshDatas.push_back(meshdata);
|
2014-06-05 18:21:25 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
bool Bundle3D::loadSkinDataJson(SkinData* skindata)
|
2014-06-05 18:21:25 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_jsonReader.HasMember(SKINDATA_SKIN )) return false;
|
2014-06-24 14:10:03 +08:00
|
|
|
|
2014-06-25 09:13:24 +08:00
|
|
|
const rapidjson::Value& skin_data_array = _jsonReader[SKINDATA_SKIN ];
|
2014-06-24 14:10:03 +08:00
|
|
|
|
2014-06-12 10:01:54 +08:00
|
|
|
assert(skin_data_array.IsArray());
|
|
|
|
const rapidjson::Value& skin_data_array_val_0 = skin_data_array[(rapidjson::SizeType)0];
|
2014-06-24 14:10:03 +08:00
|
|
|
|
2014-08-16 11:12:26 +08:00
|
|
|
if (!skin_data_array_val_0.HasMember(BONES))
|
2014-06-16 19:08:43 +08:00
|
|
|
return false;
|
2014-06-24 14:10:03 +08:00
|
|
|
|
2014-08-16 11:12:26 +08:00
|
|
|
const rapidjson::Value& skin_data_bones = skin_data_array_val_0[BONES];
|
2014-06-12 10:01:54 +08:00
|
|
|
for (rapidjson::SizeType i = 0; i < skin_data_bones.Size(); i++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& skin_data_bone = skin_data_bones[i];
|
2014-08-16 11:12:26 +08:00
|
|
|
std::string name = skin_data_bone[NODE].GetString();
|
2014-06-24 14:10:03 +08:00
|
|
|
skindata->addSkinBoneNames(name);
|
2014-06-16 19:08:43 +08:00
|
|
|
|
2014-06-12 10:01:54 +08:00
|
|
|
Mat4 mat_bind_pos;
|
2014-06-20 22:38:09 +08:00
|
|
|
const rapidjson::Value& bind_pos = skin_data_bone[SKINDATA_BINDSHAPE];
|
2014-06-12 10:01:54 +08:00
|
|
|
for (rapidjson::SizeType j = 0; j < bind_pos.Size(); j++)
|
|
|
|
{
|
|
|
|
mat_bind_pos.m[j] = bind_pos[j].GetDouble();
|
|
|
|
}
|
2014-06-16 15:38:03 +08:00
|
|
|
skindata->inverseBindPoseMatrices.push_back(mat_bind_pos);
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
2014-06-24 14:10:03 +08:00
|
|
|
|
|
|
|
// set root bone infomation
|
2014-06-16 19:08:43 +08:00
|
|
|
const rapidjson::Value& skin_data_1 = skin_data_array[1];
|
2014-06-24 14:10:03 +08:00
|
|
|
|
|
|
|
// parent and child relationship map
|
2014-06-24 23:33:30 +08:00
|
|
|
skindata->skinBoneOriginMatrices.resize(skindata->skinBoneNames.size());
|
2014-06-24 14:10:03 +08:00
|
|
|
getChildMap(skindata->boneChild, skindata, skin_data_1);
|
2014-06-05 18:21:25 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-08-16 14:14:37 +08:00
|
|
|
bool Bundle3D::loadMaterialDataJson_0_1(MaterialDatas& materialdatas)
|
2014-06-05 18:21:25 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_jsonReader.HasMember(MATERIALDATA_MATERIAL))
|
2014-06-13 19:26:46 +08:00
|
|
|
return false;
|
2014-08-16 14:14:37 +08:00
|
|
|
NMaterialData materialData;
|
2014-06-25 09:13:24 +08:00
|
|
|
const rapidjson::Value& material_data_array = _jsonReader[MATERIALDATA_MATERIAL];
|
2014-06-12 10:01:54 +08:00
|
|
|
|
2014-06-16 19:08:43 +08:00
|
|
|
const rapidjson::Value& material_data_array_0 = material_data_array[(rapidjson::SizeType)0];
|
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
const rapidjson::Value& material_data_base_array = material_data_array_0[MATERIALDATA_BASE];
|
2014-06-16 19:08:43 +08:00
|
|
|
|
|
|
|
const rapidjson::Value& material_data_base_array_0 = material_data_base_array[(rapidjson::SizeType)0];
|
2014-08-16 14:14:37 +08:00
|
|
|
NTextureData textureData;
|
2014-07-29 10:49:06 +08:00
|
|
|
// set texture
|
2014-08-16 14:44:41 +08:00
|
|
|
textureData.filename =_modelPath + material_data_base_array_0[MATERIALDATA_FILENAME].GetString();
|
2014-08-16 14:14:37 +08:00
|
|
|
textureData.type= NTextureData::Usage::Diffuse;
|
|
|
|
textureData.id="";
|
|
|
|
materialData.textures.push_back(textureData);
|
|
|
|
materialdatas.materials.push_back(materialData);
|
2014-07-29 10:49:06 +08:00
|
|
|
return true;
|
|
|
|
}
|
2014-06-13 19:26:46 +08:00
|
|
|
|
2014-08-16 14:14:37 +08:00
|
|
|
bool Bundle3D::loadMaterialDataJson_0_2(MaterialDatas& materialdatas)
|
2014-07-29 10:49:06 +08:00
|
|
|
{
|
|
|
|
if (!_jsonReader.HasMember(MATERIALDATA_MATERIAL))
|
|
|
|
return false;
|
2014-08-16 14:14:37 +08:00
|
|
|
NMaterialData materialData;
|
2014-07-29 10:49:06 +08:00
|
|
|
const rapidjson::Value& material_array = _jsonReader[MATERIALDATA_MATERIAL];
|
|
|
|
|
|
|
|
for (rapidjson::SizeType i = 0; i < material_array.Size(); i++)
|
|
|
|
{
|
2014-08-16 14:14:37 +08:00
|
|
|
NTextureData textureData;
|
2014-07-29 10:49:06 +08:00
|
|
|
const rapidjson::Value& material_val = material_array[i];
|
2014-08-16 14:44:41 +08:00
|
|
|
|
2014-07-29 10:49:06 +08:00
|
|
|
// set texture
|
2014-08-16 14:44:41 +08:00
|
|
|
textureData.filename = _modelPath + material_val[MATERIALDATA_TEXTURES].GetString();
|
2014-08-16 14:14:37 +08:00
|
|
|
textureData.type= NTextureData::Usage::Diffuse;
|
|
|
|
textureData.id="";
|
|
|
|
materialData.textures.push_back(textureData);
|
2014-07-29 10:49:06 +08:00
|
|
|
}
|
2014-08-16 14:14:37 +08:00
|
|
|
materialdatas.materials.push_back(materialData);
|
2014-06-05 18:21:25 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
bool Bundle3D::loadAnimationDataJson(Animation3DData* animationdata)
|
2014-06-05 18:21:25 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_jsonReader.HasMember(ANIMATIONDATA_ANIMATION)) return false;
|
2014-06-16 19:08:43 +08:00
|
|
|
|
2014-06-25 09:13:24 +08:00
|
|
|
const rapidjson::Value& animation_data_array = _jsonReader[ANIMATIONDATA_ANIMATION];
|
2014-06-16 19:08:43 +08:00
|
|
|
if (animation_data_array.Size()==0) return false;
|
2014-06-12 16:28:36 +08:00
|
|
|
|
2014-06-16 19:08:43 +08:00
|
|
|
const rapidjson::Value& animation_data_array_val_0 = animation_data_array[(rapidjson::SizeType)0];
|
2014-06-12 10:01:54 +08:00
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
animationdata->_totalTime = animation_data_array_val_0[ANIMATIONDATA_LENGTH].GetDouble();
|
2014-06-16 15:38:03 +08:00
|
|
|
|
2014-08-16 11:12:26 +08:00
|
|
|
const rapidjson::Value& bones = animation_data_array_val_0[BONES];
|
2014-06-16 19:08:43 +08:00
|
|
|
for (rapidjson::SizeType i = 0; i < bones.Size(); i++)
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
|
|
|
const rapidjson::Value& bone = bones[i];
|
2014-06-20 22:38:09 +08:00
|
|
|
std::string bone_name = bone[ANIMATIONDATA_BONEID].GetString();
|
2014-06-12 10:01:54 +08:00
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
if ( bone.HasMember(ANIMATIONDATA_KEYFRAMES))
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-06-20 22:38:09 +08:00
|
|
|
const rapidjson::Value& bone_keyframes = bone[ANIMATIONDATA_KEYFRAMES];
|
2014-06-13 19:26:46 +08:00
|
|
|
rapidjson::SizeType keyframe_size = bone_keyframes.Size();
|
2014-06-24 14:10:03 +08:00
|
|
|
for (rapidjson::SizeType j = 0; j < keyframe_size; j++)
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
|
|
|
const rapidjson::Value& bone_keyframe = bone_keyframes[j];
|
2014-06-12 16:28:36 +08:00
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
if ( bone_keyframe.HasMember(ANIMATIONDATA_TRANSLATION))
|
2014-06-13 19:26:46 +08:00
|
|
|
{
|
2014-06-20 22:38:09 +08:00
|
|
|
const rapidjson::Value& bone_keyframe_translation = bone_keyframe[ANIMATIONDATA_TRANSLATION];
|
|
|
|
float keytime = bone_keyframe[ANIMATIONDATA_KEYTIME].GetDouble();
|
2014-06-13 19:26:46 +08:00
|
|
|
Vec3 val = Vec3(bone_keyframe_translation[(rapidjson::SizeType)0].GetDouble(), bone_keyframe_translation[1].GetDouble(), bone_keyframe_translation[2].GetDouble());
|
|
|
|
animationdata->_translationKeys[bone_name].push_back(Animation3DData::Vec3Key(keytime,val));
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
if ( bone_keyframe.HasMember(ANIMATIONDATA_ROTATION))
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-06-20 22:38:09 +08:00
|
|
|
const rapidjson::Value& bone_keyframe_rotation = bone_keyframe[ANIMATIONDATA_ROTATION];
|
|
|
|
float keytime = bone_keyframe[ANIMATIONDATA_KEYTIME].GetDouble();
|
2014-06-13 19:26:46 +08:00
|
|
|
Quaternion val = Quaternion(bone_keyframe_rotation[(rapidjson::SizeType)0].GetDouble(),bone_keyframe_rotation[1].GetDouble(),bone_keyframe_rotation[2].GetDouble(),bone_keyframe_rotation[3].GetDouble());
|
|
|
|
animationdata->_rotationKeys[bone_name].push_back(Animation3DData::QuatKey(keytime,val));
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
|
|
|
|
2014-06-20 22:38:09 +08:00
|
|
|
if ( bone_keyframe.HasMember(ANIMATIONDATA_SCALE))
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-06-20 22:38:09 +08:00
|
|
|
const rapidjson::Value& bone_keyframe_scale = bone_keyframe[ANIMATIONDATA_SCALE];
|
|
|
|
float keytime = bone_keyframe[ANIMATIONDATA_KEYTIME].GetDouble();
|
2014-06-13 19:26:46 +08:00
|
|
|
Vec3 val = Vec3(bone_keyframe_scale[(rapidjson::SizeType)0].GetDouble(), bone_keyframe_scale[1].GetDouble(), bone_keyframe_scale[2].GetDouble());
|
|
|
|
animationdata->_scaleKeys[bone_name].push_back(Animation3DData::Vec3Key(keytime,val));
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-06-15 22:45:56 +08:00
|
|
|
|
2014-06-05 18:21:25 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-06-19 15:43:02 +08:00
|
|
|
bool Bundle3D::loadBinary(const std::string& path)
|
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
clear();
|
|
|
|
|
2014-06-19 15:43:02 +08:00
|
|
|
// get file data
|
2014-06-20 15:30:08 +08:00
|
|
|
CC_SAFE_DELETE(_binaryBuffer);
|
|
|
|
_binaryBuffer = new Data();
|
|
|
|
*_binaryBuffer = FileUtils::getInstance()->getDataFromFile(path);
|
|
|
|
if (_binaryBuffer->isNull())
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
clear();
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO(false, "Failed to read file: %s", path.c_str());
|
2014-06-19 15:43:02 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-07-01 09:30:14 +08:00
|
|
|
// Initialise bundle reader
|
2014-06-25 09:13:24 +08:00
|
|
|
_binaryReader.init( (char*)_binaryBuffer->getBytes(), _binaryBuffer->getSize() );
|
2014-06-19 15:43:02 +08:00
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
// Read identifier info
|
2014-06-19 15:43:02 +08:00
|
|
|
char identifier[] = { 'C', '3', 'B', '\0'};
|
|
|
|
char sig[4];
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(sig, 1, 4) != 4 || memcmp(sig, identifier, 4) != 0)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
clear();
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO(false, "Invalid identifier: %s", path.c_str());
|
2014-06-19 15:43:02 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read version
|
|
|
|
unsigned char ver[2];
|
2014-07-01 09:26:21 +08:00
|
|
|
if (_binaryReader.read(ver, 1, 2)!= 2){
|
|
|
|
CCLOG("Failed to read version:");
|
|
|
|
return false;
|
2014-06-19 15:43:02 +08:00
|
|
|
}
|
2014-07-01 09:26:21 +08:00
|
|
|
|
2014-07-29 10:49:06 +08:00
|
|
|
char version[20] = {0};
|
|
|
|
sprintf(version, "%d.%d", ver[0], ver[1]);
|
|
|
|
_version = version;
|
2014-06-19 15:43:02 +08:00
|
|
|
|
|
|
|
// Read ref table size
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(&_referenceCount, 4, 1) != 1)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
clear();
|
2014-06-19 15:43:02 +08:00
|
|
|
CCLOGINFO("Failed to read ref table size '%s'.", path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read all refs
|
|
|
|
CC_SAFE_DELETE_ARRAY(_references);
|
2014-06-20 15:30:08 +08:00
|
|
|
_references = new Reference[_referenceCount];
|
2014-06-27 14:42:48 +08:00
|
|
|
for (ssize_t i = 0; i < _referenceCount; ++i)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
if ((_references[i].id = _binaryReader.readString()).empty() ||
|
|
|
|
_binaryReader.read(&_references[i].type, 4, 1) != 1 ||
|
|
|
|
_binaryReader.read(&_references[i].offset, 4, 1) != 1)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
clear();
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO("Failed to read ref number %d for bundle '%s'.", i, path.c_str());
|
2014-06-19 15:43:02 +08:00
|
|
|
CC_SAFE_DELETE_ARRAY(_references);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Bundle3D::loadMeshDataBinary(MeshData* meshdata)
|
2014-07-29 10:49:06 +08:00
|
|
|
{
|
|
|
|
if (_version == "0.1")
|
|
|
|
{
|
|
|
|
return loadMeshDataBinary_0_1(meshdata);
|
|
|
|
}
|
|
|
|
else if(_version == "0.2")
|
|
|
|
{
|
|
|
|
return loadMeshDataBinary_0_2(meshdata);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CCLOGINFO(false, "Unsupported version of loadMeshDataBinary() : %s", _version);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Bundle3D::loadMeshDataBinary_0_1(MeshData* meshdata)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
if (!seekToFirstType(BUNDLE_TYPE_MESH))
|
|
|
|
return false;
|
2014-06-19 15:43:02 +08:00
|
|
|
|
|
|
|
// read mesh data
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(&meshdata->attribCount, 4, 1) != 1 || meshdata->attribCount < 1)
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read meshdata: attribCount '%s'.", _path.c_str());
|
2014-06-19 15:43:02 +08:00
|
|
|
return false;
|
2014-06-20 15:30:08 +08:00
|
|
|
}
|
2014-06-19 15:43:02 +08:00
|
|
|
|
|
|
|
meshdata->attribs.resize(meshdata->attribCount);
|
|
|
|
for (ssize_t i = 0; i < meshdata->attribCount; i++)
|
|
|
|
{
|
|
|
|
unsigned int vUsage, vSize;
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(&vUsage, 4, 1) != 1 || _binaryReader.read(&vSize, 4, 1) != 1)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO("Failed to read meshdata: usage or size '%s'.", _path.c_str());
|
2014-06-19 15:43:02 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
meshdata->attribs[i].size = vSize;
|
|
|
|
meshdata->attribs[i].attribSizeBytes = meshdata->attribs[i].size * 4;
|
|
|
|
meshdata->attribs[i].type = GL_FLOAT;
|
|
|
|
meshdata->attribs[i].vertexAttrib = vUsage;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read vertex data
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(&meshdata->vertexSizeInFloat, 4, 1) != 1 || meshdata->vertexSizeInFloat == 0)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO("Failed to read meshdata: vertexSizeInFloat '%s'.", _path.c_str());
|
2014-06-19 15:43:02 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
meshdata->vertex.resize(meshdata->vertexSizeInFloat);
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(&meshdata->vertex[0], 4, meshdata->vertexSizeInFloat) != meshdata->vertexSizeInFloat)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO("Failed to read meshdata: vertex element '%s'.", _path.c_str());
|
2014-06-19 15:43:02 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read index data
|
2014-06-30 17:10:07 +08:00
|
|
|
unsigned int meshPartCount = 1;
|
2014-06-25 09:13:24 +08:00
|
|
|
//_binaryReader.read(&meshPartCount, 4, 1);
|
2014-06-19 15:43:02 +08:00
|
|
|
|
2014-06-30 17:10:07 +08:00
|
|
|
for (unsigned int i = 0; i < meshPartCount; ++i)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-30 17:10:07 +08:00
|
|
|
unsigned int nIndexCount;
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(&nIndexCount, 4, 1) != 1)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO("Failed to read meshdata: nIndexCount '%s'.", _path.c_str());
|
2014-06-19 15:43:02 +08:00
|
|
|
return false;
|
|
|
|
}
|
2014-07-29 10:49:06 +08:00
|
|
|
|
|
|
|
std::vector<unsigned short> indices;
|
|
|
|
indices.resize(nIndexCount);
|
|
|
|
if (_binaryReader.read(&indices[0], 2, nIndexCount) != nIndexCount)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO("Failed to read meshdata: indices '%s'.", _path.c_str());
|
2014-06-19 15:43:02 +08:00
|
|
|
return false;
|
|
|
|
}
|
2014-07-29 10:49:06 +08:00
|
|
|
|
|
|
|
meshdata->subMeshIndices.push_back(indices);
|
2014-06-19 15:43:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-07-29 10:49:06 +08:00
|
|
|
bool Bundle3D::loadMeshDataBinary_0_2(MeshData* meshdata)
|
|
|
|
{
|
|
|
|
if (!seekToFirstType(BUNDLE_TYPE_MESH))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
meshdata->resetData();
|
|
|
|
|
|
|
|
// read mesh data
|
|
|
|
if (_binaryReader.read(&meshdata->attribCount, 4, 1) != 1 || meshdata->attribCount < 1)
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read meshdata: attribCount '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
meshdata->attribs.resize(meshdata->attribCount);
|
|
|
|
for (ssize_t i = 0; i < meshdata->attribCount; i++)
|
|
|
|
{
|
|
|
|
unsigned int vUsage, vSize;
|
|
|
|
if (_binaryReader.read(&vUsage, 4, 1) != 1 || _binaryReader.read(&vSize, 4, 1) != 1)
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read meshdata: usage or size '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
meshdata->attribs[i].size = vSize;
|
|
|
|
meshdata->attribs[i].attribSizeBytes = meshdata->attribs[i].size * 4;
|
|
|
|
meshdata->attribs[i].type = GL_FLOAT;
|
|
|
|
meshdata->attribs[i].vertexAttrib = vUsage;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Read vertex data
|
|
|
|
if (_binaryReader.read(&meshdata->vertexSizeInFloat, 4, 1) != 1 || meshdata->vertexSizeInFloat == 0)
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read meshdata: vertexSizeInFloat '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
meshdata->vertex.resize(meshdata->vertexSizeInFloat);
|
|
|
|
if (_binaryReader.read(&meshdata->vertex[0], 4, meshdata->vertexSizeInFloat) != meshdata->vertexSizeInFloat)
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read meshdata: vertex element '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// read submesh
|
|
|
|
unsigned int submeshCount;
|
|
|
|
if (_binaryReader.read(&submeshCount, 4, 1) != 1)
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read meshdata: submeshCount '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < submeshCount; ++i)
|
|
|
|
{
|
|
|
|
unsigned int nIndexCount;
|
|
|
|
if (_binaryReader.read(&nIndexCount, 4, 1) != 1)
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read meshdata: nIndexCount '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<unsigned short> indices;
|
|
|
|
indices.resize(nIndexCount);
|
|
|
|
if (_binaryReader.read(&indices[0], 2, nIndexCount) != nIndexCount)
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read meshdata: indices '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
meshdata->subMeshIndices.push_back(indices);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
bool Bundle3D::loadSkinDataBinary(SkinData* skindata)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
if (!seekToFirstType(BUNDLE_TYPE_MESHSKIN))
|
|
|
|
return false;
|
2014-06-24 14:10:03 +08:00
|
|
|
|
2014-06-25 13:20:42 +08:00
|
|
|
std::string boneName = _binaryReader.readString();
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
// transform
|
2014-06-19 15:43:02 +08:00
|
|
|
float bindShape[16];
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_binaryReader.readMatrix(bindShape))
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read SkinData: bindShape matrix '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
2014-06-24 14:10:03 +08:00
|
|
|
|
|
|
|
// bone count
|
|
|
|
unsigned int boneNum;
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_binaryReader.read(&boneNum))
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read SkinData: boneNum '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
2014-06-19 15:43:02 +08:00
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
// bone names and bind pos
|
|
|
|
float bindpos[16];
|
2014-06-24 14:10:03 +08:00
|
|
|
for (unsigned int i = 0; i < boneNum; i++)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-25 13:20:42 +08:00
|
|
|
std::string skinBoneName = _binaryReader.readString();
|
|
|
|
skindata->skinBoneNames.push_back(skinBoneName);
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_binaryReader.readMatrix(bindpos))
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to load SkinData: bindpos '%s'.", _path.c_str());
|
2014-06-30 17:07:55 +08:00
|
|
|
return false;
|
2014-06-20 15:30:08 +08:00
|
|
|
}
|
|
|
|
skindata->inverseBindPoseMatrices.push_back(bindpos);
|
2014-06-19 15:43:02 +08:00
|
|
|
}
|
2014-06-24 14:10:03 +08:00
|
|
|
|
2014-06-25 11:35:55 +08:00
|
|
|
skindata->skinBoneOriginMatrices.resize(boneNum);
|
|
|
|
|
2014-06-25 13:20:42 +08:00
|
|
|
boneName = _binaryReader.readString();
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
// bind shape
|
2014-06-25 09:13:24 +08:00
|
|
|
_binaryReader.readMatrix(bindShape);
|
2014-06-25 13:20:42 +08:00
|
|
|
int rootIndex = skindata->getSkinBoneNameIndex(boneName);
|
|
|
|
if(rootIndex < 0)
|
|
|
|
{
|
|
|
|
skindata->addNodeBoneNames(boneName);
|
|
|
|
rootIndex = skindata->getBoneNameIndex(boneName);
|
|
|
|
skindata->nodeBoneOriginMatrices.push_back(bindShape);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
skindata->skinBoneOriginMatrices[rootIndex] = bindShape;
|
|
|
|
}
|
|
|
|
|
|
|
|
// set root bone index
|
|
|
|
skindata->rootBoneIndex = rootIndex;
|
2014-06-24 14:10:03 +08:00
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
// read parent and child relationship map
|
|
|
|
float transform[16];
|
2014-06-24 14:10:03 +08:00
|
|
|
unsigned int linkNum;
|
2014-06-25 09:13:24 +08:00
|
|
|
_binaryReader.read(&linkNum);
|
2014-06-24 14:10:03 +08:00
|
|
|
for (unsigned int i = 0; i < linkNum; ++i)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
std::string id = _binaryReader.readString();
|
2014-06-24 14:10:03 +08:00
|
|
|
int index = skindata->getSkinBoneNameIndex(id);
|
2014-06-25 13:20:42 +08:00
|
|
|
|
|
|
|
|
|
|
|
std::string parentid = _binaryReader.readString();
|
|
|
|
|
|
|
|
if (!_binaryReader.readMatrix(transform))
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to load SkinData: transform '%s'.", _path.c_str());
|
2014-06-30 17:07:55 +08:00
|
|
|
return false;
|
2014-06-25 13:20:42 +08:00
|
|
|
}
|
|
|
|
|
2014-06-24 14:10:03 +08:00
|
|
|
if(index < 0)
|
|
|
|
{
|
|
|
|
skindata->addNodeBoneNames(id);
|
|
|
|
index = skindata->getBoneNameIndex(id);
|
|
|
|
skindata->nodeBoneOriginMatrices.push_back(transform);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2014-06-25 11:35:55 +08:00
|
|
|
skindata->skinBoneOriginMatrices[index] = transform;
|
2014-06-24 14:10:03 +08:00
|
|
|
}
|
|
|
|
|
2014-06-25 11:35:55 +08:00
|
|
|
int parentIndex = skindata->getSkinBoneNameIndex(parentid);
|
2014-06-24 14:10:03 +08:00
|
|
|
if(parentIndex < 0)
|
|
|
|
{
|
|
|
|
skindata->addNodeBoneNames(parentid);
|
2014-06-24 14:43:20 +08:00
|
|
|
parentIndex = skindata->getBoneNameIndex(parentid);
|
2014-06-24 14:10:03 +08:00
|
|
|
}
|
2014-06-25 13:20:42 +08:00
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
skindata->boneChild[parentIndex].push_back(index);
|
2014-06-24 14:10:03 +08:00
|
|
|
|
2014-06-19 15:43:02 +08:00
|
|
|
}
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Bundle3D::loadMaterialDataBinary(MaterialData* materialdata)
|
|
|
|
{
|
|
|
|
if (!seekToFirstType(BUNDLE_TYPE_MATERIAL))
|
|
|
|
return false;
|
2014-06-19 15:43:02 +08:00
|
|
|
|
2014-07-29 10:49:06 +08:00
|
|
|
unsigned int materialnum = 1;
|
|
|
|
if (_version == "0.2")
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
2014-07-29 10:49:06 +08:00
|
|
|
_binaryReader.read(&materialnum, 4, 1);
|
2014-06-20 15:30:08 +08:00
|
|
|
}
|
2014-07-29 10:49:06 +08:00
|
|
|
|
|
|
|
for (int i = 0; i < materialnum; i++)
|
|
|
|
{
|
|
|
|
std::string texturePath = _binaryReader.readString();
|
|
|
|
if (texturePath.empty())
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read Materialdata: texturePath is empty '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-08-16 11:12:26 +08:00
|
|
|
std::string path = _modelPath + texturePath;
|
2014-07-29 10:49:06 +08:00
|
|
|
materialdata->texturePaths[i] = path;
|
|
|
|
}
|
|
|
|
|
2014-06-19 15:43:02 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
bool Bundle3D::loadAnimationDataBinary(Animation3DData* animationdata)
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
if (!seekToFirstType(BUNDLE_TYPE_ANIMATIONS))
|
|
|
|
return false;
|
|
|
|
|
2014-06-25 09:13:24 +08:00
|
|
|
_binaryReader.readString();
|
2014-06-20 15:30:08 +08:00
|
|
|
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_binaryReader.read(&animationdata->_totalTime))
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO("Failed to read AnimationData: totalTime '%s'.", _path.c_str());
|
|
|
|
return false;
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
2014-06-20 15:30:08 +08:00
|
|
|
|
2014-06-30 17:10:07 +08:00
|
|
|
unsigned int animNum;
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_binaryReader.read(&animNum))
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-06-20 15:30:08 +08:00
|
|
|
CCLOGINFO("Failed to read AnimationData: animNum '%s'.", _path.c_str());
|
|
|
|
return false;
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
2014-06-20 15:30:08 +08:00
|
|
|
|
2014-06-30 17:10:07 +08:00
|
|
|
for (unsigned int i = 0; i < animNum; ++i)
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
std::string boneName = _binaryReader.readString();
|
2014-06-30 17:10:07 +08:00
|
|
|
unsigned int keyframeNum;
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_binaryReader.read(&keyframeNum))
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read AnimationData: keyframeNum '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2014-06-30 17:10:07 +08:00
|
|
|
for (unsigned int j = 0; j < keyframeNum; ++j)
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
float keytime;
|
2014-06-25 09:13:24 +08:00
|
|
|
if (!_binaryReader.read(&keytime))
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read AnimationData: keytime '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Quaternion rotate;
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(&rotate, 4, 4) != 4)
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read AnimationData: rotate '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
animationdata->_rotationKeys[boneName].push_back(Animation3DData::QuatKey(keytime, rotate));
|
|
|
|
|
|
|
|
Vec3 scale;
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(&scale, 4, 3) != 3)
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read AnimationData: scale '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
animationdata->_scaleKeys[boneName].push_back(Animation3DData::Vec3Key(keytime, scale));
|
|
|
|
|
|
|
|
Vec3 position;
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.read(&position, 4, 3) != 3)
|
2014-06-20 15:30:08 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read AnimationData: position '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
animationdata->_translationKeys[boneName].push_back(Animation3DData::Vec3Key(keytime, position));
|
|
|
|
}
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
2014-06-20 15:30:08 +08:00
|
|
|
return true;
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
|
|
|
|
2014-08-16 11:12:26 +08:00
|
|
|
bool Bundle3D::loadNodesJson(NodeDatas& nodedatas)
|
|
|
|
{
|
|
|
|
if (!_jsonReader.HasMember(NODES)) return false;
|
|
|
|
const rapidjson::Value& nodes = _jsonReader[NODES];
|
|
|
|
if(!nodes.IsArray()) return false;
|
|
|
|
|
|
|
|
loadBoneNamesJson(nodes);
|
|
|
|
|
2014-08-16 14:28:15 +08:00
|
|
|
// traverse the nodes again
|
2014-08-16 11:12:26 +08:00
|
|
|
for (rapidjson::SizeType i = 0; i < nodes.Size(); i++)
|
|
|
|
{
|
2014-08-16 14:28:15 +08:00
|
|
|
_skeleton = false;
|
2014-08-16 11:12:26 +08:00
|
|
|
const rapidjson::Value& jnode = nodes[i];
|
|
|
|
std::string id = jnode[ID].GetString();
|
|
|
|
NodeData* nodedata = parseNodesRecursivelyJson(jnode);
|
|
|
|
|
2014-08-16 14:28:15 +08:00
|
|
|
//bool isSkeleton;
|
|
|
|
//isSkeleton = checkIsSkeletonJson(jnode);
|
2014-08-16 11:12:26 +08:00
|
|
|
|
2014-08-16 14:28:15 +08:00
|
|
|
if (_skeleton)
|
2014-08-16 11:12:26 +08:00
|
|
|
nodedatas.skeleton.push_back(nodedata);
|
|
|
|
else
|
|
|
|
nodedatas.nodes.push_back(nodedata);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Bundle3D::loadBoneNamesJson(const rapidjson::Value& jnodes)
|
|
|
|
{
|
|
|
|
for (rapidjson::SizeType i = 0; i < jnodes.Size(); i++)
|
|
|
|
{
|
|
|
|
parseBoneNameRecursivelyJson(jnodes[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Bundle3D::parseBoneNameRecursivelyJson(const rapidjson::Value& jnode)
|
|
|
|
{
|
|
|
|
std::string id = jnode[ID].GetString();
|
|
|
|
if (jnode.HasMember(PARTS))
|
|
|
|
{
|
|
|
|
const rapidjson::Value& parts = jnode[PARTS];
|
|
|
|
|
|
|
|
for (rapidjson::SizeType i = 0; i < parts.Size(); i++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& part = parts[i];
|
|
|
|
|
|
|
|
if (part.HasMember(BONES))
|
|
|
|
{
|
|
|
|
const rapidjson::Value& bones = part[BONES];
|
|
|
|
|
|
|
|
for (rapidjson::SizeType j = 0; j < bones.Size(); j++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& bone = bones[j];
|
|
|
|
std::string bonename = bone[NODE].GetString();
|
|
|
|
|
|
|
|
if (!checkIsBone(bonename))
|
|
|
|
{
|
|
|
|
_bonenames.push_back(bonename);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (jnode.HasMember(CHILDREN))
|
|
|
|
{
|
|
|
|
const rapidjson::Value& children = jnode[CHILDREN];
|
|
|
|
|
|
|
|
for (rapidjson::SizeType i = 0; i < children.Size(); i++)
|
|
|
|
{
|
|
|
|
parseBoneNameRecursivelyJson(children[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Bundle3D::checkIsBone(const std::string& name)
|
|
|
|
{
|
|
|
|
std::list<std::string>::iterator iter = std::find(_bonenames.begin(), _bonenames.end(), name);
|
|
|
|
bool ret = (iter != _bonenames.end()) ? true : false;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
NodeData* Bundle3D::parseNodesRecursivelyJson(const rapidjson::Value& jvalue)
|
|
|
|
{
|
|
|
|
NodeData* nodedata;
|
|
|
|
if (jvalue.HasMember(PARTS))
|
|
|
|
nodedata = new ModelNodeData();
|
|
|
|
else
|
|
|
|
nodedata = new NodeData();
|
|
|
|
|
|
|
|
// id
|
|
|
|
nodedata->id = jvalue[ID].GetString();
|
|
|
|
|
2014-08-16 14:28:15 +08:00
|
|
|
// check is skeleton
|
|
|
|
if (checkIsBone(nodedata->id))
|
|
|
|
_skeleton = true;
|
|
|
|
|
2014-08-16 11:12:26 +08:00
|
|
|
// transform
|
|
|
|
Mat4 tranform;
|
|
|
|
const rapidjson::Value& jtransform = jvalue[TRANSFORM];
|
|
|
|
|
|
|
|
for (rapidjson::SizeType j = 0; j < jtransform.Size(); j++)
|
|
|
|
{
|
|
|
|
tranform.m[j] = jtransform[j].GetDouble();
|
|
|
|
}
|
|
|
|
|
|
|
|
nodedata->transform = tranform;
|
|
|
|
|
|
|
|
// parts
|
|
|
|
if (jvalue.HasMember(PARTS))
|
|
|
|
{
|
|
|
|
const rapidjson::Value& parts = jvalue[PARTS];
|
|
|
|
ModelNodeData* modelnodedata = dynamic_cast<ModelNodeData*>(nodedata);
|
|
|
|
|
|
|
|
for (rapidjson::SizeType i = 0; i < parts.Size(); i++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& part = parts[i];
|
|
|
|
std::string meshPartId = part[MESHPARTID].GetString();
|
|
|
|
std::string materialId = part[MATERIALID].GetString();
|
|
|
|
|
|
|
|
if (meshPartId == "" || materialId == "")
|
|
|
|
{
|
|
|
|
std::string err = "Node " + nodedata->id + " part is missing meshPartId or materialId";
|
|
|
|
CCASSERT(false, err.c_str());
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (part.HasMember(BONES))
|
|
|
|
{
|
|
|
|
const rapidjson::Value& bones = part[BONES];
|
|
|
|
|
|
|
|
for (rapidjson::SizeType j = 0; j < bones.Size(); j++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& bone = bones[i];
|
|
|
|
|
|
|
|
// node
|
|
|
|
if (!bone.HasMember(NODE))
|
|
|
|
{
|
|
|
|
CCASSERT(false, "Bone node ID missing");
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
modelnodedata->bones.push_back(bone[NODE].GetString());
|
|
|
|
|
|
|
|
Mat4 invbindpos;
|
|
|
|
const rapidjson::Value& jtransform = jvalue[TRANSFORM];
|
|
|
|
|
|
|
|
for (rapidjson::SizeType j = 0; j < jtransform.Size(); j++)
|
|
|
|
{
|
|
|
|
invbindpos.m[j] = jtransform[j].GetDouble();
|
|
|
|
}
|
|
|
|
|
|
|
|
modelnodedata->invBindPose.push_back(invbindpos);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (jvalue.HasMember(CHILDREN))
|
|
|
|
{
|
|
|
|
const rapidjson::Value& children = jvalue[CHILDREN];
|
|
|
|
for (rapidjson::SizeType i = 0; i < children.Size(); i++)
|
|
|
|
{
|
|
|
|
const rapidjson::Value& child = children[i];
|
|
|
|
|
|
|
|
NodeData* tempdata = parseNodesRecursivelyJson(child);
|
|
|
|
nodedata->children.push_back(tempdata);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nodedata;
|
|
|
|
}
|
|
|
|
|
2014-08-16 14:28:15 +08:00
|
|
|
bool Bundle3D::loadNodesBinary(NodeDatas& nodedatas)
|
|
|
|
{
|
|
|
|
if (!seekToFirstType(BUNDLE_TYPE_NODE))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
loadBoneNamesBinary();
|
|
|
|
|
|
|
|
if (!seekToFirstType(BUNDLE_TYPE_NODE))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned int nodeSize = 0;
|
|
|
|
if (_binaryReader.read(&nodeSize, 4, 1) != 1)
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read nodes: size '%s'.", _path.c_str());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// traverse the nodes again
|
|
|
|
for (rapidjson::SizeType i = 0; i < nodeSize; i++)
|
|
|
|
{
|
|
|
|
std::string id = _binaryReader.readString();
|
|
|
|
NodeData* nodedata = parseNodesRecursivelyBinary();
|
|
|
|
|
|
|
|
if (_skeleton)
|
|
|
|
nodedatas.skeleton.push_back(nodedata);
|
|
|
|
else
|
|
|
|
nodedatas.nodes.push_back(nodedata);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Bundle3D::loadBoneNamesBinary()
|
|
|
|
{
|
|
|
|
unsigned int nodeSize=0;
|
|
|
|
if (_binaryReader.read(&nodeSize, 4, 1) != 1)
|
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to read nodes: size '%s'.", _path.c_str());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < nodeSize; i++)
|
|
|
|
{
|
|
|
|
parseBoneNameRecursivelyBinary();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Bundle3D::parseBoneNameRecursivelyBinary()
|
|
|
|
{
|
|
|
|
std::string id = _binaryReader.readString();
|
|
|
|
|
|
|
|
Mat4 nodeMat;
|
|
|
|
if (!_binaryReader.readMatrix(nodeMat.m))
|
|
|
|
return;
|
|
|
|
|
|
|
|
// read pass
|
|
|
|
unsigned int partsSize=0;
|
|
|
|
if (_binaryReader.read(&partsSize, 4, 1) != 1)
|
|
|
|
{
|
|
|
|
CCASSERT("Failed to read part size: '%s'.", _path.c_str());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (partsSize > 0)
|
|
|
|
{
|
|
|
|
for (unsigned i = 0; i < partsSize; i++)
|
|
|
|
{
|
|
|
|
unsigned int boneSize=0;
|
|
|
|
if (_binaryReader.read(&boneSize, 4, 1) != 1)
|
|
|
|
{
|
|
|
|
CCASSERT("Failed to read bone: size '%s'.", _path.c_str());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (boneSize > 0)
|
|
|
|
{
|
|
|
|
for (unsigned j = 0; j < boneSize; j++)
|
|
|
|
{
|
|
|
|
std::string bonename = _binaryReader.readString();
|
|
|
|
|
|
|
|
Mat4 boneMat;
|
|
|
|
if (!_binaryReader.readMatrix(boneMat.m))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (!checkIsBone(bonename))
|
|
|
|
{
|
|
|
|
_bonenames.push_back(bonename);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// read children
|
|
|
|
unsigned int childrenSize = 0;
|
|
|
|
if (_binaryReader.read(&childrenSize, 4, 1) != 1)
|
|
|
|
{
|
|
|
|
CCASSERT("Failed to read children size: '%s'.", _path.c_str());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (childrenSize > 0)
|
|
|
|
{
|
|
|
|
for (rapidjson::SizeType i = 0; i < childrenSize; i++)
|
|
|
|
{
|
|
|
|
parseBoneNameRecursivelyBinary();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NodeData* Bundle3D::parseNodesRecursivelyBinary()
|
|
|
|
{
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
GLenum Bundle3D::parseGLType(const std::string& str)
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-07-07 17:22:46 +08:00
|
|
|
if (str == "GL_BYTE")
|
2014-06-12 10:01:54 +08:00
|
|
|
{
|
2014-07-07 09:16:08 +08:00
|
|
|
return GL_BYTE;
|
|
|
|
}
|
2014-07-07 17:22:46 +08:00
|
|
|
else if(str == "GL_UNSIGNED_BYTE")
|
2014-07-07 09:16:08 +08:00
|
|
|
{
|
|
|
|
return GL_UNSIGNED_BYTE;
|
|
|
|
}
|
2014-07-07 17:22:46 +08:00
|
|
|
else if(str == "GL_SHORT")
|
2014-07-07 09:16:08 +08:00
|
|
|
{
|
|
|
|
return GL_SHORT;
|
|
|
|
}
|
2014-07-07 17:22:46 +08:00
|
|
|
else if(str == "GL_UNSIGNED_SHORT")
|
2014-07-07 09:16:08 +08:00
|
|
|
{
|
|
|
|
return GL_UNSIGNED_SHORT;
|
|
|
|
}
|
2014-07-07 17:22:46 +08:00
|
|
|
else if(str == "GL_INT")
|
2014-07-07 09:16:08 +08:00
|
|
|
{
|
|
|
|
return GL_INT;
|
|
|
|
}
|
2014-07-07 17:22:46 +08:00
|
|
|
else if (str == "GL_UNSIGNED_INT")
|
2014-07-07 09:16:08 +08:00
|
|
|
{
|
|
|
|
return GL_UNSIGNED_INT;
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
2014-07-07 09:16:08 +08:00
|
|
|
else if (str == "GL_FLOAT")
|
|
|
|
{
|
|
|
|
return GL_FLOAT;
|
|
|
|
}
|
2014-06-12 10:01:54 +08:00
|
|
|
else
|
|
|
|
{
|
2014-07-07 09:16:08 +08:00
|
|
|
CCASSERT(false, "Wrong GL type");
|
2014-06-20 15:30:08 +08:00
|
|
|
return 0;
|
2014-06-12 10:01:54 +08:00
|
|
|
}
|
|
|
|
}
|
2014-08-16 10:41:42 +08:00
|
|
|
NTextureData::Usage Bundle3D::parseGLTextureType(const std::string& str)
|
|
|
|
{
|
|
|
|
if (str == "AMBIENT")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::Ambient;
|
|
|
|
}
|
|
|
|
else if(str == "BUMP")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::Bump;
|
|
|
|
}
|
|
|
|
else if(str == "DIFFUSE")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::Diffuse;
|
|
|
|
}
|
|
|
|
else if(str == "EMISSIVE")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::Emissive;
|
|
|
|
}
|
|
|
|
else if(str == "NONE")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::None;
|
|
|
|
}
|
|
|
|
else if (str == "NORMAL")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::Normal;
|
|
|
|
}
|
|
|
|
else if (str == "REFLECTION")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::Reflection;
|
|
|
|
}
|
|
|
|
else if (str == "SHININESS")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::Shininess;
|
|
|
|
}
|
|
|
|
else if (str == "SPECULAR")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::Specular;
|
|
|
|
}
|
|
|
|
else if (str == "TRANSPARENCY")
|
|
|
|
{
|
|
|
|
return NTextureData::Usage::Transparency;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CCASSERT(false, "Wrong GL type");
|
|
|
|
return NTextureData::Usage::Unknown;
|
|
|
|
}
|
|
|
|
}
|
2014-06-12 10:01:54 +08:00
|
|
|
unsigned int Bundle3D::parseGLProgramAttribute(const std::string& str)
|
|
|
|
{
|
|
|
|
if (str == "VERTEX_ATTRIB_POSITION")
|
|
|
|
{
|
|
|
|
return GLProgram::VERTEX_ATTRIB_POSITION;
|
|
|
|
}
|
|
|
|
else if (str == "VERTEX_ATTRIB_COLOR")
|
|
|
|
{
|
|
|
|
return GLProgram::VERTEX_ATTRIB_COLOR;
|
|
|
|
}
|
|
|
|
else if (str == "VERTEX_ATTRIB_TEX_COORD")
|
|
|
|
{
|
|
|
|
return GLProgram::VERTEX_ATTRIB_TEX_COORD;
|
|
|
|
}
|
|
|
|
else if (str == "VERTEX_ATTRIB_NORMAL")
|
|
|
|
{
|
|
|
|
return GLProgram::VERTEX_ATTRIB_NORMAL;
|
|
|
|
}
|
|
|
|
else if (str == "VERTEX_ATTRIB_BLEND_WEIGHT")
|
|
|
|
{
|
|
|
|
return GLProgram::VERTEX_ATTRIB_BLEND_WEIGHT;
|
|
|
|
}
|
|
|
|
else if (str == "VERTEX_ATTRIB_BLEND_INDEX")
|
|
|
|
{
|
|
|
|
return GLProgram::VERTEX_ATTRIB_BLEND_INDEX;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
assert(0);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-20 15:30:08 +08:00
|
|
|
void Bundle3D::getModelRelativePath(const std::string& path)
|
2014-06-16 19:08:43 +08:00
|
|
|
{
|
2014-06-30 17:10:07 +08:00
|
|
|
ssize_t index = path.find_last_of('/');
|
2014-06-16 19:08:43 +08:00
|
|
|
std::string fullModelPath;
|
2014-08-16 11:12:26 +08:00
|
|
|
_modelPath = path.substr(0, index + 1);
|
2014-06-16 19:08:43 +08:00
|
|
|
}
|
|
|
|
|
2014-06-19 15:43:02 +08:00
|
|
|
Reference* Bundle3D::seekToFirstType(unsigned int type)
|
|
|
|
{
|
|
|
|
// for each Reference
|
|
|
|
for (unsigned int i = 0; i < _referenceCount; ++i)
|
|
|
|
{
|
|
|
|
Reference* ref = &_references[i];
|
|
|
|
if (ref->type == type)
|
|
|
|
{
|
|
|
|
// Found a match
|
2014-06-25 09:13:24 +08:00
|
|
|
if (_binaryReader.seek(ref->offset, SEEK_SET) == false)
|
2014-06-19 15:43:02 +08:00
|
|
|
{
|
|
|
|
CCLOGINFO("Failed to seek to object '%s' in bundle '%s'.", ref->id.c_str(), _path.c_str());
|
2014-06-20 22:38:09 +08:00
|
|
|
return nullptr;
|
2014-06-19 15:43:02 +08:00
|
|
|
}
|
|
|
|
return ref;
|
|
|
|
}
|
|
|
|
}
|
2014-06-20 22:38:09 +08:00
|
|
|
return nullptr;
|
2014-06-19 15:43:02 +08:00
|
|
|
}
|
|
|
|
|
2014-06-05 16:36:01 +08:00
|
|
|
Bundle3D::Bundle3D()
|
2014-06-19 15:43:02 +08:00
|
|
|
:_isBinary(false),
|
2014-08-16 11:12:26 +08:00
|
|
|
_modelPath(""),
|
2014-06-19 15:43:02 +08:00
|
|
|
_path(""),
|
2014-07-29 10:49:06 +08:00
|
|
|
_version(""),
|
2014-06-25 09:13:24 +08:00
|
|
|
_jsonBuffer(nullptr),
|
|
|
|
_binaryBuffer(nullptr),
|
2014-06-19 15:43:02 +08:00
|
|
|
_referenceCount(0),
|
2014-08-16 14:28:15 +08:00
|
|
|
_references(nullptr),
|
|
|
|
_skeleton(false)
|
2014-06-05 16:36:01 +08:00
|
|
|
{
|
2014-06-12 10:01:54 +08:00
|
|
|
|
2014-06-05 16:36:01 +08:00
|
|
|
}
|
|
|
|
Bundle3D::~Bundle3D()
|
|
|
|
{
|
2014-06-25 09:13:24 +08:00
|
|
|
clear();
|
|
|
|
|
2014-06-05 16:36:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
NS_CC_END
|