source: GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderingRuns/OgreCubeMapRenderingRun.cpp @ 2055

Revision 2055, 6.1 KB checked in by szirmay, 17 years ago (diff)
Line 
1#include "OgreCubeMapRenderingRun.h"
2#include "OgreIlluminationManager.h"
3
4
5
6OgreCubeMapRenderingRun::OgreCubeMapRenderingRun(OgreSharedRuns* sharedRuns,
7                                                                                                                   String name,
8                                                                                                                   unsigned long startFrame,
9                                                                                                                   unsigned long updateInterval,
10                                                                                                                   unsigned int resolution,
11                                                                                                                   bool useDistCalc,
12                                                                                                                   bool useFaceAngleCalc,
13                                                                                                                   float distTolerance,
14                                                                                                                   float angleTolerance,
15                                                                                                                   bool updateAllFace,
16                                                                                                                   bool renderSelf,
17                                                                                                                   bool renderEnvironment,
18                                                                                                                   String selfMaterial,
19                                                                                                                   String environmentMaterial,
20                                                                                                                   bool getMinMax,
21                                                                                                                   RenderingRunType cubemapRunType)
22                                                                                                                   :CubeMapRenderingRun(startFrame, updateInterval, resolution, useDistCalc, useFaceAngleCalc, distTolerance, angleTolerance, updateAllFace, renderSelf, renderEnvironment)
23                                                        , OgreRenderingRun(startFrame, updateInterval)
24                                                        , RenderingRun(startFrame, updateInterval)
25
26{
27        this->getMinMax = getMinMax;
28        this->cubemapRunType = cubemapRunType;
29        this->sharedRuns = sharedRuns;
30        this->name = name;
31        this->selfMaterial = selfMaterial;
32        this->environmentMaterial = environmentMaterial;
33       
34        if(environmentMaterial == "")
35                useEnvMaterial = false;
36        else
37                useEnvMaterial = true;
38
39        if(selfMaterial == "")
40                useSelfMaterial = false;
41        else
42                useSelfMaterial = true;
43
44
45        createCubeMap();
46}
47
48void OgreCubeMapRenderingRun::createCubeMap()
49{
50        ColourValue clearColor = ColourValue::Black;
51        clearColor.a = 0.0;
52        cubemapTexture = createCubeRenderTexture(name,
53                                                                                                sharedRuns->getRootPosition(),
54                                                                                                resolution,
55                                                                                                PF_FLOAT16_RGBA,
56                                                                                                //PF_R8G8B8A8,
57                                                                                                0,
58                                                                                                clearColor);   
59}
60
61void OgreCubeMapRenderingRun::updateCubeFace(int facenum)
62{
63        OgreSharedRuns* root = (OgreSharedRuns*) sharedRuns->getRoot(cubemapRunType);
64        SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
65        RenderQueue* rq = sm->getRenderQueue();
66       
67        RenderTarget* rt = cubemapTexture->getBuffer(facenum, 0).getPointer()->getRenderTarget();
68        Camera*  cam =  rt->getViewport(0)->getCamera();
69        Vector3 center = sharedRuns->getRootPosition(cubemapRunType);
70        cam->setPosition(center);
71
72        bool renderAllwithOwnColor = false;
73
74        if(renderSelf && renderEnvironment && !useSelfMaterial && !useEnvMaterial)
75                renderAllwithOwnColor = true;
76
77        if(!renderAllwithOwnColor)
78        {
79                root->hide();
80
81                if(renderEnvironment)
82                {
83                        if(useEnvMaterial)
84                        {
85                                setMaterialForVisibles(environmentMaterial, cam);
86                                //sm->_queueSkiesForRendering(cam);                             
87                        }
88                        else
89                        {
90                                sm->_findVisibleObjects(cam, false);
91                                sm->_queueSkiesForRendering(cam);
92                                sm->setFindVisibleObjects(false);
93                        }
94                }
95                else
96                {
97                        rq->clear();
98                        sm->setFindVisibleObjects(false);               
99                }
100               
101                if(renderSelf)
102                {
103                        root->restoreVisibility();
104                        if(useSelfMaterial)
105                                root->setMaterial(selfMaterial);
106                        root->addRenderablesToQueue(rq);
107                }
108        }
109       
110
111       
112        rt->update();
113
114        //rt->writeContentsToFile( "cubeLayer" + StringConverter::toString(cubemapRunType)+ "face" +  StringConverter::toString(facenum) + ".dds");
115       
116        if(!renderAllwithOwnColor)
117        {
118                if(renderEnvironment && useEnvMaterial)
119                        restoreMaterials();
120                else
121                        sm->setFindVisibleObjects(true);
122               
123                if(!renderSelf)
124                        root->restoreVisibility();
125                else if(useSelfMaterial)
126                        root->restoreMaterial();
127        }
128
129        if(facenum == 5 && getMinMax)
130        {
131                getCubeMapMinMax();
132                this->sharedRuns->runUpdated(cubemapRunType, this);
133        }
134}
135
136void OgreCubeMapRenderingRun::getCubeMapMinMax()
137{
138    unsigned int buffersize = resolution * resolution * 4;
139        float* floatbuffer = new float[buffersize];
140        PixelBox lockBox(resolution, resolution, 1, PF_FLOAT32_RGBA, floatbuffer);
141       
142        float minX = 0;
143        float minY = 0;
144        float minZ = 0;
145        float minW = 0;
146        float maxX = 0;
147        float maxY = 0;
148        float maxZ = 0;
149        float maxW = 0;
150
151        bool first = true;
152               
153        for(int iFace = 0; iFace <6 ; iFace++)
154        {
155                this->cubemapTexture->getBuffer(iFace,0)->blitToMemory(lockBox);
156               
157                for(unsigned int i = 0; i < buffersize; i+= 4)
158                {
159                        float x = floatbuffer[i];
160                        float y = floatbuffer[i + 1];
161                        float z = floatbuffer[i + 2];
162                        float w = floatbuffer[i + 3];
163
164                        if(first && w != 0)
165                        {
166                                minX = x;
167                                minY = y;
168                                minZ = z;
169                                minW = w;
170                                maxX = x;
171                                maxY = y;
172                                maxZ = z;
173                                maxW = w;                               
174
175                                first = false;
176                        }
177                        else if( /*(x * x + y * y + z * z + w * w) != 0*/ w != 0)
178                        {
179                                if(x < minX)minX = x;
180                                if(y < minY)minY = y;
181                                if(z < minZ)minZ = z;
182                                if(w < minW)minW = w;
183
184                                if(x > maxX)maxX = x;
185                                if(y > maxY)maxY = y;
186                                if(z > maxZ)maxZ = z;
187                                if(w > maxW)maxW = w;
188                               
189                        }
190                }
191        }
192       
193        min.x = minX; min.y = minY; min.z = minZ; min.w = minW;
194        max.x = maxX; max.y = maxY; max.z = maxZ; max.w = maxW;
195
196   
197        delete[] floatbuffer;
198}
199
200bool OgreCubeMapRenderingRun::faceNeedsUpdate(int facenum)
201{       
202        if(useDistCalc || useFaceAngleCalc)
203        {
204                float chance1 = 1.0;
205                float chance2 = 1.0;
206               
207                Camera* mainCamera = OgreIlluminationManager::getSingleton().getMainCamera();
208
209                if(useDistCalc)
210                {
211                        Vector3 cubemapPosition = sharedRuns->getRootPosition(cubemapRunType);
212                        float objradius = sharedRuns->getRootBoundingSphere(cubemapRunType).getRadius();
213                        float fov = mainCamera->getFOVy().valueRadians() / 2.0;
214                        float dist = (cubemapPosition - mainCamera->getPosition()).length();
215                        float vangle = Math::ASin( objradius / dist).valueRadians();
216                        float angleratio = vangle / fov;
217                        chance1 = Math::Pow(angleratio, 1.0 / distTolerance);
218                }
219
220                if(useFaceAngleCalc)
221                {
222                        Vector3 faceDir = getCubeMapFaceDirection(facenum);                     
223                        Vector3 cameraDir = mainCamera->getDirection();
224                        float angle = faceDir.dotProduct(-1 * cameraDir);
225                        float facingforward = (angle + 1) / 2.0;
226                        chance2 = Math::Pow(facingforward, 1.0 / angleTolerance);
227                }
228       
229                float dice = Math::UnitRandom();
230                float chance = chance1 * chance2;
231
232                if(dice < chance)
233                {       
234                        return true;
235                }
236                else
237                {
238                        return false;
239                }
240        }
241
242        return true;
243}
Note: See TracBrowser for help on using the repository browser.