697 lines
22 KiB
C++
697 lines
22 KiB
C++
/*
|
|
* 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 * m_meshPaths[MESH_COUNT] =
|
|
{
|
|
"meshes/cube.bin",
|
|
"meshes/orb.bin",
|
|
"meshes/column.bin",
|
|
"meshes/bunny.bin",
|
|
"meshes/tree.bin",
|
|
"meshes/hollowcube.bin"
|
|
};
|
|
|
|
// 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 ExampleReflectiveShadowMap : public entry::AppI
|
|
{
|
|
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(m_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 (const Model & m : m_models)
|
|
{
|
|
// Set up transform matrix for each model
|
|
float scale = m_meshScale[m.mesh];
|
|
float mtx[16];
|
|
bx::mtxSRT(mtx
|
|
, scale
|
|
, scale
|
|
, scale
|
|
, 0.0f
|
|
, 0.0f
|
|
, 0.0f
|
|
, m.position[0]
|
|
, m.position[1]
|
|
, m.position[2]
|
|
);
|
|
|
|
// Submit mesh to gbuffer
|
|
bgfx::setUniform(u_tint, m.color);
|
|
meshSubmit(m_meshes[m.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];
|
|
|
|
uint32_t m_reading = 0;
|
|
uint32_t m_currFrame = UINT32_MAX;
|
|
|
|
// UI
|
|
bool m_cameraSpin = false;
|
|
|
|
struct Model
|
|
{
|
|
uint32_t mesh; // Index of mesh in m_meshes
|
|
float color[4];
|
|
float position[3];
|
|
};
|
|
|
|
Model m_models[MODEL_COUNT];
|
|
|
|
// Light position;
|
|
float m_lightDir[4];
|
|
float m_lightElevation = 35.0f;
|
|
float m_lightAzimuth = 215.0f;
|
|
|
|
|
|
float m_rsmAmount = 0.25f; // Amount of rsm
|
|
float m_vplRadius = 3.0f; // Radius of virtual point light
|
|
|
|
const float m_meshScale[MESH_COUNT] = {0.25f, 0.5f, 0.05f, 0.5f, 0.05f, 0.05f};
|
|
const bgfx::Caps* m_caps;
|
|
Mesh * m_meshes[MESH_COUNT];
|
|
|
|
float m_texelHalf = 0.0f; // Texel offset for dx9
|
|
};
|
|
|
|
ENTRY_IMPLEMENT_MAIN(ExampleReflectiveShadowMap);
|