FGFS-4.1/OpenSceneGraph
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Ran dos2unix on lib3ds files

Browse Source
This commit is contained in:
Robert Osfield
2010-04-15 18:38:03 +00:00
parent 7ee549bb06
commit 6b73cef997
19 changed files with 8006 additions and 8006 deletions
Download Patch File Download Diff File Expand all files Collapse all files

506
src/osgPlugins/3ds/lib3ds/lib3ds_atmosphere.c
View File

@@ -1,253 +1,253 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
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
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);
}
void
lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io) {
Lib3dsChunk c;
lib3ds_chunk_read(&c, io);
switch (c.chunk) {
case CHK_FOG: {
lib3ds_chunk_read_reset(&c, io);
fog_read(atmosphere, io);
break;
}
case CHK_LAYER_FOG: {
lib3ds_chunk_read_reset(&c, io);
layer_fog_read(atmosphere, io);
break;
}
case CHK_DISTANCE_CUE: {
lib3ds_chunk_read_reset(&c, io);
distance_cue_read(atmosphere, io);
break;
}
case CHK_USE_FOG: {
atmosphere->use_fog = TRUE;
break;
}
case CHK_USE_LAYER_FOG: {
atmosphere->use_layer_fog = TRUE;
break;
}
case CHK_USE_DISTANCE_CUE: {
atmosphere->use_dist_cue = TRUE;
break;
}
}
}
void
lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io) {
if (atmosphere->use_fog) { /*---- LIB3DS_FOG ----*/
Lib3dsChunk c;
c.chunk = CHK_FOG;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_float(io, atmosphere->fog_near_plane);
lib3ds_io_write_float(io, atmosphere->fog_near_density);
lib3ds_io_write_float(io, atmosphere->fog_far_plane);
lib3ds_io_write_float(io, atmosphere->fog_far_density);
{
Lib3dsChunk c;
c.chunk = CHK_COLOR_F;
c.size = 18;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_rgb(io, atmosphere->fog_color);
}
if (atmosphere->fog_background) {
Lib3dsChunk c;
c.chunk = CHK_FOG_BGND;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
lib3ds_chunk_write_end(&c, io);
}
if (atmosphere->use_layer_fog) { /*---- LIB3DS_LAYER_FOG ----*/
Lib3dsChunk c;
c.chunk = CHK_LAYER_FOG;
c.size = 40;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, atmosphere->layer_fog_near_y);
lib3ds_io_write_float(io, atmosphere->layer_fog_far_y);
lib3ds_io_write_float(io, atmosphere->layer_fog_near_y);
lib3ds_io_write_dword(io, atmosphere->layer_fog_flags);
{
Lib3dsChunk c;
c.chunk = CHK_COLOR_F;
c.size = 18;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_rgb(io, atmosphere->fog_color);
}
}
if (atmosphere->use_dist_cue) { /*---- LIB3DS_DISTANCE_CUE ----*/
Lib3dsChunk c;
c.chunk = CHK_DISTANCE_CUE;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_float(io, atmosphere->dist_cue_near_plane);
lib3ds_io_write_float(io, atmosphere->dist_cue_near_dimming);
lib3ds_io_write_float(io, atmosphere->dist_cue_far_plane);
lib3ds_io_write_float(io, atmosphere->dist_cue_far_dimming);
if (atmosphere->dist_cue_background) {
Lib3dsChunk c;
c.chunk = CHK_DCUE_BGND;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
lib3ds_chunk_write_end(&c, io);
}
if (atmosphere->use_fog) { /*---- LIB3DS_USE_FOG ----*/
Lib3dsChunk c;
c.chunk = CHK_USE_FOG;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (atmosphere->use_layer_fog) { /*---- LIB3DS_USE_LAYER_FOG ----*/
Lib3dsChunk c;
c.chunk = CHK_USE_LAYER_FOG;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (atmosphere->use_dist_cue) { /*---- LIB3DS_USE_DISTANCE_CUE ----*/
Lib3dsChunk c;
c.chunk = CHK_USE_V_GRADIENT;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
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
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);
}
void
lib3ds_atmosphere_read(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io) {
Lib3dsChunk c;
lib3ds_chunk_read(&c, io);
switch (c.chunk) {
case CHK_FOG: {
lib3ds_chunk_read_reset(&c, io);
fog_read(atmosphere, io);
break;
}
case CHK_LAYER_FOG: {
lib3ds_chunk_read_reset(&c, io);
layer_fog_read(atmosphere, io);
break;
}
case CHK_DISTANCE_CUE: {
lib3ds_chunk_read_reset(&c, io);
distance_cue_read(atmosphere, io);
break;
}
case CHK_USE_FOG: {
atmosphere->use_fog = TRUE;
break;
}
case CHK_USE_LAYER_FOG: {
atmosphere->use_layer_fog = TRUE;
break;
}
case CHK_USE_DISTANCE_CUE: {
atmosphere->use_dist_cue = TRUE;
break;
}
}
}
void
lib3ds_atmosphere_write(Lib3dsAtmosphere *atmosphere, Lib3dsIo *io) {
if (atmosphere->use_fog) { /*---- LIB3DS_FOG ----*/
Lib3dsChunk c;
c.chunk = CHK_FOG;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_float(io, atmosphere->fog_near_plane);
lib3ds_io_write_float(io, atmosphere->fog_near_density);
lib3ds_io_write_float(io, atmosphere->fog_far_plane);
lib3ds_io_write_float(io, atmosphere->fog_far_density);
{
Lib3dsChunk c;
c.chunk = CHK_COLOR_F;
c.size = 18;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_rgb(io, atmosphere->fog_color);
}
if (atmosphere->fog_background) {
Lib3dsChunk c;
c.chunk = CHK_FOG_BGND;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
lib3ds_chunk_write_end(&c, io);
}
if (atmosphere->use_layer_fog) { /*---- LIB3DS_LAYER_FOG ----*/
Lib3dsChunk c;
c.chunk = CHK_LAYER_FOG;
c.size = 40;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, atmosphere->layer_fog_near_y);
lib3ds_io_write_float(io, atmosphere->layer_fog_far_y);
lib3ds_io_write_float(io, atmosphere->layer_fog_near_y);
lib3ds_io_write_dword(io, atmosphere->layer_fog_flags);
{
Lib3dsChunk c;
c.chunk = CHK_COLOR_F;
c.size = 18;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_rgb(io, atmosphere->fog_color);
}
}
if (atmosphere->use_dist_cue) { /*---- LIB3DS_DISTANCE_CUE ----*/
Lib3dsChunk c;
c.chunk = CHK_DISTANCE_CUE;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_float(io, atmosphere->dist_cue_near_plane);
lib3ds_io_write_float(io, atmosphere->dist_cue_near_dimming);
lib3ds_io_write_float(io, atmosphere->dist_cue_far_plane);
lib3ds_io_write_float(io, atmosphere->dist_cue_far_dimming);
if (atmosphere->dist_cue_background) {
Lib3dsChunk c;
c.chunk = CHK_DCUE_BGND;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
lib3ds_chunk_write_end(&c, io);
}
if (atmosphere->use_fog) { /*---- LIB3DS_USE_FOG ----*/
Lib3dsChunk c;
c.chunk = CHK_USE_FOG;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (atmosphere->use_layer_fog) { /*---- LIB3DS_USE_LAYER_FOG ----*/
Lib3dsChunk c;
c.chunk = CHK_USE_LAYER_FOG;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (atmosphere->use_dist_cue) { /*---- LIB3DS_USE_DISTANCE_CUE ----*/
Lib3dsChunk c;
c.chunk = CHK_USE_V_GRADIENT;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
}

426
src/osgPlugins/3ds/lib3ds/lib3ds_background.c
View File

@@ -1,213 +1,213 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
static void
solid_bgnd_read(Lib3dsBackground *background, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
int have_lin = FALSE;
lib3ds_chunk_read_start(&c, CHK_SOLID_BGND, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_LIN_COLOR_F:
lib3ds_io_read_rgb(io, background->solid_color);
have_lin = TRUE;
break;
case CHK_COLOR_F:
lib3ds_io_read_rgb(io, background->solid_color);
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);
}
void
lib3ds_background_read(Lib3dsBackground *background, Lib3dsIo *io) {
Lib3dsChunk c;
lib3ds_chunk_read(&c, io);
switch (c.chunk) {
case CHK_BIT_MAP: {
lib3ds_io_read_string(io, background->bitmap_name, 64);
break;
}
case CHK_SOLID_BGND: {
lib3ds_chunk_read_reset(&c, io);
solid_bgnd_read(background, io);
break;
}
case CHK_V_GRADIENT: {
lib3ds_chunk_read_reset(&c, io);
v_gradient_read(background, io);
break;
}
case CHK_USE_BIT_MAP: {
background->use_bitmap = TRUE;
break;
}
case CHK_USE_SOLID_BGND: {
background->use_solid = TRUE;
break;
}
case CHK_USE_V_GRADIENT: {
background->use_gradient = TRUE;
break;
}
}
}
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 int
colorf_defined(float rgb[3]) {
int i;
for (i = 0; i < 3; ++i) {
if (fabs(rgb[i]) > LIB3DS_EPSILON) {
break;
}
}
return(i < 3);
}
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);
}
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
static void
solid_bgnd_read(Lib3dsBackground *background, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
int have_lin = FALSE;
lib3ds_chunk_read_start(&c, CHK_SOLID_BGND, io);
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_LIN_COLOR_F:
lib3ds_io_read_rgb(io, background->solid_color);
have_lin = TRUE;
break;
case CHK_COLOR_F:
lib3ds_io_read_rgb(io, background->solid_color);
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);
}
void
lib3ds_background_read(Lib3dsBackground *background, Lib3dsIo *io) {
Lib3dsChunk c;
lib3ds_chunk_read(&c, io);
switch (c.chunk) {
case CHK_BIT_MAP: {
lib3ds_io_read_string(io, background->bitmap_name, 64);
break;
}
case CHK_SOLID_BGND: {
lib3ds_chunk_read_reset(&c, io);
solid_bgnd_read(background, io);
break;
}
case CHK_V_GRADIENT: {
lib3ds_chunk_read_reset(&c, io);
v_gradient_read(background, io);
break;
}
case CHK_USE_BIT_MAP: {
background->use_bitmap = TRUE;
break;
}
case CHK_USE_SOLID_BGND: {
background->use_solid = TRUE;
break;
}
case CHK_USE_V_GRADIENT: {
background->use_gradient = TRUE;
break;
}
}
}
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 int
colorf_defined(float rgb[3]) {
int i;
for (i = 0; i < 3; ++i) {
if (fabs(rgb[i]) > LIB3DS_EPSILON) {
break;
}
}
return(i < 3);
}
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);
}
}

330
src/osgPlugins/3ds/lib3ds/lib3ds_camera.c
View File

@@ -1,165 +1,165 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
/*!
* Return a new Lib3dsCamera object.
*
* Object is initialized with the given name and fov=45. All other
* values are 0.
*
* \param name Name of this camera. Must not be NULL. Must be < 64 characters.
*
* \return Lib3dsCamera object or NULL on failure.
*/
Lib3dsCamera*
lib3ds_camera_new(const char *name) {
Lib3dsCamera *camera;
assert(name);
assert(strlen(name) < 64);
camera = (Lib3dsCamera*)calloc(sizeof(Lib3dsCamera), 1);
if (!camera) {
return(0);
}
strcpy(camera->name, name);
camera->fov = 45.0f;
return(camera);
}
/*!
* Free a Lib3dsCamera object and all of its resources.
*
* \param camera Lib3dsCamera object to be freed.
*/
void
lib3ds_camera_free(Lib3dsCamera *camera) {
memset(camera, 0, sizeof(Lib3dsCamera));
free(camera);
}
/*!
* 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.
*
* \see lib3ds_file_read
*/
void
lib3ds_camera_read(Lib3dsCamera *camera, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
lib3ds_chunk_read_start(&c, CHK_N_CAMERA, io);
{
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 CHK_CAM_SEE_CONE: {
camera->see_cone = TRUE;
}
break;
case CHK_CAM_RANGES: {
camera->near_range = lib3ds_io_read_float(io);
camera->far_range = lib3ds_io_read_float(io);
}
break;
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
/*!
* 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);
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
/*!
* Return a new Lib3dsCamera object.
*
* Object is initialized with the given name and fov=45. All other
* values are 0.
*
* \param name Name of this camera. Must not be NULL. Must be < 64 characters.
*
* \return Lib3dsCamera object or NULL on failure.
*/
Lib3dsCamera*
lib3ds_camera_new(const char *name) {
Lib3dsCamera *camera;
assert(name);
assert(strlen(name) < 64);
camera = (Lib3dsCamera*)calloc(sizeof(Lib3dsCamera), 1);
if (!camera) {
return(0);
}
strcpy(camera->name, name);
camera->fov = 45.0f;
return(camera);
}
/*!
* Free a Lib3dsCamera object and all of its resources.
*
* \param camera Lib3dsCamera object to be freed.
*/
void
lib3ds_camera_free(Lib3dsCamera *camera) {
memset(camera, 0, sizeof(Lib3dsCamera));
free(camera);
}
/*!
* 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.
*
* \see lib3ds_file_read
*/
void
lib3ds_camera_read(Lib3dsCamera *camera, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
lib3ds_chunk_read_start(&c, CHK_N_CAMERA, io);
{
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 CHK_CAM_SEE_CONE: {
camera->see_cone = TRUE;
}
break;
case CHK_CAM_RANGES: {
camera->near_range = lib3ds_io_read_float(io);
camera->far_range = lib3ds_io_read_float(io);
}
break;
default:
lib3ds_chunk_unknown(chunk, io);
}
}
lib3ds_chunk_read_end(&c, io);
}
/*!
* 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);
}

292
src/osgPlugins/3ds/lib3ds/lib3ds_chunk.c
View File

@@ -1,146 +1,146 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
/*#define LIB3DS_CHUNK_DEBUG*/
/*#define LIB3DS_CHUNK_WARNING*/
/*!
* 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.");
}
}
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++;
}
void
lib3ds_chunk_read_tell(Lib3dsChunk *c, Lib3dsIo *io) {
c->cur = lib3ds_io_tell(io);
}
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;
}
void
lib3ds_chunk_read_reset(Lib3dsChunk *c, Lib3dsIo *io) {
lib3ds_io_seek(io, -6, LIB3DS_SEEK_CUR);
}
void
lib3ds_chunk_read_end(Lib3dsChunk *c, Lib3dsIo *io) {
((Lib3dsIoImpl*)io->impl)->log_indent--;
lib3ds_io_seek(io, c->end, LIB3DS_SEEK_SET);
}
/*!
* Writes a 3d-Studio chunk header into a little endian file stream.
*
* \param c The chunk to be written.
* \param io The file stream.
*
* \return True on success, False otherwise.
*/
void
lib3ds_chunk_write(Lib3dsChunk *c, Lib3dsIo *io) {
assert(c);
lib3ds_io_write_word(io, c->chunk);
lib3ds_io_write_dword(io, c->size);
}
void
lib3ds_chunk_write_start(Lib3dsChunk *c, Lib3dsIo *io) {
assert(c);
c->size = 0;
c->cur = lib3ds_io_tell(io);
lib3ds_io_write_word(io, c->chunk);
lib3ds_io_write_dword(io, c->size);
}
void
lib3ds_chunk_write_end(Lib3dsChunk *c, Lib3dsIo *io) {
assert(c);
c->size = lib3ds_io_tell(io) - c->cur;
lib3ds_io_seek(io, c->cur + 2, LIB3DS_SEEK_SET);
lib3ds_io_write_dword(io, c->size);
c->cur += c->size;
lib3ds_io_seek(io, c->cur, LIB3DS_SEEK_SET);
}
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);
}
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
/*#define LIB3DS_CHUNK_DEBUG*/
/*#define LIB3DS_CHUNK_WARNING*/
/*!
* 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.");
}
}
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++;
}
void
lib3ds_chunk_read_tell(Lib3dsChunk *c, Lib3dsIo *io) {
c->cur = lib3ds_io_tell(io);
}
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;
}
void
lib3ds_chunk_read_reset(Lib3dsChunk *c, Lib3dsIo *io) {
lib3ds_io_seek(io, -6, LIB3DS_SEEK_CUR);
}
void
lib3ds_chunk_read_end(Lib3dsChunk *c, Lib3dsIo *io) {
((Lib3dsIoImpl*)io->impl)->log_indent--;
lib3ds_io_seek(io, c->end, LIB3DS_SEEK_SET);
}
/*!
* Writes a 3d-Studio chunk header into a little endian file stream.
*
* \param c The chunk to be written.
* \param io The file stream.
*
* \return True on success, False otherwise.
*/
void
lib3ds_chunk_write(Lib3dsChunk *c, Lib3dsIo *io) {
assert(c);
lib3ds_io_write_word(io, c->chunk);
lib3ds_io_write_dword(io, c->size);
}
void
lib3ds_chunk_write_start(Lib3dsChunk *c, Lib3dsIo *io) {
assert(c);
c->size = 0;
c->cur = lib3ds_io_tell(io);
lib3ds_io_write_word(io, c->chunk);
lib3ds_io_write_dword(io, c->size);
}
void
lib3ds_chunk_write_end(Lib3dsChunk *c, Lib3dsIo *io) {
assert(c);
c->size = lib3ds_io_tell(io) - c->cur;
lib3ds_io_seek(io, c->cur + 2, LIB3DS_SEEK_SET);
lib3ds_io_write_dword(io, c->size);
c->cur += c->size;
lib3ds_io_seek(io, c->cur, LIB3DS_SEEK_SET);
}
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);
}
}

