static Lib3dsBool
distance_cue_read(Lib3dsDistanceCue *cue, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_DISTANCE_CUE, io)) {
return(LIB3DS_FALSE);
}
cue->near_plane=lib3ds_io_read_float(io);
cue->near_dimming=lib3ds_io_read_float(io);
cue->far_plane=lib3ds_io_read_float(io);
cue->far_dimming=lib3ds_io_read_float(io);
lib3ds_chunk_read_tell(&c, io);
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_DCUE_BGND:
{
cue->cue_background=LIB3DS_TRUE;
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
static Lib3dsBool
layer_fog_read(Lib3dsLayerFog *fog, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
Lib3dsBool have_lin=LIB3DS_FALSE;
if (!lib3ds_chunk_read_start(&c, LIB3DS_LAYER_FOG, io)) {
return(LIB3DS_FALSE);
}
fog->near_y=lib3ds_io_read_float(io);
fog->far_y=lib3ds_io_read_float(io);
fog->density=lib3ds_io_read_float(io);
fog->flags=lib3ds_io_read_dword(io);
lib3ds_chunk_read_tell(&c, io);
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_LIN_COLOR_F:
lib3ds_io_read_rgb(io, fog->col);
have_lin=LIB3DS_TRUE;
break;
case LIB3DS_COLOR_F:
lib3ds_io_read_rgb(io, fog->col);
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
static void
layer_fog_read(Lib3dsAtmosphere *at, Lib3dsIo *io)
{
Lib3dsChunk c;
uint16_t chunk;
int have_lin = FALSE;
lib3ds_chunk_read_start(&c, CHK_LAYER_FOG, io);
at->layer_fog_near_y = lib3ds_io_read_float(io);
at->layer_fog_far_y = lib3ds_io_read_float(io);
at->layer_fog_density = lib3ds_io_read_float(io);
at->layer_fog_flags = lib3ds_io_read_dword(io);
lib3ds_chunk_read_tell(&c, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0)
{
switch (chunk)
{
case CHK_LIN_COLOR_F:
lib3ds_io_read_rgb(io, at->layer_fog_color);
have_lin = TRUE;
break;
case CHK_COLOR_F:
lib3ds_io_read_rgb(io, at->layer_fog_color);
break;
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
static void
distance_cue_read(Lib3dsAtmosphere *at, Lib3dsIo *io)
{
Lib3dsChunk c;
uint16_t chunk;
lib3ds_chunk_read_start(&c, CHK_DISTANCE_CUE, io);
at->dist_cue_near_plane = lib3ds_io_read_float(io);
at->dist_cue_near_dimming = lib3ds_io_read_float(io);
at->dist_cue_far_plane = lib3ds_io_read_float(io);
at->dist_cue_far_dimming = lib3ds_io_read_float(io);
lib3ds_chunk_read_tell(&c, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0)
{
switch (chunk)
{
case CHK_DCUE_BGND: {
at->dist_cue_background = TRUE;
}
break;
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
/*!
* Read a camera definition from a file.
*
* This function is called by lib3ds_file_read(), and you probably
* don't want to call it directly.
*
* \param camera A Lib3dsCamera to be filled in.
* \param io A Lib3dsIo object previously set up by the caller.
*
* \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
*
* \see lib3ds_file_read
*
* \ingroup camera
*/
Lib3dsBool
lib3ds_camera_read(Lib3dsCamera *camera, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_N_CAMERA, io)) {
return(LIB3DS_FALSE);
}
{
int i;
for (i=0; i<3; ++i) {
camera->position[i]=lib3ds_io_read_float(io);
}
for (i=0; i<3; ++i) {
camera->target[i]=lib3ds_io_read_float(io);
}
}
camera->roll=lib3ds_io_read_float(io);
{
float s;
s=lib3ds_io_read_float(io);
if (fabs(s)<LIB3DS_EPSILON) {
camera->fov=45.0;
}
else {
camera->fov=2400.0f/s;
}
}
lib3ds_chunk_read_tell(&c, io);
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_CAM_SEE_CONE:
{
camera->see_cone=LIB3DS_TRUE;
}
break;
case LIB3DS_CAM_RANGES:
{
camera->near_range=lib3ds_io_read_float(io);
camera->far_range=lib3ds_io_read_float(io);
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
static Lib3dsBool
v_gradient_read(Lib3dsBackground *background, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
int index[2];
Lib3dsRgb col[2][3];
int have_lin=0;
if (!lib3ds_chunk_read_start(&c, LIB3DS_V_GRADIENT, io)) {
return(LIB3DS_FALSE);
}
background->gradient.percent=lib3ds_io_read_float(io);
lib3ds_chunk_read_tell(&c, io);
index[0]=index[1]=0;
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_COLOR_F:
lib3ds_io_read_rgb(io, col[0][index[0]]);
index[0]++;
break;
case LIB3DS_LIN_COLOR_F:
lib3ds_io_read_rgb(io, col[1][index[1]]);
index[1]++;
have_lin=1;
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
{
int i;
for (i=0; i<3; ++i) {
background->gradient.top[i]=col[have_lin][0][i];
background->gradient.middle[i]=col[have_lin][1][i];
background->gradient.bottom[i]=col[have_lin][2][i];
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
static void
fog_read(Lib3dsAtmosphere *at, Lib3dsIo *io)
{
Lib3dsChunk c;
uint16_t chunk;
lib3ds_chunk_read_start(&c, CHK_FOG, io);
at->fog_near_plane = lib3ds_io_read_float(io);
at->fog_near_density = lib3ds_io_read_float(io);
at->fog_far_plane = lib3ds_io_read_float(io);
at->fog_far_density = lib3ds_io_read_float(io);
lib3ds_chunk_read_tell(&c, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0)
{
switch (chunk)
{
case CHK_LIN_COLOR_F: {
int i;
for (i = 0; i < 3; ++i)
{
at->fog_color[i] = lib3ds_io_read_float(io);
}
}
break;
case CHK_COLOR_F:
break;
case CHK_FOG_BGND: {
at->fog_background = TRUE;
}
break;
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
static void
v_gradient_read(Lib3dsBackground *background, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
int index[2];
float col[2][3][3];
int have_lin = 0;
lib3ds_chunk_read_start(&c, CHK_V_GRADIENT, io);
background->gradient_percent = lib3ds_io_read_float(io);
lib3ds_chunk_read_tell(&c, io);
index[0] = index[1] = 0;
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_COLOR_F:
lib3ds_io_read_rgb(io, col[0][index[0]]);
index[0]++;
break;
case CHK_LIN_COLOR_F:
lib3ds_io_read_rgb(io, col[1][index[1]]);
index[1]++;
have_lin = 1;
break;
default:
lib3ds_chunk_unknown(chunk, io);
}
}
{
int i;
for (i = 0; i < 3; ++i) {
background->gradient_top[i] = col[have_lin][0][i];
background->gradient_middle[i] = col[have_lin][1][i];
background->gradient_bottom[i] = col[have_lin][2][i];
}
}
lib3ds_chunk_read_end(&c, io);
}
static Lib3dsBool
fog_read(Lib3dsFog *fog, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_FOG, io)) {
return(LIB3DS_FALSE);
}
fog->near_plane = lib3ds_io_read_float(io);
fog->near_density=lib3ds_io_read_float(io);
fog->far_plane=lib3ds_io_read_float(io);
fog->far_density=lib3ds_io_read_float(io);
lib3ds_chunk_read_tell(&c, io);
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_LIN_COLOR_F:
{
int i;
for (i=0; i<3; ++i) {
fog->col[i]=lib3ds_io_read_float(io);
}
}
break;
case LIB3DS_COLOR_F:
break;
case LIB3DS_FOG_BGND:
{
fog->fog_background=LIB3DS_TRUE;
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
static Lib3dsBool
named_object_read(Lib3dsFile *file, FILE *f)
{
Lib3dsChunk c;
char name[64];
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_NAMED_OBJECT, f)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_string_read(name, 64, f)) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_dump_info(" NAME=%s", name);
lib3ds_chunk_read_tell(&c, f);
while ((chunk=lib3ds_chunk_read_next(&c, f))!=0) {
switch (chunk) {
case LIB3DS_N_TRI_OBJECT:
{
Lib3dsMesh *mesh;
mesh=lib3ds_mesh_new(name);
if (!mesh) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_mesh_read(mesh, f)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_mesh(file, mesh);
}
break;
case LIB3DS_N_CAMERA:
{
Lib3dsCamera *camera;
camera=lib3ds_camera_new(name);
if (!camera) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_camera_read(camera, f)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_camera(file, camera);
}
break;
case LIB3DS_N_DIRECT_LIGHT:
{
Lib3dsLight *light;
light=lib3ds_light_new(name);
if (!light) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, f);
if (!lib3ds_light_read(light, f)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_light(file, light);
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, f);
return(LIB3DS_TRUE);
}
/*!
* \ingroup viewport
*/
Lib3dsBool
lib3ds_viewport_read(Lib3dsViewport *viewport, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, 0, io)) {
return(LIB3DS_FALSE);
}
switch (c.chunk) {
case LIB3DS_VIEWPORT_LAYOUT:
{
int cur=0;
viewport->layout.style=lib3ds_io_read_word(io);
viewport->layout.active=lib3ds_io_read_intw(io);
lib3ds_io_read_intw(io);
viewport->layout.swap=lib3ds_io_read_intw(io);
lib3ds_io_read_intw(io);
viewport->layout.swap_prior=lib3ds_io_read_intw(io);
viewport->layout.swap_view=lib3ds_io_read_intw(io);
lib3ds_chunk_read_tell(&c, io);
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_VIEWPORT_SIZE:
{
viewport->layout.position[0]=lib3ds_io_read_word(io);
viewport->layout.position[1]=lib3ds_io_read_word(io);
viewport->layout.size[0]=lib3ds_io_read_word(io);
viewport->layout.size[1]=lib3ds_io_read_word(io);
}
break;
case LIB3DS_VIEWPORT_DATA_3:
{
lib3ds_viewport_set_views(viewport,cur+1);
lib3ds_io_read_intw(io);
viewport->layout.viewL[cur].axis_lock=lib3ds_io_read_word(io);
viewport->layout.viewL[cur].position[0]=lib3ds_io_read_intw(io);
viewport->layout.viewL[cur].position[1]=lib3ds_io_read_intw(io);
viewport->layout.viewL[cur].size[0]=lib3ds_io_read_intw(io);
viewport->layout.viewL[cur].size[1]=lib3ds_io_read_intw(io);
viewport->layout.viewL[cur].type=lib3ds_io_read_word(io);
viewport->layout.viewL[cur].zoom=lib3ds_io_read_float(io);
lib3ds_io_read_vector(io, viewport->layout.viewL[cur].center);
viewport->layout.viewL[cur].horiz_angle=lib3ds_io_read_float(io);
viewport->layout.viewL[cur].vert_angle=lib3ds_io_read_float(io);
lib3ds_io_read(io, viewport->layout.viewL[cur].camera, 11);
++cur;
}
break;
case LIB3DS_VIEWPORT_DATA:
/* 3DS R2 & R3 chunk
unsupported */
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
}
break;
case LIB3DS_DEFAULT_VIEW:
{
memset(&viewport->default_view,0,sizeof(Lib3dsDefaultView));
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_VIEW_TOP:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_TOP;
lib3ds_io_read_vector(io, viewport->default_view.position);
viewport->default_view.width=lib3ds_io_read_float(io);
}
break;
case LIB3DS_VIEW_BOTTOM:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_BOTTOM;
lib3ds_io_read_vector(io, viewport->default_view.position);
viewport->default_view.width=lib3ds_io_read_float(io);
}
break;
case LIB3DS_VIEW_LEFT:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_LEFT;
lib3ds_io_read_vector(io, viewport->default_view.position);
viewport->default_view.width=lib3ds_io_read_float(io);
}
break;
case LIB3DS_VIEW_RIGHT:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_RIGHT;
lib3ds_io_read_vector(io, viewport->default_view.position);
viewport->default_view.width=lib3ds_io_read_float(io);
}
break;
case LIB3DS_VIEW_FRONT:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_FRONT;
lib3ds_io_read_vector(io, viewport->default_view.position);
viewport->default_view.width=lib3ds_io_read_float(io);
}
break;
case LIB3DS_VIEW_BACK:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_BACK;
lib3ds_io_read_vector(io, viewport->default_view.position);
viewport->default_view.width=lib3ds_io_read_float(io);
}
break;
case LIB3DS_VIEW_USER:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_USER;
lib3ds_io_read_vector(io, viewport->default_view.position);
viewport->default_view.width=lib3ds_io_read_float(io);
viewport->default_view.horiz_angle=lib3ds_io_read_float(io);
viewport->default_view.vert_angle=lib3ds_io_read_float(io);
viewport->default_view.roll_angle=lib3ds_io_read_float(io);
}
break;
case LIB3DS_VIEW_CAMERA:
{
viewport->default_view.type=LIB3DS_VIEW_TYPE_CAMERA;
lib3ds_io_read(io, viewport->default_view.camera, 11);
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
}
break;
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
void
lib3ds_light_read(Lib3dsLight *light, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
lib3ds_chunk_read_start(&c, CHK_N_DIRECT_LIGHT, io);
{
int i;
for (i = 0; i < 3; ++i) {
light->position[i] = lib3ds_io_read_float(io);
}
}
lib3ds_chunk_read_tell(&c, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_COLOR_F: {
int i;
for (i = 0; i < 3; ++i) {
light->color[i] = lib3ds_io_read_float(io);
}
break;
}
case CHK_DL_OFF:
light->off = TRUE;
break;
case CHK_DL_OUTER_RANGE:
light->outer_range = lib3ds_io_read_float(io);
break;
case CHK_DL_INNER_RANGE:
light->inner_range = lib3ds_io_read_float(io);
break;
case CHK_DL_MULTIPLIER:
light->multiplier = lib3ds_io_read_float(io);
break;
case CHK_DL_EXCLUDE: {
/* FIXME: */
lib3ds_chunk_unknown(chunk, io);
break;
}
case CHK_DL_ATTENUATE:
light->attenuation = lib3ds_io_read_float(io);
break;
case CHK_DL_SPOTLIGHT: {
lib3ds_chunk_read_reset(&c, io);
spotlight_read(light, io);
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
static Lib3dsBool
named_object_read(Lib3dsFile *file, Lib3dsIo *io)
{
Lib3dsChunk c;
char name[64];
Lib3dsWord chunk;
Lib3dsMesh *mesh = NULL;
Lib3dsCamera *camera = NULL;
Lib3dsLight *light = NULL;
Lib3dsDword object_flags;
if (!lib3ds_chunk_read_start(&c, LIB3DS_NAMED_OBJECT, io)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_io_read_string(io, name, 64)) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_dump_info(" NAME=%s", name);
lib3ds_chunk_read_tell(&c, io);
object_flags = 0;
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_N_TRI_OBJECT:
{
mesh=lib3ds_mesh_new(name);
if (!mesh) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_mesh_read(mesh, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_mesh(file, mesh);
}
break;
case LIB3DS_N_CAMERA:
{
camera=lib3ds_camera_new(name);
if (!camera) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_camera_read(camera, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_camera(file, camera);
}
break;
case LIB3DS_N_DIRECT_LIGHT:
{
light=lib3ds_light_new(name);
if (!light) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_light_read(light, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_light(file, light);
}
break;
case LIB3DS_OBJ_HIDDEN:
object_flags |= LIB3DS_OBJECT_HIDDEN;
break;
case LIB3DS_OBJ_DOESNT_CAST:
object_flags |= LIB3DS_OBJECT_DOESNT_CAST;
break;
case LIB3DS_OBJ_VIS_LOFTER:
object_flags |= LIB3DS_OBJECT_VIS_LOFTER;
break;
case LIB3DS_OBJ_MATTE:
object_flags |= LIB3DS_OBJECT_MATTE;
break;
case LIB3DS_OBJ_DONT_RCVSHADOW:
object_flags |= LIB3DS_OBJECT_DONT_RCVSHADOW;
break;
case LIB3DS_OBJ_FAST:
object_flags |= LIB3DS_OBJECT_FAST;
break;
case LIB3DS_OBJ_FROZEN:
object_flags |= LIB3DS_OBJECT_FROZEN;
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
if (mesh)
mesh->object_flags = object_flags;
if (camera)
camera->object_flags = object_flags;
if (light)
light->object_flags = object_flags;
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
static Lib3dsBool
face_array_read(Lib3dsMesh *mesh, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
int i;
int faces;
if (!lib3ds_chunk_read_start(&c, LIB3DS_FACE_ARRAY, io)) {
return(LIB3DS_FALSE);
}
lib3ds_mesh_free_face_list(mesh);
faces=lib3ds_io_read_word(io);
if (faces) {
if (!lib3ds_mesh_new_face_list(mesh, faces)) {
LIB3DS_ERROR_LOG;
return(LIB3DS_FALSE);
}
for (i=0; i<faces; ++i) {
strcpy(mesh->faceL[i].material, "");
mesh->faceL[i].points[0]=lib3ds_io_read_word(io);
mesh->faceL[i].points[1]=lib3ds_io_read_word(io);
mesh->faceL[i].points[2]=lib3ds_io_read_word(io);
mesh->faceL[i].flags=lib3ds_io_read_word(io);
}
lib3ds_chunk_read_tell(&c, io);
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_SMOOTH_GROUP:
{
unsigned i;
for (i=0; i<mesh->faces; ++i) {
mesh->faceL[i].smoothing=lib3ds_io_read_dword(io);
}
}
break;
case LIB3DS_MSH_MAT_GROUP:
{
char name[64];
unsigned faces;
unsigned i;
unsigned index;
if (!lib3ds_io_read_string(io, name, 64)) {
return(LIB3DS_FALSE);
}
faces=lib3ds_io_read_word(io);
for (i=0; i<faces; ++i) {
index=lib3ds_io_read_word(io);
ASSERT(index<mesh->faces);
strcpy(mesh->faceL[index].material, name);
}
}
break;
case LIB3DS_MSH_BOXMAP:
{
char name[64];
if (!lib3ds_io_read_string(io, name, 64)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.front, name);
if (!lib3ds_io_read_string(io, name, 64)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.back, name);
if (!lib3ds_io_read_string(io, name, 64)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.left, name);
if (!lib3ds_io_read_string(io, name, 64)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.right, name);
if (!lib3ds_io_read_string(io, name, 64)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.top, name);
if (!lib3ds_io_read_string(io, name, 64)) {
return(LIB3DS_FALSE);
}
strcpy(mesh->box_map.bottom, name);
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
/*!
* \ingroup light
*/
Lib3dsBool
lib3ds_light_read(Lib3dsLight *light, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_N_DIRECT_LIGHT, io)) {
return(LIB3DS_FALSE);
}
{
int i;
for (i=0; i<3; ++i) {
light->position[i]=lib3ds_io_read_float(io);
}
}
lib3ds_chunk_read_tell(&c, io);
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_COLOR_F:
{
int i;
for (i=0; i<3; ++i) {
light->color[i]=lib3ds_io_read_float(io);
}
}
break;
case LIB3DS_DL_OFF:
{
light->off=LIB3DS_TRUE;
}
break;
case LIB3DS_DL_OUTER_RANGE:
{
light->outer_range=lib3ds_io_read_float(io);
}
break;
case LIB3DS_DL_INNER_RANGE:
{
light->inner_range=lib3ds_io_read_float(io);
}
break;
case LIB3DS_DL_MULTIPLIER:
{
light->multiplier=lib3ds_io_read_float(io);
}
break;
case LIB3DS_DL_EXCLUDE:
{
/* FIXME: */
lib3ds_chunk_unknown(chunk);
}
case LIB3DS_DL_ATTENUATE:
{
light->attenuation=lib3ds_io_read_float(io);
}
break;
case LIB3DS_DL_SPOTLIGHT:
{
lib3ds_chunk_read_reset(&c, io);
if (!spotlight_read(light, io)) {
return(LIB3DS_FALSE);
}
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
/*!
* \ingroup light
*/
static Lib3dsBool
spotlight_read(Lib3dsLight *light, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
int i;
if (!lib3ds_chunk_read_start(&c, LIB3DS_DL_SPOTLIGHT, io)) {
return(LIB3DS_FALSE);
}
light->spot_light=LIB3DS_TRUE;
for (i=0; i<3; ++i) {
light->spot[i]=lib3ds_io_read_float(io);
}
light->hot_spot = lib3ds_io_read_float(io);
light->fall_off = lib3ds_io_read_float(io);
lib3ds_chunk_read_tell(&c, io);
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_DL_SPOT_ROLL:
{
light->roll=lib3ds_io_read_float(io);
}
break;
case LIB3DS_DL_SHADOWED:
{
light->shadowed=LIB3DS_TRUE;
}
break;
case LIB3DS_DL_LOCAL_SHADOW2:
{
light->shadow_bias=lib3ds_io_read_float(io);
light->shadow_filter=lib3ds_io_read_float(io);
light->shadow_size=lib3ds_io_read_intw(io);
}
break;
case LIB3DS_DL_SEE_CONE:
{
light->see_cone=LIB3DS_TRUE;
}
break;
case LIB3DS_DL_SPOT_RECTANGULAR:
{
light->rectangular_spot=LIB3DS_TRUE;
}
break;
case LIB3DS_DL_SPOT_ASPECT:
{
light->spot_aspect=lib3ds_io_read_float(io);
}
break;
case LIB3DS_DL_SPOT_PROJECTOR:
{
light->use_projector=LIB3DS_TRUE;
if (!lib3ds_io_read_string(io, light->projector, 64)) {
return(LIB3DS_FALSE);
}
}
case LIB3DS_DL_SPOT_OVERSHOOT:
{
light->spot_overshoot=LIB3DS_TRUE;
}
break;
case LIB3DS_DL_RAY_BIAS:
{
light->ray_bias=lib3ds_io_read_float(io);
}
break;
case LIB3DS_DL_RAYSHAD:
{
light->ray_shadows=LIB3DS_TRUE;
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
static void
spotlight_read(Lib3dsLight *light, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
int i;
lib3ds_chunk_read_start(&c, CHK_DL_SPOTLIGHT, io);
light->spot_light = TRUE;
for (i = 0; i < 3; ++i) {
light->target[i] = lib3ds_io_read_float(io);
}
light->hotspot = lib3ds_io_read_float(io);
light->falloff = lib3ds_io_read_float(io);
lib3ds_chunk_read_tell(&c, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_DL_SPOT_ROLL:
light->roll = lib3ds_io_read_float(io);
break;
case CHK_DL_SHADOWED: {
light->shadowed = TRUE;
break;
}
case CHK_DL_LOCAL_SHADOW2: {
light->shadow_bias = lib3ds_io_read_float(io);
light->shadow_filter = lib3ds_io_read_float(io);
light->shadow_size = lib3ds_io_read_intw(io);
break;
}
case CHK_DL_SEE_CONE: {
light->see_cone = TRUE;
break;
}
case CHK_DL_SPOT_RECTANGULAR: {
light->rectangular_spot = TRUE;
break;
}
case CHK_DL_SPOT_ASPECT: {
light->spot_aspect = lib3ds_io_read_float(io);
break;
}
case CHK_DL_SPOT_PROJECTOR: {
light->use_projector = TRUE;
lib3ds_io_read_string(io, light->projector, 64);
break;
}
case CHK_DL_SPOT_OVERSHOOT: {
light->spot_overshoot = TRUE;
break;
}
case CHK_DL_RAY_BIAS: {
light->ray_bias = lib3ds_io_read_float(io);
break;
}
case CHK_DL_RAYSHAD: {
light->ray_shadows = TRUE;
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
static void
face_array_read(Lib3dsFile *file, Lib3dsMesh *mesh, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
int i;
uint16_t nfaces;
lib3ds_chunk_read_start(&c, CHK_FACE_ARRAY, io);
lib3ds_mesh_resize_faces(mesh, 0);
nfaces = lib3ds_io_read_word(io);
if (nfaces) {
lib3ds_mesh_resize_faces(mesh, nfaces);
for (i = 0; i < nfaces; ++i) {
mesh->faces[i].index[0] = lib3ds_io_read_word(io);
mesh->faces[i].index[1] = lib3ds_io_read_word(io);
mesh->faces[i].index[2] = lib3ds_io_read_word(io);
mesh->faces[i].flags = lib3ds_io_read_word(io);
}
lib3ds_chunk_read_tell(&c, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_MSH_MAT_GROUP: {
char name[64];
unsigned n;
unsigned i;
int index;
int material;
lib3ds_io_read_string(io, name, 64);
material = lib3ds_file_material_by_name(file, name);
n = lib3ds_io_read_word(io);
for (i = 0; i < n; ++i) {
index = lib3ds_io_read_word(io);
if (index < mesh->nfaces) {
mesh->faces[index].material = material;
} else {
// TODO warning
}
}
break;
}
case CHK_SMOOTH_GROUP: {
int i;
for (i = 0; i < mesh->nfaces; ++i) {
mesh->faces[i].smoothing_group = lib3ds_io_read_dword(io);
}
break;
}
case CHK_MSH_BOXMAP: {
lib3ds_io_read_string(io, mesh->box_front, 64);
lib3ds_io_read_string(io, mesh->box_back, 64);
lib3ds_io_read_string(io, mesh->box_left, 64);
lib3ds_io_read_string(io, mesh->box_right, 64);
lib3ds_io_read_string(io, mesh->box_top, 64);
lib3ds_io_read_string(io, mesh->box_bottom, 64);
break;
}
default:
lib3ds_chunk_unknown(chunk,io);
}
}
}
lib3ds_chunk_read_end(&c, io);
}
static void
named_object_read(Lib3dsFile *file, Lib3dsIo *io) {
Lib3dsChunk c;
char name[64];
uint16_t chunk;
Lib3dsMesh *mesh = NULL;
Lib3dsCamera *camera = NULL;
Lib3dsLight *light = NULL;
uint32_t object_flags;
lib3ds_chunk_read_start(&c, CHK_NAMED_OBJECT, io);
lib3ds_io_read_string(io, name, 64);
lib3ds_io_log(io, LIB3DS_LOG_INFO, " NAME=%s", name);
lib3ds_chunk_read_tell(&c, io);
object_flags = 0;
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_N_TRI_OBJECT: {
mesh = lib3ds_mesh_new(name);
lib3ds_file_insert_mesh(file, mesh, -1);
lib3ds_chunk_read_reset(&c, io);
lib3ds_mesh_read(file, mesh, io);
break;
}
case CHK_N_CAMERA: {
camera = lib3ds_camera_new(name);
lib3ds_file_insert_camera(file, camera, -1);
lib3ds_chunk_read_reset(&c, io);
lib3ds_camera_read(camera, io);
break;
}
case CHK_N_DIRECT_LIGHT: {
light = lib3ds_light_new(name);
lib3ds_file_insert_light(file, light, -1);
lib3ds_chunk_read_reset(&c, io);
lib3ds_light_read(light, io);
break;
}
case CHK_OBJ_HIDDEN:
object_flags |= LIB3DS_OBJECT_HIDDEN;
break;
case CHK_OBJ_DOESNT_CAST:
object_flags |= LIB3DS_OBJECT_DOESNT_CAST;
break;
case CHK_OBJ_VIS_LOFTER:
object_flags |= LIB3DS_OBJECT_VIS_LOFTER;
break;
case CHK_OBJ_MATTE:
object_flags |= LIB3DS_OBJECT_MATTE;
break;
case CHK_OBJ_DONT_RCVSHADOW:
object_flags |= LIB3DS_OBJECT_DONT_RCVSHADOW;
break;
case CHK_OBJ_FAST:
object_flags |= LIB3DS_OBJECT_FAST;
break;
case CHK_OBJ_FROZEN:
object_flags |= LIB3DS_OBJECT_FROZEN;
break;
default:
lib3ds_chunk_unknown(chunk, io);
}
}
if (mesh)
mesh->object_flags = object_flags;
if (camera)
camera->object_flags = object_flags;
if (light)
light->object_flags = object_flags;
lib3ds_chunk_read_end(&c, io);
}
