void
lib3ds_track_read(Lib3dsTrack *track, Lib3dsIo *io) {
unsigned nkeys;
unsigned i;
track->flags = lib3ds_io_read_word(io);
lib3ds_io_read_dword(io);
lib3ds_io_read_dword(io);
nkeys = lib3ds_io_read_intd(io);
lib3ds_track_resize(track, nkeys);
switch (track->type) {
case LIB3DS_TRACK_BOOL:
for (i = 0; i < nkeys; ++i) {
track->keys[i].frame = lib3ds_io_read_intd(io);
tcb_read(&track->keys[i], io);
}
break;
case LIB3DS_TRACK_FLOAT:
for (i = 0; i < nkeys; ++i) {
track->keys[i].frame = lib3ds_io_read_intd(io);
tcb_read(&track->keys[i], io);
track->keys[i].value[0] = lib3ds_io_read_float(io);
}
break;
case LIB3DS_TRACK_VECTOR:
for (i = 0; i < nkeys; ++i) {
track->keys[i].frame = lib3ds_io_read_intd(io);
tcb_read(&track->keys[i], io);
lib3ds_io_read_vector(io, track->keys[i].value);
}
break;
case LIB3DS_TRACK_QUAT:
for (i = 0; i < nkeys; ++i) {
track->keys[i].frame = lib3ds_io_read_intd(io);
tcb_read(&track->keys[i], io);
track->keys[i].value[3] = lib3ds_io_read_float(io);
lib3ds_io_read_vector(io, track->keys[i].value);
}
break;
/*case LIB3DS_TRACK_MORPH:
for (i = 0; i < nkeys; ++i) {
track->keys[i].frame = lib3ds_io_read_intd(io);
tcb_read(&track->keys[i].tcb, io);
lib3ds_io_read_string(io, track->keys[i].data.m.name, 64);
}
break;*/
default:
break;
}
}
/*!
* \ingroup tcb
*/
Lib3dsBool
lib3ds_tcb_read(Lib3dsTcb *tcb, Lib3dsIo *io)
{
Lib3dsWord flags;
tcb->frame=lib3ds_io_read_intd(io);
tcb->flags=flags=lib3ds_io_read_word(io);
if (flags&LIB3DS_USE_TENSION) {
tcb->tens=lib3ds_io_read_float(io);
}
if (flags&LIB3DS_USE_CONTINUITY) {
tcb->cont=lib3ds_io_read_float(io);
}
if (flags&LIB3DS_USE_BIAS) {
tcb->bias=lib3ds_io_read_float(io);
}
if (flags&LIB3DS_USE_EASE_TO) {
tcb->ease_to=lib3ds_io_read_float(io);
}
if (flags&LIB3DS_USE_EASE_FROM) {
tcb->ease_from=lib3ds_io_read_float(io);
}
if (lib3ds_io_error(io)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
}
/*!
* \ingroup tracks
*/
Lib3dsBool
lib3ds_lin3_track_read(Lib3dsLin3Track *track, Lib3dsIo *io)
{
int keys;
int i,j;
Lib3dsLin3Key *k;
track->flags=lib3ds_io_read_word(io);
lib3ds_io_read_dword(io);
lib3ds_io_read_dword(io);
keys=lib3ds_io_read_intd(io);
for (i=0; i<keys; ++i) {
k=lib3ds_lin3_key_new();
if (!lib3ds_tcb_read(&k->tcb, io)) {
return(LIB3DS_FALSE);
}
for (j=0; j<3; ++j) {
k->value[j]=lib3ds_io_read_float(io);
}
lib3ds_lin3_track_insert(track, k);
}
lib3ds_lin3_track_setup(track);
return(LIB3DS_TRUE);
}
/*!
* \ingroup tracks
*/
Lib3dsBool
lib3ds_quat_track_read(Lib3dsQuatTrack *track, Lib3dsIo *io)
{
int keys;
int i,j;
Lib3dsQuatKey *p,*k;
track->flags=lib3ds_io_read_word(io);
lib3ds_io_read_dword(io);
lib3ds_io_read_dword(io);
keys=lib3ds_io_read_intd(io);
for (p=0,i=0; i<keys; p=k,++i) {
k=lib3ds_quat_key_new();
if (!lib3ds_tcb_read(&k->tcb, io)) {
return(LIB3DS_FALSE);
}
k->angle=lib3ds_io_read_float(io);
for (j=0; j<3; ++j) {
k->axis[j]=lib3ds_io_read_float(io);
}
lib3ds_quat_track_insert(track, k);
}
lib3ds_quat_track_setup(track);
return(LIB3DS_TRUE);
}
/*!
* \ingroup tracks
*/
Lib3dsBool
lib3ds_morph_track_read(Lib3dsMorphTrack *track, Lib3dsIo *io)
{
/* This function was written by Stephane Denis on 5-18-04 */
int i;
Lib3dsMorphKey *k = 0;
Lib3dsMorphKey *pk = 0;
int keys;
track->flags=lib3ds_io_read_word(io);
lib3ds_io_read_dword(io);
lib3ds_io_read_dword(io);
keys=lib3ds_io_read_intd(io);
for (i=0; i<keys; ++i) {
k=lib3ds_morph_key_new();
if (!lib3ds_tcb_read(&k->tcb, io)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_io_read_string(io, k->name, 11)) {
return(LIB3DS_FALSE);
}
if (!track->keyL)
track->keyL = k;
else
pk->next = k;
pk = k;
}
return(LIB3DS_TRUE);
}
/*!
* \ingroup shadow
*/
Lib3dsBool
lib3ds_shadow_read(Lib3dsShadow *shadow, Lib3dsIo *io)
{
Lib3dsChunk c;
if (!lib3ds_chunk_read(&c, io)) {
return(LIB3DS_FALSE);
}
switch (c.chunk) {
case LIB3DS_SHADOW_MAP_SIZE:
{
shadow->map_size=lib3ds_io_read_intw(io);
}
break;
case LIB3DS_LO_SHADOW_BIAS:
{
shadow->lo_bias=lib3ds_io_read_float(io);
}
break;
case LIB3DS_HI_SHADOW_BIAS:
{
shadow->hi_bias=lib3ds_io_read_float(io);
}
break;
case LIB3DS_SHADOW_SAMPLES:
{
shadow->samples=lib3ds_io_read_intw(io);
}
break;
case LIB3DS_SHADOW_RANGE:
{
shadow->range=lib3ds_io_read_intd(io);
}
break;
case LIB3DS_SHADOW_FILTER:
{
shadow->filter=lib3ds_io_read_float(io);
}
break;
case LIB3DS_RAY_BIAS:
{
shadow->ray_bias=lib3ds_io_read_float(io);
}
break;
}
return(LIB3DS_TRUE);
}
/*!
* \ingroup tracks
*/
Lib3dsBool
lib3ds_bool_track_read(Lib3dsBoolTrack *track, Lib3dsIo *io)
{
int keys;
int i;
Lib3dsBoolKey *k;
track->flags=lib3ds_io_read_word(io);
lib3ds_io_read_dword(io);
lib3ds_io_read_dword(io);
keys=lib3ds_io_read_intd(io);
for (i=0; i<keys; ++i) {
k=lib3ds_bool_key_new();
if (!lib3ds_tcb_read(&k->tcb, io)) {
return(LIB3DS_FALSE);
}
lib3ds_bool_track_insert(track, k);
}
return(LIB3DS_TRUE);
}
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 Lib3dsBool
kfdata_read(Lib3dsFile *file, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
Lib3dsDword node_number = 0;
if (!lib3ds_chunk_read_start(&c, LIB3DS_KFDATA, io)) {
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_KFHDR:
{
file->keyf_revision=lib3ds_io_read_word(io);
if (!lib3ds_io_read_string(io, file->name, 12+1)) {
return(LIB3DS_FALSE);
}
file->frames=lib3ds_io_read_intd(io);
}
break;
case LIB3DS_KFSEG:
{
file->segment_from=lib3ds_io_read_intd(io);
file->segment_to=lib3ds_io_read_intd(io);
}
break;
case LIB3DS_KFCURTIME:
{
file->current_frame=lib3ds_io_read_intd(io);
}
break;
case LIB3DS_VIEWPORT_LAYOUT:
case LIB3DS_DEFAULT_VIEW:
{
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_viewport_read(&file->viewport_keyf, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_AMBIENT_NODE_TAG:
{
Lib3dsNode *node;
node=lib3ds_node_new_ambient();
if (!node) {
return(LIB3DS_FALSE);
}
node->node_id=node_number++;
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_node_read(node, file, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
}
break;
case LIB3DS_OBJECT_NODE_TAG:
{
Lib3dsNode *node;
node=lib3ds_node_new_object();
if (!node) {
return(LIB3DS_FALSE);
}
node->node_id=node_number++;
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_node_read(node, file, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
}
break;
case LIB3DS_CAMERA_NODE_TAG:
{
Lib3dsNode *node;
node=lib3ds_node_new_camera();
if (!node) {
return(LIB3DS_FALSE);
}
node->node_id=node_number++;
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_node_read(node, file, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
}
break;
case LIB3DS_TARGET_NODE_TAG:
{
Lib3dsNode *node;
node=lib3ds_node_new_target();
if (!node) {
return(LIB3DS_FALSE);
}
node->node_id=node_number++;
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_node_read(node, file, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
}
break;
case LIB3DS_LIGHT_NODE_TAG:
case LIB3DS_SPOTLIGHT_NODE_TAG:
{
Lib3dsNode *node;
node=lib3ds_node_new_light();
if (!node) {
return(LIB3DS_FALSE);
}
node->node_id=node_number++;
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_node_read(node, file, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
}
break;
case LIB3DS_L_TARGET_NODE_TAG:
{
Lib3dsNode *node;
node=lib3ds_node_new_spot();
if (!node) {
return(LIB3DS_FALSE);
}
node->node_id=node_number++;
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_node_read(node, file, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_node(file, node);
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
static Lib3dsBool
mdata_read(Lib3dsFile *file, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
if (!lib3ds_chunk_read_start(&c, LIB3DS_MDATA, io)) {
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_MESH_VERSION:
{
file->mesh_version=lib3ds_io_read_intd(io);
}
break;
case LIB3DS_MASTER_SCALE:
{
file->master_scale=lib3ds_io_read_float(io);
}
break;
case LIB3DS_SHADOW_MAP_SIZE:
case LIB3DS_LO_SHADOW_BIAS:
case LIB3DS_HI_SHADOW_BIAS:
case LIB3DS_SHADOW_SAMPLES:
case LIB3DS_SHADOW_RANGE:
case LIB3DS_SHADOW_FILTER:
case LIB3DS_RAY_BIAS:
{
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_shadow_read(&file->shadow, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_VIEWPORT_LAYOUT:
case LIB3DS_DEFAULT_VIEW:
{
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_viewport_read(&file->viewport, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_O_CONSTS:
{
int i;
for (i=0; i<3; ++i) {
file->construction_plane[i]=lib3ds_io_read_float(io);
}
}
break;
case LIB3DS_AMBIENT_LIGHT:
{
lib3ds_chunk_read_reset(&c, io);
if (!ambient_read(file, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_BIT_MAP:
case LIB3DS_SOLID_BGND:
case LIB3DS_V_GRADIENT:
case LIB3DS_USE_BIT_MAP:
case LIB3DS_USE_SOLID_BGND:
case LIB3DS_USE_V_GRADIENT:
{
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_background_read(&file->background, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_FOG:
case LIB3DS_LAYER_FOG:
case LIB3DS_DISTANCE_CUE:
case LIB3DS_USE_FOG:
case LIB3DS_USE_LAYER_FOG:
case LIB3DS_USE_DISTANCE_CUE:
{
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_atmosphere_read(&file->atmosphere, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_ENTRY:
{
Lib3dsMaterial *material;
material=lib3ds_material_new();
if (!material) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_read_reset(&c, io);
if (!lib3ds_material_read(material, io)) {
return(LIB3DS_FALSE);
}
lib3ds_file_insert_material(file, material);
}
break;
case LIB3DS_NAMED_OBJECT:
{
lib3ds_chunk_read_reset(&c, io);
if (!named_object_read(file, io)) {
return(LIB3DS_FALSE);
}
}
break;
default:
lib3ds_chunk_unknown(chunk);
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
static void
kfdata_read(Lib3dsFile *file, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
unsigned num_nodes = 0;
Lib3dsNode *last = NULL;
lib3ds_chunk_read_start(&c, CHK_KFDATA, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_KFHDR: {
file->keyf_revision = lib3ds_io_read_word(io);
lib3ds_io_read_string(io, file->name, 12 + 1);
file->frames = lib3ds_io_read_intd(io);
break;
}
case CHK_KFSEG: {
file->segment_from = lib3ds_io_read_intd(io);
file->segment_to = lib3ds_io_read_intd(io);
break;
}
case CHK_KFCURTIME: {
file->current_frame = lib3ds_io_read_intd(io);
break;
}
case CHK_VIEWPORT_LAYOUT:
case CHK_DEFAULT_VIEW: {
lib3ds_chunk_read_reset(&c, io);
lib3ds_viewport_read(&file->viewport_keyf, io);
break;
}
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: {
Lib3dsNodeType type = (Lib3dsNodeType)0;
Lib3dsNode *node;
switch (chunk) {
case CHK_AMBIENT_NODE_TAG:
type = LIB3DS_NODE_AMBIENT_COLOR;
break;
case CHK_OBJECT_NODE_TAG:
type = LIB3DS_NODE_MESH_INSTANCE;
break;
case CHK_CAMERA_NODE_TAG:
type = LIB3DS_NODE_CAMERA;
break;
case CHK_TARGET_NODE_TAG:
type = LIB3DS_NODE_CAMERA_TARGET;
break;
case CHK_LIGHT_NODE_TAG:
type = LIB3DS_NODE_OMNILIGHT;
break;
case CHK_SPOTLIGHT_NODE_TAG:
type = LIB3DS_NODE_SPOTLIGHT;
break;
case CHK_L_TARGET_NODE_TAG:
type = LIB3DS_NODE_SPOTLIGHT_TARGET;
break;
}
node = lib3ds_node_new(type);
node->node_id = (unsigned short)(num_nodes++);
if (last) {
last->next = node;
} else {
file->nodes = node;
}
node->user_ptr = last;
last = node;
lib3ds_chunk_read_reset(&c, io);
lib3ds_node_read(node, io);
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
}
{
Lib3dsNode **nodes = (Lib3dsNode**)malloc(num_nodes * sizeof(Lib3dsNode*));
unsigned i;
Lib3dsNode *p, *q, *parent;
p = file->nodes;
for (i = 0; i < num_nodes; ++i) {
nodes[i] = p;
p = p->next;
}
qsort(nodes, num_nodes, sizeof(Lib3dsNode*), compare_node_id);
p = last;
while (p) {
q = (Lib3dsNode*)p->user_ptr;
if (p->user_id != 65535) {
parent = *(Lib3dsNode**)bsearch(&p->user_id, nodes, num_nodes, sizeof(Lib3dsNode*), compare_node_id2);
if (parent) {
q->next = p->next;
p->next = parent->childs;
p->parent = parent;
parent->childs = p;
} else {
/* TODO: warning */
}
}
p->user_id = 0;
p->user_ptr = NULL;
p = q;
}
free(nodes);
}
lib3ds_chunk_read_end(&c, io);
}
static void
mdata_read(Lib3dsFile *file, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
lib3ds_chunk_read_start(&c, CHK_MDATA, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_MESH_VERSION: {
file->mesh_version = lib3ds_io_read_intd(io);
break;
}
case CHK_MASTER_SCALE: {
file->master_scale = lib3ds_io_read_float(io);
break;
}
case CHK_SHADOW_MAP_SIZE:
case CHK_LO_SHADOW_BIAS:
case CHK_HI_SHADOW_BIAS:
case CHK_SHADOW_SAMPLES:
case CHK_SHADOW_RANGE:
case CHK_SHADOW_FILTER:
case CHK_RAY_BIAS: {
lib3ds_chunk_read_reset(&c, io);
lib3ds_shadow_read(&file->shadow, io);
break;
}
case CHK_VIEWPORT_LAYOUT:
case CHK_DEFAULT_VIEW: {
lib3ds_chunk_read_reset(&c, io);
lib3ds_viewport_read(&file->viewport, io);
break;
}
case CHK_O_CONSTS: {
int i;
for (i = 0; i < 3; ++i) {
file->construction_plane[i] = lib3ds_io_read_float(io);
}
break;
}
case CHK_AMBIENT_LIGHT: {
lib3ds_chunk_read_reset(&c, io);
ambient_read(file, io);
break;
}
case CHK_BIT_MAP:
case CHK_SOLID_BGND:
case CHK_V_GRADIENT:
case CHK_USE_BIT_MAP:
case CHK_USE_SOLID_BGND:
case CHK_USE_V_GRADIENT: {
lib3ds_chunk_read_reset(&c, io);
lib3ds_background_read(&file->background, io);
break;
}
case CHK_FOG:
case CHK_LAYER_FOG:
case CHK_DISTANCE_CUE:
case CHK_USE_FOG:
case CHK_USE_LAYER_FOG:
case CHK_USE_DISTANCE_CUE: {
lib3ds_chunk_read_reset(&c, io);
lib3ds_atmosphere_read(&file->atmosphere, io);
break;
}
case CHK_MAT_ENTRY: {
Lib3dsMaterial *material = lib3ds_material_new(NULL);
lib3ds_file_insert_material(file, material, -1);
lib3ds_chunk_read_reset(&c, io);
lib3ds_material_read(material, io);
break;
}
case CHK_NAMED_OBJECT: {
lib3ds_chunk_read_reset(&c, io);
named_object_read(file, io);
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
/*!
* \ingroup material
*/
Lib3dsBool
lib3ds_material_read(Lib3dsMaterial *material, Lib3dsIo *io)
{
Lib3dsChunk c;
Lib3dsWord chunk;
ASSERT(material);
if (!lib3ds_chunk_read_start(&c, LIB3DS_MAT_ENTRY, io)) {
return(LIB3DS_FALSE);
}
while ((chunk=lib3ds_chunk_read_next(&c, io))!=0) {
switch (chunk) {
case LIB3DS_MAT_NAME:
{
if (!lib3ds_io_read_string(io, material->name, 64)) {
return(LIB3DS_FALSE);
}
lib3ds_chunk_dump_info(" NAME=%s", material->name);
}
break;
case LIB3DS_MAT_AMBIENT:
{
lib3ds_chunk_read_reset(&c, io);
if (!color_read(material->ambient, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_DIFFUSE:
{
lib3ds_chunk_read_reset(&c, io);
if (!color_read(material->diffuse, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SPECULAR:
{
lib3ds_chunk_read_reset(&c, io);
if (!color_read(material->specular, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SHININESS:
{
lib3ds_chunk_read_reset(&c, io);
if (!int_percentage_read(&material->shininess, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SHIN2PCT:
{
lib3ds_chunk_read_reset(&c, io);
if (!int_percentage_read(&material->shin_strength, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_TRANSPARENCY:
{
lib3ds_chunk_read_reset(&c, io);
if (!int_percentage_read(&material->transparency, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_XPFALL:
{
lib3ds_chunk_read_reset(&c, io);
if (!int_percentage_read(&material->falloff, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SELF_ILPCT:
{
lib3ds_chunk_read_reset(&c, io);
if (!int_percentage_read(&material->self_ilpct, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_USE_XPFALL:
{
material->use_falloff=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_REFBLUR:
{
lib3ds_chunk_read_reset(&c, io);
if (!int_percentage_read(&material->blur, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_USE_REFBLUR:
{
material->use_blur=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_SHADING:
{
material->shading=lib3ds_io_read_intw(io);
}
break;
case LIB3DS_MAT_SELF_ILLUM:
{
material->self_illum=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_TWO_SIDE:
{
material->two_sided=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_DECAL:
{
material->map_decal=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_ADDITIVE:
{
material->additive=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_FACEMAP:
{
material->face_map=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_PHONGSOFT:
{
material->soften=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_WIRE:
{
material->use_wire=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_WIREABS:
{
material->use_wire_abs=LIB3DS_TRUE;
}
break;
case LIB3DS_MAT_WIRE_SIZE:
{
material->wire_size=lib3ds_io_read_float(io);
}
break;
case LIB3DS_MAT_TEXMAP:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->texture1_map, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_TEXMASK:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->texture1_mask, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_TEX2MAP:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->texture2_map, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_TEX2MASK:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->texture2_mask, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_OPACMAP:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->opacity_map, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_OPACMASK:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->opacity_mask, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_BUMPMAP:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->bump_map, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_BUMPMASK:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->bump_mask, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SPECMAP:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->specular_map, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SPECMASK:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->specular_mask, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SHINMAP:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->shininess_map, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SHINMASK:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->shininess_mask, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SELFIMAP:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->self_illum_map, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_SELFIMASK:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->self_illum_mask, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_REFLMAP:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->reflection_map, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_REFLMASK:
{
lib3ds_chunk_read_reset(&c, io);
if (!texture_map_read(&material->reflection_mask, io)) {
return(LIB3DS_FALSE);
}
}
break;
case LIB3DS_MAT_ACUBIC:
{
lib3ds_io_read_intb(io);
material->autorefl_map.level=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);
}
}
lib3ds_chunk_read_end(&c, io);
return(LIB3DS_TRUE);
}
