source: GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderTechniques/OgreCubeMapRenderTechnique.cpp @ 1722

Revision 1722, 8.2 KB checked in by szirmay, 18 years ago (diff)
Line 
1#include "OgreCubeMapRenderTechnique.h"
2#include "OgreTechniqueGroup.h"
3#include "OgreCubeMapRenderingRun.h"
4
5OgreCubeMapRenderTechnique::OgreCubeMapRenderTechnique(unsigned long startFrame,
6                                                                                                                unsigned long cubeMapUpdateInterval,
7                                                                                                                unsigned int cubeMapResolution,                                                                                         
8                                                                                                                unsigned char texID,
9                                                                                                                bool useDistCalc,
10                                                                                                                bool useFaceAngleCalc,
11                                                                                                                float distTolerance,
12                                                                                                                float angleTolerance,
13                                                                                                                bool updateAllFace,
14                                                                                                                bool renderSelf,
15                                                                                                                bool renderEnvironment,
16                                                                                                                String selfMaterial,
17                                                                                                                String environmentMaterial,
18                                                                                                                Pass* pass,
19                                                                                                                OgreRenderable* parentRenderable,
20                                                                                                                OgreTechniqueGroup* parentTechniqueGroup,
21                                                                                                                bool createCubeRun)
22                                                        :OgreRenderTechnique( pass, parentRenderable, parentTechniqueGroup),
23                                                        CubeMapRenderTechnique(startFrame, cubeMapUpdateInterval, cubeMapResolution, useDistCalc, useFaceAngleCalc, distTolerance, angleTolerance, updateAllFace, renderSelf, renderEnvironment, parentRenderable, parentTechniqueGroup),
24                                                        RenderTechnique(parentRenderable, parentTechniqueGroup)
25{       
26        this->texID = texID;
27        this->selfMaterial = selfMaterial;
28        this->environmentMaterial = environmentMaterial;
29        texturePostFix = "_CUBEMAP";
30
31        if(createCubeRun)
32        {
33                if(sharedRuns->getRun(ILLUMRUN_CUBEMAP) == 0)
34                sharedRuns->addRun(ILLUMRUN_CUBEMAP, createCubeMapRun());
35
36                cubeMapRunChanged(sharedRuns->getRun(ILLUMRUN_CUBEMAP));
37        }
38}
39
40
41OgreCubeMapRenderTechnique::~OgreCubeMapRenderTechnique()
42{
43
44}
45
46void OgreCubeMapRenderTechnique::cubeMapRunChanged(RenderingRun* run)
47{
48        OgreCubeMapRenderingRun* cuberun =(OgreCubeMapRenderingRun*) (run->asOgreRenderingRun());
49        String cubemapname = cuberun->getCubeMapTextureName();
50       
51        pass->getTextureUnitState(texID)->setTextureName(cubemapname);
52}
53
54RenderingRun* OgreCubeMapRenderTechnique::createCubeMapRun()
55{
56        return new OgreCubeMapRenderingRun( (OgreSharedRuns*) parentTechniqueGroup->getSharedRuns(),
57                                                                                                parentOgreRenderable->getName()  + texturePostFix,
58                                                                                                startFrame,
59                                                                                                cubeMapUpdateInterval,
60                                                                                                cubeMapResolution,
61                                                                                                useDistCalc,
62                                                                                                useFaceAngleCalc,
63                                                                                                distTolerance,
64                                                                                                angleTolerance,
65                                                                                                updateAllFace,
66                                                                                                renderSelf,
67                                                                                                renderEnvironment,
68                                                                                                selfMaterial,
69                                                                                                environmentMaterial);
70}
71
72///Technique Parsers
73namespace CubemapParsers
74{
75        void parseStartFrame(String& params, RenderTechniqueFactory* factory)
76        {
77                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
78                f->startFrame =  StringConverter::parseUnsignedLong(params);
79        }
80        void parseCubeMapUpdateInterval(String& params, RenderTechniqueFactory* factory)
81        {
82                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
83                f->cubeMapUpdateInterval =  StringConverter::parseUnsignedLong(params);
84        }
85
86        void parseCubeMapResolution(String& params, RenderTechniqueFactory* factory)
87        {
88                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
89                f->cubeMapResolution =  StringConverter::parseUnsignedInt(params);
90        }
91
92        void parseTexID(String& params, RenderTechniqueFactory* factory)
93        {
94                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
95                f->texID =  StringConverter::parseUnsignedInt(params);
96        }
97
98        void parseUseDistCalc(String& params, RenderTechniqueFactory* factory)
99        {
100                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
101                // format: on/off tolerance(float)
102                StringVector vecparams = StringUtil::split(params, " \t");
103
104                if(StringConverter::parseBool(vecparams[0]))//on
105                {
106                        f->useDistCalc = true;
107
108                        if(vecparams.size()>1)
109                        {                       
110                                f->distTolerance = StringConverter::parseReal(vecparams[1]);
111                        }
112                }
113                else
114                {
115                        f->useDistCalc = false;
116                }
117        }
118
119        void parseUseFaceAngleCalc(String& params, RenderTechniqueFactory* factory)
120        {
121                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
122                // format: on/off tolerance(float)
123                StringVector vecparams = StringUtil::split(params, " \t");
124
125                if(StringConverter::parseBool(vecparams[0]))//on
126                {
127                        f->useFaceAngleCalc = true;
128
129                        if(vecparams.size()>1)
130                        {                       
131                                f->angleTolerance = StringConverter::parseReal(vecparams[1]);
132                        }
133                }
134                else
135                {
136                        f->useFaceAngleCalc = false;
137                }
138        }
139
140        void parseUpdateAllFace(String& params, RenderTechniqueFactory* factory)
141        {
142                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
143                f->updateAllFace =  StringConverter::parseBool(params);
144        }
145
146        void parseRenderSelf(String& params, RenderTechniqueFactory* factory)
147        {
148                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
149                f->renderSelf =  StringConverter::parseBool(params);
150        }
151
152        void parseRenderEnv(String& params, RenderTechniqueFactory* factory)
153        {
154                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
155                f->renderEnvironment =  StringConverter::parseBool(params);
156        }
157
158        void parseSelfMaterial(String& params, RenderTechniqueFactory* factory)
159        {
160                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
161                f->selfMaterial =  params;
162        }
163
164        void parseEnvMaterial(String& params, RenderTechniqueFactory* factory)
165        {
166                OgreCubeMapRenderTechniqueFactory* f = (OgreCubeMapRenderTechniqueFactory*) factory;
167                f->environmentMaterial =  params;
168        }
169}
170///Technique factory
171OgreCubeMapRenderTechniqueFactory::OgreCubeMapRenderTechniqueFactory()
172{
173       
174        using namespace CubemapParsers;
175
176        //register parsers
177        this->attributeParsers.insert(AttribParserList::value_type("start_frame", (ILLUM_ATTRIBUTE_PARSER) parseStartFrame));
178        this->attributeParsers.insert(AttribParserList::value_type("update_interval", (ILLUM_ATTRIBUTE_PARSER) parseCubeMapUpdateInterval));
179        this->attributeParsers.insert(AttribParserList::value_type("resolution", (ILLUM_ATTRIBUTE_PARSER) parseCubeMapResolution));
180        this->attributeParsers.insert(AttribParserList::value_type("texture_unit_id", (ILLUM_ATTRIBUTE_PARSER) parseTexID));
181        this->attributeParsers.insert(AttribParserList::value_type("distance_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseDistCalc));
182        this->attributeParsers.insert(AttribParserList::value_type("face_angle_calc", (ILLUM_ATTRIBUTE_PARSER) parseUseFaceAngleCalc));
183        this->attributeParsers.insert(AttribParserList::value_type("update_all_face", (ILLUM_ATTRIBUTE_PARSER) parseUpdateAllFace));
184        this->attributeParsers.insert(AttribParserList::value_type("render_self", (ILLUM_ATTRIBUTE_PARSER) parseRenderSelf));
185        this->attributeParsers.insert(AttribParserList::value_type("render_env", (ILLUM_ATTRIBUTE_PARSER) parseRenderEnv));
186        this->attributeParsers.insert(AttribParserList::value_type("self_material", (ILLUM_ATTRIBUTE_PARSER) parseSelfMaterial));
187        this->attributeParsers.insert(AttribParserList::value_type("env_material", (ILLUM_ATTRIBUTE_PARSER) parseEnvMaterial));
188
189}
190
191void OgreCubeMapRenderTechniqueFactory::resetParams()
192{
193        startFrame = 1;
194        cubeMapUpdateInterval = 1;
195        cubeMapResolution = 256;                                                                                               
196        texID = 0;
197        useDistCalc = 1;
198        useFaceAngleCalc = false;
199        distTolerance = 2.0;
200        angleTolerance = 2.0;
201        updateAllFace = false;
202        renderSelf = false;
203        renderEnvironment = true;
204        selfMaterial = "";
205        environmentMaterial = "";
206}
207
208OgreRenderTechnique* OgreCubeMapRenderTechniqueFactory::createInstance(
209                                                                                IllumTechniqueParams* params,
210                                                                                Pass* pass,
211                                                                                OgreRenderable* parentRenderable,
212                                                                                OgreTechniqueGroup* parentTechniqueGroup)
213{       
214        resetParams();
215        parseParams(params);
216       
217        OgreCubeMapRenderTechnique* result = new OgreCubeMapRenderTechnique(
218                                                                                                startFrame,
219                                                                                                cubeMapUpdateInterval,
220                                                                                                cubeMapResolution,
221                                                                                                texID,
222                                                                                                useDistCalc,
223                                                                                                useFaceAngleCalc,
224                                                                                                distTolerance,
225                                                                                                angleTolerance,
226                                                                                                updateAllFace,
227                                                                                                renderSelf,
228                                                                                                renderEnvironment,
229                                                                                                selfMaterial,
230                                                                                                environmentMaterial,
231                                                                                                pass,
232                                                                                                parentRenderable,
233                                                                                                parentTechniqueGroup,
234                                                                                                true);
235
236        return result;
237}
Note: See TracBrowser for help on using the repository browser.