obj_t::obj_t( const char * objname )
{
// long name
fullpath = realname( objname );
// model handle
const char * shortname = strip_path_and_extension( objname );
name = copy_string( shortname );
// memory map file
mmfile_t mm( fullpath );
index = 0;
size = mm.size;
data = mm.data;
while ( index < size )
{
strip_white_space();
switch( data[i] )
{
case 'm':
if ( check_name( "mtllib" ) )
consume_line();
break;
case 'u':
if ( check_name( "usemtl" ) )
consume_line();
break;
case 'g':
consume_line();
break;
case '#':
strip_white_space();
break;
case 'v':
if ( check_name( "vn" ) )
add_normal();
else if ( check_name( "vt" ) )
add_texcoord();
else if ( data[index+1] == ' ' )
add_vertex();
else
core.warn( "obj_t: straggling v in objfile: %s", name );
break;
case 'f':
if ( data[index+1] == ' ' )
add_face();
break;
case 's':
default:
++index;
break;
}
}
}
void mesh_parametric::set_plane_xy_unit(int const size_u_param,int const size_v_param)
{
ASSERT_CPE(size_u_param>0 && size_v_param>0 , "Problem of mesh size");
size_u_data = size_u_param;
size_v_data = size_v_param;
//set data
for(int kv=0 ; kv<size_v_param ; ++kv)
{
float const v = static_cast<float>(kv)/(size_v_param-1);
for(int ku=0 ; ku<size_u_param ; ++ku)
{
float const u = static_cast<float>(ku)/(size_u_param-1);
add_vertex( {u,v,0.0f} );
add_texture_coord( {u,v} );
add_normal( {0.0f,0.0f,1.0f} );
}
}
//set connectivity
for(int kv=0 ; kv<size_v_param-1 ; ++kv)
{
for(int ku=0 ; ku<size_u_param-1 ; ++ku)
{
int const offset = ku+size_u_param*kv;
triangle_index tri0 = {offset,offset+1,offset+size_u_param+1};
triangle_index tri1 = {offset,offset+size_u_param+1,offset+size_u_param};
add_triangle_index(tri0);
add_triangle_index(tri1);
}
}
fill_empty_field_by_default();
ASSERT_CPE(valid_mesh(),"Mesh is not valid");
}
struct model *load_obj_model(char *filename)
{
char dirname[1024];
char line[200];
struct model *model;
struct mesh *curmesh = NULL;
int fvp[20], fvt[20], fvn[20];
char *p, *s;
int i, n;
FILE *fp;
strlcpy(dirname, filename, sizeof dirname);
p = strrchr(dirname, '/');
if (!p) p = strrchr(dirname, '\\');
if (p) *p = 0;
else strlcpy(dirname, ".", sizeof dirname);
printf("loading obj model: %s\n", filename);
fp = fopen(filename, "r");
if (!fp) {
fprintf(stderr, "error: cannot load model '%s'\n", filename);
return NULL;
}
model = malloc(sizeof(struct model));
memset(model, 0, sizeof(struct model));
model->min[0] = model->min[1] = model->min[2] = 1e10;
model->max[0] = model->max[1] = model->max[2] = -1e10;
model->radius = 0;
while (1) {
if (!fgets(line, sizeof line, fp))
break;
s = strtok(line, SEP);
if (!s) {
continue;
} else if (!strcmp(s, "v")) {
char *x = strtok(NULL, SEP);
char *y = strtok(NULL, SEP);
char *z = strtok(NULL, SEP);
add_position(model, atof(x), atof(y), atof(z));
} else if (!strcmp(s, "vt")) {
char *u = strtok(NULL, SEP);
char *v = strtok(NULL, SEP);
add_texcoord(model, atof(u), atof(v));
} else if (!strcmp(s, "vn")) {
char *x = strtok(NULL, SEP);
char *y = strtok(NULL, SEP);
char *z = strtok(NULL, SEP);
add_normal(model, atof(x), atof(y), atof(z));
} else if (!strcmp(s, "f")) {
n = 0;
s = strtok(NULL, SEP);
while (s) {
if (*s) {
splitfv(s, fvp+n, fvt+n, fvn+n);
n++;
}
s = strtok(NULL, SEP);
}
for (i = 1; i < n - 1; i++) {
add_triangle(curmesh,
fvp[0], fvt[0], fvn[0],
fvp[i], fvt[i], fvn[i],
fvp[i+1], fvt[i+1], fvn[i+1]);
}
} else if (!strcmp(s, "mtllib")) {
s = strtok(NULL, SEP);
model->material = load_material(dirname, s);
} else if (!strcmp(s, "usemtl")) {
s = strtok(NULL, SEP);
curmesh = find_mesh(model, s);
}
}
model->radius = sqrtf(model->radius);
fclose(fp);
return model;
}
void MarchingCubes::create_marching_cubes_from_array(const T* scalar_field, CVector mesh_dimensions, CVector box_length, double threshold, bool larger_than) {
int nx = mesh_dimensions.x;
int ny = mesh_dimensions.y;
int nz = mesh_dimensions.z;
initialize(nx*ny*nz);
num_vertices = 0;
num_triangles = 0;
Random *rnd = new Random(-time(NULL), 0, 0);
float r = 111/255.0;
float g = 133/255.0;
float b = 144/255.0;
// float r = rnd->next_double();
// float g = rnd->next_double();
// float b = rnd->next_double();
CIsoSurface<T> surf;
surf.GenerateSurface(scalar_field,threshold,nx-1,ny-1,nz-1,box_length.x, box_length.y, box_length.z, larger_than);
for(int triangle=0; triangle<surf.m_nTriangles; triangle++) {
unsigned int p1_index = surf.m_piTriangleIndices[3*triangle+0];
unsigned int p2_index = surf.m_piTriangleIndices[3*triangle+1];
unsigned int p3_index = surf.m_piTriangleIndices[3*triangle+2];
CVector p1(surf.m_ppt3dVertices[p1_index][0], surf.m_ppt3dVertices[p1_index][1], surf.m_ppt3dVertices[p1_index][2]);
CVector p2(surf.m_ppt3dVertices[p2_index][0], surf.m_ppt3dVertices[p2_index][1], surf.m_ppt3dVertices[p2_index][2]);
CVector p3(surf.m_ppt3dVertices[p3_index][0], surf.m_ppt3dVertices[p3_index][1], surf.m_ppt3dVertices[p3_index][2]);
VECTOR3D &norm1 = surf.m_pvec3dNormals[p1_index];
VECTOR3D &norm2 = surf.m_pvec3dNormals[p2_index];
VECTOR3D &norm3 = surf.m_pvec3dNormals[p3_index];
// CVector n1 = (p2 - p1).cross(p3 - p1).normalize();
// CVector n2 = (p2 - p1).cross(p3 - p1).normalize();
// CVector n3 = (p2 - p1).cross(p3 - p1).normalize();
CVector n1(norm1[0], norm1[1], norm1[2]);
CVector n2(norm2[0], norm2[1], norm2[2]);
CVector n3(norm3[0], norm3[1], norm3[2]);
CVector color(r,g,b);
// n1 = n1*(-1);
// n2 = n2*(-1);
// n3 = n3*(-1);
add_vertex(p1);
add_normal(n1);
add_color(color, 1.0);
add_vertex(p2);
add_normal(n2);
add_color(color, 1.0);
add_vertex(p3);
add_normal(n3);
add_color(color, 1.0);
continue;
n1 = n1*(-1);
n2 = n2*(-1);
n3 = n3*(-1);
p1 = p1+n1*0.01;
p2 = p2+n2*0.01;
p3 = p3+n3*0.01;
add_vertex(p1);
add_normal(n1);
add_color(color, 1.0);
add_vertex(p2);
add_normal(n2);
add_color(color, 1.0);
add_vertex(p3);
add_normal(n3);
add_color(color, 1.0);
}
cout << "Marching cubes created with " << surf.m_nTriangles << " triangles." << endl;
}
struct model *load_obj_from_memory(const char *filename, unsigned char *data, int len)
{
char dirname[1024];
char *line, *next, *p, *s;
struct model *model;
struct mesh *mesh;
int fvp[20], fvt[20], fvn[20];
int first, material;
int i, n;
printf("loading obj model '%s'\n", filename);
strlcpy(dirname, filename, sizeof dirname);
p = strrchr(dirname, '/');
if (!p) p = strrchr(dirname, '\\');
if (p) *p = 0;
else strlcpy(dirname, "", sizeof dirname);
mtl_count = 0;
position.len = 0;
texcoord.len = 0;
normal.len = 0;
element.len = 0;
part.len = 0;
first = 0;
material = 0;
data[len-1] = 0; /* over-write final newline to zero-terminate */
for (line = (char*)data; line; line = next) {
next = strchr(line, '\n');
if (next)
*next++ = 0;
s = strtok(line, SEP);
if (!s) {
continue;
} else if (!strcmp(s, "v")) {
char *x = strtok(NULL, SEP);
char *y = strtok(NULL, SEP);
char *z = strtok(NULL, SEP);
add_position(atof(x), atof(y), atof(z));
} else if (!strcmp(s, "vt")) {
char *u = strtok(NULL, SEP);
char *v = strtok(NULL, SEP);
add_texcoord(atof(u), atof(v));
} else if (!strcmp(s, "vn")) {
char *x = strtok(NULL, SEP);
char *y = strtok(NULL, SEP);
char *z = strtok(NULL, SEP);
add_normal(atof(x), atof(y), atof(z));
} else if (!strcmp(s, "f")) {
n = 0;
s = strtok(NULL, SEP);
while (s) {
if (*s) {
splitfv(s, fvp+n, fvn+n, fvt+n);
n++;
}
s = strtok(NULL, SEP);
}
for (i = 1; i < n - 1; i++) {
add_triangle(fvp[0], fvn[0], fvt[0],
fvp[i], fvn[i], fvt[i],
fvp[i+1], fvn[i+1], fvt[i+1]);
}
} else if (!strcmp(s, "mtllib")) {
s = strtok(NULL, SEP);
mtllib(dirname, s);
} else if (!strcmp(s, "usemtl")) {
if (element.len > first)
push_part(&part, first, element.len, material);
s = strtok(NULL, SEP);
material = usemtl(s);
first = element.len;
}
}
if (element.len > first)
push_part(&part, first, element.len, material);
printf("\t%d parts; %d vertices; %d triangles", part.len, vertex.len/8, element.len/3);
mesh = malloc(sizeof(struct mesh));
mesh->tag = TAG_MESH;
mesh->enabled = 1<<ATT_POSITION | 1<<ATT_NORMAL | 1<<ATT_TEXCOORD;
mesh->skel = NULL;
mesh->inv_bind_matrix = NULL;
mesh->count = part.len;
mesh->part = malloc(part.len * sizeof(struct part));
memcpy(mesh->part, part.data, part.len * sizeof(struct part));
glGenVertexArrays(1, &mesh->vao);
glGenBuffers(1, &mesh->vbo);
glGenBuffers(1, &mesh->ibo);
glBindVertexArray(mesh->vao);
glBindBuffer(GL_ARRAY_BUFFER, mesh->vbo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->ibo);
glBufferData(GL_ARRAY_BUFFER, vertex.len * 4, vertex.data, GL_STATIC_DRAW);
glEnableVertexAttribArray(ATT_POSITION);
glEnableVertexAttribArray(ATT_NORMAL);
glEnableVertexAttribArray(ATT_TEXCOORD);
glVertexAttribPointer(ATT_POSITION, 3, GL_FLOAT, 0, 32, (void*)0);
glVertexAttribPointer(ATT_NORMAL, 3, GL_FLOAT, 0, 32, (void*)20);
glVertexAttribPointer(ATT_TEXCOORD, 2, GL_FLOAT, 0, 32, (void*)12);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, element.len * 2, element.data, GL_STATIC_DRAW);
model = malloc(sizeof *model);
model->skel = NULL;
model->mesh = mesh;
model->anim = NULL;
return model;
}