518
src/osgPlugins/3ds/lib3ds/lib3ds_chunktable.c
View File

@@ -1,259 +1,259 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
typedef struct Lib3dsChunkTable {
uint32_t chunk;
const char* name;
} Lib3dsChunkTable;
static Lib3dsChunkTable lib3ds_chunk_table[] = {
{CHK_NULL_CHUNK, "NULL_CHUNK"},
{CHK_M3DMAGIC, "M3DMAGIC"},
{CHK_SMAGIC, "SMAGIC"},
{CHK_LMAGIC, "LMAGIC"},
{CHK_MLIBMAGIC, "MLIBMAGIC"},
{CHK_MATMAGIC, "MATMAGIC"},
{CHK_CMAGIC, "CMAGIC"},
{CHK_M3D_VERSION, "M3D_VERSION"},
{CHK_M3D_KFVERSION, "M3D_KFVERSION"},
{CHK_COLOR_F, "COLOR_F"},
{CHK_COLOR_24, "COLOR_24"},
{CHK_LIN_COLOR_24, "LIN_COLOR_24"},
{CHK_LIN_COLOR_F, "LIN_COLOR_F"},
{CHK_INT_PERCENTAGE, "INT_PERCENTAGE"},
{CHK_FLOAT_PERCENTAGE, "FLOAT_PERCENTAGE"},
{CHK_MDATA, "MDATA"},
{CHK_MESH_VERSION, "MESH_VERSION"},
{CHK_MASTER_SCALE, "MASTER_SCALE"},
{CHK_LO_SHADOW_BIAS, "LO_SHADOW_BIAS"},
{CHK_HI_SHADOW_BIAS, "HI_SHADOW_BIAS"},
{CHK_SHADOW_MAP_SIZE, "SHADOW_MAP_SIZE"},
{CHK_SHADOW_SAMPLES, "SHADOW_SAMPLES"},
{CHK_SHADOW_RANGE, "SHADOW_RANGE"},
{CHK_SHADOW_FILTER, "SHADOW_FILTER"},
{CHK_RAY_BIAS, "RAY_BIAS"},
{CHK_O_CONSTS, "O_CONSTS"},
{CHK_AMBIENT_LIGHT, "AMBIENT_LIGHT"},
{CHK_BIT_MAP, "BIT_MAP"},
{CHK_SOLID_BGND, "SOLID_BGND"},
{CHK_V_GRADIENT, "V_GRADIENT"},
{CHK_USE_BIT_MAP, "USE_BIT_MAP"},
{CHK_USE_SOLID_BGND, "USE_SOLID_BGND"},
{CHK_USE_V_GRADIENT, "USE_V_GRADIENT"},
{CHK_FOG, "FOG"},
{CHK_FOG_BGND, "FOG_BGND"},
{CHK_LAYER_FOG, "LAYER_FOG"},
{CHK_DISTANCE_CUE, "DISTANCE_CUE"},
{CHK_DCUE_BGND, "DCUE_BGND"},
{CHK_USE_FOG, "USE_FOG"},
{CHK_USE_LAYER_FOG, "USE_LAYER_FOG"},
{CHK_USE_DISTANCE_CUE, "USE_DISTANCE_CUE"},
{CHK_MAT_ENTRY, "MAT_ENTRY"},
{CHK_MAT_NAME, "MAT_NAME"},
{CHK_MAT_AMBIENT, "MAT_AMBIENT"},
{CHK_MAT_DIFFUSE, "MAT_DIFFUSE"},
{CHK_MAT_SPECULAR, "MAT_SPECULAR"},
{CHK_MAT_SHININESS, "MAT_SHININESS"},
{CHK_MAT_SHIN2PCT, "MAT_SHIN2PCT"},
{CHK_MAT_TRANSPARENCY, "MAT_TRANSPARENCY"},
{CHK_MAT_XPFALL, "MAT_XPFALL"},
{CHK_MAT_USE_XPFALL, "MAT_USE_XPFALL"},
{CHK_MAT_REFBLUR, "MAT_REFBLUR"},
{CHK_MAT_SHADING, "MAT_SHADING"},
{CHK_MAT_USE_REFBLUR, "MAT_USE_REFBLUR"},
{CHK_MAT_SELF_ILLUM, "MAT_SELF_ILLUM"},
{CHK_MAT_TWO_SIDE, "MAT_TWO_SIDE"},
{CHK_MAT_DECAL, "MAT_DECAL"},
{CHK_MAT_ADDITIVE, "MAT_ADDITIVE"},
{CHK_MAT_SELF_ILPCT, "MAT_SELF_ILPCT"},
{CHK_MAT_WIRE, "MAT_WIRE"},
{CHK_MAT_FACEMAP, "MAT_FACEMAP"},
{CHK_MAT_PHONGSOFT, "MAT_PHONGSOFT"},
{CHK_MAT_WIREABS, "MAT_WIREABS"},
{CHK_MAT_WIRE_SIZE, "MAT_WIRE_SIZE"},
{CHK_MAT_TEXMAP, "MAT_TEXMAP"},
{CHK_MAT_SXP_TEXT_DATA, "MAT_SXP_TEXT_DATA"},
{CHK_MAT_TEXMASK, "MAT_TEXMASK"},
{CHK_MAT_SXP_TEXTMASK_DATA, "MAT_SXP_TEXTMASK_DATA"},
{CHK_MAT_TEX2MAP, "MAT_TEX2MAP"},
{CHK_MAT_SXP_TEXT2_DATA, "MAT_SXP_TEXT2_DATA"},
{CHK_MAT_TEX2MASK, "MAT_TEX2MASK"},
{CHK_MAT_SXP_TEXT2MASK_DATA, "MAT_SXP_TEXT2MASK_DATA"},
{CHK_MAT_OPACMAP, "MAT_OPACMAP"},
{CHK_MAT_SXP_OPAC_DATA, "MAT_SXP_OPAC_DATA"},
{CHK_MAT_OPACMASK, "MAT_OPACMASK"},
{CHK_MAT_SXP_OPACMASK_DATA, "MAT_SXP_OPACMASK_DATA"},
{CHK_MAT_BUMPMAP, "MAT_BUMPMAP"},
{CHK_MAT_SXP_BUMP_DATA, "MAT_SXP_BUMP_DATA"},
{CHK_MAT_BUMPMASK, "MAT_BUMPMASK"},
{CHK_MAT_SXP_BUMPMASK_DATA, "MAT_SXP_BUMPMASK_DATA"},
{CHK_MAT_SPECMAP, "MAT_SPECMAP"},
{CHK_MAT_SXP_SPEC_DATA, "MAT_SXP_SPEC_DATA"},
{CHK_MAT_SPECMASK, "MAT_SPECMASK"},
{CHK_MAT_SXP_SPECMASK_DATA, "MAT_SXP_SPECMASK_DATA"},
{CHK_MAT_SHINMAP, "MAT_SHINMAP"},
{CHK_MAT_SXP_SHIN_DATA, "MAT_SXP_SHIN_DATA"},
{CHK_MAT_SHINMASK, "MAT_SHINMASK"},
{CHK_MAT_SXP_SHINMASK_DATA, "MAT_SXP_SHINMASK_DATA"},
{CHK_MAT_SELFIMAP, "MAT_SELFIMAP"},
{CHK_MAT_SXP_SELFI_DATA, "MAT_SXP_SELFI_DATA"},
{CHK_MAT_SELFIMASK, "MAT_SELFIMASK"},
{CHK_MAT_SXP_SELFIMASK_DATA, "MAT_SXP_SELFIMASK_DATA"},
{CHK_MAT_REFLMAP, "MAT_REFLMAP"},
{CHK_MAT_REFLMASK, "MAT_REFLMASK"},
{CHK_MAT_SXP_REFLMASK_DATA, "MAT_SXP_REFLMASK_DATA"},
{CHK_MAT_ACUBIC, "MAT_ACUBIC"},
{CHK_MAT_MAPNAME, "MAT_MAPNAME"},
{CHK_MAT_MAP_TILING, "MAT_MAP_TILING"},
{CHK_MAT_MAP_TEXBLUR, "MAT_MAP_TEXBLUR"},
{CHK_MAT_MAP_USCALE, "MAT_MAP_USCALE"},
{CHK_MAT_MAP_VSCALE, "MAT_MAP_VSCALE"},
{CHK_MAT_MAP_UOFFSET, "MAT_MAP_UOFFSET"},
{CHK_MAT_MAP_VOFFSET, "MAT_MAP_VOFFSET"},
{CHK_MAT_MAP_ANG, "MAT_MAP_ANG"},
{CHK_MAT_MAP_COL1, "MAT_MAP_COL1"},
{CHK_MAT_MAP_COL2, "MAT_MAP_COL2"},
{CHK_MAT_MAP_RCOL, "MAT_MAP_RCOL"},
{CHK_MAT_MAP_GCOL, "MAT_MAP_GCOL"},
{CHK_MAT_MAP_BCOL, "MAT_MAP_BCOL"},
{CHK_NAMED_OBJECT, "NAMED_OBJECT"},
{CHK_N_DIRECT_LIGHT, "N_DIRECT_LIGHT"},
{CHK_DL_OFF, "DL_OFF"},
{CHK_DL_OUTER_RANGE, "DL_OUTER_RANGE"},
{CHK_DL_INNER_RANGE, "DL_INNER_RANGE"},
{CHK_DL_MULTIPLIER, "DL_MULTIPLIER"},
{CHK_DL_EXCLUDE, "DL_EXCLUDE"},
{CHK_DL_ATTENUATE, "DL_ATTENUATE"},
{CHK_DL_SPOTLIGHT, "DL_SPOTLIGHT"},
{CHK_DL_SPOT_ROLL, "DL_SPOT_ROLL"},
{CHK_DL_SHADOWED, "DL_SHADOWED"},
{CHK_DL_LOCAL_SHADOW2, "DL_LOCAL_SHADOW2"},
{CHK_DL_SEE_CONE, "DL_SEE_CONE"},
{CHK_DL_SPOT_RECTANGULAR, "DL_SPOT_RECTANGULAR"},
{CHK_DL_SPOT_ASPECT, "DL_SPOT_ASPECT"},
{CHK_DL_SPOT_PROJECTOR, "DL_SPOT_PROJECTOR"},
{CHK_DL_SPOT_OVERSHOOT, "DL_SPOT_OVERSHOOT"},
{CHK_DL_RAY_BIAS, "DL_RAY_BIAS"},
{CHK_DL_RAYSHAD, "DL_RAYSHAD"},
{CHK_N_CAMERA, "N_CAMERA"},
{CHK_CAM_SEE_CONE, "CAM_SEE_CONE"},
{CHK_CAM_RANGES, "CAM_RANGES"},
{CHK_OBJ_HIDDEN, "OBJ_HIDDEN"},
{CHK_OBJ_VIS_LOFTER, "OBJ_VIS_LOFTER"},
{CHK_OBJ_DOESNT_CAST, "OBJ_DOESNT_CAST"},
{CHK_OBJ_DONT_RCVSHADOW, "OBJ_DONT_RCVSHADOW"},
{CHK_OBJ_MATTE, "OBJ_MATTE"},
{CHK_OBJ_FAST, "OBJ_FAST"},
{CHK_OBJ_PROCEDURAL, "OBJ_PROCEDURAL"},
{CHK_OBJ_FROZEN, "OBJ_FROZEN"},
{CHK_N_TRI_OBJECT, "N_TRI_OBJECT"},
{CHK_POINT_ARRAY, "POINT_ARRAY"},
{CHK_POINT_FLAG_ARRAY, "POINT_FLAG_ARRAY"},
{CHK_FACE_ARRAY, "FACE_ARRAY"},
{CHK_MSH_MAT_GROUP, "MSH_MAT_GROUP"},
{CHK_SMOOTH_GROUP, "SMOOTH_GROUP"},
{CHK_MSH_BOXMAP, "MSH_BOXMAP"},
{CHK_TEX_VERTS, "TEX_VERTS"},
{CHK_MESH_MATRIX, "MESH_MATRIX"},
{CHK_MESH_COLOR, "MESH_COLOR"},
{CHK_MESH_TEXTURE_INFO, "MESH_TEXTURE_INFO"},
{CHK_KFDATA, "KFDATA"},
{CHK_KFHDR, "KFHDR"},
{CHK_KFSEG, "KFSEG"},
{CHK_KFCURTIME, "KFCURTIME"},
{CHK_AMBIENT_NODE_TAG, "AMBIENT_NODE_TAG"},
{CHK_OBJECT_NODE_TAG, "OBJECT_NODE_TAG"},
{CHK_CAMERA_NODE_TAG, "CAMERA_NODE_TAG"},
{CHK_TARGET_NODE_TAG, "TARGET_NODE_TAG"},
{CHK_LIGHT_NODE_TAG, "LIGHT_NODE_TAG"},
{CHK_L_TARGET_NODE_TAG, "L_TARGET_NODE_TAG"},
{CHK_SPOTLIGHT_NODE_TAG, "SPOTLIGHT_NODE_TAG"},
{CHK_NODE_ID, "NODE_ID"},
{CHK_NODE_HDR, "NODE_HDR"},
{CHK_PIVOT, "PIVOT"},
{CHK_INSTANCE_NAME, "INSTANCE_NAME"},
{CHK_MORPH_SMOOTH, "MORPH_SMOOTH"},
{CHK_BOUNDBOX, "BOUNDBOX"},
{CHK_POS_TRACK_TAG, "POS_TRACK_TAG"},
{CHK_COL_TRACK_TAG, "COL_TRACK_TAG"},
{CHK_ROT_TRACK_TAG, "ROT_TRACK_TAG"},
{CHK_SCL_TRACK_TAG, "SCL_TRACK_TAG"},
{CHK_MORPH_TRACK_TAG, "MORPH_TRACK_TAG"},
{CHK_FOV_TRACK_TAG, "FOV_TRACK_TAG"},
{CHK_ROLL_TRACK_TAG, "ROLL_TRACK_TAG"},
{CHK_HOT_TRACK_TAG, "HOT_TRACK_TAG"},
{CHK_FALL_TRACK_TAG, "FALL_TRACK_TAG"},
{CHK_HIDE_TRACK_TAG, "HIDE_TRACK_TAG"},
{CHK_POLY_2D, "POLY_2D"},
{CHK_SHAPE_OK, "SHAPE_OK"},
{CHK_SHAPE_NOT_OK, "SHAPE_NOT_OK"},
{CHK_SHAPE_HOOK, "SHAPE_HOOK"},
{CHK_PATH_3D, "PATH_3D"},
{CHK_PATH_MATRIX, "PATH_MATRIX"},
{CHK_SHAPE_2D, "SHAPE_2D"},
{CHK_M_SCALE, "M_SCALE"},
{CHK_M_TWIST, "M_TWIST"},
{CHK_M_TEETER, "M_TEETER"},
{CHK_M_FIT, "M_FIT"},
{CHK_M_BEVEL, "M_BEVEL"},
{CHK_XZ_CURVE, "XZ_CURVE"},
{CHK_YZ_CURVE, "YZ_CURVE"},
{CHK_INTERPCT, "INTERPCT"},
{CHK_DEFORM_LIMIT, "DEFORM_LIMIT"},
{CHK_USE_CONTOUR, "USE_CONTOUR"},
{CHK_USE_TWEEN, "USE_TWEEN"},
{CHK_USE_SCALE, "USE_SCALE"},
{CHK_USE_TWIST, "USE_TWIST"},
{CHK_USE_TEETER, "USE_TEETER"},
{CHK_USE_FIT, "USE_FIT"},
{CHK_USE_BEVEL, "USE_BEVEL"},
{CHK_DEFAULT_VIEW, "DEFAULT_VIEW"},
{CHK_VIEW_TOP, "VIEW_TOP"},
{CHK_VIEW_BOTTOM, "VIEW_BOTTOM"},
{CHK_VIEW_LEFT, "VIEW_LEFT"},
{CHK_VIEW_RIGHT, "VIEW_RIGHT"},
{CHK_VIEW_FRONT, "VIEW_FRONT"},
{CHK_VIEW_BACK, "VIEW_BACK"},
{CHK_VIEW_USER, "VIEW_USER"},
{CHK_VIEW_CAMERA, "VIEW_CAMERA"},
{CHK_VIEW_WINDOW, "VIEW_WINDOW"},
{CHK_VIEWPORT_LAYOUT_OLD, "VIEWPORT_LAYOUT_OLD"},
{CHK_VIEWPORT_DATA_OLD, "VIEWPORT_DATA_OLD"},
{CHK_VIEWPORT_LAYOUT, "VIEWPORT_LAYOUT"},
{CHK_VIEWPORT_DATA, "VIEWPORT_DATA"},
{CHK_VIEWPORT_DATA_3, "VIEWPORT_DATA_3"},
{CHK_VIEWPORT_SIZE, "VIEWPORT_SIZE"},
{CHK_NETWORK_VIEW, "NETWORK_VIEW"},
{0, 0}
};
const char*
lib3ds_chunk_name(uint16_t chunk) {
Lib3dsChunkTable *p;
for (p = lib3ds_chunk_table; p->name != 0; ++p) {
if (p->chunk == chunk) {
return(p->name);
}
}
return("***UNKNOWN***");
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
typedef struct Lib3dsChunkTable {
uint32_t chunk;
const char* name;
} Lib3dsChunkTable;
static Lib3dsChunkTable lib3ds_chunk_table[] = {
{CHK_NULL_CHUNK, "NULL_CHUNK"},
{CHK_M3DMAGIC, "M3DMAGIC"},
{CHK_SMAGIC, "SMAGIC"},
{CHK_LMAGIC, "LMAGIC"},
{CHK_MLIBMAGIC, "MLIBMAGIC"},
{CHK_MATMAGIC, "MATMAGIC"},
{CHK_CMAGIC, "CMAGIC"},
{CHK_M3D_VERSION, "M3D_VERSION"},
{CHK_M3D_KFVERSION, "M3D_KFVERSION"},
{CHK_COLOR_F, "COLOR_F"},
{CHK_COLOR_24, "COLOR_24"},
{CHK_LIN_COLOR_24, "LIN_COLOR_24"},
{CHK_LIN_COLOR_F, "LIN_COLOR_F"},
{CHK_INT_PERCENTAGE, "INT_PERCENTAGE"},
{CHK_FLOAT_PERCENTAGE, "FLOAT_PERCENTAGE"},
{CHK_MDATA, "MDATA"},
{CHK_MESH_VERSION, "MESH_VERSION"},
{CHK_MASTER_SCALE, "MASTER_SCALE"},
{CHK_LO_SHADOW_BIAS, "LO_SHADOW_BIAS"},
{CHK_HI_SHADOW_BIAS, "HI_SHADOW_BIAS"},
{CHK_SHADOW_MAP_SIZE, "SHADOW_MAP_SIZE"},
{CHK_SHADOW_SAMPLES, "SHADOW_SAMPLES"},
{CHK_SHADOW_RANGE, "SHADOW_RANGE"},
{CHK_SHADOW_FILTER, "SHADOW_FILTER"},
{CHK_RAY_BIAS, "RAY_BIAS"},
{CHK_O_CONSTS, "O_CONSTS"},
{CHK_AMBIENT_LIGHT, "AMBIENT_LIGHT"},
{CHK_BIT_MAP, "BIT_MAP"},
{CHK_SOLID_BGND, "SOLID_BGND"},
{CHK_V_GRADIENT, "V_GRADIENT"},
{CHK_USE_BIT_MAP, "USE_BIT_MAP"},
{CHK_USE_SOLID_BGND, "USE_SOLID_BGND"},
{CHK_USE_V_GRADIENT, "USE_V_GRADIENT"},
{CHK_FOG, "FOG"},
{CHK_FOG_BGND, "FOG_BGND"},
{CHK_LAYER_FOG, "LAYER_FOG"},
{CHK_DISTANCE_CUE, "DISTANCE_CUE"},
{CHK_DCUE_BGND, "DCUE_BGND"},
{CHK_USE_FOG, "USE_FOG"},
{CHK_USE_LAYER_FOG, "USE_LAYER_FOG"},
{CHK_USE_DISTANCE_CUE, "USE_DISTANCE_CUE"},
{CHK_MAT_ENTRY, "MAT_ENTRY"},
{CHK_MAT_NAME, "MAT_NAME"},
{CHK_MAT_AMBIENT, "MAT_AMBIENT"},
{CHK_MAT_DIFFUSE, "MAT_DIFFUSE"},
{CHK_MAT_SPECULAR, "MAT_SPECULAR"},
{CHK_MAT_SHININESS, "MAT_SHININESS"},
{CHK_MAT_SHIN2PCT, "MAT_SHIN2PCT"},
{CHK_MAT_TRANSPARENCY, "MAT_TRANSPARENCY"},
{CHK_MAT_XPFALL, "MAT_XPFALL"},
{CHK_MAT_USE_XPFALL, "MAT_USE_XPFALL"},
{CHK_MAT_REFBLUR, "MAT_REFBLUR"},
{CHK_MAT_SHADING, "MAT_SHADING"},
{CHK_MAT_USE_REFBLUR, "MAT_USE_REFBLUR"},
{CHK_MAT_SELF_ILLUM, "MAT_SELF_ILLUM"},
{CHK_MAT_TWO_SIDE, "MAT_TWO_SIDE"},
{CHK_MAT_DECAL, "MAT_DECAL"},
{CHK_MAT_ADDITIVE, "MAT_ADDITIVE"},
{CHK_MAT_SELF_ILPCT, "MAT_SELF_ILPCT"},
{CHK_MAT_WIRE, "MAT_WIRE"},
{CHK_MAT_FACEMAP, "MAT_FACEMAP"},
{CHK_MAT_PHONGSOFT, "MAT_PHONGSOFT"},
{CHK_MAT_WIREABS, "MAT_WIREABS"},
{CHK_MAT_WIRE_SIZE, "MAT_WIRE_SIZE"},
{CHK_MAT_TEXMAP, "MAT_TEXMAP"},
{CHK_MAT_SXP_TEXT_DATA, "MAT_SXP_TEXT_DATA"},
{CHK_MAT_TEXMASK, "MAT_TEXMASK"},
{CHK_MAT_SXP_TEXTMASK_DATA, "MAT_SXP_TEXTMASK_DATA"},
{CHK_MAT_TEX2MAP, "MAT_TEX2MAP"},
{CHK_MAT_SXP_TEXT2_DATA, "MAT_SXP_TEXT2_DATA"},
{CHK_MAT_TEX2MASK, "MAT_TEX2MASK"},
{CHK_MAT_SXP_TEXT2MASK_DATA, "MAT_SXP_TEXT2MASK_DATA"},
{CHK_MAT_OPACMAP, "MAT_OPACMAP"},
{CHK_MAT_SXP_OPAC_DATA, "MAT_SXP_OPAC_DATA"},
{CHK_MAT_OPACMASK, "MAT_OPACMASK"},
{CHK_MAT_SXP_OPACMASK_DATA, "MAT_SXP_OPACMASK_DATA"},
{CHK_MAT_BUMPMAP, "MAT_BUMPMAP"},
{CHK_MAT_SXP_BUMP_DATA, "MAT_SXP_BUMP_DATA"},
{CHK_MAT_BUMPMASK, "MAT_BUMPMASK"},
{CHK_MAT_SXP_BUMPMASK_DATA, "MAT_SXP_BUMPMASK_DATA"},
{CHK_MAT_SPECMAP, "MAT_SPECMAP"},
{CHK_MAT_SXP_SPEC_DATA, "MAT_SXP_SPEC_DATA"},
{CHK_MAT_SPECMASK, "MAT_SPECMASK"},
{CHK_MAT_SXP_SPECMASK_DATA, "MAT_SXP_SPECMASK_DATA"},
{CHK_MAT_SHINMAP, "MAT_SHINMAP"},
{CHK_MAT_SXP_SHIN_DATA, "MAT_SXP_SHIN_DATA"},
{CHK_MAT_SHINMASK, "MAT_SHINMASK"},
{CHK_MAT_SXP_SHINMASK_DATA, "MAT_SXP_SHINMASK_DATA"},
{CHK_MAT_SELFIMAP, "MAT_SELFIMAP"},
{CHK_MAT_SXP_SELFI_DATA, "MAT_SXP_SELFI_DATA"},
{CHK_MAT_SELFIMASK, "MAT_SELFIMASK"},
{CHK_MAT_SXP_SELFIMASK_DATA, "MAT_SXP_SELFIMASK_DATA"},
{CHK_MAT_REFLMAP, "MAT_REFLMAP"},
{CHK_MAT_REFLMASK, "MAT_REFLMASK"},
{CHK_MAT_SXP_REFLMASK_DATA, "MAT_SXP_REFLMASK_DATA"},
{CHK_MAT_ACUBIC, "MAT_ACUBIC"},
{CHK_MAT_MAPNAME, "MAT_MAPNAME"},
{CHK_MAT_MAP_TILING, "MAT_MAP_TILING"},
{CHK_MAT_MAP_TEXBLUR, "MAT_MAP_TEXBLUR"},
{CHK_MAT_MAP_USCALE, "MAT_MAP_USCALE"},
{CHK_MAT_MAP_VSCALE, "MAT_MAP_VSCALE"},
{CHK_MAT_MAP_UOFFSET, "MAT_MAP_UOFFSET"},
{CHK_MAT_MAP_VOFFSET, "MAT_MAP_VOFFSET"},
{CHK_MAT_MAP_ANG, "MAT_MAP_ANG"},
{CHK_MAT_MAP_COL1, "MAT_MAP_COL1"},
{CHK_MAT_MAP_COL2, "MAT_MAP_COL2"},
{CHK_MAT_MAP_RCOL, "MAT_MAP_RCOL"},
{CHK_MAT_MAP_GCOL, "MAT_MAP_GCOL"},
{CHK_MAT_MAP_BCOL, "MAT_MAP_BCOL"},
{CHK_NAMED_OBJECT, "NAMED_OBJECT"},
{CHK_N_DIRECT_LIGHT, "N_DIRECT_LIGHT"},
{CHK_DL_OFF, "DL_OFF"},
{CHK_DL_OUTER_RANGE, "DL_OUTER_RANGE"},
{CHK_DL_INNER_RANGE, "DL_INNER_RANGE"},
{CHK_DL_MULTIPLIER, "DL_MULTIPLIER"},
{CHK_DL_EXCLUDE, "DL_EXCLUDE"},
{CHK_DL_ATTENUATE, "DL_ATTENUATE"},
{CHK_DL_SPOTLIGHT, "DL_SPOTLIGHT"},
{CHK_DL_SPOT_ROLL, "DL_SPOT_ROLL"},
{CHK_DL_SHADOWED, "DL_SHADOWED"},
{CHK_DL_LOCAL_SHADOW2, "DL_LOCAL_SHADOW2"},
{CHK_DL_SEE_CONE, "DL_SEE_CONE"},
{CHK_DL_SPOT_RECTANGULAR, "DL_SPOT_RECTANGULAR"},
{CHK_DL_SPOT_ASPECT, "DL_SPOT_ASPECT"},
{CHK_DL_SPOT_PROJECTOR, "DL_SPOT_PROJECTOR"},
{CHK_DL_SPOT_OVERSHOOT, "DL_SPOT_OVERSHOOT"},
{CHK_DL_RAY_BIAS, "DL_RAY_BIAS"},
{CHK_DL_RAYSHAD, "DL_RAYSHAD"},
{CHK_N_CAMERA, "N_CAMERA"},
{CHK_CAM_SEE_CONE, "CAM_SEE_CONE"},
{CHK_CAM_RANGES, "CAM_RANGES"},
{CHK_OBJ_HIDDEN, "OBJ_HIDDEN"},
{CHK_OBJ_VIS_LOFTER, "OBJ_VIS_LOFTER"},
{CHK_OBJ_DOESNT_CAST, "OBJ_DOESNT_CAST"},
{CHK_OBJ_DONT_RCVSHADOW, "OBJ_DONT_RCVSHADOW"},
{CHK_OBJ_MATTE, "OBJ_MATTE"},
{CHK_OBJ_FAST, "OBJ_FAST"},
{CHK_OBJ_PROCEDURAL, "OBJ_PROCEDURAL"},
{CHK_OBJ_FROZEN, "OBJ_FROZEN"},
{CHK_N_TRI_OBJECT, "N_TRI_OBJECT"},
{CHK_POINT_ARRAY, "POINT_ARRAY"},
{CHK_POINT_FLAG_ARRAY, "POINT_FLAG_ARRAY"},
{CHK_FACE_ARRAY, "FACE_ARRAY"},
{CHK_MSH_MAT_GROUP, "MSH_MAT_GROUP"},
{CHK_SMOOTH_GROUP, "SMOOTH_GROUP"},
{CHK_MSH_BOXMAP, "MSH_BOXMAP"},
{CHK_TEX_VERTS, "TEX_VERTS"},
{CHK_MESH_MATRIX, "MESH_MATRIX"},
{CHK_MESH_COLOR, "MESH_COLOR"},
{CHK_MESH_TEXTURE_INFO, "MESH_TEXTURE_INFO"},
{CHK_KFDATA, "KFDATA"},
{CHK_KFHDR, "KFHDR"},
{CHK_KFSEG, "KFSEG"},
{CHK_KFCURTIME, "KFCURTIME"},
{CHK_AMBIENT_NODE_TAG, "AMBIENT_NODE_TAG"},
{CHK_OBJECT_NODE_TAG, "OBJECT_NODE_TAG"},
{CHK_CAMERA_NODE_TAG, "CAMERA_NODE_TAG"},
{CHK_TARGET_NODE_TAG, "TARGET_NODE_TAG"},
{CHK_LIGHT_NODE_TAG, "LIGHT_NODE_TAG"},
{CHK_L_TARGET_NODE_TAG, "L_TARGET_NODE_TAG"},
{CHK_SPOTLIGHT_NODE_TAG, "SPOTLIGHT_NODE_TAG"},
{CHK_NODE_ID, "NODE_ID"},
{CHK_NODE_HDR, "NODE_HDR"},
{CHK_PIVOT, "PIVOT"},
{CHK_INSTANCE_NAME, "INSTANCE_NAME"},
{CHK_MORPH_SMOOTH, "MORPH_SMOOTH"},
{CHK_BOUNDBOX, "BOUNDBOX"},
{CHK_POS_TRACK_TAG, "POS_TRACK_TAG"},
{CHK_COL_TRACK_TAG, "COL_TRACK_TAG"},
{CHK_ROT_TRACK_TAG, "ROT_TRACK_TAG"},
{CHK_SCL_TRACK_TAG, "SCL_TRACK_TAG"},
{CHK_MORPH_TRACK_TAG, "MORPH_TRACK_TAG"},
{CHK_FOV_TRACK_TAG, "FOV_TRACK_TAG"},
{CHK_ROLL_TRACK_TAG, "ROLL_TRACK_TAG"},
{CHK_HOT_TRACK_TAG, "HOT_TRACK_TAG"},
{CHK_FALL_TRACK_TAG, "FALL_TRACK_TAG"},
{CHK_HIDE_TRACK_TAG, "HIDE_TRACK_TAG"},
{CHK_POLY_2D, "POLY_2D"},
{CHK_SHAPE_OK, "SHAPE_OK"},
{CHK_SHAPE_NOT_OK, "SHAPE_NOT_OK"},
{CHK_SHAPE_HOOK, "SHAPE_HOOK"},
{CHK_PATH_3D, "PATH_3D"},
{CHK_PATH_MATRIX, "PATH_MATRIX"},
{CHK_SHAPE_2D, "SHAPE_2D"},
{CHK_M_SCALE, "M_SCALE"},
{CHK_M_TWIST, "M_TWIST"},
{CHK_M_TEETER, "M_TEETER"},
{CHK_M_FIT, "M_FIT"},
{CHK_M_BEVEL, "M_BEVEL"},
{CHK_XZ_CURVE, "XZ_CURVE"},
{CHK_YZ_CURVE, "YZ_CURVE"},
{CHK_INTERPCT, "INTERPCT"},
{CHK_DEFORM_LIMIT, "DEFORM_LIMIT"},
{CHK_USE_CONTOUR, "USE_CONTOUR"},
{CHK_USE_TWEEN, "USE_TWEEN"},
{CHK_USE_SCALE, "USE_SCALE"},
{CHK_USE_TWIST, "USE_TWIST"},
{CHK_USE_TEETER, "USE_TEETER"},
{CHK_USE_FIT, "USE_FIT"},
{CHK_USE_BEVEL, "USE_BEVEL"},
{CHK_DEFAULT_VIEW, "DEFAULT_VIEW"},
{CHK_VIEW_TOP, "VIEW_TOP"},
{CHK_VIEW_BOTTOM, "VIEW_BOTTOM"},
{CHK_VIEW_LEFT, "VIEW_LEFT"},
{CHK_VIEW_RIGHT, "VIEW_RIGHT"},
{CHK_VIEW_FRONT, "VIEW_FRONT"},
{CHK_VIEW_BACK, "VIEW_BACK"},
{CHK_VIEW_USER, "VIEW_USER"},
{CHK_VIEW_CAMERA, "VIEW_CAMERA"},
{CHK_VIEW_WINDOW, "VIEW_WINDOW"},
{CHK_VIEWPORT_LAYOUT_OLD, "VIEWPORT_LAYOUT_OLD"},
{CHK_VIEWPORT_DATA_OLD, "VIEWPORT_DATA_OLD"},
{CHK_VIEWPORT_LAYOUT, "VIEWPORT_LAYOUT"},
{CHK_VIEWPORT_DATA, "VIEWPORT_DATA"},
{CHK_VIEWPORT_DATA_3, "VIEWPORT_DATA_3"},
{CHK_VIEWPORT_SIZE, "VIEWPORT_SIZE"},
{CHK_NETWORK_VIEW, "NETWORK_VIEW"},
{0, 0}
};
const char*
lib3ds_chunk_name(uint16_t chunk) {
Lib3dsChunkTable *p;
for (p = lib3ds_chunk_table; p->name != 0; ++p) {
if (p->chunk == chunk) {
return(p->name);
}
}
return("***UNKNOWN***");
}

2852
src/osgPlugins/3ds/lib3ds/lib3ds_file.c
View File

File diff suppressed because it is too large Load Diff

1042
src/osgPlugins/3ds/lib3ds/lib3ds_io.c
View File

File diff suppressed because it is too large Load Diff

646
src/osgPlugins/3ds/lib3ds/lib3ds_light.c
View File

@@ -1,323 +1,323 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
Lib3dsLight*
lib3ds_light_new(const char *name) {
Lib3dsLight *light;
assert(name);
assert(strlen(name) < 64);
light = (Lib3dsLight*)calloc(sizeof(Lib3dsLight), 1);
if (!light) {
return(0);
}
strcpy(light->name, name);
return(light);
}
void
lib3ds_light_free(Lib3dsLight *light) {
memset(light, 0, sizeof(Lib3dsLight));
free(light);
}
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);
}
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);
}
void
lib3ds_light_write(Lib3dsLight *light, Lib3dsIo *io) {
Lib3dsChunk c;
c.chunk = CHK_N_DIRECT_LIGHT;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_vector(io, light->position);
{ /*---- LIB3DS_COLOR_F ----*/
Lib3dsChunk c;
c.chunk = CHK_COLOR_F;
c.size = 18;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_rgb(io, light->color);
}
if (light->off) { /*---- LIB3DS_DL_OFF ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_OFF;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
{ /*---- LIB3DS_DL_OUTER_RANGE ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_OUTER_RANGE;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->outer_range);
}
{ /*---- LIB3DS_DL_INNER_RANGE ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_INNER_RANGE;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->inner_range);
}
{ /*---- LIB3DS_DL_MULTIPLIER ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_MULTIPLIER;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->multiplier);
}
if (light->attenuation) { /*---- LIB3DS_DL_ATTENUATE ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_ATTENUATE;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (light->spot_light) {
Lib3dsChunk c;
c.chunk = CHK_DL_SPOTLIGHT;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_vector(io, light->target);
lib3ds_io_write_float(io, light->hotspot);
lib3ds_io_write_float(io, light->falloff);
{ /*---- LIB3DS_DL_SPOT_ROLL ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_ROLL;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->roll);
}
if (light->shadowed) { /*---- LIB3DS_DL_SHADOWED ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SHADOWED;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if ((fabs(light->shadow_bias) > LIB3DS_EPSILON) ||
(fabs(light->shadow_filter) > LIB3DS_EPSILON) ||
(light->shadow_size != 0)) { /*---- LIB3DS_DL_LOCAL_SHADOW2 ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_LOCAL_SHADOW2;
c.size = 16;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->shadow_bias);
lib3ds_io_write_float(io, light->shadow_filter);
lib3ds_io_write_intw(io, (int16_t)light->shadow_size);
}
if (light->see_cone) { /*---- LIB3DS_DL_SEE_CONE ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SEE_CONE;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (light->rectangular_spot) { /*---- LIB3DS_DL_SPOT_RECTANGULAR ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_RECTANGULAR;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (fabs(light->spot_aspect) > LIB3DS_EPSILON) { /*---- LIB3DS_DL_SPOT_ASPECT ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_ASPECT;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->spot_aspect);
}
if (light->use_projector) { /*---- LIB3DS_DL_SPOT_PROJECTOR ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_PROJECTOR;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_string(io, light->projector);
}
if (light->spot_overshoot) { /*---- LIB3DS_DL_SPOT_OVERSHOOT ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_OVERSHOOT;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (fabs(light->ray_bias) > LIB3DS_EPSILON) { /*---- LIB3DS_DL_RAY_BIAS ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_RAY_BIAS;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->ray_bias);
}
if (light->ray_shadows) { /*---- LIB3DS_DL_RAYSHAD ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_RAYSHAD;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
lib3ds_chunk_write_end(&c, io);
}
lib3ds_chunk_write_end(&c, io);
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
Lib3dsLight*
lib3ds_light_new(const char *name) {
Lib3dsLight *light;
assert(name);
assert(strlen(name) < 64);
light = (Lib3dsLight*)calloc(sizeof(Lib3dsLight), 1);
if (!light) {
return(0);
}
strcpy(light->name, name);
return(light);
}
void
lib3ds_light_free(Lib3dsLight *light) {
memset(light, 0, sizeof(Lib3dsLight));
free(light);
}
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);
}
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);
}
void
lib3ds_light_write(Lib3dsLight *light, Lib3dsIo *io) {
Lib3dsChunk c;
c.chunk = CHK_N_DIRECT_LIGHT;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_vector(io, light->position);
{ /*---- LIB3DS_COLOR_F ----*/
Lib3dsChunk c;
c.chunk = CHK_COLOR_F;
c.size = 18;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_rgb(io, light->color);
}
if (light->off) { /*---- LIB3DS_DL_OFF ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_OFF;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
{ /*---- LIB3DS_DL_OUTER_RANGE ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_OUTER_RANGE;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->outer_range);
}
{ /*---- LIB3DS_DL_INNER_RANGE ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_INNER_RANGE;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->inner_range);
}
{ /*---- LIB3DS_DL_MULTIPLIER ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_MULTIPLIER;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->multiplier);
}
if (light->attenuation) { /*---- LIB3DS_DL_ATTENUATE ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_ATTENUATE;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (light->spot_light) {
Lib3dsChunk c;
c.chunk = CHK_DL_SPOTLIGHT;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_vector(io, light->target);
lib3ds_io_write_float(io, light->hotspot);
lib3ds_io_write_float(io, light->falloff);
{ /*---- LIB3DS_DL_SPOT_ROLL ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_ROLL;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->roll);
}
if (light->shadowed) { /*---- LIB3DS_DL_SHADOWED ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SHADOWED;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if ((fabs(light->shadow_bias) > LIB3DS_EPSILON) ||
(fabs(light->shadow_filter) > LIB3DS_EPSILON) ||
(light->shadow_size != 0)) { /*---- LIB3DS_DL_LOCAL_SHADOW2 ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_LOCAL_SHADOW2;
c.size = 16;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->shadow_bias);
lib3ds_io_write_float(io, light->shadow_filter);
lib3ds_io_write_intw(io, (int16_t)light->shadow_size);
}
if (light->see_cone) { /*---- LIB3DS_DL_SEE_CONE ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SEE_CONE;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (light->rectangular_spot) { /*---- LIB3DS_DL_SPOT_RECTANGULAR ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_RECTANGULAR;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (fabs(light->spot_aspect) > LIB3DS_EPSILON) { /*---- LIB3DS_DL_SPOT_ASPECT ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_ASPECT;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->spot_aspect);
}
if (light->use_projector) { /*---- LIB3DS_DL_SPOT_PROJECTOR ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_PROJECTOR;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_string(io, light->projector);
}
if (light->spot_overshoot) { /*---- LIB3DS_DL_SPOT_OVERSHOOT ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_SPOT_OVERSHOOT;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
if (fabs(light->ray_bias) > LIB3DS_EPSILON) { /*---- LIB3DS_DL_RAY_BIAS ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_RAY_BIAS;
c.size = 10;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_float(io, light->ray_bias);
}
if (light->ray_shadows) { /*---- LIB3DS_DL_RAYSHAD ----*/
Lib3dsChunk c;
c.chunk = CHK_DL_RAYSHAD;
c.size = 6;
lib3ds_chunk_write(&c, io);
}
lib3ds_chunk_write_end(&c, io);
}
lib3ds_chunk_write_end(&c, io);
}

