417 lines
9.8 KiB
C++
417 lines
9.8 KiB
C++
#include "BlenderFileLoader.h"
|
|
|
|
BlenderFileLoader::BlenderFileLoader(Render *re, SceneRenderLayer* srl)
|
|
{
|
|
_re = re;
|
|
_srl = srl;
|
|
_Scene = NULL;
|
|
_numFacesRead = 0;
|
|
_minEdgeSize = DBL_MAX;
|
|
}
|
|
|
|
BlenderFileLoader::~BlenderFileLoader()
|
|
{
|
|
_Scene = NULL;
|
|
}
|
|
|
|
NodeGroup* BlenderFileLoader::Load()
|
|
{
|
|
ObjectInstanceRen *obi;
|
|
ObjectRen *obr;
|
|
|
|
cout << "\n=== Importing triangular meshes into Blender ===" << endl;
|
|
|
|
// creation of the scene root node
|
|
_Scene = new NodeGroup;
|
|
|
|
int id = 0;
|
|
for(obi= (ObjectInstanceRen *) _re->instancetable.first; obi; obi=obi->next) {
|
|
if (!(obi->lay & _re->scene->lay & _srl->lay))
|
|
continue;
|
|
|
|
obr= obi->obr;
|
|
|
|
if( obr->totvlak > 0)
|
|
insertShapeNode(obr, ++id);
|
|
else
|
|
cout << " Sorry, only vlak-based shapes are supported." << endl;
|
|
}
|
|
|
|
//Returns the built scene.
|
|
return _Scene;
|
|
}
|
|
|
|
void BlenderFileLoader::insertShapeNode(ObjectRen *obr, int id)
|
|
{
|
|
VlakRen *vlr;
|
|
|
|
float minBBox[3];
|
|
float maxBBox[3];
|
|
|
|
NodeTransform *currentMesh = new NodeTransform;
|
|
NodeShape * shape;
|
|
|
|
// Mesh *mesh = (Mesh *)ob->data;
|
|
//---------------------
|
|
// mesh => obr
|
|
|
|
// builds the shape:
|
|
shape = new NodeShape;
|
|
|
|
// We invert the matrix in order to be able to retrieve the shape's coordinates in its local coordinates system (origin is the iNode pivot)
|
|
// Lib3dsMatrix M;
|
|
// lib3ds_matrix_copy(M, mesh->matrix);
|
|
// lib3ds_matrix_inv(M);
|
|
//---------------------
|
|
// M allows to recover world coordinates from camera coordinates
|
|
// M => obr->ob->imat * obr->obmat (multiplication from left to right)
|
|
float M[4][4];
|
|
Mat4MulMat4(M, obr->ob->imat, obr->ob->obmat);
|
|
|
|
// We compute a normal per vertex and manages the smoothing of the shape:
|
|
// Lib3dsVector *normalL=(Lib3dsVector*)malloc(3*sizeof(Lib3dsVector)*mesh->faces);
|
|
// lib3ds_mesh_calculate_normals(mesh, normalL);
|
|
// mesh_calc_normals(mesh->mvert, mesh->totvert, mesh->mface, mesh->totface, NULL);
|
|
//---------------------
|
|
// already calculated and availabe in vlak ?
|
|
|
|
// We build the rep:
|
|
IndexedFaceSet *rep;
|
|
unsigned numFaces = 0;
|
|
for(int a=0; a < obr->totvlak; a++) {
|
|
if((a & 255)==0) vlr= obr->vlaknodes[a>>8].vlak;
|
|
else vlr++;
|
|
|
|
if(vlr->v4)
|
|
numFaces += 2;
|
|
else
|
|
numFaces++;
|
|
}
|
|
|
|
unsigned vSize = 3*3*numFaces;
|
|
float *vertices = new float[vSize];
|
|
unsigned nSize = vSize;
|
|
float *normals = new float[nSize];
|
|
unsigned *numVertexPerFaces = new unsigned[numFaces];
|
|
vector<FrsMaterial> meshFrsMaterials;
|
|
|
|
IndexedFaceSet::TRIANGLES_STYLE *faceStyle = new IndexedFaceSet::TRIANGLES_STYLE[numFaces];
|
|
unsigned i;
|
|
for (i = 0; i <numFaces; i++) {
|
|
faceStyle[i] = IndexedFaceSet::TRIANGLES;
|
|
numVertexPerFaces[i] = 3;
|
|
}
|
|
|
|
unsigned viSize = 3*numFaces;
|
|
unsigned *VIndices = new unsigned[viSize];
|
|
unsigned niSize = viSize;
|
|
unsigned *NIndices = new unsigned[niSize];
|
|
unsigned *MIndices = new unsigned[viSize]; // Material Indices
|
|
|
|
|
|
float *pv = vertices;
|
|
float *pn = normals;
|
|
unsigned *pvi = VIndices;
|
|
unsigned *pni = NIndices;
|
|
unsigned *pmi = MIndices;
|
|
|
|
unsigned currentIndex = 0;
|
|
unsigned currentMIndex = 0;
|
|
|
|
FrsMaterial tmpMat;
|
|
|
|
// we want to find the min and max coordinates as we build the rep.
|
|
// We initialize the min and max values whith the first vertex.
|
|
//lib3ds_vector_transform(pvtmp, M, mesh->pointL[mesh->faceL[0].points[0]].pos);
|
|
float pvtmp[3];
|
|
pvtmp[0] = obr->vertnodes[0].vert->co[0];
|
|
pvtmp[1] = obr->vertnodes[0].vert->co[1];
|
|
pvtmp[2] = obr->vertnodes[0].vert->co[2];
|
|
|
|
Mat4MulVecfl( M, pvtmp);
|
|
|
|
minBBox[0] = pvtmp[0];
|
|
maxBBox[0] = pvtmp[0];
|
|
minBBox[1] = pvtmp[1];
|
|
maxBBox[1] = pvtmp[1];
|
|
minBBox[2] = pvtmp[2];
|
|
maxBBox[2] = pvtmp[2];
|
|
|
|
int p;
|
|
real vert[3][3];
|
|
real norm;
|
|
for(p=0; p < obr->totvlak; ++p) // we parse the faces of the mesh
|
|
{
|
|
VertRen * fv[3];
|
|
|
|
// Lib3dsFace *f=&mesh->faceL[p];
|
|
// Lib3dsMaterial *mat=0;
|
|
if((p & 255)==0) vlr = obr->vlaknodes[p>>8].vlak;
|
|
else vlr++;
|
|
Material *mat = vlr->mat;
|
|
|
|
if (mat)
|
|
{
|
|
tmpMat.setDiffuse( mat->r, mat->g, mat->b, mat->alpha );
|
|
tmpMat.setSpecular( mat->specr, mat->specg, mat->specb, mat->spectra);
|
|
float s = 1.0 * (mat->har + 1) / 4 ; // in Blender: [1;511] => in OpenGL: [0;128]
|
|
if(s > 128.f)
|
|
s = 128.f;
|
|
tmpMat.setShininess(s);
|
|
}
|
|
|
|
if(meshFrsMaterials.empty())
|
|
{
|
|
meshFrsMaterials.push_back(tmpMat);
|
|
shape->setFrsMaterial(tmpMat);
|
|
} else {
|
|
// find if the material is aleady in the list
|
|
unsigned i=0;
|
|
bool found = false;
|
|
|
|
for(vector<FrsMaterial>::iterator it=meshFrsMaterials.begin(), itend=meshFrsMaterials.end();
|
|
it!=itend;
|
|
++it){
|
|
if(*it == tmpMat){
|
|
currentMIndex = i;
|
|
found = true;
|
|
break;
|
|
}
|
|
++i;
|
|
}
|
|
|
|
if(!found){
|
|
meshFrsMaterials.push_back(tmpMat);
|
|
currentMIndex = meshFrsMaterials.size()-1;
|
|
}
|
|
}
|
|
|
|
unsigned j;
|
|
fv[0] = vlr->v1;
|
|
fv[1] = vlr->v2;
|
|
fv[2] = vlr->v3;
|
|
float *pv_ptr[3];
|
|
for(i=0; i<3; ++i) // we parse the vertices of the face f
|
|
{
|
|
|
|
//lib3ds_vector_transform(pv, M, mesh->pointL[f->points[i]].pos); //fills the cells of the pv array
|
|
for(j=0; j<3; j++)
|
|
pv[j] = fv[i]->co[j];
|
|
Mat4MulVecfl( M, pv);
|
|
|
|
for(j=0; j<3; j++) // we parse the xyz coordinates of the vertex i
|
|
{
|
|
if(minBBox[j] > pv[j])
|
|
minBBox[j] = pv[j];
|
|
|
|
if(maxBBox[j] < pv[j])
|
|
maxBBox[j] = pv[j];
|
|
|
|
vert[i][j] = pv[j];
|
|
}
|
|
|
|
pv_ptr[i] = pv;
|
|
*pvi = currentIndex;
|
|
*pmi = currentMIndex;
|
|
|
|
currentIndex +=3;
|
|
pv += 3;
|
|
|
|
pvi++;
|
|
pmi++;
|
|
}
|
|
|
|
currentIndex -= 9;
|
|
|
|
float vec01[3];
|
|
vec01[0] = pv_ptr[1][0] - pv_ptr[0][0];
|
|
vec01[1] = pv_ptr[1][1] - pv_ptr[0][1];
|
|
vec01[2] = pv_ptr[1][2] - pv_ptr[0][2];
|
|
|
|
float vec02[3];
|
|
vec02[0] = pv_ptr[2][0] - pv_ptr[0][0];
|
|
vec02[1] = pv_ptr[2][1] - pv_ptr[0][1];
|
|
vec02[2] = pv_ptr[2][2] - pv_ptr[0][2];
|
|
|
|
float n[3];
|
|
Crossf(n, vec01, vec02);
|
|
Normalize(n);
|
|
|
|
for(i=0; i<3; ++i) {
|
|
for(j=0; j<3; ++j) {
|
|
pn[j] = n[j];
|
|
}
|
|
*pni = currentIndex;
|
|
|
|
pn += 3;
|
|
pni++;
|
|
|
|
currentIndex +=3;
|
|
}
|
|
|
|
for(i=0; i<3; i++)
|
|
{
|
|
norm = 0.0;
|
|
|
|
for (unsigned j = 0; j < 3; j++)
|
|
norm += (vert[i][j] - vert[(i+1)%3][j])*(vert[i][j] - vert[(i+1)%3][j]);
|
|
|
|
norm = sqrt(norm);
|
|
if(_minEdgeSize > norm)
|
|
_minEdgeSize = norm;
|
|
}
|
|
|
|
++_numFacesRead;
|
|
|
|
|
|
if(vlr->v4){
|
|
|
|
unsigned j;
|
|
fv[0] = vlr->v1;
|
|
fv[1] = vlr->v3;
|
|
fv[2] = vlr->v4;
|
|
float *pv_ptr[3];
|
|
for(i=0; i<3; ++i) // we parse the vertices of the face f
|
|
{
|
|
|
|
//lib3ds_vector_transform(pv, M, mesh->pointL[f->points[i]].pos); //fills the cells of the pv array
|
|
for(j=0; j<3; j++)
|
|
pv[j] = fv[i]->co[j];
|
|
Mat4MulVecfl( M, pv);
|
|
|
|
for(j=0; j<3; j++) // we parse the xyz coordinates of the vertex i
|
|
{
|
|
if(minBBox[j] > pv[j])
|
|
minBBox[j] = pv[j];
|
|
|
|
if(maxBBox[j] < pv[j])
|
|
maxBBox[j] = pv[j];
|
|
|
|
vert[i][j] = pv[j];
|
|
}
|
|
|
|
pv_ptr[i] = pv;
|
|
*pvi = currentIndex;
|
|
*pmi = currentMIndex;
|
|
|
|
currentIndex +=3;
|
|
pv += 3;
|
|
|
|
pvi++;
|
|
pmi++;
|
|
}
|
|
|
|
currentIndex -= 9;
|
|
|
|
float vec01[3];
|
|
vec01[0] = pv_ptr[1][0] - pv_ptr[0][0];
|
|
vec01[1] = pv_ptr[1][1] - pv_ptr[0][1];
|
|
vec01[2] = pv_ptr[1][2] - pv_ptr[0][2];
|
|
|
|
float vec02[3];
|
|
vec02[0] = pv_ptr[2][0] - pv_ptr[0][0];
|
|
vec02[1] = pv_ptr[2][1] - pv_ptr[0][1];
|
|
vec02[2] = pv_ptr[2][2] - pv_ptr[0][2];
|
|
|
|
float n[3];
|
|
Crossf(n, vec01, vec02);
|
|
Normalize(n);
|
|
|
|
for(i=0; i<3; ++i) {
|
|
for(j=0; j<3; ++j) {
|
|
pn[j] = n[j];
|
|
}
|
|
*pni = currentIndex;
|
|
|
|
pn += 3;
|
|
pni++;
|
|
|
|
currentIndex +=3;
|
|
}
|
|
|
|
for(i=0; i<3; i++)
|
|
{
|
|
norm = 0.0;
|
|
|
|
for (unsigned j = 0; j < 3; j++)
|
|
norm += (vert[i][j] - vert[(i+1)%3][j])*(vert[i][j] - vert[(i+1)%3][j]);
|
|
|
|
norm = sqrt(norm);
|
|
if(_minEdgeSize > norm)
|
|
_minEdgeSize = norm;
|
|
}
|
|
|
|
++_numFacesRead;
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// We might have several times the same vertex. We want a clean
|
|
// shape with no real-vertex. Here, we are making a cleaning
|
|
// pass.
|
|
real *cleanVertices = NULL;
|
|
unsigned cvSize;
|
|
unsigned *cleanVIndices = NULL;
|
|
|
|
GeomCleaner::CleanIndexedVertexArray(
|
|
vertices, vSize,
|
|
VIndices, viSize,
|
|
&cleanVertices, &cvSize,
|
|
&cleanVIndices);
|
|
|
|
real *cleanNormals = NULL;
|
|
unsigned cnSize;
|
|
unsigned *cleanNIndices = NULL;
|
|
|
|
GeomCleaner::CleanIndexedVertexArray(
|
|
normals, nSize,
|
|
NIndices, niSize,
|
|
&cleanNormals, &cnSize,
|
|
&cleanNIndices);
|
|
|
|
// format materials array
|
|
FrsMaterial** marray = new FrsMaterial*[meshFrsMaterials.size()];
|
|
unsigned mindex=0;
|
|
for(vector<FrsMaterial>::iterator m=meshFrsMaterials.begin(), mend=meshFrsMaterials.end();
|
|
m!=mend;
|
|
++m){
|
|
marray[mindex] = new FrsMaterial(*m);
|
|
++mindex;
|
|
}
|
|
// deallocates memory:
|
|
delete [] vertices;
|
|
delete [] normals;
|
|
delete [] VIndices;
|
|
delete [] NIndices;
|
|
|
|
// Create the IndexedFaceSet with the retrieved attributes
|
|
rep = new IndexedFaceSet(cleanVertices, cvSize,
|
|
cleanNormals, cnSize,
|
|
marray, meshFrsMaterials.size(),
|
|
0, 0,
|
|
numFaces, numVertexPerFaces, faceStyle,
|
|
cleanVIndices, viSize,
|
|
cleanNIndices, niSize,
|
|
MIndices, viSize,
|
|
0,0,
|
|
0);
|
|
// sets the id of the rep
|
|
rep->setId(Id(id, 0));
|
|
|
|
const BBox<Vec3r> bbox = BBox<Vec3r>(Vec3r(minBBox[0], minBBox[1], minBBox[2]),
|
|
Vec3r(maxBBox[0], maxBBox[1], maxBBox[2]));
|
|
rep->setBBox(bbox);
|
|
shape->AddRep(rep);
|
|
|
|
Matrix44r meshMat = Matrix44r::identity();
|
|
currentMesh->setMatrix(meshMat);
|
|
currentMesh->Translate(0,0,0);
|
|
|
|
currentMesh->AddChild(shape);
|
|
_Scene->AddChild(currentMesh);
|
|
|
|
}
|