void SMwriter_smc_old::set_boundingbox(const float* bb_min_f, const float* bb_max_f)
{
if (this->bb_min_f == 0) this->bb_min_f = new float[3];
if (this->bb_max_f == 0) this->bb_max_f = new float[3];
VecCopy3fv(this->bb_min_f, bb_min_f);
VecCopy3fv(this->bb_max_f, bb_max_f);
}
SMevent SMreadPostAsCompactPre::read_event()
{
if ((have_new + have_triangle + have_finalized) == 0)
{
return read_element();
}
if (have_new)
{
v_idx = t_idx[new_vertices[next_new]];
VecCopy3fv(v_pos_f, t_pos_f[new_vertices[next_new]]);
have_new--; next_new++;
v_count++;
return SM_VERTEX;
}
else if (have_triangle)
{
have_triangle = 0;
f_count++;
return SM_TRIANGLE;
}
else if (have_finalized)
{
final_idx = t_idx[finalized_vertices[next_finalized]];
have_finalized--; next_finalized++;
return SM_FINALIZED;
}
return SM_ERROR;
}
SMevent SMreadPostAsCompactPre::read_element()
{
if ((have_new + have_triangle) == 0)
{
next_new = 0;
have_finalized = next_finalized = 0;
int ok = read_triangle();
if (ok <= 0)
{
return (SMevent)ok;
}
}
if (have_new)
{
v_idx = t_idx[new_vertices[next_new]];
VecCopy3fv(v_pos_f,t_pos_f[new_vertices[next_new]]);
have_new--; next_new++;
v_count++;
return SM_VERTEX;
}
else
{
have_triangle = 0;
f_count++;
return SM_TRIANGLE;
}
}
SMevent SMreader_smb::read_element()
{
if (element_counter < element_number)
{
have_finalized = next_finalized = 0;
if (element_descriptor & 1) // next element is a vertex
{
if (endian_swap) VecCopy3fv_swap_endian(v_pos_f, (float*)(&element_buffer[element_counter*3]));
else VecCopy3fv(v_pos_f, (float*)(&element_buffer[element_counter*3]));
v_idx = v_count;
v_count++;
if (post_order) {finalized_vertices[have_finalized] = v_idx; have_finalized++;}
element_counter++;
if (element_counter == element_number)
{
read_buffer();
}
else
{
element_descriptor = element_descriptor >> 1;
}
return SM_VERTEX;
}
else // next element is a triangle
{
if (endian_swap) VecCopy3iv_swap_endian(t_idx, (int*)(&element_buffer[element_counter*3]));
static SMedge* allocEdge(float* v)
{
if (edge_buffer_next == 0)
{
edge_buffer_next = (SMedge*)malloc(sizeof(SMedge)*edge_buffer_alloc);
if (edge_buffer_next == 0)
{
fprintf(stderr,"malloc for edge buffer failed\n");
return 0;
}
for (int i = 0; i < edge_buffer_alloc; i++)
{
edge_buffer_next[i].buffer_next = &(edge_buffer_next[i+1]);
}
edge_buffer_next[edge_buffer_alloc-1].buffer_next = 0;
edge_buffer_alloc = 2*edge_buffer_alloc;
}
// get index of next available vertex
SMedge* edge = edge_buffer_next;
edge_buffer_next = edge->buffer_next;
edge->origin = 0;
edge->target = 0;
edge->degree = 1;
VecCopy3fv(edge->across,v);
edge_buffer_size++; if (edge_buffer_size > edge_buffer_maxsize) edge_buffer_maxsize = edge_buffer_size;
return edge;
}
void SMwriter_smc_old::write_vertex(const float* v_pos_f)
{
if (v_count + f_count == 0) write_header();
SMvertex* vertex = allocVertex();
vertex->index = v_count;
VecCopy3fv(vertex->v, v_pos_f);
vertex_hash->insert(my_vertex_hash::value_type(v_count, vertex));
v_count++;
}
int SMreadPostAsCompactPre::read_postorder_input()
{
int i;
SMvertex* vertex;
SMtriangle* triangle;
my_hash::iterator hash_element;
SMevent event = smreader->read_element();
if (event == SM_TRIANGLE)
{
// create triangle
triangle = allocTriangle();
// insert triangle into waiting area
waiting_area->addElement(triangle);
// process the triangle's vertices
for (i = 0; i < 3; i++)
{
// look for vertex in the hash
hash_element = vertex_hash->find(smreader->t_idx[i]);
// did we find the vertex in the hash
if (hash_element == vertex_hash->end())
{
// create vertex
vertex = allocVertex();
// insert vertex into hash
vertex_hash->insert(my_hash::value_type(smreader->t_idx[i], vertex));
}
else
{
// use vertex found in hash
vertex = (*hash_element).second;
}
// add vertex to triangle
triangle->vertices[i] = vertex;
// add triangle to vertex
if (vertex->list_size == vertex->list_alloc)
{
vertex->list_alloc += 4;
vertex->list = (SMtriangle**)realloc(vertex->list,vertex->list_alloc*sizeof(SMtriangle*));
}
vertex->list[vertex->list_size++] = triangle;
}
}
else if (event == SM_VERTEX)
{
// look for vertex in the vertex hash
hash_element = vertex_hash->find(smreader->v_idx);
// we inform the user if a vertex was not in the hash
if (hash_element == vertex_hash->end())
{
fprintf(stderr, "WARNING: post-order vertex not used by any triangle. skipping ...\n");
return 1;
}
// use vertex found in hash
vertex = vertex = (*hash_element).second;
// copy coordinates
VecCopy3fv(vertex->v, smreader->v_pos_f);
// finalizing vertex may make some triangles eligible for output
for (i = 0; i < vertex->list_size; i++)
{
triangle = vertex->list[i];
triangle->ready++;
if (triangle->ready == 3)
{
if (preserve_order) // we have to preserve the triangle order
{
if (triangle == waiting_area->getFirstElement())
{
waiting_area->removeFirstElement();
output_triangles->addElement(triangle);
// behind this triangle additional ready triangles may be waiting
while (waiting_area->size())
{
triangle = (SMtriangle*)waiting_area->getFirstElement();
if (triangle->ready == 3)
{
waiting_area->removeFirstElement();
output_triangles->addElement(triangle);
}
else
{
break;
}
}
}
}
else // we do not have to preserve the triangle order
{
waiting_area->removeElement(triangle);
output_triangles->addElement(triangle);
}
}
}
// remove vertex from hash
vertex_hash->erase(hash_element);
}
else if (event == SM_EOF)
{
if (vertex_hash->size())
{
fprintf(stderr, "FATAL ERROR: some outstanding vertices when reaching SM_EOF\n");
return -1;
}
else
{
return 0;
}
}
return 1;
}
int main(int argc, char *argv[])
{
char* file_name;
if (argc == 2)
{
file_name = argv[1];
}
else
{
fprintf(stderr,"usage:\n");
fprintf(stderr,"ps_load <file_name>\n");
exit(1);
}
PSreader* psreader = 0;
if (strstr(file_name, "compressed"))
{
PSreader_oocc* psreader_oocc = new PSreader_oocc();
psreader_oocc->open(file_name);
psreader = psreader_oocc;
}
else if (strstr(file_name, ".sma") || strstr(file_name, ".obj") || strstr(file_name, ".smf"))
{
FILE* sma_fp = fopen(file_name, "r");
if (sma_fp == 0)
{
fprintf(stderr,"ERROR: cannot open %s\n",file_name);
exit(1);
}
SMreader_sma* smreader_sma = new SMreader_sma();
smreader_sma->open(sma_fp);
PSconverter* psconverter = new PSconverter();
psconverter->open(smreader_sma, 256, 512);
psreader = psconverter;
}
else
{
fprintf(stderr,"ERROR: cannot guess input type from file name\n");
exit(1);
}
float* vertices = 0;
int vertices_alloced = 1024;
int vertices_number = 0;
int* faces = 0;
int faces_alloced = 512;
int faces_number = 0;
if (psreader->nverts == -1)
{
fprintf(stderr,"nverts not defined\n");
}
else
{
fprintf(stderr,"nverts %d\n",psreader->nverts);
vertices_alloced = psreader->nverts;
}
vertices = allocVertices(0, vertices_alloced);
if (psreader->nfaces == -1)
{
fprintf(stderr,"nfaces not defined\n");
}
else
{
fprintf(stderr,"nfaces %d\n",psreader->nfaces);
faces_alloced = psreader->nfaces;
}
faces = allocFaces(0, faces_alloced);
int i;
while(psreader->read_triangle())
{
// make sure there is memory for the next face
if (faces_number == faces_alloced)
{
faces_alloced *= 2;
faces = allocFaces(faces, faces_alloced);
}
// copy new face into memory
VecCopy3iv(&(faces[faces_number*3]), psreader->t_idx);
faces_number++;
for (i = 0; i < 3; i++)
{
// check for new vertices
if (PS_IS_NEW_VERTEX(psreader->t_vflag[i]))
{
// make sure there is memory for the next vertex
if (vertices_number == vertices_alloced)
{
vertices_alloced *= 2;
vertices = allocVertices(vertices, vertices_alloced);
}
// copy new face into memory
VecCopy3fv(&(vertices[vertices_number*3]), psreader->t_pos_f[i]);
vertices_number++;
}
}
}
fprintf(stderr,"vertex counters: %d %d %d (should be equal)\n",vertices_number,psreader->v_count,psreader->nverts);
fprintf(stderr,"face counters: %d %d %d (should be equal)\n",faces_number,psreader->f_count,psreader->nfaces);
psreader->close();
deallocVertices(vertices);
deallocFaces(faces);
return 1;
}
void veccopy3fv(float v[3], const float a[3]) {
VecCopy3fv(v, a);
}
