void ccGenericMesh::applyGLTransformation(const ccGLMatrix& trans)
{
//vertices should be handled another way!
//we must take care of the triangle normals!
if (m_triNormals && (!getParent() || !getParent()->isKindOf(CC_MESH)))
{
bool recoded = false;
//if there is more triangle normals than the size of the compressed
//normals array, we recompress the array instead of recompressing each normal
unsigned i,numTriNormals = m_triNormals->currentSize();
if (numTriNormals>ccNormalVectors::GetNumberOfVectors())
{
NormsIndexesTableType* newNorms = new NormsIndexesTableType;
if (newNorms->reserve(ccNormalVectors::GetNumberOfVectors()))
{
for (i=0; i<ccNormalVectors::GetNumberOfVectors(); i++)
{
CCVector3 new_n(ccNormalVectors::GetNormal(i));
trans.applyRotation(new_n);
normsType newNormIndex = ccNormalVectors::GetNormIndex(new_n.u);
newNorms->addElement(newNormIndex);
}
m_triNormals->placeIteratorAtBegining();
for (i=0; i<numTriNormals; i++)
{
m_triNormals->setValue(i,newNorms->getValue(m_triNormals->getCurrentValue()));
m_triNormals->forwardIterator();
}
recoded=true;
}
newNorms->clear();
newNorms->release();
newNorms=0;
}
//if there is less triangle normals than the compressed normals array size
//(or if there is not enough memory to instantiate the temporary array),
//we recompress each normal ...
if (!recoded)
{
//on recode direct chaque normale
m_triNormals->placeIteratorAtBegining();
for (i=0; i<numTriNormals; i++)
{
normsType* _theNormIndex = m_triNormals->getCurrentValuePtr();
CCVector3 new_n(ccNormalVectors::GetNormal(*_theNormIndex));
trans.applyRotation(new_n.u);
*_theNormIndex = ccNormalVectors::GetNormIndex(new_n.u);
m_triNormals->forwardIterator();
}
}
}
else
{
//TODO: process failed!
}
}
void ccGenericMesh::drawMeOnly(CC_DRAW_CONTEXT& context)
{
ccGenericPointCloud* vertices = getAssociatedCloud();
if (!vertices)
return;
handleColorRamp(context);
//3D pass
if (MACRO_Draw3D(context))
{
//any triangle?
unsigned triNum = size();
if (triNum == 0)
return;
//L.O.D.
bool lodEnabled = (triNum > GET_MAX_LOD_FACES_NUMBER() && context.decimateMeshOnMove && MACRO_LODActivated(context));
unsigned decimStep = (lodEnabled ? (unsigned)ceil((float)triNum*3 / (float)GET_MAX_LOD_FACES_NUMBER()) : 1);
unsigned displayedTriNum = triNum / decimStep;
//display parameters
glDrawParams glParams;
getDrawingParameters(glParams);
glParams.showNorms &= bool(MACRO_LightIsEnabled(context));
//vertices visibility
const ccGenericPointCloud::VisibilityTableType* verticesVisibility = vertices->getTheVisibilityArray();
bool visFiltering = (verticesVisibility && verticesVisibility->isAllocated());
//wireframe ? (not compatible with LOD)
bool showWired = isShownAsWire() && !lodEnabled;
//per-triangle normals?
bool showTriNormals = (hasTriNormals() && triNormsShown());
//fix 'showNorms'
glParams.showNorms = showTriNormals || (vertices->hasNormals() && m_normalsDisplayed);
//materials & textures
bool applyMaterials = (hasMaterials() && materialsShown());
bool showTextures = (hasTextures() && materialsShown() && !lodEnabled);
//GL name pushing
bool pushName = MACRO_DrawEntityNames(context);
//special case: triangle names pushing (for picking)
bool pushTriangleNames = MACRO_DrawTriangleNames(context);
pushName |= pushTriangleNames;
if (pushName)
{
//not fast at all!
if (MACRO_DrawFastNamesOnly(context))
return;
glPushName(getUniqueIDForDisplay());
//minimal display for picking mode!
glParams.showNorms = false;
glParams.showColors = false;
//glParams.showSF --> we keep it only if SF 'NaN' values are hidden
showTriNormals = false;
applyMaterials = false;
showTextures = false;
}
//in the case we need to display scalar field colors
ccScalarField* currentDisplayedScalarField = 0;
bool greyForNanScalarValues = true;
unsigned colorRampSteps = 0;
ccColorScale::Shared colorScale(0);
if (glParams.showSF)
{
assert(vertices->isA(CC_TYPES::POINT_CLOUD));
ccPointCloud* cloud = static_cast<ccPointCloud*>(vertices);
greyForNanScalarValues = (cloud->getCurrentDisplayedScalarField() && cloud->getCurrentDisplayedScalarField()->areNaNValuesShownInGrey());
if (greyForNanScalarValues && pushName)
{
//in picking mode, no need to take SF into account if we don't hide any points!
glParams.showSF = false;
}
else
{
currentDisplayedScalarField = cloud->getCurrentDisplayedScalarField();
colorScale = currentDisplayedScalarField->getColorScale();
colorRampSteps = currentDisplayedScalarField->getColorRampSteps();
assert(colorScale);
//get default color ramp if cloud has no scale associated?!
if (!colorScale)
colorScale = ccColorScalesManager::GetUniqueInstance()->getDefaultScale(ccColorScalesManager::BGYR);
}
}
//materials or color?
bool colorMaterial = false;
if (glParams.showSF || glParams.showColors)
{
applyMaterials = false;
colorMaterial = true;
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
}
//in the case we need to display vertex colors
ColorsTableType* rgbColorsTable = 0;
if (glParams.showColors)
{
if (isColorOverriden())
{
glColor3ubv(m_tempColor);
glParams.showColors = false;
}
else
{
assert(vertices->isA(CC_TYPES::POINT_CLOUD));
rgbColorsTable = static_cast<ccPointCloud*>(vertices)->rgbColors();
}
}
else
{
glColor3fv(context.defaultMat.diffuseFront);
}
if (glParams.showNorms)
{
//DGM: Strangely, when Qt::renderPixmap is called, the OpenGL version can fall to 1.0!
glEnable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
glEnable(GL_LIGHTING);
context.defaultMat.applyGL(true,colorMaterial);
}
//in the case we need normals (i.e. lighting)
NormsIndexesTableType* normalsIndexesTable = 0;
ccNormalVectors* compressedNormals = 0;
if (glParams.showNorms)
{
assert(vertices->isA(CC_TYPES::POINT_CLOUD));
normalsIndexesTable = static_cast<ccPointCloud*>(vertices)->normals();
compressedNormals = ccNormalVectors::GetUniqueInstance();
}
//stipple mask
if (stipplingEnabled())
EnableGLStippleMask(true);
if (!pushTriangleNames && !visFiltering && !(applyMaterials || showTextures) && (!glParams.showSF || greyForNanScalarValues))
{
//the GL type depends on the PointCoordinateType 'size' (float or double)
GLenum GL_COORD_TYPE = sizeof(PointCoordinateType) == 4 ? GL_FLOAT : GL_DOUBLE;
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3,GL_COORD_TYPE,0,GetVertexBuffer());
if (glParams.showNorms)
{
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_COORD_TYPE,0,GetNormalsBuffer());
}
if (glParams.showSF || glParams.showColors)
{
glEnableClientState(GL_COLOR_ARRAY);
glColorPointer(3,GL_UNSIGNED_BYTE,0,GetColorsBuffer());
}
//we can scan and process each chunk separately in an optimized way
//we mimic the way ccMesh beahves by using virtual chunks!
unsigned chunks = static_cast<unsigned>(ceil((double)displayedTriNum/(double)MAX_NUMBER_OF_ELEMENTS_PER_CHUNK));
unsigned chunkStart = 0;
const colorType* col = 0;
for (unsigned k=0; k<chunks; ++k, chunkStart += MAX_NUMBER_OF_ELEMENTS_PER_CHUNK)
{
//virtual chunk size
const unsigned chunkSize = k+1 < chunks ? MAX_NUMBER_OF_ELEMENTS_PER_CHUNK : (displayedTriNum % MAX_NUMBER_OF_ELEMENTS_PER_CHUNK);
//vertices
PointCoordinateType* _vertices = GetVertexBuffer();
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
memcpy(_vertices,vertices->getPoint(ti->i1)->u,sizeof(PointCoordinateType)*3);
_vertices+=3;
memcpy(_vertices,vertices->getPoint(ti->i2)->u,sizeof(PointCoordinateType)*3);
_vertices+=3;
memcpy(_vertices,vertices->getPoint(ti->i3)->u,sizeof(PointCoordinateType)*3);
_vertices+=3;
}
//scalar field
if (glParams.showSF)
{
colorType* _rgbColors = GetColorsBuffer();
assert(colorScale);
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
col = currentDisplayedScalarField->getValueColor(ti->i1);
memcpy(_rgbColors,col,sizeof(colorType)*3);
_rgbColors += 3;
col = currentDisplayedScalarField->getValueColor(ti->i2);
memcpy(_rgbColors,col,sizeof(colorType)*3);
_rgbColors += 3;
col = currentDisplayedScalarField->getValueColor(ti->i3);
memcpy(_rgbColors,col,sizeof(colorType)*3);
_rgbColors += 3;
}
}
//colors
else if (glParams.showColors)
{
colorType* _rgbColors = GetColorsBuffer();
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
memcpy(_rgbColors,rgbColorsTable->getValue(ti->i1),sizeof(colorType)*3);
_rgbColors += 3;
memcpy(_rgbColors,rgbColorsTable->getValue(ti->i2),sizeof(colorType)*3);
_rgbColors += 3;
memcpy(_rgbColors,rgbColorsTable->getValue(ti->i3),sizeof(colorType)*3);
_rgbColors += 3;
}
}
//normals
if (glParams.showNorms)
{
PointCoordinateType* _normals = GetNormalsBuffer();
if (showTriNormals)
{
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
CCVector3 Na, Nb, Nc;
getTriangleNormals(chunkStart + n, Na, Nb, Nc);
memcpy(_normals,Na.u,sizeof(PointCoordinateType)*3);
_normals+=3;
memcpy(_normals,Nb.u,sizeof(PointCoordinateType)*3);
_normals+=3;
memcpy(_normals,Nc.u,sizeof(PointCoordinateType)*3);
_normals+=3;
}
}
else
{
for (unsigned n=0; n<chunkSize; n+=decimStep)
{
const CCLib::TriangleSummitsIndexes* ti = getTriangleIndexes(chunkStart + n);
memcpy(_normals,vertices->getPointNormal(ti->i1).u,sizeof(PointCoordinateType)*3);
_normals+=3;
memcpy(_normals,vertices->getPointNormal(ti->i2).u,sizeof(PointCoordinateType)*3);
_normals+=3;
memcpy(_normals,vertices->getPointNormal(ti->i3).u,sizeof(PointCoordinateType)*3);
_normals+=3;
}
}
}
if (!showWired)
{
glDrawArrays(lodEnabled ? GL_POINTS : GL_TRIANGLES,0,(chunkSize/decimStep)*3);
}
else
{
glDrawElements(GL_LINES,(chunkSize/decimStep)*6,GL_UNSIGNED_INT,GetWireVertexIndexes());
}
}
//disable arrays
glDisableClientState(GL_VERTEX_ARRAY);
if (glParams.showNorms)
glDisableClientState(GL_NORMAL_ARRAY);
if (glParams.showSF || glParams.showColors)
glDisableClientState(GL_COLOR_ARRAY);
}
else
{
//current vertex color
const colorType *col1=0,*col2=0,*col3=0;
//current vertex normal
const PointCoordinateType *N1=0,*N2=0,*N3=0;
//current vertex texture coordinates
float *Tx1=0,*Tx2=0,*Tx3=0;
//loop on all triangles
int lasMtlIndex = -1;
if (showTextures)
{
//#define TEST_TEXTURED_BUNDLER_IMPORT
#ifdef TEST_TEXTURED_BUNDLER_IMPORT
glPushAttrib(GL_COLOR_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(context.sourceBlend, context.destBlend);
#endif
glEnable(GL_TEXTURE_2D);
}
if (pushTriangleNames)
glPushName(0);
GLenum triangleDisplayType = lodEnabled ? GL_POINTS : showWired ? GL_LINE_LOOP : GL_TRIANGLES;
glBegin(triangleDisplayType);
//per-triangle normals
const NormsIndexesTableType* triNormals = getTriNormsTable();
//materials
const ccMaterialSet* materials = getMaterialSet();
for (unsigned n=0; n<triNum; ++n)
{
//current triangle vertices
const CCLib::TriangleSummitsIndexes* tsi = getTriangleIndexes(n);
//LOD: shall we display this triangle?
if (n % decimStep)
continue;
if (visFiltering)
{
//we skip the triangle if at least one vertex is hidden
if ((verticesVisibility->getValue(tsi->i1) != POINT_VISIBLE) ||
(verticesVisibility->getValue(tsi->i2) != POINT_VISIBLE) ||
(verticesVisibility->getValue(tsi->i3) != POINT_VISIBLE))
continue;
}
if (glParams.showSF)
{
assert(colorScale);
col1 = currentDisplayedScalarField->getValueColor(tsi->i1);
if (!col1)
continue;
col2 = currentDisplayedScalarField->getValueColor(tsi->i2);
if (!col2)
continue;
col3 = currentDisplayedScalarField->getValueColor(tsi->i3);
if (!col3)
continue;
}
else if (glParams.showColors)
{
col1 = rgbColorsTable->getValue(tsi->i1);
col2 = rgbColorsTable->getValue(tsi->i2);
col3 = rgbColorsTable->getValue(tsi->i3);
}
if (glParams.showNorms)
{
if (showTriNormals)
{
assert(triNormals);
int n1,n2,n3;
getTriangleNormalIndexes(n,n1,n2,n3);
N1 = (n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n1)).u : 0);
N2 = (n1==n2 ? N1 : n1>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n2)).u : 0);
N3 = (n1==n3 ? N1 : n3>=0 ? ccNormalVectors::GetNormal(triNormals->getValue(n3)).u : 0);
}
else
{
N1 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i1)).u;
N2 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i2)).u;
N3 = compressedNormals->getNormal(normalsIndexesTable->getValue(tsi->i3)).u;
}
}
if (applyMaterials || showTextures)
{
assert(materials);
int newMatlIndex = this->getTriangleMtlIndex(n);
//do we need to change material?
if (lasMtlIndex != newMatlIndex)
{
assert(newMatlIndex<(int)materials->size());
glEnd();
if (showTextures)
{
GLuint texID = (newMatlIndex>=0 ? (*materials)[newMatlIndex].texID : 0);
if (texID>0)
assert(glIsTexture(texID));
glBindTexture(GL_TEXTURE_2D, texID);
}
//if we don't have any current material, we apply default one
(newMatlIndex>=0 ? (*materials)[newMatlIndex] : context.defaultMat).applyGL(glParams.showNorms,false);
glBegin(triangleDisplayType);
lasMtlIndex=newMatlIndex;
}
if (showTextures)
{
getTriangleTexCoordinates(n,Tx1,Tx2,Tx3);
}
}
if (pushTriangleNames)
{
glEnd();
glLoadName(n);
glBegin(triangleDisplayType);
}
else if (showWired)
{
glEnd();
glBegin(triangleDisplayType);
}
//vertex 1
if (N1)
ccGL::Normal3v(N1);
if (col1)
glColor3ubv(col1);
if (Tx1)
glTexCoord2fv(Tx1);
ccGL::Vertex3v(vertices->getPoint(tsi->i1)->u);
//vertex 2
if (N2)
ccGL::Normal3v(N2);
if (col2)
glColor3ubv(col2);
if (Tx2)
glTexCoord2fv(Tx2);
ccGL::Vertex3v(vertices->getPoint(tsi->i2)->u);
//vertex 3
if (N3)
ccGL::Normal3v(N3);
if (col3)
glColor3ubv(col3);
if (Tx3)
glTexCoord2fv(Tx3);
ccGL::Vertex3v(vertices->getPoint(tsi->i3)->u);
}
glEnd();
if (pushTriangleNames)
glPopName();
if (showTextures)
{
#ifdef TEST_TEXTURED_BUNDLER_IMPORT
glPopAttrib(); //GL_COLOR_BUFFER_BIT
#endif
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
}
}
if (stipplingEnabled())
EnableGLStippleMask(false);
if (colorMaterial)
glDisable(GL_COLOR_MATERIAL);
if (glParams.showNorms)
{
glDisable(GL_LIGHTING);
glDisable((QGLFormat::openGLVersionFlags() & QGLFormat::OpenGL_Version_1_2 ? GL_RESCALE_NORMAL : GL_NORMALIZE));
}
if (pushName)
glPopName();
}
}
// Converts a CC mesh to an FBX mesh
static FbxNode* ToFbxMesh(ccGenericMesh* mesh, FbxScene* pScene)
{
if (!mesh)
return 0;
FbxMesh* lMesh = FbxMesh::Create(pScene, qPrintable(mesh->getName()));
ccGenericPointCloud* cloud = mesh->getAssociatedCloud();
if (!cloud)
return 0;
unsigned vertCount = cloud->size();
unsigned faceCount = mesh->size();
// Create control points.
{
lMesh->InitControlPoints(vertCount);
FbxVector4* lControlPoints = lMesh->GetControlPoints();
for (unsigned i=0; i<vertCount; ++i)
{
const CCVector3* P = cloud->getPoint(i);
lControlPoints[i] = FbxVector4(P->x,P->y,P->z);
}
}
ccMesh* asCCMesh = 0;
if (mesh->isA(CC_MESH))
asCCMesh = static_cast<ccMesh*>(mesh);
// normals
if (mesh->hasNormals())
{
FbxGeometryElementNormal* lGeometryElementNormal = lMesh->CreateElementNormal();
if (mesh->hasTriNormals())
{
// We want to have one normal per vertex of each polygon,
// so we set the mapping mode to eByPolygonVertex.
lGeometryElementNormal->SetMappingMode(FbxGeometryElement::eByPolygonVertex);
lGeometryElementNormal->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
lGeometryElementNormal->GetIndexArray().SetCount(faceCount*3);
if (asCCMesh)
{
NormsIndexesTableType* triNorms = asCCMesh->getTriNormsTable();
assert(triNorms);
for (unsigned i=0; i<triNorms->currentSize(); ++i)
{
const PointCoordinateType* N = ccNormalVectors::GetNormal(triNorms->getValue(i));
FbxVector4 Nfbx(N[0],N[1],N[2]);
lGeometryElementNormal->GetDirectArray().Add(Nfbx);
}
for (unsigned j=0; j<faceCount; ++j)
{
int i1,i2,i3;
asCCMesh->getTriangleNormalIndexes(j,i1,i2,i3);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+0, i1);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+1, i2);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+2, i3);
}
}
else
{
for (unsigned j=0; j<faceCount; ++j)
{
//we can't use the 'NormsIndexesTable' so we save all the normals of all the vertices
CCVector3 Na,Nb,Nc;
lGeometryElementNormal->GetDirectArray().Add(FbxVector4(Na.x,Na.y,Na.z));
lGeometryElementNormal->GetDirectArray().Add(FbxVector4(Nb.x,Nb.y,Nb.z));
lGeometryElementNormal->GetDirectArray().Add(FbxVector4(Nc.x,Nc.y,Nc.z));
mesh->getTriangleNormals(j,Na,Nb,Nc);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+0, static_cast<int>(j)*3+0);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+1, static_cast<int>(j)*3+1);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+2, static_cast<int>(j)*3+2);
}
}
}
else
{
// We want to have one normal for each vertex (or control point),
// so we set the mapping mode to eByControlPoint.
lGeometryElementNormal->SetMappingMode(FbxGeometryElement::eByControlPoint);
// The first method is to set the actual normal value
// for every control point.
lGeometryElementNormal->SetReferenceMode(FbxGeometryElement::eDirect);
for (unsigned i=0; i<vertCount; ++i)
{
const PointCoordinateType* N = cloud->getPointNormal(i);
FbxVector4 Nfbx(N[0],N[1],N[2]);
lGeometryElementNormal->GetDirectArray().Add(Nfbx);
}
}
}
else
{
ccLog::Warning("[FBX] Mesh has no normal! You can manually compute them (select it then call \"Edit > Normals > Compute\")");
}
// colors
if (cloud->hasColors())
{
FbxGeometryElementVertexColor* lGeometryElementVertexColor = lMesh->CreateElementVertexColor();
lGeometryElementVertexColor->SetMappingMode(FbxGeometryElement::eByControlPoint);
lGeometryElementVertexColor->SetReferenceMode(FbxGeometryElement::eDirect);
for (unsigned i=0; i<vertCount; ++i)
{
const colorType* C = cloud->getPointColor(i);
FbxColor col( FbxDouble3( static_cast<double>(C[0])/MAX_COLOR_COMP,
static_cast<double>(C[1])/MAX_COLOR_COMP,
static_cast<double>(C[2])/MAX_COLOR_COMP ) );
lGeometryElementVertexColor->GetDirectArray().Add(col);
}
}
// Set material mapping.
//FbxGeometryElementMaterial* lMaterialElement = lMesh->CreateElementMaterial();
//lMaterialElement->SetMappingMode(FbxGeometryElement::eByPolygon);
//lMaterialElement->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
// Create polygons. Assign material indices.
{
for (unsigned j=0; j<faceCount; ++j)
{
const CCLib::TriangleSummitsIndexes* tsi = mesh->getTriangleIndexes(j);
lMesh->BeginPolygon(static_cast<int>(j));
lMesh->AddPolygon(tsi->i1);
lMesh->AddPolygon(tsi->i2);
lMesh->AddPolygon(tsi->i3);
lMesh->EndPolygon();
}
}
FbxNode* lNode = FbxNode::Create(pScene,qPrintable(mesh->getName()));
lNode->SetNodeAttribute(lMesh);
//CreateMaterials(pScene, lMesh);
return lNode;
}
CC_FILE_ERROR ObjFilter::saveToFile(ccHObject* entity, QString filename, SaveParameters& parameters)
{
if (!entity)
return CC_FERR_BAD_ARGUMENT;
if (!entity->isKindOf(CC_TYPES::MESH))
{
ccLog::Warning("[OBJ] This filter can only save one mesh (optionally with sub-meshes) at a time!");
return CC_FERR_BAD_ENTITY_TYPE;
}
//mesh
ccGenericMesh* mesh = ccHObjectCaster::ToGenericMesh(entity);
if (!mesh || mesh->size() == 0)
{
ccLog::Warning("[OBJ] Input mesh is empty!");
return CC_FERR_NO_SAVE;
}
//vertices
ccGenericPointCloud* vertices = mesh->getAssociatedCloud();
if (!vertices || vertices->size() == 0)
{
ccLog::Warning("[OBJ] Input mesh has no vertices?!");
return CC_FERR_NO_SAVE;
}
unsigned nbPoints = vertices->size();
//try to open file for saving
QFile file(filename);
if (!file.open(QFile::Text | QFile::WriteOnly))
return CC_FERR_WRITING;
//progress
ccProgressDialog pdlg(true);
unsigned numberOfTriangles = mesh->size();
CCLib::NormalizedProgress nprogress(&pdlg,numberOfTriangles);
pdlg.setMethodTitle(qPrintable(QString("Saving mesh [%1]").arg(mesh->getName())));
pdlg.setInfo(qPrintable(QString("Triangles: %1").arg(numberOfTriangles)));
pdlg.start();
QTextStream stream(&file);
stream.setRealNumberPrecision(sizeof(PointCoordinateType) == 4 ? 8 : 12);
stream << "#OBJ Generated by CloudCompare (TELECOM PARISTECH/EDF R&D)" << endl;
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
for (unsigned i=0; i<nbPoints; ++i)
{
const CCVector3* P = vertices->getPoint(i);
CCVector3d Pglobal = vertices->toGlobal3d<PointCoordinateType>(*P);
stream << "v " << Pglobal.x << " " << Pglobal.y << " " << Pglobal.z << endl;
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
}
//normals
bool withTriNormals = mesh->hasTriNormals();
bool withVertNormals = vertices->hasNormals();
bool withNormals = withTriNormals || withVertNormals;
if (withNormals)
{
//per-triangle normals
if (withTriNormals)
{
NormsIndexesTableType* normsTable = mesh->getTriNormsTable();
if (normsTable)
{
for (unsigned i=0; i<normsTable->currentSize(); ++i)
{
const CCVector3& normalVec = ccNormalVectors::GetNormal(normsTable->getValue(i));
stream << "vn " << normalVec.x << " " << normalVec.y << " " << normalVec.z << endl;
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
}
}
else
{
assert(false);
withTriNormals = false;
}
}
//per-vertices normals
else //if (withVertNormals)
{
for (unsigned i=0; i<nbPoints; ++i)
{
const CCVector3& normalVec = vertices->getPointNormal(i);
stream << "vn " << normalVec.x << " " << normalVec.y << " " << normalVec.z << endl;
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
}
}
}
//materials
const ccMaterialSet* materials = mesh->getMaterialSet();
bool withMaterials = (materials && mesh->hasMaterials());
if (withMaterials)
{
//save mtl file
QStringList errors;
QString baseName = QFileInfo(filename).baseName();
if (materials->saveAsMTL(QFileInfo(filename).absolutePath(),baseName,errors))
{
stream << "mtllib " << baseName << ".mtl" << endl;
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
}
else
{
materials = 0;
withMaterials = false;
}
//display potential 'errors'
for (int i=0; i<errors.size(); ++i)
{
ccLog::Warning(QString("[OBJ][Material file writer] ")+errors[i]);
}
}
//save texture coordinates
bool withTexCoordinates = withMaterials && mesh->hasPerTriangleTexCoordIndexes();
if (withTexCoordinates)
{
TextureCoordsContainer* texCoords = mesh->getTexCoordinatesTable();
if (texCoords)
{
for (unsigned i=0; i<texCoords->currentSize(); ++i)
{
const float* tc = texCoords->getValue(i);
stream << "vt " << tc[0] << " " << tc[1] << endl;
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
}
}
else
{
withTexCoordinates = false;
}
}
ccHObject::Container subMeshes;
//look for sub-meshes
mesh->filterChildren(subMeshes,false,CC_TYPES::SUB_MESH);
//check that the number of facets is the same as the full mesh!
{
unsigned faceCount = 0;
for (ccHObject::Container::const_iterator it = subMeshes.begin(); it != subMeshes.end(); ++it)
faceCount += static_cast<ccSubMesh*>(*it)->size();
//if there's no face (i.e. no sub-mesh) or less face than the total mesh, we save the full mesh!
if (faceCount < mesh->size())
{
subMeshes.clear();
subMeshes.push_back(mesh);
}
}
//mesh or sub-meshes
unsigned indexShift = 0;
for (ccHObject::Container::const_iterator it = subMeshes.begin(); it != subMeshes.end(); ++it)
{
ccGenericMesh* st = static_cast<ccGenericMesh*>(*it);
stream << "g " << (st->getName().isNull() ? "mesh" : st->getName()) << endl;
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
unsigned triNum = st->size();
st->placeIteratorAtBegining();
int lastMtlIndex = -1;
int t1 = -1, t2 = -1, t3 = -1;
for (unsigned i=0; i<triNum; ++i)
{
if (withMaterials)
{
int mtlIndex = mesh->getTriangleMtlIndex(indexShift+i);
if (mtlIndex != lastMtlIndex)
{
if (mtlIndex >= 0 && mtlIndex < static_cast<int>(materials->size()))
{
ccMaterial::CShared mat = materials->at(mtlIndex);
stream << "usemtl " << mat->getName() << endl;
}
else
{
stream << "usemtl " << endl;
}
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
lastMtlIndex = mtlIndex;
}
if (withTexCoordinates)
{
mesh->getTriangleTexCoordinatesIndexes(indexShift+i,t1,t2,t3);
if (t1 >= 0) ++t1;
if (t2 >= 0) ++t2;
if (t3 >= 0) ++t3;
}
}
const CCLib::VerticesIndexes* tsi = st->getNextTriangleVertIndexes();
//for per-triangle normals
unsigned i1 = tsi->i1 + 1;
unsigned i2 = tsi->i2 + 1;
unsigned i3 = tsi->i3 + 1;
stream << "f";
if (withNormals)
{
int n1 = static_cast<int>(i1);
int n2 = static_cast<int>(i2);
int n3 = static_cast<int>(i3);
if (withTriNormals)
{
st->getTriangleNormalIndexes(i,n1,n2,n3);
if (n1 >= 0) ++n1;
if (n2 >= 0) ++n2;
if (n3 >= 0) ++n3;
}
if (withTexCoordinates)
{
stream << " " << i1 << "/" << t1 << "/" << n1;
stream << " " << i2 << "/" << t2 << "/" << n2;
stream << " " << i3 << "/" << t3 << "/" << n3;
}
else
{
stream << " " << i1 << "//" << n1;
stream << " " << i2 << "//" << n2;
stream << " " << i3 << "//" << n3;
}
}
else
{
if (withTexCoordinates)
{
stream << " " << i1 << "/" << t1;
stream << " " << i2 << "/" << t2;
stream << " " << i3 << "/" << t3;
}
else
{
stream << " " << i1;
stream << " " << i2;
stream << " " << i3;
}
}
stream << endl;
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
if (!nprogress.oneStep()) //cancel requested
return CC_FERR_CANCELED_BY_USER;
}
stream << "#" << triNum << " faces" << endl;
if (file.error() != QFile::NoError)
return CC_FERR_WRITING;
indexShift += triNum;
}
return CC_FERR_NO_ERROR;
}
// Converts a CC mesh to an FBX mesh
static FbxNode* ToFbxMesh(ccGenericMesh* mesh, FbxScene* pScene, QString filename, size_t meshIndex)
{
if (!mesh)
return 0;
FbxNode* lNode = FbxNode::Create(pScene,qPrintable(mesh->getName()));
FbxMesh* lMesh = FbxMesh::Create(pScene, qPrintable(mesh->getName()));
lNode->SetNodeAttribute(lMesh);
ccGenericPointCloud* cloud = mesh->getAssociatedCloud();
if (!cloud)
return 0;
unsigned vertCount = cloud->size();
unsigned faceCount = mesh->size();
// Create control points.
{
lMesh->InitControlPoints(vertCount);
FbxVector4* lControlPoints = lMesh->GetControlPoints();
for (unsigned i=0; i<vertCount; ++i)
{
const CCVector3* P = cloud->getPoint(i);
lControlPoints[i] = FbxVector4(P->x,P->y,P->z);
//lControlPoints[i] = FbxVector4(P->x,P->z,-P->y); //DGM: see loadFile (Y and Z are inverted)
}
}
ccMesh* asCCMesh = 0;
if (mesh->isA(CC_TYPES::MESH))
asCCMesh = static_cast<ccMesh*>(mesh);
// normals
if (mesh->hasNormals())
{
FbxGeometryElementNormal* lGeometryElementNormal = lMesh->CreateElementNormal();
if (mesh->hasTriNormals())
{
// We want to have one normal per vertex of each polygon,
// so we set the mapping mode to eByPolygonVertex.
lGeometryElementNormal->SetMappingMode(FbxGeometryElement::eByPolygonVertex);
lGeometryElementNormal->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
lGeometryElementNormal->GetIndexArray().SetCount(faceCount*3);
if (asCCMesh)
{
NormsIndexesTableType* triNorms = asCCMesh->getTriNormsTable();
assert(triNorms);
for (unsigned i=0; i<triNorms->currentSize(); ++i)
{
const CCVector3& N = ccNormalVectors::GetNormal(triNorms->getValue(i));
FbxVector4 Nfbx(N.x,N.y,N.z);
lGeometryElementNormal->GetDirectArray().Add(Nfbx);
}
for (unsigned j=0; j<faceCount; ++j)
{
int i1,i2,i3;
asCCMesh->getTriangleNormalIndexes(j,i1,i2,i3);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+0, i1);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+1, i2);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+2, i3);
}
}
else
{
for (unsigned j=0; j<faceCount; ++j)
{
//we can't use the 'NormsIndexesTable' so we save all the normals of all the vertices
CCVector3 Na,Nb,Nc;
lGeometryElementNormal->GetDirectArray().Add(FbxVector4(Na.x,Na.y,Na.z));
lGeometryElementNormal->GetDirectArray().Add(FbxVector4(Nb.x,Nb.y,Nb.z));
lGeometryElementNormal->GetDirectArray().Add(FbxVector4(Nc.x,Nc.y,Nc.z));
mesh->getTriangleNormals(j,Na,Nb,Nc);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+0, static_cast<int>(j)*3+0);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+1, static_cast<int>(j)*3+1);
lGeometryElementNormal->GetIndexArray().SetAt(static_cast<int>(j)*3+2, static_cast<int>(j)*3+2);
}
}
}
else
{
// We want to have one normal for each vertex (or control point),
// so we set the mapping mode to eByControlPoint.
lGeometryElementNormal->SetMappingMode(FbxGeometryElement::eByControlPoint);
// The first method is to set the actual normal value
// for every control point.
lGeometryElementNormal->SetReferenceMode(FbxGeometryElement::eDirect);
for (unsigned i=0; i<vertCount; ++i)
{
const CCVector3& N = cloud->getPointNormal(i);
FbxVector4 Nfbx(N.x,N.y,N.z);
lGeometryElementNormal->GetDirectArray().Add(Nfbx);
}
}
}
else
{
ccLog::Warning("[FBX] Mesh has no normal! You can manually compute them (select it then call \"Edit > Normals > Compute\")");
}
// Set material mapping.
bool hasMaterial = false;
if (asCCMesh && asCCMesh->hasMaterials())
{
const ccMaterialSet* matSet = asCCMesh->getMaterialSet();
size_t matCount = matSet->size();
//check if we have textures
bool hasTextures = asCCMesh->hasTextures();
if (hasTextures)
{
//check that we actually have materials with textures as well!
hasTextures = false;
for (size_t i=0; i<matCount; ++i)
{
ccMaterial::CShared mat = matSet->at(i);
if (mat->hasTexture())
{
hasTextures = true;
break;
}
}
}
static const char gDiffuseElementName[] = "DiffuseUV";
// Create UV for Diffuse channel
if (hasTextures)
{
FbxGeometryElementUV* lUVDiffuseElement = lMesh->CreateElementUV(gDiffuseElementName);
assert(lUVDiffuseElement != 0);
lUVDiffuseElement->SetMappingMode(FbxGeometryElement::eByPolygonVertex);
lUVDiffuseElement->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
//fill Direct Array
const TextureCoordsContainer* texCoords = asCCMesh->getTexCoordinatesTable();
assert(texCoords);
if (texCoords)
{
unsigned count = texCoords->currentSize();
lUVDiffuseElement->GetDirectArray().SetCount(static_cast<int>(count));
for (unsigned i=0; i<count; ++i)
{
const float* uv = texCoords->getValue(i);
lUVDiffuseElement->GetDirectArray().SetAt(i,FbxVector2(uv[0],uv[1]));
}
}
//fill Indexes Array
assert(asCCMesh->hasPerTriangleTexCoordIndexes());
if (asCCMesh->hasPerTriangleTexCoordIndexes())
{
unsigned triCount = asCCMesh->size();
lUVDiffuseElement->GetIndexArray().SetCount(static_cast<int>(3*triCount));
for (unsigned j=0; j<triCount; ++j)
{
int t1=0, t2=0, t3=0;
asCCMesh->getTriangleTexCoordinatesIndexes(j, t1, t2, t3);
lUVDiffuseElement->GetIndexArray().SetAt(j*3+0,t1);
lUVDiffuseElement->GetIndexArray().SetAt(j*3+1,t2);
lUVDiffuseElement->GetIndexArray().SetAt(j*3+2,t3);
}
}
}
//Textures used in this file
QMap<QString,QString> texFilenames;
//directory to save textures (if any)
QFileInfo info(filename);
QString textDirName = info.baseName() + QString(".fbm");
QDir baseDir = info.absoluteDir();
QDir texDir = QDir(baseDir.absolutePath() + QString("/") + textDirName);
for (size_t i=0; i<matCount; ++i)
{
ccMaterial::CShared mat = matSet->at(i);
FbxSurfacePhong *lMaterial = FbxSurfacePhong::Create(pScene, qPrintable(mat->getName()));
const ccColor::Rgbaf& emission = mat->getEmission();
const ccColor::Rgbaf& ambient = mat->getAmbient();
const ccColor::Rgbaf& diffuse = mat->getDiffuseFront();
const ccColor::Rgbaf& specular = mat->getDiffuseFront();
lMaterial->Emissive.Set(FbxDouble3(emission.r,emission.g,emission.b));
lMaterial->Ambient .Set(FbxDouble3( ambient.r, ambient.g, ambient.b));
lMaterial->Diffuse .Set(FbxDouble3( diffuse.r, diffuse.g, diffuse.b));
lMaterial->Specular.Set(FbxDouble3(specular.r,specular.g,specular.b));
lMaterial->Shininess = mat->getShininessFront();
lMaterial->ShadingModel.Set("Phong");
if (hasTextures && mat->hasTexture())
{
QString texFilename = mat->getTextureFilename();
//texture has not already been processed
if (!texFilenames.contains(texFilename))
{
//if necessary, we (try to) create a subfolder to store textures
if (!texDir.exists())
{
texDir = baseDir;
if (texDir.mkdir(textDirName))
{
texDir.cd(textDirName);
}
else
{
textDirName = QString();
ccLog::Warning("[FBX] Failed to create subfolder '%1' to store texture files (files will be stored next to the .fbx file)");
}
}
QFileInfo fileInfo(texFilename);
QString baseTexName = fileInfo.fileName();
//add extension
QString extension = QFileInfo(texFilename).suffix();
if (fileInfo.suffix().isEmpty())
baseTexName += QString(".png");
QString absoluteFilename = texDir.absolutePath() + QString("/") + baseTexName;
ccLog::PrintDebug(QString("[FBX] Material '%1' texture: %2").arg(mat->getName()).arg(absoluteFilename));
texFilenames[texFilename] = absoluteFilename;
}
//mat.texture.save(absoluteFilename);
// Set texture properties.
FbxFileTexture* lTexture = FbxFileTexture::Create(pScene,"DiffuseTexture");
assert(!texFilenames[texFilename].isEmpty());
lTexture->SetFileName(qPrintable(texFilenames[texFilename]));
lTexture->SetTextureUse(FbxTexture::eStandard);
lTexture->SetMappingType(FbxTexture::eUV);
lTexture->SetMaterialUse(FbxFileTexture::eModelMaterial);
lTexture->SetSwapUV(false);
lTexture->SetTranslation(0.0, 0.0);
lTexture->SetScale(1.0, 1.0);
lTexture->SetRotation(0.0, 0.0);
lTexture->UVSet.Set(FbxString(gDiffuseElementName)); // Connect texture to the proper UV
// don't forget to connect the texture to the corresponding property of the material
lMaterial->Diffuse.ConnectSrcObject(lTexture);
}
int matIndex = lNode->AddMaterial(lMaterial);
assert(matIndex == static_cast<int>(i));
}
//don't forget to save the texture files
{
for (QMap<QString,QString>::ConstIterator it = texFilenames.begin(); it != texFilenames.end(); ++it)
{
const QImage image = ccMaterial::GetTexture(it.key());
image.mirrored().save(it.value());
}
texFilenames.clear(); //don't need this anymore!
}
// Create 'triangle to material index' mapping
{
FbxGeometryElementMaterial* lMaterialElement = lMesh->CreateElementMaterial();
lMaterialElement->SetMappingMode(FbxGeometryElement::eByPolygon);
lMaterialElement->SetReferenceMode(FbxGeometryElement::eIndexToDirect);
}
hasMaterial = true;
}
// colors
if (cloud->hasColors())
{
FbxGeometryElementVertexColor* lGeometryElementVertexColor = lMesh->CreateElementVertexColor();
lGeometryElementVertexColor->SetMappingMode(FbxGeometryElement::eByControlPoint);
lGeometryElementVertexColor->SetReferenceMode(FbxGeometryElement::eDirect);
lGeometryElementVertexColor->GetDirectArray().SetCount(vertCount);
for (unsigned i=0; i<vertCount; ++i)
{
const colorType* C = cloud->getPointColor(i);
FbxColor col( static_cast<double>(C[0])/ccColor::MAX,
static_cast<double>(C[1])/ccColor::MAX,
static_cast<double>(C[2])/ccColor::MAX );
lGeometryElementVertexColor->GetDirectArray().SetAt(i,col);
}
if (!hasMaterial)
{
//it seems that we have to create a fake material in order for the colors to be displayed (in Unity and FBX Review at least)!
FbxSurfacePhong *lMaterial = FbxSurfacePhong::Create(pScene, "ColorMaterial");
lMaterial->Emissive.Set(FbxDouble3(0,0,0));
lMaterial->Ambient.Set(FbxDouble3(0,0,0));
lMaterial->Diffuse.Set(FbxDouble3(1,1,1));
lMaterial->Specular.Set(FbxDouble3(0,0,0));
lMaterial->Shininess = 0;
lMaterial->ShadingModel.Set("Phong");
FbxGeometryElementMaterial* lMaterialElement = lMesh->CreateElementMaterial();
lMaterialElement->SetMappingMode(FbxGeometryElement::eAllSame);
lMaterialElement->SetReferenceMode(FbxGeometryElement::eDirect);
lNode->AddMaterial(lMaterial);
}
}
// Create polygons
{
for (unsigned j=0; j<faceCount; ++j)
{
const CCLib::TriangleSummitsIndexes* tsi = mesh->getTriangleIndexes(j);
int matIndex = hasMaterial ? asCCMesh->getTriangleMtlIndex(j) : -1;
lMesh->BeginPolygon(matIndex);
lMesh->AddPolygon(tsi->i1);
lMesh->AddPolygon(tsi->i2);
lMesh->AddPolygon(tsi->i3);
lMesh->EndPolygon();
}
}
return lNode;
}
