Pointer< Array<VertexData> > Loader3Ds::unroll_vertices(Lib3dsMesh *const lm) const {
//read vertex data
const Pointer< Array<VertexData> > pVertices = new Array<VertexData>(3*lm->nfaces);
VertexData *const vd = pVertices->base;
Array<vec3> aNormals( 3*lm->nfaces );
fill(*pVertices);
fill(aNormals);
lib3ds_mesh_calculate_vertex_normals( lm, aNormals.base );
for(int j=0; j<lm->nfaces; ++j) {
for(int k=0; k<3; ++k) {
const int vi = lm->faces[j].index[k];
const int x = 3*j+k;
memcpy(vd[x].pos, lm->vertices[vi], 3*sizeof(float));
memcpy(vd[x].nor, &aNormals[x], 3*sizeof(float));
memcpy(vd[x].tex, lm->texcos[vi], 2*sizeof(float));
}
}
return pVertices;
}
void write_mesh(FILE *o, Lib3dsFile *f, Lib3dsMeshInstanceNode *node) {
float (*orig_vertices)[3];
int export_texcos;
int export_normals;
int i, j;
Lib3dsMesh *mesh;
mesh = lib3ds_file_mesh_for_node(f, (Lib3dsNode*)node);
if (!mesh || !mesh->vertices) return;
fprintf(o, "# object %s\n", node->base.name);
fprintf(o, "g %s\n", node->instance_name[0]? node->instance_name : node->base.name);
orig_vertices = (float(*)[3])malloc(sizeof(float) * 3 * mesh->nvertices);
memcpy(orig_vertices, mesh->vertices, sizeof(float) * 3 * mesh->nvertices);
{
float inv_matrix[4][4], M[4][4];
float tmp[3];
int i;
lib3ds_matrix_copy(M, node->base.matrix);
lib3ds_matrix_translate(M, -node->pivot[0], -node->pivot[1], -node->pivot[2]);
lib3ds_matrix_copy(inv_matrix, mesh->matrix);
lib3ds_matrix_inv(inv_matrix);
lib3ds_matrix_mult(M, M, inv_matrix);
for (i = 0; i < mesh->nvertices; ++i) {
lib3ds_vector_transform(tmp, M, mesh->vertices[i]);
lib3ds_vector_copy(mesh->vertices[i], tmp);
}
}
export_texcos = (mesh->texcos != 0);
export_normals = (mesh->faces != 0);
for (i = 0; i < mesh->nvertices; ++i) {
fprintf(o, "v %f %f %f\n", mesh->vertices[i][0],
mesh->vertices[i][1],
mesh->vertices[i][2]);
}
fprintf(o, "# %d vertices\n", mesh->nvertices);
if (export_texcos) {
for (i = 0; i < mesh->nvertices; ++i) {
fprintf(o, "vt %f %f\n", mesh->texcos[i][0],
mesh->texcos[i][1]);
}
fprintf(o, "# %d texture vertices\n", mesh->nvertices);
}
if (export_normals) {
float (*normals)[3] = (float(*)[3])malloc(sizeof(float) * 9 * mesh->nfaces);
lib3ds_mesh_calculate_vertex_normals(mesh, normals);
for (i = 0; i < 3 * mesh->nfaces; ++i) {
fprintf(o, "vn %f %f %f\n", normals[i][0],
normals[i][1],
normals[i][2]);
}
free(normals);
fprintf(o, "# %d normals\n", 3 * mesh->nfaces);
}
{
int mat_index = -1;
for (i = 0; i < mesh->nfaces; ++i) {
if (mat_index != mesh->faces[i].material) {
mat_index = mesh->faces[i].material;
if (mat_index != -1) {
fprintf(o, "usemtl %s\n", f->materials[mat_index]->name);
}
}
fprintf(o, "f ");
for (j = 0; j < 3; ++j) {
fprintf(o, "%d", mesh->faces[i].index[j] + max_vertices + 1);
if (export_texcos) {
fprintf(o, "/%d", mesh->faces[i].index[j] + max_texcos + 1);
} else if (export_normals) {
fprintf(o, "/");
}
if (export_normals) {
fprintf(o, "/%d", 3 * i + j + max_normals + 1);
}
if (j < 3) {
fprintf(o, " ");
}
}
fprintf(o, "\n");
}
}
max_vertices += mesh->nvertices;
if (export_texcos)
max_texcos += mesh->nvertices;
if (export_normals)
max_normals += 3 * mesh->nfaces;
memcpy(mesh->vertices, orig_vertices, sizeof(float) * 3 * mesh->nvertices);
free(orig_vertices);
}
/*!
* Render node recursively, first children, then parent.
* Each node receives its own OpenGL display list.
*/
static void
render_node(Lib3dsNode *node) {
assert(file);
{
Lib3dsNode *p;
for (p = node->childs; p != 0; p = p->next) {
render_node(p);
}
}
if (node->type == LIB3DS_NODE_MESH_INSTANCE) {
int index;
Lib3dsMesh *mesh;
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
if (strcmp(node->name, "$$$DUMMY") == 0) {
return;
}
index = lib3ds_file_mesh_by_name(file, n->instance_name);
if (index < 0)
index = lib3ds_file_mesh_by_name(file, node->name);
if (index < 0) {
return;
}
mesh = file->meshes[index];
if (!mesh->user_id) {
assert(mesh);
mesh->user_id = glGenLists(1);
glNewList(mesh->user_id, GL_COMPILE);
{
int p;
float (*normalL)[3] = (float(*)[3])malloc(3 * 3 * sizeof(float) * mesh->nfaces);
Lib3dsMaterial *oldmat = (Lib3dsMaterial *) - 1;
{
float M[4][4];
lib3ds_matrix_copy(M, mesh->matrix);
lib3ds_matrix_inv(M);
glMultMatrixf(&M[0][0]);
}
lib3ds_mesh_calculate_vertex_normals(mesh, normalL);
for (p = 0; p < mesh->nfaces; ++p) {
Lib3dsMaterial *mat = 0;
#ifdef USE_SDL
Player_texture *pt = NULL;
int tex_mode = 0;
#endif
if (mesh->faces[p].material > 0) {
mat = file->materials[mesh->faces[p].material];
}
if (mat != oldmat) {
if (mat) {
if (mat->two_sided)
glDisable(GL_CULL_FACE);
else
glEnable(GL_CULL_FACE);
glDisable(GL_CULL_FACE);
/* Texturing added by Gernot < *****@*****.** > */
if (mat->texture1_map.name[0]) { /* texture map? */
Lib3dsTextureMap *tex = &mat->texture1_map;
if (!tex->user_ptr) { /* no player texture yet? */
char texname[1024];
pt = (Player_texture*)malloc(sizeof(*pt));
tex->user_ptr = pt;
//snprintf(texname, sizeof(texname), "%s/%s", datapath, tex->name);
strcpy(texname, datapath);
strcat(texname, "/");
strcat(texname, tex->name);
#ifdef DEBUG
printf("Loading texture map, name %s\n", texname);
#endif /* DEBUG */
#ifdef USE_SDL
#ifdef USE_SDL_IMG_load
pt->bitmap = IMG_load(texname);
#else
pt->bitmap = IMG_Load(texname);
#endif /* IMG_Load */
#else /* USE_SDL */
pt->bitmap = NULL;
fputs("3dsplayer: Warning: No image loading support, skipping texture.\n", stderr);
#endif /* USE_SDL */
if (pt->bitmap) { /* could image be loaded ? */
/* this OpenGL texupload code is incomplete format-wise!
* to make it complete, examine SDL_surface->format and
* tell us @lib3ds.sf.net about your improvements :-)
*/
int upload_format = GL_RED; /* safe choice, shows errors */
#ifdef USE_SDL
int bytespp = pt->bitmap->format->BytesPerPixel;
void *pixel = NULL;
glGenTextures(1, &pt->tex_id);
#ifdef DEBUG
printf("Uploading texture to OpenGL, id %d, at %d bytepp\n",
pt->tex_id, bytespp);
#endif /* DEBUG */
if (pt->bitmap->format->palette) {
pixel = convert_to_RGB_Surface(pt->bitmap);
upload_format = GL_RGBA;
} else {
pixel = pt->bitmap->pixels;
/* e.g. this could also be a color palette */
if (bytespp == 1) upload_format = GL_LUMINANCE;
else if (bytespp == 3) upload_format = GL_RGB;
else if (bytespp == 4) upload_format = GL_RGBA;
}
glBindTexture(GL_TEXTURE_2D, pt->tex_id);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA,
TEX_XSIZE, TEX_YSIZE, 0,
GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,
GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexSubImage2D(GL_TEXTURE_2D,
0, 0, 0, pt->bitmap->w, pt->bitmap->h,
upload_format, GL_UNSIGNED_BYTE, pixel);
pt->scale_x = (float)pt->bitmap->w / (float)TEX_XSIZE;
pt->scale_y = (float)pt->bitmap->h / (float)TEX_YSIZE;
#endif /* USE_SDL */
pt->valid = 1;
} else {
fprintf(stderr,
"Load of texture %s did not succeed "
"(format not supported !)\n",
texname);
pt->valid = 0;
}
} else {
pt = (Player_texture *)tex->user_ptr;
}
tex_mode = pt->valid;
} else {
tex_mode = 0;
}
{
float a[4], d[4], s[4];
int i;
for (i=0; i<3; ++i) {
a[i] = mat->ambient[i];
d[i] = mat->diffuse[i];
s[i] = mat->specular[i];
}
a[3] = d[3] = s[3] = 1.0f;
glMaterialfv(GL_FRONT, GL_AMBIENT, a);
glMaterialfv(GL_FRONT, GL_DIFFUSE, d);
glMaterialfv(GL_FRONT, GL_SPECULAR, s);
}
glMaterialf(GL_FRONT, GL_SHININESS, pow(2, 10.0*mat->shininess));
} else {
static const float a[4] = {0.7, 0.7, 0.7, 1.0};
static const float d[4] = {0.7, 0.7, 0.7, 1.0};
static const float s[4] = {1.0, 1.0, 1.0, 1.0};
glMaterialfv(GL_FRONT, GL_AMBIENT, a);
glMaterialfv(GL_FRONT, GL_DIFFUSE, d);
glMaterialfv(GL_FRONT, GL_SPECULAR, s);
glMaterialf(GL_FRONT, GL_SHININESS, pow(2, 10.0*0.5));
}
oldmat = mat;
}
else if (mat != NULL && mat->texture1_map.name[0]) {
Lib3dsTextureMap *tex = &mat->texture1_map;
if (tex != NULL && tex->user_ptr != NULL) {
pt = (Player_texture *)tex->user_ptr;
tex_mode = pt->valid;
}
}
{
int i;
#ifndef USE_GL10
if (tex_mode) {
//printf("Binding texture %d\n", pt->tex_id);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, pt->tex_id);
}
#endif
#if 0
{
float v1[3], n[3], v2[3];
glBegin(GL_LINES);
for (i = 0; i < 3; ++i) {
lib3ds_vector_copy(v1, mesh->vertices[f->points[i]]);
glVertex3fv(v1);
lib3ds_vector_copy(n, normalL[3*p+i]);
lib3ds_vector_scalar(n, 10.f);
lib3ds_vector_add(v2, v1, n);
glVertex3fv(v2);
}
glEnd();
}
#endif
glBegin(GL_TRIANGLES);
for (i = 0; i < 3; ++i) {
glNormal3fv(normalL[3*p+i]);
if (tex_mode) {
glTexCoord2f(
mesh->texcos[mesh->faces[p].index[i]][1]*pt->scale_x,
pt->scale_y - mesh->texcos[mesh->faces[p].index[i]][0]*pt->scale_y);
}
glVertex3fv(mesh->vertices[mesh->faces[p].index[i]]);
}
glEnd();
if (tex_mode)
glDisable(GL_TEXTURE_2D);
}
}
free(normalL);
}
glEndList();
}
if (mesh->user_id) {
glPushMatrix();
glMultMatrixf(&node->matrix[0][0]);
glTranslatef(-n->pivot[0], -n->pivot[1], -n->pivot[2]);
glCallList(mesh->user_id);
/* glutSolidSphere(50.0, 20,20); */
glPopMatrix();
if (flush)
glFlush();
}
}
}
std::vector<CL_Lib3dsMesh> CL_Lib3dsFile::export_meshes(Lib3dsNode *node)
{
if (node == 0)
{
lib3ds_file_eval(file, 0.0f);
node = file->nodes;
}
std::vector<CL_Lib3dsMesh> meshes;
for (; node; node = node->next)
{
if (node->type == LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode *instance_node = (Lib3dsMeshInstanceNode *) node;
Lib3dsMesh *mesh = lib3ds_file_mesh_for_node(file, (Lib3dsNode*)node);
if (mesh && mesh->vertices)
{
float inv_matrix[4][4], M[4][4];
lib3ds_matrix_copy(M, instance_node->base.matrix);
lib3ds_matrix_translate(M, -instance_node->pivot[0], -instance_node->pivot[1], -instance_node->pivot[2]);
lib3ds_matrix_copy(inv_matrix, mesh->matrix);
lib3ds_matrix_inv(inv_matrix);
lib3ds_matrix_mult(M, M, inv_matrix);
std::vector<CL_Vec3f> positions;
for (int i = 0; i < mesh->nvertices; ++i)
{
float position[3];
lib3ds_vector_transform(position, M, mesh->vertices[i]);
positions.push_back(CL_Vec3f(position[0], position[1], position[2]));
}
std::vector<CL_Vec2f> texcoords;
if (mesh->texcos)
{
for (int i = 0; i < mesh->nvertices; ++i)
{
float tx = mesh->texcos[i][0];
float ty = mesh->texcos[i][1];
texcoords.push_back(CL_Vec2f(tx, ty));
}
}
std::vector<CL_Vec3f> normals;
if (mesh->faces && mesh->nfaces > 0)
{
float (*normals_array)[3] = (float(*)[3])malloc(sizeof(float) * 9 * mesh->nfaces);
lib3ds_mesh_calculate_vertex_normals(mesh, normals_array);
for (int i = 0; i < 3 * mesh->nfaces; ++i)
{
normals.push_back(CL_Vec3f(normals_array[i][0], normals_array[i][1], normals_array[i][2]));
}
free(normals_array);
}
CL_Lib3dsMesh mesh_object;
for (int i = 0; i < mesh->nfaces; ++i)
{
int material_index = mesh->faces[i].material;
mesh_object.face_materials.push_back(material_index);
for (int j = 0; j < 3; ++j)
{
int vertex_index = mesh->faces[i].index[j];
mesh_object.positions.push_back(positions[vertex_index]);
if (!texcoords.empty())
mesh_object.texcooords.push_back(texcoords[vertex_index]);
if (!normals.empty())
mesh_object.normals.push_back(normals[i*3+j]);
}
}
meshes.push_back(mesh_object);
}
if (node->childs)
{
std::vector<CL_Lib3dsMesh> child_meshes = export_meshes(node->childs);
meshes.insert(meshes.end(), child_meshes.begin(), child_meshes.end());
}
}
}
return meshes;
}
