bgfx/examples/31-rsm/reflectiveshadowmap.cpp

/*
 * 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:
// 1.  Draw into G-Buffer
// 2.  Draw Shadow Map (with RSM piggybacked on)
// 3.  Populate light buffer
// 4.  Deferred "combine" pass.

// Details:
// 1.  G-Buffer:
// Typical G-Buffer with normals, color, depth.
// 2.  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.
// 3.  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.
// 4.  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 MESH_COUNT  6    // Mesh (which is a vert/index buffer)
#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 i = 0; i < MESH_COUNT; i++)
		{
			m_meshes[i] = meshLoad(s_meshPaths[i]);
		}

		// Randomly create some models
		bx::RngMwc mwc;  // Random number generator
		for (Model & m : m_models)
		{
			uint32_t r = mwc.gen() % 256;
			uint32_t g = mwc.gen() % 256;
			uint32_t b = mwc.gen() % 256;
			m.mesh = 1+mwc.gen()%(MESH_COUNT-1);
			m.color[0] = r/255.0f;
			m.color[1] = g/255.0f;
			m.color[2] = b/255.0f;
			m.color[3] = 1.0f;
			m.position[0] = (((mwc.gen() % 256)) - 128.0f)/20.0f;
			m.position[1] = 0;
			m.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 i = 0; i < MESH_COUNT; i++)
		{
			meshUnload(m_meshes[i]);
		}

		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 i = 0; i < BX_COUNTOF(m_gbufferTex); i++)
			bgfx::destroyTexture(m_gbufferTex[i]);

		bgfx::destroyTexture(m_lightBufferTex);
		for (uint32_t i = 0; i < BX_COUNTOF(m_shadowBufferTex); i++)
			bgfx::destroyTexture(m_shadowBufferTex[i]);

		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-reflectiveshadowmap");
			bgfx::dbgTextPrintf(0, 2, 0x6f, "Description: GI via 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[MESH_COUNT];

	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);