SLShadowMap Class Reference

Class for standard and cascaded shadow mapping. More...

#include <SLShadowMap.h>

Public Member Functions
	SLShadowMap (SLLight *light, const SLfloat lightClipNear=0.1f, const SLfloat lightClipFar=20.0f, const SLVec2f &size=SLVec2f(8, 8), const SLVec2i &texSize=SLVec2i(1024, 1024))
	Ctor for standard fixed sized shadow mapping without cascades. More...
	SLShadowMap (SLLight *light, SLCamera *camera, const SLVec2i &texSize=SLVec2i(1024, 1024), const SLint numCascades=4)
	Ctor for standard auto sized shadow mapping with cascades. More...
	~SLShadowMap ()
void	renderShadows (SLSceneView *sv, SLNode *root)
void	drawFrustum ()
	SLShadowMap::drawFrustum draws the volume affected by the shadow map. More...
void	drawRays ()
void	useCubemap (SLbool useCubemap)
void	rayCount (const SLVec2i &rayCount)
void	clipNear (SLfloat clipNear)
void	clipFar (SLfloat clipFar)
void	size (const SLVec2f &size)
void	textureSize (const SLVec2i &textureSize)
void	numCascades (int numCascades)
void	cascadesFactor (float factor)
SLProjType	projection ()
SLbool	useCubemap () const
SLbool	useCascaded () const
SLMat4f *	lightSpace ()
SLGLDepthBuffer *	depthBuffer ()
SLGLVDepthBuffer	depthBuffers ()
SLVec2i	rayCount ()
SLfloat	lightClipNear ()
SLfloat	lightClipFar ()
SLVec2f	size ()
SLVec2i	textureSize ()
int	numCascades ()
int	maxCascades ()
float	cascadesFactor ()
SLCamera *	camera ()

Static Public Attributes
static SLuint	drawCalls = 0
	NO. of draw calls for shadow mapping. More...

Private Member Functions
void	updateLightSpaces ()
	SLShadowMap::updateLightSpaces updates a light view projection matrix. More...
void	renderDirectionalLightCascaded (SLSceneView *sv, SLNode *root)
SLVVec2f	getShadowMapCascades (int numCascades, float camClipNear, float camClipFar)
void	drawNodesIntoDepthBufferRec (SLNode *node, SLSceneView *sv, SLMat4f &lightView)
void	lightCullingAdaptiveRec (SLNode *node, SLMat4f &lightProj, SLMat4f &lightView, SLPlane *lightFrustumPlanes, SLVNode &visibleNodes)
void	drawNodesDirectionalCulling (SLVNode visibleNodes, SLSceneView *sv, SLMat4f &lightView)

Private Attributes
SLLight *	_light
	The light which uses this shadow map. More...
SLProjType	_projection
	Projection to use to create shadow map. More...
SLbool	_useCubemap
	Flag if cubemap should be used for perspective projections. More...
SLbool	_useCascaded
	Flag if cascaded shadow maps should be used. More...
SLint	_numCascades
	Number of cascades for directional light shadow mapping. More...
SLint	_maxCascades
	Max. number of cascades for for which the shader gets generated. More...
SLfloat	_cascadesFactor
	Factor that determines the cascades distribution. More...
SLMat4f	_lightView [6]
	Light view matrices. More...
SLMat4f	_lightProj [6]
	Light projection matrices. More...
SLMat4f	_lightSpace [6]
	Light space matrices (= _lightProj * _lightView) More...
SLGLVDepthBuffer	_depthBuffers
	Vector of framebuffers with texture. More...
SLGLVertexArrayExt *	_frustumVAO
	Visualization of light-space-frustum. More...
SLVec2i	_rayCount
	Amount of rays drawn by drawRays() More...
SLMaterial *	_material
	Material used to render the shadow map. More...
SLfloat	_lightClipNear
	Light frustum near clipping plane. More...
SLfloat	_lightClipFar
	Light frustum far clipping plane. More...
SLVec2f	_size
	Height and width of the frustum (only for SLLightDirect non cascaded) More...
SLVec2f	_halfSize
	_size divided by two (only for SLLightDirect non cascaded) More...
SLVec2i	_textureSize
	Size of the shadow map texture. More...
SLCamera *	_camera
	Camera to witch the light frustums are adapted. More...

Detailed Description

Class for standard and cascaded shadow mapping.

Shadow mapping is a technique to render shadows. The scene gets rendered from the point of view of the lights which cast shadows. The resulting depth-map of that render-pass can be used to determine which fragments are affected by which lights. The standard fixed size shadow maps can be used with all light types. The auto sized shadow maps get automatically sized to a specified camera. At the moment only directional light get supported with multiple cascaded shadow maps.

Definition at line 38 of file SLShadowMap.h.

Constructor & Destructor Documentation

SLShadowMap() [1/2]

