/*!
* Find the bounding box of a mesh object.
*
* \param mesh The mesh object
* \param min Returned bounding box
* \param max Returned bounding box
*
* \ingroup mesh
*/
void
lib3ds_mesh_bounding_box(Lib3dsMesh *mesh, Lib3dsVector min, Lib3dsVector max)
{
unsigned i,j;
Lib3dsFloat v;
if (!mesh->points) {
lib3ds_vector_zero(min);
lib3ds_vector_zero(max);
return;
}
lib3ds_vector_copy(min, mesh->pointL[0].pos);
lib3ds_vector_copy(max, mesh->pointL[0].pos);
for (i=1; i<mesh->points; ++i) {
for (j=0; j<3; ++j) {
v=mesh->pointL[i].pos[j];
if (v<min[j]) {
min[j]=v;
}
if (v>max[j]) {
max[j]=v;
}
}
};
}
void
lib3ds_track_eval_vector(Lib3dsTrack *track, float v[3], float t) {
lib3ds_vector_zero(v);
if (track) {
assert(track->type == LIB3DS_TRACK_VECTOR);
track_eval_linear(track, v, t);
}
}
/*!
* \ingroup tracks
*/
void
lib3ds_lin3_key_setup(Lib3dsLin3Key *p, Lib3dsLin3Key *cp, Lib3dsLin3Key *c,
Lib3dsLin3Key *cn, Lib3dsLin3Key *n)
{
Lib3dsVector np,nn;
Lib3dsFloat ksm,ksp,kdm,kdp;
int i;
ASSERT(c);
if (!cp) {
cp=c;
}
if (!cn) {
cn=c;
}
if (!p && !n) {
lib3ds_vector_zero(c->ds);
lib3ds_vector_zero(c->dd);
return;
}
if (n && p) {
lib3ds_tcb(&p->tcb, &cp->tcb, &c->tcb, &cn->tcb, &n->tcb, &ksm, &ksp, &kdm, &kdp);
lib3ds_vector_sub(np, c->value, p->value);
lib3ds_vector_sub(nn, n->value, c->value);
for(i=0; i<3; ++i) {
c->ds[i]=ksm*np[i] + ksp*nn[i];
c->dd[i]=kdm*np[i] + kdp*nn[i];
}
}
else {
if (p) {
lib3ds_vector_sub(np, c->value, p->value);
lib3ds_vector_copy(c->ds, np);
lib3ds_vector_copy(c->dd, np);
}
if (n) {
lib3ds_vector_sub(nn, n->value, c->value);
lib3ds_vector_copy(c->ds, nn);
lib3ds_vector_copy(c->dd, nn);
}
}
}
/*!
* \ingroup tracks
*/
void
lib3ds_lin3_track_setup(Lib3dsLin3Track *track)
{
Lib3dsLin3Key *pp,*pc,*pn,*pl;
ASSERT(track);
pc=track->keyL;
if (!pc) {
return;
}
if (!pc->next) {
lib3ds_vector_zero(pc->ds);
lib3ds_vector_zero(pc->dd);
return;
}
if (track->flags&LIB3DS_SMOOTH) {
for (pl=track->keyL; pl->next->next; pl=pl->next);
lib3ds_lin3_key_setup(pl, pl->next, pc, 0, pc->next);
}
else {
lib3ds_lin3_key_setup(0, 0, pc, 0, pc->next);
}
for (;;) {
pp=pc;
pc=pc->next;
pn=pc->next;
if (!pn) {
break;
}
lib3ds_lin3_key_setup(pp, 0, pc, 0, pn);
}
if (track->flags&LIB3DS_SMOOTH) {
lib3ds_lin3_key_setup(pp, 0, pc, track->keyL, track->keyL->next);
}
else {
lib3ds_lin3_key_setup(pp, 0, pc, 0, 0);
}
}
/*!
* \ingroup tracks
*/
void
lib3ds_lin3_track_eval(Lib3dsLin3Track *track, Lib3dsVector p, Lib3dsFloat t)
{
Lib3dsLin3Key *k;
Lib3dsFloat nt;
Lib3dsFloat u;
if (!track->keyL) {
lib3ds_vector_zero(p);
return;
}
if (!track->keyL->next) {
lib3ds_vector_copy(p, track->keyL->value);
return;
}
for (k=track->keyL; k->next!=0; k=k->next) {
if ((t>=(Lib3dsFloat)k->tcb.frame) && (t<(Lib3dsFloat)k->next->tcb.frame)) {
break;
}
}
if (!k->next) {
if (track->flags&LIB3DS_REPEAT) {
nt=(Lib3dsFloat)fmod(t, k->tcb.frame);
for (k=track->keyL; k->next!=0; k=k->next) {
if ((nt>=(Lib3dsFloat)k->tcb.frame) && (nt<(Lib3dsFloat)k->next->tcb.frame)) {
break;
}
}
ASSERT(k->next);
}
else {
lib3ds_vector_copy(p, k->value);
return;
}
}
else {
nt=t;
}
u=nt - (Lib3dsFloat)k->tcb.frame;
u/=(Lib3dsFloat)(k->next->tcb.frame - k->tcb.frame);
lib3ds_vector_cubic(
p,
k->value,
k->dd,
k->next->ds,
k->next->value,
u
);
}
Lib3dsAmbientColorNode*
lib3ds_node_new_ambient_color(float color0[3]) {
Lib3dsNode *node;
Lib3dsAmbientColorNode *n;
node = lib3ds_node_new(LIB3DS_NODE_AMBIENT_COLOR);
n = (Lib3dsAmbientColorNode*)node;
lib3ds_track_resize(&n->color_track, 1);
if (color0) {
lib3ds_vector_copy(n->color_track.keys[0].value, color0);
} else {
lib3ds_vector_zero(n->color_track.keys[0].value);
}
return n;
}
/*!
* Calculates the vertex normals corresponding to the smoothing group
* settings for each face of a mesh.
*
* \param mesh A pointer to the mesh to calculate the normals for.
* \param normals A pointer to a buffer to store the calculated
* normals. The buffer must have the size:
* 3*3*sizeof(float)*mesh->nfaces.
*
* To allocate the normal buffer do for example the following:
* \code
* Lib3dsVector *normals = malloc(3*3*sizeof(float)*mesh->nfaces);
* \endcode
*
* To access the normal of the i-th vertex of the j-th face do the
* following:
* \code
* normals[3*j+i]
* \endcode
*/
void
lib3ds_mesh_calculate_vertex_normals(Lib3dsMesh *mesh, float (*normals)[3]) {
Lib3dsFaces **fl;
Lib3dsFaces *fa;
int i, j;
if (!mesh->nfaces) {
return;
}
fl = (Lib3dsFaces**)calloc(sizeof(Lib3dsFaces*), mesh->nvertices);
fa = (Lib3dsFaces*)malloc(sizeof(Lib3dsFaces) * 3 * mesh->nfaces);
for (i = 0; i < mesh->nfaces; ++i) {
for (j = 0; j < 3; ++j) {
Lib3dsFaces* l = &fa[3*i+j];
float p[3], q[3], n[3];
float len, weight;
l->index = i;
l->next = fl[mesh->faces[i].index[j]];
fl[mesh->faces[i].index[j]] = l;
lib3ds_vector_sub(p, mesh->vertices[mesh->faces[i].index[j<2? j + 1 : 0]], mesh->vertices[mesh->faces[i].index[j]]);
lib3ds_vector_sub(q, mesh->vertices[mesh->faces[i].index[j>0? j - 1 : 2]], mesh->vertices[mesh->faces[i].index[j]]);
lib3ds_vector_cross(n, p, q);
len = lib3ds_vector_length(n);
if (len > 0) {
weight = (float)atan2(len, lib3ds_vector_dot(p, q));
lib3ds_vector_scalar_mul(l->normal, n, weight / len);
} else {
lib3ds_vector_zero(l->normal);
}
}
}
for (i = 0; i < mesh->nfaces; ++i) {
Lib3dsFace *f = &mesh->faces[i];
for (j = 0; j < 3; ++j) {
float n[3];
Lib3dsFaces *p;
Lib3dsFace *pf;
assert(mesh->faces[i].index[j] < mesh->nvertices);
if (f->smoothing_group) {
unsigned smoothing_group = f->smoothing_group;
lib3ds_vector_zero(n);
for (p = fl[mesh->faces[i].index[j]]; p; p = p->next) {
pf = &mesh->faces[p->index];
if (pf->smoothing_group & f->smoothing_group)
smoothing_group |= pf->smoothing_group;
}
for (p = fl[mesh->faces[i].index[j]]; p; p = p->next) {
pf = &mesh->faces[p->index];
if (smoothing_group & pf->smoothing_group) {
lib3ds_vector_add(n, n, p->normal);
}
}
} else {
lib3ds_vector_copy(n, fa[3*i+j].normal);
}
lib3ds_vector_normalize(n);
lib3ds_vector_copy(normals[3*i+j], n);
}
}
free(fa);
free(fl);
}
/*!
* Calculates the vertex normals corresponding to the smoothing group
* settings for each face of a mesh.
*
* \param mesh A pointer to the mesh to calculate the normals for.
* \param normalL A pointer to a buffer to store the calculated
* normals. The buffer must have the size:
* 3*sizeof(Lib3dsVector)*mesh->faces.
*
* To allocate the normal buffer do for example the following:
* \code
* Lib3dsVector *normalL = malloc(3*sizeof(Lib3dsVector)*mesh->faces);
* \endcode
*
* To access the normal of the i-th vertex of the j-th face do the
* following:
* \code
* normalL[3*j+i]
* \endcode
*
* \ingroup mesh
*/
void
lib3ds_mesh_calculate_normals(Lib3dsMesh *mesh, Lib3dsVector *normalL)
{
Lib3dsFaces **fl;
Lib3dsFaces *fa;
unsigned i,j,k;
if (!mesh->faces) {
return;
}
fl=calloc(sizeof(Lib3dsFaces*),mesh->points);
ASSERT(fl);
fa=calloc(sizeof(Lib3dsFaces),3*mesh->faces);
ASSERT(fa);
k=0;
for (i=0; i<mesh->faces; ++i) {
Lib3dsFace *f=&mesh->faceL[i];
for (j=0; j<3; ++j) {
Lib3dsFaces* l=&fa[k++];
ASSERT(f->points[j]<mesh->points);
l->face=f;
l->next=fl[f->points[j]];
fl[f->points[j]]=l;
}
}
for (i=0; i<mesh->faces; ++i) {
Lib3dsFace *f=&mesh->faceL[i];
for (j=0; j<3; ++j) {
// FIXME: static array needs at least check!!
Lib3dsVector n,N[128];
Lib3dsFaces *p;
int k,l;
int found;
ASSERT(f->points[j]<mesh->points);
if (f->smoothing) {
lib3ds_vector_zero(n);
k=0;
for (p=fl[f->points[j]]; p; p=p->next) {
found=0;
for (l=0; l<k; ++l) {
if( l >= 128 )
printf("array N overflow: i=%d, j=%d, k=%d\n", i,j,k);
if (fabs(lib3ds_vector_dot(N[l], p->face->normal)-1.0)<1e-5) {
found=1;
break;
}
}
if (!found) {
if (f->smoothing & p->face->smoothing) {
lib3ds_vector_add(n,n, p->face->normal);
lib3ds_vector_copy(N[k], p->face->normal);
++k;
}
}
}
}
else {
lib3ds_vector_copy(n, f->normal);
}
lib3ds_vector_normalize(n);
lib3ds_vector_copy(normalL[3*i+j], n);
}
}
free(fa);
free(fl);
}
static void
file_bounding_box_of_nodes_impl(Lib3dsNode *node, Lib3dsFile *file,
int include_meshes, int include_cameras, int include_lights,
float bmin[3], float bmax[3], float matrix[4][4]) {
switch (node->type) {
case LIB3DS_NODE_MESH_INSTANCE:
if (include_meshes) {
int index;
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
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) {
Lib3dsMesh *mesh;
float inv_matrix[4][4], M[4][4];
float v[3];
int i;
mesh = file->meshes[index];
lib3ds_matrix_copy(inv_matrix, mesh->matrix);
lib3ds_matrix_inv(inv_matrix);
lib3ds_matrix_mult(M, matrix, node->matrix);
lib3ds_matrix_translate(M, -n->pivot[0], -n->pivot[1], -n->pivot[2]);
lib3ds_matrix_mult(M, M, inv_matrix);
for (i = 0; i < mesh->nvertices; ++i) {
lib3ds_vector_transform(v, M, mesh->vertices[i]);
lib3ds_vector_min(bmin, v);
lib3ds_vector_max(bmax, v);
}
}
}
break;
case LIB3DS_NODE_CAMERA:
case LIB3DS_NODE_CAMERA_TARGET:
if (include_cameras) {
float z[3], v[3];
float M[4][4];
lib3ds_matrix_mult(M, matrix, node->matrix);
lib3ds_vector_zero(z);
lib3ds_vector_transform(v, M, z);
lib3ds_vector_min(bmin, v);
lib3ds_vector_max(bmax, v);
}
break;
case LIB3DS_NODE_OMNILIGHT:
case LIB3DS_NODE_SPOTLIGHT:
case LIB3DS_NODE_SPOTLIGHT_TARGET:
if (include_lights) {
float z[3], v[3];
float M[4][4];
lib3ds_matrix_mult(M, matrix, node->matrix);
lib3ds_vector_zero(z);
lib3ds_vector_transform(v, M, z);
lib3ds_vector_min(bmin, v);
lib3ds_vector_max(bmax, v);
}
break;
}
{
Lib3dsNode *p = node->childs;
while (p) {
file_bounding_box_of_nodes_impl(p, file, include_meshes, include_cameras, include_lights, bmin, bmax, matrix);
p = p->next;
}
}
}