223 lines
6.1 KiB
C++
223 lines
6.1 KiB
C++
#include "precompiled.h"
|
|
#include "0ad_warning_disable.h"
|
|
|
|
# include <string.h>
|
|
# include "se_mesh.h"
|
|
|
|
//# define SR_USE_TRACE1 // IO trace
|
|
# include "sr_trace.h"
|
|
|
|
//================================ IO =========================================
|
|
|
|
# define ID(se) intptr_t(se->_edge)
|
|
|
|
void SeMeshBase::_elemsave ( SrOutput& out, SeMeshBase::ElemType type, SeElement* first )
|
|
{
|
|
SrClassManagerBase* man;
|
|
SeElement *e;
|
|
int esize;
|
|
const char* st;
|
|
|
|
if ( type==TypeVertex )
|
|
{ esize=_vertices; man=_vtxman; st="Vertices"; }
|
|
else if ( type==TypeEdge )
|
|
{ esize=_edges; man=_edgman; st="Edges"; }
|
|
else
|
|
{ esize=_faces; man=_facman; st="Faces"; }
|
|
|
|
out << srnl << st << srspc << esize << srnl;
|
|
//fprintf ( f, "\n%s %d\n", st, esize );
|
|
|
|
e = first;
|
|
do { e->_index = 0;
|
|
out << ID(e->_symedge) <<srspc;
|
|
//fprintf ( f, "%d ", ID(e->_symedge) );
|
|
man->output(out,e);
|
|
out << srnl;
|
|
//fprintf ( f, "\n" );
|
|
e = e->nxt();
|
|
} while (e!=first);
|
|
|
|
SR_TRACE1 ( esize << " elements written !" );
|
|
}
|
|
|
|
bool SeMeshBase::save ( SrOutput& out )
|
|
{
|
|
SeBase *se;
|
|
SeElement *el, *eli;
|
|
int symedges, j;
|
|
intptr_t i;
|
|
|
|
out << "SYMEDGE MESH DESCRIPTION\n\n";
|
|
//fprintf ( f, "SYMEDGE MESH DESCRIPTION\n\n" );
|
|
SR_TRACE1("Header written.");
|
|
|
|
symedges = _edges*2;
|
|
out << "SymEdges " << symedges << srnl;
|
|
//fprintf ( f, "SymEdges %d\n", symedges );
|
|
|
|
if ( empty() ) return true;
|
|
|
|
SrArray<SeBase*> ses(symedges);
|
|
SrArray<SeEdge*> edg(symedges);
|
|
|
|
// get adjacency information of symedges to save:
|
|
SR_TRACE1("Mounting S array...");
|
|
i=0;
|
|
el = eli = _first->edg();
|
|
do { se = el->se();
|
|
el->_index = i/2;
|
|
for ( j=0; j<2; j++ )
|
|
{ if ( j==1 ) se = se->sym();
|
|
ses[i] = se;
|
|
edg[i] = se->_edge; // save edge pointer
|
|
se->_edge = (SeEdge*)i; // and use it to keep indices
|
|
i++;
|
|
}
|
|
el = el->nxt();
|
|
} while ( el!=eli );
|
|
|
|
// adjust vtx and fac indices:
|
|
SR_TRACE1("Adjusting indexes...");
|
|
|
|
i = 0;
|
|
el = eli = _first->vtx();
|
|
do { el->_index=i++; el=el->nxt(); } while (el!=eli);
|
|
|
|
i = 0;
|
|
el = eli = _first->fac();
|
|
do { el->_index=i++; el=el->nxt(); } while (el!=eli);
|
|
|
|
for ( i=0; i<ses.size(); i++ )
|
|
{ out << ID(ses[i]->_next) << srspc
|
|
<< ID(ses[i]->_rotate) << srspc
|
|
<< ses[i]->_vertex->_index << srspc
|
|
<< edg[i]->_index << srspc
|
|
<< ses[i]->_face->_index << srspc
|
|
<< srnl;
|
|
/*fprintf ( f, "%d %d %d %d %d\n",
|
|
ID(ses[i]->_next),
|
|
ID(ses[i]->_rotate),
|
|
ses[i]->_vertex->_index,
|
|
edg[i]->_index,
|
|
ses[i]->_face->_index );*/
|
|
}
|
|
|
|
SR_TRACE1("Symedges written.");
|
|
|
|
_elemsave ( out, TypeVertex, _first->vtx() );
|
|
_elemsave ( out, TypeEdge, edg[0] );
|
|
_elemsave ( out, TypeFace, _first->fac() );
|
|
|
|
_curmark = 1;
|
|
_marking = _indexing = false;
|
|
for ( i=0; i<ses.size(); i++ ) ses[i]->_edge = edg[i];
|
|
|
|
SR_TRACE1 ( "save OK !" );
|
|
return true;
|
|
}
|
|
|
|
# undef ID
|
|
|
|
//---------------------------------- load --------------------------------
|
|
|
|
/*
|
|
static int load_int ( FILE* f )
|
|
{
|
|
int i;
|
|
fscanf ( f, "%d", &i );
|
|
return i;
|
|
}
|
|
|
|
static void skip ( FILE* f, int n )
|
|
{
|
|
char s[60];
|
|
while ( n-- ) fscanf ( f, "%s", s );
|
|
}
|
|
*/
|
|
void SeMeshBase::_elemload ( SrInput& inp, SrArray<SeElement*>& E,
|
|
const SrArray<SeBase*>& S, SrClassManagerBase* man )
|
|
{
|
|
int i, x;
|
|
|
|
inp.get_token(); // skip elem type label
|
|
//skip ( f, 1 ); // skip elem type label
|
|
|
|
inp >> x; E.size(x);
|
|
//x = load_int(f); E.size(x);
|
|
|
|
for ( i=0; i<E.size(); i++ )
|
|
{ inp >> x; //x = load_int(f);
|
|
E[i] = (SeElement*)man->alloc();
|
|
E[i]->_symedge = S.get(x);
|
|
man->input ( inp, E[i] );
|
|
//man->read ( E[i], f );
|
|
if ( i>0 ) E[0]->_insert(E[i]);
|
|
}
|
|
|
|
SR_TRACE1 ( e.size() << " elements loaded !" );
|
|
}
|
|
|
|
bool SeMeshBase::load ( SrInput& inp )
|
|
{
|
|
//char buf[64];
|
|
int i;
|
|
intptr_t x;
|
|
|
|
//fscanf ( f, "%s", buf ); if ( strcmp(buf,"SYMEDGE") ) return false;
|
|
//fscanf ( f, "%s", buf ); if ( strcmp(buf,"MESH") ) return false;
|
|
//fscanf ( f, "%s", buf ); if ( strcmp(buf,"DESCRIPTION") ) return false;
|
|
inp.get_token(); if ( inp.last_token()!="SYMEDGE" ) return false;
|
|
inp.get_token(); if ( inp.last_token()!="MESH" ) return false;
|
|
inp.get_token(); if ( inp.last_token()!="DESCRIPTION" ) return false;
|
|
SR_TRACE1 ( "Signature ok." );
|
|
|
|
// destroy actual structure to load the new one:
|
|
destroy ();
|
|
|
|
// load indices and store them in an array:
|
|
inp.get_token(); // skip SymEdges label
|
|
//skip ( f, 1 ); // skip SymEdges label
|
|
inp >> i; //i = load_int ( f );
|
|
SrArray<SeBase*> S(i);
|
|
for ( i=0; i<S.size(); i++ )
|
|
{ S[i] = new SeBase;
|
|
inp>>x; S[i]->_next = (SeBase*)x;
|
|
inp>>x; S[i]->_rotate = (SeBase*)x;
|
|
inp>>x; S[i]->_vertex = (SeVertex*)x;
|
|
inp>>x; S[i]->_edge = (SeEdge*)x;
|
|
inp>>x; S[i]->_face = (SeFace*)x;
|
|
}
|
|
SR_TRACE1 ( "Symedges loaded." );
|
|
|
|
// load infos:
|
|
SrArray<SeElement*> V;
|
|
SrArray<SeElement*> E;
|
|
SrArray<SeElement*> F;
|
|
_elemload ( inp, V, S, _vtxman );
|
|
_elemload ( inp, E, S, _edgman );
|
|
_elemload ( inp, F, S, _facman );
|
|
|
|
// convert indices to pointers:
|
|
for ( i=0; i<S.size(); i++ )
|
|
{ S[i]->_next = S[(intptr_t)(S[i]->_next)];
|
|
S[i]->_rotate = S[(intptr_t)(S[i]->_rotate)];
|
|
S[i]->_vertex = V[(intptr_t)(S[i]->_vertex)];
|
|
S[i]->_edge = E[(intptr_t)(S[i]->_edge)];
|
|
S[i]->_face = F[(intptr_t)(S[i]->_face)];
|
|
}
|
|
|
|
// adjust internal variables:
|
|
_first = S[0];
|
|
_vertices = V.size();
|
|
_edges = E.size();
|
|
_faces = F.size();
|
|
_curmark = 1;
|
|
_marking = _indexing = false;
|
|
|
|
SR_TRACE1 ( "load OK !" );
|
|
return true;
|
|
}
|
|
|
|
//=== End of File ===================================================================
|