SLShadowMap::SLShadowMap	(	SLLight *	light,
		const SLfloat	lightClipNear = 0.1f,
		const SLfloat	lightClipFar = 20.0f,
		const SLVec2f &	size = SLVec2f(8, 8),
		const SLVec2i &	texSize = SLVec2i(1024, 1024)
	)

Ctor for standard fixed sized shadow mapping without cascades.

Ctor for standard fixed size shadow map for any type of light

Parameters

light	Pointer to the light for which the shadow is created
lightClipNear	The light frustums near clipping distance
lightClipFar	The light frustums near clipping distance
size	Ignored for rectangular lights
texSize	Shadow texture map size

Definition at line 38 of file SLShadowMap.cpp.

{
    assert(light && "SLShadowMap::SLShadowMap: No light passed");
    assert(lightClipFar > lightClipNear &&
           "SLShadowMap::SLShadowMap: Invalid clip distances passed");
 
    PROFILE_FUNCTION();
 
    if (typeid(*light) == typeid(SLLightDirect))
        _projection = P_monoOrthographic;
    else if (typeid(*light) == typeid(SLLightSpot))
        _projection = P_monoPerspective;
    else if (typeid(*light) == typeid(SLLightRect))
        _projection = P_monoPerspective;
    else
        SL_EXIT_MSG("SLShadowMap::SLShadowMap: Unknown light type");
 
    _light         = light;
    _useCubemap    = false;
    _useCascaded   = false;
    _depthBuffers  = SLGLVDepthBuffer();
    _frustumVAO    = nullptr;
    _rayCount      = SLVec2i(0, 0);
    _material      = nullptr;
    _lightClipNear = lightClipNear;
    _lightClipFar  = lightClipFar;
    _size          = size;
    _halfSize      = _size / 2;
    _textureSize   = texSize;
    _camera        = nullptr;
    _numCascades   = 0;
}

SLShadowMap() [2/2]

SLShadowMap::SLShadowMap	(	SLLight *	light,
		SLCamera *	camera,
		const SLVec2i &	texSize = SLVec2i(1024, 1024),
		const SLint	numCascades = 4
	)

Ctor for standard auto sized shadow mapping with cascades.

Ctor for auto sized cascaded shadow mapping

Parameters

light	Pointer to the light for which the shadow is created
camera	Pointer to the camera for witch the shadow map gets sized
texSize	Shadow texture map size (equal for all cascades)
numCascades	NO. of cascades for cascaded shadow mapping

Definition at line 81 of file SLShadowMap.cpp.

{
    assert(light && "SLShadowMap::SLShadowMap: No light passed");
    assert(camera && "SLShadowMap::SLShadowMap: No camera passed");
    assert(numCascades >= 0 && numCascades <= 5 &&
           "SLShadowMap::SLShadowMap: Invalid NO.of cascades (0-5)");
 
    PROFILE_FUNCTION();
 
    if (typeid(*light) == typeid(SLLightDirect))
        _projection = P_monoOrthographic;
    else
        SL_EXIT_MSG("Auto sized shadow maps only exist for directional lights yet.");
 
    _light          = light;
    _useCubemap     = false;
    _useCascaded    = true;
    _depthBuffers   = SLGLVDepthBuffer();
    _frustumVAO     = nullptr;
    _rayCount       = SLVec2i(0, 0);
    _material       = nullptr;
    _camera         = camera;
    _numCascades    = numCascades;
    _maxCascades    = numCascades;
    _textureSize    = texSize;
    _size           = SLVec2f(0, 0); // will be ignored and automatically calculated
    _halfSize       = SLVec2f(0, 0); // will be ignored and automatically calculated
    _lightClipNear  = 0.1f;          // will be ignored and automatically calculated
    _lightClipFar   = 20.f;          // will be ignored and automatically calculated
    _cascadesFactor = 30.f;
}

~SLShadowMap()

SLShadowMap::~SLShadowMap

(

)

Definition at line 116 of file SLShadowMap.cpp.

{
    _depthBuffers.erase(_depthBuffers.begin(), _depthBuffers.end());
    delete _frustumVAO;
    delete _material;
}

Member Function Documentation

camera()

SLCamera* SLShadowMap::camera ( )

inline

Definition at line 90 of file SLShadowMap.h.

{ return _camera; }

cascadesFactor() [1/2]

float SLShadowMap::cascadesFactor ( )

inline

Definition at line 89 of file SLShadowMap.h.

{ return _cascadesFactor; }

cascadesFactor() [2/2]

void SLShadowMap::cascadesFactor ( float  factor )

inline

Definition at line 73 of file SLShadowMap.h.

{ _cascadesFactor = factor; }

clipFar()

void SLShadowMap::clipFar ( SLfloat  clipFar )

inline

Definition at line 65 of file SLShadowMap.h.