1722
src/osgPlugins/3ds/lib3ds/lib3ds_material.c
View File

File diff suppressed because it is too large Load Diff

124
src/osgPlugins/3ds/lib3ds/lib3ds_math.c
View File

@@ -1,62 +1,62 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
float
lib3ds_math_ease(float fp, float fc, float fn, float ease_from, float ease_to) {
double s, step;
double tofrom;
double a;
s = step = (float)(fc - fp) / (fn - fp);
tofrom = ease_to + ease_from;
if (tofrom != 0.0) {
if (tofrom > 1.0) {
ease_to = (float)(ease_to / tofrom);
ease_from = (float)(ease_from / tofrom);
}
a = 1.0 / (2.0 - (ease_to + ease_from));
if (step < ease_from) s = a / ease_from * step * step;
else {
if ((1.0 - ease_to) <= step) {
step = 1.0 - step;
s = 1.0 - a / ease_to * step * step;
} else {
s = ((2.0 * step) - ease_from) * a;
}
}
}
return((float)s);
}
void
lib3ds_math_cubic_interp(float *v, float *a, float *p, float *q, float *b, int n, float t) {
float x, y, z, w;
int i;
x = 2 * t * t * t - 3 * t * t + 1;
y = -2 * t * t * t + 3 * t * t;
z = t * t * t - 2 * t * t + t;
w = t * t * t - t * t;
for (i = 0; i < n; ++i) {
v[i] = x * a[i] + y * b[i] + z * p[i] + w * q[i];
}
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
float
lib3ds_math_ease(float fp, float fc, float fn, float ease_from, float ease_to) {
double s, step;
double tofrom;
double a;
s = step = (float)(fc - fp) / (fn - fp);
tofrom = ease_to + ease_from;
if (tofrom != 0.0) {
if (tofrom > 1.0) {
ease_to = (float)(ease_to / tofrom);
ease_from = (float)(ease_from / tofrom);
}
a = 1.0 / (2.0 - (ease_to + ease_from));
if (step < ease_from) s = a / ease_from * step * step;
else {
if ((1.0 - ease_to) <= step) {
step = 1.0 - step;
s = 1.0 - a / ease_to * step * step;
} else {
s = ((2.0 * step) - ease_from) * a;
}
}
}
return((float)s);
}
void
lib3ds_math_cubic_interp(float *v, float *a, float *p, float *q, float *b, int n, float t) {
float x, y, z, w;
int i;
x = 2 * t * t * t - 3 * t * t + 1;
y = -2 * t * t * t + 3 * t * t;
z = t * t * t - 2 * t * t + t;
w = t * t * t - t * t;
for (i = 0; i < n; ++i) {
v[i] = x * a[i] + y * b[i] + z * p[i] + w * q[i];
}
}

932
src/osgPlugins/3ds/lib3ds/lib3ds_matrix.c
View File

@@ -1,466 +1,466 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
/*!
* Clear a matrix to all zeros.
*
* \param m Matrix to be cleared.
*/
void
lib3ds_matrix_zero(float m[4][4]) {
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) m[i][j] = 0.0f;
}
}
/*!
* Set a matrix to identity.
*
* \param m Matrix to be set.
*/
void
lib3ds_matrix_identity(float m[4][4]) {
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) m[i][j] = 0.0;
}
for (i = 0; i < 4; i++) m[i][i] = 1.0;
}
/*!
* Copy a matrix.
*/
void
lib3ds_matrix_copy(float dest[4][4], float src[4][4]) {
memcpy(dest, src, 16 * sizeof(float));
}
/*!
* Negate a matrix -- all elements negated.
*/
void
lib3ds_matrix_neg(float m[4][4]) {
int i, j;
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
m[j][i] = -m[j][i];
}
}
}
/*!
* Transpose a matrix in place.
*/
void
lib3ds_matrix_transpose(float m[4][4]) {
int i, j;
float swp;
for (j = 0; j < 4; j++) {
for (i = j + 1; i < 4; i++) {
swp = m[j][i];
m[j][i] = m[i][j];
m[i][j] = swp;
}
}
}
/*!
* Add two matrices.
*/
void
lib3ds_matrix_add(float m[4][4], float a[4][4], float b[4][4]) {
int i, j;
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
m[j][i] = a[j][i] + b[j][i];
}
}
}
/*!
* Subtract two matrices.
*
* \param m Result.
* \param a Addend.
* \param b Minuend.
*/
void
lib3ds_matrix_sub(float m[4][4], float a[4][4], float b[4][4]) {
int i, j;
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
m[j][i] = a[j][i] - b[j][i];
}
}
}
/*!
* Multiplies a matrix by a second one (m = m * n).
*/
void
lib3ds_matrix_mult(float m[4][4], float a[4][4], float b[4][4]) {
float tmp[4][4];
int i, j, k;
float ab;
memcpy(tmp, a, 16 * sizeof(float));
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
ab = 0.0f;
for (k = 0; k < 4; k++) ab += tmp[k][i] * b[j][k];
m[j][i] = ab;
}
}
}
/*!
* Multiply a matrix by a scalar.
*
* \param m Matrix to be set.
* \param k Scalar.
*/
void
lib3ds_matrix_scalar(float m[4][4], float k) {
int i, j;
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
m[j][i] *= k;
}
}
}
static float
det2x2(
float a, float b,
float c, float d) {
return((a)*(d) - (b)*(c));
}
static float
det3x3(
float a1, float a2, float a3,
float b1, float b2, float b3,
float c1, float c2, float c3) {
return(
a1*det2x2(b2, b3, c2, c3) -
b1*det2x2(a2, a3, c2, c3) +
c1*det2x2(a2, a3, b2, b3)
);
}
/*!
* Find determinant of a matrix.
*/
float
lib3ds_matrix_det(float m[4][4]) {
float a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3, d4;
a1 = m[0][0];
b1 = m[1][0];
c1 = m[2][0];
d1 = m[3][0];
a2 = m[0][1];
b2 = m[1][1];
c2 = m[2][1];
d2 = m[3][1];
a3 = m[0][2];
b3 = m[1][2];
c3 = m[2][2];
d3 = m[3][2];
a4 = m[0][3];
b4 = m[1][3];
c4 = m[2][3];
d4 = m[3][3];
return(
a1 * det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4) -
b1 * det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4) +
c1 * det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4) -
d1 * det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4)
);
}
/*!
* Invert a matrix in place.
*
* \param m Matrix to invert.
*
* \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
*
* GGemsII, K.Wu, Fast Matrix Inversion
*/
int
lib3ds_matrix_inv(float m[4][4]) {
int i, j, k;
int pvt_i[4], pvt_j[4]; /* Locations of pivot elements */
float pvt_val; /* Value of current pivot element */
float hold; /* Temporary storage */
float determinat;
determinat = 1.0f;
for (k = 0; k < 4; k++) {
/* Locate k'th pivot element */
pvt_val = m[k][k]; /* Initialize for search */
pvt_i[k] = k;
pvt_j[k] = k;
for (i = k; i < 4; i++) {
for (j = k; j < 4; j++) {
if (fabs(m[i][j]) > fabs(pvt_val)) {
pvt_i[k] = i;
pvt_j[k] = j;
pvt_val = m[i][j];
}
}
}
/* Product of pivots, gives determinant when finished */
determinat *= pvt_val;
if (fabs(determinat) < LIB3DS_EPSILON) {
return(FALSE); /* Matrix is singular (zero determinant) */
}
/* "Interchange" rows (with sign change stuff) */
i = pvt_i[k];
if (i != k) { /* If rows are different */
for (j = 0; j < 4; j++) {
hold = -m[k][j];
m[k][j] = m[i][j];
m[i][j] = hold;
}
}
/* "Interchange" columns */
j = pvt_j[k];
if (j != k) { /* If columns are different */
for (i = 0; i < 4; i++) {
hold = -m[i][k];
m[i][k] = m[i][j];
m[i][j] = hold;
}
}
/* Divide column by minus pivot value */
for (i = 0; i < 4; i++) {
if (i != k) m[i][k] /= (-pvt_val) ;
}
/* Reduce the matrix */
for (i = 0; i < 4; i++) {
hold = m[i][k];
for (j = 0; j < 4; j++) {
if (i != k && j != k) m[i][j] += hold * m[k][j];
}
}
/* Divide row by pivot */
for (j = 0; j < 4; j++) {
if (j != k) m[k][j] /= pvt_val;
}
/* Replace pivot by reciprocal (at last we can touch it). */
m[k][k] = 1.0f / pvt_val;
}
/* That was most of the work, one final pass of row/column interchange */
/* to finish */
for (k = 4 - 2; k >= 0; k--) { /* Don't need to work with 1 by 1 corner*/
i = pvt_j[k]; /* Rows to swap correspond to pivot COLUMN */
if (i != k) { /* If rows are different */
for (j = 0; j < 4; j++) {
hold = m[k][j];
m[k][j] = -m[i][j];
m[i][j] = hold;
}
}
j = pvt_i[k]; /* Columns to swap correspond to pivot ROW */
if (j != k) /* If columns are different */
for (i = 0; i < 4; i++) {
hold = m[i][k];
m[i][k] = -m[i][j];
m[i][j] = hold;
}
}
return(TRUE);
}
/*!
* Apply a translation to a matrix.
*/
void
lib3ds_matrix_translate(float m[4][4], float x, float y, float z) {
int i;
for (i = 0; i < 3; i++) {
m[3][i] += m[0][i] * x + m[1][i] * y + m[2][i] * z;
}
}
/*!
* Apply scale factors to a matrix.
*/
void
lib3ds_matrix_scale(float m[4][4], float x, float y, float z) {
int i;
for (i = 0; i < 4; i++) {
m[0][i] *= x;
m[1][i] *= y;
m[2][i] *= z;
}
}
/*!
* Apply a rotation about an arbitrary axis to a matrix.
*/
void
lib3ds_matrix_rotate_quat(float m[4][4], float q[4]) {
float s, xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz, l;
float R[4][4];
l = q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3];
if (fabs(l) < LIB3DS_EPSILON) {
s = 1.0f;
} else {
s = 2.0f / l;
}
xs = q[0] * s;
ys = q[1] * s;
zs = q[2] * s;
wx = q[3] * xs;
wy = q[3] * ys;
wz = q[3] * zs;
xx = q[0] * xs;
xy = q[0] * ys;
xz = q[0] * zs;
yy = q[1] * ys;
yz = q[1] * zs;
zz = q[2] * zs;
R[0][0] = 1.0f - (yy + zz);
R[1][0] = xy - wz;
R[2][0] = xz + wy;
R[0][1] = xy + wz;
R[1][1] = 1.0f - (xx + zz);
R[2][1] = yz - wx;
R[0][2] = xz - wy;
R[1][2] = yz + wx;
R[2][2] = 1.0f - (xx + yy);
R[3][0] = R[3][1] = R[3][2] = R[0][3] = R[1][3] = R[2][3] = 0.0f;
R[3][3] = 1.0f;
lib3ds_matrix_mult(m, m, R);
}
/*!
* Apply a rotation about an arbitrary axis to a matrix.
*/
void
lib3ds_matrix_rotate(float m[4][4], float angle, float ax, float ay, float az) {
float q[4];
float axis[3];
lib3ds_vector_make(axis, ax, ay, az);
lib3ds_quat_axis_angle(q, axis, angle);
lib3ds_matrix_rotate_quat(m, q);
}
/*!
* Compute a camera matrix based on position, target and roll.
*
* Generates a translate/rotate matrix that maps world coordinates
* to camera coordinates. Resulting matrix does not include perspective
* transform.
*
* \param matrix Destination matrix.
* \param pos Camera position
* \param tgt Camera target
* \param roll Roll angle
*/
void
lib3ds_matrix_camera(float matrix[4][4], float pos[3], float tgt[3], float roll) {
float M[4][4];
float x[3], y[3], z[3];
lib3ds_vector_sub(y, tgt, pos);
lib3ds_vector_normalize(y);
if (y[0] != 0. || y[1] != 0) {
z[0] = 0;
z[1] = 0;
z[2] = 1.0;
} else { /* Special case: looking straight up or down z axis */
z[0] = -1.0;
z[1] = 0;
z[2] = 0;
}
lib3ds_vector_cross(x, y, z);
lib3ds_vector_cross(z, x, y);
lib3ds_vector_normalize(x);
lib3ds_vector_normalize(z);
lib3ds_matrix_identity(M);
M[0][0] = x[0];
M[1][0] = x[1];
M[2][0] = x[2];
M[0][1] = y[0];
M[1][1] = y[1];
M[2][1] = y[2];
M[0][2] = z[0];
M[1][2] = z[1];
M[2][2] = z[2];
lib3ds_matrix_identity(matrix);
lib3ds_matrix_rotate(matrix, roll, 0, 1, 0);
lib3ds_matrix_mult(matrix, matrix, M);
lib3ds_matrix_translate(matrix, -pos[0], -pos[1], -pos[2]);
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
/*!
* Clear a matrix to all zeros.
*
* \param m Matrix to be cleared.
*/
void
lib3ds_matrix_zero(float m[4][4]) {
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) m[i][j] = 0.0f;
}
}
/*!
* Set a matrix to identity.
*
* \param m Matrix to be set.
*/
void
lib3ds_matrix_identity(float m[4][4]) {
int i, j;
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) m[i][j] = 0.0;
}
for (i = 0; i < 4; i++) m[i][i] = 1.0;
}
/*!
* Copy a matrix.
*/
void
lib3ds_matrix_copy(float dest[4][4], float src[4][4]) {
memcpy(dest, src, 16 * sizeof(float));
}
/*!
* Negate a matrix -- all elements negated.
*/
void
lib3ds_matrix_neg(float m[4][4]) {
int i, j;
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
m[j][i] = -m[j][i];
}
}
}
/*!
* Transpose a matrix in place.
*/
void
lib3ds_matrix_transpose(float m[4][4]) {
int i, j;
float swp;
for (j = 0; j < 4; j++) {
for (i = j + 1; i < 4; i++) {
swp = m[j][i];
m[j][i] = m[i][j];
m[i][j] = swp;
}
}
}
/*!
* Add two matrices.
*/
void
lib3ds_matrix_add(float m[4][4], float a[4][4], float b[4][4]) {
int i, j;
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
m[j][i] = a[j][i] + b[j][i];
}
}
}
/*!
* Subtract two matrices.
*
* \param m Result.
* \param a Addend.
* \param b Minuend.
*/
void
lib3ds_matrix_sub(float m[4][4], float a[4][4], float b[4][4]) {
int i, j;
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
m[j][i] = a[j][i] - b[j][i];
}
}
}
/*!
* Multiplies a matrix by a second one (m = m * n).
*/
void
lib3ds_matrix_mult(float m[4][4], float a[4][4], float b[4][4]) {
float tmp[4][4];
int i, j, k;
float ab;
memcpy(tmp, a, 16 * sizeof(float));
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
ab = 0.0f;
for (k = 0; k < 4; k++) ab += tmp[k][i] * b[j][k];
m[j][i] = ab;
}
}
}
/*!
* Multiply a matrix by a scalar.
*
* \param m Matrix to be set.
* \param k Scalar.
*/
void
lib3ds_matrix_scalar(float m[4][4], float k) {
int i, j;
for (j = 0; j < 4; j++) {
for (i = 0; i < 4; i++) {
m[j][i] *= k;
}
}
}
static float
det2x2(
float a, float b,
float c, float d) {
return((a)*(d) - (b)*(c));
}
static float
det3x3(
float a1, float a2, float a3,
float b1, float b2, float b3,
float c1, float c2, float c3) {
return(
a1*det2x2(b2, b3, c2, c3) -
b1*det2x2(a2, a3, c2, c3) +
c1*det2x2(a2, a3, b2, b3)
);
}
/*!
* Find determinant of a matrix.
*/
float
lib3ds_matrix_det(float m[4][4]) {
float a1, a2, a3, a4, b1, b2, b3, b4, c1, c2, c3, c4, d1, d2, d3, d4;
a1 = m[0][0];
b1 = m[1][0];
c1 = m[2][0];
d1 = m[3][0];
a2 = m[0][1];
b2 = m[1][1];
c2 = m[2][1];
d2 = m[3][1];
a3 = m[0][2];
b3 = m[1][2];
c3 = m[2][2];
d3 = m[3][2];
a4 = m[0][3];
b4 = m[1][3];
c4 = m[2][3];
d4 = m[3][3];
return(
a1 * det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4) -
b1 * det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4) +
c1 * det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4) -
d1 * det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4)
);
}
/*!
* Invert a matrix in place.
*
* \param m Matrix to invert.
*
* \return LIB3DS_TRUE on success, LIB3DS_FALSE on failure.
*
* GGemsII, K.Wu, Fast Matrix Inversion
*/
int
lib3ds_matrix_inv(float m[4][4]) {
int i, j, k;
int pvt_i[4], pvt_j[4]; /* Locations of pivot elements */
float pvt_val; /* Value of current pivot element */
float hold; /* Temporary storage */
float determinat;
determinat = 1.0f;
for (k = 0; k < 4; k++) {
/* Locate k'th pivot element */
pvt_val = m[k][k]; /* Initialize for search */
pvt_i[k] = k;
pvt_j[k] = k;
for (i = k; i < 4; i++) {
for (j = k; j < 4; j++) {
if (fabs(m[i][j]) > fabs(pvt_val)) {
pvt_i[k] = i;
pvt_j[k] = j;
pvt_val = m[i][j];
}
}
}
/* Product of pivots, gives determinant when finished */
determinat *= pvt_val;
if (fabs(determinat) < LIB3DS_EPSILON) {
return(FALSE); /* Matrix is singular (zero determinant) */
}
/* "Interchange" rows (with sign change stuff) */
i = pvt_i[k];
if (i != k) { /* If rows are different */
for (j = 0; j < 4; j++) {
hold = -m[k][j];
m[k][j] = m[i][j];
m[i][j] = hold;
}
}
/* "Interchange" columns */
j = pvt_j[k];
if (j != k) { /* If columns are different */
for (i = 0; i < 4; i++) {
hold = -m[i][k];
m[i][k] = m[i][j];
m[i][j] = hold;
}
}
/* Divide column by minus pivot value */
for (i = 0; i < 4; i++) {
if (i != k) m[i][k] /= (-pvt_val) ;
}
/* Reduce the matrix */
for (i = 0; i < 4; i++) {
hold = m[i][k];
for (j = 0; j < 4; j++) {
if (i != k && j != k) m[i][j] += hold * m[k][j];
}
}
/* Divide row by pivot */
for (j = 0; j < 4; j++) {
if (j != k) m[k][j] /= pvt_val;
}
/* Replace pivot by reciprocal (at last we can touch it). */
m[k][k] = 1.0f / pvt_val;
}
/* That was most of the work, one final pass of row/column interchange */
/* to finish */
for (k = 4 - 2; k >= 0; k--) { /* Don't need to work with 1 by 1 corner*/
i = pvt_j[k]; /* Rows to swap correspond to pivot COLUMN */
if (i != k) { /* If rows are different */
for (j = 0; j < 4; j++) {
hold = m[k][j];
m[k][j] = -m[i][j];
m[i][j] = hold;
}
}
j = pvt_i[k]; /* Columns to swap correspond to pivot ROW */
if (j != k) /* If columns are different */
for (i = 0; i < 4; i++) {
hold = m[i][k];
m[i][k] = -m[i][j];
m[i][j] = hold;
}
}
return(TRUE);
}
/*!
* Apply a translation to a matrix.
*/
void
lib3ds_matrix_translate(float m[4][4], float x, float y, float z) {
int i;
for (i = 0; i < 3; i++) {
m[3][i] += m[0][i] * x + m[1][i] * y + m[2][i] * z;
}
}
/*!
* Apply scale factors to a matrix.
*/
void
lib3ds_matrix_scale(float m[4][4], float x, float y, float z) {
int i;
for (i = 0; i < 4; i++) {
m[0][i] *= x;
m[1][i] *= y;
m[2][i] *= z;
}
}
/*!
* Apply a rotation about an arbitrary axis to a matrix.
*/
void
lib3ds_matrix_rotate_quat(float m[4][4], float q[4]) {
float s, xs, ys, zs, wx, wy, wz, xx, xy, xz, yy, yz, zz, l;
float R[4][4];
l = q[0] * q[0] + q[1] * q[1] + q[2] * q[2] + q[3] * q[3];
if (fabs(l) < LIB3DS_EPSILON) {
s = 1.0f;
} else {
s = 2.0f / l;
}
xs = q[0] * s;
ys = q[1] * s;
zs = q[2] * s;
wx = q[3] * xs;
wy = q[3] * ys;
wz = q[3] * zs;
xx = q[0] * xs;
xy = q[0] * ys;
xz = q[0] * zs;
yy = q[1] * ys;
yz = q[1] * zs;
zz = q[2] * zs;
R[0][0] = 1.0f - (yy + zz);
R[1][0] = xy - wz;
R[2][0] = xz + wy;
R[0][1] = xy + wz;
R[1][1] = 1.0f - (xx + zz);
R[2][1] = yz - wx;
R[0][2] = xz - wy;
R[1][2] = yz + wx;
R[2][2] = 1.0f - (xx + yy);
R[3][0] = R[3][1] = R[3][2] = R[0][3] = R[1][3] = R[2][3] = 0.0f;
R[3][3] = 1.0f;
lib3ds_matrix_mult(m, m, R);
}
/*!
* Apply a rotation about an arbitrary axis to a matrix.
*/
void
lib3ds_matrix_rotate(float m[4][4], float angle, float ax, float ay, float az) {
float q[4];
float axis[3];
lib3ds_vector_make(axis, ax, ay, az);
lib3ds_quat_axis_angle(q, axis, angle);
lib3ds_matrix_rotate_quat(m, q);
}
/*!
* Compute a camera matrix based on position, target and roll.
*
* Generates a translate/rotate matrix that maps world coordinates
* to camera coordinates. Resulting matrix does not include perspective
* transform.
*
* \param matrix Destination matrix.
* \param pos Camera position
* \param tgt Camera target
* \param roll Roll angle
*/
void
lib3ds_matrix_camera(float matrix[4][4], float pos[3], float tgt[3], float roll) {
float M[4][4];
float x[3], y[3], z[3];
lib3ds_vector_sub(y, tgt, pos);
lib3ds_vector_normalize(y);
if (y[0] != 0. || y[1] != 0) {
z[0] = 0;
z[1] = 0;
z[2] = 1.0;
} else { /* Special case: looking straight up or down z axis */
z[0] = -1.0;
z[1] = 0;
z[2] = 0;
}
lib3ds_vector_cross(x, y, z);
lib3ds_vector_cross(z, x, y);
lib3ds_vector_normalize(x);
lib3ds_vector_normalize(z);
lib3ds_matrix_identity(M);
M[0][0] = x[0];
M[1][0] = x[1];
M[2][0] = x[2];
M[0][1] = y[0];
M[1][1] = y[1];
M[2][1] = y[2];
M[0][2] = z[0];
M[1][2] = z[1];
M[2][2] = z[2];
lib3ds_matrix_identity(matrix);
lib3ds_matrix_rotate(matrix, roll, 0, 1, 0);
lib3ds_matrix_mult(matrix, matrix, M);
lib3ds_matrix_translate(matrix, -pos[0], -pos[1], -pos[2]);
}

