root/OpenSceneGraph/branches/OpenSceneGraph-3.2/src/osgPlugins/lwo/lwo2parser.h @ 14038

Revision 14038, 29.5 kB (checked in by robert, 38 hours ago)

From Alberto Luaces,"the current code uses the preprocessor for generating the plugin path in
a way that when CMAKE_INSTALL_PREFIX contains something along the lines
of

/usr/x86_64-linux-gnu/

it gets substituted as

/usr/x86_64-1-gnu/

that is, the string is preprocessed again, thereby making changes to
anything that matches any defined symbol, as "linux" in this example
(https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=763816).

Quoting that path directly in CMake scripts solves that problem.
"

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*******************************************************
2      Lightwave Object Loader for OSG
3
4  Copyright (C) 2004 Marco Jez <marco.jez@poste.it>
5  OpenSceneGraph is (C) 2004 Robert Osfield
6********************************************************/
7
8#ifndef LWO2PARSER_
9#define LWO2PARSER_
10
11#include "iffparser.h"
12#include "lwo2chunks.h"
13#include "lwo2read.h"
14
15#include <stdexcept>
16#include <vector>
17
18namespace lwo2
19{
20
21    class parser_error: public std::runtime_error {
22    public:
23        parser_error(const std::string &message): std::runtime_error("[LWO2 parser error] " + message) {}
24    };
25
26    template<typename Iter>
27    class Parser: public iff::GenericParser<Iter> {
28    public:
29        Parser();
30        Parser(std::ostream &os);
31
32        virtual ~Parser();
33
34    protected:
35        virtual iff::Chunk *parse_chunk_data(const std::string &tag, const std::string &context, Iter it, Iter end);
36        iff::Chunk *parse_subchunk(Iter &it, const std::string &context);
37
38        Parser& operator = (const Parser&) { return *this; }
39    };
40
41
42    /////////////////////////////////////////////////////////////////////////
43    // IMPLEMENTATION OF TEMPLATE FUNCTIONS
44
45#    define LP_TMP    template<class Iter>
46
47    LP_TMP Parser<Iter>::Parser()
48        : iff::GenericParser<Iter>()
49    {
50    }
51
52    LP_TMP Parser<Iter>::Parser(std::ostream &os)
53        : iff::GenericParser<Iter>(os)
54    {
55    }
56
57    LP_TMP Parser<Iter>::~Parser()
58    {
59    }
60
61    LP_TMP iff::Chunk *Parser<Iter>::parse_chunk_data(const std::string &tag, const std::string &context, Iter it, Iter end)
62    {
63        // GLOBAL CONTEXT
64        if (context.empty()) {
65            if (tag == "FORM") {
66                FORM *chk = new FORM;
67                chk->type = read_ID4(it);
68                if (std::string(chk->type.id, 4) != "LWO2") {
69                    throw parser_error("invalid file format");
70                }
71                while (it < end)
72                    chk->data.push_back(this->parse_chunk(it, "FORM"));
73                return chk;
74            }
75        }
76
77        // FORM CONTEXT
78        if (context == "FORM") {
79
80            if (tag == "LAYR") {
81                FORM::LAYR *chk = new FORM::LAYR;
82                chk->number = read_U2(it);
83                chk->flags = read_U2(it);
84                chk->pivot = read_VEC12(it);
85                chk->name = read_S0(it);
86                if (it < end) {
87                    chk->parent = read_I2(it);
88                } else {
89                    chk->parent = -1;
90                }
91                return chk;
92            }
93
94            if (tag == "PNTS") {
95                FORM::PNTS *chk = new FORM::PNTS;
96                while (it < end) {
97                    chk->point_location.push_back(read_VEC12(it));
98                }
99                return chk;
100            }
101
102            if (tag == "VMAP") {
103                FORM::VMAP *chk = new FORM::VMAP;
104                chk->type = read_ID4(it);
105                chk->dimension = read_U2(it);
106                chk->name = read_S0(it);
107                while (it < end) {
108                    FORM::VMAP::mapping_type mp;
109                    mp.vert = read_VX(it);
110                    for (int i=0; i<chk->dimension; ++i) {
111                        mp.value.push_back(read_F4(it));
112                    }
113                    chk->mapping.push_back(mp);
114                }
115                return chk;
116            }
117
118            if (tag == "POLS") {
119                FORM::POLS *chk = new FORM::POLS;
120                chk->type = read_ID4(it);
121                while (it < end) {
122                    FORM::POLS::polygon_type pl;
123                    U2 nvf = read_U2(it);
124                    pl.flags = nvf >> 10;
125                    pl.numvert = nvf & 0x03FF;
126                    for (int i=0; i<pl.numvert; ++i)
127                        pl.vert.push_back(read_VX(it));
128                    chk->polygons.push_back(pl);
129                }
130                return chk;
131            }
132
133            if (tag == "TAGS") {
134                FORM::TAGS *chk = new FORM::TAGS;
135                while (it < end) {
136                    std::string tags = read_S0(it);
137                    chk->tag_string.push_back(tags);
138                }
139                return chk;
140            }
141
142            if (tag == "PTAG") {
143                FORM::PTAG *chk = new FORM::PTAG;
144                chk->type = read_ID4(it);
145                while (it < end) {
146                    FORM::PTAG::mapping_type mp;
147                    mp.poly = read_VX(it);
148                    mp.tag = read_U2(it);
149                    chk->mapping.push_back(mp);
150                }
151                return chk;
152            }
153
154            if (tag == "VMAD") {
155                FORM::VMAD *chk = new FORM::VMAD;
156                chk->type = read_ID4(it);
157                chk->dimension = read_U2(it);
158                chk->name = read_S0(it);
159                while (it < end) {
160                    FORM::VMAD::mapping_type mp;
161                    mp.vert = read_VX(it);
162                    mp.poly = read_VX(it);
163                    for (int i=0; i<chk->dimension; ++i)
164                        mp.value.push_back(read_F4(it));
165                    chk->mapping.push_back(mp);
166                }
167                return chk;
168            }
169
170            if (tag == "ENVL") {
171                FORM::ENVL *chk = new FORM::ENVL;
172                chk->index = read_VX(it);
173                while (it < end) {
174                    chk->attributes.push_back(parse_subchunk(it, "FORM::ENVL"));
175                }
176                return chk;
177            }
178
179            if (tag == "CLIP") {
180                FORM::CLIP *chk = new FORM::CLIP;
181                chk->index = read_U4(it);
182                while (it < end) {
183                    chk->attributes.push_back(parse_subchunk(it, "FORM::CLIP"));
184                }
185                return chk;
186            }
187
188            if (tag == "SURF") {
189                FORM::SURF *chk = new FORM::SURF;
190                chk->name = read_S0(it);
191                chk->source = read_S0(it);
192                while (it < end) {
193                    chk->attributes.push_back(parse_subchunk(it, "FORM::SURF"));
194                }
195                return chk;
196            }
197
198            if (tag == "BBOX") {
199                FORM::BBOX *chk = new FORM::BBOX;
200                chk->min = read_VEC12(it);
201                chk->max = read_VEC12(it);
202                return chk;
203            }
204
205            if (tag == "DESC") {
206                FORM::DESC *chk = new FORM::DESC;
207                chk->description_line = read_S0(it);
208                return chk;
209            }
210
211            if (tag == "TEXT") {
212                FORM::TEXT *chk = new FORM::TEXT;
213                chk->comment = read_S0(it);
214                return chk;
215            }
216
217            if (tag == "ICON") {
218                FORM::ICON *chk = new FORM::ICON;
219                chk->encoding = read_U2(it);
220                chk->width = read_U2(it);
221                while (it < end) chk->data.push_back(read_U1(it));
222                return chk;
223            }
224
225        }
226
227        // ENVELOPE CONTEXT
228        if (context == "FORM::ENVL") {
229
230            if (tag == "TYPE") {
231                FORM::ENVL::TYPE *chk = new FORM::ENVL::TYPE;
232                chk->user_format = read_U1(it);
233                chk->type = read_U1(it);
234                return chk;
235            }
236
237            if (tag == "PRE ") {
238                FORM::ENVL::PRE *chk = new FORM::ENVL::PRE;
239                chk->type = read_U2(it);
240                return chk;
241            }
242
243            if (tag == "POST") {
244                FORM::ENVL::POST *chk = new FORM::ENVL::POST;
245                chk->type = read_U2(it);
246                return chk;
247            }
248
249            if (tag == "KEY ") {
250                FORM::ENVL::KEY *chk = new FORM::ENVL::KEY;
251                chk->time = read_F4(it);
252                chk->value = read_F4(it);
253                return chk;
254            }
255
256            if (tag == "SPAN") {
257                FORM::ENVL::SPAN *chk = new FORM::ENVL::SPAN;
258                chk->type = read_ID4(it);
259                while (it < end) chk->parameters.push_back(read_F4(it));
260                return chk;
261            }
262
263            if (tag == "CHAN") {
264                FORM::ENVL::CHAN *chk = new FORM::ENVL::CHAN;
265                chk->server_name = read_S0(it);
266                chk->flags = read_U2(it);
267                while (it < end) chk->data.push_back(read_U1(it));
268                return chk;
269            }
270
271            if (tag == "NAME") {
272                FORM::ENVL::NAME *chk = new FORM::ENVL::NAME;
273                chk->channel_name = read_S0(it);
274                return chk;
275            }
276
277        }
278
279        // CLIP CONTEXT
280        if (context == "FORM::CLIP") {
281
282            if (tag == "STIL") {
283                FORM::CLIP::STIL *chk = new FORM::CLIP::STIL;
284                chk->name = read_FNAM0(it);
285                return chk;
286            }
287
288            if (tag == "ISEQ") {
289                FORM::CLIP::ISEQ *chk = new FORM::CLIP::ISEQ;
290                chk->num_digits = read_U1(it);
291                chk->flags = read_U1(it);
292                chk->offset = read_I2(it);
293                chk->reserved = read_U2(it);
294                chk->start = read_I2(it);
295                chk->end = read_I2(it);
296                chk->prefix = read_FNAM0(it);
297                chk->suffix = read_S0(it);
298                return chk;
299            }
300
301            if (tag == "ANIM") {
302                FORM::CLIP::ANIM *chk = new FORM::CLIP::ANIM;
303                chk->filename = read_FNAM0(it);
304                chk->server_name = read_S0(it);
305                chk->flags = read_U2(it);
306                while (it < end) chk->data.push_back(read_U1(it));
307                return chk;
308            }
309
310            if (tag == "XREF") {
311                FORM::CLIP::XREF *chk = new FORM::CLIP::XREF;
312                chk->index = read_U4(it);
313                chk->string = read_S0(it);
314                return chk;
315            }
316
317            if (tag == "STCC") {
318                FORM::CLIP::STCC *chk = new FORM::CLIP::STCC;
319                chk->lo = read_I2(it);
320                chk->hi = read_I2(it);
321                chk->name = read_FNAM0(it);
322            }
323
324            if (tag == "TIME") {
325                FORM::CLIP::TIME *chk = new FORM::CLIP::TIME;
326                chk->start_time = read_FP4(it);
327                chk->duration = read_FP4(it);
328                chk->frame_rate = read_FP4(it);
329                return chk;
330            }
331
332            if (tag == "CONT") {
333                FORM::CLIP::CONT *chk = new FORM::CLIP::CONT;
334                chk->contrast_delta = read_FP4(it);
335                chk->envelope = read_VX(it);
336                return chk;
337            }
338
339            if (tag == "BRIT") {
340                FORM::CLIP::BRIT *chk = new FORM::CLIP::BRIT;
341                chk->brightness_delta = read_FP4(it);
342                chk->envelope = read_VX(it);
343                return chk;
344            }
345
346            if (tag == "SATR") {
347                FORM::CLIP::SATR *chk = new FORM::CLIP::SATR;
348                chk->saturation_delta = read_FP4(it);
349                chk->envelope = read_VX(it);
350                return chk;
351            }
352
353            if (tag == "HUE ") {
354                FORM::CLIP::HUE *chk = new FORM::CLIP::HUE;
355                chk->hue_rotation = read_FP4(it);
356                chk->envelope = read_VX(it);
357                return chk;
358            }
359
360            if (tag == "GAMM") {
361                FORM::CLIP::GAMM *chk = new FORM::CLIP::GAMM;
362                chk->gamma = read_F4(it);
363                chk->envelope = read_VX(it);
364                return chk;
365            }
366
367            if (tag == "NEGA") {
368                FORM::CLIP::NEGA *chk = new FORM::CLIP::NEGA;
369                chk->enable = read_U2(it);
370                return chk;
371            }
372
373            if (tag == "IFLT") {
374                FORM::CLIP::IFLT *chk = new FORM::CLIP::IFLT;
375                chk->server_name = read_S0(it);
376                chk->flags = read_U2(it);
377                while (it < end) chk->data.push_back(read_U1(it));
378                return chk;
379            }
380
381            if (tag == "PFLT") {
382                FORM::CLIP::PFLT *chk = new FORM::CLIP::PFLT;
383                chk->server_name = read_S0(it);
384                chk->flags = read_U2(it);
385                while (it < end) chk->data.push_back(read_U1(it));
386                return chk;
387            }
388
389        }
390
391        // SURFACE CONTEXT
392        if (context == "FORM::SURF") {
393
394            if (tag == "COLR") {
395                FORM::SURF::COLR *chk = new FORM::SURF::COLR;
396                chk->base_color = read_COL12(it);
397                chk->envelope = read_VX(it);
398                return chk;
399            }
400
401            if (tag == "DIFF") {
402                FORM::SURF::DIFF *chk = new FORM::SURF::DIFF;
403                chk->intensity = read_FP4(it);
404                chk->envelope = read_VX(it);
405                return chk;
406            }
407
408            if (tag == "LUMI") {
409                FORM::SURF::LUMI *chk = new FORM::SURF::LUMI;
410                chk->intensity = read_FP4(it);
411                chk->envelope = read_VX(it);
412                return chk;
413            }
414
415            if (tag == "SPEC") {
416                FORM::SURF::SPEC *chk = new FORM::SURF::SPEC;
417                chk->intensity = read_FP4(it);
418                chk->envelope = read_VX(it);
419                return chk;
420            }
421
422            if (tag == "REFL") {
423                FORM::SURF::REFL *chk = new FORM::SURF::REFL;
424                chk->intensity = read_FP4(it);
425                chk->envelope = read_VX(it);
426                return chk;
427            }
428
429            if (tag == "TRAN") {
430                FORM::SURF::TRAN *chk = new FORM::SURF::TRAN;
431                chk->intensity = read_FP4(it);
432                chk->envelope = read_VX(it);
433                return chk;
434            }
435
436            if (tag == "TRNL") {
437                FORM::SURF::TRNL *chk = new FORM::SURF::TRNL;
438                chk->intensity = read_FP4(it);
439                chk->envelope = read_VX(it);
440                return chk;
441            }
442
443            if (tag == "GLOS") {
444                FORM::SURF::GLOS *chk = new FORM::SURF::GLOS;
445                chk->glossiness = read_FP4(it);
446                chk->envelope = read_VX(it);
447                return chk;
448            }
449
450            if (tag == "SHRP") {
451                FORM::SURF::SHRP *chk = new FORM::SURF::SHRP;
452                chk->sharpness = read_FP4(it);
453                chk->envelope = read_VX(it);
454                return chk;
455            }
456
457            if (tag == "BUMP") {
458                FORM::SURF::BUMP *chk = new FORM::SURF::BUMP;
459                chk->strength = read_FP4(it);
460                chk->envelope = read_VX(it);
461                return chk;
462            }
463
464            if (tag == "SIDE") {
465                FORM::SURF::SIDE *chk = new FORM::SURF::SIDE;
466                chk->sidedness = read_U2(it);
467                return chk;
468            }
469
470            if (tag == "SMAN") {
471                FORM::SURF::SMAN *chk = new FORM::SURF::SMAN;
472                chk->max_smoothing_angle = read_ANG4(it);
473                return chk;
474            }
475
476            if (tag == "RFOP") {
477                FORM::SURF::RFOP *chk = new FORM::SURF::RFOP;
478                chk->reflection_options = read_U2(it);
479                return chk;
480            }
481
482            if (tag == "RIMG") {
483                FORM::SURF::RIMG *chk = new FORM::SURF::RIMG;
484                chk->image = read_VX(it);
485                return chk;
486            }
487
488            if (tag == "RSAN") {
489                FORM::SURF::RSAN *chk = new FORM::SURF::RSAN;
490                chk->seam_angle = read_ANG4(it);
491                chk->envelope = read_VX(it);
492                return chk;
493            }
494
495            if (tag == "RBLR") {
496                FORM::SURF::RBLR *chk = new FORM::SURF::RBLR;
497                chk->blur_percentage = read_FP4(it);
498                chk->envelope = read_VX(it);
499                return chk;
500            }
501
502            if (tag == "RIND") {
503                FORM::SURF::RIND *chk = new FORM::SURF::RIND;
504                chk->refractive_index = read_F4(it);
505                chk->envelope = read_VX(it);
506                return chk;
507            }
508
509            if (tag == "TROP") {
510                FORM::SURF::TROP *chk = new FORM::SURF::TROP;
511                chk->transparency_options = read_U2(it);
512                return chk;
513            }
514
515            if (tag == "TIMG") {
516                FORM::SURF::TIMG *chk = new FORM::SURF::TIMG;
517                chk->image = read_VX(it);
518                return chk;
519            }
520
521            if (tag == "TBLR") {
522                FORM::SURF::TBLR *chk = new FORM::SURF::TBLR;
523                chk->blur_percentage = read_FP4(it);
524                chk->envelope = read_VX(it);
525                return chk;
526            }
527
528            if (tag == "CLRH") {
529                FORM::SURF::CLRH *chk = new FORM::SURF::CLRH;
530                chk->color_highlights = read_FP4(it);
531                chk->envelope = read_VX(it);
532                return chk;
533            }
534
535            if (tag == "CLRF") {
536                FORM::SURF::CLRF *chk = new FORM::SURF::CLRF;
537                chk->color_filter = read_FP4(it);
538                chk->envelope = read_VX(it);
539                return chk;
540            }
541
542            if (tag == "ADTR") {
543                FORM::SURF::ADTR *chk = new FORM::SURF::ADTR;
544                chk->additive = read_FP4(it);
545                chk->envelope = read_VX(it);
546                return chk;
547            }
548
549            if (tag == "GLOW") {
550                FORM::SURF::GLOW *chk = new FORM::SURF::GLOW;
551                chk->type = read_U2(it);
552                chk->intensity = read_F4(it);
553                chk->intensity_envelope = read_VX(it);
554                chk->size = read_F4(it);
555                chk->size_envelope = read_VX(it);
556                return chk;
557            }
558
559            if (tag == "LINE") {
560                FORM::SURF::LINE *chk = new FORM::SURF::LINE;
561                chk->flags = read_U2(it);
562                if (it < end) {
563                    chk->size = read_F4(it);
564                    chk->size_envelope = read_VX(it);
565                    if (it < end) {
566                        chk->color = read_COL12(it);
567                        chk->color_envelope = read_VX(it);
568                    }
569                }
570                return chk;
571            }
572
573            if (tag == "ALPH") {
574                FORM::SURF::ALPH *chk = new FORM::SURF::ALPH;
575                chk->mode = read_U2(it);
576                chk->value = read_FP4(it);
577                return chk;
578            }
579
580            if (tag == "VCOL") {
581                FORM::SURF::VCOL *chk = new FORM::SURF::VCOL;
582                chk->intensity = read_FP4(it);
583                chk->envelope = read_VX(it);
584                chk->vmap_type = read_ID4(it);
585                chk->name = read_S0(it);
586                return chk;
587            }
588
589            // surface blocks
590
591            if (tag == "BLOK") {
592                FORM::SURF::BLOK *chk = new FORM::SURF::BLOK;
593                std::string hid;
594                for (Iter tempit=it; tempit<(it+4); ++tempit) hid += *tempit;
595                chk->header = parse_subchunk(it, "FORM::SURF::BLOK");
596                while (it < end) {
597                    chk->attributes.push_back(parse_subchunk(it, "FORM::SURF::BLOK::" + hid));
598                }
599                return chk;
600            }
601
602        }
603
604        if (context == "FORM::SURF::BLOK") {    // block headers
605
606            if (tag == "IMAP") {
607                FORM::SURF::BLOK::IMAP *chk = new FORM::SURF::BLOK::IMAP;
608                chk->ordinal = read_S0(it);
609                while (it < end) {
610                    chk->block_attributes.push_back(parse_subchunk(it, "FORM::SURF::BLOK"));
611                }
612                return chk;
613            }
614
615            if (tag == "PROC") {
616                FORM::SURF::BLOK::PROC *chk = new FORM::SURF::BLOK::PROC;
617                chk->ordinal = read_S0(it);
618                while (it < end) {
619                    chk->block_attributes.push_back(parse_subchunk(it, "FORM::SURF::BLOK"));
620                }
621                return chk;
622            }
623
624            if (tag == "GRAD") {
625                FORM::SURF::BLOK::GRAD *chk = new FORM::SURF::BLOK::GRAD;
626                chk->ordinal = read_S0(it);
627                while (it < end) {
628                    chk->block_attributes.push_back(parse_subchunk(it, "FORM::SURF::BLOK"));
629                }
630                return chk;
631            }
632
633            if (tag == "SHDR") {
634                FORM::SURF::BLOK::SHDR *chk = new FORM::SURF::BLOK::SHDR;
635                chk->ordinal = read_S0(it);
636                while (it < end) {
637                    chk->block_attributes.push_back(parse_subchunk(it, "FORM::SURF::BLOK"));
638                }
639                return chk;
640            }
641
642        }
643
644        if (context == "FORM::SURF::BLOK") {    // attributes common to all block headers
645
646            if (tag == "CHAN") {
647                FORM::SURF::BLOK::CHAN *chk = new FORM::SURF::BLOK::CHAN;
648                chk->texture_channel = read_ID4(it);
649                return chk;
650            }
651
652            if (tag == "ENAB") {
653                FORM::SURF::BLOK::ENAB *chk = new FORM::SURF::BLOK::ENAB;
654                chk->enable = read_U2(it);
655                return chk;
656            }
657
658            if (tag == "OPAC") {
659                FORM::SURF::BLOK::OPAC *chk = new FORM::SURF::BLOK::OPAC;
660                chk->type = read_U2(it);
661                chk->opacity = read_FP4(it);
662                chk->envelope = read_VX(it);
663                return chk;
664            }
665
666            if (tag == "AXIS") {
667                FORM::SURF::BLOK::AXIS *chk = new FORM::SURF::BLOK::AXIS;
668                chk->displacement_axis = read_U2(it);
669                return chk;
670            }
671
672        }
673
674        if (context == "FORM::SURF::BLOK::IMAP" || context == "FORM::SURF::BLOK::PROC") {
675
676            if (tag == "TMAP") {
677                FORM::SURF::BLOK::IMAP::TMAP *chk = new FORM::SURF::BLOK::IMAP::TMAP;
678                while (it < end) chk->attributes.push_back(parse_subchunk(it, "FORM::SURF::BLOK::IMAP/PROC::TMAP"));
679                return chk;
680            }
681
682        }
683
684        if (context == "FORM::SURF::BLOK::IMAP/PROC::TMAP") {
685
686            if (tag == "CNTR") {
687                FORM::SURF::BLOK::IMAP::TMAP::CNTR *chk = new FORM::SURF::BLOK::IMAP::TMAP::CNTR;
688                chk->vector = read_VEC12(it);
689                chk->envelope = read_VX(it);
690                return chk;
691            }
692
693            if (tag == "SIZE") {
694                FORM::SURF::BLOK::IMAP::TMAP::SIZE *chk = new FORM::SURF::BLOK::IMAP::TMAP::SIZE;
695                chk->vector = read_VEC12(it);
696                chk->envelope = read_VX(it);
697                return chk;
698            }
699
700            if (tag == "ROTA") {
701                FORM::SURF::BLOK::IMAP::TMAP::ROTA *chk = new FORM::SURF::BLOK::IMAP::TMAP::ROTA;
702                chk->vector = read_VEC12(it);
703                chk->envelope = read_VX(it);
704                return chk;
705            }
706
707            if (tag == "OREF") {
708                FORM::SURF::BLOK::IMAP::TMAP::OREF *chk = new FORM::SURF::BLOK::IMAP::TMAP::OREF;
709                chk->object_name = read_S0(it);
710                return chk;
711            }
712
713            if (tag == "FALL") {
714                FORM::SURF::BLOK::IMAP::TMAP::FALL *chk = new FORM::SURF::BLOK::IMAP::TMAP::FALL;
715                chk->type = read_U2(it);
716                chk->vector = read_VEC12(it);
717                chk->envelope = read_VX(it);
718                return chk;
719            }
720
721            if (tag == "CSYS") {
722                FORM::SURF::BLOK::IMAP::TMAP::CSYS *chk = new FORM::SURF::BLOK::IMAP::TMAP::CSYS;
723                chk->type = read_U2(it);
724                return chk;
725            }
726
727        }
728
729        if (context == "FORM::SURF::BLOK::IMAP") {
730
731            if (tag == "PROJ") {
732                FORM::SURF::BLOK::IMAP::PROJ *chk = new FORM::SURF::BLOK::IMAP::PROJ;
733                chk->projection_mode = read_U2(it);
734                return chk;
735            }
736
737            if (tag == "AXIS") {
738                FORM::SURF::BLOK::IMAP::AXIS *chk = new FORM::SURF::BLOK::IMAP::AXIS;
739                chk->texture_axis = read_U2(it);
740                return chk;
741            }
742
743            if (tag == "IMAG") {
744                FORM::SURF::BLOK::IMAP::IMAG *chk = new FORM::SURF::BLOK::IMAP::IMAG;
745                chk->texture_image = read_VX(it);
746                return chk;
747            }
748
749            if (tag == "WRAP") {
750                FORM::SURF::BLOK::IMAP::WRAP *chk = new FORM::SURF::BLOK::IMAP::WRAP;
751                chk->width_wrap = read_U2(it);
752                chk->height_wrap = read_U2(it);
753                return chk;
754            }
755
756            if (tag == "WRPW") {
757                FORM::SURF::BLOK::IMAP::WRPW *chk = new FORM::SURF::BLOK::IMAP::WRPW;
758                chk->cycles = read_FP4(it);
759                chk->envelope = read_VX(it);
760                return chk;
761            }
762
763            if (tag == "WRPH") {
764                FORM::SURF::BLOK::IMAP::WRPH *chk = new FORM::SURF::BLOK::IMAP::WRPH;
765                chk->cycles = read_FP4(it);
766                chk->envelope = read_VX(it);
767                return chk;
768            }
769
770            if (tag == "VMAP") {
771                FORM::SURF::BLOK::IMAP::VMAP *chk = new FORM::SURF::BLOK::IMAP::VMAP;
772                chk->txuv_map_name = read_S0(it);
773                return chk;
774            }
775
776            if (tag == "AAST") {
777                FORM::SURF::BLOK::IMAP::AAST *chk = new FORM::SURF::BLOK::IMAP::AAST;
778                chk->flags = read_U2(it);
779                chk->antialiasing_strength = read_FP4(it);
780                return chk;
781            }
782
783            if (tag == "PIXB") {
784                FORM::SURF::BLOK::IMAP::PIXB *chk = new FORM::SURF::BLOK::IMAP::PIXB;
785                chk->flags = read_U2(it);
786                return chk;
787            }
788
789            if (tag == "STCK") {
790                FORM::SURF::BLOK::IMAP::STCK *chk = new FORM::SURF::BLOK::IMAP::STCK;
791                chk->on_off = read_U2(it);
792                chk->time = read_FP4(it);
793                return chk;
794            }
795
796            if (tag == "TAMP") {
797                FORM::SURF::BLOK::IMAP::TAMP *chk = new FORM::SURF::BLOK::IMAP::TAMP;
798                chk->amplitude = read_FP4(it);
799                chk->envelope = read_VX(it);
800                return chk;
801            }
802
803        }
804
805        if (context == "FORM::SURF::BLOK::PROC") {
806
807            if (tag == "AXIS") {
808                FORM::SURF::BLOK::PROC::AXIS *chk = new FORM::SURF::BLOK::PROC::AXIS;
809                chk->axis = read_U2(it);
810                return chk;
811            }
812
813            if (tag == "VALU") {
814                FORM::SURF::BLOK::PROC::VALU *chk = new FORM::SURF::BLOK::PROC::VALU;
815                while (it < end) chk->value.push_back(read_FP4(it));
816                return chk;
817            }
818
819            if (tag == "FUNC") {
820                FORM::SURF::BLOK::PROC::FUNC *chk = new FORM::SURF::BLOK::PROC::FUNC;
821                chk->algorithm_name = read_S0(it);
822                while (it < end) chk->data.push_back(read_U1(it));
823                return chk;
824            }
825
826        }
827
828        if (context == "FORM::SURF::BLOK::GRAD") {
829
830            if (tag == "PNAM") {
831                FORM::SURF::BLOK::GRAD::PNAM *chk = new FORM::SURF::BLOK::GRAD::PNAM;
832                chk->parameter = read_S0(it);
833                return chk;
834            }
835
836            if (tag == "INAM") {
837                FORM::SURF::BLOK::GRAD::INAM *chk = new FORM::SURF::BLOK::GRAD::INAM;
838                chk->item_name = read_S0(it);
839                return chk;
840            }
841
842            if (tag == "GRST") {
843                FORM::SURF::BLOK::GRAD::GRST *chk = new FORM::SURF::BLOK::GRAD::GRST;
844                chk->input_range = read_FP4(it);
845                return chk;
846            }
847
848            if (tag == "GREN") {
849                FORM::SURF::BLOK::GRAD::GREN *chk = new FORM::SURF::BLOK::GRAD::GREN;
850                chk->input_range = read_FP4(it);
851                return chk;
852            }
853
854            if (tag == "GRPT") {
855                FORM::SURF::BLOK::GRAD::GRPT *chk = new FORM::SURF::BLOK::GRAD::GRPT;
856                chk->repeat_mode = read_U2(it);
857                return chk;
858            }
859
860            if (tag == "FKEY") {
861                FORM::SURF::BLOK::GRAD::FKEY *chk = new FORM::SURF::BLOK::GRAD::FKEY;
862                while (it < end) {
863                    FORM::SURF::BLOK::GRAD::FKEY::value_type val;
864                    val.input = read_FP4(it);
865                    for (int i=0; i<4; ++i) val.output[i] = read_FP4(it);
866                    chk->values.push_back(val);
867                }
868                return chk;
869            }
870
871            if (tag == "IKEY") {
872                FORM::SURF::BLOK::GRAD::IKEY *chk = new FORM::SURF::BLOK::GRAD::IKEY;
873                while (it < end) chk->interpolation.push_back(read_U2(it));
874                return chk;
875            }
876
877        }
878
879        if (context == "FORM::SURF::BLOK::SHDR") {
880
881            if (tag == "FUNC") {
882                FORM::SURF::BLOK::SHDR::FUNC *chk = new FORM::SURF::BLOK::SHDR::FUNC;
883                chk->algorithm_name = read_S0(it);
884                while (it < end) chk->data.push_back(read_U1(it));
885                return chk;
886            }
887
888        }
889
890        return 0;
891    }
892
893    LP_TMP iff::Chunk *Parser<Iter>::parse_subchunk(Iter &it, const std::string &context)
894    {
895        std::string tag;
896        for (int i=0; i<4; ++i) tag += *(it++);
897
898        unsigned int len = ((static_cast<unsigned int>(*it) & 0xFF) << 8) | (static_cast<unsigned int>(*(it+1)) & 0xFF);
899        it += 2;
900
901        this->os() << "DEBUG INFO: lwo2parser: reading subchunk " << tag << ", length = " << len << ", context = " << context << "\n";
902        iff::Chunk *chk = parse_chunk_data(tag, context, it, it+len);
903        if (!chk) this->os() << "DEBUG INFO: lwo2parser: \tprevious subchunk not handled\n";
904        it += len;
905        if ((len % 2) != 0) ++it;
906        return chk;
907    }
908
909
910}
911
912#endif
Note: See TracBrowser for help on using the browser.