{ _lightClipFar = clipFar; }

clipNear()

void SLShadowMap::clipNear ( SLfloat  clipNear )

inline

Definition at line 64 of file SLShadowMap.h.

{ _lightClipNear = clipNear; }

depthBuffer()

SLGLDepthBuffer* SLShadowMap::depthBuffer ( )

inline

Definition at line 80 of file SLShadowMap.h.

{ return _depthBuffers.at(0); }

depthBuffers()

SLGLVDepthBuffer SLShadowMap::depthBuffers ( )

inline

Definition at line 81 of file SLShadowMap.h.

{ return _depthBuffers; }

drawFrustum()

void SLShadowMap::drawFrustum

(

)

SLShadowMap::drawFrustum draws the volume affected by the shadow map.

Definition at line 124 of file SLShadowMap.cpp.

{
    // clang-format off
    static SLVVec3f P = {
        {-1,  1, -1}, { 1,  1, -1}, // lower rect
        {-1,  1, -1}, {-1,  1,  1},
        { 1,  1,  1}, {-1,  1,  1},
        { 1,  1,  1}, { 1,  1, -1},
 
        {-1, -1, -1}, { 1, -1, -1}, // upper rect
        {-1, -1, -1}, {-1, -1,  1},
        { 1, -1,  1}, {-1, -1,  1},
        { 1, -1,  1}, { 1, -1, -1},
 
        {-1, -1, -1}, {-1,  1, -1}, // vertical lines
        { 1, -1, -1}, { 1,  1, -1},
        {-1, -1,  1}, {-1,  1,  1},
        { 1, -1,  1}, { 1,  1,  1},
    };
    // clang-format on
 
    if (_frustumVAO == nullptr)
    {
        _frustumVAO = new SLGLVertexArrayExt();
        _frustumVAO->generateVertexPos(&P);
    }
 
    SLGLState* stateGL = SLGLState::instance();
 
    if (_useCascaded)
    {
        for (SLint i = 0; i < _numCascades; ++i)
        {
            // Inverse matrix in a way to avoid precision error
            SLMat4f s, t;
            s.scale(1.0f / _lightProj[i].m(0), 1.0f / _lightProj[i].m(5), 1.0f / _lightProj[i].m(10));
            t.translate((-_lightProj[i].m(12)), (-_lightProj[i].m(13)), (-_lightProj[i].m(14)));
 
            stateGL->modelMatrix = _lightView[i].inverted() * s * t;
            _frustumVAO->drawArrayAsColored(PT_lines,
                                            SLCol4f::GREEN,
                                            1.0f,
                                            0,
                                            (SLuint)P.size());
        }
    }
    else
    {
        for (SLint i = 0; i < (_useCubemap ? 6 : 1); ++i)
        {
            stateGL->modelMatrix = _lightSpace[i].inverted();
            _frustumVAO->drawArrayAsColored(PT_lines,
                                            SLCol4f::GREEN,
                                            1.0f,
                                            0,
                                            (SLuint)P.size());
        }
    }
}

drawNodesDirectionalCulling()

void SLShadowMap::drawNodesDirectionalCulling ( SLVNode  visibleNodes, SLSceneView *  sv, SLMat4f &  lightView  )

private

SLShadowMap::drawNodesDirectionalCulling draw all nodes in the vector visibleNodes.

Parameters

visibleNodes	Vector of visible nodes
sv	Pointer to the sceneview
lightView	The light view matrix

Definition at line 397 of file SLShadowMap.cpp.

{
    SLGLState* stateGL = SLGLState::instance();
 
    for (SLNode* node : visibleNodes)
    {
        if (node->castsShadows() &&
            node->mesh() &&
            node->mesh()->primitive() >= GL_TRIANGLES)
        {
            stateGL->viewMatrix  = lightView;
            stateGL->modelMatrix = node->updateAndGetWM();
            node->mesh()->drawIntoDepthBuffer(sv, node, _material);
            SLShadowMap::drawCalls++;
        }
    }
}

drawNodesIntoDepthBufferRec()

void SLShadowMap::drawNodesIntoDepthBufferRec ( SLNode *  node, SLSceneView *  sv, SLMat4f &  lightView  )

private

Recursive node drawing function for standard shadow map drawing.

Parameters

node	The node do draw
sv	Pointer to the sceneview
lightView	The light view matrix

Definition at line 422 of file SLShadowMap.cpp.

{
    assert(node && "SLShadowMap::drawNodesIntoDepthBufferRec: No node passed.");
 
    if (node->drawBit(SL_DB_HIDDEN))
        return;
    SLGLState* stateGL   = SLGLState::instance();
    stateGL->viewMatrix  = lightView;
    stateGL->modelMatrix = node->updateAndGetWM();
 
    if (node->castsShadows() &&
        node->mesh() &&
        node->mesh()->primitive() >= GL_TRIANGLES)
    {
        node->mesh()->drawIntoDepthBuffer(sv, node, _material);
        SLShadowMap::drawCalls++;
    }
 
    for (SLNode* child : node->children())
        drawNodesIntoDepthBufferRec(child, sv, lightView);
}