1354
src/osgPlugins/3ds/lib3ds/lib3ds_mesh.c
View File

File diff suppressed because it is too large Load Diff

2124
src/osgPlugins/3ds/lib3ds/lib3ds_node.c
View File

File diff suppressed because it is too large Load Diff

588
src/osgPlugins/3ds/lib3ds/lib3ds_quat.c
View File

@@ -1,294 +1,294 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
/*!
* Set a quaternion to Identity
*/
void
lib3ds_quat_identity(float c[4]) {
c[0] = c[1] = c[2] = 0.0f;
c[3] = 1.0f;
}
/*!
* Copy a quaternion.
*/
void
lib3ds_quat_copy(float dest[4], float src[4]) {
int i;
for (i = 0; i < 4; ++i) {
dest[i] = src[i];
}
}
/*!
* Compute a quaternion from axis and angle.
*
* \param c Computed quaternion
* \param axis Rotation axis
* \param angle Angle of rotation, radians.
*/
void
lib3ds_quat_axis_angle(float c[4], float axis[3], float angle) {
double omega, s;
double l;
l = sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
if (l < LIB3DS_EPSILON) {
c[0] = c[1] = c[2] = 0.0f;
c[3] = 1.0f;
} else {
omega = -0.5 * angle;
s = sin(omega) / l;
c[0] = (float)s * axis[0];
c[1] = (float)s * axis[1];
c[2] = (float)s * axis[2];
c[3] = (float)cos(omega);
}
}
/*!
* Negate a quaternion
*/
void
lib3ds_quat_neg(float c[4]) {
int i;
for (i = 0; i < 4; ++i) {
c[i] = -c[i];
}
}
/*!
* Compute the conjugate of a quaternion
*/
void
lib3ds_quat_cnj(float c[4]) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = -c[i];
}
}
/*!
* Multiply two quaternions.
*
* \param c Result
* \param a,b Inputs
*/
void
lib3ds_quat_mul(float c[4], float a[4], float b[4]) {
float qa[4], qb[4];
lib3ds_quat_copy(qa, a);
lib3ds_quat_copy(qb, b);
c[0] = qa[3] * qb[0] + qa[0] * qb[3] + qa[1] * qb[2] - qa[2] * qb[1];
c[1] = qa[3] * qb[1] + qa[1] * qb[3] + qa[2] * qb[0] - qa[0] * qb[2];
c[2] = qa[3] * qb[2] + qa[2] * qb[3] + qa[0] * qb[1] - qa[1] * qb[0];
c[3] = qa[3] * qb[3] - qa[0] * qb[0] - qa[1] * qb[1] - qa[2] * qb[2];
}
/*!
* Multiply a quaternion by a scalar.
*/
void
lib3ds_quat_scalar(float c[4], float k) {
int i;
for (i = 0; i < 4; ++i) {
c[i] *= k;
}
}
/*!
* Normalize a quaternion.
*/
void
lib3ds_quat_normalize(float c[4]) {
double l, m;
l = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2] + c[3] * c[3]);
if (fabs(l) < LIB3DS_EPSILON) {
c[0] = c[1] = c[2] = 0.0f;
c[3] = 1.0f;
} else {
int i;
m = 1.0f / l;
for (i = 0; i < 4; ++i) {
c[i] = (float)(c[i] * m);
}
}
}
/*!
* Compute the inverse of a quaternion.
*/
void
lib3ds_quat_inv(float c[4]) {
double l, m;
l = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2] + c[3] * c[3]);
if (fabs(l) < LIB3DS_EPSILON) {
c[0] = c[1] = c[2] = 0.0f;
c[3] = 1.0f;
} else {
m = 1.0f / l;
c[0] = (float)(-c[0] * m);
c[1] = (float)(-c[1] * m);
c[2] = (float)(-c[2] * m);
c[3] = (float)(c[3] * m);
}
}
/*!
* Compute the dot-product of a quaternion.
*/
float
lib3ds_quat_dot(float a[4], float b[4]) {
return(a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]);
}
float
lib3ds_quat_norm(float c[4]) {
return(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]);
}
void
lib3ds_quat_ln(float c[4]) {
double om, s, t;
s = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);
om = atan2(s, (double)c[3]);
if (fabs(s) < LIB3DS_EPSILON) {
t = 0.0f;
} else {
t = om / s;
}
{
int i;
for (i = 0; i < 3; ++i) {
c[i] = (float)(c[i] * t);
}
c[3] = 0.0f;
}
}
void
lib3ds_quat_ln_dif(float c[4], float a[4], float b[4]) {
float invp[4];
lib3ds_quat_copy(invp, a);
lib3ds_quat_inv(invp);
lib3ds_quat_mul(c, invp, b);
lib3ds_quat_ln(c);
}
void
lib3ds_quat_exp(float c[4]) {
double om, sinom;
om = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);
if (fabs(om) < LIB3DS_EPSILON) {
sinom = 1.0f;
} else {
sinom = sin(om) / om;
}
{
int i;
for (i = 0; i < 3; ++i) {
c[i] = (float)(c[i] * sinom);
}
c[3] = (float)cos(om);
}
}
void
lib3ds_quat_slerp(float c[4], float a[4], float b[4], float t) {
double l;
double om, sinom;
double sp, sq;
float flip = 1.0f;
int i;
l = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
if (l < 0) {
flip = -1.0f;
l = -l;
}
om = acos(l);
sinom = sin(om);
if (fabs(sinom) > LIB3DS_EPSILON) {
sp = sin((1.0f - t) * om) / sinom;
sq = sin(t * om) / sinom;
} else {
sp = 1.0f - t;
sq = t;
}
sq *= flip;
for (i = 0; i < 4; ++i) {
c[i] = (float)(sp * a[i] + sq * b[i]);
}
}
void
lib3ds_quat_squad(float c[4], float a[4], float p[4], float q[4], float b[4], float t) {
float ab[4];
float pq[4];
lib3ds_quat_slerp(ab, a, b, t);
lib3ds_quat_slerp(pq, p, q, t);
lib3ds_quat_slerp(c, ab, pq, 2*t*(1 - t));
}
void
lib3ds_quat_tangent(float c[4], float p[4], float q[4], float n[4]) {
float dn[4], dp[4], x[4];
int i;
lib3ds_quat_ln_dif(dn, q, n);
lib3ds_quat_ln_dif(dp, q, p);
for (i = 0; i < 4; i++) {
x[i] = -1.0f / 4.0f * (dn[i] + dp[i]);
}
lib3ds_quat_exp(x);
lib3ds_quat_mul(c, q, x);
}
void
lib3ds_quat_dump(float q[4]) {
printf("%f %f %f %f\n", q[0], q[1], q[2], q[3]);
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
/*!
* Set a quaternion to Identity
*/
void
lib3ds_quat_identity(float c[4]) {
c[0] = c[1] = c[2] = 0.0f;
c[3] = 1.0f;
}
/*!
* Copy a quaternion.
*/
void
lib3ds_quat_copy(float dest[4], float src[4]) {
int i;
for (i = 0; i < 4; ++i) {
dest[i] = src[i];
}
}
/*!
* Compute a quaternion from axis and angle.
*
* \param c Computed quaternion
* \param axis Rotation axis
* \param angle Angle of rotation, radians.
*/
void
lib3ds_quat_axis_angle(float c[4], float axis[3], float angle) {
double omega, s;
double l;
l = sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);
if (l < LIB3DS_EPSILON) {
c[0] = c[1] = c[2] = 0.0f;
c[3] = 1.0f;
} else {
omega = -0.5 * angle;
s = sin(omega) / l;
c[0] = (float)s * axis[0];
c[1] = (float)s * axis[1];
c[2] = (float)s * axis[2];
c[3] = (float)cos(omega);
}
}
/*!
* Negate a quaternion
*/
void
lib3ds_quat_neg(float c[4]) {
int i;
for (i = 0; i < 4; ++i) {
c[i] = -c[i];
}
}
/*!
* Compute the conjugate of a quaternion
*/
void
lib3ds_quat_cnj(float c[4]) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = -c[i];
}
}
/*!
* Multiply two quaternions.
*
* \param c Result
* \param a,b Inputs
*/
void
lib3ds_quat_mul(float c[4], float a[4], float b[4]) {
float qa[4], qb[4];
lib3ds_quat_copy(qa, a);
lib3ds_quat_copy(qb, b);
c[0] = qa[3] * qb[0] + qa[0] * qb[3] + qa[1] * qb[2] - qa[2] * qb[1];
c[1] = qa[3] * qb[1] + qa[1] * qb[3] + qa[2] * qb[0] - qa[0] * qb[2];
c[2] = qa[3] * qb[2] + qa[2] * qb[3] + qa[0] * qb[1] - qa[1] * qb[0];
c[3] = qa[3] * qb[3] - qa[0] * qb[0] - qa[1] * qb[1] - qa[2] * qb[2];
}
/*!
* Multiply a quaternion by a scalar.
*/
void
lib3ds_quat_scalar(float c[4], float k) {
int i;
for (i = 0; i < 4; ++i) {
c[i] *= k;
}
}
/*!
* Normalize a quaternion.
*/
void
lib3ds_quat_normalize(float c[4]) {
double l, m;
l = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2] + c[3] * c[3]);
if (fabs(l) < LIB3DS_EPSILON) {
c[0] = c[1] = c[2] = 0.0f;
c[3] = 1.0f;
} else {
int i;
m = 1.0f / l;
for (i = 0; i < 4; ++i) {
c[i] = (float)(c[i] * m);
}
}
}
/*!
* Compute the inverse of a quaternion.
*/
void
lib3ds_quat_inv(float c[4]) {
double l, m;
l = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2] + c[3] * c[3]);
if (fabs(l) < LIB3DS_EPSILON) {
c[0] = c[1] = c[2] = 0.0f;
c[3] = 1.0f;
} else {
m = 1.0f / l;
c[0] = (float)(-c[0] * m);
c[1] = (float)(-c[1] * m);
c[2] = (float)(-c[2] * m);
c[3] = (float)(c[3] * m);
}
}
/*!
* Compute the dot-product of a quaternion.
*/
float
lib3ds_quat_dot(float a[4], float b[4]) {
return(a[0]*b[0] + a[1]*b[1] + a[2]*b[2] + a[3]*b[3]);
}
float
lib3ds_quat_norm(float c[4]) {
return(c[0]*c[0] + c[1]*c[1] + c[2]*c[2] + c[3]*c[3]);
}
void
lib3ds_quat_ln(float c[4]) {
double om, s, t;
s = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);
om = atan2(s, (double)c[3]);
if (fabs(s) < LIB3DS_EPSILON) {
t = 0.0f;
} else {
t = om / s;
}
{
int i;
for (i = 0; i < 3; ++i) {
c[i] = (float)(c[i] * t);
}
c[3] = 0.0f;
}
}
void
lib3ds_quat_ln_dif(float c[4], float a[4], float b[4]) {
float invp[4];
lib3ds_quat_copy(invp, a);
lib3ds_quat_inv(invp);
lib3ds_quat_mul(c, invp, b);
lib3ds_quat_ln(c);
}
void
lib3ds_quat_exp(float c[4]) {
double om, sinom;
om = sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);
if (fabs(om) < LIB3DS_EPSILON) {
sinom = 1.0f;
} else {
sinom = sin(om) / om;
}
{
int i;
for (i = 0; i < 3; ++i) {
c[i] = (float)(c[i] * sinom);
}
c[3] = (float)cos(om);
}
}
void
lib3ds_quat_slerp(float c[4], float a[4], float b[4], float t) {
double l;
double om, sinom;
double sp, sq;
float flip = 1.0f;
int i;
l = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
if (l < 0) {
flip = -1.0f;
l = -l;
}
om = acos(l);
sinom = sin(om);
if (fabs(sinom) > LIB3DS_EPSILON) {
sp = sin((1.0f - t) * om) / sinom;
sq = sin(t * om) / sinom;
} else {
sp = 1.0f - t;
sq = t;
}
sq *= flip;
for (i = 0; i < 4; ++i) {
c[i] = (float)(sp * a[i] + sq * b[i]);
}
}
void
lib3ds_quat_squad(float c[4], float a[4], float p[4], float q[4], float b[4], float t) {
float ab[4];
float pq[4];
lib3ds_quat_slerp(ab, a, b, t);
lib3ds_quat_slerp(pq, p, q, t);
lib3ds_quat_slerp(c, ab, pq, 2*t*(1 - t));
}
void
lib3ds_quat_tangent(float c[4], float p[4], float q[4], float n[4]) {
float dn[4], dp[4], x[4];
int i;
lib3ds_quat_ln_dif(dn, q, n);
lib3ds_quat_ln_dif(dp, q, p);
for (i = 0; i < 4; i++) {
x[i] = -1.0f / 4.0f * (dn[i] + dp[i]);
}
lib3ds_quat_exp(x);
lib3ds_quat_mul(c, q, x);
}
void
lib3ds_quat_dump(float q[4]) {
printf("%f %f %f %f\n", q[0], q[1], q[2], q[3]);
}

