root/OpenSceneGraph/trunk/src/osgWrappers/deprecated-dotosg/osg/Geometry.cpp @ 13041

Revision 13041, 44.5 kB (checked in by robert, 2 years ago)

Ran script to remove trailing spaces and tabs

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#include <osg/Geometry>
2#include <osg/Notify>
3#include <osg/io_utils>
4
5#include <osgDB/Registry>
6#include <osgDB/Input>
7#include <osgDB/ParameterOutput>
8
9#include <string.h>
10
11using namespace osg;
12using namespace osgDB;
13
14// forward declare functions to use later.
15bool Geometry_readLocalData(Object& obj, Input& fr);
16bool Geometry_writeLocalData(const Object& obj, Output& fw);
17
18bool Geometry_matchBindingTypeStr(const char* str,Geometry::AttributeBinding& mode);
19const char* Geometry_getBindingTypeStr(Geometry::AttributeBinding mode);
20
21bool Geometry_matchPrimitiveModeStr(const char* str,GLenum& mode);
22const char* Geometry_getPrimitiveModeStr(GLenum mode);
23
24Array* Array_readLocalData(Input& fr);
25
26bool Primitive_readLocalData(Input& fr,osg::Geometry& geom);
27
28//register the read and write functions with the osgDB::Registry.
29REGISTER_DOTOSGWRAPPER(Geometry)
30(
31    new osg::Geometry,
32    "Geometry",
33    "Object Drawable Geometry",
34    &Geometry_readLocalData,
35    &Geometry_writeLocalData,
36    DotOsgWrapper::READ_AND_WRITE
37);
38
39bool Geometry_readLocalData(Object& obj, Input& fr)
40{
41    bool iteratorAdvanced = false;
42
43    Geometry& geom = static_cast<Geometry&>(obj);
44
45    if (fr.matchSequence("Primitives %i {") || fr.matchSequence("PrimitiveSets %i {") )
46    {
47        int entry = fr[1].getNoNestedBrackets();
48
49        int capacity;
50        fr[1].getInt(capacity);
51
52        Geometry::PrimitiveSetList& primitives = geom.getPrimitiveSetList();
53        if (capacity>0) primitives.reserve(capacity);
54
55
56        fr += 3;
57
58
59        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
60        {
61            if (!Primitive_readLocalData(fr,geom)) fr.advanceOverCurrentFieldOrBlock();
62        }
63
64        ++fr;
65
66        iteratorAdvanced = true;
67
68    }
69
70    if (fr[0].matchWord("VertexArray"))
71    {
72        if (fr.matchSequence("VertexArray %i {"))
73        {
74
75            int entry = fr[0].getNoNestedBrackets();
76
77            int capacity;
78            fr[1].getInt(capacity);
79
80            Vec3Array* vertices = new Vec3Array;
81            vertices->reserve(capacity);
82
83            fr += 3;
84
85            while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
86            {
87                Vec3 v;
88                if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()))
89                {
90                    fr += 3;
91                    vertices->push_back(v);
92                }
93                else
94                {
95                    ++fr;
96                }
97            }
98
99            geom.setVertexArray(vertices);
100
101            iteratorAdvanced = true;
102            ++fr;
103
104        }
105        else
106        {
107            // post 0.9.3 releases.
108            ++fr;
109            Array* vertices = Array_readLocalData(fr);
110            if (vertices)
111            {
112                geom.setVertexArray(vertices);
113            }
114            iteratorAdvanced = true;
115        }
116    }
117
118    if (fr[0].matchWord("VertexIndices"))
119    {
120        ++fr;
121
122        IndexArray* indices = dynamic_cast<IndexArray*>(Array_readLocalData(fr));
123        if (indices)
124        {
125            geom.setVertexIndices(indices);
126        }
127
128        iteratorAdvanced = true;
129    }
130
131
132    Geometry::AttributeBinding normalBinding=Geometry::BIND_OFF;
133    if (fr[0].matchWord("NormalBinding") && Geometry_matchBindingTypeStr(fr[1].getStr(),normalBinding))
134    {
135        geom.setNormalBinding(normalBinding);
136        fr+=2;
137        iteratorAdvanced = true;
138    }
139
140    if (fr[0].matchWord("NormalArray"))
141    {
142        if (fr.matchSequence("NormalArray %i {"))
143        {
144            // pre 0.9.3 releases..
145            int entry = fr[0].getNoNestedBrackets();
146
147            int capacity;
148            fr[1].getInt(capacity);
149
150            Vec3Array* normals = new Vec3Array;
151            normals->reserve(capacity);
152
153            fr += 3;
154
155            while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
156            {
157                Vec3 v;
158                if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()))
159                {
160                    fr += 3;
161                    normals->push_back(v);
162                }
163                else
164                {
165                    ++fr;
166                }
167            }
168
169            geom.setNormalArray(normals);
170
171            iteratorAdvanced = true;
172            ++fr;
173        }
174        else
175        {
176            // post 0.9.3 releases.
177            ++fr;
178            Array* normals = Array_readLocalData(fr);
179            if (normals)
180            {
181                geom.setNormalArray(normals);
182            }
183            iteratorAdvanced = true;
184        }
185    }
186    if (fr[0].matchWord("NormalIndices"))
187    {
188        ++fr;
189        IndexArray* indices = dynamic_cast<IndexArray*>(Array_readLocalData(fr));
190        if (indices)
191        {
192            geom.setNormalIndices(indices);
193        }
194        iteratorAdvanced = true;
195    }
196
197    Geometry::AttributeBinding colorBinding=Geometry::BIND_OFF;
198    if (fr[0].matchWord("ColorBinding") && Geometry_matchBindingTypeStr(fr[1].getStr(),colorBinding))
199    {
200        geom.setColorBinding(colorBinding);
201        fr+=2;
202        iteratorAdvanced = true;
203    }
204
205    if (fr[0].matchWord("ColorArray"))
206    {
207        ++fr;
208        Array* colors = Array_readLocalData(fr);
209        if (colors)
210        {
211            geom.setColorArray(colors);
212        }
213        iteratorAdvanced = true;
214    }
215
216    if (fr[0].matchWord("ColorIndices"))
217    {
218        ++fr;
219        IndexArray* indices = dynamic_cast<IndexArray*>(Array_readLocalData(fr));
220        if (indices)
221        {
222            geom.setColorIndices(indices);
223        }
224        iteratorAdvanced = true;
225    }
226
227
228    Geometry::AttributeBinding secondaryColorBinding=Geometry::BIND_OFF;
229    if (fr[0].matchWord("SecondaryColorBinding") && Geometry_matchBindingTypeStr(fr[1].getStr(),secondaryColorBinding))
230    {
231        geom.setSecondaryColorBinding(secondaryColorBinding);
232        fr+=2;
233        iteratorAdvanced = true;
234    }
235
236    if (fr[0].matchWord("SecondaryColorArray"))
237    {
238        ++fr;
239        Array* colors = Array_readLocalData(fr);
240        if (colors)
241        {
242            geom.setSecondaryColorArray(colors);
243        }
244        iteratorAdvanced = true;
245    }
246
247    if (fr[0].matchWord("SecondaryColorIndices"))
248    {
249        ++fr;
250        IndexArray* indices = dynamic_cast<IndexArray*>(Array_readLocalData(fr));
251        if (indices)
252        {
253            geom.setSecondaryColorIndices(indices);
254        }
255        iteratorAdvanced = true;
256    }
257
258
259    Geometry::AttributeBinding fogCoordBinding=Geometry::BIND_OFF;
260    if (fr[0].matchWord("FogCoordBinding") && Geometry_matchBindingTypeStr(fr[1].getStr(),fogCoordBinding))
261    {
262        geom.setFogCoordBinding(fogCoordBinding);
263        fr+=2;
264        iteratorAdvanced = true;
265    }
266
267    if (fr[0].matchWord("FogCoordArray"))
268    {
269        ++fr;
270        Array* fogcoords = Array_readLocalData(fr);
271        if (fogcoords)
272        {
273            geom.setFogCoordArray(fogcoords);
274        }
275        iteratorAdvanced = true;
276    }
277
278    if (fr[0].matchWord("FogCoordIndices"))
279    {
280        ++fr;
281        IndexArray* indices = dynamic_cast<IndexArray*>(Array_readLocalData(fr));
282        if (indices)
283        {
284            geom.setFogCoordIndices(indices);
285        }
286        iteratorAdvanced = true;
287    }
288
289
290    if (fr.matchSequence("TexCoordArray %i"))
291    {
292        int unit=0;
293        fr[1].getInt(unit);
294
295        fr+=2;
296        Array* texcoords = Array_readLocalData(fr);
297        if (texcoords)
298        {
299            geom.setTexCoordArray(unit,texcoords);
300        }
301        iteratorAdvanced = true;
302
303    }
304
305    if (fr.matchSequence("TexCoordIndices %i"))
306    {
307        int unit=0;
308        fr[1].getInt(unit);
309
310        fr+=2;
311        IndexArray* indices = dynamic_cast<IndexArray*>(Array_readLocalData(fr));
312        if (indices)
313        {
314            geom.setTexCoordIndices(unit,indices);
315        }
316        iteratorAdvanced = true;
317    }
318
319    Geometry::AttributeBinding vertexAttribBinding=Geometry::BIND_OFF;
320    if (fr.matchSequence("VertexAttribBinding %i %w") && Geometry_matchBindingTypeStr(fr[2].getStr(),vertexAttribBinding))
321    {
322        int unit=0;
323        fr[1].getInt(unit);
324        geom.setVertexAttribBinding(unit,vertexAttribBinding);
325        fr+=3;
326        iteratorAdvanced = true;
327    }
328
329    if (fr.matchSequence("VertexAttribNormalize %i %w"))
330    {
331        int unit=0;
332        fr[1].getInt(unit);
333
334        if (fr[2].matchString("TRUE"))
335            geom.setVertexAttribNormalize(unit,GL_TRUE);
336        else
337            geom.setVertexAttribNormalize(unit,GL_FALSE);
338
339        fr+=3;
340        iteratorAdvanced = true;
341    }
342
343    if (fr.matchSequence("VertexAttribArray %i"))
344    {
345        int unit=0;
346        fr[1].getInt(unit);
347
348        fr+=2;
349        Array* vertexattrib = Array_readLocalData(fr);
350        if (vertexattrib)
351        {
352            geom.setVertexAttribArray(unit,vertexattrib);
353        }
354        iteratorAdvanced = true;
355
356    }
357
358    if (fr.matchSequence("VertexAttribIndices %i"))
359    {
360        int unit=0;
361        fr[1].getInt(unit);
362
363        fr+=2;
364        IndexArray* indices = dynamic_cast<IndexArray*>(Array_readLocalData(fr));
365        if (indices)
366        {
367            geom.setVertexAttribIndices(unit,indices);
368        }
369        iteratorAdvanced = true;
370    }
371
372    return iteratorAdvanced;
373}
374
375
376Array* Array_readLocalData(Input& fr)
377{
378    if (fr[0].matchWord("Use"))
379    {
380        if (fr[1].isString())
381        {
382            Object* obj = fr.getObjectForUniqueID(fr[1].getStr());
383            if (obj)
384            {
385                fr+=2;
386                return dynamic_cast<Array*>(obj);
387            }
388        }
389
390        osg::notify(osg::WARN)<<"Warning: invalid uniqueID found in file."<<std::endl;
391        return NULL;
392    }
393
394    std::string uniqueID;
395    if (fr[0].matchWord("UniqueID") && fr[1].isString())
396    {
397        uniqueID = fr[1].getStr();
398        fr += 2;
399    }
400
401
402    int entry = fr[0].getNoNestedBrackets();
403
404    const char* arrayName = fr[0].getStr();
405
406    unsigned int capacity = 0;
407    fr[1].getUInt(capacity);
408    ++fr;
409
410    fr += 2;
411
412
413    Array* return_array = 0;
414
415    if (strcmp(arrayName,"ByteArray")==0)
416    {
417        ByteArray* array = new ByteArray;
418        array->reserve(capacity);
419        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
420        {
421            int int_value;
422            if (fr[0].getInt(int_value))
423            {
424                ++fr;
425                array->push_back(int_value);
426            }
427            else ++fr;
428        }
429        ++fr;
430
431        return_array = array;
432    }
433    else if (strcmp(arrayName,"ShortArray")==0)
434    {
435        ShortArray* array = new ShortArray;
436        array->reserve(capacity);
437        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
438        {
439            int int_value;
440            if (fr[0].getInt(int_value))
441            {
442                ++fr;
443                array->push_back(int_value);
444            }
445            else ++fr;
446        }
447        ++fr;
448        return_array = array;
449    }
450    else if (strcmp(arrayName,"IntArray")==0)
451    {
452        IntArray* array = new IntArray;
453        array->reserve(capacity);
454        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
455        {
456            int int_value;
457            if (fr[0].getInt(int_value))
458            {
459                ++fr;
460                array->push_back(int_value);
461            }
462            else ++fr;
463        }
464        ++fr;
465        return_array = array;
466    }
467    else if (strcmp(arrayName,"UByteArray")==0)
468    {
469        UByteArray* array = new UByteArray;
470        array->reserve(capacity);
471        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
472        {
473            unsigned int uint_value;
474            if (fr[0].getUInt(uint_value))
475            {
476                ++fr;
477                array->push_back(uint_value);
478            }
479            else ++fr;
480        }
481        ++fr;
482        return_array = array;
483    }
484    else if (strcmp(arrayName,"UShortArray")==0)
485    {
486        UShortArray* array = new UShortArray;
487        array->reserve(capacity);
488        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
489        {
490            unsigned int uint_value;
491            if (fr[0].getUInt(uint_value))
492            {
493                ++fr;
494                array->push_back(uint_value);
495            }
496            else ++fr;
497        }
498        ++fr;
499        return_array = array;
500    }
501    else if (strcmp(arrayName,"UIntArray")==0)
502    {
503        UIntArray* array = new UIntArray;
504        array->reserve(capacity);
505        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
506        {
507            unsigned int uint_value;
508            if (fr[0].getUInt(uint_value))
509            {
510                ++fr;
511                array->push_back(uint_value);
512            }
513            else ++fr;
514        }
515        ++fr;
516        return_array = array;
517    }
518    else if (strcmp(arrayName,"UVec4bArray")==0 || strcmp(arrayName,"Vec4ubArray")==0)
519    {
520        Vec4ubArray* array = new Vec4ubArray;
521        array->reserve(capacity);
522        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
523        {
524            unsigned int r,g,b,a;
525            if (fr[0].getUInt(r) &&
526                fr[1].getUInt(g) &&
527                fr[2].getUInt(b) &&
528                fr[3].getUInt(a))
529            {
530                fr+=4;
531                array->push_back(osg::Vec4ub(r,g,b,a));
532            }
533            else ++fr;
534        }
535        ++fr;
536        return_array = array;
537    }
538    else if (strcmp(arrayName,"FloatArray")==0)
539    {
540        FloatArray* array = new FloatArray;
541        array->reserve(capacity);
542        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
543        {
544            float float_value;
545            if (fr[0].getFloat(float_value))
546            {
547                ++fr;
548                array->push_back(float_value);
549            }
550            else ++fr;
551        }
552        ++fr;
553        return_array = array;
554    }
555    else if (strcmp(arrayName,"DoubleArray")==0)
556    {
557        DoubleArray* array = new DoubleArray;
558        array->reserve(capacity);
559        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
560        {
561            double double_value;
562            if (fr[0].getFloat(double_value))
563            {
564                ++fr;
565                array->push_back(double_value);
566            }
567            else ++fr;
568        }
569        ++fr;
570        return_array = array;
571    }
572    else if (strcmp(arrayName,"Vec2Array")==0)
573    {
574        Vec2Array* array = new Vec2Array;
575        array->reserve(capacity);
576        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
577        {
578            Vec2 v;
579            if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()))
580            {
581                fr += 2;
582                array->push_back(v);
583            }
584            else ++fr;
585        }
586        ++fr;
587        return_array = array;
588    }
589    else if (strcmp(arrayName,"Vec2dArray")==0)
590    {
591        Vec2dArray* array = new Vec2dArray;
592        array->reserve(capacity);
593        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
594        {
595            Vec2d v;
596            if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()))
597            {
598                fr += 2;
599                array->push_back(v);
600            }
601            else ++fr;
602        }
603        ++fr;
604        return_array = array;
605    }
606    else if (strcmp(arrayName,"Vec3Array")==0)
607    {
608        Vec3Array* array = new Vec3Array;
609        array->reserve(capacity);
610        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
611        {
612            Vec3 v;
613            if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()))
614            {
615                fr += 3;
616                array->push_back(v);
617            }
618            else ++fr;
619        }
620        ++fr;
621        return_array = array;
622    }
623    else if (strcmp(arrayName,"Vec3dArray")==0)
624    {
625        Vec3dArray* array = new Vec3dArray;
626        array->reserve(capacity);
627        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
628        {
629            Vec3d v;
630            if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()))
631            {
632                fr += 3;
633                array->push_back(v);
634            }
635            else ++fr;
636        }
637        ++fr;
638        return_array = array;
639    }
640    else if (strcmp(arrayName,"Vec4Array")==0)
641    {
642        Vec4Array* array = new Vec4Array;
643        array->reserve(capacity);
644        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
645        {
646            Vec4 v;
647            if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()) && fr[3].getFloat(v.w()))
648            {
649                fr += 4;
650                array->push_back(v);
651            }
652            else ++fr;
653        }
654        ++fr;
655        return_array = array;
656    }
657    else if (strcmp(arrayName,"Vec4dArray")==0)
658    {
659        Vec4dArray* array = new Vec4dArray;
660        array->reserve(capacity);
661        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
662        {
663            Vec4d v;
664            if (fr[0].getFloat(v.x()) && fr[1].getFloat(v.y()) && fr[2].getFloat(v.z()) && fr[3].getFloat(v.w()))
665            {
666                fr += 4;
667                array->push_back(v);
668            }
669            else ++fr;
670        }
671        ++fr;
672        return_array = array;
673    }
674    else if (strcmp(arrayName,"Vec2bArray")==0)
675    {
676        Vec2bArray* array = new Vec2bArray;
677        array->reserve(capacity);
678        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
679        {
680            unsigned int r,g;
681            if (fr[0].getUInt(r) &&
682                fr[1].getUInt(g))
683            {
684                fr+=2;
685                array->push_back(osg::Vec2b(r,g));
686            }
687            else ++fr;
688        }
689        ++fr;
690        return_array = array;
691    }
692    else if (strcmp(arrayName,"Vec3bArray")==0)
693    {
694        Vec3bArray* array = new Vec3bArray;
695        array->reserve(capacity);
696        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
697        {
698            unsigned int r,g,b;
699            if (fr[0].getUInt(r) &&
700                fr[1].getUInt(g) &&
701                fr[2].getUInt(b))
702            {
703                fr+=3;
704                array->push_back(osg::Vec3b(r,g,b));
705            }
706            else ++fr;
707        }
708        ++fr;
709        return_array = array;
710    }
711    else if (strcmp(arrayName,"Vec4bArray")==0)
712    {
713        Vec4bArray* array = new Vec4bArray;
714        array->reserve(capacity);
715        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
716        {
717            unsigned int r,g,b,a;
718            if (fr[0].getUInt(r) &&
719                fr[1].getUInt(g) &&
720                fr[2].getUInt(b) &&
721                fr[3].getUInt(a))
722            {
723                fr+=4;
724                array->push_back(osg::Vec4b(r,g,b,a));
725            }
726            else ++fr;
727        }
728        ++fr;
729        return_array = array;
730    }
731    else if (strcmp(arrayName,"Vec2sArray")==0)
732    {
733        Vec2sArray* array = new Vec2sArray;
734        array->reserve(capacity);
735        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
736        {
737            unsigned int r,g;
738            if (fr[0].getUInt(r) &&
739                fr[1].getUInt(g))
740            {
741                fr+=2;
742                array->push_back(osg::Vec2s(r,g));
743            }
744            else ++fr;
745        }
746        ++fr;
747        return_array = array;
748    }
749    else if (strcmp(arrayName,"Vec3sArray")==0)
750    {
751        Vec3sArray* array = new Vec3sArray;
752        array->reserve(capacity);
753        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
754        {
755            unsigned int r,g,b;
756            if (fr[0].getUInt(r) &&
757                fr[1].getUInt(g) &&
758                fr[2].getUInt(b))
759            {
760                fr+=3;
761                array->push_back(osg::Vec3s(r,g,b));
762            }
763            else ++fr;
764        }
765        ++fr;
766        return_array = array;
767    }
768    else if (strcmp(arrayName,"Vec4sArray")==0)
769    {
770        Vec4sArray* array = new Vec4sArray;
771        array->reserve(capacity);
772        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
773        {
774            unsigned int r,g,b,a;
775            if (fr[0].getUInt(r) &&
776                fr[1].getUInt(g) &&
777                fr[2].getUInt(b) &&
778                fr[3].getUInt(a))
779            {
780                fr+=4;
781                array->push_back(osg::Vec4s(r,g,b,a));
782            }
783            else ++fr;
784        }
785        ++fr;
786        return_array = array;
787    }
788
789    if (return_array)
790    {
791        if (!uniqueID.empty()) fr.registerUniqueIDForObject(uniqueID.c_str(),return_array);
792    }
793
794    return return_array;
795}
796
797
798bool Array_writeLocalData(const Array& array,Output& fw)
799{
800    if (array.referenceCount()>1)
801    {
802        std::string uniqueID;
803        if (fw.getUniqueIDForObject(&array,uniqueID))
804        {
805            fw << "Use " << uniqueID << std::endl;
806            return true;
807        }
808        else
809        {
810            std::string uniqueID;
811            fw.createUniqueIDForObject(&array,uniqueID);
812            fw.registerUniqueIDForObject(&array,uniqueID);
813            fw << "UniqueID " << uniqueID << " ";
814        }
815    }
816
817
818    switch(array.getType())
819    {
820        case(Array::ByteArrayType):
821            {
822                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
823                const ByteArray::ElementDataType* base = static_cast<const ByteArray::ElementDataType*>(array.getDataPointer());
824                writeArrayAsInts(fw,&base[0], &base[array.getNumElements()]);
825                return true;
826            }
827            break;
828        case(Array::ShortArrayType):
829            {
830                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
831                const ShortArray::ElementDataType* base = static_cast<const ShortArray::ElementDataType*>(array.getDataPointer());
832                writeArray(fw,&base[0], &base[array.getNumElements()]);
833                return true;
834            }
835            break;
836        case(Array::IntArrayType):
837            {
838                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
839                const IntArray::ElementDataType* base = static_cast<const IntArray::ElementDataType*>(array.getDataPointer());
840                writeArray(fw,&base[0], &base[array.getNumElements()]);
841                return true;
842            }
843            break;
844        case(Array::UByteArrayType):
845            {
846                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
847                const UByteArray::ElementDataType* base = static_cast<const UByteArray::ElementDataType*>(array.getDataPointer());
848                writeArrayAsInts(fw,&base[0], &base[array.getNumElements()]);
849                return true;
850            }
851            break;
852        case(Array::UShortArrayType):
853            {
854                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
855                const UShortArray::ElementDataType* base = static_cast<const UShortArray::ElementDataType*>(array.getDataPointer());
856                writeArray(fw,&base[0], &base[array.getNumElements()]);
857                return true;
858            }
859            break;
860        case(Array::UIntArrayType):
861            {
862                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
863                const UIntArray::ElementDataType* base = static_cast<const UIntArray::ElementDataType*>(array.getDataPointer());
864                writeArray(fw,&base[0], &base[array.getNumElements()]);
865                return true;
866            }
867            break;
868        case(Array::Vec4ubArrayType):
869            {
870                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
871                const Vec4ubArray::ElementDataType* base = static_cast<const Vec4ubArray::ElementDataType*>(array.getDataPointer());
872                writeArray(fw,&base[0], &base[array.getNumElements()],1);
873                return true;
874            }
875            break;
876        case(Array::FloatArrayType):
877            {
878                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
879                const FloatArray::ElementDataType* base = static_cast<const FloatArray::ElementDataType*>(array.getDataPointer());
880                writeArray(fw,&base[0], &base[array.getNumElements()]);
881                return true;
882            }
883            break;
884        case(Array::Vec2ArrayType):
885            {
886                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
887                const Vec2Array::ElementDataType* base = static_cast<const Vec2Array::ElementDataType*>(array.getDataPointer());
888                writeArray(fw,&base[0], &base[array.getNumElements()],1);
889                return true;
890            }
891            break;
892        case(Array::Vec3ArrayType):
893            {
894                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
895                const Vec3Array::ElementDataType* base = static_cast<const Vec3Array::ElementDataType*>(array.getDataPointer());
896                writeArray(fw,&base[0], &base[array.getNumElements()],1);
897                return true;
898            }
899            break;
900        case(Array::Vec4ArrayType):
901            {
902                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
903                const Vec4Array::ElementDataType* base = static_cast<const Vec4Array::ElementDataType*>(array.getDataPointer());
904                writeArray(fw,&base[0], &base[array.getNumElements()],1);
905                return true;
906            }
907            break;
908        case(Array::DoubleArrayType):
909            {
910                int prec = fw.precision(15);
911                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
912                const DoubleArray::ElementDataType* base = static_cast<const DoubleArray::ElementDataType*>(array.getDataPointer());
913                writeArray(fw,&base[0], &base[array.getNumElements()]);
914                fw.precision(prec);
915                return true;
916            }
917            break;
918        case(Array::Vec2dArrayType):
919            {
920                int prec = fw.precision(15);
921                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
922                const Vec2dArray::ElementDataType* base = static_cast<const Vec2dArray::ElementDataType*>(array.getDataPointer());
923                writeArray(fw,&base[0], &base[array.getNumElements()],1);
924                fw.precision(prec);
925                return true;
926            }
927            break;
928        case(Array::Vec3dArrayType):
929            {
930                int prec = fw.precision(15);
931                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
932                const Vec3dArray::ElementDataType* base = static_cast<const Vec3dArray::ElementDataType*>(array.getDataPointer());
933                writeArray(fw,&base[0], &base[array.getNumElements()],1);
934                fw.precision(prec);
935                return true;
936            }
937            break;
938        case(Array::Vec4dArrayType):
939            {
940                int prec = fw.precision(15);
941                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
942                const Vec4dArray::ElementDataType* base = static_cast<const Vec4dArray::ElementDataType*>(array.getDataPointer());
943                writeArray(fw,&base[0], &base[array.getNumElements()],1);
944                fw.precision(prec);
945                return true;
946            }
947            break;
948        case(Array::Vec2sArrayType):
949            {
950                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
951                const Vec2sArray::ElementDataType* base = static_cast<const Vec2sArray::ElementDataType*>(array.getDataPointer());
952                writeArray(fw,&base[0], &base[array.getNumElements()], 3);
953                return true;
954            }
955            break;
956        case(Array::Vec3sArrayType):
957            {
958                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
959                const Vec3sArray::ElementDataType* base = static_cast<const Vec3sArray::ElementDataType*>(array.getDataPointer());
960                writeArray(fw,&base[0], &base[array.getNumElements()], 2);
961                return true;
962            }
963            break;
964        case(Array::Vec4sArrayType):
965            {
966                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
967                const Vec4sArray::ElementDataType* base = static_cast<const Vec4sArray::ElementDataType*>(array.getDataPointer());
968                writeArray(fw,&base[0], &base[array.getNumElements()], 1);
969                return true;
970            }
971            break;
972        case(Array::Vec2bArrayType):
973            {
974                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
975                const Vec2bArray::ElementDataType* base = static_cast<const Vec2bArray::ElementDataType*>(array.getDataPointer());
976                writeArray(fw,&base[0], &base[array.getNumElements()],1);
977                return true;
978            }
979            break;
980        case(Array::Vec3bArrayType):
981            {
982                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
983                const Vec3bArray::ElementDataType* base = static_cast<const Vec3bArray::ElementDataType*>(array.getDataPointer());
984                writeArray(fw,&base[0], &base[array.getNumElements()],1);
985                return true;
986            }
987            break;
988        case(Array::Vec4bArrayType):
989            {
990                fw<<array.className()<<" "<<array.getNumElements()<<std::endl;
991                const Vec4bArray::ElementDataType* base = static_cast<const Vec4bArray::ElementDataType*>(array.getDataPointer());
992                writeArray(fw,&base[0], &base[array.getNumElements()],1);
993                return true;
994            }
995            break;
996        case(Array::ArrayType):
997        default:
998            return false;
999    }
1000}
1001
1002
1003bool Primitive_readLocalData(Input& fr,osg::Geometry& geom)
1004{
1005    bool iteratorAdvanced = false;
1006    bool firstMatched = false;
1007    if ((firstMatched = fr.matchSequence("DrawArrays %w %i %i %i")) ||
1008         fr.matchSequence("DrawArrays %w %i %i") )
1009    {
1010
1011        GLenum mode;
1012        Geometry_matchPrimitiveModeStr(fr[1].getStr(),mode);
1013
1014        int first;
1015        fr[2].getInt(first);
1016
1017        int count;
1018        fr[3].getInt(count);
1019
1020        int numInstances = 0;
1021        if (firstMatched)
1022        {
1023            fr[4].getInt(numInstances);
1024            fr += 5;
1025        }
1026        else
1027        {
1028            fr += 4;
1029        }
1030
1031        geom.addPrimitiveSet(new DrawArrays(mode, first, count, numInstances));
1032
1033
1034        iteratorAdvanced = true;
1035
1036    }
1037    else if ((firstMatched = fr.matchSequence("DrawArrayLengths %w %i %i %i {")) ||
1038         fr.matchSequence("DrawArrayLengths %w %i %i {") )
1039    {
1040        int entry = fr[1].getNoNestedBrackets();
1041
1042        GLenum mode;
1043        Geometry_matchPrimitiveModeStr(fr[1].getStr(),mode);
1044
1045        int first;
1046        fr[2].getInt(first);
1047
1048        int capacity;
1049        fr[3].getInt(capacity);
1050
1051        int numInstances = 0;
1052        if (firstMatched)
1053        {
1054            fr[4].getInt(numInstances);
1055            fr += 6;
1056        }
1057        else
1058        {
1059            fr += 5;
1060        }
1061
1062        DrawArrayLengths* prim = new DrawArrayLengths;
1063        prim->setMode(mode);
1064        prim->setNumInstances(numInstances);
1065        prim->setFirst(first);
1066        prim->reserve(capacity);
1067
1068        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
1069        {
1070            unsigned int i;
1071            if (fr[0].getUInt(i))
1072            {
1073                prim->push_back(i);
1074                ++fr;
1075            }
1076        }
1077         ++fr;
1078
1079         geom.addPrimitiveSet(prim);
1080
1081        iteratorAdvanced = true;
1082    }
1083    else if ((firstMatched = fr.matchSequence("DrawElementsUByte %w %i %i {")) ||
1084         fr.matchSequence("DrawElementsUByte %w %i {"))
1085    {
1086        int entry = fr[1].getNoNestedBrackets();
1087
1088        GLenum mode;
1089        Geometry_matchPrimitiveModeStr(fr[1].getStr(),mode);
1090
1091        int capacity;
1092        fr[2].getInt(capacity);
1093
1094        int numInstances = 0;
1095        if (firstMatched)
1096        {
1097            fr[3].getInt(numInstances);
1098            fr += 5;
1099        }
1100        else
1101        {
1102            fr += 4;
1103        }
1104
1105        DrawElementsUByte* prim = new DrawElementsUByte;
1106        prim->setMode(mode);
1107        prim->setNumInstances(numInstances);
1108        prim->reserve(capacity);
1109
1110        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
1111        {
1112            unsigned int i;
1113            if (fr[0].getUInt(i))
1114            {
1115                prim->push_back(i);
1116                ++fr;
1117            }
1118        }
1119         ++fr;
1120
1121         geom.addPrimitiveSet(prim);
1122
1123        iteratorAdvanced = true;
1124    }
1125    else if ((firstMatched = fr.matchSequence("DrawElementsUShort %w %i %i {")) ||
1126         fr.matchSequence("DrawElementsUShort %w %i {"))
1127    {
1128        int entry = fr[1].getNoNestedBrackets();
1129
1130        GLenum mode;
1131        Geometry_matchPrimitiveModeStr(fr[1].getStr(),mode);
1132
1133        int capacity;
1134        fr[2].getInt(capacity);
1135
1136        int numInstances = 0;
1137        if (firstMatched)
1138        {
1139            fr[3].getInt(numInstances);
1140            fr += 5;
1141        }
1142        else
1143        {
1144            fr += 4;
1145        }
1146
1147        DrawElementsUShort* prim = new DrawElementsUShort;
1148        prim->setMode(mode);
1149        prim->setNumInstances(numInstances);
1150        prim->reserve(capacity);
1151
1152        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
1153        {
1154            unsigned int i;
1155            if (fr[0].getUInt(i))
1156            {
1157                prim->push_back(i);
1158                ++fr;
1159            }
1160        }
1161         ++fr;
1162
1163         geom.addPrimitiveSet(prim);
1164
1165        iteratorAdvanced = true;
1166    }
1167    else if ((firstMatched = fr.matchSequence("DrawElementsUInt %w %i %i {")) ||
1168              fr.matchSequence("DrawElementsUInt %w %i {"))
1169    {
1170        int entry = fr[1].getNoNestedBrackets();
1171
1172        GLenum mode;
1173        Geometry_matchPrimitiveModeStr(fr[1].getStr(),mode);
1174
1175        int capacity;
1176        fr[2].getInt(capacity);
1177
1178        int numInstances = 0;
1179        if (firstMatched)
1180        {
1181            fr[3].getInt(numInstances);
1182            fr += 5;
1183        }
1184        else
1185        {
1186            fr += 4;
1187        }
1188
1189        DrawElementsUInt* prim = new DrawElementsUInt;
1190        prim->setMode(mode);
1191        prim->setNumInstances(numInstances);
1192        prim->reserve(capacity);
1193
1194        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
1195        {
1196            unsigned int i;
1197            if (fr[0].getUInt(i))
1198            {
1199                prim->push_back(i);
1200                ++fr;
1201            }
1202        }
1203         ++fr;
1204
1205         geom.addPrimitiveSet(prim);
1206
1207        iteratorAdvanced = true;
1208    }
1209
1210    return iteratorAdvanced;
1211}
1212
1213bool Primitive_writeLocalData(const PrimitiveSet& prim,Output& fw)
1214{
1215
1216    switch(prim.getType())
1217    {
1218        case(PrimitiveSet::DrawArraysPrimitiveType):
1219            {
1220                const DrawArrays& cprim = static_cast<const DrawArrays&>(prim);
1221                fw<<cprim.className()<<" "<<Geometry_getPrimitiveModeStr(cprim.getMode())<<" "<<cprim.getFirst()<<" "<<cprim.getCount();
1222                if (prim.getNumInstances()>0) fw<<" "<<prim.getNumInstances();
1223                fw<<std::endl;
1224                return true;
1225            }
1226            break;
1227        case(PrimitiveSet::DrawArrayLengthsPrimitiveType):
1228            {
1229                const DrawArrayLengths& cprim = static_cast<const DrawArrayLengths&>(prim);
1230                fw<<cprim.className()<<" "<<Geometry_getPrimitiveModeStr(cprim.getMode())<<" "<<cprim.getFirst()<<" "<<cprim.size();
1231                if (prim.getNumInstances()>0) fw<<" "<<prim.getNumInstances();
1232                fw<<std::endl;
1233                writeArray(fw,cprim.begin(),cprim.end());
1234                return true;
1235            }
1236            break;
1237        case(PrimitiveSet::DrawElementsUBytePrimitiveType):
1238            {
1239                const DrawElementsUByte& cprim = static_cast<const DrawElementsUByte&>(prim);
1240                fw<<cprim.className()<<" "<<Geometry_getPrimitiveModeStr(cprim.getMode())<<" "<<cprim.size();
1241                if (prim.getNumInstances()>0) fw<<" "<<prim.getNumInstances();
1242                fw<<std::endl;
1243                writeArrayAsInts(fw,cprim.begin(),cprim.end());
1244                return true;
1245            }
1246            break;
1247        case(PrimitiveSet::DrawElementsUShortPrimitiveType):
1248            {
1249                const DrawElementsUShort& cprim = static_cast<const DrawElementsUShort&>(prim);
1250                fw<<cprim.className()<<" "<<Geometry_getPrimitiveModeStr(cprim.getMode())<<" "<<cprim.size();
1251                if (prim.getNumInstances()>0) fw<<" "<<prim.getNumInstances();
1252                fw<<std::endl;
1253                writeArray(fw,cprim.begin(),cprim.end());
1254                return true;
1255            }
1256            break;
1257        case(PrimitiveSet::DrawElementsUIntPrimitiveType):
1258            {
1259                const DrawElementsUInt& cprim = static_cast<const DrawElementsUInt&>(prim);
1260                fw<<cprim.className()<<" "<<Geometry_getPrimitiveModeStr(cprim.getMode())<<" "<<cprim.size();
1261                if (prim.getNumInstances()>0) fw<<" "<<prim.getNumInstances();
1262                fw<<std::endl;
1263                writeArray(fw,cprim.begin(),cprim.end());
1264                return true;
1265            }
1266            break;
1267        default:
1268            return false;
1269    }
1270}
1271
1272bool Geometry_writeLocalData(const Object& obj, Output& fw)
1273{
1274    const Geometry& geom = static_cast<const Geometry&>(obj);
1275
1276    const Geometry::PrimitiveSetList& primitives = geom.getPrimitiveSetList();
1277    if (!primitives.empty())
1278    {
1279        fw.indent() << "PrimitiveSets "<<primitives.size()<<std::endl;
1280        fw.indent() << "{"<<std::endl;
1281        fw.moveIn();
1282        for(Geometry::PrimitiveSetList::const_iterator itr=primitives.begin();
1283            itr!=primitives.end();
1284            ++itr)
1285        {
1286            fw.indent();
1287            Primitive_writeLocalData(**itr,fw);
1288        }
1289        fw.moveOut();
1290        fw.indent() << "}"<<std::endl;
1291    }
1292
1293    if (geom.getVertexArray())
1294    {
1295//         const Vec3Array& vertices = *geom.getVertexArray();
1296//         fw.indent()<<"VertexArray "<<vertices.size()<<std::endl;
1297//         Array_writeLocalData(fw,vertices.begin(),vertices.end(),1);
1298
1299        fw.indent()<<"VertexArray ";
1300        Array_writeLocalData(*geom.getVertexArray(),fw);
1301
1302    }
1303    if (geom.getVertexIndices())
1304    {
1305        fw.indent()<<"VertexIndices ";
1306        Array_writeLocalData(*geom.getVertexIndices(),fw);
1307    }
1308
1309    if (geom.getNormalArray())
1310    {
1311
1312        fw.indent()<<"NormalBinding "<<Geometry_getBindingTypeStr(geom.getNormalBinding())<<std::endl;
1313
1314//        const Vec3Array& normals = *geom.getNormalArray();
1315//        fw.indent()<<"NormalArray "<<normals.size()<<std::endl;
1316//        Array_writeLocalData(fw,normals.begin(),normals.end(),1);
1317
1318        fw.indent()<<"NormalArray ";
1319        Array_writeLocalData(*geom.getNormalArray(),fw);
1320
1321    }
1322    if (geom.getNormalIndices())
1323    {
1324        fw.indent()<<"NormalIndices ";
1325        Array_writeLocalData(*geom.getNormalIndices(),fw);
1326    }
1327
1328    if (geom.getColorArray())
1329    {
1330        fw.indent()<<"ColorBinding "<<Geometry_getBindingTypeStr(geom.getColorBinding())<<std::endl;
1331        fw.indent()<<"ColorArray ";
1332        Array_writeLocalData(*geom.getColorArray(),fw);
1333    }
1334    if (geom.getColorIndices())
1335    {
1336        fw.indent()<<"ColorIndices ";
1337        Array_writeLocalData(*geom.getColorIndices(),fw);
1338    }
1339
1340    if (geom.getSecondaryColorArray())
1341    {
1342        fw.indent()<<"SecondaryColorBinding "<<Geometry_getBindingTypeStr(geom.getSecondaryColorBinding())<<std::endl;
1343        fw.indent()<<"SecondaryColorArray ";
1344        Array_writeLocalData(*geom.getSecondaryColorArray(),fw);
1345    }
1346    if (geom.getSecondaryColorIndices())
1347    {
1348        fw.indent()<<"SecondayColorIndices ";
1349        Array_writeLocalData(*geom.getSecondaryColorIndices(),fw);
1350    }
1351
1352    if (geom.getFogCoordArray())
1353    {
1354        fw.indent()<<"FogCoordBinding "<<Geometry_getBindingTypeStr(geom.getFogCoordBinding())<<std::endl;
1355        fw.indent()<<"FogCoordArray ";
1356        Array_writeLocalData(*geom.getFogCoordArray(),fw);
1357    }
1358    if (geom.getFogCoordIndices())
1359    {
1360        fw.indent()<<"FogCoordIndices ";
1361        Array_writeLocalData(*geom.getFogCoordIndices(),fw);
1362    }
1363
1364    const Geometry::ArrayDataList& tcal=geom.getTexCoordArrayList();
1365    unsigned int i;
1366    for(i=0;i<tcal.size();++i)
1367    {
1368        if (tcal[i].array.valid())
1369        {
1370            fw.indent()<<"TexCoordArray "<<i<<" ";
1371            Array_writeLocalData(*(tcal[i].array),fw);
1372        }
1373        if (tcal[i].indices.valid())
1374        {
1375            fw.indent()<<"TexCoordIndices "<<i<<" ";
1376            Array_writeLocalData(*(tcal[i].indices),fw);
1377        }
1378    }
1379
1380    const Geometry::ArrayDataList& vaal=geom.getVertexAttribArrayList();
1381    for(i=0;i<vaal.size();++i)
1382    {
1383        const osg::Geometry::ArrayData& arrayData = vaal[i];
1384
1385        if (arrayData.array.valid())
1386        {
1387            fw.indent()<<"VertexAttribBinding "<<i<<" "<<Geometry_getBindingTypeStr(arrayData.binding)<<std::endl;
1388
1389            if (arrayData.normalize)
1390                fw.indent()<<"VertexAttribNormalize "<<i<<" TRUE"<<std::endl;
1391            else
1392                fw.indent()<<"VertexAttribNormalize "<<i<<" FALSE"<<std::endl;
1393
1394            fw.indent()<<"VertexAttribArray "<<i<<" ";
1395            Array_writeLocalData(*(arrayData.array),fw);
1396        }
1397        if (arrayData.indices.valid())
1398        {
1399            fw.indent()<<"VertexAttribIndices "<<i<<" ";
1400            Array_writeLocalData(*(arrayData.indices),fw);
1401        }
1402    }
1403
1404    return true;
1405}
1406
1407bool Geometry_matchBindingTypeStr(const char* str,Geometry::AttributeBinding& mode)
1408{
1409    if (strcmp(str,"OFF")==0) mode = Geometry::BIND_OFF;
1410    else if (strcmp(str,"OVERALL")==0) mode = Geometry::BIND_OVERALL;
1411    else if (strcmp(str,"PER_PRIMITIVE")==0) mode = Geometry::BIND_PER_PRIMITIVE;
1412    else if (strcmp(str,"PER_PRIMITIVE_SET")==0) mode = Geometry::BIND_PER_PRIMITIVE_SET;
1413    else if (strcmp(str,"PER_VERTEX")==0) mode = Geometry::BIND_PER_VERTEX;
1414    else return false;
1415    return true;
1416}
1417
1418
1419const char* Geometry_getBindingTypeStr(Geometry::AttributeBinding mode)
1420{
1421    switch(mode)
1422    {
1423        case (Geometry::BIND_OVERALL)           : return "OVERALL";
1424        case (Geometry::BIND_PER_PRIMITIVE)     : return "PER_PRIMITIVE";
1425        case (Geometry::BIND_PER_PRIMITIVE_SET) : return "PER_PRIMITIVE_SET";
1426        case (Geometry::BIND_PER_VERTEX)        : return "PER_VERTEX";
1427        case (Geometry::BIND_OFF)               :
1428        default                                        : return "OFF";
1429    }
1430}
1431
1432bool Geometry_matchPrimitiveModeStr(const char* str,GLenum& mode)
1433{
1434    if      (strcmp(str,"POINTS")==0)           mode = PrimitiveSet::POINTS;
1435    else if (strcmp(str,"LINES")==0)            mode = PrimitiveSet::LINES;
1436    else if (strcmp(str,"LINE_STRIP")==0)       mode = PrimitiveSet::LINE_STRIP;
1437    else if (strcmp(str,"LINE_LOOP")==0)        mode = PrimitiveSet::LINE_LOOP;
1438    else if (strcmp(str,"TRIANGLES")==0)        mode = PrimitiveSet::TRIANGLES;
1439    else if (strcmp(str,"TRIANGLE_STRIP")==0)   mode = PrimitiveSet::TRIANGLE_STRIP;
1440    else if (strcmp(str,"TRIANGLE_FAN")==0)     mode = PrimitiveSet::TRIANGLE_FAN;
1441    else if (strcmp(str,"QUADS")==0)            mode = PrimitiveSet::QUADS;
1442    else if (strcmp(str,"QUAD_STRIP")==0)       mode = PrimitiveSet::QUAD_STRIP;
1443    else if (strcmp(str,"POLYGON")==0)          mode = PrimitiveSet::POLYGON;
1444    else if (strcmp(str,"LINES_ADJACENCY")==0)          mode = PrimitiveSet::LINES_ADJACENCY;
1445    else if (strcmp(str,"LINE_STRIP_ADJACENCY")==0)     mode = PrimitiveSet::LINE_STRIP_ADJACENCY;
1446    else if (strcmp(str,"TRIANGLES_ADJACENCY")==0)      mode = PrimitiveSet::TRIANGLES_ADJACENCY;
1447    else if (strcmp(str,"TRIANGLE_STRIP_ADJECENCY")==0) mode = PrimitiveSet::TRIANGLE_STRIP_ADJACENCY;
1448    else if (strcmp(str,"TRIANGLE_STRIP_ADJACENCY")==0) mode = PrimitiveSet::TRIANGLE_STRIP_ADJACENCY;
1449    else if (strcmp(str,"PATCHES")==0)                  mode = PrimitiveSet::PATCHES;
1450    else return false;
1451    return true;
1452}
1453
1454
1455const char* Geometry_getPrimitiveModeStr(GLenum mode)
1456{
1457    switch(mode)
1458    {
1459        case (PrimitiveSet::POINTS)            : return "POINTS";
1460        case (PrimitiveSet::LINES)             : return "LINES";
1461        case (PrimitiveSet::LINE_STRIP)        : return "LINE_STRIP";
1462        case (PrimitiveSet::LINE_LOOP)         : return "LINE_LOOP";
1463        case (PrimitiveSet::TRIANGLES)         : return "TRIANGLES";
1464        case (PrimitiveSet::TRIANGLE_STRIP)    : return "TRIANGLE_STRIP";
1465        case (PrimitiveSet::TRIANGLE_FAN)      : return "TRIANGLE_FAN";
1466        case (PrimitiveSet::QUADS)             : return "QUADS";
1467        case (PrimitiveSet::QUAD_STRIP)        : return "QUAD_STRIP";
1468        case (PrimitiveSet::POLYGON)           : return "POLYGON";
1469        case (PrimitiveSet::LINES_ADJACENCY)            : return "LINES_ADJACENCY";
1470        case (PrimitiveSet::LINE_STRIP_ADJACENCY)       : return "LINE_STRIP_ADJACENCY";
1471        case (PrimitiveSet::TRIANGLES_ADJACENCY)        : return "TRIANGLES_ADJACENCY";
1472        case (PrimitiveSet::TRIANGLE_STRIP_ADJACENCY)   : return "TRIANGLE_STRIP_ADJACENCY";
1473        case (PrimitiveSet::PATCHES)                    : return "PATCHES";
1474        default                                         : return "UnknownPrimitveType";
1475    }
1476}
Note: See TracBrowser for help on using the browser.