// Read a signed dword a from file stream in little endian format.
static int lib3ds_io_read_intd(Lib3dsIo io)
{
Debug.Assert(io != null);
byte[] b = new byte[4];
lib3ds_io_read(io, b, 4);
return((int)((b[3] << 23) | (b[2] << 16) | (b[1] << 8) | b[0]));
}
// Read a vector from a file stream in little endian format.
//
// \param io IO input handle.
// \param v The vector to store the data.
static void lib3ds_io_read_vector(Lib3dsIo io, float[] v)
{
Debug.Assert(io != null);
v[0] = lib3ds_io_read_float(io);
v[1] = lib3ds_io_read_float(io);
v[2] = lib3ds_io_read_float(io);
}
// Writes a vector into a file stream in little endian format.
static void lib3ds_io_write_vector(Lib3dsIo io, float[] v)
{
for (int i = 0; i < 3; i++)
{
lib3ds_io_write_float(io, v[i]);
}
}
// Read a signed byte from a file stream.
static sbyte lib3ds_io_read_intb(Lib3dsIo io)
{
Debug.Assert(io != null);
byte[] b = new byte[1];
lib3ds_io_read(io, b, 1);
return((sbyte)b[0]);
}
// Read a signed word from a file stream in little endian format.
static short lib3ds_io_read_intw(Lib3dsIo io)
{
Debug.Assert(io != null);
byte[] b = new byte[2];
lib3ds_io_read(io, b, 2);
return((short)((b[1] << 8) | b[0]));
}
// 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
public static void lib3ds_camera_read(Lib3dsCamera camera, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
Lib3dsChunks chunk;
lib3ds_chunk_read_start(c, Lib3dsChunks.CHK_N_CAMERA, io);
for(int i=0; i<3; i++) camera.position[i]=lib3ds_io_read_float(io);
for(int i=0; i<3; i++) camera.target[i]=lib3ds_io_read_float(io);
camera.roll=lib3ds_io_read_float(io);
float s=lib3ds_io_read_float(io);
if(Math.Abs(s)<EPSILON) camera.fov=45.0f;
else camera.fov=2400.0f/s;
lib3ds_chunk_read_tell(c, io);
while((chunk=lib3ds_chunk_read_next(c, io))!=0)
{
switch(chunk)
{
case Lib3dsChunks.CHK_CAM_SEE_CONE: camera.see_cone=true; break;
case Lib3dsChunks.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); break;
}
}
lib3ds_chunk_read_end(c, io);
}
// Read a byte from a file stream.
static byte lib3ds_io_read_byte(Lib3dsIo io)
{
Debug.Assert(io != null);
byte[] b = new byte[1];
lib3ds_io_read(io, b, 1);
return(b[0]);
}
static void lib3ds_io_read_vector(Lib3dsIo io, Lib3dsVertex v)
{
Debug.Assert(io != null);
v.x = lib3ds_io_read_float(io);
v.y = lib3ds_io_read_float(io);
v.z = lib3ds_io_read_float(io);
}
// Read a zero-terminated string from a file stream.
static string lib3ds_io_read_string(Lib3dsIo io, int buflen)
{
Debug.Assert(io != null);
byte[] c = new byte[1];
string s = "";
int k = 0;
for (; ;)
{
if (lib3ds_io_read(io, c, 1) != 1)
{
lib3ds_io_read_error(io);
}
if (c[0] == 0)
{
break;
}
s += (char)c[0];
k++;
if (k >= buflen)
{
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_ERROR, "Invalid string in input stream.");
}
}
return(s);
}
// Read a byte from a file stream.
static byte lib3ds_io_read_byte(Lib3dsIo io)
{
Debug.Assert(io!=null);
byte[] b=new byte[1];
lib3ds_io_read(io, b, 1);
return b[0];
}
static Lib3dsChunks lib3ds_chunk_read_next(Lib3dsChunk c, Lib3dsIo io)
{
Lib3dsChunk d = new Lib3dsChunk();
if (c.cur >= c.end)
{
Debug.Assert(c.cur == c.end);
return(0);
}
lib3ds_io_seek(io, (long)c.cur, Lib3dsIoSeek.LIB3DS_SEEK_SET);
d.chunk = (Lib3dsChunks)lib3ds_io_read_word(io);
d.size = lib3ds_io_read_dword(io);
c.cur += d.size;
if (io.log_func != null)
{
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_INFO, "{0} (0x{1:X}) size={2}", lib3ds_chunk_name(d.chunk), d.chunk, d.size);
}
if (c.cur > c.end)
{
if (io.log_func != null)
{
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_WARN, "***STOPPED READING - INVALID CHUNK SIZE***");
}
return(0);
}
return(d.chunk);
}
// Saves a .3DS file from memory to disk.
//
// \param file A pointer to a Lib3dsFile structure containing the
// the data that should be stored.
// \param filename The filename of the .3DS file to store the data in.
//
// \return true on success, false otherwise.
//
// \see lib3ds_file_open
public static bool lib3ds_file_save(Lib3dsFile file, string filename)
{
try
{
FileStream f = File.Create(filename);
try
{
Lib3dsIo io = new Lib3dsIo();
io.self = f;
io.seek_func = fileio_seek_func;
io.tell_func = fileio_tell_func;
io.read_func = fileio_read_func;
io.write_func = fileio_write_func;
io.log_func = null;
return(lib3ds_file_write(file, io));
}
finally
{
f.Close();
}
}
catch
{
return(false);
}
}
static void lib3ds_io_log(Lib3dsIo io, Lib3dsLogLevel level, string format, params object[] args)
{
Debug.Assert(io!=null);
if(io==null||io.log_func==null) return;
lib3ds_io_log_str(io, level, string.Format(format, args));
if(level==Lib3dsLogLevel.LIB3DS_LOG_ERROR) throw new Exception();
}
static void lib3ds_chunk_unknown(Lib3dsChunks chunk, Lib3dsIo io)
{
if (io.log_func != null)
{
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_WARN, "Unknown Chunk: {0} (0x{1:X})", lib3ds_chunk_name(chunk), chunk);
}
}
static void solid_bgnd_read(Lib3dsBackground background, Lib3dsIo io)
{
Lib3dsChunk c = new Lib3dsChunk();
Lib3dsChunks chunk;
bool have_lin = false;
lib3ds_chunk_read_start(c, Lib3dsChunks.CHK_SOLID_BGND, io);
while ((chunk = lib3ds_chunk_read_next(c, io)) != 0)
{
switch (chunk)
{
case Lib3dsChunks.CHK_LIN_COLOR_F:
lib3ds_io_read_rgb(io, background.solid_color);
have_lin = true;
break;
case Lib3dsChunks.CHK_COLOR_F:
lib3ds_io_read_rgb(io, background.solid_color);
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
lib3ds_chunk_read_end(c, io);
}
public static void lib3ds_background_read(Lib3dsBackground background, Lib3dsIo io)
{
Lib3dsChunk c = new Lib3dsChunk();
lib3ds_chunk_read(c, io);
switch (c.chunk)
{
case Lib3dsChunks.CHK_BIT_MAP: background.bitmap_name = lib3ds_io_read_string(io, 64); break;
case Lib3dsChunks.CHK_SOLID_BGND:
lib3ds_chunk_read_reset(c, io);
solid_bgnd_read(background, io);
break;
case Lib3dsChunks.CHK_V_GRADIENT:
lib3ds_chunk_read_reset(c, io);
v_gradient_read(background, io);
break;
case Lib3dsChunks.CHK_USE_BIT_MAP: background.use_bitmap = true; break;
case Lib3dsChunks.CHK_USE_SOLID_BGND: background.use_solid = true; break;
case Lib3dsChunks.CHK_USE_V_GRADIENT: background.use_gradient = true; break;
}
}
// Write 3ds file data from a Lib3dsFile object to a file.
//
// \param file The Lib3dsFile object to be written.
// \param io A Lib3dsIo object previously set up by the caller.
//
// \return true on success, false on failure.
public static bool lib3ds_file_write(Lib3dsFile file, Lib3dsIo io)
{
Lib3dsChunk c = new Lib3dsChunk();
lib3ds_io_setup(io);
try
{
c.chunk = Lib3dsChunks.CHK_M3DMAGIC;
lib3ds_chunk_write_start(c, io);
// ---- LIB3DS_M3D_VERSION ----
Lib3dsChunk c_version = new Lib3dsChunk();
c_version.chunk = Lib3dsChunks.CHK_M3D_VERSION;
c_version.size = 10;
lib3ds_chunk_write(c_version, io);
lib3ds_io_write_dword(io, file.mesh_version);
mdata_write(file, io);
kfdata_write(file, io);
lib3ds_chunk_write_end(c, io);
lib3ds_io_cleanup(io);
return(true);
}
catch
{
lib3ds_io_cleanup(io);
return(false);
}
}
static void lib3ds_io_write_rgb(Lib3dsIo io, float[] rgb)
{
for (int i = 0; i < 3; i++)
{
lib3ds_io_write_float(io, rgb[i]);
}
}
public static void lib3ds_light_read(Lib3dsLight light, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
Lib3dsChunks chunk;
lib3ds_chunk_read_start(c, Lib3dsChunks.CHK_N_DIRECT_LIGHT, io);
for(int 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 Lib3dsChunks.CHK_COLOR_F:
for(int i=0; i<3; i++) light.color[i]=lib3ds_io_read_float(io);
break;
case Lib3dsChunks.CHK_DL_OFF: light.off=true; break;
case Lib3dsChunks.CHK_DL_OUTER_RANGE: light.outer_range=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_DL_INNER_RANGE: light.inner_range=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_DL_MULTIPLIER: light.multiplier=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_DL_EXCLUDE: lib3ds_chunk_unknown(chunk, io); break; // FIXME:
case Lib3dsChunks.CHK_DL_ATTENUATE: light.attenuation=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_DL_SPOTLIGHT: lib3ds_chunk_read_reset(c, io); spotlight_read(light, io); break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
lib3ds_chunk_read_end(c, io);
}
static Lib3dsChunks lib3ds_chunk_read_next(Lib3dsChunk c, Lib3dsIo io)
{
Lib3dsChunk d=new Lib3dsChunk();
if(c.cur>=c.end)
{
Debug.Assert(c.cur==c.end);
return 0;
}
lib3ds_io_seek(io, (long)c.cur, Lib3dsIoSeek.LIB3DS_SEEK_SET);
d.chunk=(Lib3dsChunks)lib3ds_io_read_word(io);
d.size=lib3ds_io_read_dword(io);
c.cur+=d.size;
if(io.log_func!=null)
{
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_INFO, "{0} (0x{1:X}) size={2}", lib3ds_chunk_name(d.chunk), d.chunk, d.size);
}
if(c.cur>c.end)
{
if(io.log_func!=null)
{
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_WARN, "***STOPPED READING - INVALID CHUNK SIZE***");
}
return 0;
}
return d.chunk;
}
static void lib3ds_io_read_rgb(Lib3dsIo io, float[] rgb)
{
Debug.Assert(io != null);
rgb[0] = lib3ds_io_read_float(io);
rgb[1] = lib3ds_io_read_float(io);
rgb[2] = lib3ds_io_read_float(io);
}
// Read a float from a file stream in little endian format.
static float lib3ds_io_read_float(Lib3dsIo io)
{
Debug.Assert(io != null);
byte[] b = new byte[4];
lib3ds_io_read(io, b, 4);
return(BitConverter.ToSingle(b, 0));
}
// Read 3ds file data into a Lib3dsFile object.
//
// \param file The Lib3dsFile object to be filled.
// \param io A Lib3dsIo object previously set up by the caller.
//
// \return true on success, false on failure.
public static bool lib3ds_file_read(Lib3dsFile file, Lib3dsIo io)
{
Lib3dsChunk c = new Lib3dsChunk();
Lib3dsChunks chunk;
lib3ds_io_setup(io);
try
{
lib3ds_chunk_read_start(c, 0, io);
switch (c.chunk)
{
case Lib3dsChunks.CHK_MDATA:
lib3ds_chunk_read_reset(c, io);
mdata_read(file, io);
break;
case Lib3dsChunks.CHK_M3DMAGIC:
case Lib3dsChunks.CHK_MLIBMAGIC:
case Lib3dsChunks.CHK_CMAGIC:
while ((chunk = lib3ds_chunk_read_next(c, io)) != 0)
{
switch (chunk)
{
case Lib3dsChunks.CHK_M3D_VERSION:
file.mesh_version = lib3ds_io_read_dword(io);
break;
case Lib3dsChunks.CHK_MDATA:
lib3ds_chunk_read_reset(c, io);
mdata_read(file, io);
break;
case Lib3dsChunks.CHK_KFDATA:
lib3ds_chunk_read_reset(c, io);
kfdata_read(file, io);
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
break;
default:
lib3ds_chunk_unknown(c.chunk, io);
return(false);
}
lib3ds_chunk_read_end(c, io);
lib3ds_io_cleanup(io);
return(true);
}
catch
{
lib3ds_io_cleanup(io);
return(false);
}
}
static void lib3ds_chunk_read_start(Lib3dsChunk c, Lib3dsChunks chunk, Lib3dsIo io)
{
Debug.Assert(c!=null);
Debug.Assert(io!=null);
lib3ds_chunk_read(c, io);
if((chunk!=0)&&(c.chunk!=chunk)) lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_ERROR, "Unexpected chunk found.");
io.log_indent++;
}
static void lib3ds_chunk_write_start(Lib3dsChunk c, Lib3dsIo io)
{
Debug.Assert(c != null);
c.size = 0;
c.cur = (uint)lib3ds_io_tell(io);
lib3ds_io_write_word(io, (ushort)c.chunk);
lib3ds_io_write_dword(io, c.size);
}
// Writes a float into a little endian file stream.
static void lib3ds_io_write_float(Lib3dsIo io, float l)
{
Debug.Assert(io != null);
if (lib3ds_io_write(io, BitConverter.GetBytes(l), 4) != 4)
{
lib3ds_io_write_error(io);
}
}
public static void lib3ds_background_write(Lib3dsBackground background, Lib3dsIo io)
{
if (background.bitmap_name.Length > 0)
{ // ---- LIB3DS_BIT_MAP ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_BIT_MAP;
c.size = 6 + 1 + (uint)background.bitmap_name.Length;
lib3ds_chunk_write(c, io);
lib3ds_io_write_string(io, background.bitmap_name);
}
if (colorf_defined(background.solid_color))
{ // ---- LIB3DS_SOLID_BGND ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.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 = new Lib3dsChunk();
c.chunk = Lib3dsChunks.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 = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_USE_BIT_MAP;
c.size = 6;
lib3ds_chunk_write(c, io);
}
if (background.use_solid)
{ // ---- LIB3DS_USE_SOLID_BGND ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_USE_SOLID_BGND;
c.size = 6;
lib3ds_chunk_write(c, io);
}
if (background.use_gradient)
{ // ---- LIB3DS_USE_V_GRADIENT ----
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_USE_V_GRADIENT;
c.size = 6;
lib3ds_chunk_write(c, io);
}
}
static void v_gradient_read(Lib3dsBackground background, Lib3dsIo io)
{
Lib3dsChunk c = new Lib3dsChunk();
Lib3dsChunks chunk;
List <float[]> color = new List <float[]>();
List <float[]> lin_color = new List <float[]>();
bool have_lin = false;
lib3ds_chunk_read_start(c, Lib3dsChunks.CHK_V_GRADIENT, io);
background.gradient_percent = lib3ds_io_read_float(io);
lib3ds_chunk_read_tell(c, io);
while ((chunk = lib3ds_chunk_read_next(c, io)) != 0)
{
switch (chunk)
{
case Lib3dsChunks.CHK_COLOR_F:
{
float[] col = new float[3];
lib3ds_io_read_rgb(io, col);
color.Add(col);
}
break;
case Lib3dsChunks.CHK_LIN_COLOR_F:
{
float[] col = new float[3];
lib3ds_io_read_rgb(io, col);
lin_color.Add(col);
have_lin = true;
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
if (have_lin)
{
color = lin_color;
}
while (color.Count < 3)
{
color.Add(new float[3]);
}
for (int i = 0; i < 3; i++)
{
background.gradient_top[i] = color[0][i];
background.gradient_middle[i] = color[1][i];
background.gradient_bottom[i] = color[2][i];
}
lib3ds_chunk_read_end(c, io);
}
static void int_percentage_write(float p, Lib3dsIo io)
{
Lib3dsChunk c = new Lib3dsChunk();
c.chunk = Lib3dsChunks.CHK_INT_PERCENTAGE;
c.size = 8;
lib3ds_chunk_write(c, io);
lib3ds_io_write_intw(io, (byte)Math.Floor(100.0 * p + 0.5));
}
static void lib3ds_io_log_str(Lib3dsIo io, Lib3dsLogLevel level, string str)
{
Debug.Assert(io != null);
if (io == null || io.log_func == null)
{
return;
}
io.log_func(io.self, level, io.log_indent, str);
}
static int lib3ds_io_write(Lib3dsIo io, byte[] buffer, int size)
{
Debug.Assert(io != null);
if (io == null || io.write_func == null)
{
return(0);
}
return(io.write_func(io.self, buffer, size));
}
static long lib3ds_io_tell(Lib3dsIo io)
{
Debug.Assert(io != null);
if (io == null || io.tell_func == null)
{
return(0);
}
return(io.tell_func(io.self));
}
static void lib3ds_chunk_write_end(Lib3dsChunk c, Lib3dsIo io)
{
Debug.Assert(c != null);
c.size = (uint)lib3ds_io_tell(io) - c.cur;
lib3ds_io_seek(io, c.cur + 2, Lib3dsIoSeek.LIB3DS_SEEK_SET);
lib3ds_io_write_dword(io, c.size);
c.cur += c.size;
lib3ds_io_seek(io, c.cur, Lib3dsIoSeek.LIB3DS_SEEK_SET);
}
static long lib3ds_io_seek(Lib3dsIo io, long offset, Lib3dsIoSeek origin)
{
Debug.Assert(io != null);
if (io == null || io.seek_func == null)
{
return(0);
}
return(io.seek_func(io.self, offset, origin));
}
static void lib3ds_io_log_indent(Lib3dsIo io, int indent)
{
Debug.Assert(io != null);
if (io == null)
{
return;
}
io.log_indent += indent;
}
static void color_read(float[] rgb, Lib3dsIo io)
{
Lib3dsChunk c = new Lib3dsChunk();
Lib3dsChunks chunk;
bool have_lin = false;
lib3ds_chunk_read_start(c, 0, io);
while ((chunk = lib3ds_chunk_read_next(c, io)) != 0)
{
switch (chunk)
{
case Lib3dsChunks.CHK_LIN_COLOR_24:
for (int i = 0; i < 3; i++)
{
rgb[i] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
}
have_lin = true;
break;
case Lib3dsChunks.CHK_COLOR_24:
// gamma corrected color chunk
// replaced in 3ds R3 by LIN_COLOR_24
if (!have_lin)
{
for (int i = 0; i < 3; i++)
{
rgb[i] = 1.0f * lib3ds_io_read_byte(io) / 255.0f;
}
}
break;
case Lib3dsChunks.CHK_LIN_COLOR_F:
for (int i = 0; i < 3; i++)
{
rgb[i] = lib3ds_io_read_float(io);
}
have_lin = true;
break;
case Lib3dsChunks.CHK_COLOR_F:
if (!have_lin)
{
for (int i = 0; i < 3; i++)
{
rgb[i] = lib3ds_io_read_float(io);
}
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
lib3ds_chunk_read_end(c, io);
}
// 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.
static void lib3ds_chunk_read(Lib3dsChunk c, Lib3dsIo io)
{
Debug.Assert(c!=null);
Debug.Assert(io!=null);
c.cur=(uint)lib3ds_io_tell(io);
c.chunk=(Lib3dsChunks)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, Lib3dsLogLevel.LIB3DS_LOG_ERROR, "Invalid chunk header.");
}
public static void lib3ds_shadow_read(Lib3dsShadow shadow, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
lib3ds_chunk_read(c, io);
switch(c.chunk)
{
case Lib3dsChunks.CHK_SHADOW_MAP_SIZE: shadow.map_size=lib3ds_io_read_intw(io); break;
case Lib3dsChunks.CHK_LO_SHADOW_BIAS: shadow.low_bias=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_HI_SHADOW_BIAS: shadow.hi_bias=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_SHADOW_FILTER: shadow.filter=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_RAY_BIAS: shadow.ray_bias=lib3ds_io_read_float(io); break;
}
}
public static void lib3ds_shadow_write(Lib3dsShadow shadow, Lib3dsIo io)
{
if(Math.Abs(shadow.low_bias)>EPSILON)
{ // ---- CHK_LO_SHADOW_BIAS ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_LO_SHADOW_BIAS;
c.size=10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_float(io, shadow.low_bias);
}
if(Math.Abs(shadow.hi_bias)>EPSILON)
{ // ---- CHK_HI_SHADOW_BIAS ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_HI_SHADOW_BIAS;
c.size=10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_float(io, shadow.hi_bias);
}
if(shadow.map_size!=0)
{ // ---- CHK_SHADOW_MAP_SIZE ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_SHADOW_MAP_SIZE;
c.size=8;
lib3ds_chunk_write(c, io);
lib3ds_io_write_intw(io, shadow.map_size);
}
if(Math.Abs(shadow.filter)>EPSILON)
{ // ---- CHK_SHADOW_FILTER ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_SHADOW_FILTER;
c.size=10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_float(io, shadow.filter);
}
if(Math.Abs(shadow.ray_bias)>EPSILON)
{ // ---- CHK_RAY_BIAS ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_RAY_BIAS;
c.size=10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_float(io, shadow.ray_bias);
}
}
static void color_read(float[] rgb, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
Lib3dsChunks chunk;
bool have_lin=false;
lib3ds_chunk_read_start(c, 0, io);
while((chunk=lib3ds_chunk_read_next(c, io))!=0)
{
switch(chunk)
{
case Lib3dsChunks.CHK_LIN_COLOR_24:
for(int i=0; i<3; i++) rgb[i]=1.0f*lib3ds_io_read_byte(io)/255.0f;
have_lin=true;
break;
case Lib3dsChunks.CHK_COLOR_24:
// gamma corrected color chunk
// replaced in 3ds R3 by LIN_COLOR_24
if(!have_lin)
{
for(int i=0; i<3; i++) rgb[i]=1.0f*lib3ds_io_read_byte(io)/255.0f;
}
break;
case Lib3dsChunks.CHK_LIN_COLOR_F:
for(int i=0; i<3; i++) rgb[i]=lib3ds_io_read_float(io);
have_lin=true;
break;
case Lib3dsChunks.CHK_COLOR_F:
if(!have_lin)
{
for(int i=0; i<3; i++) rgb[i]=lib3ds_io_read_float(io);
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
lib3ds_chunk_read_end(c, io);
}
static void spotlight_read(Lib3dsLight light, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
Lib3dsChunks chunk;
lib3ds_chunk_read_start(c, Lib3dsChunks.CHK_DL_SPOTLIGHT, io);
light.spot_light=true;
for(int 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 Lib3dsChunks.CHK_DL_SPOT_ROLL: light.roll=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_DL_SHADOWED: light.shadowed=true; break;
case Lib3dsChunks.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 Lib3dsChunks.CHK_DL_SEE_CONE: light.see_cone=true; break;
case Lib3dsChunks.CHK_DL_SPOT_RECTANGULAR: light.rectangular_spot=true; break;
case Lib3dsChunks.CHK_DL_SPOT_ASPECT: light.spot_aspect=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_DL_SPOT_PROJECTOR:
light.use_projector=true;
light.projector=lib3ds_io_read_string(io, 64);
break;
case Lib3dsChunks.CHK_DL_SPOT_OVERSHOOT: light.spot_overshoot=true; break;
case Lib3dsChunks.CHK_DL_RAY_BIAS: light.ray_bias=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_DL_RAYSHAD: light.ray_shadows=true; break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
lib3ds_chunk_read_end(c, io);
}
public static void lib3ds_track_read(Lib3dsTrack track, Lib3dsIo io)
{
track.flags=(Lib3dsTrackFlags)lib3ds_io_read_word(io);
lib3ds_io_read_dword(io);
lib3ds_io_read_dword(io);
int nkeys=lib3ds_io_read_intd(io);
lib3ds_track_resize(track, nkeys);
switch(track.type)
{
case Lib3dsTrackType.LIB3DS_TRACK_BOOL:
for(int i=0; i<nkeys; i++)
{
track.keys[i].frame=lib3ds_io_read_intd(io);
tcb_read(track.keys[i], io);
}
break;
case Lib3dsTrackType.LIB3DS_TRACK_FLOAT:
for(int i=0; i<nkeys; i++)
{
track.keys[i].frame=lib3ds_io_read_intd(io);
tcb_read(track.keys[i], io);
track.keys[i].value[0]=lib3ds_io_read_float(io);
}
break;
case Lib3dsTrackType.LIB3DS_TRACK_VECTOR:
for(int i=0; i<nkeys; i++)
{
track.keys[i].frame=lib3ds_io_read_intd(io);
tcb_read(track.keys[i], io);
lib3ds_io_read_vector(io, track.keys[i].value);
}
break;
case Lib3dsTrackType.LIB3DS_TRACK_QUAT:
for(int i=0; i<nkeys; i++)
{
track.keys[i].frame=lib3ds_io_read_intd(io);
tcb_read(track.keys[i], io);
track.keys[i].value[3]=lib3ds_io_read_float(io);
lib3ds_io_read_vector(io, track.keys[i].value);
}
break;
//case Lib3dsTrackType.LIB3DS_TRACK_MORPH:
// for(int i=0; i<nkeys; i++)
// {
// track.keys[i].frame = lib3ds_io_read_intd(io);
// tcb_read(track.keys[i].tcb, io);
// lib3ds_io_read_string(io, track.keys[i].data.m.name, 64);
// }
// break;
}
}
static void tcb_read(Lib3dsKey key, Lib3dsIo io)
{
key.flags=(Lib3dsKeyFlags)lib3ds_io_read_word(io);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_TENS)!=0) key.tens=lib3ds_io_read_float(io);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_CONT)!=0) key.cont=lib3ds_io_read_float(io);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_BIAS)!=0) key.bias=lib3ds_io_read_float(io);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_EASE_TO)!=0) key.ease_to=lib3ds_io_read_float(io);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_EASE_FROM)!=0) key.ease_from=lib3ds_io_read_float(io);
}
static void named_object_read(Lib3dsFile file, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
string name;
Lib3dsChunks chunk;
Lib3dsMesh mesh=null;
Lib3dsCamera camera=null;
Lib3dsLight light=null;
Lib3dsObjectFlags object_flags=0;
lib3ds_chunk_read_start(c, Lib3dsChunks.CHK_NAMED_OBJECT, io);
name=lib3ds_io_read_string(io, 64);
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_INFO, "NAME={0}", name);
lib3ds_chunk_read_tell(c, io);
while((chunk=lib3ds_chunk_read_next(c, io))!=0)
{
switch(chunk)
{
case Lib3dsChunks.CHK_N_TRI_OBJECT:
mesh=lib3ds_mesh_new(name);
lib3ds_file_insert_mesh(file, mesh, -1);
lib3ds_chunk_read_reset(c, io);
lib3ds_mesh_read(file, mesh, io);
break;
case Lib3dsChunks.CHK_N_CAMERA:
camera=lib3ds_camera_new(name);
lib3ds_file_insert_camera(file, camera, -1);
lib3ds_chunk_read_reset(c, io);
lib3ds_camera_read(camera, io);
break;
case Lib3dsChunks.CHK_N_DIRECT_LIGHT:
light=lib3ds_light_new(name);
lib3ds_file_insert_light(file, light, -1);
lib3ds_chunk_read_reset(c, io);
lib3ds_light_read(light, io);
break;
case Lib3dsChunks.CHK_OBJ_HIDDEN: object_flags|=Lib3dsObjectFlags.LIB3DS_OBJECT_HIDDEN; break;
case Lib3dsChunks.CHK_OBJ_DOESNT_CAST: object_flags|=Lib3dsObjectFlags.LIB3DS_OBJECT_DOESNT_CAST; break;
case Lib3dsChunks.CHK_OBJ_VIS_LOFTER: object_flags|=Lib3dsObjectFlags.LIB3DS_OBJECT_VIS_LOFTER; break;
case Lib3dsChunks.CHK_OBJ_MATTE: object_flags|=Lib3dsObjectFlags.LIB3DS_OBJECT_MATTE; break;
case Lib3dsChunks.CHK_OBJ_DONT_RCVSHADOW: object_flags|=Lib3dsObjectFlags.LIB3DS_OBJECT_DONT_RCVSHADOW; break;
case Lib3dsChunks.CHK_OBJ_FAST: object_flags|=Lib3dsObjectFlags.LIB3DS_OBJECT_FAST; break;
case Lib3dsChunks.CHK_OBJ_FROZEN: object_flags|=Lib3dsObjectFlags.LIB3DS_OBJECT_FROZEN; break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
if(mesh!=null) mesh.object_flags=object_flags;
if(camera!=null) camera.object_flags=object_flags;
if(light!=null) light.object_flags=object_flags;
lib3ds_chunk_read_end(c, io);
}
static void ambient_read(Lib3dsFile file, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
Lib3dsChunks chunk;
bool have_lin=false;
lib3ds_chunk_read_start(c, Lib3dsChunks.CHK_AMBIENT_LIGHT, io);
while((chunk=lib3ds_chunk_read_next(c, io))!=0)
{
switch(chunk)
{
case Lib3dsChunks.CHK_LIN_COLOR_F:
for(int i=0; i<3; i++) file.ambient[i]=lib3ds_io_read_float(io);
have_lin=true;
break;
case Lib3dsChunks.CHK_COLOR_F:
// gamma corrected color chunk
// replaced in 3ds R3 by LIN_COLOR_24
if(!have_lin)
{
for(int i=0; i<3; i++) file.ambient[i]=lib3ds_io_read_float(io);
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
lib3ds_chunk_read_end(c, io);
}
static void mdata_read(Lib3dsFile file, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
Lib3dsChunks chunk;
lib3ds_chunk_read_start(c, Lib3dsChunks.CHK_MDATA, io);
while((chunk=lib3ds_chunk_read_next(c, io))!=0)
{
switch(chunk)
{
case Lib3dsChunks.CHK_MESH_VERSION: file.mesh_version=lib3ds_io_read_dword(io); break;
case Lib3dsChunks.CHK_MASTER_SCALE: file.master_scale=lib3ds_io_read_float(io); break;
case Lib3dsChunks.CHK_SHADOW_MAP_SIZE:
case Lib3dsChunks.CHK_LO_SHADOW_BIAS:
case Lib3dsChunks.CHK_HI_SHADOW_BIAS:
case Lib3dsChunks.CHK_SHADOW_SAMPLES:
case Lib3dsChunks.CHK_SHADOW_RANGE:
case Lib3dsChunks.CHK_SHADOW_FILTER:
case Lib3dsChunks.CHK_RAY_BIAS:
lib3ds_chunk_read_reset(c, io);
lib3ds_shadow_read(file.shadow, io);
break;
case Lib3dsChunks.CHK_VIEWPORT_LAYOUT:
case Lib3dsChunks.CHK_DEFAULT_VIEW:
lib3ds_chunk_read_reset(c, io);
lib3ds_viewport_read(file.viewport, io);
break;
case Lib3dsChunks.CHK_O_CONSTS:
for(int i=0; i<3; i++) file.construction_plane[i]=lib3ds_io_read_float(io);
break;
case Lib3dsChunks.CHK_AMBIENT_LIGHT:
lib3ds_chunk_read_reset(c, io);
ambient_read(file, io);
break;
case Lib3dsChunks.CHK_BIT_MAP:
case Lib3dsChunks.CHK_SOLID_BGND:
case Lib3dsChunks.CHK_V_GRADIENT:
case Lib3dsChunks.CHK_USE_BIT_MAP:
case Lib3dsChunks.CHK_USE_SOLID_BGND:
case Lib3dsChunks.CHK_USE_V_GRADIENT:
lib3ds_chunk_read_reset(c, io);
lib3ds_background_read(file.background, io);
break;
case Lib3dsChunks.CHK_FOG:
case Lib3dsChunks.CHK_LAYER_FOG:
case Lib3dsChunks.CHK_DISTANCE_CUE:
case Lib3dsChunks.CHK_USE_FOG:
case Lib3dsChunks.CHK_USE_LAYER_FOG:
case Lib3dsChunks.CHK_USE_DISTANCE_CUE:
lib3ds_chunk_read_reset(c, io);
lib3ds_atmosphere_read(file.atmosphere, io);
break;
case Lib3dsChunks.CHK_MAT_ENTRY:
Lib3dsMaterial material=lib3ds_material_new(null);
lib3ds_file_insert_material(file, material, -1);
lib3ds_chunk_read_reset(c, io);
lib3ds_material_read(material, io);
break;
case Lib3dsChunks.CHK_NAMED_OBJECT:
lib3ds_chunk_read_reset(c, io);
named_object_read(file, io);
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
lib3ds_chunk_read_end(c, io);
}
// Read 3ds file data into a Lib3dsFile object.
//
// \param file The Lib3dsFile object to be filled.
// \param io A Lib3dsIo object previously set up by the caller.
//
// \return true on success, false on failure.
public static bool lib3ds_file_read(Lib3dsFile file, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
Lib3dsChunks chunk;
lib3ds_io_setup(io);
try
{
lib3ds_chunk_read_start(c, 0, io);
switch(c.chunk)
{
case Lib3dsChunks.CHK_MDATA:
lib3ds_chunk_read_reset(c, io);
mdata_read(file, io);
break;
case Lib3dsChunks.CHK_M3DMAGIC:
case Lib3dsChunks.CHK_MLIBMAGIC:
case Lib3dsChunks.CHK_CMAGIC:
while((chunk=lib3ds_chunk_read_next(c, io))!=0)
{
switch(chunk)
{
case Lib3dsChunks.CHK_M3D_VERSION:
file.mesh_version=lib3ds_io_read_dword(io);
break;
case Lib3dsChunks.CHK_MDATA:
lib3ds_chunk_read_reset(c, io);
mdata_read(file, io);
break;
case Lib3dsChunks.CHK_KFDATA:
lib3ds_chunk_read_reset(c, io);
kfdata_read(file, io);
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
break;
default:
lib3ds_chunk_unknown(c.chunk, io);
return false;
}
lib3ds_chunk_read_end(c, io);
lib3ds_io_cleanup(io);
return true;
}
catch
{
lib3ds_io_cleanup(io);
return false;
}
}
public static void lib3ds_node_read(Lib3dsNode node, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
Lib3dsChunks chunk;
Debug.Assert(node!=null);
lib3ds_chunk_read_start(c, 0, io);
switch(c.chunk)
{
case Lib3dsChunks.CHK_AMBIENT_NODE_TAG:
case Lib3dsChunks.CHK_OBJECT_NODE_TAG:
case Lib3dsChunks.CHK_CAMERA_NODE_TAG:
case Lib3dsChunks.CHK_TARGET_NODE_TAG:
case Lib3dsChunks.CHK_LIGHT_NODE_TAG:
case Lib3dsChunks.CHK_SPOTLIGHT_NODE_TAG:
case Lib3dsChunks.CHK_L_TARGET_NODE_TAG: break;
default: return;
}
while((chunk=lib3ds_chunk_read_next(c, io))!=0)
{
switch(chunk)
{
case Lib3dsChunks.CHK_NODE_ID:
node.node_id=lib3ds_io_read_word(io);
node.hasNodeID=true;
lib3ds_io_log_indent(io, 1);
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_INFO, "ID={0}", node.node_id);
lib3ds_io_log_indent(io, -1);
break;
case Lib3dsChunks.CHK_NODE_HDR:
node.name=lib3ds_io_read_string(io, 64);
node.flags=lib3ds_io_read_dword(io);
node.parent_id=lib3ds_io_read_word(io);
lib3ds_io_log_indent(io, 1);
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_INFO, "NAME={0}", node.name);
lib3ds_io_log(io, Lib3dsLogLevel.LIB3DS_LOG_INFO, "PARENT={0}", (short)node.parent_id);
lib3ds_io_log_indent(io, -1);
break;
case Lib3dsChunks.CHK_PIVOT:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
lib3ds_io_read_vector(io, n.pivot);
}
else lib3ds_chunk_unknown(chunk, io);
break;
case Lib3dsChunks.CHK_INSTANCE_NAME:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
n.instance_name=lib3ds_io_read_string(io, 64);
}
else lib3ds_chunk_unknown(chunk, io);
break;
case Lib3dsChunks.CHK_BOUNDBOX:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
lib3ds_io_read_vector(io, n.bbox_min);
lib3ds_io_read_vector(io, n.bbox_max);
}
else lib3ds_chunk_unknown(chunk, io);
break;
case Lib3dsChunks.CHK_COL_TRACK_TAG:
{
Lib3dsTrack track=null;
switch(node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR:
{
Lib3dsAmbientColorNode n=(Lib3dsAmbientColorNode)node;
track=n.color_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT:
{
Lib3dsOmnilightNode n=(Lib3dsOmnilightNode)node;
track=n.color_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n=(Lib3dsSpotlightNode)node;
track=n.color_track;
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
if(track!=null) lib3ds_track_read(track, io);
}
break;
case Lib3dsChunks.CHK_POS_TRACK_TAG:
{
Lib3dsTrack track=null;
switch(node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE:
{
Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
track=n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA:
{
Lib3dsCameraNode n=(Lib3dsCameraNode)node;
track=n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET:
{
Lib3dsTargetNode n=(Lib3dsTargetNode)node;
track=n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT:
{
Lib3dsOmnilightNode n=(Lib3dsOmnilightNode)node;
track=n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n=(Lib3dsSpotlightNode)node;
track=n.pos_track;
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET:
{
Lib3dsTargetNode n=(Lib3dsTargetNode)node;
track=n.pos_track;
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
if(track!=null) lib3ds_track_read(track, io);
}
break;
case Lib3dsChunks.CHK_ROT_TRACK_TAG:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
n.rot_track.type=Lib3dsTrackType.LIB3DS_TRACK_QUAT;
lib3ds_track_read(n.rot_track, io);
}
else lib3ds_chunk_unknown(chunk, io);
break;
case Lib3dsChunks.CHK_SCL_TRACK_TAG:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
n.scl_track.type=Lib3dsTrackType.LIB3DS_TRACK_VECTOR;
lib3ds_track_read(n.scl_track, io);
}
else lib3ds_chunk_unknown(chunk, io);
break;
case Lib3dsChunks.CHK_FOV_TRACK_TAG:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_CAMERA)
{
Lib3dsCameraNode n=(Lib3dsCameraNode)node;
n.fov_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.fov_track, io);
}
else lib3ds_chunk_unknown(chunk, io);
break;
case Lib3dsChunks.CHK_HOT_TRACK_TAG:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT)
{
Lib3dsSpotlightNode n=(Lib3dsSpotlightNode)node;
n.hotspot_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.hotspot_track, io);
}
else lib3ds_chunk_unknown(chunk, io);
break;
case Lib3dsChunks.CHK_FALL_TRACK_TAG:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT)
{
Lib3dsSpotlightNode n=(Lib3dsSpotlightNode)node;
n.falloff_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.falloff_track, io);
}
else lib3ds_chunk_unknown(chunk, io);
break;
case Lib3dsChunks.CHK_ROLL_TRACK_TAG:
switch(node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_CAMERA:
{
Lib3dsCameraNode n=(Lib3dsCameraNode)node;
n.roll_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.roll_track, io);
}
break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT:
{
Lib3dsSpotlightNode n=(Lib3dsSpotlightNode)node;
n.roll_track.type=Lib3dsTrackType.LIB3DS_TRACK_FLOAT;
lib3ds_track_read(n.roll_track, io);
}
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
break;
case Lib3dsChunks.CHK_HIDE_TRACK_TAG:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
n.hide_track.type=Lib3dsTrackType.LIB3DS_TRACK_BOOL;
lib3ds_track_read(n.hide_track, io);
}
else lib3ds_chunk_unknown(chunk, io);
break;
case Lib3dsChunks.CHK_MORPH_SMOOTH:
if(node.type==Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
{
Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
n.morph_smooth=lib3ds_io_read_float(io);
}
else lib3ds_chunk_unknown(chunk, io);
break;
//case Lib3dsChunks.LIB3DS_MORPH_TRACK_TAG:
// if(node.type==Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE)
// {
// Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
// n.morph_track=lib3ds_track_new(node, LIB3DS_TRACK_MORPH, 0);
// lib3ds_track_read(n.morph_track, io);
// }
// else lib3ds_chunk_unknown(chunk, io);
// break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
lib3ds_chunk_read_end(c, io);
}
public static Lib3dsFile lib3ds_file_open(Stream stream, log_func log_func)
{
try
{
Lib3dsIo io=new Lib3dsIo();
io.self=stream;
io.seek_func=fileio_seek_func;
io.tell_func=fileio_tell_func;
io.read_func=fileio_read_func;
io.write_func=fileio_write_func;
io.log_func=log_func;
Lib3dsFile file=lib3ds_file_new();
if(file==null) return null;
if(!lib3ds_file_read(file, io)) return null;
return file;
}
catch
{
return null;
}
}
// Write 3ds file data from a Lib3dsFile object to a file.
//
// \param file The Lib3dsFile object to be written.
// \param io A Lib3dsIo object previously set up by the caller.
//
// \return true on success, false on failure.
public static bool lib3ds_file_write(Lib3dsFile file, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
lib3ds_io_setup(io);
try
{
c.chunk=Lib3dsChunks.CHK_M3DMAGIC;
lib3ds_chunk_write_start(c, io);
// ---- LIB3DS_M3D_VERSION ----
Lib3dsChunk c_version=new Lib3dsChunk();
c_version.chunk=Lib3dsChunks.CHK_M3D_VERSION;
c_version.size=10;
lib3ds_chunk_write(c_version, io);
lib3ds_io_write_dword(io, file.mesh_version);
mdata_write(file, io);
kfdata_write(file, io);
lib3ds_chunk_write_end(c, io);
lib3ds_io_cleanup(io);
return true;
}
catch
{
lib3ds_io_cleanup(io);
return false;
}
}
static void kfdata_write(Lib3dsFile file, Lib3dsIo io)
{
if(file.nodes.Count==0) return;
Lib3dsChunk c_kfdata=new Lib3dsChunk();
c_kfdata.chunk=Lib3dsChunks.CHK_KFDATA;
lib3ds_chunk_write_start(c_kfdata, io);
{ // ---- LIB3DS_KFHDR ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_KFHDR;
c.size=6+2+(uint)file.name.Length+1+4;
lib3ds_chunk_write(c, io);
lib3ds_io_write_intw(io, (short)file.keyf_revision);
lib3ds_io_write_string(io, file.name);
lib3ds_io_write_intd(io, file.frames);
}
{ // ---- LIB3DS_KFSEG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_KFSEG;
c.size=14;
lib3ds_chunk_write(c, io);
lib3ds_io_write_intd(io, file.segment_from);
lib3ds_io_write_intd(io, file.segment_to);
}
{ // ---- LIB3DS_KFCURTIME ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_KFCURTIME;
c.size=10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_intd(io, file.current_frame);
}
lib3ds_viewport_write(file.viewport_keyf, io);
ushort default_id=0;
nodes_write(file.nodes, ref default_id, 65535, io);
lib3ds_chunk_write_end(c_kfdata, io);
}
static void nodes_write(List<Lib3dsNode> nodes, ref ushort default_id, ushort parent_id, Lib3dsIo io)
{
foreach(Lib3dsNode p in nodes)
{
ushort node_id;
if((p.type==Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR)||(p.node_id!=65535)) node_id=p.node_id;
else node_id=default_id;
default_id++;
lib3ds_node_write(p, node_id, parent_id, io);
nodes_write(p.childs, ref default_id, node_id, io);
}
}
static void mdata_write(Lib3dsFile file, Lib3dsIo io)
{
Lib3dsChunk c_mdata=new Lib3dsChunk();
c_mdata.chunk=Lib3dsChunks.CHK_MDATA;
lib3ds_chunk_write_start(c_mdata, io);
{ // ---- LIB3DS_MESH_VERSION ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_MESH_VERSION;
c.size=10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_intd(io, (int)file.mesh_version);
}
{ // ---- LIB3DS_MASTER_SCALE ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_MASTER_SCALE;
c.size=10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_float(io, file.master_scale);
}
{ // ---- LIB3DS_O_CONSTS ----
int i;
for(i=0; i<3; i++) if(Math.Abs(file.construction_plane[i])>EPSILON) break;
if(i<3)
{
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_O_CONSTS;
c.size=18;
lib3ds_chunk_write(c, io);
lib3ds_io_write_vector(io, file.construction_plane);
}
}
{ // ---- LIB3DS_AMBIENT_LIGHT ----
int i;
for(i=0; i<3; i++) if(Math.Abs(file.ambient[i])>EPSILON) break;
if(i<3)
{
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_AMBIENT_LIGHT;
c.size=42;
lib3ds_chunk_write(c, io);
colorf_write(file.ambient, io);
}
}
lib3ds_background_write(file.background, io);
lib3ds_atmosphere_write(file.atmosphere, io);
lib3ds_shadow_write(file.shadow, io);
lib3ds_viewport_write(file.viewport, io);
{
foreach(Lib3dsMaterial material in file.materials) lib3ds_material_write(material, io);
}
{
Lib3dsChunk c=new Lib3dsChunk();
foreach(Lib3dsCamera camera in file.cameras)
{
c.chunk=Lib3dsChunks.CHK_NAMED_OBJECT;
lib3ds_chunk_write_start(c, io);
lib3ds_io_write_string(io, camera.name);
lib3ds_camera_write(camera, io);
object_flags_write(camera.object_flags, io);
lib3ds_chunk_write_end(c, io);
}
}
{
Lib3dsChunk c=new Lib3dsChunk();
foreach(Lib3dsLight light in file.lights)
{
c.chunk=Lib3dsChunks.CHK_NAMED_OBJECT;
lib3ds_chunk_write_start(c, io);
lib3ds_io_write_string(io, light.name);
lib3ds_light_write(light, io);
object_flags_write(light.object_flags, io);
lib3ds_chunk_write_end(c, io);
}
}
{
Lib3dsChunk c=new Lib3dsChunk();
foreach(Lib3dsMesh mesh in file.meshes)
{
c.chunk=Lib3dsChunks.CHK_NAMED_OBJECT;
lib3ds_chunk_write_start(c, io);
lib3ds_io_write_string(io, mesh.name);
lib3ds_mesh_write(file, mesh, io);
object_flags_write(mesh.object_flags, io);
lib3ds_chunk_write_end(c, io);
}
}
lib3ds_chunk_write_end(c_mdata, io);
}
static void object_flags_write(Lib3dsObjectFlags flags, Lib3dsIo io)
{
if(flags==0) return;
Lib3dsChunk c=new Lib3dsChunk();
c.size=6;
if((flags&Lib3dsObjectFlags.LIB3DS_OBJECT_HIDDEN)!=0)
{
c.chunk=Lib3dsChunks.CHK_OBJ_HIDDEN;
lib3ds_chunk_write(c, io);
}
if((flags&Lib3dsObjectFlags.LIB3DS_OBJECT_VIS_LOFTER)!=0)
{
c.chunk=Lib3dsChunks.CHK_OBJ_VIS_LOFTER;
lib3ds_chunk_write(c, io);
}
if((flags&Lib3dsObjectFlags.LIB3DS_OBJECT_DOESNT_CAST)!=0)
{
c.chunk=Lib3dsChunks.CHK_OBJ_DOESNT_CAST;
lib3ds_chunk_write(c, io);
}
if((flags&Lib3dsObjectFlags.LIB3DS_OBJECT_MATTE)!=0)
{
c.chunk=Lib3dsChunks.CHK_OBJ_MATTE;
lib3ds_chunk_write(c, io);
}
if((flags&Lib3dsObjectFlags.LIB3DS_OBJECT_DONT_RCVSHADOW)!=0)
{
c.chunk=Lib3dsChunks.CHK_OBJ_DOESNT_CAST;
lib3ds_chunk_write(c, io);
}
if((flags&Lib3dsObjectFlags.LIB3DS_OBJECT_FAST)!=0)
{
c.chunk=Lib3dsChunks.CHK_OBJ_FAST;
lib3ds_chunk_write(c, io);
}
if((flags&Lib3dsObjectFlags.LIB3DS_OBJECT_FROZEN)!=0)
{
c.chunk=Lib3dsChunks.CHK_OBJ_FROZEN;
lib3ds_chunk_write(c, io);
}
}
static void colorf_write(float[] rgb, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_COLOR_F;
c.size=18;
lib3ds_chunk_write(c, io);
lib3ds_io_write_rgb(io, rgb);
c.chunk=Lib3dsChunks.CHK_LIN_COLOR_F;
c.size=18;
lib3ds_chunk_write(c, io);
lib3ds_io_write_rgb(io, rgb);
}
public static void tcb_write(Lib3dsKey key, Lib3dsIo io)
{
lib3ds_io_write_word(io, (ushort)key.flags);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_TENS)!=0) lib3ds_io_write_float(io, key.tens);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_CONT)!=0) lib3ds_io_write_float(io, key.cont);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_BIAS)!=0) lib3ds_io_write_float(io, key.bias);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_EASE_TO)!=0) lib3ds_io_write_float(io, key.ease_to);
if((key.flags&Lib3dsKeyFlags.LIB3DS_KEY_USE_EASE_FROM)!=0) lib3ds_io_write_float(io, key.ease_from);
}
public static void lib3ds_track_write(Lib3dsTrack track, Lib3dsIo io)
{
lib3ds_io_write_word(io, (ushort)track.flags);
lib3ds_io_write_dword(io, 0);
lib3ds_io_write_dword(io, 0);
lib3ds_io_write_intd(io, track.keys.Count);
switch(track.type)
{
case Lib3dsTrackType.LIB3DS_TRACK_BOOL:
for(int i=0; i<track.keys.Count; i++)
{
lib3ds_io_write_intd(io, track.keys[i].frame);
tcb_write(track.keys[i], io);
}
break;
case Lib3dsTrackType.LIB3DS_TRACK_FLOAT:
for(int i=0; i<track.keys.Count; i++)
{
lib3ds_io_write_intd(io, track.keys[i].frame);
tcb_write(track.keys[i], io);
lib3ds_io_write_float(io, track.keys[i].value[0]);
}
break;
case Lib3dsTrackType.LIB3DS_TRACK_VECTOR:
for(int i=0; i<track.keys.Count; i++)
{
lib3ds_io_write_intd(io, track.keys[i].frame);
tcb_write(track.keys[i], io);
lib3ds_io_write_vector(io, track.keys[i].value);
}
break;
case Lib3dsTrackType.LIB3DS_TRACK_QUAT:
for(int i=0; i<track.keys.Count; i++)
{
lib3ds_io_write_intd(io, track.keys[i].frame);
tcb_write(track.keys[i], io);
lib3ds_io_write_float(io, track.keys[i].value[3]);
lib3ds_io_write_vector(io, track.keys[i].value);
}
break;
//case Lib3dsTrackType.LIB3DS_TRACK_MORPH:
// for(int i=0; i<track.keys.Count; i++)
// {
// lib3ds_io_write_intd(io, track.keys[i].frame);
// tcb_write(track.keys[i].tcb, io);
// lib3ds_io_write_string(io, track.keys[i].data.m.name);
// }
// break;
}
}
public static void lib3ds_light_write(Lib3dsLight light, Lib3dsIo io)
{
Lib3dsChunk c_n_direct_light=new Lib3dsChunk();
c_n_direct_light.chunk=Lib3dsChunks.CHK_N_DIRECT_LIGHT;
lib3ds_chunk_write_start(c_n_direct_light, io);
lib3ds_io_write_vector(io, light.position);
{ // ---- LIB3DS_COLOR_F ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.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=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_DL_OFF;
c.size=6;
lib3ds_chunk_write(c, io);
}
{ // ---- LIB3DS_DL_OUTER_RANGE ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.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=new Lib3dsChunk();
c.chunk=Lib3dsChunks.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=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_DL_MULTIPLIER;
c.size=10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_float(io, light.multiplier);
}
if(light.attenuation!=0)
{ // ---- LIB3DS_DL_ATTENUATE ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_DL_ATTENUATE;
c.size=6;
lib3ds_chunk_write(c, io);
}
if(light.spot_light)
{
Lib3dsChunk c_dl_spotlight=new Lib3dsChunk();
c_dl_spotlight.chunk=Lib3dsChunks.CHK_DL_SPOTLIGHT;
lib3ds_chunk_write_start(c_dl_spotlight, 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=new Lib3dsChunk();
c.chunk=Lib3dsChunks.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=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_DL_SHADOWED;
c.size=6;
lib3ds_chunk_write(c, io);
}
if((Math.Abs(light.shadow_bias)>EPSILON)||(Math.Abs(light.shadow_filter)>EPSILON)||(light.shadow_size!=0))
{ // ---- LIB3DS_DL_LOCAL_SHADOW2 ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.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, (short)light.shadow_size);
}
if(light.see_cone)
{ // ---- LIB3DS_DL_SEE_CONE ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_DL_SEE_CONE;
c.size=6;
lib3ds_chunk_write(c, io);
}
if(light.rectangular_spot)
{ // ---- LIB3DS_DL_SPOT_RECTANGULAR ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_DL_SPOT_RECTANGULAR;
c.size=6;
lib3ds_chunk_write(c, io);
}
if(Math.Abs(light.spot_aspect)>EPSILON)
{ // ---- LIB3DS_DL_SPOT_ASPECT ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.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=new Lib3dsChunk();
c.chunk=Lib3dsChunks.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=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_DL_SPOT_OVERSHOOT;
c.size=6;
lib3ds_chunk_write(c, io);
}
if(Math.Abs(light.ray_bias)>EPSILON)
{ // ---- LIB3DS_DL_RAY_BIAS ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.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=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_DL_RAYSHAD;
c.size=6;
lib3ds_chunk_write(c, io);
}
lib3ds_chunk_write_end(c_dl_spotlight, io);
}
lib3ds_chunk_write_end(c_n_direct_light, io);
}
public static void lib3ds_node_write(Lib3dsNode node, ushort node_id, ushort parent_id, Lib3dsIo io)
{
Lib3dsChunk c_node=new Lib3dsChunk();
switch(node.type)
{
case Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR: c_node.chunk=Lib3dsChunks.CHK_AMBIENT_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE: c_node.chunk=Lib3dsChunks.CHK_OBJECT_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA: c_node.chunk=Lib3dsChunks.CHK_CAMERA_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET: c_node.chunk=Lib3dsChunks.CHK_TARGET_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT: c_node.chunk=Lib3dsChunks.CHK_LIGHT_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT: c_node.chunk=Lib3dsChunks.CHK_SPOTLIGHT_NODE_TAG; break;
case Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET: c_node.chunk=Lib3dsChunks.CHK_L_TARGET_NODE_TAG; break;
default: Debug.Assert(false); return;
}
lib3ds_chunk_write_start(c_node, io);
{ // ---- CHK_NODE_ID ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_NODE_ID;
c.size=8;
lib3ds_chunk_write(c, io);
lib3ds_io_write_word(io, node_id);
}
{ // ---- CHK_NODE_HDR ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_NODE_HDR;
c.size=6+1+(uint)node.name.Length+2+2+2;
lib3ds_chunk_write(c, io);
lib3ds_io_write_string(io, node.name);
lib3ds_io_write_dword(io, node.flags);
lib3ds_io_write_word(io, parent_id);
}
switch(c_node.chunk)
{
case Lib3dsChunks.CHK_AMBIENT_NODE_TAG:
{
Lib3dsAmbientColorNode n=(Lib3dsAmbientColorNode)node;
if(n.color_track.keys.Count!=0)
{ // ---- CHK_COL_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_COL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.color_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_OBJECT_NODE_TAG:
{
Lib3dsMeshInstanceNode n=(Lib3dsMeshInstanceNode)node;
{ // ---- CHK_PIVOT ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_PIVOT;
c.size=18;
lib3ds_chunk_write(c, io);
lib3ds_io_write_vector(io, n.pivot);
}
if(n.instance_name.Length!=0)
{ // ---- CHK_INSTANCE_NAME ----
string name=n.instance_name;
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_INSTANCE_NAME;
c.size=6+1+(uint)name.Length;
lib3ds_chunk_write(c, io);
lib3ds_io_write_string(io, name);
}
{
int i=0;
for(i=0; i<3; i++)
{
if(Math.Abs(n.bbox_min[i])>EPSILON||Math.Abs(n.bbox_max[i])>EPSILON) break;
}
if(i<3)
{ // ---- CHK_BOUNDBOX ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_BOUNDBOX;
c.size=30;
lib3ds_chunk_write(c, io);
lib3ds_io_write_vector(io, n.bbox_min);
lib3ds_io_write_vector(io, n.bbox_max);
}
}
if(n.pos_track.keys.Count!=0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.rot_track.keys.Count!=0)
{ // ---- CHK_ROT_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_ROT_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.rot_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.scl_track.keys.Count!=0)
{ // ---- LIB3DS_SCL_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_SCL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.scl_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.hide_track.keys.Count!=0)
{ // ---- CHK_HIDE_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_HIDE_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.hide_track, io);
lib3ds_chunk_write_end(c, io);
}
if(Math.Abs(n.morph_smooth)>EPSILON)
{ // ---- CHK_MORPH_SMOOTH ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_MORPH_SMOOTH;
c.size=10;
lib3ds_chunk_write(c, io);
lib3ds_io_write_float(io, n.morph_smooth);
}
}
break;
case Lib3dsChunks.CHK_CAMERA_NODE_TAG:
{
Lib3dsCameraNode n=(Lib3dsCameraNode)node;
if(n.pos_track.keys.Count!=0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.fov_track.keys.Count!=0)
{ // ---- CHK_FOV_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_FOV_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.fov_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.roll_track.keys.Count!=0)
{ // ---- CHK_ROLL_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_ROLL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.roll_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_TARGET_NODE_TAG:
{
Lib3dsTargetNode n=(Lib3dsTargetNode)node;
if(n.pos_track.keys.Count!=0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_LIGHT_NODE_TAG:
{
Lib3dsOmnilightNode n=(Lib3dsOmnilightNode)node;
if(n.pos_track.keys.Count!=0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.color_track.keys.Count!=0)
{ // ---- CHK_COL_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_COL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.color_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_SPOTLIGHT_NODE_TAG:
{
Lib3dsSpotlightNode n=(Lib3dsSpotlightNode)node;
if(n.pos_track.keys.Count!=0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.color_track.keys.Count!=0)
{ // ---- CHK_COL_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_COL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.color_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.hotspot_track.keys.Count!=0)
{ // ---- CHK_HOT_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_HOT_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.hotspot_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.falloff_track.keys.Count!=0)
{ // ---- CHK_FALL_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_FALL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.falloff_track, io);
lib3ds_chunk_write_end(c, io);
}
if(n.roll_track.keys.Count!=0)
{ // ---- CHK_ROLL_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_ROLL_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.roll_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
case Lib3dsChunks.CHK_L_TARGET_NODE_TAG:
{
Lib3dsTargetNode n=(Lib3dsTargetNode)node;
if(n.pos_track.keys.Count!=0)
{ // ---- CHK_POS_TRACK_TAG ----
Lib3dsChunk c=new Lib3dsChunk();
c.chunk=Lib3dsChunks.CHK_POS_TRACK_TAG;
lib3ds_chunk_write_start(c, io);
lib3ds_track_write(n.pos_track, io);
lib3ds_chunk_write_end(c, io);
}
}
break;
}
lib3ds_chunk_write_end(c_node, io);
}
static void kfdata_read(Lib3dsFile file, Lib3dsIo io)
{
Lib3dsChunk c=new Lib3dsChunk();
Lib3dsChunks chunk;
lib3ds_chunk_read_start(c, Lib3dsChunks.CHK_KFDATA, io);
while((chunk=lib3ds_chunk_read_next(c, io))!=0)
{
switch(chunk)
{
case Lib3dsChunks.CHK_KFHDR:
file.keyf_revision=lib3ds_io_read_word(io);
file.name=lib3ds_io_read_string(io, 12+1);
file.frames=lib3ds_io_read_intd(io);
break;
case Lib3dsChunks.CHK_KFSEG:
file.segment_from=lib3ds_io_read_intd(io);
file.segment_to=lib3ds_io_read_intd(io);
break;
case Lib3dsChunks.CHK_KFCURTIME:
file.current_frame=lib3ds_io_read_intd(io);
break;
case Lib3dsChunks.CHK_VIEWPORT_LAYOUT:
case Lib3dsChunks.CHK_DEFAULT_VIEW:
lib3ds_chunk_read_reset(c, io);
lib3ds_viewport_read(file.viewport_keyf, io);
break;
case Lib3dsChunks.CHK_AMBIENT_NODE_TAG:
case Lib3dsChunks.CHK_OBJECT_NODE_TAG:
case Lib3dsChunks.CHK_CAMERA_NODE_TAG:
case Lib3dsChunks.CHK_TARGET_NODE_TAG:
case Lib3dsChunks.CHK_LIGHT_NODE_TAG:
case Lib3dsChunks.CHK_SPOTLIGHT_NODE_TAG:
case Lib3dsChunks.CHK_L_TARGET_NODE_TAG:
Lib3dsNodeType type;
switch(chunk)
{
case Lib3dsChunks.CHK_AMBIENT_NODE_TAG: type=Lib3dsNodeType.LIB3DS_NODE_AMBIENT_COLOR; break;
case Lib3dsChunks.CHK_OBJECT_NODE_TAG: type=Lib3dsNodeType.LIB3DS_NODE_MESH_INSTANCE; break;
case Lib3dsChunks.CHK_CAMERA_NODE_TAG: type=Lib3dsNodeType.LIB3DS_NODE_CAMERA; break;
case Lib3dsChunks.CHK_TARGET_NODE_TAG: type=Lib3dsNodeType.LIB3DS_NODE_CAMERA_TARGET; break;
case Lib3dsChunks.CHK_LIGHT_NODE_TAG: type=Lib3dsNodeType.LIB3DS_NODE_OMNILIGHT; break;
case Lib3dsChunks.CHK_SPOTLIGHT_NODE_TAG: type=Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT; break;
case Lib3dsChunks.CHK_L_TARGET_NODE_TAG: type=Lib3dsNodeType.LIB3DS_NODE_SPOTLIGHT_TARGET; break;
default: throw new Exception("Unknown chunk type.");
}
Lib3dsNode node=lib3ds_node_new(type);
file.nodes.Add(node);
lib3ds_chunk_read_reset(c, io);
lib3ds_node_read(node, io);
break;
default: lib3ds_chunk_unknown(chunk, io); break;
}
}
// fehlende Node IDs vergeben
List<Lib3dsNode> missingIDs=new List<Lib3dsNode>();
Dictionary<ushort, Lib3dsNode> hasIDs=new Dictionary<ushort, Lib3dsNode>();
foreach(Lib3dsNode node in file.nodes)
{
if(!node.hasNodeID) missingIDs.Add(node);
else if(!hasIDs.ContainsKey(node.node_id)) hasIDs.Add(node.node_id, node);
}
ushort num_nodes=0;
foreach(Lib3dsNode node in missingIDs)
{
while(hasIDs.ContainsKey(num_nodes))
{
num_nodes++;
if(num_nodes==65535) throw new Exception("Out of IDs.");
}
node.node_id=num_nodes;
node.hasNodeID=true;
hasIDs.Add(num_nodes, node);
num_nodes++;
if(num_nodes==65535) throw new Exception("Out of IDs.");
}
missingIDs.Clear();
foreach(Lib3dsNode node in file.nodes)
{
if(node.parent_id!=65535&&hasIDs.ContainsKey(node.parent_id))
{
Lib3dsNode parent=hasIDs[node.parent_id];
parent.childs.Add(node);
node.parent=parent;
}
}
lib3ds_chunk_read_end(c, io);
}