192
src/osgPlugins/3ds/lib3ds/lib3ds_shadow.c
View File

@@ -1,96 +1,96 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
void
lib3ds_shadow_read(Lib3dsShadow *shadow, Lib3dsIo *io) {
Lib3dsChunk c;
lib3ds_chunk_read(&c, io);
switch (c.chunk) {
case CHK_SHADOW_MAP_SIZE: {
shadow->map_size = lib3ds_io_read_intw(io);
break;
}
case CHK_LO_SHADOW_BIAS: {
shadow->low_bias = lib3ds_io_read_float(io);
break;
}
case CHK_HI_SHADOW_BIAS: {
shadow->hi_bias = lib3ds_io_read_float(io);
break;
}
case CHK_SHADOW_FILTER: {
shadow->filter = lib3ds_io_read_float(io);
break;
}
case CHK_RAY_BIAS: {
shadow->ray_bias = lib3ds_io_read_float(io);
break;
}
}
}
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);
}
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
void
lib3ds_shadow_read(Lib3dsShadow *shadow, Lib3dsIo *io) {
Lib3dsChunk c;
lib3ds_chunk_read(&c, io);
switch (c.chunk) {
case CHK_SHADOW_MAP_SIZE: {
shadow->map_size = lib3ds_io_read_intw(io);
break;
}
case CHK_LO_SHADOW_BIAS: {
shadow->low_bias = lib3ds_io_read_float(io);
break;
}
case CHK_HI_SHADOW_BIAS: {
shadow->hi_bias = lib3ds_io_read_float(io);
break;
}
case CHK_SHADOW_FILTER: {
shadow->filter = lib3ds_io_read_float(io);
break;
}
case CHK_RAY_BIAS: {
shadow->ray_bias = lib3ds_io_read_float(io);
break;
}
}
}
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);
}
}

