root/OpenSceneGraph/trunk/src/osgPlugins/txp/trpage_geom.cpp @ 12536

Revision 12536, 21.8 kB (checked in by robert, 3 years ago)

Replaced tabs with four spaces

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* ************************
2   Copyright Terrain Experts Inc.
3   Terrain Experts Inc (TERREX) reserves all rights to this source code
4   unless otherwise specified in writing by the President of TERREX.
5   This copyright may be updated in the future, in which case that version
6   supercedes this one.
7   -------------------
8   Terrex Experts Inc.
9   4400 East Broadway #314
10   Tucson, AZ  85711
11   info@terrex.com
12   Tel: (520) 323-7990
13   ************************
14   */
15
16/* trpage_geom.cpp
17    Methods for the trpgGeometry class.
18    This includes read and write methods.
19    You should only need to change something in here if you want to modify
20     what trpgGeometry contains.
21    */
22
23#include <stdlib.h>
24#include <stdio.h>
25#include <string.h>
26
27#include <trpage_geom.h>
28#include <trpage_read.h>
29
30#if defined(_WIN32)
31#define ALIGNMENT_WORKAROUND    false
32#else
33#define ALIGNMENT_WORKAROUND    true
34#endif
35
36// Constructor
37trpgGeometry::trpgGeometry()
38{
39    primType = Polygons;
40    normBind = Overall;
41    numPrim = 0;
42}
43trpgGeometry::~trpgGeometry()
44{
45}
46
47// Reset function
48void trpgGeometry::Reset()
49{
50    primType = Polygons;
51    numPrim = 0;
52    primLength.resize(0);
53    materials.resize(0);
54    vertDataFloat.resize(0);
55    vertDataDouble.resize(0);
56    normBind = Overall;
57    normDataFloat.resize(0);
58    normDataDouble.resize(0);
59    colors.resize(0);
60    texData.resize(0);
61    edgeFlags.resize(0);
62}
63
64// Set functions
65void trpgGeometry::SetPrimType(PrimType type)
66{
67    primType = type;
68}
69void trpgGeometry::SetPrimLengths(int num,const int *len)
70{
71    if (num < 0)
72        return;
73
74    numPrim = num;
75    for (int i=0;i<num;i++)
76        primLength.push_back(len[i]);
77}
78void trpgGeometry::AddPrimLength(int len)
79{
80    if (len < 0)
81        return;
82
83    numPrim++;
84    primLength.push_back(len);
85}
86void trpgGeometry::AddPrim()
87{
88    numPrim++;
89}
90void trpgGeometry::SetNumPrims(int num)
91{
92    numPrim = num;
93}
94void trpgGeometry::SetNumMaterial(int no)
95{
96    if (no < 0)
97        return;
98
99    materials.resize(no,-1);
100}
101void trpgGeometry::SetMaterial(int which,int mat,bool isLocal)
102{
103    if (which < 0 || which >= (int)materials.size())
104        return;
105
106    materials[which] = (isLocal ? -(mat+1) : mat);
107}
108void trpgGeometry::SetMaterials(int32 num,const int32 *mat)
109{
110    materials.resize(num);
111    for (int i=0;i<num;i++)
112        materials[i] = mat[i];
113}
114int trpgGeometry::AddMaterial(int mat)
115{
116    materials.push_back(mat);
117
118    return materials.size()-1;
119}
120
121// Geometry/color/normal/etc... set functions
122void trpgGeometry::SetVertices(int num,const float32 *data)
123{
124    if (num < 0)
125        return;
126
127    vertDataFloat.resize(0);
128    vertDataDouble.resize(0);
129    for (int i=0;i<3*num;i++)
130        vertDataFloat.push_back(data[i]);
131}
132void trpgGeometry::SetVertices(int num,const float64 *data)
133{
134    if (num < 0)
135        return;
136
137    vertDataFloat.resize(0);
138    vertDataDouble.resize(0);
139    for (int i=0;i<3*num;i++)
140        vertDataDouble.push_back(data[i]);
141}
142void trpgGeometry::AddVertex(DataType type,trpg3dPoint &pt)
143{
144    if (type == FloatData) {
145        vertDataFloat.push_back(static_cast<float>(pt.x));
146        vertDataFloat.push_back(static_cast<float>(pt.y));
147        vertDataFloat.push_back(static_cast<float>(pt.z));
148    } else {
149        vertDataDouble.push_back(pt.x);
150        vertDataDouble.push_back(pt.y);
151        vertDataDouble.push_back(pt.z);
152    }
153}
154void trpgGeometry::SetNormals(int num,BindType bind,const float32 *data)
155{
156    if (num < 0)
157        return;
158
159    normBind = bind;
160    normDataFloat.resize(0);
161    normDataDouble.resize(0);
162    for (int i=0;i<3*num;i++)
163        normDataFloat.push_back(data[i]);
164}
165void trpgGeometry::SetNormals(int num,BindType bind,const float64 *data)
166{
167    if (num <0)
168        return;
169
170    normBind = bind;
171    normDataFloat.resize(0);
172    normDataDouble.resize(0);
173    for (int i=0;i<3*num;i++)
174        normDataDouble.push_back(data[i]);
175}
176void trpgGeometry::AddNormal(DataType type,trpg3dPoint &pt)
177{
178    if (type == FloatData) {
179        normDataFloat.push_back(static_cast<float>(pt.x));
180        normDataFloat.push_back(static_cast<float>(pt.y));
181        normDataFloat.push_back(static_cast<float>(pt.z));
182    } else {
183        normDataDouble.push_back(pt.x);
184        normDataDouble.push_back(pt.y);
185        normDataDouble.push_back(pt.z);
186    }
187}
188// Constructor
189trpgColorInfo::trpgColorInfo()
190{
191}
192trpgColorInfo::~trpgColorInfo()
193{
194}
195void trpgColorInfo::Reset()
196{
197    bind = 0;
198    type = 0;
199    data.resize(0);
200}
201void trpgGeometry::SetColors(int num,ColorType type,BindType bind,const trpgColor *data)
202{
203    trpgColorInfo ci;
204
205    if (num < 0)
206        return;
207
208    // Set up color list
209    ci.type = type;
210    ci.bind = bind;
211    for (int i=0;i<num;i++)
212        ci.data.push_back(data[i]);
213
214    colors.push_back(ci);
215}
216// Constructor
217trpgTexData::trpgTexData()
218{
219}
220trpgTexData::~trpgTexData()
221{
222}
223void trpgTexData::set(int num,int in_bind,const float32 *data)
224{
225    bind = in_bind;
226    floatData.resize(0);
227    doubleData.resize(0);
228    for (int i=0;i<2*num;i++)
229        floatData.push_back(data[i]);
230}
231void trpgTexData::set(int num,int in_bind,const float64 *data)
232{
233    bind = in_bind;
234    floatData.resize(0);
235    doubleData.resize(0);
236    for (int i=0;i<2*num;i++)
237        doubleData.push_back(data[i]);
238}
239void trpgTexData::Reset()
240{
241    bind = 0;
242    floatData.resize(0);
243    doubleData.resize(0);
244}
245
246void trpgGeometry::SetTexCoords(int num,BindType bind,const float32 *data)
247{
248    if (num < 0)
249        return;
250
251    trpgTexData td;
252    td.set(num,bind,data);
253    texData.push_back(td);
254}
255void trpgGeometry::SetTexCoords(int num,BindType bind,const float64 *data)
256{
257    if (num < 0)
258        return;
259
260    trpgTexData td;
261    td.set(num,bind,data);
262    texData.push_back(td);
263}
264void trpgGeometry::AddTexCoord(DataType type,trpg2dPoint &pt, int n)
265{
266    if ((n<0) || (n >= (int)texData.size()))
267        return;
268    trpgTexData *td = &texData[n];
269
270    if (type == FloatData) {
271        td->floatData.push_back(static_cast<float>(pt.x));
272        td->floatData.push_back(static_cast<float>(pt.y));
273    } else {
274        td->doubleData.push_back(pt.x);
275        td->doubleData.push_back(pt.y);
276    }
277}
278void trpgGeometry::AddTexCoord(DataType type,std::vector<trpg2dPoint> &pts)
279{
280    if (texData.size() != pts.size())
281        return;
282
283    for (unsigned int loop = 0; loop < pts.size(); loop++ ) {
284        trpgTexData *td = &texData[loop];
285
286        if (type == FloatData) {
287            td->floatData.push_back(static_cast<float>(pts[loop].x));
288            td->floatData.push_back(static_cast<float>(pts[loop].y));
289        } else {
290            td->doubleData.push_back(pts[loop].x);
291            td->doubleData.push_back(pts[loop].y);
292        }
293    }
294}
295void trpgGeometry::AddTexCoords(BindType bind)
296{
297    trpgTexData td;
298    td.bind = bind;
299    texData.push_back(td);
300}
301void trpgGeometry::SetEdgeFlags(int num,const char *flags)
302{
303    if (num < 0)
304        return;
305
306    edgeFlags.resize(0);
307    for (int i=0;i<num;i++)
308        edgeFlags.push_back(flags[i]);
309}
310
311// Get methods
312bool trpgGeometry::GetPrimType(PrimType &t) const
313{
314    if (!isValid()) return false;
315    t = (PrimType)primType;
316    return true;
317}
318bool trpgGeometry::GetNumPrims(int &n) const
319{
320    if (!isValid()) return false;
321    n = numPrim;
322    return true;
323}
324bool trpgGeometry::GetPrimLengths(int *ret) const
325{
326    if (!isValid()) return false;
327    for (int i=0;i<numPrim;i++)
328        ret[i] = primLength[i];
329    return true;
330}
331bool trpgGeometry::GetNumMaterial(int &n) const
332{
333    if (!isValid()) return false;
334    n = materials.size();
335    return true;
336}
337bool trpgGeometry::GetMaterial(int id,int32 &m,bool &isLocal) const
338{
339    isLocal = false;
340    if (!isValid() || id < 0 || id >= (int)materials.size()) return false;
341    m = materials[id];
342    if (m < 0) {
343        m = -m - 1;
344        isLocal = true;
345    }
346    return true;
347}
348bool trpgGeometry::GetNumVertex(int &v) const
349{
350    if (!isValid()) return false;
351    int nvf = vertDataFloat.size();
352    int nvd = vertDataDouble.size();
353    v = MAX(nvf,nvd);
354    v = v / 3;
355    return true;
356}
357bool trpgGeometry::GetVertices(float32 *v) const
358{
359    unsigned int i;
360
361    if (!isValid()) return false;
362    if (vertDataFloat.size() != 0)
363        for (i=0;i<vertDataFloat.size();i++)
364            v[i] = vertDataFloat[i];
365    else
366        for (i=0;i<vertDataDouble.size();i++)
367            v[i] = static_cast<float32>(vertDataDouble[i]);
368    return true;
369}
370bool trpgGeometry::GetVertices(float64 *v) const
371{
372    unsigned int i;
373
374    if (!isValid()) return false;
375    if (vertDataFloat.size() != 0)
376        for (i=0;i<vertDataFloat.size();i++)
377            v[i] = vertDataFloat[i];
378    else
379        for (i=0;i<vertDataDouble.size();i++)
380            v[i] = vertDataDouble[i];
381    return true;
382}
383bool trpgGeometry::GetVertex(int n,trpg3dPoint &pt) const
384{
385    int id = 3*n;
386    int idMax = 3*n+2;
387    if (id < 0 || (idMax >= (int)vertDataFloat.size() && idMax >= (int)vertDataDouble.size()))
388        return false;
389    if (vertDataFloat.size() > vertDataDouble.size()) {
390        pt.x = vertDataFloat[id];
391        pt.y = vertDataFloat[id+1];
392        pt.z = vertDataFloat[id+2];
393    } else {
394        pt.x = vertDataDouble[id];
395        pt.y = vertDataDouble[id+1];
396        pt.z = vertDataDouble[id+2];
397    }
398    return true;
399}
400bool trpgGeometry::GetNumNormal(int32 &n) const
401{
402    if (!isValid()) return false;
403    if (normDataFloat.size() != 0)
404        n = normDataFloat.size();
405    if (normDataDouble.size() != 0)
406        n = normDataDouble.size();
407    n = n / 3;
408    return true;
409}
410bool trpgGeometry::GetNormals(float32 *v) const
411{
412    unsigned int i;
413
414    if (!isValid()) return false;
415    if (normDataFloat.size() != 0)
416        for (i=0;i<normDataFloat.size();i++)
417            v[i] = normDataFloat[i];
418    else
419        for (i=0;i<normDataDouble.size();i++)
420            v[i] = static_cast<float32>(normDataDouble[i]);
421    return true;
422}
423bool trpgGeometry::GetNormals(float64 *v) const
424{
425    unsigned int i;
426
427    if (!isValid()) return false;
428    if (normDataFloat.size() != 0)
429        for (i=0;i<normDataFloat.size();i++)
430            v[i] = normDataFloat[i];
431    else
432        for (i=0;i<normDataDouble.size();i++)
433            v[i] = normDataDouble[i];
434    return true;
435}
436bool trpgGeometry::GetNumColorSets(int &n) const
437{
438    if (!isValid()) return false;
439    n = colors.size();
440    return true;
441}
442bool trpgGeometry::GetColorSet(int id,trpgColorInfo *ci) const
443{
444    if (!isValid() || id < 0 || id >= (int)colors.size()) return false;
445    *ci = colors[id];
446    return true;
447}
448bool trpgGeometry::GetNumTexCoordSets(int &n) const
449{
450    if (!isValid()) return false;
451    n = texData.size();
452    return true;
453}
454bool trpgGeometry::GetTexCoordSet(int id,trpgTexData *tx) const
455{
456    if (!isValid() || id < 0 || id >= (int)texData.size()) return false;
457    *tx = texData[id];
458    return true;
459}
460const trpgTexData *trpgGeometry::GetTexCoordSet(int id) const
461{
462    if (!isValid() || id < 0 || id >= (int)texData.size()) return 0;
463    return &(texData[id]);
464}
465bool trpgGeometry::GetNumEdgeFlag(int &n) const
466{
467    if (!isValid()) return false;
468    n = edgeFlags.size();
469    return true;
470}
471bool trpgGeometry::GetEdgeFlags(char *e) const
472{
473    if (!isValid()) return false;
474    for (unsigned int i=0;i<edgeFlags.size();i++)
475        e[i] = edgeFlags[i];
476    return true;
477}
478
479// Validity check
480// Note: maybe I should do this sometime
481bool trpgGeometry::isValid() const
482{
483    return true;
484}
485
486// Write geometry fields.
487// Order doesn't matter very much for this
488bool trpgGeometry::Write(trpgWriteBuffer &buf)
489{
490    unsigned int i,j;
491
492    if (!isValid())
493        return false;
494
495    buf.Begin(TRPG_GEOMETRY);
496    /* Primitive info
497        Primitive Type
498         Number of primitives
499        Primitive array lengths
500        */
501    buf.Begin(TRPG_GEOM_PRIM);
502     buf.Add(primType);
503    buf.Add(numPrim);
504    if (primLength.size() != 0) {
505        buf.Add((uint8)1);
506        for (i=0;i<(unsigned int)numPrim;i++)
507            buf.Add(primLength[i]);
508    } else
509        buf.Add((uint8)0);
510    buf.End();
511
512    /* Material info
513        Num materials
514        Material indicies
515        */
516    if (materials.size() > 0) {
517        buf.Begin(TRPG_GEOM_MATERIAL);
518        buf.Add((int32)materials.size());
519        for (i=0;i<materials.size();i++)
520            buf.Add(materials[i]);
521        buf.End();
522    }
523
524    /* Vertices
525        Float and Double should never both be here
526        Num vertex
527        Vertex data
528        */
529    if (vertDataFloat.size() > 0) {
530        buf.Begin(TRPG_GEOM_VERT32);
531        int32 num = vertDataFloat.size()/3;
532        buf.Add(num);
533        for (i=0;i<(unsigned int)3*num;i++)
534            buf.Add(vertDataFloat[i]);
535        buf.End();
536    }
537    if (vertDataDouble.size() > 0) {
538        buf.Begin(TRPG_GEOM_VERT64);
539        int32 num = vertDataDouble.size()/3;
540        buf.Add(num);
541        for (i=0;i<(unsigned int)3*num;i++)
542            buf.Add(vertDataDouble[i]);
543        buf.End();
544    }
545
546    /* Normals
547        Normal binding
548        Num normals
549        Normal data
550        */
551    if (normDataFloat.size() > 0) {
552        buf.Begin(TRPG_GEOM_NORM32);
553        buf.Add((int32)normBind);
554        int32 num = normDataFloat.size()/3;
555        buf.Add(num);
556        for (i=0;i<(unsigned int)3*num;i++)
557            buf.Add(normDataFloat[i]);
558        buf.End();
559    }
560    if (normDataDouble.size() > 0) {
561        buf.Begin(TRPG_GEOM_NORM64);
562        buf.Add((int32)normBind);
563        int32 num = normDataDouble.size()/3;
564        buf.Add(num);
565        for (i=0;i<(unsigned int)3*num;i++)
566            buf.Add(normDataDouble[i]);
567        buf.End();
568    }
569
570    /* Colors
571        Color binding
572        Num colors
573        Colors
574           */
575    if (colors.size() > 0) {
576        for (i=0;i<colors.size();i++) {
577            trpgColorInfo &ci = colors[i];
578            if (ci.data.size()) {
579                buf.Begin(TRPG_GEOM_COLOR);
580                buf.Add((int32)ci.type);
581                buf.Add((int32)ci.bind);
582                buf.Add((int32)ci.data.size());
583                for (j=0;j<ci.data.size();j++)
584                    buf.Add(ci.data[j]);
585                buf.End();
586            }
587        }
588    }
589
590    /* Texture coordinates
591        Binding
592        Num coords
593        Texture coords
594        */
595    for (i=0;i<texData.size();i++) {
596        trpgTexData &td = texData[i];
597        if (td.floatData.size()) {
598            buf.Begin(TRPG_GEOM_TEX32);
599            buf.Add((int32)td.bind);
600            int32 num = td.floatData.size()/2;
601            buf.Add(num);
602            for (j=0;j<(unsigned int)num*2;j++)
603                buf.Add(td.floatData[j]);
604            buf.End();
605        }
606        if (td.doubleData.size()) {
607            buf.Begin(TRPG_GEOM_TEX64);
608            buf.Add((int32)td.bind);
609            int32 num = td.doubleData.size()/2;
610            buf.Add(num);
611            for (j=0;j<(unsigned int)num*2;j++)
612                buf.Add(td.doubleData[j]);
613            buf.End();
614
615            float u;
616            for (j=0;j<(unsigned int)num*2;j++)
617                u = (float)td.doubleData[j];
618        }
619    }
620
621    // Edge flags (for triangle strips, etc..)
622    if (edgeFlags.size() > 0) {
623        buf.Begin(TRPG_GEOM_EFLAG);
624        buf.Add((int32)edgeFlags.size());
625        for (i=0;i<edgeFlags.size();i++)
626            buf.Add(edgeFlags[i]);
627        buf.End();
628    }
629
630    buf.End();
631
632    return true;
633}
634
635// Geometry class is made up of individual tokens.
636class geomCB : public trpgr_Callback {
637public:
638    void *Parse(trpgToken,trpgReadBuffer &buf);
639    trpgGeometry *geom;
640};
641
642void *geomCB::Parse(trpgToken tok,trpgReadBuffer &buf)
643{
644    int32 *iData;
645    int32 num,primType,bind,type;
646    float32 *fData;
647    float64 *dData;
648    trpgColor *cData;
649    char *charData;
650    uint8 hasPrimLen;
651
652    try {
653        switch (tok) {
654        case TRPG_GEOM_PRIM:
655            buf.Get(primType);
656            geom->SetPrimType((trpgGeometry::PrimType)primType);
657            buf.Get(num);
658            if (num < 0) throw 1;
659            geom->SetNumPrims(num);
660            buf.Get(hasPrimLen);
661            if (hasPrimLen) {
662                buf.GetArray(num,&iData);
663                if (ALIGNMENT_WORKAROUND)
664                {
665                    int32 *aligned;
666                    aligned = (int32 *)calloc (num, sizeof(int32));
667                    memcpy (aligned, iData, num * sizeof(int32));
668                    geom->SetPrimLengths(num, aligned);
669                    free (aligned);
670                }
671                else
672                    geom->SetPrimLengths(num,iData);
673            }
674            break;
675        case TRPG_GEOM_MATERIAL:
676            buf.Get(num);
677            if (num < 0) throw 1;
678            buf.GetArray(num,&iData);
679            if (ALIGNMENT_WORKAROUND)
680            {
681                int32 *aligned;
682                aligned = (int32 *)calloc (num, sizeof(int32));
683                memcpy (aligned, iData, num * sizeof(int32));
684                geom->SetMaterials(num,aligned);
685                free (aligned);
686            }
687            else
688                geom->SetMaterials(num,iData);
689            break;
690        case TRPG_GEOM_VERT32:
691            buf.Get(num);
692            if (num < 0) throw 1;
693            buf.GetArray(3*num,&fData);
694            if (ALIGNMENT_WORKAROUND)
695            {
696                float32 *aligned;
697                aligned = (float32 *)calloc (3*num, sizeof(float32));
698                memcpy (aligned, fData, 3*num * sizeof(float32));
699                geom->SetVertices(num,aligned);
700                free (aligned);
701            }
702            else
703                geom->SetVertices(num,fData);
704            break;
705        case TRPG_GEOM_VERT64:
706            buf.Get(num);
707            if (num < 0) throw 1;
708            buf.GetArray(3*num,&dData);
709            if (ALIGNMENT_WORKAROUND)
710            {
711                float64 *aligned;
712                aligned = (float64 *)calloc (3*num, sizeof(float64));
713                memcpy (aligned, dData, 3*num * sizeof(float64));
714                geom->SetVertices(num,aligned);
715                free (aligned);
716            }
717            else
718                geom->SetVertices(num,dData);
719            break;
720        case TRPG_GEOM_NORM32:
721            buf.Get(bind);
722            buf.Get(num);
723            if (num < 0) throw 1;
724            buf.GetArray(3*num,&fData);
725            if (ALIGNMENT_WORKAROUND)
726            {
727                float32 *aligned;
728                aligned = (float32 *)calloc (3*num, sizeof(float32));
729                memcpy (aligned, fData, 3*num * sizeof(float32));
730                geom->SetNormals(num,(trpgGeometry::BindType)bind,aligned);
731                free (aligned);
732            }
733            else
734                geom->SetNormals(num,(trpgGeometry::BindType)bind,fData);
735            break;
736        case TRPG_GEOM_NORM64:
737            buf.Get(bind);
738            buf.Get(num);
739            if (num < 0) throw 1;
740            buf.GetArray(3*num,&dData);
741            if (ALIGNMENT_WORKAROUND)
742            {
743                float64 *aligned;
744                aligned = (float64 *)calloc (3*num, sizeof(float64));
745                memcpy (aligned, dData, 3*num * sizeof(float64));
746                geom->SetNormals(num,(trpgGeometry::BindType)bind,aligned);
747                free (aligned);
748            }
749            else
750                geom->SetNormals(num,(trpgGeometry::BindType)bind,dData);
751            break;
752        case TRPG_GEOM_COLOR:
753            buf.Get(num);
754            if (num < 0) throw 1;
755            buf.Get(type);
756            buf.Get(bind);
757            buf.GetArray(num,&cData);
758            if (ALIGNMENT_WORKAROUND)
759            {
760                trpgColor *aligned;
761                aligned = (trpgColor *)calloc (num, sizeof(trpgColor));
762                memcpy (aligned, cData, num * sizeof(trpgColor));
763                geom->SetColors(num,(trpgGeometry::ColorType)type,(trpgGeometry::BindType)bind,aligned);
764                free (aligned);
765            }
766            else
767                geom->SetColors(num,(trpgGeometry::ColorType)type,(trpgGeometry::BindType)bind,cData);
768            break;
769        case TRPG_GEOM_TEX32:
770            buf.Get(bind);
771            buf.Get(num);
772            if (num < 0) throw 1;
773            buf.GetArray(2*num,&fData);
774            if (ALIGNMENT_WORKAROUND)
775            {
776                float32 *aligned;
777                aligned = (float32 *)calloc (2*num, sizeof(float32));
778                memcpy (aligned, fData, 2*num * sizeof(float32));
779                geom->SetTexCoords(num,(trpgGeometry::BindType)bind,aligned);
780                free (aligned);
781            }
782            else
783                geom->SetTexCoords(num,(trpgGeometry::BindType)bind,fData);
784            break;
785        case TRPG_GEOM_TEX64:
786            buf.Get(bind);
787            buf.Get(num);
788            if (num < 0) throw 1;
789            buf.GetArray(2*num,&dData);
790            if (ALIGNMENT_WORKAROUND)
791            {
792                float64 *aligned;
793                aligned = (float64 *)calloc (2*num, sizeof(float64));
794                memcpy (aligned, dData, 2*num * sizeof(float64));
795                geom->SetTexCoords(num,(trpgGeometry::BindType)bind,aligned);
796                free (aligned);
797            }
798            else
799                geom->SetTexCoords(num,(trpgGeometry::BindType)bind,dData);
800            break;
801        case TRPG_GEOM_EFLAG:
802            buf.Get(num);
803            if (num < 0) throw 1;
804            buf.GetArray(num,&charData);
805            geom->SetEdgeFlags(num,charData);
806            break;
807        default:
808            // Skip
809            break;
810        }
811    }
812    catch (...) {
813        return NULL;
814    }
815
816    return geom;
817}
818
819// Read Geometry
820bool trpgGeometry::Read(trpgReadBuffer &buf)
821{
822    trpgr_Parser parse;
823    geomCB gcb;
824
825    gcb.geom = this;
826    parse.AddCallback(TRPG_GEOM_PRIM,&gcb,false);
827    parse.AddCallback(TRPG_GEOM_MATERIAL,&gcb,false);
828    parse.AddCallback(TRPG_GEOM_VERT32,&gcb,false);
829    parse.AddCallback(TRPG_GEOM_VERT64,&gcb,false);
830    parse.AddCallback(TRPG_GEOM_NORM32,&gcb,false);
831    parse.AddCallback(TRPG_GEOM_NORM64,&gcb,false);
832    parse.AddCallback(TRPG_GEOM_COLOR,&gcb,false);
833    parse.AddCallback(TRPG_GEOM_TEX32,&gcb,false);
834    parse.AddCallback(TRPG_GEOM_TEX64,&gcb,false);
835    parse.AddCallback(TRPG_GEOM_EFLAG,&gcb,false);
836    parse.Parse(buf);
837
838    return isValid();
839}
Note: See TracBrowser for help on using the browser.