?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed: auto_ptr -> unique_ptr
[opensg.git] / Source / System / NodeCores / Groups / Light / Shadow / Engines / OSGSimpleShadowMapEngine.cpp
blob71f66493243d0b52d8155235bead82143e3512c9
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2002 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de *
10 * *
11 \*---------------------------------------------------------------------------*/
12 /*---------------------------------------------------------------------------*\
13 * License *
14 * *
15 * This library is free software; you can redistribute it and/or modify it *
16 * under the terms of the GNU Library General Public License as published *
17 * by the Free Software Foundation, version 2. *
18 * *
19 * This library is distributed in the hope that it will be useful, but *
20 * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
22 * Library General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU Library General Public *
25 * License along with this library; if not, write to the Free Software *
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
27 * *
28 \*---------------------------------------------------------------------------*/
29 /*---------------------------------------------------------------------------*\
30 * Changes *
31 * *
32 * *
33 * *
34 * *
35 * *
36 * *
37 \*---------------------------------------------------------------------------*/
38
39 #include <cstdlib>
40 #include <cstdio>
41
42 #include "OSGConfig.h"
43
44 #include "OSGSimpleShadowMapEngine.h"
45
46 #include "OSGMatrixCamera.h"
47
48 #include "OSGMatrixUtility.h"
49 #include "OSGRenderAction.h"
50
51 #include "OSGRenderPartition.h"
52 #include "OSGFrameBufferObject.h"
53 #include "OSGGroup.h"
54 #include "OSGChunkMaterial.h"
55
56 #include "OSGTextureBuffer.h"
57 #include "OSGTextureObjChunk.h"
58 #include "OSGPolygonChunk.h"
59 #include "OSGTexGenChunk.h"
60 #include "OSGBlendChunk.h"
61 #include "OSGImage.h"
62
63 OSG_USING_NAMESPACE
64
65 // Documentation for this class is emited in the
66 // OSGSimpleShadowMapEngineBase.cpp file.
67 // To modify it, please change the .fcd file (OSGSimpleShadowMapEngine.fcd) and
68 // regenerate the base file.
69
70
71 /*! \class OSG::SimpleShadowMapEngine
72 */
73
74 /*-------------------------------------------------------------------------*/
75 /* Sync */
76
77 void SimpleShadowMapEngine::changed(ConstFieldMaskArg whichField,
78 UInt32 origin,
79 BitVector details)
80 {
81 Inherited::changed(whichField, origin, details);
82 }
83
84 /*-------------------------------------------------------------------------*/
85 /* Dump */
86
87 void SimpleShadowMapEngine::dump( UInt32 uiIndent,
88 const BitVector bvFlags) const
89 {
90 Inherited::dump(uiIndent, bvFlags);
91 }
92
93 /*-------------------------------------------------------------------------*/
94 /* Constructors */
95
96 SimpleShadowMapEngine::SimpleShadowMapEngine(void) :
97 Inherited( )
98 {
99 }
100
101 SimpleShadowMapEngine::SimpleShadowMapEngine(
102 const SimpleShadowMapEngine &source) :
103
104 Inherited(source)
105 {
106 }
107
108 /*-------------------------------------------------------------------------*/
109 /* Destructor */
110
111 SimpleShadowMapEngine::~SimpleShadowMapEngine(void)
112 {
113 }
114
115
116 /*-------------------------------------------------------------------------*/
117 /* Init */
118
119 void SimpleShadowMapEngine::initMethod(InitPhase ePhase)
120 {
121 Inherited::initMethod(ePhase);
122
123 if(ePhase == TypeObject::SystemPost)
124 {
125 }
126 }
127
128 void SimpleShadowMapEngine::lightRenderEnter(Light *pLight,
129 RenderAction *pAction)
130 {
131 if(pLight->getOn() == false)
132 return;
133
134 StateChunk *pChunk = pLight->getChunk();
135
136 UInt32 uiSlot = pChunk->getClassId();
137
138 Int32 iLightIndex = pAction->allocateLightIndex();
139
140 // LightChunk *pLightChunk = dynamic_cast<LightChunk *>(pChunk);
141
142 // Color4f tmpVal(0.0, 0.0, 0.0, 1.0);
143
144 // pLightChunk->setAmbient(tmpVal);
145
146
147 if(iLightIndex >= 0)
148 {
149 pAction->addOverride(uiSlot + iLightIndex, pChunk);
150 }
151 else
152 {
153 SWARNING << "maximum light source limit ("
154 << -iLightIndex
155 << ") is reached"
156 << " skipping light sources!"
157 << std::endl;
158 }
159 }
160
161 void SimpleShadowMapEngine::setupCamera(Light *pLight,
162 LightTypeE eType,
163 RenderAction *pAction,
164 EngineDataPtr pEngineData)
165 {
166 if(eType == Directional)
167 {
168 DirectionalLight *pDLight =
169 dynamic_cast<DirectionalLight *>(pLight);
170
171 MatrixCameraUnrecPtr pCam =
172 dynamic_cast<MatrixCamera *>(pEngineData->getCamera());
173
174 if(pCam == NULL)
175 {
176 pCam = MatrixCamera::createLocal();
177
178 pEngineData->setCamera(pCam);
179 }
180
181
182 Vec3f diff;
183 Pnt3f center;
184 Matrix transMatrix;
185 Node *pNode = pAction->getActNode();
186
187 // tmpDir = DirectionalLightPtr::dcast(_lights[i]);
188
189 diff = (pNode->getVolume().getMax() -
190 pNode->getVolume().getMin());
191
192 Real32 sceneWidth = diff.length() * 0.5f;
193 // Not final values. May get tweaked in the future
194
195 Real32 sceneHeight = diff.length() * 0.5f;
196
197 pNode->getVolume().getCenter(center);
198
199 Vec3f lightdir = pDLight->getDirection();
200
201 if(pLight->getBeacon() != NULL)
202 {
203 Matrix m = pLight->getBeacon()->getToWorld();
204
205 m.mult(lightdir, lightdir);
206 }
207
208 MatrixLookAt(transMatrix,
209 center + lightdir,
210 center,
211 Vec3f(0,1,0));
212
213 transMatrix.invert();
214
215 Matrix proMatrix;
216
217 proMatrix.setIdentity();
218
219 MatrixOrthogonal( proMatrix,
220 -sceneWidth, sceneWidth, -sceneHeight,
221 sceneHeight, -sceneWidth, sceneWidth);
222
223
224 pCam->setProjectionMatrix(proMatrix );
225 pCam->setModelviewMatrix (transMatrix);
226 }
227 else if(eType == Point)
228 {
229 PointLight *pPLight = dynamic_cast<PointLight *>(pLight);
230
231 MatrixCameraUnrecPtr pCam =
232 dynamic_cast<MatrixCamera *>(pEngineData->getCamera());
233
234 if(pCam == NULL)
235 {
236 pCam = MatrixCamera::createLocal();
237
238 pEngineData->setCamera(pCam);
239 }
240
241 Real32 angle;
242 Vec3f dist;
243 Pnt3f center;
244 Vec3f diff;
245
246 Matrix transMatrix;
247
248 Node *pNode = pAction->getActNode();
249
250
251 pNode->getVolume().getCenter(center);
252
253 Pnt3f lightpos = pPLight->getPosition();
254
255 if(pLight->getBeacon() != NULL)
256 {
257 Matrix m = pLight->getBeacon()->getToWorld();
258
259 m.mult(lightpos, lightpos);
260 }
261
262
263 MatrixLookAt(transMatrix,
264 lightpos,
265 center,
266 Vec3f(0,1,0));
267
268 transMatrix.invert();
269
270
271 diff = (pNode->getVolume().getMax() -
272 pNode->getVolume().getMin());
273
274 dist = lightpos - center;
275
276 angle = atan((diff.length() * 0.5) / dist.length());
277
278 Matrix proMatrix;
279
280 proMatrix.setIdentity();
281
282 MatrixPerspective( proMatrix,
283 2.f * angle,
284 1,
285 pAction->getActivePartition()->getNear(),
286 pAction->getActivePartition()->getFar ());
287
288
289 pCam->setProjectionMatrix(proMatrix );
290 pCam->setModelviewMatrix (transMatrix);
291 }
292 }
293
294 void SimpleShadowMapEngine::setupLightChunk(Light *pLight,
295 LightTypeE eType,
296 RenderAction *pAction,
297 EngineDataPtr pEngineData)
298 {
299 if(eType == Directional)
300 {
301 DirectionalLight *pDLight =
302 dynamic_cast<DirectionalLight *>(pLight);
303
304 LightChunkUnrecPtr pChunk = pEngineData->getLightChunk();
305
306 if(pChunk == NULL)
307 {
308 pChunk = LightChunk::createLocal();
309
310 pEngineData->setLightChunk(pChunk);
311 }
312
313 Color4f tmpVal(0.0, 0.0, 0.0, 1.0);
314
315 pChunk->setSpecular(tmpVal);
316
317 tmpVal.setValuesRGBA(0.2f, 0.2f, 0.2f, 1.0f);
318
319 pChunk->setDiffuse (tmpVal);
320
321 tmpVal.setValuesRGBA(0.0, 0.0, 0.0, 1.0);
322
323 pChunk->setAmbient (tmpVal);
324
325 Vec4f dir(pDLight->getDirection());
326
327 dir[3] = 0;
328
329 pChunk->setPosition(dir);
330
331 pChunk->setBeacon(pLight->getBeacon());
332 }
333 else if(eType == Point)
334 {
335 PointLight *pPLight = dynamic_cast<PointLight *>(pLight);
336
337 LightChunkUnrecPtr pChunk = pEngineData->getLightChunk();
338
339 if(pChunk == NULL)
340 {
341 pChunk = LightChunk::createLocal();
342
343 pEngineData->setLightChunk(pChunk);
344 }
345
346 Color4f tmpVal(0.0, 0.0, 0.0, 1.0);
347
348 pChunk->setSpecular(tmpVal);
349
350 tmpVal.setValuesRGBA(this->getShadowColor()[0],
351 this->getShadowColor()[1],
352 this->getShadowColor()[2],
353 this->getShadowColor()[3]);
354
355 pChunk->setDiffuse (tmpVal);
356
357 tmpVal.setValuesRGBA(0.0, 0.0, 0.0, 1.0);
358
359 pChunk->setAmbient (tmpVal);
360
361 Vec4f pos(pPLight->getPosition());
362
363 pos[3] = 1;
364
365 pChunk->setPosition(pos);
366
367 pChunk->setBeacon(pLight->getBeacon());
368 }
369 }
370
371
372 void SimpleShadowMapEngine::doLightPass(Light *pLight,
373 RenderAction *pAction,
374 EngineDataPtr pEngineData)
375 {
376 this->pushPartition(pAction);
377
378 RenderPartition *pPart = pAction ->getActivePartition();
379 Viewarea *pArea = pAction ->getViewarea ();
380 Background *pBack = pAction ->getBackground ();
381
382 FrameBufferObject *pTarget = pEngineData->getRenderTarget();
383
384 if(pTarget == NULL)
385 {
386 FrameBufferObjectUnrecPtr pFBO = FrameBufferObject::createLocal();
387
388 pFBO->setWidth (this->getWidth ());
389 pFBO->setHeight(this->getHeight());
390
391 pEngineData->setRenderTarget(pFBO);
392
393 pTarget = pFBO;
394 }
395
396 TextureObjChunk *pTexChunk = pEngineData->getTexChunk();
397
398
399 TextureBufferUnrecPtr pTexBuffer = pEngineData->getTexBuffer();
400
401 if(pTexBuffer == NULL)
402 {
403 pTexBuffer = TextureBuffer::createLocal();
404
405 pEngineData->setTexBuffer (pTexBuffer);
406
407 pTexBuffer->setTexture (pTexChunk );
408 pTarget ->setDepthAttachment(pTexBuffer);
409 }
410
411 PolygonChunkUnrecPtr pPoly = pEngineData->getPolyChunk();
412
413 if(pPoly == NULL)
414 {
415 pPoly = PolygonChunk::createLocal();
416
417 pPoly->setOffsetBias (this->getOffsetBias ());
418 pPoly->setOffsetFactor(this->getOffsetFactor());
419 pPoly->setOffsetFill (true );
420
421 pEngineData->setPolyChunk(pPoly);
422 }
423
424 pPart->setRenderTarget(pTarget);
425
426 if(pArea != NULL)
427 {
428 Camera *pCam = pEngineData->getCamera();
429
430 pPart->setWindow (pAction->getWindow());
431
432 pPart->calcViewportDimension(0.f, 0.f, 1.f, 1.f,
433 pTarget->getWidth (),
434 pTarget->getHeight ());
435
436 Matrix m, t;
437
438 // set the projection
439 pCam->getProjection (m,
440 pPart->getViewportWidth (),
441 pPart->getViewportHeight());
442
443 pCam->getProjectionTranslation(t,
444 pPart->getViewportWidth (),
445 pPart->getViewportHeight());
446
447
448 pPart->setupProjection(m, t);
449
450 pCam->getViewing(m,
451 pPart->getViewportWidth (),
452 pPart->getViewportHeight());
453
454
455 pPart->setupViewing(m);
456
457 pPart->setNear (pCam->getNear());
458 pPart->setFar (pCam->getFar ());
459
460 pPart->calcFrustum ();
461
462 pPart->setBackground(pBack);
463 }
464
465 Node *pActNode = pAction->getActNode();
466
467 pAction->overrideMaterial(_pLightPassMat, pActNode);
468
469 pAction->pushState();
470
471 UInt32 uiPolySlot = pPoly->getClassId();
472
473 pAction->addOverride (uiPolySlot, pPoly);
474
475 // lightRenderEnter(pLight, pAction);
476
477 pAction->useNodeList(false);
478
479 this->recurseFrom(pAction, pLight);
480
481 pAction->popState();
482
483 pAction->overrideMaterial(NULL, pActNode);
484
485 this->popPartition(pAction);
486 }
487
488 void SimpleShadowMapEngine::doAmbientPass(Light *pLight,
489 RenderAction *pAction,
490 EngineDataPtr pEngineData)
491 {
492 this->pushPartition(pAction,
493 (RenderPartition::CopyViewing |
494 RenderPartition::CopyProjection |
495 RenderPartition::CopyWindow |
496 RenderPartition::CopyViewportSize |
497 RenderPartition::CopyFrustum |
498 RenderPartition::CopyNearFar ));
499
500 LightChunk *pChunk = pEngineData->getLightChunk();
501
502 UInt32 uiSlot = pChunk->getClassId();
503
504 Int32 iLightIndex = pAction->allocateLightIndex();
505
506 pAction->pushState();
507
508 if(iLightIndex >= 0)
509 {
510 pAction->addOverride(uiSlot + iLightIndex, pChunk);
511 }
512 else
513 {
514 SWARNING << "maximum light source limit ("
515 << -iLightIndex
516 << ") is reached"
517 << " skipping light sources!"
518 << std::endl;
519 }
520
521 pAction->useNodeList(false);
522
523 this->recurseFrom(pAction, pLight);
524
525 pAction->popState();
526
527 this->popPartition(pAction);
528 }
529
530 void SimpleShadowMapEngine::doFinalPass(Light *pLight,
531 RenderAction *pAction,
532 EngineDataPtr pEngineData)
533 {
534 this->pushPartition(pAction,
535 (RenderPartition::CopyViewing |
536 RenderPartition::CopyProjection |
537 RenderPartition::CopyWindow |
538 RenderPartition::CopyViewportSize |
539 RenderPartition::CopyFrustum |
540 RenderPartition::CopyNearFar ));
541
542 FrameBufferObject *pTarget = pEngineData->getRenderTarget();
543
544 if(pTarget == NULL)
545 {
546 FrameBufferObjectUnrecPtr pFBO = FrameBufferObject::createLocal();
547
548 pFBO->setWidth (this->getWidth ());
549 pFBO->setHeight(this->getHeight());
550
551 pEngineData->setRenderTarget(pFBO);
552
553 pTarget = pFBO;
554 }
555
556 BlendChunkUnrecPtr pBlender = pEngineData->getBlendChunk();
557
558 if(pBlender == NULL)
559 {
560 pBlender = BlendChunk::createLocal();
561
562 pBlender->setSrcFactor(GL_ONE);
563 pBlender->setDestFactor(GL_ONE);
564 pBlender->setAlphaFunc(GL_GEQUAL);
565 pBlender->setAlphaValue(0.99f);
566
567 pEngineData->setBlendChunk(pBlender);
568 }
569
570
571 Matrix4f projectionMatrix, viewMatrix, biasMatrix;
572
573 biasMatrix.setIdentity();
574 biasMatrix.setScale(0.5);
575 biasMatrix.setTranslate(0.5,0.5,0.5);
576
577 MatrixCamera *pCam = dynamic_cast<MatrixCamera *>(
578 pEngineData->getCamera());
579
580 pCam->getProjection(projectionMatrix,
581 this->getWidth (),
582 this->getHeight());
583
584 pCam->getViewing (viewMatrix,
585 this->getWidth (),
586 this->getHeight());
587
588 Matrix textureMatrix = biasMatrix;
589 textureMatrix.mult(projectionMatrix);
590 textureMatrix.mult(viewMatrix);
591
592 textureMatrix.transpose();
593 Vec4f ps = textureMatrix[0];
594 Vec4f pt = textureMatrix[1];
595 Vec4f pr = textureMatrix[2];
596 Vec4f pq = textureMatrix[3];
597
598 TexGenChunkUnrecPtr pTexGen = pEngineData->getTexGenChunk();
599
600 if(pTexGen == NULL)
601 {
602 pTexGen = TexGenChunk::createLocal();
603
604 pEngineData->setTexGenChunk(pTexGen);
605
606 pTexGen->setEyeModelViewMode(TexGenChunk::EyeModelViewCamera);
607
608 pTexGen->setGenFuncS(GL_EYE_LINEAR);
609 pTexGen->setGenFuncT(GL_EYE_LINEAR);
610 pTexGen->setGenFuncR(GL_EYE_LINEAR);
611 pTexGen->setGenFuncQ(GL_EYE_LINEAR);
612 }
613
614 pTexGen->setGenFuncSPlane(ps);
615 pTexGen->setGenFuncTPlane(pt);
616 pTexGen->setGenFuncRPlane(pr);
617 pTexGen->setGenFuncQPlane(pq);
618
619 TextureObjChunkUnrecPtr pTexChunk = pEngineData->getTexChunk();
620
621 if(pTexChunk == NULL)
622 {
623 pTexChunk = TextureObjChunk::createLocal();
624
625 pEngineData->setTexChunk(pTexChunk);
626
627 ImageUnrecPtr pImage = Image::createLocal();
628
629 // creates a image without allocating main memory.
630
631 pImage->set(Image::OSG_L_PF,
632 pTarget->getWidth (),
633 pTarget->getHeight(),
634 1,
635 1,
636 1,
637 0,
638 NULL,
639 Image::OSG_UINT8_IMAGEDATA,
640 false);
641
642
643 pTexChunk->setImage (pImage);
644 pTexChunk->setInternalFormat(GL_DEPTH_COMPONENT32);
645 pTexChunk->setExternalFormat(GL_DEPTH_COMPONENT);
646 pTexChunk->setMinFilter (GL_LINEAR);
647 pTexChunk->setMagFilter (GL_LINEAR);
648 pTexChunk->setWrapS (GL_CLAMP_TO_BORDER);
649 pTexChunk->setWrapT (GL_CLAMP_TO_BORDER);
650 // pTexChunk->setEnvMode (GL_MODULATE);
651 pTexChunk->setTarget (GL_TEXTURE_2D);
652
653 pTexChunk->setCompareMode(GL_COMPARE_R_TO_TEXTURE);
654 pTexChunk->setCompareFunc(GL_LEQUAL);
655 pTexChunk->setDepthMode (GL_INTENSITY);
656 }
657
658 pAction->pushState();
659
660 UInt32 uiBlendSlot = pBlender ->getClassId();
661 UInt32 uiTexSlot = pTexChunk->getClassId();
662 UInt32 uiTexGenSlot = pTexGen ->getClassId();
663
664 if(this->getForceTextureUnit() != -1)
665 {
666 uiTexSlot += this->getForceTextureUnit();
667 uiTexGenSlot += this->getForceTextureUnit();
668 }
669 else
670 {
671 uiTexSlot += 3;
672 uiTexGenSlot += 3;
673 }
674
675 pAction->addOverride(uiBlendSlot, pBlender );
676 pAction->addOverride(uiTexSlot, pTexChunk);
677 pAction->addOverride(uiTexGenSlot, pTexGen );
678
679 lightRenderEnter(pLight, pAction);
680
681 pAction->useNodeList(false);
682
683 this->recurseFrom(pAction, pLight);
684
685 pAction->popState();
686
687 this->popPartition(pAction);
688 }
689
690
691 Action::ResultE SimpleShadowMapEngine::runOnEnter(
692 Light *pLight,
693 LightTypeE eType,
694 RenderAction *pAction)
695 {
696 EngineDataUnrecPtr pEngineData =
697 pAction->getData<SimpleShadowMapEngineData *>(_iDataSlotId);
698
699 if(pEngineData == NULL)
700 {
701 pEngineData = EngineData::createLocal();
702
703 this->setData(pEngineData, _iDataSlotId, pAction);
704 }
705
706 BitVector bvMask = pAction->getPassMask() & (bvLightPassMask |
707 bvAmbientPassMask |
708 bvDiffusePassMask );
709
710 /*
711 fprintf(stderr, "%p %llu %llu | %llu %llu %llu\n",
712 this,
713 bvMask,
714 (bvLightPassMask |
715 bvAmbientPassMask |
716 bvDiffusePassMask ),
717 bvLightPassMask,
718 bvAmbientPassMask,
719 bvDiffusePassMask);
720 */
721
722 if(0x0000 != bvMask)
723 {
724 if(0x0000 != (bvMask & bvDiffusePassMask))
725 {
726 this->recurseFrom(pAction, pLight);
727
728 setupCamera (pLight, eType, pAction, pEngineData);
729 doFinalPass (pLight, pAction, pEngineData);
730 }
731
732 if(0x0000 != (bvMask & bvAmbientPassMask))
733 {
734 this->recurseFrom(pAction, pLight);
735
736 setupLightChunk(pLight, eType, pAction, pEngineData);
737 }
738
739 if(0x0000 != (bvMask & bvLightPassMask))
740 {
741 this->recurseFrom(pAction, pLight);
742
743 doLightPass (pLight, pAction, pEngineData);
744 }
745 }
746 else
747 {
748 setupCamera (pLight, eType, pAction, pEngineData);
749
750 setupLightChunk(pLight, eType, pAction, pEngineData);
751
752 pAction->addPassMask(bvDiffusePassMask);
753 doFinalPass (pLight, pAction, pEngineData);
754 pAction->subPassMask(bvDiffusePassMask);
755
756 pAction->addPassMask(bvAmbientPassMask);
757 doAmbientPass (pLight, pAction, pEngineData);
758 pAction->subPassMask(bvAmbientPassMask);
759
760 pAction->addPassMask(bvLightPassMask);
761 doLightPass (pLight, pAction, pEngineData);
762 pAction->subPassMask(bvLightPassMask);
763 }
764
765 return Action::Skip;
766 }
767
768 Action::ResultE SimpleShadowMapEngine::runOnLeave(
769 Light *pLight,
770 LightTypeE eType,
771 RenderAction *pAction)
772 {
773 return Action::Continue;
774 }
775