drawRays()

void SLShadowMap::drawRays

(

)

SLShadowMap::drawRays draws sample rays of the light for visualization purpose only. Gets turned on when the light node is selected.

Definition at line 188 of file SLShadowMap.cpp.

{
#ifndef SL_GLES              // Reading the depth-buffer with GLES is non-trivial
 
    if (_useCubemap) return; // Not implemented for cubemaps
    SLint w = _rayCount.x;
    SLint h = _rayCount.y;
    if (w == 0 || h == 0) return;
 
    SLGLState* stateGL = SLGLState::instance();
    SLVVec3f   P;
 
    _depthBuffers[0]->bind();
 
    SLfloat  pixelWidth  = (SLfloat)_textureSize.x / w;
    SLfloat  pixelHeight = (SLfloat)_textureSize.y / h;
    SLfloat* depths      = _depthBuffers[0]->readPixels();
 
    for (SLint x = 0; x < w; ++x)
    {
        for (SLint y = 0; y < h; ++y)
        {
            SLint   pixelX     = (SLint)(pixelWidth * (x + 0.5f));
            SLint   pixelY     = (SLint)(pixelHeight * (y + 0.5f));
            SLfloat viewSpaceX = Utils::lerp((x + 0.5f) / w, -1.0f, 1.0f);
            SLfloat viewSpaceY = Utils::lerp((y + 0.5f) / h, -1.0f, 1.0f);
            SLfloat depth      = depths[pixelY * _depthBuffers[0]->dimensions().x + pixelX] * 2 - 1;
            if (depth == 1.0f)
                continue;
            P.push_back(SLVec3f(viewSpaceX, viewSpaceY, -1.0f));
            P.push_back(SLVec3f(viewSpaceX, viewSpaceY, depth));
        }
    }
 
    delete depths;
    _depthBuffers[0]->unbind();
    if (P.empty()) return;
 
    SLGLVertexArrayExt vao;
    vao.generateVertexPos(&P);
 
    stateGL->modelMatrix = _lightSpace[0].inverted();
    vao.drawArrayAsColored(PT_lines,
                           SLCol4f::YELLOW,
                           1.0f,
                           0,
                           (SLuint)P.size());
 
#endif
}

getShadowMapCascades()

SLVVec2f SLShadowMap::getShadowMapCascades ( int  numCascades, float  camClipNear, float  camClipFar  )

private

Returns a vector of near and far clip distances for all shadow cascades along the cameras view direction.

Parameters

numCascades	NO. of cascades
camClipNear	The cameras near clipping distance
camClipFar	The cameras far clipping distance

Returns

A SLVVec2f vector with the near and far clip distances

Definition at line 536 of file SLShadowMap.cpp.

{
    SLVVec2f cascades;
 
    float ni, fi = camClipNear;
 
    for (int i = 0; i < numCascades; i++)
    {
        ni = fi;
        fi = _cascadesFactor *
             camClipNear *
             pow((camClipFar / (_cascadesFactor * camClipNear)),
                 (float)(i + 1) / (float)numCascades);
 
        cascades.push_back(SLVec2f(ni, fi));
    }
    return cascades;
}

lightClipFar()

SLfloat SLShadowMap::lightClipFar ( )

inline

Definition at line 84 of file SLShadowMap.h.

{ return _lightClipFar; }

lightClipNear()

SLfloat SLShadowMap::lightClipNear ( )

inline

Definition at line 83 of file SLShadowMap.h.

{ return _lightClipNear; }

lightCullingAdaptiveRec()

void SLShadowMap::lightCullingAdaptiveRec ( SLNode *  node, SLMat4f &  lightProj, SLMat4f &  lightView, SLPlane *  lightFrustumPlanes, SLVNode &  visibleNodes  )

private

Returns the visible nodes inside the light frustum Check if the passed node is inside the light frustum and add if so to the visibleNodes vector. The goal is to exit this function as fast as possible if the node is not visible from the light hence gets not lighted.

Parameters

node	Node to cull or add to to visibleNodes vector
lightProj	The cascades light projection matrix that gets adapted
lightView	The cascades light view matrix
lightFrustumPlanes	The six light frustum planes
visibleNodes	Vector to push the lighted nodes

Definition at line 310 of file SLShadowMap.cpp.

