/*!
* Write a camera definition to a file.
*
* This function is called by lib3ds_file_write(), and you probably
* don't want to call it directly.
*
* \param camera A Lib3dsCamera to be written.
* \param io A Lib3dsIo object previously set up by the caller.
*
* \see lib3ds_file_write
*/
void
lib3ds_camera_write(Lib3dsCamera *camera, Lib3dsIo *io) {
Lib3dsChunk c;
c.chunk = CHK_N_CAMERA;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_vector(io, camera->position);
lib3ds_io_write_vector(io, camera->target);
lib3ds_io_write_float(io, camera->roll);
if (fabs(camera->fov) < LIB3DS_EPSILON) {
lib3ds_io_write_float(io, 2400.0f / 45.0f);
} else {
lib3ds_io_write_float(io, 2400.0f / camera->fov);
}
if (camera->see_cone) {
Lib3dsChunk c;
c.chunk = CHK_CAM_SEE_CONE;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
{
Lib3dsChunk c;
c.chunk = CHK_CAM_RANGES;
c.size = 14;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, camera->near_range);
lib3ds_io_write_float(io, camera->far_range);
}
lib3ds_chunk_write_end(&c, io);
}
static Lib3dsBool
kfdata_write(Lib3dsFile *file, Lib3dsIo *io)
{
Lib3dsChunk c;
if (!file->nodes) {
return(LIB3DS_TRUE);
}
c.chunk=LIB3DS_KFDATA;
if (!lib3ds_chunk_write_start(&c,io)) {
return(LIB3DS_FALSE);
}
{ /*---- LIB3DS_KFHDR ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_KFHDR;
c.size=6 + 2 + (Lib3dsDword)strlen(file->name)+1 +4;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_intw(io, file->keyf_revision);
lib3ds_io_write_string(io, file->name);
lib3ds_io_write_intd(io, file->frames);
}
{ /*---- LIB3DS_KFSEG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_KFSEG;
c.size=14;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_intd(io, file->segment_from);
lib3ds_io_write_intd(io, file->segment_to);
}
{ /*---- LIB3DS_KFCURTIME ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_KFCURTIME;
c.size=10;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_intd(io, file->current_frame);
}
lib3ds_viewport_write(&file->viewport_keyf, io);
{
Lib3dsNode *p;
for (p=file->nodes; p!=0; p=p->next) {
if (!lib3ds_node_write(p, file, io)) {
return(LIB3DS_FALSE);
}
if (!nodes_write(p, file, io)) {
return(LIB3DS_FALSE);
}
}
}
if (!lib3ds_chunk_write_end(&c,io)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
}
static Lib3dsBool
kfdata_write(Lib3dsFile *file, FILE *f)
{
Lib3dsChunk c;
c.chunk=LIB3DS_KFDATA;
if (!lib3ds_chunk_write_start(&c,f)) {
return(LIB3DS_FALSE);
}
{ /*---- LIB3DS_KFHDR ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_KFHDR;
c.size=6 + 2 + strlen(file->name)+1 +4;
lib3ds_chunk_write(&c,f);
lib3ds_intw_write(file->keyf_revision,f);
lib3ds_string_write(file->name, f);
lib3ds_intd_write(file->frames, f);
}
{ /*---- LIB3DS_KFSEG ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_KFSEG;
c.size=14;
lib3ds_chunk_write(&c,f);
lib3ds_intd_write(file->segment_from,f);
lib3ds_intd_write(file->segment_to,f);
}
{ /*---- LIB3DS_KFCURTIME ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_KFCURTIME;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_intd_write(file->current_frame,f);
}
lib3ds_viewport_write(&file->viewport_keyf, f);
{
Lib3dsNode *p;
for (p=file->nodes; p!=0; p=p->next) {
if (!lib3ds_node_write(p, file, f)) {
return(LIB3DS_FALSE);
}
if (!nodes_write(p, file, f)) {
return(LIB3DS_FALSE);
}
}
}
if (!lib3ds_chunk_write_end(&c,f)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
}
static void
colorf_write(float rgb[3], Lib3dsIo *io) {
Lib3dsChunk c;
c.chunk = CHK_COLOR_F;
c.size = 18;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_rgb(io, rgb);
c.chunk = CHK_LIN_COLOR_F;
c.size = 18;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_rgb(io, rgb);
}
static void
point_array_write(Lib3dsMesh *mesh, Lib3dsIo *io) {
Lib3dsChunk c;
int i;
c.chunk = CHK_POINT_ARRAY;
c.size = 8 + 12 * mesh->nvertices;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_word(io, (uint16_t) mesh->nvertices);
if (lib3ds_matrix_det(mesh->matrix) >= 0.0f) {
for (i = 0; i < mesh->nvertices; ++i) {
lib3ds_io_write_vector(io, mesh->vertices[i]);
}
} else {
/* Flip X coordinate of vertices if mesh matrix
has negative determinant */
float inv_matrix[4][4], M[4][4];
float tmp[3];
lib3ds_matrix_copy(inv_matrix, mesh->matrix);
lib3ds_matrix_inv(inv_matrix);
lib3ds_matrix_copy(M, mesh->matrix);
lib3ds_matrix_scale(M, -1.0f, 1.0f, 1.0f);
lib3ds_matrix_mult(M, M, inv_matrix);
for (i = 0; i < mesh->nvertices; ++i) {
lib3ds_vector_transform(tmp, M, mesh->vertices[i]);
lib3ds_io_write_vector(io, tmp);
}
}
}
/*!
* Write 3ds file data from a Lib3dsFile object to a file.
*
* \param file The Lib3dsFile object to be written.
* \param io A Lib3dsIo object previously set up by the caller.
*
* \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
*/
int
lib3ds_file_write(Lib3dsFile *file, Lib3dsIo *io) {
Lib3dsChunk c;
Lib3dsIoImpl *impl;
lib3ds_io_setup(io);
impl = (Lib3dsIoImpl*)io->impl;
if (setjmp(impl->jmpbuf) != 0) {
lib3ds_io_cleanup(io);
return FALSE;
}
c.chunk = CHK_M3DMAGIC;
lib3ds_chunk_write_start(&c, io);
{ /*---- LIB3DS_M3D_VERSION ----*/
Lib3dsChunk c;
c.chunk = CHK_M3D_VERSION;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_dword(io, file->mesh_version);
}
mdata_write(file, io);
kfdata_write(file, io);
lib3ds_chunk_write_end(&c, io);
memset(impl->jmpbuf, 0, sizeof(impl->jmpbuf));
lib3ds_io_cleanup(io);
return TRUE;
}
/*!
* \ingroup file
*/
Lib3dsBool
lib3ds_file_write(Lib3dsFile *file, FILE *f)
{
Lib3dsChunk c;
c.chunk=LIB3DS_M3DMAGIC;
if (!lib3ds_chunk_write_start(&c,f)) {
LIB3DS_ERROR_LOG;
return(LIB3DS_FALSE);
}
{ /*---- LIB3DS_M3D_VERSION ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_M3D_VERSION;
c.size=10;
lib3ds_chunk_write(&c,f);
lib3ds_dword_write(file->mesh_version, f);
}
if (!mdata_write(file, f)) {
return(LIB3DS_FALSE);
}
if (!kfdata_write(file, f)) {
return(LIB3DS_FALSE);
}
if (!lib3ds_chunk_write_end(&c,f)) {
return(LIB3DS_FALSE);
}
return(LIB3DS_TRUE);
}
static Lib3dsBool
colorf_write(Lib3dsRgba rgb, Lib3dsIo *io)
{
Lib3dsChunk c;
c.chunk=LIB3DS_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_rgb(io, rgb);
c.chunk=LIB3DS_LIN_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_rgb(io, rgb);
return(LIB3DS_TRUE);
}
static Lib3dsBool
colorf_write(Lib3dsRgba rgb, FILE *f)
{
Lib3dsChunk c;
c.chunk=LIB3DS_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_rgb_write(rgb,f);
c.chunk=LIB3DS_LIN_COLOR_F;
c.size=18;
lib3ds_chunk_write(&c,f);
lib3ds_rgb_write(rgb,f);
return(LIB3DS_TRUE);
}
/*!
* \ingroup chunk
*/
Lib3dsBool
lib3ds_chunk_write_switch(Lib3dsWord chunk, Lib3dsIo *io)
{
Lib3dsChunk c;
c.chunk=chunk;
c.size=6;
return lib3ds_chunk_write(&c,io);
}
static void
color_write(float rgb[3], Lib3dsIo *io) {
Lib3dsChunk c;
c.chunk = CHK_COLOR_24;
c.size = 9;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_byte(io, (uint8_t)floor(255.0*rgb[0] + 0.5));
lib3ds_io_write_byte(io, (uint8_t)floor(255.0*rgb[1] + 0.5));
lib3ds_io_write_byte(io, (uint8_t)floor(255.0*rgb[2] + 0.5));
c.chunk = CHK_LIN_COLOR_24;
c.size = 9;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_byte(io, (uint8_t)floor(255.0*rgb[0] + 0.5));
lib3ds_io_write_byte(io, (uint8_t)floor(255.0*rgb[1] + 0.5));
lib3ds_io_write_byte(io, (uint8_t)floor(255.0*rgb[2] + 0.5));
}
static void
int_percentage_write(float p, Lib3dsIo *io) {
Lib3dsChunk c;
c.chunk = CHK_INT_PERCENTAGE;
c.size = 8;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_intw(io, (uint8_t)floor(100.0*p + 0.5));
}
/*!
* \ingroup shadow
*/
Lib3dsBool
lib3ds_shadow_write(Lib3dsShadow *shadow, Lib3dsIo *io)
{
if (fabs(shadow->lo_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_LO_SHADOW_BIAS ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_LO_SHADOW_BIAS;
c.size=10;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_float(io, shadow->lo_bias);
}
if (fabs(shadow->hi_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_HI_SHADOW_BIAS ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_HI_SHADOW_BIAS;
c.size=10;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_float(io, shadow->hi_bias);
}
if (shadow->map_size) { /*---- LIB3DS_SHADOW_MAP_SIZE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SHADOW_MAP_SIZE;
c.size=8;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_intw(io, shadow->map_size);
}
if (shadow->samples) { /*---- LIB3DS_SHADOW_SAMPLES ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SHADOW_SAMPLES;
c.size=8;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_intw(io, shadow->samples);
}
if (shadow->range) { /*---- LIB3DS_SHADOW_RANGE ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SHADOW_RANGE;
c.size=10;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_intd(io, shadow->range);
}
if (fabs(shadow->filter)>LIB3DS_EPSILON) { /*---- LIB3DS_SHADOW_FILTER ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SHADOW_FILTER;
c.size=10;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_float(io, shadow->filter);
}
if (fabs(shadow->ray_bias)>LIB3DS_EPSILON) { /*---- LIB3DS_RAY_BIAS ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_RAY_BIAS;
c.size=10;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_float(io, shadow->ray_bias);
}
return(LIB3DS_TRUE);
}
static void
kfdata_write(Lib3dsFile *file, Lib3dsIo *io) {
Lib3dsChunk c;
if (!file->nodes) {
return;
}
c.chunk = CHK_KFDATA;
lib3ds_chunk_write_start(&c, io);
{ /*---- LIB3DS_KFHDR ----*/
Lib3dsChunk c;
c.chunk = CHK_KFHDR;
c.size = 6 + 2 + (uint32_t)strlen(file->name) + 1 + 4;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_intw(io, (int16_t)file->keyf_revision);
lib3ds_io_write_string(io, file->name);
lib3ds_io_write_intd(io, file->frames);
}
{ /*---- LIB3DS_KFSEG ----*/
Lib3dsChunk c;
c.chunk = CHK_KFSEG;
c.size = 14;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_intd(io, file->segment_from);
lib3ds_io_write_intd(io, file->segment_to);
}
{ /*---- LIB3DS_KFCURTIME ----*/
Lib3dsChunk c;
c.chunk = CHK_KFCURTIME;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_intd(io, file->current_frame);
}
lib3ds_viewport_write(&file->viewport_keyf, io);
{
uint16_t default_id = 0;
nodes_write(file->nodes, &default_id, 65535, io);
}
lib3ds_chunk_write_end(&c, io);
}
void
lib3ds_shadow_write(Lib3dsShadow *shadow, Lib3dsIo *io) {
if (fabs(shadow->low_bias) > LIB3DS_EPSILON) { /*---- CHK_LO_SHADOW_BIAS ----*/
Lib3dsChunk c;
c.chunk = CHK_LO_SHADOW_BIAS;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, shadow->low_bias);
}
if (fabs(shadow->hi_bias) > LIB3DS_EPSILON) { /*---- CHK_HI_SHADOW_BIAS ----*/
Lib3dsChunk c;
c.chunk = CHK_HI_SHADOW_BIAS;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, shadow->hi_bias);
}
if (shadow->map_size) { /*---- CHK_SHADOW_MAP_SIZE ----*/
Lib3dsChunk c;
c.chunk = CHK_SHADOW_MAP_SIZE;
c.size = 8;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_intw(io, shadow->map_size);
}
if (fabs(shadow->filter) > LIB3DS_EPSILON) { /*---- CHK_SHADOW_FILTER ----*/
Lib3dsChunk c;
c.chunk = CHK_SHADOW_FILTER;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, shadow->filter);
}
if (fabs(shadow->ray_bias) > LIB3DS_EPSILON) { /*---- CHK_RAY_BIAS ----*/
Lib3dsChunk c;
c.chunk = CHK_RAY_BIAS;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, shadow->ray_bias);
}
}
static Lib3dsBool
int_percentage_write(Lib3dsFloat p, FILE *f)
{
Lib3dsChunk c;
c.chunk=LIB3DS_INT_PERCENTAGE;
c.size=8;
lib3ds_chunk_write(&c,f);
lib3ds_intw_write((Lib3dsByte)floor(100.0*p+0.5),f);
return(LIB3DS_TRUE);
}
static Lib3dsBool
color_write(Lib3dsRgba rgb, Lib3dsIo *io)
{
Lib3dsChunk c;
c.chunk=LIB3DS_COLOR_24;
c.size=9;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[0]+0.5));
lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[1]+0.5));
lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[2]+0.5));
c.chunk=LIB3DS_LIN_COLOR_24;
c.size=9;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[0]+0.5));
lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[1]+0.5));
lib3ds_io_write_byte(io, (Lib3dsByte)floor(255.0*rgb[2]+0.5));
return(LIB3DS_TRUE);
}
static Lib3dsBool
int_percentage_write(Lib3dsFloat p, Lib3dsIo *io)
{
Lib3dsChunk c;
c.chunk=LIB3DS_INT_PERCENTAGE;
c.size=8;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_intw(io, (Lib3dsByte)floor(100.0*p+0.5));
return(LIB3DS_TRUE);
}
static Lib3dsBool
color_write(Lib3dsRgba rgb, FILE *f)
{
Lib3dsChunk c;
c.chunk=LIB3DS_COLOR_24;
c.size=9;
lib3ds_chunk_write(&c,f);
lib3ds_byte_write((Lib3dsByte)floor(255.0*rgb[0]+0.5),f);
lib3ds_byte_write((Lib3dsByte)floor(255.0*rgb[1]+0.5),f);
lib3ds_byte_write((Lib3dsByte)floor(255.0*rgb[2]+0.5),f);
c.chunk=LIB3DS_LIN_COLOR_24;
c.size=9;
lib3ds_chunk_write(&c,f);
lib3ds_byte_write((Lib3dsByte)floor(255.0*rgb[0]+0.5),f);
lib3ds_byte_write((Lib3dsByte)floor(255.0*rgb[1]+0.5),f);
lib3ds_byte_write((Lib3dsByte)floor(255.0*rgb[2]+0.5),f);
return(LIB3DS_TRUE);
}
/*!
* \ingroup background
*/
Lib3dsBool
lib3ds_background_write(Lib3dsBackground *background, Lib3dsIo *io)
{
if (strlen(background->bitmap.name)) { /*---- LIB3DS_BIT_MAP ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_BIT_MAP;
c.size=6+1+(Lib3dsDword)strlen(background->bitmap.name);
lib3ds_chunk_write(&c,io);
lib3ds_io_write_string(io, background->bitmap.name);
}
if (colorf_defined(background->solid.col)) { /*---- LIB3DS_SOLID_BGND ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_SOLID_BGND;
c.size=42;
lib3ds_chunk_write(&c,io);
colorf_write(background->solid.col, io);
}
if (colorf_defined(background->gradient.top) ||
colorf_defined(background->gradient.middle) ||
colorf_defined(background->gradient.bottom)) { /*---- LIB3DS_V_GRADIENT ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_V_GRADIENT;
c.size=118;
lib3ds_chunk_write(&c,io);
lib3ds_io_write_float(io, background->gradient.percent);
colorf_write(background->gradient.top,io);
colorf_write(background->gradient.middle,io);
colorf_write(background->gradient.bottom,io);
}
if (background->bitmap.use) { /*---- LIB3DS_USE_BIT_MAP ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_USE_BIT_MAP;
c.size=6;
lib3ds_chunk_write(&c,io);
}
if (background->solid.use) { /*---- LIB3DS_USE_SOLID_BGND ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_USE_SOLID_BGND;
c.size=6;
lib3ds_chunk_write(&c,io);
}
if (background->gradient.use) { /*---- LIB3DS_USE_V_GRADIENT ----*/
Lib3dsChunk c;
c.chunk=LIB3DS_USE_V_GRADIENT;
c.size=6;
lib3ds_chunk_write(&c,io);
}
return(LIB3DS_TRUE);
}
static void
flag_array_write(Lib3dsMesh *mesh, Lib3dsIo *io) {
Lib3dsChunk c;
int i;
if (!mesh->vflags) {
return;
}
c.chunk = CHK_POINT_FLAG_ARRAY;
c.size = 8 + 2 * mesh->nvertices;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_word(io, (uint16_t) mesh->nvertices);
for (i = 0; i < mesh->nvertices; ++i) {
lib3ds_io_write_word(io, mesh->vflags[i]);
}
}
void
lib3ds_background_write(Lib3dsBackground *background, Lib3dsIo *io) {
if (strlen(background->bitmap_name)) { /*---- LIB3DS_BIT_MAP ----*/
Lib3dsChunk c;
c.chunk = CHK_BIT_MAP;
c.size = 6 + 1 + (uint32_t)strlen(background->bitmap_name);
lib3ds_chunk_write(&c, io);
lib3ds_io_write_string(io, background->bitmap_name);
}
if (colorf_defined(background->solid_color)) { /*---- LIB3DS_SOLID_BGND ----*/
Lib3dsChunk c;
c.chunk = CHK_SOLID_BGND;
c.size = 42;
lib3ds_chunk_write(&c, io);
colorf_write(background->solid_color, io);
}
if (colorf_defined(background->gradient_top) ||
colorf_defined(background->gradient_middle) ||
colorf_defined(background->gradient_bottom)) { /*---- LIB3DS_V_GRADIENT ----*/
Lib3dsChunk c;
c.chunk = CHK_V_GRADIENT;
c.size = 118;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, background->gradient_percent);
colorf_write(background->gradient_top, io);
colorf_write(background->gradient_middle, io);
colorf_write(background->gradient_bottom, io);
}
if (background->use_bitmap) { /*---- LIB3DS_USE_BIT_MAP ----*/
Lib3dsChunk c;
c.chunk = CHK_USE_BIT_MAP;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (background->use_solid) { /*---- LIB3DS_USE_SOLID_BGND ----*/
Lib3dsChunk c;
c.chunk = CHK_USE_SOLID_BGND;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (background->use_gradient) { /*---- LIB3DS_USE_V_GRADIENT ----*/
Lib3dsChunk c;
c.chunk = CHK_USE_V_GRADIENT;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
}
static void
texco_array_write(Lib3dsMesh *mesh, Lib3dsIo *io) {
Lib3dsChunk c;
int i;
if (!mesh->texcos) {
return;
}
c.chunk = CHK_TEX_VERTS;
c.size = 8 + 8 * mesh->nvertices;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_word(io, mesh->nvertices);
for (i = 0; i < mesh->nvertices; ++i) {
lib3ds_io_write_float(io, mesh->texcos[i][0]);
lib3ds_io_write_float(io, mesh->texcos[i][1]);
}
}
static Lib3dsBool
point_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
{
Lib3dsChunk c;
unsigned i;
if (!mesh->points || !mesh->pointL) {
return(LIB3DS_TRUE);
}
ASSERT(mesh->points<0x10000);
c.chunk=LIB3DS_POINT_ARRAY;
c.size=8+12*mesh->points;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_word(io, (Lib3dsWord)mesh->points);
for (i=0; i<mesh->points; ++i) {
lib3ds_io_write_vector(io, mesh->pointL[i].pos);
}
return(LIB3DS_TRUE);
}
static Lib3dsBool
flag_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
{
Lib3dsChunk c;
unsigned i;
if (!mesh->flags || !mesh->flagL) {
return(LIB3DS_TRUE);
}
ASSERT(mesh->flags<0x10000);
c.chunk=LIB3DS_POINT_FLAG_ARRAY;
c.size=8+2*mesh->flags;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_word(io, (Lib3dsWord)mesh->flags);
for (i=0; i<mesh->flags; ++i) {
lib3ds_io_write_word(io, mesh->flagL[i]);
}
return(LIB3DS_TRUE);
}
static Lib3dsBool
point_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
{
Lib3dsChunk c;
unsigned i;
if (!mesh->points || !mesh->pointL) {
return(LIB3DS_TRUE);
}
ASSERT(mesh->points<0x10000);
c.chunk=LIB3DS_POINT_ARRAY;
c.size=8+12*mesh->points;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_word(io, (Lib3dsWord)mesh->points);
if (lib3ds_matrix_det(mesh->matrix) >= 0.0f) {
for (i=0; i<mesh->points; ++i) {
lib3ds_io_write_vector(io, mesh->pointL[i].pos);
}
}
else {
/* Flip X coordinate of vertices if mesh matrix
has negative determinant */
Lib3dsMatrix inv_matrix, M;
Lib3dsVector tmp;
lib3ds_matrix_copy(inv_matrix, mesh->matrix);
lib3ds_matrix_inv(inv_matrix);
lib3ds_matrix_copy(M, mesh->matrix);
lib3ds_matrix_scale_xyz(M, -1.0f, 1.0f, 1.0f);
lib3ds_matrix_mult(M, inv_matrix);
for (i=0; i<mesh->points; ++i) {
lib3ds_vector_transform(tmp, M, mesh->pointL[i].pos);
lib3ds_io_write_vector(io, tmp);
}
}
return(LIB3DS_TRUE);
}
static Lib3dsBool
texel_array_write(Lib3dsMesh *mesh, Lib3dsIo *io)
{
Lib3dsChunk c;
unsigned i;
if (!mesh->texels || !mesh->texelL) {
return(LIB3DS_TRUE);
}
ASSERT(mesh->texels<0x10000);
c.chunk=LIB3DS_TEX_VERTS;
c.size=8+8*mesh->texels;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_word(io, (Lib3dsWord)mesh->texels);
for (i=0; i<mesh->texels; ++i) {
lib3ds_io_write_float(io, mesh->texelL[i][0]);
lib3ds_io_write_float(io, mesh->texelL[i][1]);
}
return(LIB3DS_TRUE);
}
static void
object_flags_write(uint32_t flags, Lib3dsIo *io) {
if (flags) {
Lib3dsChunk c;
c.size = 6;
if (flags & LIB3DS_OBJECT_HIDDEN) {
c.chunk = CHK_OBJ_HIDDEN;
lib3ds_chunk_write(&c, io);
}
if (flags & LIB3DS_OBJECT_VIS_LOFTER) {
c.chunk = CHK_OBJ_VIS_LOFTER;
lib3ds_chunk_write(&c, io);
}
if (flags & LIB3DS_OBJECT_DOESNT_CAST) {
c.chunk = CHK_OBJ_DOESNT_CAST;
lib3ds_chunk_write(&c, io);
}
if (flags & LIB3DS_OBJECT_MATTE) {
c.chunk = CHK_OBJ_MATTE;
lib3ds_chunk_write(&c, io);
}
if (flags & LIB3DS_OBJECT_DONT_RCVSHADOW) {
c.chunk = CHK_OBJ_DOESNT_CAST;
lib3ds_chunk_write(&c, io);
}
if (flags & LIB3DS_OBJECT_FAST) {
c.chunk = CHK_OBJ_FAST;
lib3ds_chunk_write(&c, io);
}
if (flags & LIB3DS_OBJECT_FROZEN) {
c.chunk = CHK_OBJ_FROZEN;
lib3ds_chunk_write(&c, io);
}
}
}
void
lib3ds_mesh_write(Lib3dsFile *file, Lib3dsMesh *mesh, Lib3dsIo *io) {
Lib3dsChunk c;
c.chunk = CHK_N_TRI_OBJECT;
lib3ds_chunk_write_start(&c, io);
point_array_write(mesh, io);
texco_array_write(mesh, io);
if (mesh->map_type != LIB3DS_MAP_NONE) { /*---- LIB3DS_MESH_TEXTURE_INFO ----*/
Lib3dsChunk c;
int i, j;
c.chunk = CHK_MESH_TEXTURE_INFO;
c.size = 92;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_word(io, (uint16_t)mesh->map_type);
for (i = 0; i < 2; ++i) {
lib3ds_io_write_float(io, mesh->map_tile[i]);
}
lib3ds_io_write_vector(io, mesh->map_pos);
lib3ds_io_write_float(io, mesh->map_scale);
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++) {
lib3ds_io_write_float(io, mesh->map_matrix[i][j]);
}
}
for (i = 0; i < 2; ++i) {
lib3ds_io_write_float(io, mesh->map_planar_size[i]);
}
lib3ds_io_write_float(io, mesh->map_cylinder_height);
}
flag_array_write(mesh, io);
{
/*---- LIB3DS_MESH_MATRIX ----*/
Lib3dsChunk c;
int i, j;
c.chunk = CHK_MESH_MATRIX;
c.size = 54;
lib3ds_chunk_write(&c, io);
for (i = 0; i < 4; i++) {
for (j = 0; j < 3; j++) {
lib3ds_io_write_float(io, mesh->matrix[i][j]);
}
}
}
if (mesh->color) { /*---- LIB3DS_MESH_COLOR ----*/
Lib3dsChunk c;
c.chunk = CHK_MESH_COLOR;
c.size = 7;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_byte(io, (uint8_t)mesh->color);
}
face_array_write(file, mesh, io);
lib3ds_chunk_write_end(&c, io);
}
static void
face_array_write(Lib3dsFile *file, Lib3dsMesh *mesh, Lib3dsIo *io) {
Lib3dsChunk c;
if (mesh->nfaces == 0) {
return;
}
c.chunk = CHK_FACE_ARRAY;
lib3ds_chunk_write_start(&c, io);
{
int i;
lib3ds_io_write_word(io, (uint16_t) mesh->nfaces);
for (i = 0; i < mesh->nfaces; ++i) {
lib3ds_io_write_word(io, mesh->faces[i].index[0]);
lib3ds_io_write_word(io, mesh->faces[i].index[1]);
lib3ds_io_write_word(io, mesh->faces[i].index[2]);
lib3ds_io_write_word(io, mesh->faces[i].flags);
}
}
{
/*---- MSH_CHK_MAT_GROUP ----*/
Lib3dsChunk c;
int i, j;
uint16_t num;
char *matf = (char*)calloc(sizeof(char), mesh->nfaces);
((Lib3dsIoImpl*)io->impl)->tmp_mem = matf;
assert(matf);
for (i = 0; i < mesh->nfaces; ++i) {
if (!matf[i] && (mesh->faces[i].material >= 0) && (mesh->faces[i].material < file->nmaterials)) {
matf[i] = 1;
num = 1;
for (j = i + 1; j < mesh->nfaces; ++j) {
if (mesh->faces[i].material == mesh->faces[j].material) ++num;
}
c.chunk = CHK_MSH_MAT_GROUP;
c.size = 6 + (uint32_t)strlen(file->materials[mesh->faces[i].material]->name) + 1 + 2 + 2 * num;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_string(io, file->materials[mesh->faces[i].material]->name);
lib3ds_io_write_word(io, num);
lib3ds_io_write_word(io, (uint16_t) i);
for (j = i + 1; j < mesh->nfaces; ++j) {
if (mesh->faces[i].material == mesh->faces[j].material) {
lib3ds_io_write_word(io, (uint16_t) j);
matf[j] = 1;
}
}
}
}
((Lib3dsIoImpl*)io->impl)->tmp_mem = NULL;
free(matf);
}
{
/*---- SMOOTH_GROUP ----*/
Lib3dsChunk c;
int i;
c.chunk = CHK_SMOOTH_GROUP;
c.size = 6 + 4 * mesh->nfaces;
lib3ds_chunk_write(&c, io);
for (i = 0; i < mesh->nfaces; ++i) {
lib3ds_io_write_dword(io, mesh->faces[i].smoothing_group);
}
}
{
/*---- MSH_BOXMAP ----*/
Lib3dsChunk c;
if (strlen(mesh->box_front) ||
strlen(mesh->box_back) ||
strlen(mesh->box_left) ||
strlen(mesh->box_right) ||
strlen(mesh->box_top) ||
strlen(mesh->box_bottom)) {
c.chunk = CHK_MSH_BOXMAP;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_string(io, mesh->box_front);
lib3ds_io_write_string(io, mesh->box_back);
lib3ds_io_write_string(io, mesh->box_left);
lib3ds_io_write_string(io, mesh->box_right);
lib3ds_io_write_string(io, mesh->box_top);
lib3ds_io_write_string(io, mesh->box_bottom);
lib3ds_chunk_write_end(&c, io);
}
}
lib3ds_chunk_write_end(&c, io);
}
