summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/bgfx/examples/31-rsm/reflectiveshadowmap.cpp
diff options
context:
space:
mode:
Diffstat (limited to '3rdparty/bgfx/examples/31-rsm/reflectiveshadowmap.cpp')
-rw-r--r--3rdparty/bgfx/examples/31-rsm/reflectiveshadowmap.cpp745
1 files changed, 745 insertions, 0 deletions
diff --git a/3rdparty/bgfx/examples/31-rsm/reflectiveshadowmap.cpp b/3rdparty/bgfx/examples/31-rsm/reflectiveshadowmap.cpp
new file mode 100644
index 00000000000..a7bbb6078db
--- /dev/null
+++ b/3rdparty/bgfx/examples/31-rsm/reflectiveshadowmap.cpp
@@ -0,0 +1,745 @@
+/*
+ * Copyright 2016 Joseph Cherlin. All rights reserved.
+ * License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause
+ */
+
+#include "common.h"
+#include "camera.h"
+#include "bgfx_utils.h"
+#include "imgui/imgui.h"
+#include <bx/rng.h>
+
+/*
+ * Intro
+ * =====
+ *
+ * RSM (reflective shadow map) is a technique for global illumination.
+ * It is similar to shadow map. It piggybacks on the shadow map, in fact.
+ *
+ * RSM is compatible with any type of lighting which can handle handle
+ * a lot of point lights. This sample happens to use a deferred renderer,
+ * but other types would work.
+ *
+ * Overview:
+ *
+ * - Draw into G-Buffer
+ * - Draw Shadow Map (with RSM piggybacked on)
+ * - Populate light buffer
+ * - Deferred "combine" pass.
+ *
+ * Details
+ * =======
+ *
+ * ## G-Buffer
+ *
+ * Typical G-Buffer with normals, color, depth.
+ *
+ * ## RSM
+ *
+ * A typical shadow map, except it also outputs to a "RSM" buffer.
+ * The RSM contains the color of the item drawn, as well as a scalar value which represents
+ * how much light would bounce off of the surface if it were hit with light from the origin
+ * of the shadow map.
+ *
+ * ## Light Buffer
+ *
+ * We draw a lot of spheres into the light buffer. These spheres are called VPL (virtual
+ * point lights). VPLs represent bounced light, and let us eliminate the classic "ambient"
+ * term. Instead of us supplying their world space position in a transform matrix,
+ * VPLs gain their position from the shadow map from step 2, using an unprojection. They gain
+ * their color from the RSM. You could also store their position in a buffer while drawing shadows,
+ * I'm just using depth to keep the sample smaller.
+ *
+ * ## Deferred combine
+ *
+ * Typical combine used in almost any sort of deferred renderer.
+ *
+ * References
+ * ==========
+ *
+ * http: *www.bpeers.com/blog/?itemid=517
+ *
+ */
+
+// Render passes
+#define RENDER_PASS_GBUFFER 0 // GBuffer for normals and albedo
+#define RENDER_PASS_SHADOW_MAP 1 // Draw into the shadow map (RSM and regular shadow map at same time)
+#define RENDER_PASS_LIGHT_BUFFER 2 // Light buffer for point lights
+#define RENDER_PASS_COMBINE 3 // Directional light and final result
+
+// Gbuffer has multiple render targets
+#define GBUFFER_RT_NORMAL 0
+#define GBUFFER_RT_COLOR 1
+#define GBUFFER_RT_DEPTH 2
+
+// Shadow map has multiple render targets
+#define SHADOW_RT_RSM 0 // In this algorithm, shadows write lighting info as well.
+#define SHADOW_RT_DEPTH 1 // Shadow maps always write a depth
+
+// Random meshes we draw
+#define MODEL_COUNT 222 // In this demo, a model is a mesh plus a transform and a color
+
+#define SHADOW_MAP_DIM 512
+#define LIGHT_DIST 10.0f
+
+static const char * s_meshPaths[] =
+{
+ "meshes/cube.bin",
+ "meshes/orb.bin",
+ "meshes/column.bin",
+ "meshes/bunny.bin",
+ "meshes/tree.bin",
+ "meshes/hollowcube.bin"
+};
+
+static const float s_meshScale[] =
+{
+ 0.25f,
+ 0.5f,
+ 0.05f,
+ 0.5f,
+ 0.05f,
+ 0.05f
+};
+
+// Vertex decl for our screen space quad (used in deferred rendering)
+struct PosTexCoord0Vertex
+{
+ float m_x;
+ float m_y;
+ float m_z;
+ float m_u;
+ float m_v;
+
+ static void init()
+ {
+ ms_decl
+ .begin()
+ .add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float)
+ .add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float)
+ .end();
+ }
+
+ static bgfx::VertexDecl ms_decl;
+};
+bgfx::VertexDecl PosTexCoord0Vertex::ms_decl;
+
+// Utility function to draw a screen space quad for deferred rendering
+void screenSpaceQuad(float _textureWidth, float _textureHeight, float _texelHalf, bool _originBottomLeft, float _width = 1.0f, float _height = 1.0f)
+{
+ if (bgfx::checkAvailTransientVertexBuffer(3, PosTexCoord0Vertex::ms_decl) )
+ {
+ bgfx::TransientVertexBuffer vb;
+ bgfx::allocTransientVertexBuffer(&vb, 3, PosTexCoord0Vertex::ms_decl);
+ PosTexCoord0Vertex* vertex = (PosTexCoord0Vertex*)vb.data;
+
+ const float minx = -_width;
+ const float maxx = _width;
+ const float miny = 0.0f;
+ const float maxy = _height*2.0f;
+
+ const float texelHalfW = _texelHalf/_textureWidth;
+ const float texelHalfH = _texelHalf/_textureHeight;
+ const float minu = -1.0f + texelHalfW;
+ const float maxu = 1.0f + texelHalfH;
+
+ const float zz = 0.0f;
+
+ float minv = texelHalfH;
+ float maxv = 2.0f + texelHalfH;
+
+ if (_originBottomLeft)
+ {
+ float temp = minv;
+ minv = maxv;
+ maxv = temp;
+
+ minv -= 1.0f;
+ maxv -= 1.0f;
+ }
+
+ vertex[0].m_x = minx;
+ vertex[0].m_y = miny;
+ vertex[0].m_z = zz;
+ vertex[0].m_u = minu;
+ vertex[0].m_v = minv;
+
+ vertex[1].m_x = maxx;
+ vertex[1].m_y = miny;
+ vertex[1].m_z = zz;
+ vertex[1].m_u = maxu;
+ vertex[1].m_v = minv;
+
+ vertex[2].m_x = maxx;
+ vertex[2].m_y = maxy;
+ vertex[2].m_z = zz;
+ vertex[2].m_u = maxu;
+ vertex[2].m_v = maxv;
+
+ bgfx::setVertexBuffer(&vb);
+ }
+}
+
+class ExampleRSM : public entry::AppI
+{
+public:
+ ExampleRSM()
+ : m_reading(0)
+ , m_currFrame(UINT32_MAX)
+ , m_cameraSpin(false)
+ , m_lightElevation(35.0f)
+ , m_lightAzimuth(215.0f)
+ , m_rsmAmount(0.25f)
+ , m_vplRadius(3.0f)
+ , m_texelHalf(0.0f)
+ {
+ }
+
+ void init(int _argc, char** _argv) BX_OVERRIDE
+ {
+ Args args(_argc, _argv);
+
+ m_width = 1280;
+ m_height = 720;
+ m_debug = BGFX_DEBUG_TEXT;
+ m_reset = BGFX_RESET_VSYNC;
+
+ bgfx::init(args.m_type, args.m_pciId);
+
+ bgfx::reset(m_width, m_height, m_reset);
+
+ // Enable debug text.
+ bgfx::setDebug(m_debug);
+
+ // Labeling for renderdoc captures, etc
+ bgfx::setViewName(RENDER_PASS_GBUFFER, "gbuffer" );
+ bgfx::setViewName(RENDER_PASS_SHADOW_MAP, "shadow map" );
+ bgfx::setViewName(RENDER_PASS_LIGHT_BUFFER, "light buffer");
+ bgfx::setViewName(RENDER_PASS_COMBINE, "post combine");
+
+ // Set up screen clears
+ bgfx::setViewClear(RENDER_PASS_GBUFFER
+ , BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH
+ , 0
+ , 1.0f
+ , 0
+ );
+
+ bgfx::setViewClear(RENDER_PASS_LIGHT_BUFFER
+ , BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH
+ , 0
+ , 1.0f
+ , 0
+ );
+
+ bgfx::setViewClear(RENDER_PASS_SHADOW_MAP
+ , BGFX_CLEAR_COLOR|BGFX_CLEAR_DEPTH
+ , 0
+ , 1.0f
+ , 0
+ );
+
+ // Create uniforms
+ u_tint = bgfx::createUniform("u_tint", bgfx::UniformType::Vec4); // Tint for when you click on items
+ u_lightDir = bgfx::createUniform("u_lightDir", bgfx::UniformType::Vec4); // Single directional light for entire scene
+ u_sphereInfo = bgfx::createUniform("u_sphereInfo", bgfx::UniformType::Vec4); // Info for RSM
+ u_invMvp = bgfx::createUniform("u_invMvp", bgfx::UniformType::Mat4); // Matrix needed in light buffer
+ u_invMvpShadow = bgfx::createUniform("u_invMvpShadow", bgfx::UniformType::Mat4); // Matrix needed in light buffer
+ u_lightMtx = bgfx::createUniform("u_lightMtx", bgfx::UniformType::Mat4); // Matrix needed to use shadow map (world to shadow space)
+ u_shadowDimsInv = bgfx::createUniform("u_shadowDimsInv", bgfx::UniformType::Vec4); // Used in PCF
+ u_rsmAmount = bgfx::createUniform("u_rsmAmount", bgfx::UniformType::Vec4); // How much RSM to use vs directional light
+
+ // Create texture sampler uniforms (used when we bind textures)
+ s_normal = bgfx::createUniform("s_normal", bgfx::UniformType::Int1); // Normal gbuffer
+ s_depth = bgfx::createUniform("s_depth", bgfx::UniformType::Int1); // Normal gbuffer
+ s_color = bgfx::createUniform("s_color", bgfx::UniformType::Int1); // Color (albedo) gbuffer
+ s_light = bgfx::createUniform("s_light", bgfx::UniformType::Int1); // Light buffer
+ s_shadowMap = bgfx::createUniform("s_shadowMap", bgfx::UniformType::Int1); // Shadow map
+ s_rsm = bgfx::createUniform("s_rsm", bgfx::UniformType::Int1); // Reflective shadow map
+
+ // Create program from shaders.
+ m_gbufferProgram = loadProgram("vs_rsm_gbuffer", "fs_rsm_gbuffer"); // Gbuffer
+ m_shadowProgram = loadProgram("vs_rsm_shadow", "fs_rsm_shadow" ); // Drawing shadow map
+ m_lightProgram = loadProgram("vs_rsm_lbuffer", "fs_rsm_lbuffer"); // Light buffer
+ m_combineProgram = loadProgram("vs_rsm_combine", "fs_rsm_combine"); // Combiner
+
+ // Load some meshes
+ for (uint32_t ii = 0; ii < BX_COUNTOF(s_meshPaths); ++ii)
+ {
+ m_meshes[ii] = meshLoad(s_meshPaths[ii]);
+ }
+
+ // Randomly create some models
+ bx::RngMwc mwc; // Random number generator
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_models); ++ii)
+ {
+ Model& model = m_models[ii];
+
+ uint32_t rr = mwc.gen() % 256;
+ uint32_t gg = mwc.gen() % 256;
+ uint32_t bb = mwc.gen() % 256;
+ model.mesh = 1+mwc.gen()%(BX_COUNTOF(s_meshPaths)-1);
+ model.color[0] = rr/255.0f;
+ model.color[1] = gg/255.0f;
+ model.color[2] = bb/255.0f;
+ model.color[3] = 1.0f;
+ model.position[0] = (((mwc.gen() % 256)) - 128.0f)/20.0f;
+ model.position[1] = 0;
+ model.position[2] = (((mwc.gen() % 256)) - 128.0f)/20.0f;
+ }
+
+ // Load ground. We'll just use the cube since I don't have a ground model right now
+ m_ground = meshLoad("meshes/cube.bin");
+
+ // Light sphere
+ m_lightSphere = meshLoad("meshes/unit_sphere.bin");
+
+ const uint32_t samplerFlags = 0
+ | BGFX_TEXTURE_RT
+ | BGFX_TEXTURE_MIN_POINT
+ | BGFX_TEXTURE_MAG_POINT
+ | BGFX_TEXTURE_MIP_POINT
+ | BGFX_TEXTURE_U_CLAMP
+ | BGFX_TEXTURE_V_CLAMP
+ ;
+
+ // Make gbuffer and related textures
+ m_gbufferTex[GBUFFER_RT_NORMAL] = bgfx::createTexture2D(bgfx::BackbufferRatio::Equal, 1, bgfx::TextureFormat::BGRA8, samplerFlags);
+ m_gbufferTex[GBUFFER_RT_COLOR] = bgfx::createTexture2D(bgfx::BackbufferRatio::Equal, 1, bgfx::TextureFormat::BGRA8, samplerFlags);
+ m_gbufferTex[GBUFFER_RT_DEPTH] = bgfx::createTexture2D(bgfx::BackbufferRatio::Equal, 1, bgfx::TextureFormat::D24, samplerFlags);
+ m_gbuffer = bgfx::createFrameBuffer(BX_COUNTOF(m_gbufferTex), m_gbufferTex, true);
+
+ // Make light buffer
+ m_lightBufferTex = bgfx::createTexture2D(bgfx::BackbufferRatio::Equal, 1, bgfx::TextureFormat::BGRA8, samplerFlags);
+ bgfx::TextureHandle lightBufferRTs[] = {
+ m_lightBufferTex
+ };
+ m_lightBuffer = bgfx::createFrameBuffer(BX_COUNTOF(lightBufferRTs), lightBufferRTs, true);
+
+ // Make shadow buffer
+ const uint32_t rsmFlags = 0
+ | BGFX_TEXTURE_RT
+ | BGFX_TEXTURE_MIN_POINT
+ | BGFX_TEXTURE_MAG_POINT
+ | BGFX_TEXTURE_MIP_POINT
+ | BGFX_TEXTURE_U_CLAMP
+ | BGFX_TEXTURE_V_CLAMP
+ ;
+
+ // Reflective shadow map
+ m_shadowBufferTex[SHADOW_RT_RSM] = bgfx::createTexture2D(
+ SHADOW_MAP_DIM
+ , SHADOW_MAP_DIM
+ , 1
+ , bgfx::TextureFormat::BGRA8,
+ rsmFlags
+ );
+
+ // Typical shadow map
+ m_shadowBufferTex[SHADOW_RT_DEPTH] = bgfx::createTexture2D(
+ SHADOW_MAP_DIM
+ , SHADOW_MAP_DIM
+ , 1
+ , bgfx::TextureFormat::D16,
+ BGFX_TEXTURE_RT/* | BGFX_TEXTURE_COMPARE_LEQUAL*/
+ ); // Note I'm not setting BGFX_TEXTURE_COMPARE_LEQUAL. Why?
+ // Normally a PCF shadow map such as this requires a compare. However, this sample also
+ // reads from this texture in the lighting pass, and only uses the PCF capabilites in the
+ // combine pass, so the flag is disabled by default.
+
+ m_shadowBuffer = bgfx::createFrameBuffer(BX_COUNTOF(m_shadowBufferTex), m_shadowBufferTex, true);
+
+ // Vertex decl
+ PosTexCoord0Vertex::init();
+
+ // Init camera
+ cameraCreate();
+ float camPos[] = {0.0f, 1.5f, 0.0f};
+ cameraSetPosition(camPos);
+ cameraSetVerticalAngle(-0.3f);
+
+ // Init directional light
+ updateLightDir();
+
+ // Get renderer capabilities info.
+ m_caps = bgfx::getCaps();
+ const bgfx::RendererType::Enum renderer = bgfx::getRendererType();
+ m_texelHalf = bgfx::RendererType::Direct3D9 == renderer ? 0.5f : 0.0f;
+
+ imguiCreate();
+ }
+
+ int shutdown() BX_OVERRIDE
+ {
+ for (uint32_t ii = 0; ii < BX_COUNTOF(s_meshPaths); ++ii)
+ {
+ meshUnload(m_meshes[ii]);
+ }
+
+ meshUnload(m_ground);
+ meshUnload(m_lightSphere);
+
+ // Cleanup.
+ bgfx::destroyProgram(m_gbufferProgram);
+ bgfx::destroyProgram(m_lightProgram);
+ bgfx::destroyProgram(m_combineProgram);
+ bgfx::destroyProgram(m_shadowProgram);
+
+ bgfx::destroyUniform(u_tint);
+ bgfx::destroyUniform(u_lightDir);
+ bgfx::destroyUniform(u_sphereInfo);
+ bgfx::destroyUniform(u_invMvp);
+ bgfx::destroyUniform(u_invMvpShadow);
+ bgfx::destroyUniform(u_lightMtx);
+ bgfx::destroyUniform(u_shadowDimsInv);
+ bgfx::destroyUniform(u_rsmAmount);
+ bgfx::destroyUniform(s_normal);
+ bgfx::destroyUniform(s_depth);
+ bgfx::destroyUniform(s_light);
+ bgfx::destroyUniform(s_color);
+ bgfx::destroyUniform(s_shadowMap);
+ bgfx::destroyUniform(s_rsm);
+
+ bgfx::destroyFrameBuffer(m_gbuffer);
+ bgfx::destroyFrameBuffer(m_lightBuffer);
+ bgfx::destroyFrameBuffer(m_shadowBuffer);
+
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_gbufferTex); ++ii)
+ {
+ bgfx::destroyTexture(m_gbufferTex[ii]);
+ }
+
+ bgfx::destroyTexture(m_lightBufferTex);
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_shadowBufferTex); ++ii)
+ {
+ bgfx::destroyTexture(m_shadowBufferTex[ii]);
+ }
+
+ cameraDestroy();
+
+ imguiDestroy();
+
+ // Shutdown bgfx.
+ bgfx::shutdown();
+
+ return 0;
+ }
+
+ bool update() BX_OVERRIDE
+ {
+ if (!entry::processEvents(m_width, m_height, m_debug, m_reset, &m_mouseState) )
+ {
+ // Update frame timer
+ int64_t now = bx::getHPCounter();
+ static int64_t last = now;
+ const int64_t frameTime = now - last;
+ last = now;
+ const double freq = double(bx::getHPFrequency());
+ const double toMs = 1000.0 / freq;
+ const float deltaTime = float(frameTime/freq);
+
+ // Use debug font to print information about this example.
+ bgfx::dbgTextClear();
+ bgfx::dbgTextPrintf(0, 1, 0x4f, "bgfx/examples/31-rsm");
+ bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: Global Illumination with Reflective Shadow Map.");
+ bgfx::dbgTextPrintf(0, 3, 0x0f, "Frame: % 7.3f[ms]", double(frameTime)*toMs);
+
+ // Update camera
+ cameraUpdate(deltaTime*0.15f, m_mouseState);
+
+ // Set up matrices for gbuffer
+ float view[16];
+ cameraGetViewMtx(view);
+
+ float proj[16];
+ bx::mtxProj(proj, 60.0f, float(m_width)/float(m_height), 0.1f, 100.0f);
+
+ bgfx::setViewRect(RENDER_PASS_GBUFFER, 0, 0, uint16_t(m_width), uint16_t(m_height));
+ bgfx::setViewTransform(RENDER_PASS_GBUFFER, view, proj);
+ // Make sure when we draw it goes into gbuffer and not backbuffer
+ bgfx::setViewFrameBuffer(RENDER_PASS_GBUFFER, m_gbuffer);
+ // Draw everything into g-buffer
+ drawAllModels(RENDER_PASS_GBUFFER, m_gbufferProgram);
+
+ // Draw shadow map
+
+ // Set up transforms for shadow map
+ float smView[16], smProj[16], lightEye[3], lightAt[3];
+ lightEye[0] = m_lightDir[0]*LIGHT_DIST;
+ lightEye[1] = m_lightDir[1]*LIGHT_DIST;
+ lightEye[2] = m_lightDir[2]*LIGHT_DIST;
+
+ lightAt[0] = 0.0f;
+ lightAt[1] = 0.0f;
+ lightAt[2] = 0.0f;
+
+ bx::mtxLookAt(smView, lightEye, lightAt);
+ const float area = 10.0f;
+ bgfx::RendererType::Enum renderer = bgfx::getRendererType();
+ bool flipV = false
+ || renderer == bgfx::RendererType::OpenGL
+ || renderer == bgfx::RendererType::OpenGLES
+ ;
+ bx::mtxOrtho(smProj, -area, area, -area, area, -100.0f, 100.0f, 0.0f, flipV);
+ bgfx::setViewTransform(RENDER_PASS_SHADOW_MAP, smView, smProj);
+ bgfx::setViewFrameBuffer(RENDER_PASS_SHADOW_MAP, m_shadowBuffer);
+ bgfx::setViewRect(RENDER_PASS_SHADOW_MAP, 0, 0, SHADOW_MAP_DIM, SHADOW_MAP_DIM);
+
+ drawAllModels(RENDER_PASS_SHADOW_MAP, m_shadowProgram);
+
+ // Next draw light buffer
+
+ // Set up matrices for light buffer
+ bgfx::setViewRect(RENDER_PASS_LIGHT_BUFFER, 0, 0, uint16_t(m_width), uint16_t(m_height));
+ bgfx::setViewTransform(RENDER_PASS_LIGHT_BUFFER, view, proj); // Notice, same view and proj as gbuffer
+ // Set drawing into light buffer
+ bgfx::setViewFrameBuffer(RENDER_PASS_LIGHT_BUFFER, m_lightBuffer);
+
+ // Inverse view projection is needed in shader so set that up
+ float vp[16], invMvp[16];
+ bx::mtxMul(vp, view, proj);
+ bx::mtxInverse(invMvp, vp);
+
+ // Light matrix used in combine pass and inverse used in light pass
+ float lightMtx[16]; // World space to light space (shadow map space)
+ bx::mtxMul(lightMtx, smView, smProj);
+ float invMvpShadow[16];
+ bx::mtxInverse(invMvpShadow, lightMtx);
+
+ // Draw some lights (these should really be instanced but for this example they aren't...)
+ const unsigned MAX_SPHERE = 32;
+ for (uint32_t i = 0; i < MAX_SPHERE; i++)
+ {
+ for (uint32_t j = 0; j < MAX_SPHERE; j++)
+ {
+ // These are used in the fragment shader
+ bgfx::setTexture(0, s_normal, m_gbuffer, GBUFFER_RT_NORMAL); // Normal for lighting calculations
+ bgfx::setTexture(1, s_depth, m_gbuffer, GBUFFER_RT_DEPTH); // Depth to reconstruct world position
+
+ // Thse are used in the vert shader
+ bgfx::setTexture(2, s_shadowMap, m_shadowBuffer, SHADOW_RT_DEPTH); // Used to place sphere
+ bgfx::setTexture(3, s_rsm, m_shadowBuffer, SHADOW_RT_RSM); // Used to scale/color sphere
+
+ bgfx::setUniform(u_invMvp, invMvp);
+ bgfx::setUniform(u_invMvpShadow, invMvpShadow);
+ float sphereInfo[4];
+ sphereInfo[0] = ((float)i/(MAX_SPHERE-1));
+ sphereInfo[1] = ((float)j/(MAX_SPHERE-1));
+ sphereInfo[2] = m_vplRadius;
+ sphereInfo[3] = 0.0; // Unused
+ bgfx::setUniform(u_sphereInfo, sphereInfo);
+
+ const uint64_t lightDrawState = 0
+ | BGFX_STATE_RGB_WRITE
+ | BGFX_STATE_BLEND_ADD // <=== Overlapping lights contribute more
+ | BGFX_STATE_ALPHA_WRITE
+ | BGFX_STATE_CULL_CW // <=== If we go into the lights, there will be problems, so we draw the far back face.
+ ;
+
+ meshSubmit(
+ m_lightSphere,
+ RENDER_PASS_LIGHT_BUFFER,
+ m_lightProgram,
+ NULL,
+ lightDrawState
+ );
+ }
+ }
+
+ // Draw combine pass
+
+ // Texture inputs for combine pass
+ bgfx::setTexture(0, s_normal, m_gbuffer, GBUFFER_RT_NORMAL);
+ bgfx::setTexture(1, s_color, m_gbuffer, GBUFFER_RT_COLOR);
+ bgfx::setTexture(2, s_light, m_lightBuffer, 0);
+ bgfx::setTexture(3, s_depth, m_gbuffer, GBUFFER_RT_DEPTH);
+ bgfx::setTexture(4, s_shadowMap, m_shadowBuffer, SHADOW_RT_DEPTH, BGFX_TEXTURE_COMPARE_LEQUAL);
+
+ // Uniforms for combine pass
+
+ bgfx::setUniform(u_lightDir, m_lightDir);
+ bgfx::setUniform(u_invMvp, invMvp);
+ bgfx::setUniform(u_lightMtx, lightMtx);
+ const float invDim[4] = {1.0f/SHADOW_MAP_DIM, 0.0f, 0.0f, 0.0f};
+ bgfx::setUniform(u_shadowDimsInv, invDim);
+ float rsmAmount[4] = {m_rsmAmount,m_rsmAmount,m_rsmAmount,m_rsmAmount};
+ bgfx::setUniform(u_rsmAmount, rsmAmount);
+
+ // Set up state for combine pass
+ // point of this is to avoid doing depth test, which is in the default state
+ bgfx::setState(0
+ | BGFX_STATE_RGB_WRITE
+ | BGFX_STATE_ALPHA_WRITE
+ );
+
+ // Set up transform matrix for fullscreen quad
+ float orthoProj[16];
+ bx::mtxOrtho(orthoProj, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 100.0f);
+ bgfx::setViewTransform(RENDER_PASS_COMBINE, NULL, orthoProj);
+ bgfx::setViewRect(RENDER_PASS_COMBINE, 0, 0, m_width, m_height);
+ // Bind vertex buffer and draw quad
+ screenSpaceQuad( (float)m_width, (float)m_height, m_texelHalf, m_caps->originBottomLeft);
+ bgfx::submit(RENDER_PASS_COMBINE, m_combineProgram);
+
+ // Draw UI
+ imguiBeginFrame(m_mouseState.m_mx
+ , m_mouseState.m_my
+ , (m_mouseState.m_buttons[entry::MouseButton::Left] ? IMGUI_MBUT_LEFT : 0)
+ | (m_mouseState.m_buttons[entry::MouseButton::Right] ? IMGUI_MBUT_RIGHT : 0)
+ | (m_mouseState.m_buttons[entry::MouseButton::Middle] ? IMGUI_MBUT_MIDDLE : 0)
+ , m_mouseState.m_mz
+ , m_width
+ , m_height
+ );
+
+ imguiBeginArea("RSM:", 10, 100, 300, 400);
+
+ imguiSlider("rsm amount", m_rsmAmount, 0.0f, 0.7f, 0.01f);
+ imguiSlider("vpl radius", m_vplRadius, 0.25f, 20.0f, 0.1f);
+ imguiSlider("light azimuth", m_lightAzimuth, 0.0f, 360.0f, 0.01f);
+ imguiSlider("light elevation", m_lightElevation, 35.0f, 90.0f, 0.01f);
+
+ imguiEndArea();
+ imguiEndFrame();
+
+ updateLightDir();
+
+ // Advance to next frame. Rendering thread will be kicked to
+ // process submitted rendering primitives.
+ m_currFrame = bgfx::frame();
+
+ return true;
+ }
+
+ return false;
+ }
+
+ void drawAllModels(uint8_t _pass, bgfx::ProgramHandle _program)
+ {
+ for (uint32_t ii = 0; ii < BX_COUNTOF(m_models); ++ii)
+ {
+ const Model& model = m_models[ii];
+
+ // Set up transform matrix for each model
+ float scale = s_meshScale[model.mesh];
+ float mtx[16];
+ bx::mtxSRT(mtx
+ , scale
+ , scale
+ , scale
+ , 0.0f
+ , 0.0f
+ , 0.0f
+ , model.position[0]
+ , model.position[1]
+ , model.position[2]
+ );
+
+ // Submit mesh to gbuffer
+ bgfx::setUniform(u_tint, model.color);
+ meshSubmit(m_meshes[model.mesh], _pass, _program, mtx);
+ }
+
+ // Draw ground
+ const float white[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
+ bgfx::setUniform(u_tint, white);
+ float mtxScale[16];
+ float scale = 10.0;
+ bx::mtxScale(mtxScale
+ , scale
+ , scale
+ , scale
+ );
+ float mtxTrans[16];
+ bx::mtxTranslate(mtxTrans
+ , 0.0f
+ , -10.0f
+ , 0.0f
+ );
+ float mtx[16];
+ bx::mtxMul(mtx, mtxScale, mtxTrans);
+ meshSubmit(m_ground, _pass, _program, mtx);
+ }
+
+ void updateLightDir()
+ {
+ float el = m_lightElevation * (bx::pi/180.0f);
+ float az = m_lightAzimuth * (bx::pi/180.0f);
+ m_lightDir[0] = cos(el)*cos(az);
+ m_lightDir[2] = cos(el)*sin(az);
+ m_lightDir[1] = sin(el);
+ m_lightDir[3] = 0.0f;
+ }
+
+ uint32_t m_width;
+ uint32_t m_height;
+ uint32_t m_debug;
+ uint32_t m_reset;
+
+ entry::MouseState m_mouseState;
+
+ Mesh* m_ground;
+ Mesh* m_lightSphere; // Unit sphere
+
+ // Resource handles
+ bgfx::ProgramHandle m_gbufferProgram;
+ bgfx::ProgramHandle m_shadowProgram;
+ bgfx::ProgramHandle m_lightProgram;
+ bgfx::ProgramHandle m_combineProgram;
+ bgfx::FrameBufferHandle m_gbuffer;
+ bgfx::FrameBufferHandle m_lightBuffer;
+ bgfx::FrameBufferHandle m_shadowBuffer;
+
+ // Shader uniforms
+ bgfx::UniformHandle u_tint;
+ bgfx::UniformHandle u_invMvp;
+ bgfx::UniformHandle u_invMvpShadow;
+ bgfx::UniformHandle u_lightMtx;
+ bgfx::UniformHandle u_lightDir;
+ bgfx::UniformHandle u_sphereInfo;
+ bgfx::UniformHandle u_shadowDimsInv;
+ bgfx::UniformHandle u_rsmAmount;
+
+ // Uniforms to identify texture samples
+ bgfx::UniformHandle s_normal;
+ bgfx::UniformHandle s_depth;
+ bgfx::UniformHandle s_color;
+ bgfx::UniformHandle s_light;
+ bgfx::UniformHandle s_shadowMap;
+ bgfx::UniformHandle s_rsm;
+
+ // Various render targets
+ bgfx::TextureHandle m_gbufferTex[3];
+ bgfx::TextureHandle m_lightBufferTex;
+ bgfx::TextureHandle m_shadowBufferTex[2];
+
+ const bgfx::Caps* m_caps;
+
+ struct Model
+ {
+ uint32_t mesh; // Index of mesh in m_meshes
+ float color[4];
+ float position[3];
+ };
+
+ Model m_models[MODEL_COUNT];
+ Mesh * m_meshes[BX_COUNTOF(s_meshPaths)];
+
+ uint32_t m_reading;
+ uint32_t m_currFrame;
+
+ // UI
+ bool m_cameraSpin;
+
+ // Light position;
+ float m_lightDir[4];
+ float m_lightElevation;
+ float m_lightAzimuth;
+
+ float m_rsmAmount; // Amount of rsm
+ float m_vplRadius; // Radius of virtual point light
+
+ float m_texelHalf;
+};
+
+ENTRY_IMPLEMENT_MAIN(ExampleRSM);