{
    assert(node &&
           "SLShadowMap::lightCullingAdaptiveRec: No node passed.");
    assert(node &&
           "SLShadowMap::lightCullingAdaptiveRec: No lightFrustumPlanes passed.");
 
    // Exclude LOD level nodes
    if (typeid(*node->parent()) == typeid(SLNodeLOD))
    {
        int levelForSM = node->levelForSM();
        if (levelForSM == 0 && node->drawBit(SL_DB_HIDDEN))
            return;
        else // levelForSM > 0
        {
            if (node->parent()->children().size() < levelForSM)
            {
                SL_EXIT_MSG("SLShadowMap::lightCullingAdaptiveRec: levelForSM > num. LOD Nodes.");
            }
            SLNode* nodeForSM = node->parent()->children()[levelForSM - 1];
            if (nodeForSM != node)
                return;
        }
    }
    else
    {
        if (node->drawBit(SL_DB_HIDDEN))
            return;
    }
 
    if (!node->castsShadows())
        return;
 
    // We don't need to increase far plane distance
    float distance = lightFrustumPlanes[5].distToPoint(node->aabb()->centerWS());
    if (distance < -node->aabb()->radiusWS())
        return;
 
    // Check the 4 side planes of the frustum
    for (int i = 0; i < 4; i++)
    {
        distance = lightFrustumPlanes[i].distToPoint(node->aabb()->centerWS());
        if (distance < -node->aabb()->radiusWS())
            return;
    }
 
    // If object is behind the light's near plane, move the near plane back
    if (node->mesh()) // Don't add empty group nodes
    {
        distance = lightFrustumPlanes[4].distToPoint(node->aabb()->centerWS());
        if (distance < node->aabb()->radiusWS())
        {
            float a = lightProj.m(10);
            float b = lightProj.m(14);
            float n = (b + 1.f) / a;
            float f = (b - 1.f) / a;
            n       = n + (distance - node->aabb()->radiusWS());
            lightProj.m(10, -2.f / (f - n));
            lightProj.m(14, -(f + n) / (f - n));
            SLFrustum::viewToFrustumPlanes(lightFrustumPlanes,
                                           lightProj,
                                           lightView);
        }
 
        // If the node survived until now it can cast a shadow in this cascade
        visibleNodes.push_back(node);
    }
 
    // Now recursively cull the children nodes
    for (SLNode* child : node->children())
        lightCullingAdaptiveRec(child,
                                lightProj,
                                lightView,
                                lightFrustumPlanes,
                                visibleNodes);
}

lightSpace()

SLMat4f* SLShadowMap::lightSpace ( )

inline

Definition at line 79 of file SLShadowMap.h.

{ return _lightSpace; }

maxCascades()

int SLShadowMap::maxCascades ( )

inline

Definition at line 88 of file SLShadowMap.h.

{ return _maxCascades; }

numCascades() [1/2]

int SLShadowMap::numCascades ( )

inline

Definition at line 87 of file SLShadowMap.h.

{ return _numCascades; }

numCascades() [2/2]

void SLShadowMap::numCascades ( int  numCascades )

inline

Definition at line 72 of file SLShadowMap.h.

{ _numCascades = numCascades; }

projection()

SLProjType SLShadowMap::projection ( )

inline

Definition at line 76 of file SLShadowMap.h.

{ return _projection; }

rayCount() [1/2]

SLVec2i SLShadowMap::rayCount ( )

inline

Definition at line 82 of file SLShadowMap.h.

{ return _rayCount; }

rayCount() [2/2]

void SLShadowMap::rayCount ( const SLVec2i &  rayCount )

inline

Definition at line 63 of file SLShadowMap.h.

{ _rayCount.set(rayCount); }

renderDirectionalLightCascaded()

void SLShadowMap::renderDirectionalLightCascaded ( SLSceneView *  sv, SLNode *  root  )

private

Renders the nodes into cascaded shadow maps for directional lights

Parameters

sv	Pointer of the sceneview
root	Pointer to the root node of the scene

Definition at line 561 of file SLShadowMap.cpp.

