void
lib3ds_chunk_unknown(uint16_t chunk, Lib3dsIo *io)
{
if (io->log_func)
{
lib3ds_io_log(io, LIB3DS_LOG_WARN, "Unknown Chunk: %s (0x%X)", lib3ds_chunk_name(chunk), chunk);
}
}
void
lib3ds_chunk_read_start(Lib3dsChunk *c, uint16_t chunk, Lib3dsIo *io) {
assert(c);
assert(io);
lib3ds_chunk_read(c, io);
if ((chunk != 0) && (c->chunk != chunk)) {
lib3ds_io_log(io, LIB3DS_LOG_ERROR, "Unexpected chunk found.");
}
((Lib3dsIoImpl*)io->impl)->log_indent++;
}
/*!
* Reads a 3d-Studio chunk header from a little endian file stream.
*
* \param c The chunk to store the data.
* \param io The file stream.
*
* \return True on success, False otherwise.
*/
void
lib3ds_chunk_read(Lib3dsChunk *c, Lib3dsIo *io) {
assert(c);
assert(io);
c->cur = lib3ds_io_tell(io);
c->chunk = lib3ds_io_read_word(io);
c->size = lib3ds_io_read_dword(io);
c->end = c->cur + c->size;
c->cur += 6;
if (c->size < 6) {
lib3ds_io_log(io, LIB3DS_LOG_ERROR, "Invalid chunk header.");
}
}
uint16_t
lib3ds_chunk_read_next(Lib3dsChunk *c, Lib3dsIo *io) {
Lib3dsChunk d;
if (c->cur >= c->end) {
assert(c->cur == c->end);
return 0;
}
lib3ds_io_seek(io, (long)c->cur, LIB3DS_SEEK_SET);
d.chunk = lib3ds_io_read_word(io);
d.size = lib3ds_io_read_dword(io);
c->cur += d.size;
if (io->log_func) {
lib3ds_io_log(io, LIB3DS_LOG_INFO, "%s (0x%X) size=%lu", lib3ds_chunk_name(d.chunk), d.chunk, d.size);
}
return d.chunk;
}
/*!
* Read a zero-terminated string from a file stream.
*
* \param io IO input handle.
* \param s The buffer to store the read string.
* \param buflen Buffer length.
*
* \return True on success, False otherwise.
*/
void
lib3ds_io_read_string(Lib3dsIo *io, char *s, int buflen) {
char c;
int k = 0;
assert(io);
for (;;) {
if (lib3ds_io_read(io, &c, 1) != 1) {
lib3ds_io_read_error(io);
}
*s++ = c;
if (!c) {
break;
}
++k;
if (k >= buflen) {
lib3ds_io_log(io, LIB3DS_LOG_ERROR, "Invalid string in input stream.");
}
}
}
void
lib3ds_material_read(Lib3dsMaterial *material, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
assert(material);
lib3ds_chunk_read_start(&c, CHK_MAT_ENTRY, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_MAT_NAME: {
lib3ds_io_read_string(io, material->name, 64);
lib3ds_io_log(io, LIB3DS_LOG_INFO, " NAME=%s", material->name);
break;
}
case CHK_MAT_AMBIENT: {
lib3ds_chunk_read_reset(&c, io);
color_read(material->ambient, io);
break;
}
case CHK_MAT_DIFFUSE: {
lib3ds_chunk_read_reset(&c, io);
color_read(material->diffuse, io);
break;
}
case CHK_MAT_SPECULAR: {
lib3ds_chunk_read_reset(&c, io);
color_read(material->specular, io);
break;
}
case CHK_MAT_SHININESS: {
lib3ds_chunk_read_reset(&c, io);
int_percentage_read(&material->shininess, io);
break;
}
case CHK_MAT_SHIN2PCT: {
lib3ds_chunk_read_reset(&c, io);
int_percentage_read(&material->shin_strength, io);
break;
}
case CHK_MAT_TRANSPARENCY: {
lib3ds_chunk_read_reset(&c, io);
int_percentage_read(&material->transparency, io);
break;
}
case CHK_MAT_XPFALL: {
lib3ds_chunk_read_reset(&c, io);
int_percentage_read(&material->falloff, io);
break;
}
case CHK_MAT_SELF_ILPCT: {
lib3ds_chunk_read_reset(&c, io);
int_percentage_read(&material->self_illum, io);
break;
}
case CHK_MAT_USE_XPFALL: {
material->use_falloff = TRUE;
break;
}
case CHK_MAT_REFBLUR: {
lib3ds_chunk_read_reset(&c, io);
int_percentage_read(&material->blur, io);
break;
}
case CHK_MAT_USE_REFBLUR: {
material->use_blur = TRUE;
break;
}
case CHK_MAT_SHADING: {
material->shading = lib3ds_io_read_intw(io);
break;
}
case CHK_MAT_SELF_ILLUM: {
material->self_illum_flag = TRUE;
break;
}
case CHK_MAT_TWO_SIDE: {
material->two_sided = TRUE;
break;
}
case CHK_MAT_DECAL: {
material->map_decal = TRUE;
break;
}
case CHK_MAT_ADDITIVE: {
material->is_additive = TRUE;
break;
}
case CHK_MAT_FACEMAP: {
material->face_map = TRUE;
break;
}
case CHK_MAT_PHONGSOFT: {
material->soften = TRUE;
break;
}
case CHK_MAT_WIRE: {
material->use_wire = TRUE;
break;
}
case CHK_MAT_WIREABS: {
material->use_wire_abs = TRUE;
break;
}
case CHK_MAT_WIRE_SIZE: {
material->wire_size = lib3ds_io_read_float(io);
break;
}
case CHK_MAT_TEXMAP: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->texture1_map, io);
break;
}
case CHK_MAT_TEXMASK: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->texture1_mask, io);
break;
}
case CHK_MAT_TEX2MAP: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->texture2_map, io);
break;
}
case CHK_MAT_TEX2MASK: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->texture2_mask, io);
break;
}
case CHK_MAT_OPACMAP: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->opacity_map, io);
break;
}
case CHK_MAT_OPACMASK: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->opacity_mask, io);
break;
}
case CHK_MAT_BUMPMAP: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->bump_map, io);
break;
}
case CHK_MAT_BUMPMASK: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->bump_mask, io);
break;
}
case CHK_MAT_SPECMAP: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->specular_map, io);
break;
}
case CHK_MAT_SPECMASK: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->specular_mask, io);
break;
}
case CHK_MAT_SHINMAP: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->shininess_map, io);
break;
}
case CHK_MAT_SHINMASK: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->shininess_mask, io);
break;
}
case CHK_MAT_SELFIMAP: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->self_illum_map, io);
break;
}
case CHK_MAT_SELFIMASK: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->self_illum_mask, io);
break;
}
case CHK_MAT_REFLMAP: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->reflection_map, io);
break;
}
case CHK_MAT_REFLMASK: {
lib3ds_chunk_read_reset(&c, io);
texture_map_read(&material->reflection_mask, io);
break;
}
case CHK_MAT_ACUBIC: {
lib3ds_io_read_intb(io);
material->autorefl_map_anti_alias = lib3ds_io_read_intb(io);
material->autorefl_map_flags = lib3ds_io_read_intw(io);
material->autorefl_map_size = lib3ds_io_read_intd(io);
material->autorefl_map_frame_step = lib3ds_io_read_intd(io);
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
static void
texture_map_read(Lib3dsTextureMap *map, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
lib3ds_chunk_read_start(&c, 0, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_INT_PERCENTAGE: {
map->percent = 1.0f * lib3ds_io_read_intw(io) / 100.0f;
break;
}
case CHK_MAT_MAPNAME: {
lib3ds_io_read_string(io, map->name, 64);
lib3ds_io_log(io, LIB3DS_LOG_INFO, " NAME=%s", map->name);
break;
}
case CHK_MAT_MAP_TILING: {
map->flags = lib3ds_io_read_word(io);
break;
}
case CHK_MAT_MAP_TEXBLUR:
map->blur = lib3ds_io_read_float(io);
break;
case CHK_MAT_MAP_USCALE:
map->scale[0] = lib3ds_io_read_float(io);
break;
case CHK_MAT_MAP_VSCALE: {
map->scale[1] = lib3ds_io_read_float(io);
break;
}
case CHK_MAT_MAP_UOFFSET: {
map->offset[0] = lib3ds_io_read_float(io);
break;
}
case CHK_MAT_MAP_VOFFSET: {
map->offset[1] = lib3ds_io_read_float(io);
break;
}
case CHK_MAT_MAP_ANG: {
map->rotation = lib3ds_io_read_float(io);
break;
}
case CHK_MAT_MAP_COL1: {
map->tint_1[0] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_1[1] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_1[2] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
break;
}
case CHK_MAT_MAP_COL2: {
map->tint_2[0] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_2[1] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_2[2] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
break;
}
case CHK_MAT_MAP_RCOL: {
map->tint_r[0] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_r[1] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_r[2] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
break;
}
case CHK_MAT_MAP_GCOL: {
map->tint_g[0] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_g[1] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_g[2] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
break;
}
case CHK_MAT_MAP_BCOL: {
map->tint_b[0] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_b[1] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
map->tint_b[2] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
break;
}
default:
lib3ds_chunk_unknown(chunk,io);
}
}
lib3ds_chunk_read_end(&c, io);
}
void
lib3ds_node_read(Lib3dsNode *node, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
assert(node);
lib3ds_chunk_read_start(&c, 0, io);
switch (c.chunk) {
case CHK_AMBIENT_NODE_TAG:
case CHK_OBJECT_NODE_TAG:
case CHK_CAMERA_NODE_TAG:
case CHK_TARGET_NODE_TAG:
case CHK_LIGHT_NODE_TAG:
case CHK_SPOTLIGHT_NODE_TAG:
case CHK_L_TARGET_NODE_TAG:
break;
default:
return;
}
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_NODE_ID: {
node->node_id = lib3ds_io_read_word(io);
lib3ds_io_log_indent(io, 1);
lib3ds_io_log(io, LIB3DS_LOG_INFO, "ID=%d", (short)node->node_id);
lib3ds_io_log_indent(io, -1);
break;
}
case CHK_NODE_HDR: {
lib3ds_io_read_string(io, node->name, 64);
node->flags = lib3ds_io_read_word(io);
node->flags |= ((uint32_t)lib3ds_io_read_word(io)) << 16;
node->user_id = lib3ds_io_read_word(io);
lib3ds_io_log_indent(io, 1);
lib3ds_io_log(io, LIB3DS_LOG_INFO, "NAME=%s", node->name);
lib3ds_io_log(io, LIB3DS_LOG_INFO, "PARENT=%d", (short)node->user_id);
lib3ds_io_log_indent(io, -1);
break;
}
case CHK_PIVOT: {
if (node->type == LIB3DS_NODE_MESH_INSTANCE) {
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
lib3ds_io_read_vector(io, n->pivot);
} else {
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_INSTANCE_NAME: {
if (node->type == LIB3DS_NODE_MESH_INSTANCE) {
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
lib3ds_io_read_string(io, n->instance_name, 64);
} else {
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_BOUNDBOX: {
if (node->type == LIB3DS_NODE_MESH_INSTANCE) {
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
lib3ds_io_read_vector(io, n->bbox_min);
lib3ds_io_read_vector(io, n->bbox_max);
} else {
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_COL_TRACK_TAG: {
Lib3dsTrack *track = 0;
switch (node->type) {
case LIB3DS_NODE_AMBIENT_COLOR: {
Lib3dsAmbientColorNode *n = (Lib3dsAmbientColorNode*)node;
track = &n->color_track;
break;
}
case LIB3DS_NODE_OMNILIGHT: {
Lib3dsOmnilightNode *n = (Lib3dsOmnilightNode*)node;
track = &n->color_track;
break;
}
case LIB3DS_NODE_SPOTLIGHT: {
Lib3dsSpotlightNode *n = (Lib3dsSpotlightNode*)node;
track = &n->color_track;
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
if (track) {
lib3ds_track_read(track, io);
}
break;
}
case CHK_POS_TRACK_TAG: {
Lib3dsTrack *track = 0;
switch (node->type) {
case LIB3DS_NODE_MESH_INSTANCE: {
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
track = &n->pos_track;
break;
}
case LIB3DS_NODE_CAMERA: {
Lib3dsCameraNode *n = (Lib3dsCameraNode*)node;
track = &n->pos_track;
break;
}
case LIB3DS_NODE_CAMERA_TARGET: {
Lib3dsTargetNode *n = (Lib3dsTargetNode*)node;
track = &n->pos_track;
break;
}
case LIB3DS_NODE_OMNILIGHT: {
Lib3dsOmnilightNode *n = (Lib3dsOmnilightNode*)node;
track = &n->pos_track;
break;
}
case LIB3DS_NODE_SPOTLIGHT: {
Lib3dsSpotlightNode *n = (Lib3dsSpotlightNode*)node;
track = &n->pos_track;
break;
}
case LIB3DS_NODE_SPOTLIGHT_TARGET: {
Lib3dsTargetNode *n = (Lib3dsTargetNode*)node;
track = &n->pos_track;
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
if (track) {
lib3ds_track_read(track, io);
}
break;
}
case CHK_ROT_TRACK_TAG: {
if (node->type == LIB3DS_NODE_MESH_INSTANCE) {
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
n->rot_track.type = LIB3DS_TRACK_QUAT;
lib3ds_track_read(&n->rot_track, io);
} else {
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_SCL_TRACK_TAG: {
if (node->type == LIB3DS_NODE_MESH_INSTANCE) {
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
n->scl_track.type = LIB3DS_TRACK_VECTOR;
lib3ds_track_read(&n->scl_track, io);
} else {
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_FOV_TRACK_TAG: {
if (node->type == LIB3DS_NODE_CAMERA) {
Lib3dsCameraNode *n = (Lib3dsCameraNode*)node;
n->fov_track.type = LIB3DS_TRACK_FLOAT;
lib3ds_track_read(&n->fov_track, io);
} else {
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_HOT_TRACK_TAG: {
if (node->type == LIB3DS_NODE_SPOTLIGHT) {
Lib3dsSpotlightNode *n = (Lib3dsSpotlightNode*)node;
n->hotspot_track.type = LIB3DS_TRACK_FLOAT;
lib3ds_track_read(&n->hotspot_track, io);
} else {
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_FALL_TRACK_TAG: {
if (node->type == LIB3DS_NODE_SPOTLIGHT) {
Lib3dsSpotlightNode *n = (Lib3dsSpotlightNode*)node;
n->falloff_track.type= LIB3DS_TRACK_FLOAT;
lib3ds_track_read(&n->falloff_track, io);
} else {
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_ROLL_TRACK_TAG: {
switch (node->type) {
case LIB3DS_NODE_CAMERA: {
Lib3dsCameraNode *n = (Lib3dsCameraNode*)node;
n->roll_track.type = LIB3DS_TRACK_FLOAT;
lib3ds_track_read(&n->roll_track, io);
break;
}
case LIB3DS_NODE_SPOTLIGHT: {
Lib3dsSpotlightNode *n = (Lib3dsSpotlightNode*)node;
n->roll_track.type = LIB3DS_TRACK_FLOAT;
lib3ds_track_read(&n->roll_track, io);
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_HIDE_TRACK_TAG: {
if (node->type == LIB3DS_NODE_MESH_INSTANCE) {
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
n->hide_track.type = LIB3DS_TRACK_BOOL;
lib3ds_track_read(&n->hide_track, io);
} else {
lib3ds_chunk_unknown(chunk, io);
}
break;
}
case CHK_MORPH_SMOOTH: {
if (node->type == LIB3DS_NODE_MESH_INSTANCE) {
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
n->morph_smooth = lib3ds_io_read_float(io);
} else {
lib3ds_chunk_unknown(chunk, io);
}
}
break;
/*
case LIB3DS_MORPH_TRACK_TAG: {
if (node->type == LIB3DS_NODE_MESH_INSTANCE) {
Lib3dsMeshInstanceNode *n = (Lib3dsMeshInstanceNode*)node;
n->morph_track = lib3ds_track_new(node, LIB3DS_TRACK_MORPH, 0);
lib3ds_track_read(n->morph_track, io);
} else {
lib3ds_chunk_unknown(chunk, io);
}
}
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);
}
void
lib3ds_io_write_error(Lib3dsIo *io) {
lib3ds_io_log(io, LIB3DS_LOG_ERROR, "Writing to output stream failed.");
}
void
lib3ds_io_read_error(Lib3dsIo *io) {
lib3ds_io_log(io, LIB3DS_LOG_ERROR, "Reading from input stream failed.");
}
