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

Revision 13217, 22.8 kB (checked in by robert, 10 hours ago)

From Jason Beverage, "It looks like the Callback header got accidentally removed from the CMakeLists.txt in the submission yesterday for the geometry instancing example."

  • 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;
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;
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.