bool Sprite3D::loadFromC3x(const std::string& path)
{
std::string fullPath = FileUtils::getInstance()->fullPathForFilename(path);
//find from the cache
std::string key = fullPath + "#";
auto mesh = MeshCache::getInstance()->getMesh(key);
if (mesh)
{
_mesh = mesh;
_mesh->retain();
auto tex = Sprite3DMaterialCache::getInstance()->getSprite3DMaterial(key);
setTexture(tex);
_skin = MeshSkin::create(fullPath, "");
CC_SAFE_RETAIN(_skin);
genGLProgramState();
return true;
}
//load from .c3b or .c3t
auto bundle = Bundle3D::getInstance();
if (!bundle->load(fullPath))
return false;
MeshData meshdata;
bool ret = bundle->loadMeshData("", &meshdata);
if (!ret)
{
return false;
}
_mesh = Mesh::create(meshdata.vertex, meshdata.vertexSizeInFloat, meshdata.indices, meshdata.attribs);
CC_SAFE_RETAIN(_mesh);
_skin = MeshSkin::create(fullPath, "");
CC_SAFE_RETAIN(_skin);
MaterialData materialdata;
ret = bundle->loadMaterialData("", &materialdata);
if (ret)
{
setTexture(materialdata.texturePath);
}
genGLProgramState();
//add to cache
auto cache = Director::getInstance()->getTextureCache();
auto tex = cache->addImage(materialdata.texturePath);
if (tex)
Sprite3DMaterialCache::getInstance()->addSprite3DMaterial(key, tex);
MeshCache::getInstance()->addMesh(key, _mesh);
return true;
}
bool Sprite3D::initWithFile(const std::string &path)
{
CC_SAFE_RELEASE_NULL(_mesh);
CC_SAFE_RELEASE_NULL(_texture);
//find from the cache
Mesh* mesh = Sprite3DDataCache::getInstance()->getSprite3DMesh(path);
if (mesh)
{
_mesh = mesh;
_mesh->retain();
auto tex = Sprite3DDataCache::getInstance()->getSprite3DTexture(path);
setTexture(tex);
genGLProgramState();
return true;
}
else
{
//load from file
std::string ext = path.substr(path.length() - 4, 4);
if (ext != ".obj" || !loadFromObj(path))
{
return false;
}
return true;
}
}
bool Sprite3D::initFrom(const NodeDatas& nodeDatas, const MeshDatas& meshdatas, const MaterialDatas& materialdatas)
{
for(const auto& it : meshdatas.meshDatas)
{
if(it)
{
// Mesh* mesh = Mesh::create(*it);
// _meshes.pushBack(mesh);
auto meshvertex = MeshVertexData::create(*it);
_meshVertexDatas.pushBack(meshvertex);
}
}
_skeleton = Skeleton3D::create(nodeDatas.skeleton);
CC_SAFE_RETAIN(_skeleton);
for(const auto& it : nodeDatas.nodes)
{
if(it)
{
createNode(it, this, materialdatas, nodeDatas.nodes.size() == 1);
}
}
for(const auto& it : nodeDatas.skeleton)
{
if(it)
{
createAttachSprite3DNode(it,materialdatas);
}
}
genGLProgramState();
return true;
}
Sprite3D* Sprite3D::createSprite3DNode(NodeData* nodedata,ModelData* modeldata,const MaterialDatas& materialdatas)
{
auto sprite = new (std::nothrow) Sprite3D();
if (sprite)
{
sprite->setName(nodedata->id);
auto mesh = Mesh::create(nodedata->id, getMeshIndexData(modeldata->subMeshId));
if (modeldata->matrialId == "" && materialdatas.materials.size())
{
const NTextureData* textureData = materialdatas.materials[0].getTextureData(NTextureData::Usage::Diffuse);
if (!textureData->filename.empty())
mesh->setTexture(textureData->filename);
}
else
{
const NMaterialData* materialData=materialdatas.getMaterialData(modeldata->matrialId);
if(materialData)
{
const NTextureData* textureData = materialData->getTextureData(NTextureData::Usage::Diffuse);
if(textureData && !textureData->filename.empty())
{
auto tex = Director::getInstance()->getTextureCache()->addImage(textureData->filename);
if(tex)
{
Texture2D::TexParams texParams;
texParams.minFilter = GL_LINEAR;
texParams.magFilter = GL_LINEAR;
texParams.wrapS = textureData->wrapS;
texParams.wrapT = textureData->wrapT;
tex->setTexParameters(texParams);
mesh->setTexture(tex);
mesh->_isTransparent = (materialData->getTextureData(NTextureData::Usage::Transparency) != nullptr);
}
}
}
}
// set locale transform
Vec3 pos;
Quaternion qua;
Vec3 scale;
nodedata->transform.decompose(&scale, &qua, &pos);
sprite->setPosition3D(pos);
sprite->setRotationQuat(qua);
sprite->setScaleX(scale.x);
sprite->setScaleY(scale.y);
sprite->setScaleZ(scale.z);
sprite->addMesh(mesh);
sprite->autorelease();
sprite->genGLProgramState();
}
return sprite;
}
//.mtl file should at the same directory with the same name if exist
bool Sprite3D::loadFromObj(const std::string& path)
{
std::string fullPath = FileUtils::getInstance()->fullPathForFilename(path);
//.mtl file directory
std::string dir = "";
auto last = fullPath.rfind("/");
if (last != -1)
dir = fullPath.substr(0, last + 1);
ObjLoader::shapes_t shapes;
std::string errstr = ObjLoader::LoadObj(shapes, fullPath.c_str(), dir.c_str());
if (!errstr.empty())
return false;
//convert to mesh and material
std::vector<unsigned short> indices;
std::vector<std::string> matnames;
std::string texname;
for (auto it = shapes.shapes.begin(); it != shapes.shapes.end(); it++)
{
indices.insert(indices.end(), (*it).mesh.indices.begin(),(*it).mesh.indices.end());
//indices.push_back((*it).mesh.indices);
if (texname.empty())
texname = (*it).material.diffuse_texname;
else if (texname != (*it).material.diffuse_texname)
{
CCLOGWARN("cocos2d:WARNING: more than one texture in %s", path.c_str());
}
matnames.push_back(dir + (*it).material.diffuse_texname);
}
_mesh = Mesh::create(shapes.positions, shapes.normals, shapes.texcoords, indices);
_mesh->retain();
if (_mesh == nullptr)
return false;
if (matnames.size())
{
setTexture(matnames[0]);
}
genGLProgramState();
//add to cache
Sprite3DDataCache::getInstance()->addSprite3D(fullPath, _mesh, matnames.size() > 0 ? matnames[0] : "");
return true;
}
void Sprite3D::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
if (_skeleton)
_skeleton->updateBoneMatrix();
Color4F color(getDisplayedColor());
color.a = getDisplayedOpacity() / 255.0f;
//check light and determine the shader used
const auto& lights = Director::getInstance()->getRunningScene()->getLights();
bool usingLight = false;
for (const auto light : lights) {
usingLight = ((unsigned int)light->getLightFlag() & _lightMask) > 0;
if (usingLight)
break;
}
if (usingLight != _shaderUsingLight)
genGLProgramState(usingLight);
int i = 0;
for (auto& mesh : _meshes) {
if (!mesh->isVisible())
{
i++;
continue;
}
auto programstate = mesh->getGLProgramState();
auto& meshCommand = mesh->getMeshCommand();
GLuint textureID = mesh->getTexture() ? mesh->getTexture()->getName() : 0;
meshCommand.init(_globalZOrder, textureID, programstate, _blend, mesh->getVertexBuffer(), mesh->getIndexBuffer(), mesh->getPrimitiveType(), mesh->getIndexFormat(), mesh->getIndexCount(), transform);
meshCommand.setLightMask(_lightMask);
auto skin = mesh->getSkin();
if (skin)
{
meshCommand.setMatrixPaletteSize((int)skin->getMatrixPaletteSize());
meshCommand.setMatrixPalette(skin->getMatrixPalette());
}
//support tint and fade
meshCommand.setDisplayColor(Vec4(color.r, color.g, color.b, color.a));
meshCommand.setTransparent(mesh->_isTransparent);
renderer->addCommand(&meshCommand);
}
}
void Sprite3D::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
#if CC_USE_CULLING
// camera clipping
if(Camera::getVisitingCamera() && !Camera::getVisitingCamera()->isVisibleInFrustum(&this->getAABB()))
return;
#endif
if (_skeleton)
_skeleton->updateBoneMatrix();
Color4F color(getDisplayedColor());
color.a = getDisplayedOpacity() / 255.0f;
//check light and determine the shader used
const auto& scene = Director::getInstance()->getRunningScene();
// Don't override GLProgramState if using manually set Material
if (_usingAutogeneratedGLProgram && scene)
{
const auto lights = scene->getLights();
bool usingLight = false;
for (const auto light : lights) {
usingLight = ((unsigned int)light->getLightFlag() & _lightMask) > 0;
if (usingLight)
break;
}
if (usingLight != _shaderUsingLight)
{
genGLProgramState(usingLight);
}
}
for (auto mesh: _meshes)
{
mesh->draw(renderer,
_globalZOrder,
transform,
flags,
_lightMask,
Vec4(color.r, color.g, color.b, color.a),
_forceDepthWrite);
}
}
Sprite3D* Sprite3D::createSprite3DNode(NodeData* nodedata,ModelData* modeldata,const MaterialDatas& matrialdatas)
{
auto sprite = new (std::nothrow) Sprite3D();
if (sprite)
{
sprite->setName(nodedata->id);
auto mesh = Mesh::create(nodedata->id, getMeshIndexData(modeldata->subMeshId));
if (modeldata->matrialId == "" && matrialdatas.materials.size())
{
const NTextureData* textureData = matrialdatas.materials[0].getTextureData(NTextureData::Usage::Diffuse);
if (!textureData->filename.empty())
mesh->setTexture(textureData->filename);
}
else
{
const NMaterialData* materialData=matrialdatas.getMaterialData(modeldata->matrialId);
if(materialData)
{
const NTextureData* textureData = materialData->getTextureData(NTextureData::Usage::Diffuse);
if(textureData && !textureData->filename.empty())
{
auto tex = Director::getInstance()->getTextureCache()->addImage(textureData->filename);
if(tex)
{
Texture2D::TexParams texParams;
texParams.minFilter = GL_LINEAR;
texParams.magFilter = GL_LINEAR;
texParams.wrapS = textureData->wrapS;
texParams.wrapT = textureData->wrapT;
tex->setTexParameters(texParams);
mesh->setTexture(tex);
mesh->_isTransparent = (materialData->getTextureData(NTextureData::Usage::Transparency) != nullptr);
}
}
}
}
sprite->setAdditionalTransform(&nodedata->transform);
sprite->addMesh(mesh);
sprite->autorelease();
sprite->genGLProgramState();
}
return sprite;
}
void Sprite3D::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{
#if CC_USE_CULLING
// camera clipping
if(!Camera::getVisitingCamera()->isVisibleInFrustum(&this->getAABB()))
return;
#endif
if (_skeleton)
_skeleton->updateBoneMatrix();
Color4F color(getDisplayedColor());
color.a = getDisplayedOpacity() / 255.0f;
//check light and determine the shader used
const auto& scene = Director::getInstance()->getRunningScene();
if (scene)
{
const auto& lights = scene->getLights();
bool usingLight = false;
for (const auto light : lights) {
usingLight = ((unsigned int)light->getLightFlag() & _lightMask) > 0;
if (usingLight)
break;
}
if (usingLight != _shaderUsingLight)
genGLProgramState(usingLight);
}
int i = 0;
for (auto& mesh : _meshes) {
if (!mesh->isVisible())
{
i++;
continue;
}
auto programstate = mesh->getGLProgramState();
auto& meshCommand = mesh->getMeshCommand();
#if (!defined NDEBUG) || (defined CC_MODEL_VIEWER)
GLuint textureID = 0;
if(mesh->getTexture())
{
textureID = mesh->getTexture()->getName();
}else
{ //let the mesh use a dummy texture instead of the missing or crashing texture file
auto texture = getDummyTexture();
mesh->setTexture(texture);
textureID = texture->getName();
}
#else
GLuint textureID = mesh->getTexture() ? mesh->getTexture()->getName() : 0;
#endif
float globalZ = _globalZOrder;
bool isTransparent = (mesh->_isTransparent || color.a < 1.f);
if (isTransparent && Camera::getVisitingCamera())
{
// use the view matrix for Applying to recalculating transparent mesh's Z-Order
const auto& viewMat = Camera::getVisitingCamera()->getViewMatrix();
//fetch the Z from the result matrix
globalZ = -(viewMat.m[2] * transform.m[12] + viewMat.m[6] * transform.m[13] + viewMat.m[10] * transform.m[14] + viewMat.m[14]);
}
meshCommand.init(globalZ, textureID, programstate, _blend, mesh->getVertexBuffer(), mesh->getIndexBuffer(), mesh->getPrimitiveType(), mesh->getIndexFormat(), mesh->getIndexCount(), transform, flags);
meshCommand.setLightMask(_lightMask);
auto skin = mesh->getSkin();
if (skin)
{
meshCommand.setMatrixPaletteSize((int)skin->getMatrixPaletteSize());
meshCommand.setMatrixPalette(skin->getMatrixPalette());
}
//support tint and fade
meshCommand.setDisplayColor(Vec4(color.r, color.g, color.b, color.a));
if (_forceDepthWrite)
{
meshCommand.setDepthWriteEnabled(true);
}
meshCommand.setTransparent(isTransparent);
renderer->addCommand(&meshCommand);
}
}