{
    assert(root && "LShadowMap::renderDirectionalLightCascaded: no root node");
 
    // Create depth buffer
    static SLfloat borderColor[] = {1.0, 1.0, 1.0, 1.0};
 
    // Create material
    if (_material == nullptr)
        _material = new SLMaterial(
          nullptr,
          "shadowMapMaterial",
          nullptr,
          nullptr,
          nullptr,
          nullptr,
          SLGLProgramManager::get(SP_depth));
 
    // Erase depth buffer textures if the number or size changed
    if (_depthBuffers.size() != 0 &&
        (_depthBuffers[0]->dimensions() != _textureSize ||
         _depthBuffers[0]->target() != GL_TEXTURE_2D ||
         _depthBuffers.size() != _numCascades))
    {
        _depthBuffers.erase(_depthBuffers.begin(), _depthBuffers.end());
    }
 
    // Get the vector of cascades with near and far distances
    SLVVec2f cascades = getShadowMapCascades(_numCascades,
                                             _camera->clipNear(),
                                             _camera->clipFar());
 
    SLMat4f camWM     = _camera->updateAndGetWM(); // camera space in world space
    SLNode* lightNode = dynamic_cast<SLNode*>(_light);
 
#ifdef SL_GLES
    SLint wrapMode = GL_CLAMP_TO_EDGE;
#else
    SLint wrapMode = GL_CLAMP_TO_BORDER;
#endif
 
    // Create the depth buffer if they don't exist
    if (_depthBuffers.size() == 0)
    {
        for (int i = 0; i < cascades.size(); i++)
            _depthBuffers.push_back(new SLGLDepthBuffer(_textureSize,
                                                        GL_NEAREST,
                                                        GL_NEAREST,
                                                        wrapMode,
                                                        borderColor,
                                                        GL_TEXTURE_2D));
    }
 
    // for all subdivision of frustum
    for (int i = 0; i < cascades.size(); i++)
    {
        // The cascades near and far distance on the view direction in WS
        float cn = cascades[i].x;
        float cf = cascades[i].y;
 
        // The cascades middle point on the view direction in WS
        SLVec3f cm = camWM.translation() - camWM.axisZ().normalized() * (cn + cf) * 0.5f;
 
        // Build the view matrix with lookAt method
        SLMat4f lightViewMat; // world space to light space
        lightViewMat.lookAt(cm, cm + lightNode->forwardWS(), lightNode->upWS());
 
        // Get the 8 camera frustum points in view space
        SLVec3f camFrustumPoints[8];
        SLFrustum::getPointsInViewSpace(camFrustumPoints,
                                        _camera->fovV(),
                                        sv->scrWdivH(),
                                        cn,
                                        cf);
 
        // Build min & max point of the cascades light frustum around the view frustum
        float minx = FLT_MAX, maxx = FLT_MIN;
        float miny = FLT_MAX, maxy = FLT_MIN;
        float minz = FLT_MAX, maxz = FLT_MIN;
        for (int j = 0; j < 8; j++)
        {
            SLVec3f fp = lightViewMat * camWM * camFrustumPoints[j];
            if (fp.x < minx) minx = fp.x;
            if (fp.y < miny) miny = fp.y;
            if (fp.x > maxx) maxx = fp.x;
            if (fp.y > maxy) maxy = fp.y;
            if (fp.z < minz) minz = fp.z;
            if (fp.z > maxz) maxz = fp.z;
        }
        float   sx = 2.f / (maxx - minx);
        float   sy = 2.f / (maxy - miny);
        float   sz = -2.f / (maxz - minz);
        SLVec3f t  = SLVec3f(-0.5f * (maxx + minx),
                            -0.5f * (maxy + miny),
                            -0.5f * (maxz + minz));
 
        // Build orthographic light projection matrix
        SLMat4f lightProjMat;
        lightProjMat.scale(sx, sy, sz);
        lightProjMat.translate(t);
 
        // Do light culling recursively with light frustum adaptation
        SLPlane lightFrustumPlanes[6];
        SLVNode visibleNodes;
        SLFrustum::viewToFrustumPlanes(lightFrustumPlanes,
                                       lightProjMat,
                                       lightViewMat);
        for (SLNode* child : root->children())
        {
            lightCullingAdaptiveRec(child,
                                    lightProjMat,
                                    lightViewMat,
                                    lightFrustumPlanes,
                                    visibleNodes);
        }
 
        _lightView[i]  = lightViewMat;
        _lightProj[i]  = lightProjMat;
        _lightSpace[i] = lightProjMat * lightViewMat;
 
        _depthBuffers[i]->bind();
 
        // Set OpenGL states for depth buffer rendering
        SLGLState* stateGL = SLGLState::instance();
        stateGL->viewport(0, 0, _textureSize.x, _textureSize.y);
        stateGL->clearColor(SLCol4f::BLACK);
        stateGL->clearColorDepthBuffer();
        stateGL->projectionMatrix = lightProjMat;
        stateGL->viewMatrix       = lightViewMat;
 
        ////////////////////////////////////////////////////////////
        drawNodesDirectionalCulling(visibleNodes, sv, lightViewMat);
        ////////////////////////////////////////////////////////////
 
        _depthBuffers[i]->unbind();
    }
}

renderShadows()

void SLShadowMap::renderShadows	(	SLSceneView *	sv,
		SLNode *	root
	)

SLShadowMap::render Toplevel entry function for shadow map rendering.

Parameters

sv	Pointer of the sceneview
root	Pointer to the root node of the scene

Definition at line 450 of file SLShadowMap.cpp.

