root/OpenSceneGraph/trunk/src/osgPlugins/3ds/node.cpp @ 10076

Revision 10076, 26.9 kB (checked in by robert, 6 years ago)

From Neil Hughes, converted across to use istream for reading data from file to enable reading .3ds files over http (use OSG's libcurl plugin).

From Robert Osfield, ammendments of the above to better support reading of files from local directories.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
RevLine 
[8]1/*
2 * The 3D Studio File Format Library
3 * Copyright (C) 1996-2001 by J.E. Hoffmann <je-h@gmx.net>
4 * All rights reserved.
5 *
6 * This program is  free  software;  you can redistribute it and/or modify it
[151]7 * under the terms of the  GNU Lesser General Public License  as published by
8 * the  Free Software Foundation;  either version 2.1 of the License,  or (at
[8]9 * your option) any later version.
10 *
11 * This  program  is  distributed in  the  hope that it will  be useful,  but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
[151]13 * or  FITNESS FOR A  PARTICULAR PURPOSE.  See the  GNU Lesser General Public 
[8]14 * License for more details.
15 *
16 * You should  have received  a copy of the GNU Lesser General Public License
17 * along with  this program;  if not, write to the  Free Software Foundation,
18 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 * $Id$
21 */
22#define LIB3DS_EXPORT
[1563]23#include "node.h"
24#include "file.h"
25#include "readwrite.h"
26#include "chunk.h"
27#include "matrix.h"
[8]28#include <stdlib.h>
29#include <string.h>
[151]30#include <math.h>
[1563]31#include "config.h"
[8]32#ifdef WITH_DMALLOC
33#include <dmalloc.h>
34#endif
35
[151]36
[8]37/*!
38 * \defgroup node Animation Nodes
39 *
40 * \author J.E. Hoffmann <je-h@gmx.net>
41 */
42
[151]43
[8]44/*!
45 * \ingroup node
46 */
47Lib3dsNode*
48lib3ds_node_new_ambient()
49{
[151]50  Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
51  node->type=LIB3DS_AMBIENT_NODE;
52  lib3ds_matrix_identity(node->matrix);
53  return(node);
[8]54}
55
56
57/*!
58 * \ingroup node
59 */
60Lib3dsNode*
61lib3ds_node_new_object()
62{
[151]63  Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
64  node->type=LIB3DS_OBJECT_NODE;
65  lib3ds_matrix_identity(node->matrix);
66  return(node);
[8]67}
68
69
70/*!
71 * \ingroup node
72 */
73Lib3dsNode*
74lib3ds_node_new_camera()
75{
[151]76  Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
77  node->type=LIB3DS_CAMERA_NODE;
78  lib3ds_matrix_identity(node->matrix);
79  return(node);
[8]80}
81
82
83/*!
84 * \ingroup node
85 */
86Lib3dsNode*
87lib3ds_node_new_target()
88{
[151]89  Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
90  node->type=LIB3DS_TARGET_NODE;
91  lib3ds_matrix_identity(node->matrix);
92  return(node);
[8]93}
94
95
96/*!
97 * \ingroup node
98 */
99Lib3dsNode*
100lib3ds_node_new_light()
101{
[151]102  Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
103  node->type=LIB3DS_LIGHT_NODE;
104  lib3ds_matrix_identity(node->matrix);
105  return(node);
[8]106}
107
108
109/*!
110 * \ingroup node
111 */
112Lib3dsNode*
113lib3ds_node_new_spot()
114{
[151]115  Lib3dsNode *node=(Lib3dsNode*)calloc(sizeof(Lib3dsNode), 1);
116  node->type=LIB3DS_SPOT_NODE;
117  lib3ds_matrix_identity(node->matrix);
118  return(node);
[8]119}
120
121
122static void
123free_node_and_childs(Lib3dsNode *node)
124{
[151]125  ASSERT(node);
126  switch (node->type) {
127    case LIB3DS_UNKNOWN_NODE:
128      break;
129    case LIB3DS_AMBIENT_NODE:
130      {
131        Lib3dsAmbientData *n=&node->data.ambient;
132        lib3ds_lin3_track_free_keys(&n->col_track);
133      }
134      break;
135    case LIB3DS_OBJECT_NODE:
136      {
137        Lib3dsObjectData *n=&node->data.object;
[8]138
[151]139        lib3ds_lin3_track_free_keys(&n->pos_track);
140        lib3ds_quat_track_free_keys(&n->rot_track);
141        lib3ds_lin3_track_free_keys(&n->scl_track);
142        lib3ds_bool_track_free_keys(&n->hide_track);
143        lib3ds_morph_track_free_keys(&n->morph_track);
144      }
145      break;
146    case LIB3DS_CAMERA_NODE:
147      {
148        Lib3dsCameraData *n=&node->data.camera;
149        lib3ds_lin3_track_free_keys(&n->pos_track);
150        lib3ds_lin1_track_free_keys(&n->fov_track);
151        lib3ds_lin1_track_free_keys(&n->roll_track);
152      }
153      break;
154    case LIB3DS_TARGET_NODE:
155      {
156        Lib3dsTargetData *n=&node->data.target;
157        lib3ds_lin3_track_free_keys(&n->pos_track);
158      }
159      break;
160    case LIB3DS_LIGHT_NODE:
161      {
162        Lib3dsLightData *n=&node->data.light;
163        lib3ds_lin3_track_free_keys(&n->pos_track);
164        lib3ds_lin3_track_free_keys(&n->col_track);
165        lib3ds_lin1_track_free_keys(&n->hotspot_track);
166        lib3ds_lin1_track_free_keys(&n->falloff_track);
167        lib3ds_lin1_track_free_keys(&n->roll_track);
168      }
169      break;
170    case LIB3DS_SPOT_NODE:
171      {
172        Lib3dsSpotData *n=&node->data.spot;
173        lib3ds_lin3_track_free_keys(&n->pos_track);
174      }
175      break;
176  }
177  {
178    Lib3dsNode *p,*q;
179    for (p=node->childs; p; p=q) {
180      q=p->next;
181      free_node_and_childs(p);
[8]182    }
[151]183  }
184  node->type=LIB3DS_UNKNOWN_NODE;
185  free(node);
[8]186}
187
188
189/*!
190 * \ingroup node
191 */
192void
193lib3ds_node_free(Lib3dsNode *node)
194{
[151]195  ASSERT(node);
196  free_node_and_childs(node);
[8]197}
198
199
200/*!
201 * \ingroup node
202 */
203void
204lib3ds_node_eval(Lib3dsNode *node, Lib3dsFloat t)
205{
[151]206  ASSERT(node);
207  switch (node->type) {
208    case LIB3DS_UNKNOWN_NODE:
209      {
210        ASSERT(LIB3DS_FALSE);
211      }
212      break;
213    case LIB3DS_AMBIENT_NODE:
214      {
215        Lib3dsAmbientData *n=&node->data.ambient;
216        if (node->parent) {
217          lib3ds_matrix_copy(node->matrix, node->parent->matrix);
[8]218        }
[151]219        else {
220          lib3ds_matrix_identity(node->matrix);
[8]221        }
[151]222        lib3ds_lin3_track_eval(&n->col_track, n->col, t);
223      }
224      break;
225    case LIB3DS_OBJECT_NODE:
226      {
227        Lib3dsMatrix M;
228        Lib3dsObjectData *n=&node->data.object;
[8]229
[151]230        lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
231        lib3ds_quat_track_eval(&n->rot_track, n->rot, t);
232        lib3ds_lin3_track_eval(&n->scl_track, n->scl, t);
233        lib3ds_bool_track_eval(&n->hide_track, &n->hide, t);
234        lib3ds_morph_track_eval(&n->morph_track, n->morph, t);
[8]235
[151]236        lib3ds_matrix_identity(M);
237        lib3ds_matrix_translate(M, n->pos);
238        lib3ds_matrix_rotate(M, n->rot);
239        lib3ds_matrix_scale(M, n->scl);
240       
241        if (node->parent) {
242          lib3ds_matrix_mul(node->matrix, node->parent->matrix, M);
[8]243        }
[151]244        else {
245          lib3ds_matrix_copy(node->matrix, M);
[8]246        }
[151]247      }
248      break;
249    case LIB3DS_CAMERA_NODE:
250      {
251        Lib3dsCameraData *n=&node->data.camera;
252        lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
253        lib3ds_lin1_track_eval(&n->fov_track, &n->fov, t);
254        lib3ds_lin1_track_eval(&n->roll_track, &n->roll, t);
255        if (node->parent) {
256          lib3ds_matrix_copy(node->matrix, node->parent->matrix);
[8]257        }
[151]258        else {
259          lib3ds_matrix_identity(node->matrix);
[8]260        }
[151]261        lib3ds_matrix_translate(node->matrix, n->pos);
262      }
263      break;
264    case LIB3DS_TARGET_NODE:
265      {
266        Lib3dsTargetData *n=&node->data.target;
267        lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
268        if (node->parent) {
269          lib3ds_matrix_copy(node->matrix, node->parent->matrix);
[8]270        }
[151]271        else {
272          lib3ds_matrix_identity(node->matrix);
[8]273        }
[151]274        lib3ds_matrix_translate(node->matrix, n->pos);
275      }
276      break;
277    case LIB3DS_LIGHT_NODE:
278      {
279        Lib3dsLightData *n=&node->data.light;
280        lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
281        lib3ds_lin3_track_eval(&n->col_track, n->col, t);
282        lib3ds_lin1_track_eval(&n->hotspot_track, &n->hotspot, t);
283        lib3ds_lin1_track_eval(&n->falloff_track, &n->falloff, t);
284        lib3ds_lin1_track_eval(&n->roll_track, &n->roll, t);
285        if (node->parent) {
286          lib3ds_matrix_copy(node->matrix, node->parent->matrix);
287        }
288        else {
289          lib3ds_matrix_identity(node->matrix);
290        }
291        lib3ds_matrix_translate(node->matrix, n->pos);
292      }
293      break;
294    case LIB3DS_SPOT_NODE:
295      {
296        Lib3dsSpotData *n=&node->data.spot;
297        lib3ds_lin3_track_eval(&n->pos_track, n->pos, t);
298        if (node->parent) {
299          lib3ds_matrix_copy(node->matrix, node->parent->matrix);
300        }
301        else {
302          lib3ds_matrix_identity(node->matrix);
303        }
304        lib3ds_matrix_translate(node->matrix, n->pos);
305      }
306      break;
307  }
308  {
309    Lib3dsNode *p;
310
311    for (p=node->childs; p!=0; p=p->next) {
312      lib3ds_node_eval(p, t);
[8]313    }
[151]314  }
[8]315}
316
317
318/*!
319 * \ingroup node
320 */
321Lib3dsNode*
322lib3ds_node_by_name(Lib3dsNode *node, const char* name, Lib3dsNodeTypes type)
323{
[151]324  Lib3dsNode *p,*q;
[8]325
[151]326  for (p=node->childs; p!=0; p=p->next) {
327    if ((p->type==type) && (strcmp(p->name, name)==0)) {
328      return(p);
[8]329    }
[151]330    q=lib3ds_node_by_name(p, name, type);
331    if (q) {
332      return(q);
333    }
334  }
335  return(0);
[8]336}
337
338
339/*!
340 * \ingroup node
341 */
342Lib3dsNode*
[151]343lib3ds_node_by_id(Lib3dsNode *node, Lib3dsWord node_id)
[8]344{
[151]345  Lib3dsNode *p,*q;
[8]346
[151]347  for (p=node->childs; p!=0; p=p->next) {
348    if (p->node_id==node_id) {
349      return(p);
[8]350    }
[151]351    q=lib3ds_node_by_id(p, node_id);
352    if (q) {
353      return(q);
354    }
355  }
356  return(0);
[8]357}
358
359
[151]360static const char* node_names_table[]= {
361  "***Unknown***",
362  "Ambient",
363  "Object",
364  "Camera",
365  "Target",
366  "Light",
367  "Spot"
[8]368};
369
[151]370
[8]371/*!
372 * \ingroup node
373 */
374void
375lib3ds_node_dump(Lib3dsNode *node, Lib3dsIntd level)
376{
[151]377  Lib3dsNode *p;
378  char l[128];
[8]379
[151]380  ASSERT(node);
381  memset(l, ' ', 2*level);
382  l[2*level]=0;
[8]383
[151]384  if (node->type==LIB3DS_OBJECT_NODE) {
385    printf("%s%s [%s] (%s)\n",
386      l,
387      node->name,
388      node->data.object.instance,
389      node_names_table[node->type]
390    );
391  }
392  else {
393    printf("%s%s (%s)\n",
394      l,
395      node->name,
396      node_names_table[node->type]
397    );
398  }
399 
400  for (p=node->childs; p!=0; p=p->next) {
401    lib3ds_node_dump(p, level+1);
402  }
[8]403}
404
405
406/*!
407 * \ingroup node
408 */
409Lib3dsBool
[10076]410lib3ds_node_read(Lib3dsNode *node, Lib3dsFile *, iostream *strm)
[8]411{
[151]412  Lib3dsChunk c;
413  Lib3dsWord chunk;
[8]414
[151]415  ASSERT(node);
[10076]416  if (!lib3ds_chunk_read_start(&c, 0, strm)) {
[151]417    return(LIB3DS_FALSE);
418  }
419  switch (c.chunk) {
420    case LIB3DS_AMBIENT_NODE_TAG:
421    case LIB3DS_OBJECT_NODE_TAG:
422    case LIB3DS_CAMERA_NODE_TAG:
423    case LIB3DS_TARGET_NODE_TAG:
424    case LIB3DS_LIGHT_NODE_TAG:
425    case LIB3DS_SPOTLIGHT_NODE_TAG:
426    case LIB3DS_L_TARGET_NODE_TAG:
427      break;
428    default:
429      return(LIB3DS_FALSE);
430  }
[8]431
[10076]432  while ((chunk=lib3ds_chunk_read_next(&c, strm))!=0) {
[151]433    switch (chunk) {
434      case LIB3DS_NODE_ID:
435        {
[10076]436          node->node_id=lib3ds_word_read(strm);
[151]437          lib3ds_chunk_dump_info("  ID = %d", (short)node->node_id);
438        }
439        break;
440      case LIB3DS_NODE_HDR:
441        {
[10076]442          if (!lib3ds_string_read(node->name, 64, strm)) {
[8]443            return(LIB3DS_FALSE);
[151]444          }
[10076]445          node->flags1=lib3ds_word_read(strm);
446          node->flags2=lib3ds_word_read(strm);
447          node->parent_id=lib3ds_word_read(strm);
[151]448          lib3ds_chunk_dump_info("  NAME =%s", node->name);
449          lib3ds_chunk_dump_info("  PARENT=%d", (short)node->parent_id);
450        }
451        break;
452      case LIB3DS_PIVOT:
[8]453        {
[151]454          if (node->type==LIB3DS_OBJECT_NODE) {
455            int i;
456            for (i=0; i<3; ++i) {
[10076]457              node->data.object.pivot[i]=lib3ds_float_read(strm);
[8]458            }
[151]459          }
460          else {
461            lib3ds_chunk_unknown(chunk);
462          }
463        }
464        break;
465      case LIB3DS_INSTANCE_NAME:
466        {
467          if (node->type==LIB3DS_OBJECT_NODE) {
[10076]468            if (!lib3ds_string_read(node->data.object.instance, 64, strm)) {
[151]469              return(LIB3DS_FALSE);
[8]470            }
[151]471          }
472          else {
473            lib3ds_chunk_unknown(chunk);
474          }
475        }
476        break;
477      case LIB3DS_BOUNDBOX:
478        {
479          if (node->type==LIB3DS_OBJECT_NODE) {
480            int i;
481            for (i=0; i<3; ++i) {
[10076]482              node->data.object.bbox_min[i]=lib3ds_float_read(strm);
[8]483            }
[151]484            for (i=0; i<3; ++i) {
[10076]485              node->data.object.bbox_max[i]=lib3ds_float_read(strm);
[8]486            }
[151]487          }
488          else {
489            lib3ds_chunk_unknown(chunk);
490          }
491        }
492        break;
493      case LIB3DS_COL_TRACK_TAG:
494        {
495          Lib3dsBool result=LIB3DS_TRUE;
496         
497          switch (node->type) {
498            case LIB3DS_AMBIENT_NODE:
[10076]499              result=lib3ds_lin3_track_read(&node->data.ambient.col_track, strm);
[151]500              break;
501            case LIB3DS_LIGHT_NODE:
[10076]502              result=lib3ds_lin3_track_read(&node->data.light.col_track, strm);
[151]503              break;
504            default:
505              lib3ds_chunk_unknown(chunk);
506          }
507          if (!result) {
508            return(LIB3DS_FALSE);
509          }
510        }
511        break;
512      case LIB3DS_POS_TRACK_TAG:
513        {
514          Lib3dsBool result=LIB3DS_TRUE;
[8]515
[151]516          switch (node->type) {
517            case LIB3DS_OBJECT_NODE:
[10076]518              result=lib3ds_lin3_track_read(&node->data.object.pos_track, strm);
[151]519              break;
520            case LIB3DS_CAMERA_NODE:
[10076]521              result=lib3ds_lin3_track_read(&node->data.camera.pos_track, strm);
[151]522              break;
523            case LIB3DS_TARGET_NODE:
[10076]524              result=lib3ds_lin3_track_read(&node->data.target.pos_track, strm);
[151]525              break;
526            case LIB3DS_LIGHT_NODE:
[10076]527              result=lib3ds_lin3_track_read(&node->data.light.pos_track, strm);
[151]528              break;
529            case LIB3DS_SPOT_NODE:
[10076]530              result=lib3ds_lin3_track_read(&node->data.spot.pos_track, strm);
[151]531              break;
532            default:
533              lib3ds_chunk_unknown(chunk);
534          }
535          if (!result) {
536            return(LIB3DS_FALSE);
537          }
538        }
539        break;
540      case LIB3DS_ROT_TRACK_TAG:
541        {
542          if (node->type==LIB3DS_OBJECT_NODE) {
[10076]543            if (!lib3ds_quat_track_read(&node->data.object.rot_track, strm)) {
[151]544              return(LIB3DS_FALSE);
[8]545            }
[151]546          }
547          else {
548            lib3ds_chunk_unknown(chunk);
549          }
550        }
551        break;
552      case LIB3DS_SCL_TRACK_TAG:
553        {
554          if (node->type==LIB3DS_OBJECT_NODE) {
[10076]555            if (!lib3ds_lin3_track_read(&node->data.object.scl_track, strm)) {
[151]556              return(LIB3DS_FALSE);
[8]557            }
[151]558          }
559          else {
560            lib3ds_chunk_unknown(chunk);
561          }
562        }
563        break;
564      case LIB3DS_FOV_TRACK_TAG:
565        {
566          if (node->type==LIB3DS_CAMERA_NODE) {
[10076]567            if (!lib3ds_lin1_track_read(&node->data.camera.fov_track, strm)) {
[151]568              return(LIB3DS_FALSE);
[8]569            }
[151]570          }
571          else {
572            lib3ds_chunk_unknown(chunk);
573          }
574        }
575        break;
576      case LIB3DS_HOT_TRACK_TAG:
577        {
578          if (node->type==LIB3DS_LIGHT_NODE) {
[10076]579            if (!lib3ds_lin1_track_read(&node->data.light.hotspot_track, strm)) {
[151]580              return(LIB3DS_FALSE);
[8]581            }
[151]582          }
583          else {
584            lib3ds_chunk_unknown(chunk);
585          }
586        }
587        break;
588      case LIB3DS_FALL_TRACK_TAG:
589        {
590          if (node->type==LIB3DS_LIGHT_NODE) {
[10076]591            if (!lib3ds_lin1_track_read(&node->data.light.falloff_track, strm)) {
[151]592              return(LIB3DS_FALSE);
[8]593            }
[151]594          }
595          else {
596            lib3ds_chunk_unknown(chunk);
597          }
598        }
599        break;
600      case LIB3DS_ROLL_TRACK_TAG:
601        {
602          Lib3dsBool result=LIB3DS_TRUE;
[8]603
[151]604          switch (node->type) {
605            case LIB3DS_CAMERA_NODE:
[10076]606              result=lib3ds_lin1_track_read(&node->data.camera.roll_track, strm);
[151]607              break;
608            case LIB3DS_LIGHT_NODE:
[10076]609              result=lib3ds_lin1_track_read(&node->data.light.roll_track, strm);
[151]610              break;
611            default:
612              lib3ds_chunk_unknown(chunk);
613          }
614          if (!result) {
615            return(LIB3DS_FALSE);
616          }
617        }
618        break;
619      case LIB3DS_HIDE_TRACK_TAG:
620        {
621          if (node->type==LIB3DS_OBJECT_NODE) {
[10076]622            if (!lib3ds_bool_track_read(&node->data.object.hide_track, strm)) {
[151]623              return(LIB3DS_FALSE);
[8]624            }
[151]625          }
626          else {
627            lib3ds_chunk_unknown(chunk);
628          }
629        }
630        break;
631      case LIB3DS_MORPH_SMOOTH:
632        {
633          if (node->type==LIB3DS_OBJECT_NODE) {
[10076]634            node->data.object.morph_smooth=lib3ds_float_read(strm);
[151]635          }
636          else {
637            lib3ds_chunk_unknown(chunk);
638          }
639        }
640        break;
641      case LIB3DS_MORPH_TRACK_TAG:
642        {
643          if (node->type==LIB3DS_OBJECT_NODE) {
[10076]644            if (!lib3ds_morph_track_read(&node->data.object.morph_track, strm)) {
[151]645              return(LIB3DS_FALSE);
[8]646            }
[151]647          }
648          else {
649            lib3ds_chunk_unknown(chunk);
650          }
[8]651        }
[151]652        break;
653      default:
654        lib3ds_chunk_unknown(chunk);
[8]655    }
[151]656  }
[8]657
[10076]658  lib3ds_chunk_read_end(&c, strm);
[151]659  return(LIB3DS_TRUE);
[8]660}
661
662
663/*!
664 * \ingroup node
665 */
666Lib3dsBool
[10076]667lib3ds_node_write(Lib3dsNode *node, Lib3dsFile *file, iostream *strm)
[8]668{
[151]669  Lib3dsChunk c;
670
671  switch (node->type) {
672    case LIB3DS_AMBIENT_NODE:
673      c.chunk=LIB3DS_AMBIENT_NODE_TAG;
674      break;
675    case LIB3DS_OBJECT_NODE:
676      c.chunk=LIB3DS_OBJECT_NODE_TAG;
677      break;
678    case LIB3DS_CAMERA_NODE:
679      c.chunk=LIB3DS_CAMERA_NODE_TAG;
680      break;
681    case LIB3DS_TARGET_NODE:
682      c.chunk=LIB3DS_TARGET_NODE_TAG;
683      break;
684    case LIB3DS_LIGHT_NODE:
685      if (lib3ds_file_node_by_name(file, node->name, LIB3DS_SPOT_NODE)) {
686        c.chunk=LIB3DS_SPOTLIGHT_NODE_TAG;
687      }
688      else {
689        c.chunk=LIB3DS_LIGHT_NODE_TAG;
690      }
691      break;
692    case LIB3DS_SPOT_NODE:
693      c.chunk=LIB3DS_L_TARGET_NODE_TAG;
694      break;
695    default:
696      return(LIB3DS_FALSE);
697  }
[10076]698  if (!lib3ds_chunk_write_start(&c,strm)) {
[151]699    return(LIB3DS_FALSE);
700  }
701
702  { /*---- LIB3DS_NODE_ID ----*/
[8]703    Lib3dsChunk c;
[151]704    c.chunk=LIB3DS_NODE_ID;
705    c.size=8;
[10076]706    lib3ds_chunk_write(&c,strm);
707    lib3ds_intw_write(node->node_id,strm);
[151]708  }
[8]709
[151]710  { /*---- LIB3DS_NODE_HDR ----*/
711    Lib3dsChunk c;
712    c.chunk=LIB3DS_NODE_HDR;
713    c.size=6+ 1+strlen(node->name) +2+2+2;
[10076]714    lib3ds_chunk_write(&c,strm);
715    lib3ds_string_write(node->name,strm);
716    lib3ds_word_write(node->flags1,strm);
717    lib3ds_word_write(node->flags2,strm);
718    lib3ds_word_write(node->parent_id,strm);
[151]719  }
[8]720
[151]721  switch (c.chunk) {
722    case LIB3DS_AMBIENT_NODE_TAG:
723      { /*---- LIB3DS_COL_TRACK_TAG ----*/
[8]724        Lib3dsChunk c;
[151]725        c.chunk=LIB3DS_COL_TRACK_TAG;
[10076]726        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]727          return(LIB3DS_FALSE);
728        }
[10076]729        if (!lib3ds_lin3_track_write(&node->data.ambient.col_track,strm)) {
[151]730          return(LIB3DS_FALSE);
731        }
[10076]732        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]733          return(LIB3DS_FALSE);
734        }
735      }
736      break;
737    case LIB3DS_OBJECT_NODE_TAG:
738      { /*---- LIB3DS_PIVOT ----*/
739        Lib3dsChunk c;
740        c.chunk=LIB3DS_PIVOT;
741        c.size=18;
[10076]742        lib3ds_chunk_write(&c,strm);
743        lib3ds_vector_write(node->data.object.pivot,strm);
[151]744      }
745      { /*---- LIB3DS_INSTANCE_NAME ----*/
746        Lib3dsChunk c;
747        const char *name;
748        if (strlen(node->data.object.instance)) {
749          name=node->data.object.instance;
[8]750
[151]751          c.chunk=LIB3DS_INSTANCE_NAME;
752          c.size=6+1+strlen(name);
[10076]753          lib3ds_chunk_write(&c,strm);
754          lib3ds_string_write(name,strm);
[151]755        }
756      }
757      {
758        int i;
759        for (i=0; i<3; ++i) {
760          if ((fabs(node->data.object.bbox_min[i])>LIB3DS_EPSILON) ||
761            (fabs(node->data.object.bbox_max[i])>LIB3DS_EPSILON)) {
762            break;
763          }
764        }
765       
766        if (i<3) { /*---- LIB3DS_BOUNDBOX ----*/
767          Lib3dsChunk c;
768          c.chunk=LIB3DS_BOUNDBOX;
769          c.size=30;
[10076]770          lib3ds_chunk_write(&c,strm);
771          lib3ds_vector_write(node->data.object.bbox_min, strm);
772          lib3ds_vector_write(node->data.object.bbox_max, strm);
[151]773        }
774      }
775      { /*---- LIB3DS_POS_TRACK_TAG ----*/
[8]776        Lib3dsChunk c;
[151]777        c.chunk=LIB3DS_POS_TRACK_TAG;
[10076]778        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]779          return(LIB3DS_FALSE);
780        }
[10076]781        if (!lib3ds_lin3_track_write(&node->data.object.pos_track,strm)) {
[151]782          return(LIB3DS_FALSE);
783        }
[10076]784        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]785          return(LIB3DS_FALSE);
786        }
787      }
788      { /*---- LIB3DS_ROT_TRACK_TAG ----*/
789        Lib3dsChunk c;
790        c.chunk=LIB3DS_ROT_TRACK_TAG;
[10076]791        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]792          return(LIB3DS_FALSE);
793        }
[10076]794        if (!lib3ds_quat_track_write(&node->data.object.rot_track,strm)) {
[151]795          return(LIB3DS_FALSE);
796        }
[10076]797        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]798          return(LIB3DS_FALSE);
799        }
800      }
801      { /*---- LIB3DS_SCL_TRACK_TAG ----*/
802        Lib3dsChunk c;
803        c.chunk=LIB3DS_SCL_TRACK_TAG;
[10076]804        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]805          return(LIB3DS_FALSE);
806        }
[10076]807        if (!lib3ds_lin3_track_write(&node->data.object.scl_track,strm)) {
[151]808          return(LIB3DS_FALSE);
809        }
[10076]810        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]811          return(LIB3DS_FALSE);
812        }
813      }
814      if (node->data.object.hide_track.keyL) { /*---- LIB3DS_HIDE_TRACK_TAG ----*/
815        Lib3dsChunk c;
816        c.chunk=LIB3DS_HIDE_TRACK_TAG;
[10076]817        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]818          return(LIB3DS_FALSE);
819        }
[10076]820        if (!lib3ds_bool_track_write(&node->data.object.hide_track,strm)) {
[151]821          return(LIB3DS_FALSE);
822        }
[10076]823        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]824          return(LIB3DS_FALSE);
825        }
826      }
827      if (fabs(node->data.object.morph_smooth)>LIB3DS_EPSILON){ /*---- LIB3DS_MORPH_SMOOTH ----*/
828        Lib3dsChunk c;
829        c.chunk=LIB3DS_MORPH_SMOOTH;
830        c.size=10;
[10076]831        lib3ds_chunk_write(&c,strm);
832        lib3ds_float_write(node->data.object.morph_smooth,strm);
[151]833      }
834      break;
835    case LIB3DS_CAMERA_NODE_TAG:
836      { /*---- LIB3DS_POS_TRACK_TAG ----*/
837        Lib3dsChunk c;
838        c.chunk=LIB3DS_POS_TRACK_TAG;
[10076]839        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]840          return(LIB3DS_FALSE);
[8]841        }
[10076]842        if (!lib3ds_lin3_track_write(&node->data.camera.pos_track,strm)) {
[151]843          return(LIB3DS_FALSE);
[8]844        }
[10076]845        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]846          return(LIB3DS_FALSE);
[8]847        }
[151]848      }
849      { /*---- LIB3DS_FOV_TRACK_TAG ----*/
850        Lib3dsChunk c;
851        c.chunk=LIB3DS_FOV_TRACK_TAG;
[10076]852        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]853          return(LIB3DS_FALSE);
[8]854        }
[10076]855        if (!lib3ds_lin1_track_write(&node->data.camera.fov_track,strm)) {
[151]856          return(LIB3DS_FALSE);
[8]857        }
[10076]858        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]859          return(LIB3DS_FALSE);
[8]860        }
[151]861      }
862      { /*---- LIB3DS_ROLL_TRACK_TAG ----*/
863        Lib3dsChunk c;
864        c.chunk=LIB3DS_ROLL_TRACK_TAG;
[10076]865        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]866          return(LIB3DS_FALSE);
[8]867        }
[10076]868        if (!lib3ds_lin1_track_write(&node->data.camera.roll_track,strm)) {
[151]869          return(LIB3DS_FALSE);
[8]870        }
[10076]871        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]872          return(LIB3DS_FALSE);
[8]873        }
[151]874      }
875      break;
876    case LIB3DS_TARGET_NODE_TAG:
877      { /*---- LIB3DS_POS_TRACK_TAG ----*/
878        Lib3dsChunk c;
879        c.chunk=LIB3DS_POS_TRACK_TAG;
[10076]880        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]881          return(LIB3DS_FALSE);
[8]882        }
[10076]883        if (!lib3ds_lin3_track_write(&node->data.target.pos_track,strm)) {
[151]884          return(LIB3DS_FALSE);
[8]885        }
[10076]886        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]887          return(LIB3DS_FALSE);
[8]888        }
[151]889      }
890      break;
891    case LIB3DS_LIGHT_NODE_TAG:
892      { /*---- LIB3DS_POS_TRACK_TAG ----*/
893        Lib3dsChunk c;
894        c.chunk=LIB3DS_POS_TRACK_TAG;
[10076]895        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]896          return(LIB3DS_FALSE);
[8]897        }
[10076]898        if (!lib3ds_lin3_track_write(&node->data.light.pos_track,strm)) {
[151]899          return(LIB3DS_FALSE);
[8]900        }
[10076]901        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]902          return(LIB3DS_FALSE);
[8]903        }
[151]904      }
905      { /*---- LIB3DS_COL_TRACK_TAG ----*/
906        Lib3dsChunk c;
907        c.chunk=LIB3DS_COL_TRACK_TAG;
[10076]908        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]909          return(LIB3DS_FALSE);
[8]910        }
[10076]911        if (!lib3ds_lin3_track_write(&node->data.light.col_track,strm)) {
[151]912          return(LIB3DS_FALSE);
[8]913        }
[10076]914        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]915          return(LIB3DS_FALSE);
[8]916        }
[151]917      }
918      break;
919    case LIB3DS_SPOTLIGHT_NODE_TAG:
920      { /*---- LIB3DS_POS_TRACK_TAG ----*/
921        Lib3dsChunk c;
922        c.chunk=LIB3DS_POS_TRACK_TAG;
[10076]923        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]924          return(LIB3DS_FALSE);
[8]925        }
[10076]926        if (!lib3ds_lin3_track_write(&node->data.light.pos_track,strm)) {
[151]927          return(LIB3DS_FALSE);
[8]928        }
[10076]929        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]930          return(LIB3DS_FALSE);
[8]931        }
[151]932      }
933      { /*---- LIB3DS_COL_TRACK_TAG ----*/
934        Lib3dsChunk c;
935        c.chunk=LIB3DS_COL_TRACK_TAG;
[10076]936        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]937          return(LIB3DS_FALSE);
938        }
[10076]939        if (!lib3ds_lin3_track_write(&node->data.light.col_track,strm)) {
[151]940          return(LIB3DS_FALSE);
941        }
[10076]942        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]943          return(LIB3DS_FALSE);
944        }
945      }
946      { /*---- LIB3DS_HOT_TRACK_TAG ----*/
947        Lib3dsChunk c;
948        c.chunk=LIB3DS_HOT_TRACK_TAG;
[10076]949        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]950          return(LIB3DS_FALSE);
951        }
[10076]952        if (!lib3ds_lin1_track_write(&node->data.light.hotspot_track,strm)) {
[151]953          return(LIB3DS_FALSE);
954        }
[10076]955        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]956          return(LIB3DS_FALSE);
957        }
958      }
959      { /*---- LIB3DS_FALL_TRACK_TAG ----*/
960        Lib3dsChunk c;
961        c.chunk=LIB3DS_FALL_TRACK_TAG;
[10076]962        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]963          return(LIB3DS_FALSE);
964        }
[10076]965        if (!lib3ds_lin1_track_write(&node->data.light.falloff_track,strm)) {
[151]966          return(LIB3DS_FALSE);
967        }
[10076]968        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]969          return(LIB3DS_FALSE);
970        }
971      }
972      { /*---- LIB3DS_ROLL_TRACK_TAG ----*/
973        Lib3dsChunk c;
974        c.chunk=LIB3DS_ROLL_TRACK_TAG;
[10076]975        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]976          return(LIB3DS_FALSE);
977        }
[10076]978        if (!lib3ds_lin1_track_write(&node->data.light.roll_track,strm)) {
[151]979          return(LIB3DS_FALSE);
980        }
[10076]981        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]982          return(LIB3DS_FALSE);
983        }
984      }
985      break;
986    case LIB3DS_L_TARGET_NODE_TAG:
987      { /*---- LIB3DS_POS_TRACK_TAG ----*/
988        Lib3dsChunk c;
989        c.chunk=LIB3DS_POS_TRACK_TAG;
[10076]990        if (!lib3ds_chunk_write_start(&c,strm)) {
[151]991          return(LIB3DS_FALSE);
992        }
[10076]993        if (!lib3ds_lin3_track_write(&node->data.spot.pos_track,strm)) {
[151]994          return(LIB3DS_FALSE);
995        }
[10076]996        if (!lib3ds_chunk_write_end(&c,strm)) {
[151]997          return(LIB3DS_FALSE);
998        }
999      }
1000      break;
1001    default:
1002      return(LIB3DS_FALSE);
1003  }
[8]1004
[10076]1005  if (!lib3ds_chunk_write_end(&c,strm)) {
[151]1006    return(LIB3DS_FALSE);
1007  }
1008  return(LIB3DS_TRUE);
[8]1009}
1010
1011
1012/*!
1013
1014\typedef Lib3dsNodeTypes
1015  \ingroup node
1016
1017*/
1018/*!
1019
1020\enum _Lib3dsNodeTypes
1021  \ingroup node
1022
1023*/
1024/*!
1025
1026\typedef Lib3dsBoolKey
1027  \ingroup node
1028  \sa _Lib3dsBoolKey
1029
1030*/
1031/*!
1032
1033\typedef Lib3dsBoolTrack
1034  \ingroup node
1035  \sa _Lib3dsBoolTrack
1036
1037*/
1038/*!
1039
1040\typedef Lib3dsLin1Key
1041  \ingroup node
1042  \sa _Lib3dsLin1Key
1043
1044*/
1045/*!
1046
1047\typedef Lib3dsLin1Track
1048  \ingroup node
1049  \sa _Lib3dsLin1Track
1050
1051*/
1052/*!
1053
1054\typedef Lib3dsLin3Key
1055  \ingroup node
1056  \sa _Lib3dsLin3Key
1057
1058*/
1059/*!
1060
1061\typedef Lib3dsLin3Track
1062  \ingroup node
1063  \sa _Lib3dsLin3Track
1064
1065*/
1066/*!
1067
1068\typedef Lib3dsQuatKey
1069  \ingroup node
1070  \sa _Lib3dsQuatKey
1071
1072*/
1073/*!
1074
1075\typedef Lib3dsQuatTrack
1076  \ingroup node
1077  \sa _Lib3dsLin3Key
1078
1079*/
1080/*!
1081
1082\typedef Lib3dsMorphKey
1083  \ingroup node
1084  \sa _Lib3dsMorphKey
1085
1086*/
1087/*!
1088
1089\typedef Lib3dsMorphTrack
1090  \ingroup node
1091  \sa _Lib3dsMorphTrack
1092
1093*/
[151]1094
Note: See TracBrowser for help on using the browser.