int main(int argc, char* argv[]) {
Mesh* mesh = create_mesh();
mesh_write("quad.mesh", mesh);
mesh_destroy(mesh);
Application app("my x11/win32 window", 600, 600, true);
return app.run();
}
int main ( int argc, char *argv[] )
/******************************************************************************/
/*
Purpose:
MAIN is the main program for TRIANGLE_TO_MEDIT.
Discussion:
The TRIANGLE program creates "node" and "element" files that define
a triangular mesh. A typical pair of such files might have the names
"suv.node" and "suv.ele".
This program reads this pair of files and creates a MEDIT mesh file, whose
name might be "suv.mesh".
Usage:
triangle_to_medit prefix
where 'prefix' is the common filename prefix so that:
* prefix.node contains the coordinates of the nodes;
* prefix.ele contains the indices of nodes forming each element.
* prefix.mesh will be the MESH file created by the program.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
07 December 2010
Author:
John Burkardt
*/
{
int dim;
int *edge_label;
int *edge_vertex;
int edges;
double *element_att;
int element_att_num;
char element_filename[255];
int *element_node;
int element_num;
int element_order;
int *hexahedron_label;
int *hexahedron_vertex;
int hexahedrons;
int i;
int j;
char mesh_filename[255];
double *node_att;
int node_att_num;
char node_filename[255];
int *node_marker;
double *node_coord;
int node_dim;
int node_marker_num;
int node_num;
char prefix[255];
int *quadrilateral_label;
int *quadrilateral_vertex;
int quadrilaterals;
int *tetrahedron_label;
int *tetrahedron_vertex;
int tetrahedrons;
int *triangle_label;
int *triangle_vertex;
int triangles;
double *vertex_coordinate;
int *vertex_label;
int vertices;
timestamp ( );
printf ( "\n" );
printf ( "TRIANGLE_TO_MEDIT:\n" );
printf ( " C version\n" );
printf ( " Read a pair of NODE and ELE files created by TRIANGLE.\n" );
printf ( " Write a corresponding MEDIT mesh file.\n" );
/*
Get the filename prefix.
*/
if ( 1 <= argc )
{
strcpy ( prefix, argv[1] );
}
else
{
printf ( "\n" );
printf ( " Please enter the filename prefix:\n" );
scanf ( "%s", prefix );
}
/*
Create the file names.
*/
strcpy ( node_filename, prefix );
strcat ( node_filename, ".node" );
strcpy ( element_filename, prefix );
strcat ( element_filename, ".ele" );
strcpy ( mesh_filename, prefix );
strcat ( mesh_filename, ".mesh" );
printf ( "\n" );
printf ( " Read:\n" );
printf ( " * TRIANGLE node file \"%s\"\n", node_filename );
printf ( " * TRIANGLE element file \"%s\"\n", element_filename );
printf ( " Create:\n" );
printf ( " * MEDIT mesh file \"%s\"\n", mesh_filename );
/*
Read the TRIANGLE NODE data.
*/
node_size_read ( node_filename, &node_num, &node_dim, &node_att_num,
&node_marker_num );
node_coord = ( double * ) malloc ( 2 * node_num * sizeof ( double ) );
node_att = ( double * ) malloc ( node_att_num * node_num * sizeof ( double ) );
node_marker = ( int * ) malloc ( node_num * sizeof ( int ) );
node_data_read ( node_filename, node_num, node_dim, node_att_num,
node_marker_num, node_coord, node_att, node_marker );
/*
Read the TRIANGLE ELE data.
*/
element_size_read ( element_filename, &element_num, &element_order,
&element_att_num );
element_node = ( int * ) malloc ( element_order * element_num * sizeof ( int ) );
element_att = ( double * ) malloc ( element_att_num * element_num * sizeof ( double ) );
element_data_read ( element_filename, element_num, element_order,
element_att_num, element_node, element_att );
/*
Write the MEDIT data.
*/
dim = 2;
vertices = node_num;
edges = 0;
triangles = element_num;
quadrilaterals = 0;
tetrahedrons = 0;
hexahedrons = 0;
vertex_coordinate = ( double * ) malloc ( 2 * vertices * sizeof ( double ) );
for ( j = 0; j < vertices; j++ )
{
for ( i = 0; i < 2; i++ )
{
vertex_coordinate[i+j*2] = node_coord[i+j*2];
}
}
vertex_label = ( int * ) malloc ( vertices * sizeof ( int ) );
for ( j = 0; j < vertices; j++ )
{
vertex_label[j] = node_marker[j];
}
edge_vertex = NULL;
edge_label = NULL;
triangle_vertex = ( int * ) malloc ( 3 * triangles * sizeof ( int ) );
for ( j = 0; j < triangles; j++ )
{
for ( i = 0; i < 3; i++ )
{
triangle_vertex[i+j*3] = element_node[i+j*3];
}
}
triangle_label = ( int * ) malloc ( triangles * sizeof ( int ) );
for ( j = 0; j < triangles; j++ )
{
triangle_label[j] = 0;
}
quadrilateral_vertex = NULL;
quadrilateral_label = NULL;
tetrahedron_vertex = NULL;
tetrahedron_label = NULL;
hexahedron_vertex = NULL;
hexahedron_label = NULL;
mesh_write ( mesh_filename, dim, vertices, edges, triangles, quadrilaterals,
tetrahedrons, hexahedrons, vertex_coordinate, vertex_label, edge_vertex,
edge_label, triangle_vertex, triangle_label, quadrilateral_vertex,
quadrilateral_label, tetrahedron_vertex, tetrahedron_label,
hexahedron_vertex, hexahedron_label );
/*
Free memory.
*/
free ( element_att );
free ( element_node );
free ( node_att );
free ( node_coord );
free ( node_marker );
free ( triangle_label );
free ( triangle_vertex );
/*
Terminate.
*/
printf ( "\n" );
printf ( "TRIANGLE_TO_MEDIT:\n" );
printf ( " Normal end of execution.\n" );
printf ( "\n" );
timestamp ( );
return 0;
}
void test01 ( )
/******************************************************************************/
/*
Purpose:
TEST01 creates a MESH dataset and writes it to a file.
Licensing:
This code is distributed under the GNU LGPL license.
Modified:
22 November 2010
Author:
John Burkardt
*/
{
int dim;
int *edge_label;
int *edge_vertex;
int edges;
char filename[255];
int *hexahedron_label;
int *hexahedron_vertex;
int hexahedrons;
int *quadrilateral_label;
int *quadrilateral_vertex;
int quadrilaterals;
int *tetrahedron_label;
int *tetrahedron_vertex;
int tetrahedrons;
int *triangle_label;
int *triangle_vertex;
int triangles;
double *vertex_coordinate;
int *vertex_label;
int vertices;
printf ( "\n" );
printf ( "TEST01:\n" );
printf ( " Create a hexahedral mesh and write it to a file.\n" );
/*
Get sizes.
*/
hexahexa_2x2x2_size ( &dim, &vertices, &edges, &triangles, &quadrilaterals,
&tetrahedrons, &hexahedrons );
/*
Allocate memory.
*/
edge_label = ( int * ) malloc ( edges * sizeof ( int ) );
edge_vertex = ( int * ) malloc ( 2 * edges * sizeof ( int ) );
hexahedron_label = ( int * ) malloc ( hexahedrons * sizeof ( int ) );
hexahedron_vertex = ( int * ) malloc ( 8 * hexahedrons * sizeof ( int ) );
quadrilateral_label = ( int * ) malloc ( quadrilaterals * sizeof ( int ) );
quadrilateral_vertex = ( int * ) malloc ( 4 * quadrilaterals * sizeof ( int ) );
tetrahedron_label = ( int * ) malloc ( tetrahedrons * sizeof ( int ) );
tetrahedron_vertex = ( int * ) malloc ( 4 * tetrahedrons * sizeof ( int ) );
triangle_label = ( int * ) malloc ( triangles * sizeof ( int ) );
triangle_vertex = ( int * ) malloc ( 3 * triangles * sizeof ( int ) );
vertex_coordinate = ( double * ) malloc ( dim * vertices * sizeof ( double ) );
vertex_label = ( int * ) malloc ( vertices * sizeof ( int ) );
/*
Get the data.
*/
hexahexa_2x2x2_data ( dim, vertices, edges, triangles,
quadrilaterals, tetrahedrons, hexahedrons, vertex_coordinate, vertex_label,
edge_vertex, edge_label, triangle_vertex, triangle_label,
quadrilateral_vertex, quadrilateral_label, tetrahedron_vertex,
tetrahedron_label, hexahedron_vertex, hexahedron_label );
/*
Write the data.
*/
strcpy ( filename, "hexahexa_2x2x2.mesh" );
mesh_write ( filename, dim, vertices, edges, triangles,
quadrilaterals, tetrahedrons, hexahedrons, vertex_coordinate,
vertex_label, edge_vertex, edge_label, triangle_vertex, triangle_label,
quadrilateral_vertex, quadrilateral_label, tetrahedron_vertex,
tetrahedron_label, hexahedron_vertex, hexahedron_label );
printf ( "\n" );
printf ( " Created the file \"%s\".\n", filename );
/*
Deallocate memory.
*/
free ( edge_label );
free ( edge_vertex );
free ( hexahedron_label );
free ( hexahedron_vertex );
free ( quadrilateral_label );
free ( quadrilateral_vertex );
free ( tetrahedron_label );
free ( tetrahedron_vertex );
free ( triangle_label );
free ( triangle_vertex );
free ( vertex_coordinate );
free ( vertex_label );
return;
}
void CreateGeometry::save_mesh() {
int32_t attributeOffsets[Mesh::MaxAttributes];
for(int i = 0; i < Mesh::MaxAttributes; i++)
attributeOffsets[i] = -1;
size_t offset = indices.size() * sizeof(uint16_t);
attributeOffsets[Mesh::Vertex] = offset;
offset += position.size() * Mesh::get_stride(Mesh::Vertex);
if(!normal.empty()) {
attributeOffsets[Mesh::Normal] = offset;
offset += position.size() * Mesh::get_stride(Mesh::Normal);
}
if(!sTangent.empty() && !tTangent.empty()) {
attributeOffsets[Mesh::STangent] = offset;
offset += position.size() * Mesh::get_stride(Mesh::STangent);
attributeOffsets[Mesh::TTangent] = offset;
offset += position.size() * Mesh::get_stride(Mesh::TTangent);
}
if(!color.empty()) {
attributeOffsets[Mesh::Color] = offset;
offset += position.size() * Mesh::get_stride(Mesh::Color);
}
if(!texCoord.empty()) {
attributeOffsets[Mesh::TexCoord] = offset;
offset += position.size() * Mesh::get_stride(Mesh::TexCoord);
}
if(!boneIds.empty() && !weights.empty()) {
attributeOffsets[Mesh::BoneIds] = offset;
offset += position.size() * Mesh::get_stride(Mesh::BoneIds);
attributeOffsets[Mesh::Weigths] = offset;
offset += position.size() * Mesh::get_stride(Mesh::Weigths);
}
int32_t batch_offset = offset;
offset += batches.size() * sizeof(Batch);
Mesh* mesh = (Mesh*)malloc(sizeof(Mesh) + offset);
mesh->batch_offset = batch_offset;
mesh->batch_count = (uint16_t)batches.size();
mesh->vertex_count = (uint16_t)position.size();
mesh->index_count = (uint16_t)indices.size();
memcpy(mesh->offsets, attributeOffsets, sizeof(attributeOffsets));
memcpy(mesh->index_pointer(), indices.data(), mesh->index_count*sizeof(uint16_t));
memcpy(mesh->batches_pointer(), batches.data(), mesh->batch_count*sizeof(Batch));
memcpy(mesh->get_pointer(Mesh::Vertex), position.data(), mesh->vertex_count*Mesh::get_stride(Mesh::Vertex));
if(mesh->offsets[Mesh::Normal] != -1)
memcpy(mesh->get_pointer(Mesh::Normal), normal.data(), mesh->vertex_count*Mesh::get_stride(Mesh::Normal));
if(mesh->offsets[Mesh::STangent] != -1)
memcpy(mesh->get_pointer(Mesh::STangent), sTangent.data(), mesh->vertex_count*Mesh::get_stride(Mesh::STangent));
if(mesh->offsets[Mesh::TTangent] != -1)
memcpy(mesh->get_pointer(Mesh::TTangent), tTangent.data(), mesh->vertex_count*Mesh::get_stride(Mesh::TTangent));
if(mesh->offsets[Mesh::Color] != -1)
memcpy(mesh->get_pointer(Mesh::Color), color.data(), mesh->vertex_count*Mesh::get_stride(Mesh::Color));
if(mesh->offsets[Mesh::TexCoord] != -1)
memcpy(mesh->get_pointer(Mesh::TexCoord), texCoord.data(), mesh->vertex_count*Mesh::get_stride(Mesh::TexCoord));
if(mesh->offsets[Mesh::BoneIds] != -1)
memcpy(mesh->get_pointer(Mesh::BoneIds), boneIds.data(), mesh->vertex_count*Mesh::get_stride(Mesh::BoneIds));
if(mesh->offsets[Mesh::Weigths] != -1)
memcpy(mesh->get_pointer(Mesh::Weigths), weights.data(), mesh->vertex_count*Mesh::get_stride(Mesh::Weigths));
mesh_write(output.c_str(), mesh);
mesh_destroy(mesh);
}