{
    assert(root && "SLShadowMap::render: No root node passed.");
 
    PROFILE_FUNCTION();
 
    if (_projection == P_monoOrthographic && _camera != nullptr)
    {
        renderDirectionalLightCascaded(sv, root);
        return;
    }
 
    // Create Material
    if (_material == nullptr)
        _material = new SLMaterial(
          nullptr,
          "shadowMapMaterial",
          nullptr,
          nullptr,
          nullptr,
          nullptr,
          SLGLProgramManager::get(SP_depth));
 
    // Create depth buffer
    static SLfloat borderColor[] = {1.0, 1.0, 1.0, 1.0};
 
    updateLightSpaces();
 
    if (this->_useCubemap)
        this->_textureSize.y = this->_textureSize.x;
 
#ifdef SL_GLES
    SLint wrapMode = GL_CLAMP_TO_EDGE;
#else
    SLint wrapMode = GL_CLAMP_TO_BORDER;
#endif
 
    if (_depthBuffers.size() != 0 &&
        (_depthBuffers[0]->dimensions() != _textureSize ||
         (_depthBuffers[0]->target() == GL_TEXTURE_CUBE_MAP) != _useCubemap))
    {
        _depthBuffers.erase(_depthBuffers.begin(), _depthBuffers.end());
    }
 
    if (_depthBuffers.size() == 0)
    {
        _depthBuffers.push_back(new SLGLDepthBuffer(_textureSize,
                                                    GL_NEAREST,
                                                    GL_NEAREST,
                                                    wrapMode,
                                                    borderColor,
                                                    this->_useCubemap
                                                      ? GL_TEXTURE_CUBE_MAP
                                                      : GL_TEXTURE_2D));
    }
 
    _depthBuffers[0]->bind();
 
    for (SLint i = 0; i < (_useCubemap ? 6 : 1); ++i)
    {
        if (_useCubemap)
            _depthBuffers[0]->bindFace(GL_TEXTURE_CUBE_MAP_POSITIVE_X + i);
 
        // Set OpenGL states
        SLGLState* stateGL = SLGLState::instance();
        stateGL->viewport(0, 0, _textureSize.x, _textureSize.y);
        stateGL->viewMatrix       = _lightView[i];
        stateGL->projectionMatrix = _lightProj[0];
        stateGL->clearColor(SLCol4f::BLACK);
        stateGL->clearColorDepthBuffer();
 
        /////////////////////////////////////////////////////
        drawNodesIntoDepthBufferRec(root, sv, _lightView[i]);
        /////////////////////////////////////////////////////
    }
 
    _depthBuffers[0]->unbind();
}

size() [1/2]

SLVec2f SLShadowMap::size ( )

inline

Definition at line 85 of file SLShadowMap.h.

{ return _size; }

size() [2/2]

void SLShadowMap::size ( const SLVec2f &  size )

inline

Definition at line 66 of file SLShadowMap.h.

    {
        _size.set(size);
        _halfSize.set(size / 2);
    }

textureSize() [1/2]

SLVec2i SLShadowMap::textureSize ( )

inline

Definition at line 86 of file SLShadowMap.h.

{ return _textureSize; }

textureSize() [2/2]

void SLShadowMap::textureSize ( const SLVec2i &  textureSize )

inline

Definition at line 71 of file SLShadowMap.h.

{ _textureSize.set(textureSize); }

updateLightSpaces()

void SLShadowMap::updateLightSpaces ( )

private

SLShadowMap::updateLightSpaces updates a light view projection matrix.

Definition at line 240 of file SLShadowMap.cpp.

{
    // Calculate FOV
    SLfloat fov;
 
    if (_projection == P_monoPerspective)
    {
        fov = _light->spotCutOffDEG() * 2;
 
        // Automatically use cubemap when perspective projection makes no sense
        if (fov >= 180.0f)
            _useCubemap = true;
 
        if (_useCubemap)
            fov = 90.0f;
    }
 
    // Set view matrix
    SLVec3f positionWS = _light->positionWS().vec3();
 
    if (_useCubemap)
    {
        _lightView[0].lookAt(positionWS, positionWS + SLVec3f::AXISX, -SLVec3f::AXISY);
        _lightView[1].lookAt(positionWS, positionWS - SLVec3f::AXISX, -SLVec3f::AXISY);
        _lightView[2].lookAt(positionWS, positionWS + SLVec3f::AXISY, SLVec3f::AXISZ);
        _lightView[3].lookAt(positionWS, positionWS - SLVec3f::AXISY, -SLVec3f::AXISZ);
        _lightView[4].lookAt(positionWS, positionWS + SLVec3f::AXISZ, -SLVec3f::AXISY);
        _lightView[5].lookAt(positionWS, positionWS - SLVec3f::AXISZ, -SLVec3f::AXISY);
    }
    else
    {
        SLNode* node = dynamic_cast<SLNode*>(_light);
        _lightView[0].lookAt(positionWS, positionWS + node->forwardWS(), node->upWS());
    }
 
    // Set projection matrix
    switch (_projection)
    {
        case P_monoOrthographic:
            _lightProj[0].ortho(-_halfSize.x,
                                _halfSize.x,
                                -_halfSize.y,
                                _halfSize.y,
                                _lightClipNear,
                                _lightClipFar);
            break;
 
        case P_monoPerspective:
            _lightProj[0].perspective(fov, 1.0f, _lightClipNear, _lightClipFar);
            break;
 
        default:
            SL_EXIT_MSG("Unsupported light projection");
    }
 
    // Set the model-view-projection matrix
    for (SLint i = 0; i < (_useCubemap ? 6 : 1); ++i)
        _lightSpace[i] = _lightProj[0] * _lightView[i];
}

