root/OpenSceneGraph/trunk/src/osgWrappers/deprecated-dotosg/osg/StateSet.cpp @ 14044

Revision 14044, 22.8 kB (checked in by robert, 42 hours ago)

Release OpenSceneGraph-3.3.3

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1#include <osg/StateSet>
2#include <osg/Texture1D>
3#include <osg/Texture2D>
4#include <osg/TextureCubeMap>
5#include <osg/TextureRectangle>
6#include <osg/TexGen>
7#include <osg/PolygonOffset>
8#include <osg/LineStipple>
9#include <osg/Light>
10#include <osg/ClipPlane>
11#include <osg/AlphaFunc>
12#include <osg/Point>
13#include <osg/Material>
14#include <osg/Fog>
15#include <osg/GL2Extensions>
16
17#include <osgDB/Registry>
18#include <osgDB/Input>
19#include <osgDB/Output>
20
21#include <OpenThreads/Mutex>
22#include <OpenThreads/ScopedLock>
23
24#include <set>
25#include <string.h>
26
27using namespace osg;
28using namespace osgDB;
29using namespace std;
30
31// forward declare functions to use later.
32bool GeoState_readLocalData(Object& obj, Input& fr);
33
34bool StateSet_readLocalData(Object& obj, Input& fr);
35bool StateSet_writeLocalData(const Object& obj, Output& fw);
36
37bool StateSet_matchModeStr(const char* str,StateAttribute::GLModeValue& mode);
38const char* StateSet_getModeStr(StateAttribute::GLModeValue mode);
39
40bool StateSet_matchRenderBinModeStr(const char* str,StateSet::RenderBinMode& mode);
41const char* StateSet_getRenderBinModeStr(StateSet::RenderBinMode mode);
42
43// register the read and write functions with the osgDB::Registry.
44REGISTER_DOTOSGWRAPPER(StateSet)
45(
46    new osg::StateSet,
47    "StateSet",
48    "Object StateSet",
49    &StateSet_readLocalData,
50    &StateSet_writeLocalData,
51    DotOsgWrapper::READ_AND_WRITE
52);
53
54// register the read and write functions with the osgDB::Registry.
55REGISTER_DOTOSGWRAPPER(GeoState)
56(
57    new osg::StateSet,
58    "GeoState",
59    "Object GeoState",
60    &GeoState_readLocalData,
61    NULL,
62    DotOsgWrapper::READ_ONLY
63);
64
65//
66// Set up the maps from name to GLMode and visa versa.
67//
68
69#define ADD_NAME(name,mode) _GLNameToGLModeMap[name]=mode; _GLModeToGLNameMap[mode]=name;
70
71struct ModesAndNames
72{
73    ModesAndNames();
74
75    typedef std::map<std::string,StateAttribute::GLMode>    GLNameToGLModeMap;
76    typedef std::map<StateAttribute::GLMode,std::string>    GLModeToGLNameMap;
77    typedef std::set<StateAttribute::GLMode>                TextureGLModeSet;
78
79    inline bool isTextureMode(int mode) const
80    {
81        return _TextureGLModeSet.find(mode)!=_TextureGLModeSet.end();
82    }
83
84    inline bool getGLModeForName(const std::string& str, osg::StateAttribute::GLMode& mode) const
85    {
86        GLNameToGLModeMap::const_iterator nitr = _GLNameToGLModeMap.find(str);
87        if (nitr!=_GLNameToGLModeMap.end())
88        {
89            mode = nitr->second;
90            return true;
91        }
92        else
93        {
94            return false;
95        }
96
97    }
98
99    inline bool getNameForGLMode(const osg::StateAttribute::GLMode& mode, std::string& str) const
100    {
101        GLModeToGLNameMap::const_iterator nitr = _GLModeToGLNameMap.find(mode);
102        if (nitr!=_GLModeToGLNameMap.end())
103        {
104            str = nitr->second;
105            return true;
106        }
107        else
108        {
109            return false;
110        }
111
112    }
113
114    GLNameToGLModeMap _GLNameToGLModeMap;
115    GLModeToGLNameMap _GLModeToGLNameMap;
116    TextureGLModeSet _TextureGLModeSet;
117};
118
119static ModesAndNames s_ModesAndNames;
120
121ModesAndNames::ModesAndNames()
122{
123    ADD_NAME("GL_ALPHA_TEST",GL_ALPHA_TEST)
124    ADD_NAME("GL_BLEND",GL_BLEND)
125    ADD_NAME("GL_COLOR_MATERIAL",GL_COLOR_MATERIAL)
126    ADD_NAME("GL_CULL_FACE",GL_CULL_FACE)
127    ADD_NAME("GL_DEPTH_TEST",GL_DEPTH_TEST)
128    ADD_NAME("GL_FOG",GL_FOG)
129    ADD_NAME("GL_LIGHTING",GL_LIGHTING)
130    ADD_NAME("GL_POINT_SMOOTH",GL_POINT_SMOOTH)
131    ADD_NAME("GL_LINE_STIPPLE",GL_LINE_STIPPLE)
132    ADD_NAME("GL_POLYGON_OFFSET_FILL",GL_POLYGON_OFFSET_FILL)
133    ADD_NAME("GL_POLYGON_OFFSET_LINE",GL_POLYGON_OFFSET_LINE)
134    ADD_NAME("GL_POLYGON_OFFSET_POINT",GL_POLYGON_OFFSET_POINT)
135    ADD_NAME("GL_COLOR_SUM",GL_COLOR_SUM);
136    ADD_NAME("GL_NORMALIZE",GL_NORMALIZE);
137    ADD_NAME("GL_RESCALE_NORMAL",GL_RESCALE_NORMAL);
138
139    ADD_NAME("GL_TEXTURE_1D",GL_TEXTURE_1D)
140    ADD_NAME("GL_TEXTURE_2D",GL_TEXTURE_2D)
141    ADD_NAME("GL_TEXTURE_3D",GL_TEXTURE_3D)
142
143    ADD_NAME("GL_TEXTURE_CUBE_MAP",GL_TEXTURE_CUBE_MAP);
144    ADD_NAME("GL_TEXTURE_RECTANGLE",GL_TEXTURE_RECTANGLE);
145
146    ADD_NAME("GL_TEXTURE_GEN_Q",GL_TEXTURE_GEN_Q)
147    ADD_NAME("GL_TEXTURE_GEN_R",GL_TEXTURE_GEN_R)
148    ADD_NAME("GL_TEXTURE_GEN_S",GL_TEXTURE_GEN_S)
149    ADD_NAME("GL_TEXTURE_GEN_T",GL_TEXTURE_GEN_T)
150
151    ADD_NAME("GL_STENCIL_TEST",GL_STENCIL_TEST)
152
153    ADD_NAME("GL_CLIP_PLANE0",GL_CLIP_PLANE0);
154    ADD_NAME("GL_CLIP_PLANE1",GL_CLIP_PLANE1);
155    ADD_NAME("GL_CLIP_PLANE2",GL_CLIP_PLANE2);
156    ADD_NAME("GL_CLIP_PLANE3",GL_CLIP_PLANE3);
157    ADD_NAME("GL_CLIP_PLANE4",GL_CLIP_PLANE4);
158    ADD_NAME("GL_CLIP_PLANE5",GL_CLIP_PLANE5);
159
160    ADD_NAME("GL_LIGHT0",GL_LIGHT0);
161    ADD_NAME("GL_LIGHT1",GL_LIGHT1);
162    ADD_NAME("GL_LIGHT2",GL_LIGHT2);
163    ADD_NAME("GL_LIGHT3",GL_LIGHT3);
164    ADD_NAME("GL_LIGHT4",GL_LIGHT4);
165    ADD_NAME("GL_LIGHT5",GL_LIGHT5);
166    ADD_NAME("GL_LIGHT6",GL_LIGHT6);
167    ADD_NAME("GL_LIGHT7",GL_LIGHT7);
168
169#if defined(OSG_GL3_AVAILABLE)
170    #define GL_VERTEX_PROGRAM_POINT_SIZE      0x8642
171    #define GL_VERTEX_PROGRAM_TWO_SIDE        0x8643
172#endif
173    ADD_NAME("GL_VERTEX_PROGRAM_POINT_SIZE", GL_VERTEX_PROGRAM_POINT_SIZE)
174    ADD_NAME("GL_VERTEX_PROGRAM_TWO_SIDE", GL_VERTEX_PROGRAM_TWO_SIDE)
175
176    _TextureGLModeSet.insert(GL_TEXTURE_1D);
177    _TextureGLModeSet.insert(GL_TEXTURE_2D);
178    _TextureGLModeSet.insert(GL_TEXTURE_3D);
179
180    _TextureGLModeSet.insert(GL_TEXTURE_CUBE_MAP);
181    _TextureGLModeSet.insert(GL_TEXTURE_RECTANGLE);
182
183    _TextureGLModeSet.insert(GL_TEXTURE_GEN_Q);
184    _TextureGLModeSet.insert(GL_TEXTURE_GEN_R);
185    _TextureGLModeSet.insert(GL_TEXTURE_GEN_S);
186    _TextureGLModeSet.insert(GL_TEXTURE_GEN_T);
187
188
189//     for(GLNameToGLModeMap::iterator itr=s_GLNameToGLModeMap.begin();
190//         itr!=s_GLNameToGLModeMap.end();
191//         ++itr)
192//     {
193//         cout << "Name ["<<itr->first<<","<<itr->second<<"]"<< std::endl;
194//     }
195}
196
197
198//////////////////////////////////////////////////////////////////////
199
200bool GeoState_readLocalData(Object& obj, Input& fr)
201{
202    bool iteratorAdvanced = false;
203
204    // note, StateSet replaced GeoState April 2001.
205    StateSet& statset = static_cast<StateSet&>(obj);
206
207    statset.setRenderingHint(StateSet::OPAQUE_BIN);
208
209    StateAttribute::GLModeValue mode;
210    if (fr[0].matchWord("transparency") && StateSet_matchModeStr(fr[1].getStr(),mode))
211    {
212        if (mode&StateAttribute::ON)
213        {
214            statset.setRenderingHint(StateSet::TRANSPARENT_BIN);
215        }
216        statset.setMode(GL_BLEND,mode);
217        fr+=2;
218        iteratorAdvanced = true;
219    }
220
221    if (fr[0].matchWord("antialiasing") && StateSet_matchModeStr(fr[1].getStr(),mode))
222    {
223        // what is the OpenGL modes for antialissing, need to look up.
224        // statset.setMode(GeoState::ANTIALIAS,mode);
225        fr+=2;
226        iteratorAdvanced = true;
227    }
228
229    if (fr[0].matchWord("face_culling") && StateSet_matchModeStr(fr[1].getStr(),mode))
230    {
231        statset.setMode(GL_CULL_FACE,mode);
232        fr+=2;
233        iteratorAdvanced = true;
234    }
235
236    if (fr[0].matchWord("lighting") && StateSet_matchModeStr(fr[1].getStr(),mode))
237    {
238        statset.setMode(GL_LIGHTING,mode);
239        fr+=2;
240        iteratorAdvanced = true;
241    }
242
243    if (fr[0].matchWord("texturing") && StateSet_matchModeStr(fr[1].getStr(),mode))
244    {
245        statset.setTextureMode(0,GL_TEXTURE_2D,mode);
246        fr+=2;
247        iteratorAdvanced = true;
248    }
249
250    if (fr[0].matchWord("fogging") && StateSet_matchModeStr(fr[1].getStr(),mode))
251    {
252        statset.setMode(GL_FOG,mode);
253        fr+=2;
254        iteratorAdvanced = true;
255    }
256
257    if (fr[0].matchWord("colortable") && StateSet_matchModeStr(fr[1].getStr(),mode))
258    {
259        // what is the OpenGL modes for colortable, need to look up...
260        // statset.setMode(GeoState::COLORTABLE,mode);
261        fr+=2;
262        iteratorAdvanced = true;
263    }
264
265    StateAttribute::GLModeValue texgening = StateAttribute::OFF;
266    if (fr[0].matchWord("texgening") && StateSet_matchModeStr(fr[1].getStr(),mode))
267    {
268        // leave up to a tex gen object to set modes associated with TexGen
269        // as there are mutiple modes associated with TexGen.  See below
270        // attribute reading code.
271        texgening = mode;
272        fr+=2;
273        iteratorAdvanced = true;
274    }
275
276    if (fr[0].matchWord("point_smoothing") && StateSet_matchModeStr(fr[1].getStr(),mode))
277    {
278        statset.setMode(GL_POINT_SMOOTH,mode);
279        fr+=2;
280        iteratorAdvanced = true;
281    }
282
283
284    if (fr[0].matchWord("polygon_offset") && StateSet_matchModeStr(fr[1].getStr(),mode))
285    {
286        // no GL mode associated with polygon offset so commenting out.
287        // statset.setMode(GeoState::POLYGON_OFFSET,mode);
288        fr+=2;
289        iteratorAdvanced = true;
290    }
291
292    if (fr[0].matchWord("alpha_test") && StateSet_matchModeStr(fr[1].getStr(),mode))
293    {
294        statset.setMode(GL_ALPHA_TEST,mode);
295        fr+=2;
296        iteratorAdvanced = true;
297    }
298
299
300    // new code using osg::Registry's list of prototypes to loaded attributes.
301    StateAttribute* attribute = NULL;
302    while((attribute=fr.readStateAttribute())!=NULL)
303    {
304        if (attribute->isTextureAttribute())
305        {
306            // remap to be a texture attribute
307            statset.setTextureAttribute(0,attribute);
308        }
309        else
310        {
311            statset.setAttribute(attribute);
312        }
313
314        if (attribute->getType()==StateAttribute::TEXGEN)
315            statset.setAssociatedModes(attribute,texgening);
316
317        iteratorAdvanced = true;
318    }
319
320    return iteratorAdvanced;
321}
322
323bool StateSet_readLocalData(Object& obj, Input& fr)
324{
325    bool iteratorAdvanced = false;
326
327    // note, StateSet replaced GeoState April 2001.
328    StateSet& stateset = static_cast<StateSet&>(obj);
329
330    // read the rendering hint value.
331    if (fr[0].matchWord("rendering_hint"))
332    {
333        if (fr[1].matchWord("DEFAULT_BIN"))
334        {
335            stateset.setRenderingHint(StateSet::DEFAULT_BIN);
336            fr+=2;
337            iteratorAdvanced = true;
338        }
339        else if (fr[1].matchWord("OPAQUE_BIN"))
340        {
341            stateset.setRenderingHint(StateSet::OPAQUE_BIN);
342            fr+=2;
343            iteratorAdvanced = true;
344        }
345        else if (fr[1].matchWord("TRANSPARENT_BIN"))
346        {
347            stateset.setRenderingHint(StateSet::TRANSPARENT_BIN);
348            fr+=2;
349            iteratorAdvanced = true;
350        }
351        else if (fr[1].isInt())
352        {
353            int value;
354            fr[1].getInt(value);
355            stateset.setRenderingHint(value);
356            fr+=2;
357            iteratorAdvanced = true;
358        }
359    }
360
361    bool setRenderBinDetails=false;
362    StateSet::RenderBinMode rbmode = stateset.getRenderBinMode();
363    if (fr[0].matchWord("renderBinMode") && StateSet_matchRenderBinModeStr(fr[1].getStr(),rbmode))
364    {
365        setRenderBinDetails=true;
366        fr+=2;
367        iteratorAdvanced = true;
368    }
369
370    int binNumber = stateset.getBinNumber();
371    if (fr[0].matchWord("binNumber") && fr[1].getInt(binNumber))
372    {
373        setRenderBinDetails=true;
374        fr+=2;
375        iteratorAdvanced = true;
376    }
377
378    std::string binName = stateset.getBinName();
379    if (fr[0].matchWord("binName"))
380    {
381        setRenderBinDetails=true;
382        binName = fr[1].getStr();
383
384        fr+=2;
385        iteratorAdvanced = true;
386    }
387
388    if (setRenderBinDetails)
389    {
390        stateset.setRenderBinDetails(binNumber,binName,rbmode);
391    }
392
393    while (fr.matchSequence("UpdateCallback {"))
394    {
395        // int entry = fr[0].getNoNestedBrackets();
396        fr += 2;
397        StateSet::Callback* callback = fr.readObjectOfType<StateSet::Callback>();
398        if (callback) {
399            stateset.setUpdateCallback(callback);
400        }
401        iteratorAdvanced = true;
402    }
403
404    while (fr.matchSequence("EventCallback {"))
405    {
406        //int entry = fr[0].getNoNestedBrackets();
407        fr += 2;
408        StateSet::Callback* callback = fr.readObjectOfType<StateSet::Callback>();
409        if (callback) {
410            stateset.setEventCallback(callback);
411        }
412        iteratorAdvanced = true;
413    }
414
415    bool readingMode = true;
416    StateAttribute::GLModeValue value;
417    while (readingMode)
418    {
419
420        readingMode=false;
421        if (fr[0].isInt())
422        {
423            if (StateSet_matchModeStr(fr[1].getStr(),value))
424            {
425                int mode;
426                fr[0].getInt(mode);
427
428                if (s_ModesAndNames.isTextureMode(mode))
429                {
430                    // remap to a texture unit.
431                    stateset.setTextureMode(0,(StateAttribute::GLMode)mode,value);
432                }
433                else
434                {
435                    stateset.setMode((StateAttribute::GLMode)mode,value);
436                }
437                fr+=2;
438                iteratorAdvanced = true;
439                readingMode=true;
440            }
441        }
442        else
443        if (fr[0].getStr())
444        {
445            if (StateSet_matchModeStr(fr[1].getStr(),value))
446            {
447                StateAttribute::GLMode mode=0;
448                if (s_ModesAndNames.getGLModeForName(fr[0].getStr(), mode))
449                {
450                    if (s_ModesAndNames.isTextureMode(mode))
451                    {
452                        // remap to a texture unit.
453                        stateset.setTextureMode(0,mode,value);
454                    }
455                    else
456                    {
457                        stateset.setMode(mode,value);
458                    }
459                    fr+=2;
460                    iteratorAdvanced = true;
461                    readingMode=true;
462                }
463            }
464        }
465    }
466
467    // new code using osg::Registry's list of prototypes to loaded attributes.
468    Uniform* uniform = NULL;
469    while((uniform=fr.readUniform())!=NULL)
470    {
471        stateset.addUniform(uniform);
472        iteratorAdvanced = true;
473    }
474
475
476    // new code using osg::Registry's list of prototypes to loaded attributes.
477    StateAttribute* attribute = NULL;
478    while((attribute=fr.readStateAttribute())!=NULL)
479    {
480        if (attribute->isTextureAttribute())
481        {
482            // remap to be a texture attribute
483            stateset.setTextureAttribute(0,attribute);
484        }
485        else
486        {
487            stateset.setAttribute(attribute);
488        }
489        iteratorAdvanced = true;
490    }
491
492    while(fr.matchSequence("textureUnit %i {"))
493    {
494        int entry = fr[0].getNoNestedBrackets();
495
496        unsigned int unit=0;
497        fr[1].getUInt(unit);
498        fr+=3;
499
500        while (!fr.eof() && fr[0].getNoNestedBrackets()>entry)
501        {
502            bool localIteratorAdvanced = false;
503
504            bool readingMode = true;
505            StateAttribute::GLModeValue value;
506            while (readingMode)
507            {
508                readingMode=false;
509                if (fr[0].isInt())
510                {
511                    if (StateSet_matchModeStr(fr[1].getStr(),value))
512                    {
513                        int mode;
514                        fr[0].getInt(mode);
515                        stateset.setTextureMode(unit,(StateAttribute::GLMode)mode,value);
516                        fr+=2;
517                        localIteratorAdvanced = true;
518                        readingMode=true;
519                    }
520                }
521                else
522                if (fr[0].getStr())
523                {
524                    if (StateSet_matchModeStr(fr[1].getStr(),value))
525                    {
526                        StateAttribute::GLMode mode=0;
527                        if (s_ModesAndNames.getGLModeForName(fr[0].getStr(), mode))
528                        {
529                            stateset.setTextureMode(unit,mode,value);
530                            fr+=2;
531                            localIteratorAdvanced = true;
532                            readingMode=true;
533                        }
534                    }
535                }
536            }
537
538            StateAttribute* attribute = NULL;
539            while((attribute=fr.readStateAttribute())!=NULL)
540            {
541                stateset.setTextureAttribute(unit,attribute);
542                localIteratorAdvanced = true;
543            }
544
545            if (!localIteratorAdvanced)
546                fr.advanceOverCurrentFieldOrBlock();
547        }
548
549        // skip over trailing '}'
550        ++fr;
551
552        iteratorAdvanced = true;
553
554    }
555
556
557
558
559    return iteratorAdvanced;
560}
561
562// visual studio 6.0 doesn't appear to define std::max?!? So do our own here..
563template<class T>
564T mymax(const T& a,const T& b)
565{
566    return (((a) > (b)) ? (a) : (b));
567}
568
569bool StateSet_writeLocalData(const Object& obj, Output& fw)
570{
571
572    const StateSet& stateset = static_cast<const StateSet&>(obj);
573
574    // write the rendering hint value.
575    fw.indent()<<"rendering_hint ";
576    switch(stateset.getRenderingHint())
577    {
578    case(StateSet::DEFAULT_BIN):
579        fw<<"DEFAULT_BIN"<< std::endl;
580        break;
581    case(StateSet::OPAQUE_BIN):
582        fw<<"OPAQUE_BIN"<< std::endl;
583        break;
584    case(StateSet::TRANSPARENT_BIN):
585        fw<<"TRANSPARENT_BIN"<< std::endl;
586        break;
587    default:
588        fw<<stateset.getRenderingHint()<< std::endl;
589        break;
590    }
591
592    fw.indent()<<"renderBinMode "<<StateSet_getRenderBinModeStr(stateset.getRenderBinMode())<< std::endl;
593    if (stateset.getRenderBinMode()!=StateSet::INHERIT_RENDERBIN_DETAILS)
594    {
595        fw.indent()<<"binNumber "<<stateset.getBinNumber()<< std::endl;
596        fw.indent()<<"binName "<<stateset.getBinName()<< std::endl;
597    }
598
599
600  const StateSet::ModeList& ml = stateset.getModeList();
601  for(StateSet::ModeList::const_iterator mitr=ml.begin();
602        mitr!=ml.end();
603        ++mitr)
604     {
605         std::string str;
606         if (s_ModesAndNames.getNameForGLMode(mitr->first, str))
607         {
608             fw.indent() << str << " " << StateSet_getModeStr(mitr->second) << std::endl;
609         }
610         else
611         {
612            // no name defined for GLMode so just pass its value to fw.
613             fw.indent() << "0x" << hex << (unsigned int)mitr->first << dec <<" " << StateSet_getModeStr(mitr->second) << std::endl;
614         }
615    }
616
617    const StateSet::UniformList& ul = stateset.getUniformList();
618    for(StateSet::UniformList::const_iterator uitr=ul.begin();
619        uitr!=ul.end();
620        ++uitr)
621    {
622        fw.writeObject(*(uitr->second.first));
623    }
624
625    const StateSet::AttributeList& sl = stateset.getAttributeList();
626    for(StateSet::AttributeList::const_iterator sitr=sl.begin();
627        sitr!=sl.end();
628        ++sitr)
629    {
630        fw.writeObject(*(sitr->second.first));
631    }
632
633
634    const StateSet::TextureModeList& tml = stateset.getTextureModeList();
635    const StateSet::TextureAttributeList& tal = stateset.getTextureAttributeList();
636    unsigned int maxUnit = mymax(tml.size(),tal.size());
637    for(unsigned int unit=0;unit<maxUnit;++unit)
638    {
639        fw.indent()<<"textureUnit "<<unit<<" {"<< std::endl;
640        fw.moveIn();
641
642        if (unit<tml.size())
643        {
644            const StateSet::ModeList& ml = tml[unit];
645            for(StateSet::ModeList::const_iterator mitr=ml.begin();
646                mitr!=ml.end();
647                ++mitr)
648            {
649                std::string str;
650                if (s_ModesAndNames.getNameForGLMode(mitr->first, str))
651                {
652                    fw.indent() << str << " " << StateSet_getModeStr(mitr->second) << std::endl;
653                }
654                else
655                {
656                    // no name defined for GLMode so just pass its value to fw.
657                    fw.indent() << "0x" << hex << (unsigned int)mitr->first << dec <<" " << StateSet_getModeStr(mitr->second) << std::endl;
658                }
659            }
660        }
661
662        if (unit<tal.size())
663        {
664            const StateSet::AttributeList& sl = tal[unit];
665            for(StateSet::AttributeList::const_iterator sitr=sl.begin();
666                sitr!=sl.end();
667                ++sitr)
668            {
669                fw.writeObject(*(sitr->second.first));
670            }
671        }
672
673        fw.moveOut();
674        fw.indent()<<"}"<< std::endl;
675    }
676
677    if (stateset.getUpdateCallback())
678    {
679        fw.indent() << "UpdateCallback {" << std::endl;
680        fw.moveIn();
681        fw.writeObject(*stateset.getUpdateCallback());
682        fw.moveOut();
683        fw.indent() << "}" << std::endl;
684    }
685
686    if (stateset.getEventCallback())
687    {
688        fw.indent() << "EventCallback {" << std::endl;
689        fw.moveIn();
690        fw.writeObject(*stateset.getEventCallback());
691        fw.moveOut();
692        fw.indent() << "}" << std::endl;
693    }
694
695    return true;
696}
697
698
699bool StateSet_matchModeStr(const char* str,StateAttribute::GLModeValue& mode)
700{
701    if (strcmp(str,"INHERIT")==0) mode = StateAttribute::INHERIT;
702    else if (strcmp(str,"ON")==0) mode = StateAttribute::ON;
703    else if (strcmp(str,"OFF")==0) mode = StateAttribute::OFF;
704    else if (strcmp(str,"OVERRIDE_ON")==0) mode = StateAttribute::OVERRIDE|StateAttribute::ON;
705    else if (strcmp(str,"OVERRIDE_OFF")==0) mode = StateAttribute::OVERRIDE|StateAttribute::OFF;
706    else if (strcmp(str,"OVERRIDE|ON")==0) mode = StateAttribute::OVERRIDE|StateAttribute::ON;
707    else if (strcmp(str,"OVERRIDE|OFF")==0) mode = StateAttribute::OVERRIDE|StateAttribute::OFF;
708    else if (strcmp(str,"PROTECTED|ON")==0) mode = StateAttribute::PROTECTED|StateAttribute::ON;
709    else if (strcmp(str,"PROTECTED|OFF")==0) mode = StateAttribute::PROTECTED|StateAttribute::OFF;
710    else if (strcmp(str,"PROTECTED|OVERRIDE|ON")==0) mode = StateAttribute::PROTECTED|StateAttribute::OVERRIDE|StateAttribute::ON;
711    else if (strcmp(str,"PROTECTED|OVERRIDE|OFF")==0) mode = StateAttribute::PROTECTED|StateAttribute::OVERRIDE|StateAttribute::OFF;
712    else return false;
713    return true;
714}
715
716
717const char* StateSet_getModeStr(StateAttribute::GLModeValue value)
718{
719    switch(value)
720    {
721        case(StateAttribute::INHERIT): return "INHERIT";
722        case(StateAttribute::ON): return "ON";
723        case(StateAttribute::OFF): return "OFF";
724        case(StateAttribute::OVERRIDE|StateAttribute::ON): return "OVERRIDE|ON";
725        case(StateAttribute::OVERRIDE|StateAttribute::OFF): return "OVERRIDE|OFF";
726        case(StateAttribute::PROTECTED|StateAttribute::ON): return "PROTECTED|ON";
727        case(StateAttribute::PROTECTED|StateAttribute::OFF): return "PROTECTED|OFF";
728        case(StateAttribute::PROTECTED|StateAttribute::OVERRIDE|StateAttribute::ON): return "PROTECTED|OVERRIDE|ON";
729        case(StateAttribute::PROTECTED|StateAttribute::OVERRIDE|StateAttribute::OFF): return "PROTECTED|OVERRIDE|OFF";
730    }
731    return "";
732}
733
734bool StateSet_matchRenderBinModeStr(const char* str,StateSet::RenderBinMode& mode)
735{
736    if (strcmp(str,"INHERIT")==0) mode = StateSet::INHERIT_RENDERBIN_DETAILS;
737    else if (strcmp(str,"USE")==0) mode = StateSet::USE_RENDERBIN_DETAILS;
738    else if (strcmp(str,"OVERRIDE")==0) mode = StateSet::OVERRIDE_RENDERBIN_DETAILS;
739    else if (strcmp(str,"ENCLOSE")==0) mode = StateSet::USE_RENDERBIN_DETAILS;
740    else return false;
741    return true;
742}
743
744const char* StateSet_getRenderBinModeStr(StateSet::RenderBinMode mode)
745{
746    switch(mode)
747    {
748        case(StateSet::INHERIT_RENDERBIN_DETAILS):  return "INHERIT";
749        case(StateSet::USE_RENDERBIN_DETAILS):      return "USE";
750        case(StateSet::OVERRIDE_RENDERBIN_DETAILS): return "OVERRIDE";
751    }
752    return "";
753}
Note: See TracBrowser for help on using the browser.