7426a3e35b
IMPORTANT: The setters functions' names were normalized due to constant confusion regarding capitalization. All the function names start with set... instead of Set.... This convention was changed all throughout Freestyle. To use Freestyle as an external renderer, the SWIG library MUST be regenerated.
1246 lines
28 KiB
C++
Executable File
1246 lines
28 KiB
C++
Executable File
|
|
//
|
|
// Copyright (C) : Please refer to the COPYRIGHT file distributed
|
|
// with this source distribution.
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; either version 2
|
|
// of the License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "ViewMapIO.h"
|
|
|
|
#ifdef IRIX
|
|
# define WRITE(n) Internal::write<sizeof((n))>(out, (const char*)(&(n)))
|
|
# define READ(n) Internal::read<sizeof((n))>(in, (char*)(&(n)))
|
|
#else
|
|
# define WRITE(n) out.write((const char*)(&(n)), sizeof((n)))
|
|
# define READ(n) in.read((char*)(&(n)), sizeof((n)))
|
|
#endif
|
|
|
|
#define WRITE_IF_NON_NULL(ptr) if ((ptr) == NULL) { WRITE(ZERO); } else { WRITE((ptr)->userdata); }
|
|
#define READ_IF_NON_NULL(ptr, array) READ(tmp); if (tmp == ZERO) { (ptr) = NULL; } else { (ptr) = (array)[tmp]; }
|
|
|
|
namespace ViewMapIO {
|
|
|
|
namespace Internal {
|
|
|
|
ViewMap* g_vm;
|
|
|
|
//////////////////// 'load' Functions ////////////////////
|
|
|
|
inline
|
|
int load(istream& in, Vec3r& v) {
|
|
|
|
if (Options::getFlags() & Options::FLOAT_VECTORS) {
|
|
float tmp;
|
|
READ(tmp);
|
|
v[0] = tmp;
|
|
READ(tmp);
|
|
v[1] = tmp;
|
|
READ(tmp);
|
|
v[2] = tmp;
|
|
} else {
|
|
Vec3r::value_type tmp;
|
|
READ(tmp);
|
|
v[0] = tmp;
|
|
READ(tmp);
|
|
v[1] = tmp;
|
|
READ(tmp);
|
|
v[2] = tmp;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
inline
|
|
int load(istream& in, Polygon3r& p) {
|
|
|
|
unsigned tmp;
|
|
|
|
// Id
|
|
READ(tmp);
|
|
p.setId(tmp);
|
|
|
|
// vertices (List)
|
|
vector<Vec3r> tmp_vec;
|
|
Vec3r v;
|
|
READ(tmp);
|
|
for (unsigned i = 0; i < tmp; i++) {
|
|
load(in, v);
|
|
tmp_vec.push_back(v);
|
|
}
|
|
p.setVertices(tmp_vec);
|
|
|
|
// min & max
|
|
// Already computed (in the SetVertices() method)
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
inline
|
|
int load(istream& in, Material& m) {
|
|
|
|
float tmp_array[4];
|
|
int i;
|
|
|
|
// Diffuse
|
|
for (i = 0; i < 4; i++)
|
|
READ(tmp_array[i]);
|
|
m.setDiffuse(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
|
|
|
|
// Specular
|
|
for (i = 0; i < 4; i++)
|
|
READ(tmp_array[i]);
|
|
m.setSpecular(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
|
|
|
|
// Ambient
|
|
for (i = 0; i < 4; i++)
|
|
READ(tmp_array[i]);
|
|
m.setAmbient(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
|
|
|
|
// Emission
|
|
for (i = 0; i < 4; i++)
|
|
READ(tmp_array[i]);
|
|
m.setEmission(tmp_array[0], tmp_array[1], tmp_array[2], tmp_array[3]);
|
|
|
|
// Shininess
|
|
READ(tmp_array[0]);
|
|
m.setShininess(tmp_array[0]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int load(istream& in, ViewShape* vs) {
|
|
|
|
if (!vs || !vs->sshape())
|
|
return 1;
|
|
|
|
// SShape
|
|
|
|
// -> Id
|
|
Id::id_type id1, id2;
|
|
READ(id1);
|
|
READ(id2);
|
|
vs->sshape()->setId(Id(id1, id2));
|
|
|
|
// -> Importance
|
|
float importance;
|
|
READ(importance);
|
|
vs->sshape()->setImportance(importance);
|
|
|
|
// -> BBox
|
|
// Not necessary (only used during view map computatiom)
|
|
|
|
unsigned i, size, tmp;
|
|
|
|
// -> Material
|
|
READ(size);
|
|
vector<Material> materials;
|
|
Material m;
|
|
for(i=0; i<size; ++i){
|
|
load(in, m);
|
|
materials.push_back(m);
|
|
}
|
|
vs->sshape()->setMaterials(materials);
|
|
|
|
|
|
|
|
// -> VerticesList (List)
|
|
READ(size);
|
|
for (i = 0; i < size; i++) {
|
|
SVertex* sv;
|
|
READ_IF_NON_NULL(sv, g_vm->SVertices());
|
|
vs->sshape()->AddNewVertex(sv);
|
|
}
|
|
|
|
// -> Chains (List)
|
|
READ(size);
|
|
for (i = 0; i < size; i++) {
|
|
FEdge* fe;
|
|
READ_IF_NON_NULL(fe, g_vm->FEdges());
|
|
vs->sshape()->AddChain(fe);
|
|
}
|
|
|
|
// -> EdgesList (List)
|
|
READ(size);
|
|
for (i = 0; i < size; i++) {
|
|
FEdge* fe;
|
|
READ_IF_NON_NULL(fe, g_vm->FEdges());
|
|
vs->sshape()->AddEdge(fe);
|
|
}
|
|
|
|
// ViewEdges (List)
|
|
READ(size);
|
|
for (i = 0; i < size; i++) {
|
|
ViewEdge* ve;
|
|
READ_IF_NON_NULL(ve, g_vm->ViewEdges());
|
|
vs->AddEdge(ve);
|
|
}
|
|
|
|
// ViewVertices (List)
|
|
READ(size);
|
|
for (i = 0; i < size; i++) {
|
|
ViewVertex* vv;
|
|
READ_IF_NON_NULL(vv, g_vm->ViewVertices());
|
|
vs->AddVertex(vv);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int load(istream& in, FEdge* fe) {
|
|
|
|
if (!fe)
|
|
return 1;
|
|
|
|
bool b;
|
|
|
|
FEdgeSmooth *fesmooth = 0;
|
|
FEdgeSharp * fesharp = 0;
|
|
if(fe->isSmooth()){
|
|
fesmooth = dynamic_cast<FEdgeSmooth*>(fe);
|
|
}else{
|
|
fesharp = dynamic_cast<FEdgeSharp*>(fe);
|
|
}
|
|
|
|
// Id
|
|
Id::id_type id1, id2;
|
|
READ(id1);
|
|
READ(id2);
|
|
fe->setId(Id(id1, id2));
|
|
|
|
// Nature
|
|
Nature::EdgeNature nature;
|
|
READ(nature);
|
|
fe->setNature(nature);
|
|
|
|
// hasVisibilityPoint
|
|
// bool b;
|
|
// READ(b);
|
|
// fe->setHasVisibilityPoint(b);
|
|
|
|
Vec3r v;
|
|
unsigned int matindex;
|
|
|
|
// VisibilityPointA
|
|
// load(in, v);
|
|
// fe->setVisibilityPointA(v);
|
|
|
|
// VisibilityPointB
|
|
// load(in, v);
|
|
// fe->setVisibilityPointB(v);
|
|
|
|
if(fe->isSmooth()){
|
|
// Normal
|
|
load(in, v);
|
|
fesmooth->setNormal(v);
|
|
|
|
// Material
|
|
READ(matindex);
|
|
fesmooth->setMaterialIndex(matindex);
|
|
}else{
|
|
// aNormal
|
|
load(in, v);
|
|
fesharp->setNormalA(v);
|
|
|
|
// bNormal
|
|
load(in, v);
|
|
fesharp->setNormalB(v);
|
|
|
|
// Materials
|
|
READ(matindex);
|
|
fesharp->setaMaterialIndex(matindex);
|
|
READ(matindex);
|
|
fesharp->setbMaterialIndex(matindex);
|
|
}
|
|
|
|
unsigned tmp;
|
|
|
|
// VertexA
|
|
SVertex* sva;
|
|
READ_IF_NON_NULL(sva, g_vm->SVertices());
|
|
fe->setVertexA(sva);
|
|
|
|
// VertexB
|
|
SVertex* svb;
|
|
READ_IF_NON_NULL(svb, g_vm->SVertices());
|
|
fe->setVertexB(svb);
|
|
|
|
// NextEdge
|
|
FEdge* nfe;
|
|
READ_IF_NON_NULL(nfe, g_vm->FEdges());
|
|
fe->setNextEdge(nfe);
|
|
|
|
// PreviousEdge
|
|
FEdge* pfe;
|
|
READ_IF_NON_NULL(pfe, g_vm->FEdges());
|
|
fe->setPreviousEdge(pfe);
|
|
|
|
// ViewEdge
|
|
ViewEdge* ve;
|
|
READ_IF_NON_NULL(ve, g_vm->ViewEdges());
|
|
fe->setViewEdge(ve);
|
|
|
|
// Face
|
|
// Not necessary (only used during view map computatiom)
|
|
|
|
Polygon3r p;
|
|
|
|
// aFace
|
|
load(in, p);
|
|
fe->setaFace(p);
|
|
|
|
// occludeeEmpty
|
|
READ(b);
|
|
fe->setOccludeeEmpty(b);
|
|
|
|
// occludeeIntersection
|
|
load(in, v);
|
|
fe->setOccludeeIntersection(v);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int load(istream& in, SVertex* sv) {
|
|
|
|
if (!sv)
|
|
return 1;
|
|
|
|
// Id
|
|
Id::id_type id1, id2;
|
|
READ(id1);
|
|
READ(id2);
|
|
sv->setId(Id(id1, id2));
|
|
|
|
Vec3r v;
|
|
|
|
// Point3D
|
|
load(in, v);
|
|
sv->setPoint3D(v);
|
|
|
|
// Point2D
|
|
load(in, v);
|
|
sv->setPoint2D(v);
|
|
|
|
unsigned tmp;
|
|
|
|
// Shape
|
|
ViewShape* vs;
|
|
READ_IF_NON_NULL(vs, g_vm->ViewShapes());
|
|
sv->setShape(vs->sshape());
|
|
|
|
// pViewVertex
|
|
ViewVertex* vv;
|
|
READ_IF_NON_NULL(vv, g_vm->ViewVertices());
|
|
sv->setViewVertex(vv);
|
|
|
|
unsigned i, size;
|
|
|
|
// Normals (List)
|
|
READ(size);
|
|
for (i = 0; i < size; i++) {
|
|
load(in, v);
|
|
sv->AddNormal(v);
|
|
}
|
|
|
|
// FEdges (List)
|
|
READ(size);
|
|
FEdge* fe;
|
|
for (i = 0; i < size; i++) {
|
|
READ_IF_NON_NULL(fe, g_vm->FEdges());
|
|
sv->AddFEdge(fe);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int load(istream& in, ViewEdge* ve) {
|
|
|
|
if (!ve)
|
|
return 1;
|
|
|
|
unsigned tmp;
|
|
|
|
// Id
|
|
Id::id_type id1, id2;
|
|
READ(id1);
|
|
READ(id2);
|
|
ve->setId(Id(id1, id2));
|
|
|
|
// Nature
|
|
Nature::EdgeNature nature;
|
|
READ(nature);
|
|
ve->setNature(nature);
|
|
|
|
// QI
|
|
READ(tmp);
|
|
ve->setQI(tmp);
|
|
|
|
// Shape
|
|
ViewShape* vs;
|
|
READ_IF_NON_NULL(vs, g_vm->ViewShapes());
|
|
ve->setShape(vs);
|
|
|
|
// aShape
|
|
ViewShape* avs;
|
|
READ_IF_NON_NULL(avs, g_vm->ViewShapes());
|
|
ve->setaShape(avs);
|
|
|
|
// FEdgeA
|
|
FEdge* fea;
|
|
READ_IF_NON_NULL(fea, g_vm->FEdges());
|
|
ve->setFEdgeA(fea);
|
|
|
|
// FEdgeB
|
|
FEdge* feb;
|
|
READ_IF_NON_NULL(feb, g_vm->FEdges());
|
|
ve->setFEdgeB(feb);
|
|
|
|
// A
|
|
ViewVertex* vva;
|
|
READ_IF_NON_NULL(vva, g_vm->ViewVertices());
|
|
ve->setA(vva);
|
|
|
|
// B
|
|
ViewVertex* vvb;
|
|
READ_IF_NON_NULL(vvb, g_vm->ViewVertices());
|
|
ve->setB(vvb);
|
|
|
|
// Occluders (List)
|
|
if (!(Options::getFlags() & Options::NO_OCCLUDERS)) {
|
|
unsigned size;
|
|
READ(size);
|
|
ViewShape* vso;
|
|
for (unsigned i = 0; i < size; i++) {
|
|
READ_IF_NON_NULL(vso, g_vm->ViewShapes());
|
|
ve->AddOccluder(vso);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int load(istream& in, ViewVertex* vv) {
|
|
|
|
if (!vv)
|
|
return 1;
|
|
|
|
unsigned tmp;
|
|
bool b;
|
|
|
|
// Nature
|
|
Nature::VertexNature nature;
|
|
READ(nature);
|
|
vv->setNature(nature);
|
|
|
|
if (vv->getNature() & Nature::T_VERTEX) {
|
|
TVertex* tv = dynamic_cast<TVertex*>(vv);
|
|
|
|
// Id
|
|
Id::id_type id1, id2;
|
|
READ(id1);
|
|
READ(id2);
|
|
tv->setId(Id(id1, id2));
|
|
|
|
// FrontSVertex
|
|
SVertex* fsv;
|
|
READ_IF_NON_NULL(fsv, g_vm->SVertices());
|
|
tv->setFrontVertex(fsv);
|
|
|
|
// BackSVertex
|
|
SVertex* bsv;
|
|
READ_IF_NON_NULL(bsv, g_vm->SVertices());
|
|
tv->setBackSVertex(bsv);
|
|
|
|
// FrontEdgeA
|
|
ViewEdge* fea;
|
|
READ_IF_NON_NULL(fea, g_vm->ViewEdges());
|
|
READ(b);
|
|
tv->setFrontEdgeA(fea, b);
|
|
|
|
// FrontEdgeB
|
|
ViewEdge* feb;
|
|
READ_IF_NON_NULL(feb, g_vm->ViewEdges());
|
|
READ(b);
|
|
tv->setFrontEdgeB(feb, b);
|
|
|
|
// BackEdgeA
|
|
ViewEdge* bea;
|
|
READ_IF_NON_NULL(bea, g_vm->ViewEdges());
|
|
READ(b);
|
|
tv->setBackEdgeA(bea, b);
|
|
|
|
// BackEdgeB
|
|
ViewEdge* beb;
|
|
READ_IF_NON_NULL(beb, g_vm->ViewEdges());
|
|
READ(b);
|
|
tv->setBackEdgeB(beb, b);
|
|
}
|
|
else if (vv->getNature() & Nature::NON_T_VERTEX) {
|
|
NonTVertex* ntv = dynamic_cast<NonTVertex*>(vv);
|
|
|
|
// SVertex
|
|
SVertex* sv;
|
|
READ_IF_NON_NULL(sv, g_vm->SVertices());
|
|
ntv->setSVertex(sv);
|
|
|
|
// ViewEdges (List)
|
|
unsigned size;
|
|
READ(size);
|
|
ViewEdge* ve;
|
|
for (unsigned i = 0; i < size; i++) {
|
|
READ_IF_NON_NULL(ve, g_vm->ViewEdges());
|
|
READ(b);
|
|
ntv->AddViewEdge(ve, b);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//////////////////// 'save' Functions ////////////////////
|
|
|
|
inline
|
|
int save(ostream& out, const Vec3r& v) {
|
|
|
|
if (Options::getFlags() & Options::FLOAT_VECTORS) {
|
|
float tmp;
|
|
|
|
tmp = v[0];
|
|
WRITE(tmp);
|
|
tmp = v[1];
|
|
WRITE(tmp);
|
|
tmp = v[2];
|
|
WRITE(tmp);
|
|
} else {
|
|
Vec3r::value_type tmp;
|
|
|
|
tmp = v[0];
|
|
WRITE(tmp);
|
|
tmp = v[1];
|
|
WRITE(tmp);
|
|
tmp = v[2];
|
|
WRITE(tmp);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
inline
|
|
int save(ostream& out, const Polygon3r& p) {
|
|
|
|
unsigned tmp;
|
|
|
|
// Id
|
|
tmp = p.getId();
|
|
WRITE(tmp);
|
|
|
|
// vertices (List)
|
|
tmp = p.getVertices().size();
|
|
WRITE(tmp);
|
|
for (vector<Vec3r>::const_iterator i = p.getVertices().begin();
|
|
i != p.getVertices().end(); i++) {
|
|
save(out, *i);
|
|
}
|
|
|
|
// min & max
|
|
// Do not need to be saved
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
inline
|
|
int save(ostream& out, const Material& m) {
|
|
|
|
unsigned i;
|
|
|
|
// Diffuse
|
|
for (i = 0; i < 4; i++)
|
|
WRITE(m.diffuse()[i]);
|
|
|
|
// Specular
|
|
for (i = 0; i < 4; i++)
|
|
WRITE(m.specular()[i]);
|
|
|
|
// Ambient
|
|
for (i = 0; i < 4; i++)
|
|
WRITE(m.ambient()[i]);
|
|
|
|
// Emission
|
|
for (i = 0; i < 4; i++)
|
|
WRITE(m.emission()[i]);
|
|
|
|
// Shininess
|
|
float shininess = m.shininess();
|
|
WRITE(shininess);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int save(ostream& out, ViewShape* vs) {
|
|
|
|
if (!vs || !vs->sshape()) {
|
|
cerr << "Warning: null ViewShape" << endl;
|
|
return 1;
|
|
}
|
|
|
|
unsigned tmp;
|
|
|
|
// SShape
|
|
|
|
// -> Id
|
|
Id::id_type id = vs->sshape()->getId().getFirst();
|
|
WRITE(id);
|
|
id = vs->sshape()->getId().getSecond();
|
|
WRITE(id);
|
|
|
|
// -> Importance
|
|
float importance = vs->sshape()->importance();
|
|
WRITE(importance);
|
|
|
|
// -> BBox
|
|
// Not necessary (only used during view map computatiom)
|
|
|
|
// -> Material
|
|
unsigned size = vs->sshape()->materials().size();
|
|
WRITE(size);
|
|
for(unsigned i=0; i<size; ++i)
|
|
save(out, vs->sshape()->material(i));
|
|
|
|
// -> VerticesList (List)
|
|
tmp = vs->sshape()->GetVertexList().size();
|
|
WRITE(tmp);
|
|
for (vector<SVertex*>::const_iterator i1 = vs->sshape()->GetVertexList().begin();
|
|
i1 != vs->sshape()->GetVertexList().end(); i1++)
|
|
WRITE_IF_NON_NULL(*i1);
|
|
|
|
// -> Chains (List)
|
|
tmp = vs->sshape()->GetChains().size();
|
|
WRITE(tmp);
|
|
for (vector<FEdge*>::const_iterator i2 = vs->sshape()->GetChains().begin();
|
|
i2 != vs->sshape()->GetChains().end(); i2++)
|
|
WRITE_IF_NON_NULL(*i2);
|
|
|
|
// -> EdgesList (List)
|
|
tmp = vs->sshape()->GetEdgeList().size();
|
|
WRITE(tmp);
|
|
for (vector<FEdge*>::const_iterator i3 = vs->sshape()->GetEdgeList().begin();
|
|
i3 != vs->sshape()->GetEdgeList().end(); i3++)
|
|
WRITE_IF_NON_NULL(*i3);
|
|
|
|
// ViewEdges (List)
|
|
tmp = vs->edges().size();
|
|
WRITE(tmp);
|
|
for (vector<ViewEdge*>::const_iterator i4 = vs->edges().begin();
|
|
i4 != vs->edges().end(); i4++)
|
|
WRITE_IF_NON_NULL(*i4);
|
|
|
|
// ViewVertices (List)
|
|
tmp = vs->vertices().size();
|
|
WRITE(tmp);
|
|
for (vector<ViewVertex*>::const_iterator i5 = vs->vertices().begin();
|
|
i5 != vs->vertices().end(); i5++)
|
|
WRITE_IF_NON_NULL(*i5);
|
|
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int save(ostream& out, FEdge* fe) {
|
|
|
|
if (!fe) {
|
|
cerr << "Warning: null FEdge" << endl;
|
|
return 1;
|
|
}
|
|
|
|
FEdgeSmooth * fesmooth = dynamic_cast<FEdgeSmooth*>(fe);
|
|
FEdgeSharp * fesharp = dynamic_cast<FEdgeSharp*>(fe);
|
|
|
|
// Id
|
|
Id::id_type id = fe->getId().getFirst();
|
|
WRITE(id);
|
|
id = fe->getId().getSecond();
|
|
WRITE(id);
|
|
|
|
// Nature
|
|
Nature::EdgeNature nature = fe->getNature();
|
|
WRITE(nature);
|
|
|
|
bool b;
|
|
|
|
// hasVisibilityPoint
|
|
// b = fe->hasVisibilityPoint();
|
|
// WRITE(b);
|
|
|
|
// VisibilityPointA
|
|
// save(out, fe->visibilityPointA());
|
|
//
|
|
// // VisibilityPointB
|
|
// save(out, fe->visibilityPointB());
|
|
|
|
unsigned index;
|
|
if(fe->isSmooth()){
|
|
// normal
|
|
save(out, fesmooth->normal());
|
|
// material
|
|
index = fesmooth->materialIndex();
|
|
WRITE(index);
|
|
}else{
|
|
// aNormal
|
|
save(out, fesharp->normalA());
|
|
// bNormal
|
|
save(out, fesharp->normalB());
|
|
// aMaterial
|
|
index = fesharp->aMaterialIndex();
|
|
WRITE(index);
|
|
// bMaterial
|
|
index = fesharp->bMaterialIndex();
|
|
WRITE(index);
|
|
}
|
|
|
|
|
|
// VertexA
|
|
WRITE_IF_NON_NULL(fe->vertexA());
|
|
|
|
// VertexB
|
|
WRITE_IF_NON_NULL(fe->vertexB());
|
|
|
|
// NextEdge
|
|
WRITE_IF_NON_NULL(fe->nextEdge());
|
|
|
|
// PreviousEdge
|
|
WRITE_IF_NON_NULL(fe->previousEdge());
|
|
|
|
// ViewEdge
|
|
WRITE_IF_NON_NULL(fe->viewedge());
|
|
|
|
// Face
|
|
// Not necessary (only used during view map computatiom)
|
|
|
|
// aFace
|
|
save(out, (Polygon3r&)fe->aFace());
|
|
|
|
// occludeeEmpty
|
|
b = fe->getOccludeeEmpty();
|
|
WRITE(b);
|
|
|
|
// occludeeIntersection
|
|
save(out, fe->getOccludeeIntersection());
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int save(ostream& out, SVertex* sv) {
|
|
|
|
if (!sv) {
|
|
cerr << "Warning: null SVertex" << endl;
|
|
return 1;
|
|
}
|
|
|
|
unsigned tmp;
|
|
|
|
// Id
|
|
Id::id_type id = sv->getId().getFirst();
|
|
WRITE(id);
|
|
id = sv->getId().getSecond();
|
|
WRITE(id);
|
|
|
|
Vec3r v;
|
|
|
|
// Point3D
|
|
v = sv->point3D();
|
|
save(out, sv->point3D());
|
|
|
|
// Point2D
|
|
v = sv->point2D();
|
|
save(out, v);
|
|
|
|
// Shape
|
|
WRITE_IF_NON_NULL(sv->shape());
|
|
|
|
// pViewVertex
|
|
WRITE_IF_NON_NULL(sv->viewvertex());
|
|
|
|
// Normals (List)
|
|
// Note: the 'size()' method of a set doesn't seem to return the
|
|
// actual size of the given set, so we have to hack it...
|
|
set<Vec3r>::const_iterator i;
|
|
for (i = sv->normals().begin(), tmp = 0;
|
|
i != sv->normals().end();
|
|
i++, tmp++);
|
|
WRITE(tmp);
|
|
for (i = sv->normals().begin(); i != sv->normals().end(); i++)
|
|
save(out, *i);
|
|
|
|
// FEdges (List)
|
|
tmp = sv->fedges().size();
|
|
WRITE(tmp);
|
|
for (vector<FEdge*>::const_iterator j = sv->fedges_begin();
|
|
j != sv->fedges_end(); j++)
|
|
WRITE_IF_NON_NULL(*j);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int save(ostream& out, ViewEdge* ve) {
|
|
|
|
if (!ve) {
|
|
cerr << "Warning: null ViewEdge" << endl;
|
|
return 1;
|
|
}
|
|
|
|
unsigned tmp;
|
|
|
|
// Id
|
|
Id::id_type id = ve->getId().getFirst();
|
|
WRITE(id);
|
|
id = ve->getId().getSecond();
|
|
WRITE(id);
|
|
|
|
// Nature
|
|
Nature::EdgeNature nature = ve->getNature();
|
|
WRITE(nature);
|
|
|
|
// QI
|
|
unsigned qi = ve->qi();
|
|
WRITE(qi);
|
|
|
|
// Shape
|
|
WRITE_IF_NON_NULL(ve->shape());
|
|
|
|
// aShape
|
|
WRITE_IF_NON_NULL(ve->aShape());
|
|
|
|
// FEdgeA
|
|
WRITE_IF_NON_NULL(ve->fedgeA());
|
|
|
|
// FEdgeB
|
|
WRITE_IF_NON_NULL(ve->fedgeB());
|
|
|
|
// A
|
|
WRITE_IF_NON_NULL(ve->A());
|
|
|
|
// B
|
|
WRITE_IF_NON_NULL(ve->B());
|
|
|
|
// Occluders (List)
|
|
if (!(Options::getFlags() & Options::NO_OCCLUDERS)) {
|
|
tmp = ve->occluders().size();
|
|
WRITE(tmp);
|
|
for (vector<ViewShape*>::const_iterator i = ve->occluders().begin();
|
|
i != ve->occluders().end(); i++)
|
|
WRITE_IF_NON_NULL((*i));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
int save(ostream& out, ViewVertex* vv) {
|
|
|
|
if (!vv) {
|
|
cerr << "Warning: null ViewVertex" << endl;
|
|
return 1;
|
|
}
|
|
|
|
// Nature
|
|
Nature::VertexNature nature = vv->getNature();
|
|
WRITE(nature);
|
|
|
|
if (vv->getNature() & Nature::T_VERTEX) {
|
|
TVertex* tv = dynamic_cast<TVertex*>(vv);
|
|
|
|
// Id
|
|
Id::id_type id = tv->getId().getFirst();
|
|
WRITE(id);
|
|
id = tv->getId().getSecond();
|
|
WRITE(id);
|
|
|
|
// FrontSVertex
|
|
WRITE_IF_NON_NULL(tv->frontSVertex());
|
|
|
|
// BackSVertex
|
|
WRITE_IF_NON_NULL(tv->backSVertex());
|
|
|
|
// FrontEdgeA
|
|
WRITE_IF_NON_NULL(tv->frontEdgeA().first);
|
|
WRITE(tv->frontEdgeA().second);
|
|
|
|
// FrontEdgeB
|
|
WRITE_IF_NON_NULL(tv->frontEdgeB().first);
|
|
WRITE(tv->frontEdgeB().second);
|
|
|
|
// BackEdgeA
|
|
WRITE_IF_NON_NULL(tv->backEdgeA().first);
|
|
WRITE(tv->backEdgeA().second);
|
|
|
|
// BackEdgeB
|
|
WRITE_IF_NON_NULL(tv->backEdgeB().first);
|
|
WRITE(tv->backEdgeB().second);
|
|
|
|
}
|
|
else if (vv->getNature() & Nature::NON_T_VERTEX) {
|
|
NonTVertex* ntv = dynamic_cast<NonTVertex*>(vv);
|
|
|
|
// SVertex
|
|
WRITE_IF_NON_NULL(ntv->svertex());
|
|
|
|
// ViewEdges (List)
|
|
unsigned size = ntv->viewedges().size();
|
|
WRITE(size);
|
|
vector<ViewVertex::directedViewEdge>::const_iterator i = ntv->viewedges().begin();
|
|
for ( ; i != ntv->viewedges().end(); i++){
|
|
WRITE_IF_NON_NULL(i->first);
|
|
WRITE(i->second);
|
|
}
|
|
|
|
} else {
|
|
cerr << "Warning: unexpected ViewVertex nature" << endl;
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
} // End of namespace Internal
|
|
|
|
|
|
//////////////////// "Public" 'load' and 'save' functions ////////////////////
|
|
|
|
#define SET_PROGRESS(n) if (pb) pb->setProgress((n))
|
|
|
|
int load(istream& in, ViewMap* vm, ProgressBar* pb) {
|
|
|
|
if (!vm)
|
|
return 1;
|
|
|
|
//soc unused - unsigned tmp;
|
|
|
|
int err = 0;
|
|
|
|
Internal::g_vm = vm;
|
|
|
|
// Management of the progress bar (if present)
|
|
if (pb) {
|
|
pb->reset();
|
|
pb->setLabelText("Loading View Map...");
|
|
pb->setTotalSteps(6);
|
|
pb->setProgress(0);
|
|
}
|
|
|
|
// Read and set the options
|
|
unsigned char flags;
|
|
READ(flags);
|
|
Options::setFlags(flags);
|
|
|
|
// Read the size of the five ViewMap's lists (with some extra informations for the ViewVertices)
|
|
// and instantiate them (with default costructors)
|
|
unsigned vs_s, fe_s, fe_rle1, fe_rle2, sv_s, ve_s, vv_s, vv_rle1, vv_rle2;
|
|
READ(vs_s);
|
|
READ(fe_s);
|
|
|
|
if (fe_s) {
|
|
bool b;
|
|
READ(b);
|
|
for (READ(fe_rle1), fe_rle2 = 0;
|
|
fe_rle1 < fe_s+1;
|
|
fe_rle2 = fe_rle1, READ(fe_rle1)) {
|
|
if (b) {
|
|
for (unsigned i = fe_rle2; i < fe_rle1; i++) {
|
|
FEdgeSmooth * fes = new FEdgeSmooth;
|
|
vm->AddFEdge(fes);
|
|
}
|
|
b = !b;
|
|
}
|
|
else if (!b) {
|
|
for (unsigned i = fe_rle2; i < fe_rle1; i++) {
|
|
FEdgeSharp * fes = new FEdgeSharp;
|
|
vm->AddFEdge(fes);
|
|
}
|
|
b = !b;
|
|
}
|
|
}
|
|
}
|
|
|
|
READ(sv_s);
|
|
READ(ve_s);
|
|
READ(vv_s);
|
|
|
|
if (vv_s) {
|
|
Nature::VertexNature nature;
|
|
READ(nature);
|
|
for (READ(vv_rle1), vv_rle2 = 0;
|
|
vv_rle1 < vv_s+1;
|
|
vv_rle2 = vv_rle1, READ(vv_rle1)) {
|
|
if (nature & Nature::T_VERTEX) {
|
|
for (unsigned i = vv_rle2; i < vv_rle1; i++) {
|
|
TVertex* tv = new TVertex();
|
|
vm->AddViewVertex(tv);
|
|
}
|
|
nature = Nature::NON_T_VERTEX;
|
|
}
|
|
else if (nature & Nature::NON_T_VERTEX) {
|
|
for (unsigned i = vv_rle2; i < vv_rle1; i++) {
|
|
NonTVertex* ntv = new NonTVertex();
|
|
vm->AddViewVertex(ntv);
|
|
}
|
|
nature = Nature::T_VERTEX;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (unsigned i0 = 0; i0 < vs_s; i0++) {
|
|
SShape* ss = new SShape();
|
|
ViewShape* vs = new ViewShape();
|
|
vs->setSShape(ss);
|
|
ss->setViewShape(vs);
|
|
vm->AddViewShape(vs);
|
|
}
|
|
// for (unsigned i1 = 0; i1 < fe_s; i1++) {
|
|
// FEdge* fe = new FEdge();
|
|
// vm->AddFEdge(fe);
|
|
// }
|
|
for (unsigned i2 = 0; i2 < sv_s; i2++) {
|
|
SVertex* sv = new SVertex();
|
|
vm->AddSVertex(sv);
|
|
}
|
|
for (unsigned i3 = 0; i3 < ve_s; i3++) {
|
|
ViewEdge* ve = new ViewEdge();
|
|
vm->AddViewEdge(ve);
|
|
}
|
|
|
|
|
|
// Read the values for all the objects created above
|
|
SET_PROGRESS(1);
|
|
for (vector<ViewShape*>::const_iterator i4 = vm->ViewShapes().begin();
|
|
i4 != vm->ViewShapes().end(); i4++)
|
|
err += Internal::load(in, *i4);
|
|
SET_PROGRESS(2);
|
|
for (vector<FEdge*>::const_iterator i5 = vm->FEdges().begin();
|
|
i5 != vm->FEdges().end(); i5++)
|
|
err += Internal::load(in, *i5);
|
|
SET_PROGRESS(3);
|
|
for (vector<SVertex*>::const_iterator i6 = vm->SVertices().begin();
|
|
i6 != vm->SVertices().end(); i6++)
|
|
err += Internal::load(in, *i6);
|
|
SET_PROGRESS(4);
|
|
for (vector<ViewEdge*>::const_iterator i7 = vm->ViewEdges().begin();
|
|
i7 != vm->ViewEdges().end(); i7++)
|
|
err += Internal::load(in, *i7);
|
|
SET_PROGRESS(5);
|
|
for (vector<ViewVertex*>::const_iterator i8 = vm->ViewVertices().begin();
|
|
i8 != vm->ViewVertices().end(); i8++)
|
|
err += Internal::load(in, *i8);
|
|
SET_PROGRESS(6);
|
|
|
|
// Read the shape id to index mapping
|
|
unsigned map_s;
|
|
READ(map_s);
|
|
unsigned id,index;
|
|
for(unsigned i4=0;i4<map_s;++i4){
|
|
READ(id);
|
|
READ(index);
|
|
vm->shapeIdToIndexMap()[id] = index;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
int save(ostream& out, ViewMap* vm, ProgressBar* pb) {
|
|
|
|
if (!vm)
|
|
return 1;
|
|
|
|
int err = 0;
|
|
|
|
// Management of the progress bar (if present)
|
|
if (pb) {
|
|
pb->reset();
|
|
pb->setLabelText("Saving View Map...");
|
|
pb->setTotalSteps(6);
|
|
pb->setProgress(0);
|
|
}
|
|
|
|
// For every object, initialize its userdata member to its index in the ViewMap list
|
|
for (unsigned i0 = 0; i0 < vm->ViewShapes().size(); i0++) {
|
|
vm->ViewShapes()[i0]->userdata = (void*)i0;
|
|
vm->ViewShapes()[i0]->sshape()->userdata = (void*)i0;
|
|
}
|
|
for (unsigned i1 = 0; i1 < vm->FEdges().size(); i1++)
|
|
vm->FEdges()[i1]->userdata = (void*)i1;
|
|
for (unsigned i2 = 0; i2 < vm->SVertices().size(); i2++)
|
|
vm->SVertices()[i2]->userdata = (void*)i2;
|
|
for (unsigned i3 = 0; i3 < vm->ViewEdges().size(); i3++)
|
|
vm->ViewEdges()[i3]->userdata = (void*)i3;
|
|
for (unsigned i4 = 0; i4 < vm->ViewVertices().size(); i4++)
|
|
vm->ViewVertices()[i4]->userdata = (void*)i4;
|
|
|
|
// Write the current options
|
|
unsigned char flags = Options::getFlags();
|
|
WRITE(flags);
|
|
|
|
// Write the size of the five lists (with some extra informations for the ViewVertices)
|
|
unsigned size;
|
|
size = vm->ViewShapes().size();
|
|
WRITE(size);
|
|
size = vm->FEdges().size();
|
|
WRITE(size);
|
|
if (size) {
|
|
bool b = vm->FEdges()[0]->isSmooth();
|
|
WRITE(b);
|
|
for (unsigned i = 0; i < size; i++) {
|
|
while (i < size && (vm->FEdges()[i]->isSmooth() == b))
|
|
i++;
|
|
if (i < size) {
|
|
WRITE(i);
|
|
b = !b;
|
|
}
|
|
}
|
|
WRITE(size);
|
|
size++;
|
|
WRITE(size);
|
|
}
|
|
size = vm->SVertices().size();
|
|
WRITE(size);
|
|
size = vm->ViewEdges().size();
|
|
WRITE(size);
|
|
size = vm->ViewVertices().size();
|
|
WRITE(size);
|
|
if (size) {
|
|
Nature::VertexNature nature = vm->ViewVertices()[0]->getNature();
|
|
WRITE(nature);
|
|
nature &= ~Nature::VIEW_VERTEX;
|
|
for (unsigned i = 0; i < size; i++) {
|
|
while (i < size && (vm->ViewVertices()[i]->getNature() & nature))
|
|
i++;
|
|
if (i < size) {
|
|
WRITE(i);
|
|
nature = vm->ViewVertices()[i]->getNature() & ~Nature::VIEW_VERTEX;
|
|
}
|
|
}
|
|
WRITE(size);
|
|
size++;
|
|
WRITE(size);
|
|
}
|
|
|
|
|
|
// Write all the elts of the ViewShapes List
|
|
SET_PROGRESS(1);
|
|
for (vector<ViewShape*>::const_iterator i5 = vm->ViewShapes().begin();
|
|
i5 != vm->ViewShapes().end(); i5++)
|
|
err += Internal::save(out, *i5);
|
|
SET_PROGRESS(2);
|
|
for (vector<FEdge*>::const_iterator i6 = vm->FEdges().begin();
|
|
i6 != vm->FEdges().end(); i6++)
|
|
err += Internal::save(out, *i6);
|
|
SET_PROGRESS(3);
|
|
for (vector<SVertex*>::const_iterator i7 = vm->SVertices().begin();
|
|
i7 != vm->SVertices().end(); i7++)
|
|
err += Internal::save(out, *i7);
|
|
SET_PROGRESS(4);
|
|
for (vector<ViewEdge*>::const_iterator i8 = vm->ViewEdges().begin();
|
|
i8 != vm->ViewEdges().end(); i8++)
|
|
err += Internal::save(out, *i8);
|
|
SET_PROGRESS(5);
|
|
for (vector<ViewVertex*>::const_iterator i9 = vm->ViewVertices().begin();
|
|
i9 != vm->ViewVertices().end(); i9++)
|
|
err += Internal::save(out, *i9);
|
|
|
|
// Write the shape id to index mapping
|
|
size = vm->shapeIdToIndexMap().size();
|
|
WRITE(size);
|
|
unsigned id,index;
|
|
for(ViewMap::id_to_index_map::iterator mit=vm->shapeIdToIndexMap().begin(), mitend=vm->shapeIdToIndexMap().end(); mit!=mitend; ++mit){
|
|
id = mit->first;
|
|
index = mit->second;
|
|
WRITE(id);
|
|
WRITE(index);
|
|
}
|
|
|
|
// Reset 'userdata' members
|
|
for (vector<ViewShape*>::const_iterator j0 = vm->ViewShapes().begin();
|
|
j0 != vm->ViewShapes().end(); j0++) {
|
|
(*j0)->userdata = 0;
|
|
(*j0)->sshape()->userdata = 0;
|
|
}
|
|
for (vector<FEdge*>::const_iterator j1 = vm->FEdges().begin();
|
|
j1 != vm->FEdges().end(); j1++)
|
|
(*j1)->userdata = 0;
|
|
for (vector<SVertex*>::const_iterator j2 = vm->SVertices().begin();
|
|
j2 != vm->SVertices().end(); j2++)
|
|
(*j2)->userdata = 0;
|
|
for (vector<ViewEdge*>::const_iterator j3 = vm->ViewEdges().begin();
|
|
j3 != vm->ViewEdges().end(); j3++)
|
|
(*j3)->userdata = 0;
|
|
for (vector<ViewVertex*>::const_iterator j4 = vm->ViewVertices().begin();
|
|
j4 != vm->ViewVertices().end(); j4++)
|
|
(*j4)->userdata = 0;
|
|
SET_PROGRESS(6);
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
//////////////////// Options ////////////////////
|
|
|
|
namespace Options {
|
|
|
|
namespace Internal {
|
|
|
|
static unsigned char g_flags = 0;
|
|
static string g_models_path;
|
|
|
|
} // End of namespace Internal
|
|
|
|
void setFlags(const unsigned char flags) {
|
|
Internal::g_flags = flags;
|
|
}
|
|
|
|
void addFlags(const unsigned char flags) {
|
|
Internal::g_flags |= flags;
|
|
}
|
|
|
|
void rmFlags(const unsigned char flags) {
|
|
Internal::g_flags &= ~flags;
|
|
}
|
|
|
|
unsigned char getFlags() {
|
|
return Internal::g_flags;
|
|
}
|
|
|
|
void setModelsPath(const string& path) {
|
|
Internal::g_models_path = path;
|
|
}
|
|
|
|
string getModelsPath() {
|
|
return Internal::g_models_path;
|
|
}
|
|
|
|
}; // End of namepace Options
|
|
|
|
} // End of namespace ViewMapIO
|