useCascaded()

SLbool SLShadowMap::useCascaded ( ) const

inline

Definition at line 78 of file SLShadowMap.h.

{ return _useCascaded; }

useCubemap() [1/2]

SLbool SLShadowMap::useCubemap ( ) const

inline

Definition at line 77 of file SLShadowMap.h.

{ return _useCubemap; }

useCubemap() [2/2]

void SLShadowMap::useCubemap ( SLbool  useCubemap )

inline

Definition at line 62 of file SLShadowMap.h.

{ _useCubemap = useCubemap; }

Member Data Documentation

_camera

SLCamera* SLShadowMap::_camera

private

Camera to witch the light frustums are adapted.

Definition at line 132 of file SLShadowMap.h.

_cascadesFactor

SLfloat SLShadowMap::_cascadesFactor

private

Factor that determines the cascades distribution.

Definition at line 119 of file SLShadowMap.h.

_depthBuffers

SLGLVDepthBuffer SLShadowMap::_depthBuffers

private

Vector of framebuffers with texture.

Definition at line 123 of file SLShadowMap.h.

_frustumVAO

SLGLVertexArrayExt* SLShadowMap::_frustumVAO

private

Visualization of light-space-frustum.

Definition at line 124 of file SLShadowMap.h.

_halfSize

SLVec2f SLShadowMap::_halfSize

private

_size divided by two (only for SLLightDirect non cascaded)

Definition at line 130 of file SLShadowMap.h.

_light

SLLight* SLShadowMap::_light

private

The light which uses this shadow map.

Definition at line 113 of file SLShadowMap.h.

_lightClipFar

SLfloat SLShadowMap::_lightClipFar

private

Light frustum far clipping plane.

Definition at line 128 of file SLShadowMap.h.

_lightClipNear

SLfloat SLShadowMap::_lightClipNear

private

Light frustum near clipping plane.

Definition at line 127 of file SLShadowMap.h.

_lightProj

SLMat4f SLShadowMap::_lightProj[6]

private

Light projection matrices.

Definition at line 121 of file SLShadowMap.h.

_lightSpace

SLMat4f SLShadowMap::_lightSpace[6]

private

Light space matrices (= _lightProj * _lightView)

Definition at line 122 of file SLShadowMap.h.

_lightView

SLMat4f SLShadowMap::_lightView[6]

private

Light view matrices.

Definition at line 120 of file SLShadowMap.h.

_material

SLMaterial* SLShadowMap::_material

private

Material used to render the shadow map.

Definition at line 126 of file SLShadowMap.h.

_maxCascades

SLint SLShadowMap::_maxCascades

private

Max. number of cascades for for which the shader gets generated.

Definition at line 118 of file SLShadowMap.h.

_numCascades

SLint SLShadowMap::_numCascades

private

Number of cascades for directional light shadow mapping.

Definition at line 117 of file SLShadowMap.h.

_projection

SLProjType SLShadowMap::_projection

private

Projection to use to create shadow map.

Definition at line 114 of file SLShadowMap.h.

_rayCount

SLVec2i SLShadowMap::_rayCount

private

Amount of rays drawn by drawRays()

Definition at line 125 of file SLShadowMap.h.

_size

SLVec2f SLShadowMap::_size

private

Height and width of the frustum (only for SLLightDirect non cascaded)

Definition at line 129 of file SLShadowMap.h.

_textureSize

SLVec2i SLShadowMap::_textureSize

private

Size of the shadow map texture.

Definition at line 131 of file SLShadowMap.h.

_useCascaded

SLbool SLShadowMap::_useCascaded

private

Flag if cascaded shadow maps should be used.

Definition at line 116 of file SLShadowMap.h.

_useCubemap

SLbool SLShadowMap::_useCubemap

private

Flag if cubemap should be used for perspective projections.

Definition at line 115 of file SLShadowMap.h.

drawCalls

SLuint SLShadowMap::drawCalls = 0

static

NO. of draw calls for shadow mapping.

Definition at line 92 of file SLShadowMap.h.

---

The documentation for this class was generated from the following files:

• SLShadowMap.h
• SLShadowMap.cpp