source: GTP/trunk/Lib/Illum/IllumModule/OgreIllumModule/src/RenderingRuns/OgreLightVolumeRenderingRun.cpp @ 2427

Revision 2427, 9.1 KB checked in by szirmay, 17 years ago (diff)
Line 
1#include "OgreLightVolumeRenderingRun.h"
2#include "OgreIlluminationManager.h"
3#include "OgreChildPSystemRenderingRun.h"
4
5
6
7OgreLightVolumeRenderingRun::OgreLightVolumeRenderingRun(OgreSharedRuns* sharedRuns,
8                                                                                                                   String name,
9                                                                                                                   unsigned long startFrame,
10                                                                                                                        unsigned long updateInterval,
11                                                                                                                        unsigned int resolution,
12                                                                                                                        unsigned int textureDepth,
13                                                                                                                   String materialName
14                                                                                                                   )
15                                                                                                                   :LightVolumeRenderingRun( startFrame, updateInterval, resolution, textureDepth)
16                                                                                                                   , OgreRenderingRun(startFrame, updateInterval)
17                                                                                                                   , RenderingRun(startFrame, updateInterval)
18{
19        this->sharedRuns = sharedRuns;
20        this->name = name;     
21        this->light = 0;
22        this->materialName = materialName;
23
24        volumeBuffer = 0;
25       
26               
27
28        createLightVolumeMap();
29}
30
31void OgreLightVolumeRenderingRun::createLightVolumeMap()
32{
33        TexturePtr texPtr = Ogre::TextureManager::getSingleton().createManual(name + "NoBlur",
34                                                                                                                                                "default",
35                                                                                                                                                TEX_TYPE_2D,
36                                                                                                                                                resolution,
37                                                                                                                                                resolution,
38                                                                                                                                                0,                                                                                                                                             
39                                                                                                                                                0,
40                                                                                                                                                PF_FLOAT16_RGBA,
41                                                                                                                                                TU_RENDERTARGET);
42        lightVolumeTexture = texPtr.getPointer();
43         lightVolumeCamera = Root::getSingleton()._getCurrentSceneManager()->createCamera(name + "_CAMERA");
44         //add viewport to rendertarget
45         HardwarePixelBuffer* hpb = (lightVolumeTexture->getBuffer()).getPointer();
46         RenderTarget* rt = hpb->getRenderTarget();
47         Viewport* v = rt->addViewport(lightVolumeCamera);
48         //Viewport* v = rt->addViewport(OgreIlluminationManager::getSingleton().getMainCamera());
49         v->setOverlaysEnabled(false);
50         v->setBackgroundColour(ColourValue::White);
51         rt->setAutoUpdated(false);
52       
53
54
55   
56         texPtr = Ogre::TextureManager::getSingleton().createManual(name,
57                                                                                                                                                "default",
58                                                                                                                                                TEX_TYPE_2D,
59                                                                                                                                                resolution,
60                                                                                                                                                resolution,
61                                                                                                                                                0,                                                                                                                                             
62                                                                                                                                                0,
63                                                                                                                                                PF_FLOAT16_RGBA,
64                                                                                                                                                TU_RENDERTARGET);
65        lightVolumeTexture2 = texPtr.getPointer();
66        hpb = (lightVolumeTexture2->getBuffer()).getPointer();
67        rt = hpb->getRenderTarget();
68        v = rt->addViewport(lightVolumeCamera);
69        v->setOverlaysEnabled(false);
70        v->setBackgroundColour(ColourValue::White);
71        rt->setAutoUpdated(false);
72        v->setClearEveryFrame(true);
73        SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
74        RenderQueue *rq = sm->getRenderQueue();
75        sm->setFindVisibleObjects(false);
76        rq->clear();
77        v->update();
78        sm->setFindVisibleObjects(true);
79        v->setClearEveryFrame(false);
80
81         if(textureDepth > 1)
82         {
83                TexturePtr texPtr3D = Ogre::TextureManager::getSingleton().createManual(name + "3D",
84                                                                                                                                                "default",
85                                                                                                                                                TEX_TYPE_3D,
86                                                                                                                                                resolution,
87                                                                                                                                                resolution,
88                                                                                                                                                textureDepth + 1,
89                                                                                                                                                0,
90                                                                                                                                                PF_FLOAT16_RGBA,
91                                                                                                                                                TU_DYNAMIC);
92                lightVolumeTexture3D = texPtr3D.getPointer();
93         }
94}
95
96void OgreLightVolumeRenderingRun::createVolumeBuffer()
97{
98                unsigned int buffersize = resolution * resolution * 4 * 2 * (textureDepth + 1);
99                volumeBuffer = new unsigned char[buffersize];
100
101                SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
102                RenderQueue* rq = sm->getRenderQueue();
103                RenderTarget* rt = lightVolumeTexture->getBuffer().getPointer()->getRenderTarget();
104                rq->clear();
105                //clear screen
106                sm->setFindVisibleObjects(false);
107                rt->update();
108                sm->setFindVisibleObjects(true);
109                //copy first slice
110                PixelBox volumePB(resolution, resolution, 3,PF_FLOAT16_RGBA, volumeBuffer);
111                PixelBox pb(resolution, resolution, 1,PF_FLOAT16_RGBA, volumeBuffer);
112                lightVolumeTexture->getBuffer()->blitToMemory(pb);
113                lightVolumeTexture3D->getBuffer()->blitFromMemory(volumePB);
114       
115}
116
117void OgreLightVolumeRenderingRun::updateFrame(unsigned long frameNum)
118{
119        if(textureDepth > 1 && volumeBuffer == 0)
120                createVolumeBuffer();
121
122        refreshLight();
123
124        SceneManager* sm = Ogre::Root::getSingleton()._getCurrentSceneManager();
125        RenderQueue* rq = sm->getRenderQueue();
126        rq->clear();
127
128        //((OgreSharedRuns*)sharedRuns->getRoot(ILLUMRUN_LIGHTVOLUME_MAP))->notifyCamera(lightVolumeCamera);
129        ((OgreSharedRuns*)sharedRuns->getRoot(ILLUMRUN_LIGHTVOLUME_MAP))->addRenderablesToQueue(rq, false);
130       
131        setMaterialForRenderables(materialName,rq);
132       
133        if(textureDepth == 1)
134        {
135                RenderTarget* rt = lightVolumeTexture->getBuffer().getPointer()->getRenderTarget();
136                rt->update();
137                restoreMaterials();
138
139                //do blending
140            rt = lightVolumeTexture2->getBuffer().getPointer()->getRenderTarget();
141            Material*  mat = (Material*) MaterialManager::getSingleton().getByName("GameTools/BlurLightVolume").getPointer();
142                mat->getTechnique(0)->getPass(0)->getTextureUnitState(0)->setTextureName(lightVolumeTexture->getName());
143                renderFullscreenQuad("GameTools/BlurLightVolume", rt);         
144
145
146        /*     
147                static int framecount = 0;
148                String filename = "lightvolume";
149                filename.append(this->name);
150                //filename.append(StringConverter::toString(framecount));
151                filename.append(".bmp");
152                if(framecount % 5 == 0)
153                        rt->writeContentsToFile(filename);
154                framecount++;
155*/
156        }
157        else
158        {
159                //for(unsigned int i = 0; i < textureDepth; i++)
160                unsigned int i = frameNum % textureDepth;
161                {
162                        //set camera nearplane
163                        Matrix4 proj;
164                        proj = Matrix4::IDENTITY;
165                        float fustrumDepth = (i + 1) * systemRadius / ((float) textureDepth);
166                        proj.setScale(Vector3(1.0 / systemRadius, 1.0 / systemRadius, -2.0 / fustrumDepth));
167                        proj.setTrans(Vector3(0,0,-1));
168                        lightVolumeCamera->setCustomProjectionMatrix(true,proj);
169                        //render
170                        RenderTarget* rt = lightVolumeTexture->getBuffer().getPointer()->getRenderTarget();
171                        rt->update();
172                        //copy texture data
173                        PixelBox volumePB(resolution, resolution, textureDepth, PF_FLOAT16_RGBA, volumeBuffer);
174                        PixelBox pb(resolution, resolution, 1,PF_FLOAT16_RGBA,
175                                                volumeBuffer + (i + 1) * resolution * resolution * 4 * 2);
176                        lightVolumeTexture->getBuffer()->blitToMemory(pb);
177                        lightVolumeTexture3D->getBuffer()->blitFromMemory(volumePB);
178                }
179                restoreMaterials();
180        }
181       
182       
183
184       
185
186        /*
187        PixelBox volumePB(resolution, resolution, 3,PF_FLOAT16_RGBA, volumeBuffer);
188        PixelBox pb(resolution, resolution, 1,PF_FLOAT16_RGBA, volumeBuffer);
189        lightVolumeTexture->getBuffer()->blitToMemory(pb);
190        lightVolumeTexture3D->getBuffer()->blitFromMemory(volumePB);
191        */
192       
193       
194
195       
196       
197}
198
199void OgreLightVolumeRenderingRun::refreshLight()
200{
201        SceneManager* sm = Root::getSingleton()._getCurrentSceneManager();
202        LightList list;
203        sm->_populateLightList(((OgreSharedRuns*)sharedRuns)->getRootPosition(ILLUMRUN_LIGHTVOLUME_MAP),100000, list);
204       
205        light = *(list.begin());
206
207        //if herarchical
208        float baseRad = 0.0;
209        RenderingRun* run = sharedRuns->getRun(ILLUMRUN_HPP_IMPOSTOR);
210        if( run != 0)
211        {
212                OgreChildPSystemRenderingRun* rrun = (OgreChildPSystemRenderingRun*) run->asOgreRenderingRun();
213                baseRad = rrun->getSmallSysRadius();
214                //set gpu program params
215                Material* m = (Material*) MaterialManager::getSingleton().getByName(materialName).getPointer();
216                GpuProgramParametersSharedPtr vp = m->getTechnique(0)->getPass(0)->getVertexProgramParameters();
217                vp->setNamedConstant("baseRadius",baseRad);             
218        }
219
220        if(light!= 0)
221        {
222                if(light->getType() == Light::LT_DIRECTIONAL)
223                {
224                        Vector3 dir = light->getDirection();
225                        dir.normalise();
226                        lightVolumeCamera->setDirection( dir );
227                        Real r = sharedRuns->getRootBoundingSphere(ILLUMRUN_LIGHTVOLUME_MAP).getRadius();
228                        r += baseRad;
229                        systemRadius = r;
230                        lightVolumeCamera->setPosition( sharedRuns->getRootPosition(ILLUMRUN_LIGHTVOLUME_MAP) - dir * r);
231                        lightVolumeCamera->setProjectionType(PT_ORTHOGRAPHIC);
232                        Matrix4 proj;
233                        proj = Matrix4::IDENTITY;
234                        proj.setScale(Vector3(1.0/r, 1.0/r, -1.0/r));
235                        proj.setTrans(Vector3(0,0,-1));
236                        lightVolumeCamera->setCustomProjectionMatrix(true,proj);
237                }
238                else
239                {                       
240                        Vector3 pos = light->getDerivedPosition();
241                        Vector3 dir = sharedRuns->getRootPosition(ILLUMRUN_LIGHTVOLUME_MAP) - pos;
242                        dir.normalise();
243                        Real r = sharedRuns->getRootBoundingSphere(ILLUMRUN_LIGHTVOLUME_MAP).getRadius();
244                        r += baseRad;
245                        lightVolumeCamera->setPosition( sharedRuns->getRootPosition(ILLUMRUN_LIGHTVOLUME_MAP) - dir * r);
246                        lightVolumeCamera->lookAt( sharedRuns->getRootPosition(ILLUMRUN_LIGHTVOLUME_MAP) );                     
247                        lightVolumeCamera->setProjectionType(PT_ORTHOGRAPHIC);
248                        Matrix4 proj;
249                        proj = Matrix4::IDENTITY;
250                        proj.setScale(Vector3(1.0/r, 1.0/r, -1/r));
251                        proj.setTrans(Vector3(0,0,-1));
252                        lightVolumeCamera->setCustomProjectionMatrix(true,proj);
253                }
254        }
255}
256
257void OgreLightVolumeRenderingRun::freeAllResources()
258{
259        this->lightVolumeTexture = 0;
260        this->lightVolumeTexture2 = 0;
261        this->lightVolumeTextureLast = 0;
262        this->lightVolumeTextureThis = 0;
263        this->lightVolumeTexture3D = 0;
264        TextureManager::getSingleton().remove(name);
265        TextureManager::getSingleton().remove(name + "NoBlur");
266        Root::getSingleton()._getCurrentSceneManager()->destroyCamera(name + "_CAMERA");       
267}
268
269
270 
Note: See TracBrowser for help on using the repository browser.