source/renderer/ShadowMap.h

   1 /* Copyright (C) 2021 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifndef INCLUDED_SHADOWMAP
  19 #define INCLUDED_SHADOWMAP
  20
  21 #include "graphics/ShaderProgramPtr.h"
  22 #include "lib/ogl.h"
  23
  24 class CBoundingBoxAligned;
  25 class CCamera;
  26 class CFrustum;
  27 class CVector3D;
  28
  29 struct ShadowMapInternals;
  30
  31 /**
  32  * Class ShadowMap: Maintain the shadow map texture and perform necessary OpenGL setup,
  33  * including matrix calculations.
  34  *
  35  * The class will automatically generate a texture the first time the shadow map is rendered into.
  36  * The texture will not be resized afterwards.
  37  */
  38 class ShadowMap
  39 {
  40 public:
  41         ShadowMap();
  42         ~ShadowMap();
  43
  44         /**
  45          * RecreateTexture: Destroy the current shadow texture and force creation of
  46          * a new one. Useful when the renderer's size has changed and the texture
  47          * should be resized too.
  48          */
  49         void RecreateTexture();
  50
  51         /**
  52          * GetDepthTextureBits: Return the number of bits to use for depth textures when
  53          * enabled.
  54          *
  55          * @return depth texture bit depth
  56          */
  57         int GetDepthTextureBits() const;
  58
  59         /**
  60          * SetDepthTextureBits: Sets the number of bits to use for depth textures when enabled.
  61          * Possible values are 16, 24, 32 and 0 (= use default)
  62          *
  63          * @param bits number of bits
  64          */
  65         void SetDepthTextureBits(int bits);
  66
  67         /**
  68          * SetupFrame: Configure light space for the given camera and light direction,
  69          * create the shadow texture if necessary, etc.
  70          *
  71          * @param camera the camera that will be used for world rendering
  72          * @param lightdir the direction of the (directional) sunlight
  73          */
  74         void SetupFrame(const CCamera& camera, const CVector3D& lightdir);
  75
  76         /**
  77          * Add the bounding box of an object that will cast a shadow.
  78          * This is used to calculate the bounds for the shadow map.
  79          *
  80          * @param bounds world space bounding box
  81          */
  82         void AddShadowCasterBound(const int cascade, const CBoundingBoxAligned& bounds);
  83
  84         /**
  85          * Add the bounding box of an object that will receive a shadow.
  86          * This is used to calculate the bounds for the shadow map.
  87          *
  88          * @param bounds world space bounding box
  89          */
  90         void AddShadowReceiverBound(const CBoundingBoxAligned& bounds);
  91
  92         /**
  93          * Compute the frustum originating at the light source, that encompasses
  94          * all the objects passed into AddShadowReceiverBound so far.
  95          *
  96          * This frustum can be used to determine which objects might cast a visible
  97          * shadow. Those objects should be passed to AddShadowCasterBound and
  98          * then should be rendered into the shadow map.
  99          */
 100         CFrustum GetShadowCasterCullFrustum(const int cascade);
 101
 102         /**
 103          * BeginRender: Set OpenGL state for rendering into the shadow map texture.
 104          *
 105          * @todo this depends in non-obvious ways on the behaviour of the call-site
 106          */
 107         void BeginRender();
 108
 109         /**
 110          * EndRender: Finish rendering into the shadow map.
 111          *
 112          * @todo this depends in non-obvious ways on the behaviour of the call-site
 113          */
 114         void EndRender();
 115
 116         /**
 117          * Returns the current number of used cascades.
 118          */
 119         int GetCascadeCount() const;
 120
 121         /**
 122          * Sets the renderer camera for the cascade.
 123          */
 124         void PrepareCamera(const int cascade);
 125
 126         /**
 127          * Binds all needed resources and uniforms to draw shadows using the shader.
 128          */
 129         void BindTo(const CShaderProgramPtr& shader) const;
 130
 131         /**
 132          * Visualize shadow mapping calculations to help in
 133          * debugging and optimal shadow map usage.
 134          */
 135         void RenderDebugBounds();
 136
 137         /**
 138          * Visualize shadow map texture to help in debugging.
 139          */
 140         void RenderDebugTexture();
 141
 142 private:
 143         ShadowMapInternals* m;
 144 };
 145
 146 #endif // INCLUDED_SHADOWMAP