1102
src/osgPlugins/3ds/lib3ds/lib3ds_track.c
View File

File diff suppressed because it is too large Load Diff

178
src/osgPlugins/3ds/lib3ds/lib3ds_util.c
View File

@@ -1,89 +1,89 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
void* lib3ds_util_realloc_array(void *ptr, int old_size, int new_size, int element_size) {
if (!ptr)
old_size = 0;
if (old_size != new_size) {
ptr = realloc(ptr, element_size * new_size);
if (old_size < new_size) {
memset((char*)ptr + element_size * old_size, 0, element_size * (new_size - old_size));
}
}
return ptr;
}
void lib3ds_util_reserve_array(void ***ptr, int *n, int *size, int new_size, int force, Lib3dsFreeFunc free_func) {
assert(ptr && n && size);
if ((*size < new_size) || force) {
if (force && free_func) {
int i;
for (i = new_size; i < *n; ++i) {
free_func((*ptr)[i]);
(*ptr)[i] = 0;
}
}
*ptr = (void**)realloc(*ptr, sizeof(void*) * new_size);
*size = new_size;
if (*n > new_size) {
*n = new_size;
}
}
}
void lib3ds_util_insert_array(void ***ptr, int *n, int *size, void *element, int index) {
int i;
assert(ptr && n && size && element);
i = ((index >= 0) && (index < *n)) ? index : *n;
if (i >= *size) {
int new_size = 2 * (*size);
#ifdef _DEBUG
if (new_size < 1) {
new_size = 1;
}
#else
if (new_size < 32) {
new_size = 32;
}
#endif
lib3ds_util_reserve_array(ptr, n, size, new_size, FALSE, NULL);
}
assert(*ptr);
if (i < *n) {
memmove(&(*ptr)[i+1], &(*ptr)[i], sizeof(void*) * (*n - i));
}
(*ptr)[i] = element;
*n = *n + 1;
}
void lib3ds_util_remove_array(void ***ptr, int *n, int index, Lib3dsFreeFunc free_func) {
assert(ptr && n);
if ((index >= 0) && (index < *n)) {
assert(*ptr);
free_func((*ptr)[index]);
if (index < *n - 1) {
memmove(&(*ptr)[index], &(*ptr)[index+1], sizeof(void*) * (*n - index - 1));
}
*n = *n - 1;
}
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
void* lib3ds_util_realloc_array(void *ptr, int old_size, int new_size, int element_size) {
if (!ptr)
old_size = 0;
if (old_size != new_size) {
ptr = realloc(ptr, element_size * new_size);
if (old_size < new_size) {
memset((char*)ptr + element_size * old_size, 0, element_size * (new_size - old_size));
}
}
return ptr;
}
void lib3ds_util_reserve_array(void ***ptr, int *n, int *size, int new_size, int force, Lib3dsFreeFunc free_func) {
assert(ptr && n && size);
if ((*size < new_size) || force) {
if (force && free_func) {
int i;
for (i = new_size; i < *n; ++i) {
free_func((*ptr)[i]);
(*ptr)[i] = 0;
}
}
*ptr = (void**)realloc(*ptr, sizeof(void*) * new_size);
*size = new_size;
if (*n > new_size) {
*n = new_size;
}
}
}
void lib3ds_util_insert_array(void ***ptr, int *n, int *size, void *element, int index) {
int i;
assert(ptr && n && size && element);
i = ((index >= 0) && (index < *n)) ? index : *n;
if (i >= *size) {
int new_size = 2 * (*size);
#ifdef _DEBUG
if (new_size < 1) {
new_size = 1;
}
#else
if (new_size < 32) {
new_size = 32;
}
#endif
lib3ds_util_reserve_array(ptr, n, size, new_size, FALSE, NULL);
}
assert(*ptr);
if (i < *n) {
memmove(&(*ptr)[i+1], &(*ptr)[i], sizeof(void*) * (*n - i));
}
(*ptr)[i] = element;
*n = *n + 1;
}
void lib3ds_util_remove_array(void ***ptr, int *n, int index, Lib3dsFreeFunc free_func) {
assert(ptr && n);
if ((index >= 0) && (index < *n)) {
assert(*ptr);
free_func((*ptr)[index]);
if (index < *n - 1) {
memmove(&(*ptr)[index], &(*ptr)[index+1], sizeof(void*) * (*n - index - 1));
}
*n = *n - 1;
}
}

492
src/osgPlugins/3ds/lib3ds/lib3ds_vector.c
View File

@@ -1,246 +1,246 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
void
lib3ds_vector_make(float c[3], float x, float y, float z) {
c[0] = x;
c[1] = y;
c[2] = z;
}
void
lib3ds_vector_zero(float c[3]) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = 0.0f;
}
}
void
lib3ds_vector_copy(float dst[3], float src[3]) {
int i;
for (i = 0; i < 3; ++i) {
dst[i] = src[i];
}
}
/*!
* Add two vectors.
*
* \param c Result.
* \param a First addend.
* \param b Second addend.
*/
void
lib3ds_vector_add(float c[3], float a[3], float b[3]) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = a[i] + b[i];
}
}
/*!
* Subtract two vectors.
*
* \param c Result.
* \param a Addend.
* \param b Minuend.
*/
void
lib3ds_vector_sub(float c[3], float a[3], float b[3]) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = a[i] - b[i];
}
}
/*!
* Multiply a vector by a scalar.
*
* \param c Vector to be multiplied.
* \param k Scalar.
*/
void
lib3ds_vector_scalar_mul(float c[3], float a[3], float k) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = a[i] * k;
}
}
/*!
* Compute cross product.
*
* \param c Result.
* \param a First vector.
* \param b Second vector.
*/
void
lib3ds_vector_cross(float c[3], float a[3], float b[3]) {
c[0] = a[1] * b[2] - a[2] * b[1];
c[1] = a[2] * b[0] - a[0] * b[2];
c[2] = a[0] * b[1] - a[1] * b[0];
}
/*!
* Compute dot product.
*
* \param a First vector.
* \param b Second vector.
*
* \return Dot product.
*/
float
lib3ds_vector_dot(float a[3], float b[3]) {
return(a[0]*b[0] + a[1]*b[1] + a[2]*b[2]);
}
/*!
* Compute length of vector.
*
* Computes |c| = sqrt(x*x + y*y + z*z)
*
* \param c Vector to compute.
*
* \return Length of vector.
*/
float
lib3ds_vector_length(float c[3]) {
return((float)sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]));
}
/*!
* Normalize a vector.
*
* Scales a vector so that its length is 1.0.
*
* \param c Vector to normalize.
*/
void
lib3ds_vector_normalize(float c[3]) {
float l, m;
l = (float)sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);
if (fabs(l) < LIB3DS_EPSILON) {
if ((c[0] >= c[1]) && (c[0] >= c[2])) {
c[0] = 1.0f;
c[1] = c[2] = 0.0f;
} else
if (c[1] >= c[2]) {
c[1] = 1.0f;
c[0] = c[2] = 0.0f;
} else {
c[2] = 1.0f;
c[0] = c[1] = 0.0f;
}
} else {
m = 1.0f / l;
c[0] *= m;
c[1] *= m;
c[2] *= m;
}
}
/*!
* Compute a vector normal to two line segments.
*
* Computes the normal vector to the lines b-a and b-c.
*
* \param n Returned normal vector.
* \param a Endpoint of first line.
* \param b Base point of both lines.
* \param c Endpoint of second line.
*/
void
lib3ds_vector_normal(float n[3], float a[3], float b[3], float c[3]) {
float p[3], q[3];
lib3ds_vector_sub(p, c, b);
lib3ds_vector_sub(q, a, b);
lib3ds_vector_cross(n, p, q);
lib3ds_vector_normalize(n);
}
/*!
* Multiply a point by a transformation matrix.
*
* Applies the given transformation matrix to the given point. With some
* transformation matrices, a vector may also be transformed.
*
* \param c Result.
* \param m Transformation matrix.
* \param a Input point.
*/
void
lib3ds_vector_transform(float c[3], float m[4][4], float a[3]) {
c[0] = m[0][0] * a[0] + m[1][0] * a[1] + m[2][0] * a[2] + m[3][0];
c[1] = m[0][1] * a[0] + m[1][1] * a[1] + m[2][1] * a[2] + m[3][1];
c[2] = m[0][2] * a[0] + m[1][2] * a[1] + m[2][2] * a[2] + m[3][2];
}
/*!
* c[i] = min(c[i], a[i]);
*
* Computes minimum values of x,y,z independently.
*/
void
lib3ds_vector_min(float c[3], float a[3]) {
int i;
for (i = 0; i < 3; ++i) {
if (a[i] < c[i]) {
c[i] = a[i];
}
}
}
/*!
* c[i] = max(c[i], a[i]);
*
* Computes maximum values of x,y,z independently.
*/
void
lib3ds_vector_max(float c[3], float a[3]) {
int i;
for (i = 0; i < 3; ++i) {
if (a[i] > c[i]) {
c[i] = a[i];
}
}
}
void
lib3ds_vector_dump(float c[3]) {
fprintf(stderr, "%f %f %f\n", c[0], c[1], c[2]);
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
void
lib3ds_vector_make(float c[3], float x, float y, float z) {
c[0] = x;
c[1] = y;
c[2] = z;
}
void
lib3ds_vector_zero(float c[3]) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = 0.0f;
}
}
void
lib3ds_vector_copy(float dst[3], float src[3]) {
int i;
for (i = 0; i < 3; ++i) {
dst[i] = src[i];
}
}
/*!
* Add two vectors.
*
* \param c Result.
* \param a First addend.
* \param b Second addend.
*/
void
lib3ds_vector_add(float c[3], float a[3], float b[3]) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = a[i] + b[i];
}
}
/*!
* Subtract two vectors.
*
* \param c Result.
* \param a Addend.
* \param b Minuend.
*/
void
lib3ds_vector_sub(float c[3], float a[3], float b[3]) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = a[i] - b[i];
}
}
/*!
* Multiply a vector by a scalar.
*
* \param c Vector to be multiplied.
* \param k Scalar.
*/
void
lib3ds_vector_scalar_mul(float c[3], float a[3], float k) {
int i;
for (i = 0; i < 3; ++i) {
c[i] = a[i] * k;
}
}
/*!
* Compute cross product.
*
* \param c Result.
* \param a First vector.
* \param b Second vector.
*/
void
lib3ds_vector_cross(float c[3], float a[3], float b[3]) {
c[0] = a[1] * b[2] - a[2] * b[1];
c[1] = a[2] * b[0] - a[0] * b[2];
c[2] = a[0] * b[1] - a[1] * b[0];
}
/*!
* Compute dot product.
*
* \param a First vector.
* \param b Second vector.
*
* \return Dot product.
*/
float
lib3ds_vector_dot(float a[3], float b[3]) {
return(a[0]*b[0] + a[1]*b[1] + a[2]*b[2]);
}
/*!
* Compute length of vector.
*
* Computes |c| = sqrt(x*x + y*y + z*z)
*
* \param c Vector to compute.
*
* \return Length of vector.
*/
float
lib3ds_vector_length(float c[3]) {
return((float)sqrt(c[0]*c[0] + c[1]*c[1] + c[2]*c[2]));
}
/*!
* Normalize a vector.
*
* Scales a vector so that its length is 1.0.
*
* \param c Vector to normalize.
*/
void
lib3ds_vector_normalize(float c[3]) {
float l, m;
l = (float)sqrt(c[0] * c[0] + c[1] * c[1] + c[2] * c[2]);
if (fabs(l) < LIB3DS_EPSILON) {
if ((c[0] >= c[1]) && (c[0] >= c[2])) {
c[0] = 1.0f;
c[1] = c[2] = 0.0f;
} else
if (c[1] >= c[2]) {
c[1] = 1.0f;
c[0] = c[2] = 0.0f;
} else {
c[2] = 1.0f;
c[0] = c[1] = 0.0f;
}
} else {
m = 1.0f / l;
c[0] *= m;
c[1] *= m;
c[2] *= m;
}
}
/*!
* Compute a vector normal to two line segments.
*
* Computes the normal vector to the lines b-a and b-c.
*
* \param n Returned normal vector.
* \param a Endpoint of first line.
* \param b Base point of both lines.
* \param c Endpoint of second line.
*/
void
lib3ds_vector_normal(float n[3], float a[3], float b[3], float c[3]) {
float p[3], q[3];
lib3ds_vector_sub(p, c, b);
lib3ds_vector_sub(q, a, b);
lib3ds_vector_cross(n, p, q);
lib3ds_vector_normalize(n);
}
/*!
* Multiply a point by a transformation matrix.
*
* Applies the given transformation matrix to the given point. With some
* transformation matrices, a vector may also be transformed.
*
* \param c Result.
* \param m Transformation matrix.
* \param a Input point.
*/
void
lib3ds_vector_transform(float c[3], float m[4][4], float a[3]) {
c[0] = m[0][0] * a[0] + m[1][0] * a[1] + m[2][0] * a[2] + m[3][0];
c[1] = m[0][1] * a[0] + m[1][1] * a[1] + m[2][1] * a[2] + m[3][1];
c[2] = m[0][2] * a[0] + m[1][2] * a[1] + m[2][2] * a[2] + m[3][2];
}
/*!
* c[i] = min(c[i], a[i]);
*
* Computes minimum values of x,y,z independently.
*/
void
lib3ds_vector_min(float c[3], float a[3]) {
int i;
for (i = 0; i < 3; ++i) {
if (a[i] < c[i]) {
c[i] = a[i];
}
}
}
/*!
* c[i] = max(c[i], a[i]);
*
* Computes maximum values of x,y,z independently.
*/
void
lib3ds_vector_max(float c[3], float a[3]) {
int i;
for (i = 0; i < 3; ++i) {
if (a[i] > c[i]) {
c[i] = a[i];
}
}
}
void
lib3ds_vector_dump(float c[3]) {
fprintf(stderr, "%f %f %f\n", c[0], c[1], c[2]);
}

