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

Revision 2321, 6.4 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->_findVisibleObjectsOC(cam, rt->getViewport(0), false, false, false);
91                                sm->_findVisibleObjects(cam, false);
92                                sm->_queueSkiesForRendering(cam);
93                                sm->setFindVisibleObjects(false);
94                        }
95                }
96                else
97                {
98                        rq->clear();
99                        sm->setFindVisibleObjects(false);               
100                }
101               
102                if(renderSelf)
103                {
104                        root->restoreVisibility();
105                        if(useSelfMaterial)
106                                root->setMaterial(selfMaterial);
107                        root->addRenderablesToQueue(rq);
108                }
109        }
110       
111
112       
113        rt->update();
114
115        //rt->writeContentsToFile( "cubeLayer" + StringConverter::toString(cubemapRunType)+ "face" +  StringConverter::toString(facenum) + ".dds");
116       
117        if(!renderAllwithOwnColor)
118        {
119                if(renderEnvironment && useEnvMaterial)
120                        restoreMaterials();
121                else
122                        sm->setFindVisibleObjects(true);
123               
124                if(!renderSelf)
125                        root->restoreVisibility();
126                else if(useSelfMaterial)
127                        root->restoreMaterial();
128        }
129
130        if(facenum == 5 && getMinMax)
131        {
132                getCubeMapMinMax();
133                this->sharedRuns->runUpdated(cubemapRunType, this);
134        }
135}
136
137void OgreCubeMapRenderingRun::getCubeMapMinMax()
138{
139    unsigned int buffersize = resolution * resolution * 4;
140        float* floatbuffer = new float[buffersize];
141        PixelBox lockBox(resolution, resolution, 1, PF_FLOAT32_RGBA, floatbuffer);
142       
143        float minX = 0;
144        float minY = 0;
145        float minZ = 0;
146        float minW = 0;
147        float maxX = 0;
148        float maxY = 0;
149        float maxZ = 0;
150        float maxW = 0;
151
152        bool first = true;
153               
154        for(int iFace = 0; iFace <6 ; iFace++)
155        {
156                this->cubemapTexture->getBuffer(iFace,0)->blitToMemory(lockBox);
157               
158                for(unsigned int i = 0; i < buffersize; i+= 4)
159                {
160                        float x = floatbuffer[i];
161                        float y = floatbuffer[i + 1];
162                        float z = floatbuffer[i + 2];
163                        float w = floatbuffer[i + 3];
164
165                        if(first && w != 0)
166                        {
167                                minX = x;
168                                minY = y;
169                                minZ = z;
170                                minW = w;
171                                maxX = x;
172                                maxY = y;
173                                maxZ = z;
174                                maxW = w;                               
175
176                                first = false;
177                        }
178                        else if( /*(x * x + y * y + z * z + w * w) != 0*/ w != 0)
179                        {
180                                if(x < minX)minX = x;
181                                if(y < minY)minY = y;
182                                if(z < minZ)minZ = z;
183                                if(w < minW)minW = w;
184
185                                if(x > maxX)maxX = x;
186                                if(y > maxY)maxY = y;
187                                if(z > maxZ)maxZ = z;
188                                if(w > maxW)maxW = w;
189                               
190                        }
191                }
192        }
193       
194        min.x = minX; min.y = minY; min.z = minZ; min.w = minW;
195        max.x = maxX; max.y = maxY; max.z = maxZ; max.w = maxW;
196
197   
198        delete[] floatbuffer;
199}
200
201bool OgreCubeMapRenderingRun::faceNeedsUpdate(int facenum)
202{       
203        if(useDistCalc || useFaceAngleCalc)
204        {
205                float chance1 = 1.0;
206                float chance2 = 1.0;
207               
208                Camera* mainCamera = OgreIlluminationManager::getSingleton().getMainCamera();
209
210                if(useDistCalc)
211                {
212                        Vector3 cubemapPosition = sharedRuns->getRootPosition(cubemapRunType);
213                        float objradius = sharedRuns->getRootBoundingSphere(cubemapRunType).getRadius();
214                        float fov = mainCamera->getFOVy().valueRadians() / 2.0;
215                        float dist = (cubemapPosition - mainCamera->getPosition()).length();
216                        float vangle = Math::ASin( objradius / dist).valueRadians();
217                        float angleratio = vangle / fov;
218                        chance1 = Math::Pow(angleratio, 1.0 / distTolerance);
219                }
220
221                if(useFaceAngleCalc)
222                {
223                        Vector3 faceDir = getCubeMapFaceDirection(facenum);                     
224                        Vector3 cameraDir = mainCamera->getDirection();
225                        float angle = faceDir.dotProduct(-1 * cameraDir);
226                        float facingforward = (angle + 1) / 2.0;
227                        chance2 = Math::Pow(facingforward, 1.0 / angleTolerance);
228                }
229       
230                float dice = Math::UnitRandom();
231                float chance = chance1 * chance2;
232
233                if(dice < chance)
234                {       
235                        return true;
236                }
237                else
238                {
239                        return false;
240                }
241        }
242
243        return true;
244}
245
246void OgreCubeMapRenderingRun::freeAllResources()
247{
248        this->cubemapTexture = 0;       
249        TextureManager::getSingleton().remove(name);
250        Root::getSingleton()._getCurrentSceneManager()->destroyCamera(name + "_CAMERA");       
251}
Note: See TracBrowser for help on using the repository browser.