592
src/osgPlugins/3ds/lib3ds/lib3ds_viewport.c
View File

@@ -1,296 +1,296 @@
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
void
lib3ds_viewport_read(Lib3dsViewport *viewport, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
memset(viewport, 0, sizeof(*viewport));
lib3ds_chunk_read_start(&c, 0, io);
switch (c.chunk) {
case CHK_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 CHK_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 CHK_VIEWPORT_DATA_3: {
if (cur < LIB3DS_LAYOUT_MAX_VIEWS) {
lib3ds_io_read_intw(io);
viewport->layout_views[cur].axis_lock = lib3ds_io_read_word(io);
viewport->layout_views[cur].position[0] = lib3ds_io_read_intw(io);
viewport->layout_views[cur].position[1] = lib3ds_io_read_intw(io);
viewport->layout_views[cur].size[0] = lib3ds_io_read_intw(io);
viewport->layout_views[cur].size[1] = lib3ds_io_read_intw(io);
viewport->layout_views[cur].type = lib3ds_io_read_word(io);
viewport->layout_views[cur].zoom = lib3ds_io_read_float(io);
lib3ds_io_read_vector(io, viewport->layout_views[cur].center);
viewport->layout_views[cur].horiz_angle = lib3ds_io_read_float(io);
viewport->layout_views[cur].vert_angle = lib3ds_io_read_float(io);
lib3ds_io_read(io, viewport->layout_views[cur].camera, 11);
++cur;
}
break;
}
case CHK_VIEWPORT_DATA:
/* 3DS R2 & R3 chunk unsupported */
break;
default:
lib3ds_chunk_unknown(chunk, io);
}
}
break;
}
case CHK_DEFAULT_VIEW: {
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_VIEW_TOP: {
viewport->default_type = LIB3DS_VIEW_TOP;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_BOTTOM: {
viewport->default_type = LIB3DS_VIEW_BOTTOM;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_LEFT: {
viewport->default_type = LIB3DS_VIEW_LEFT;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_RIGHT: {
viewport->default_type = LIB3DS_VIEW_RIGHT;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_FRONT: {
viewport->default_type = LIB3DS_VIEW_FRONT;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_BACK: {
viewport->default_type = LIB3DS_VIEW_BACK;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_USER: {
viewport->default_type = LIB3DS_VIEW_USER;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
viewport->default_horiz_angle = lib3ds_io_read_float(io);
viewport->default_vert_angle = lib3ds_io_read_float(io);
viewport->default_roll_angle = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_CAMERA: {
viewport->default_type = LIB3DS_VIEW_CAMERA;
lib3ds_io_read(io, viewport->default_camera, 11);
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
}
break;
}
}
lib3ds_chunk_read_end(&c, io);
}
void
lib3ds_viewport_write(Lib3dsViewport *viewport, Lib3dsIo *io) {
if (viewport->layout_nviews) {
Lib3dsChunk c;
int i;
c.chunk = CHK_VIEWPORT_LAYOUT;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_word(io, (uint16_t)viewport->layout_style);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_active);
lib3ds_io_write_intw(io, (int16_t)0);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_swap);
lib3ds_io_write_intw(io, (int16_t)0);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_swap_prior);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_swap_view);
{
Lib3dsChunk c;
c.chunk = CHK_VIEWPORT_SIZE;
c.size = 14;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_intw(io, viewport->layout_position[0]);
lib3ds_io_write_intw(io, viewport->layout_position[1]);
lib3ds_io_write_intw(io, viewport->layout_size[0]);
lib3ds_io_write_intw(io, viewport->layout_size[1]);
}
for (i = 0; i < viewport->layout_nviews; ++i) {
Lib3dsChunk c;
c.chunk = CHK_VIEWPORT_DATA_3;
c.size = 55;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_intw(io, 0);
lib3ds_io_write_word(io, (uint16_t)viewport->layout_views[i].axis_lock);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_views[i].position[0]);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_views[i].position[1]);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_views[i].size[0]);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_views[i].size[1]);
lib3ds_io_write_word(io, (int16_t)viewport->layout_views[i].type);
lib3ds_io_write_float(io, viewport->layout_views[i].zoom);
lib3ds_io_write_vector(io, viewport->layout_views[i].center);
lib3ds_io_write_float(io, viewport->layout_views[i].horiz_angle);
lib3ds_io_write_float(io, viewport->layout_views[i].vert_angle);
lib3ds_io_write(io, viewport->layout_views[i].camera, 11);
}
lib3ds_chunk_write_end(&c, io);
}
if (viewport->default_type) {
Lib3dsChunk c;
c.chunk = CHK_DEFAULT_VIEW;
lib3ds_chunk_write_start(&c, io);
switch (viewport->default_type) {
case LIB3DS_VIEW_TOP: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_TOP;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_BOTTOM: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_BOTTOM;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_LEFT: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_LEFT;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_RIGHT: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_RIGHT;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_FRONT: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_FRONT;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_BACK: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_BACK;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_USER: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_USER;
c.size = 34;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
lib3ds_io_write_float(io, viewport->default_horiz_angle);
lib3ds_io_write_float(io, viewport->default_vert_angle);
lib3ds_io_write_float(io, viewport->default_roll_angle);
break;
}
case LIB3DS_VIEW_CAMERA: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_CAMERA;
c.size = 17;
lib3ds_chunk_write(&c, io);
lib3ds_io_write(io, viewport->default_camera, 11);
break;
}
}
lib3ds_chunk_write_end(&c, io);
}
}
/*
Copyright (C) 1996-2008 by Jan Eric Kyprianidis <www.kyprianidis.com>
All rights reserved.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
by the Free Software Foundation, either version 2.1 of the License, or
(at your option) any later version.
Thisprogram is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this program; If not, see <http://www.gnu.org/licenses/>.
*/
#include "lib3ds_impl.h"
void
lib3ds_viewport_read(Lib3dsViewport *viewport, Lib3dsIo *io) {
Lib3dsChunk c;
uint16_t chunk;
memset(viewport, 0, sizeof(*viewport));
lib3ds_chunk_read_start(&c, 0, io);
switch (c.chunk) {
case CHK_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 CHK_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 CHK_VIEWPORT_DATA_3: {
if (cur < LIB3DS_LAYOUT_MAX_VIEWS) {
lib3ds_io_read_intw(io);
viewport->layout_views[cur].axis_lock = lib3ds_io_read_word(io);
viewport->layout_views[cur].position[0] = lib3ds_io_read_intw(io);
viewport->layout_views[cur].position[1] = lib3ds_io_read_intw(io);
viewport->layout_views[cur].size[0] = lib3ds_io_read_intw(io);
viewport->layout_views[cur].size[1] = lib3ds_io_read_intw(io);
viewport->layout_views[cur].type = lib3ds_io_read_word(io);
viewport->layout_views[cur].zoom = lib3ds_io_read_float(io);
lib3ds_io_read_vector(io, viewport->layout_views[cur].center);
viewport->layout_views[cur].horiz_angle = lib3ds_io_read_float(io);
viewport->layout_views[cur].vert_angle = lib3ds_io_read_float(io);
lib3ds_io_read(io, viewport->layout_views[cur].camera, 11);
++cur;
}
break;
}
case CHK_VIEWPORT_DATA:
/* 3DS R2 & R3 chunk unsupported */
break;
default:
lib3ds_chunk_unknown(chunk, io);
}
}
break;
}
case CHK_DEFAULT_VIEW: {
while ((chunk = lib3ds_chunk_read_next(&c, io)) != 0) {
switch (chunk) {
case CHK_VIEW_TOP: {
viewport->default_type = LIB3DS_VIEW_TOP;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_BOTTOM: {
viewport->default_type = LIB3DS_VIEW_BOTTOM;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_LEFT: {
viewport->default_type = LIB3DS_VIEW_LEFT;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_RIGHT: {
viewport->default_type = LIB3DS_VIEW_RIGHT;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_FRONT: {
viewport->default_type = LIB3DS_VIEW_FRONT;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_BACK: {
viewport->default_type = LIB3DS_VIEW_BACK;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_USER: {
viewport->default_type = LIB3DS_VIEW_USER;
lib3ds_io_read_vector(io, viewport->default_position);
viewport->default_width = lib3ds_io_read_float(io);
viewport->default_horiz_angle = lib3ds_io_read_float(io);
viewport->default_vert_angle = lib3ds_io_read_float(io);
viewport->default_roll_angle = lib3ds_io_read_float(io);
break;
}
case CHK_VIEW_CAMERA: {
viewport->default_type = LIB3DS_VIEW_CAMERA;
lib3ds_io_read(io, viewport->default_camera, 11);
break;
}
default:
lib3ds_chunk_unknown(chunk, io);
}
}
break;
}
}
lib3ds_chunk_read_end(&c, io);
}
void
lib3ds_viewport_write(Lib3dsViewport *viewport, Lib3dsIo *io) {
if (viewport->layout_nviews) {
Lib3dsChunk c;
int i;
c.chunk = CHK_VIEWPORT_LAYOUT;
lib3ds_chunk_write_start(&c, io);
lib3ds_io_write_word(io, (uint16_t)viewport->layout_style);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_active);
lib3ds_io_write_intw(io, (int16_t)0);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_swap);
lib3ds_io_write_intw(io, (int16_t)0);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_swap_prior);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_swap_view);
{
Lib3dsChunk c;
c.chunk = CHK_VIEWPORT_SIZE;
c.size = 14;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_intw(io, viewport->layout_position[0]);
lib3ds_io_write_intw(io, viewport->layout_position[1]);
lib3ds_io_write_intw(io, viewport->layout_size[0]);
lib3ds_io_write_intw(io, viewport->layout_size[1]);
}
for (i = 0; i < viewport->layout_nviews; ++i) {
Lib3dsChunk c;
c.chunk = CHK_VIEWPORT_DATA_3;
c.size = 55;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_intw(io, 0);
lib3ds_io_write_word(io, (uint16_t)viewport->layout_views[i].axis_lock);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_views[i].position[0]);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_views[i].position[1]);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_views[i].size[0]);
lib3ds_io_write_intw(io, (int16_t)viewport->layout_views[i].size[1]);
lib3ds_io_write_word(io, (int16_t)viewport->layout_views[i].type);
lib3ds_io_write_float(io, viewport->layout_views[i].zoom);
lib3ds_io_write_vector(io, viewport->layout_views[i].center);
lib3ds_io_write_float(io, viewport->layout_views[i].horiz_angle);
lib3ds_io_write_float(io, viewport->layout_views[i].vert_angle);
lib3ds_io_write(io, viewport->layout_views[i].camera, 11);
}
lib3ds_chunk_write_end(&c, io);
}
if (viewport->default_type) {
Lib3dsChunk c;
c.chunk = CHK_DEFAULT_VIEW;
lib3ds_chunk_write_start(&c, io);
switch (viewport->default_type) {
case LIB3DS_VIEW_TOP: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_TOP;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_BOTTOM: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_BOTTOM;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_LEFT: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_LEFT;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_RIGHT: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_RIGHT;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_FRONT: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_FRONT;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_BACK: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_BACK;
c.size = 22;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
break;
}
case LIB3DS_VIEW_USER: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_USER;
c.size = 34;
lib3ds_chunk_write(&c, io);
lib3ds_io_write_vector(io, viewport->default_position);
lib3ds_io_write_float(io, viewport->default_width);
lib3ds_io_write_float(io, viewport->default_horiz_angle);
lib3ds_io_write_float(io, viewport->default_vert_angle);
lib3ds_io_write_float(io, viewport->default_roll_angle);
break;
}
case LIB3DS_VIEW_CAMERA: {
Lib3dsChunk c;
c.chunk = CHK_VIEW_CAMERA;
c.size = 17;
lib3ds_chunk_write(&c, io);
lib3ds_io_write(io, viewport->default_camera, 11);
break;
}
}
lib3ds_chunk_write_end(&c, io);
}
}