mirror of https://github.com/bkaradzic/bgfx
852 lines
23 KiB
C++
852 lines
23 KiB
C++
/*
|
|
* Copyright 2021 Richard Schubert. All rights reserved.
|
|
* License: https://github.com/bkaradzic/bgfx/blob/master/LICENSE
|
|
*
|
|
* AMD FidelityFX Super Resolution 1.0 (FSR)
|
|
* Based on https://github.com/GPUOpen-Effects/FidelityFX-FSR/blob/master/sample/
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include <camera.h>
|
|
#include <bgfx_utils.h>
|
|
#include <imgui/imgui.h>
|
|
#include <bx/rng.h>
|
|
#include <bx/os.h>
|
|
|
|
#include "fsr.h"
|
|
|
|
namespace
|
|
{
|
|
|
|
#define FRAMEBUFFER_RT_COLOR 0
|
|
#define FRAMEBUFFER_RT_DEPTH 1
|
|
#define FRAMEBUFFER_RENDER_TARGETS 2
|
|
|
|
enum Meshes
|
|
{
|
|
MeshCube = 0,
|
|
MeshHollowCube,
|
|
};
|
|
|
|
static const char *s_meshPaths[] =
|
|
{
|
|
"meshes/cube.bin",
|
|
"meshes/hollowcube.bin",
|
|
};
|
|
|
|
static const float s_meshScale[] =
|
|
{
|
|
0.45f,
|
|
0.30f,
|
|
};
|
|
|
|
// 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_layout
|
|
.begin()
|
|
.add(bgfx::Attrib::Position, 3, bgfx::AttribType::Float)
|
|
.add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Float)
|
|
.end();
|
|
}
|
|
|
|
static bgfx::VertexLayout ms_layout;
|
|
};
|
|
|
|
bgfx::VertexLayout PosTexCoord0Vertex::ms_layout;
|
|
|
|
void screenSpaceQuad(bool _originBottomLeft, float _width = 1.0f, float _height = 1.0f, float _offsetX = 0.0f, float _offsetY = 0.0f)
|
|
{
|
|
if (3 == bgfx::getAvailTransientVertexBuffer(3, PosTexCoord0Vertex::ms_layout) )
|
|
{
|
|
bgfx::TransientVertexBuffer vb;
|
|
bgfx::allocTransientVertexBuffer(&vb, 3, PosTexCoord0Vertex::ms_layout);
|
|
PosTexCoord0Vertex *vertex = (PosTexCoord0Vertex *)vb.data;
|
|
|
|
const float minx = -_width - _offsetX;
|
|
const float maxx = _width - _offsetX;
|
|
const float miny = 0.0f - _offsetY;
|
|
const float maxy = _height * 2.0f - _offsetY;
|
|
|
|
const float minu = -1.0f;
|
|
const float maxu = 1.0f;
|
|
|
|
const float zz = 0.0f;
|
|
|
|
float minv = 0.0f;
|
|
float maxv = 2.0f;
|
|
|
|
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(0, &vb);
|
|
}
|
|
}
|
|
|
|
struct ModelUniforms
|
|
{
|
|
enum
|
|
{
|
|
NumVec4 = 2
|
|
};
|
|
|
|
void init()
|
|
{
|
|
u_params = bgfx::createUniform("u_modelParams", bgfx::UniformType::Vec4, NumVec4);
|
|
};
|
|
|
|
void submit() const
|
|
{
|
|
bgfx::setUniform(u_params, m_params, NumVec4);
|
|
};
|
|
|
|
void destroy()
|
|
{
|
|
bgfx::destroy(u_params);
|
|
}
|
|
|
|
union
|
|
{
|
|
struct
|
|
{
|
|
/* 0 */ struct
|
|
{
|
|
float m_color[3];
|
|
float m_unused0;
|
|
};
|
|
/* 1 */ struct
|
|
{
|
|
float m_lightPosition[3];
|
|
float m_unused1;
|
|
};
|
|
};
|
|
|
|
float m_params[NumVec4 * 4];
|
|
};
|
|
|
|
bgfx::UniformHandle u_params;
|
|
};
|
|
|
|
struct AppState
|
|
{
|
|
uint32_t m_width;
|
|
uint32_t m_height;
|
|
uint32_t m_debug;
|
|
uint32_t m_reset;
|
|
|
|
entry::MouseState m_mouseState;
|
|
|
|
// Resource handles
|
|
bgfx::ProgramHandle m_forwardProgram;
|
|
bgfx::ProgramHandle m_gridProgram;
|
|
bgfx::ProgramHandle m_copyLinearToGammaProgram;
|
|
|
|
// Shader uniforms
|
|
ModelUniforms m_modelUniforms;
|
|
|
|
// Uniforms to identify texture samplers
|
|
bgfx::UniformHandle s_albedo;
|
|
bgfx::UniformHandle s_color;
|
|
bgfx::UniformHandle s_normal;
|
|
|
|
bgfx::FrameBufferHandle m_frameBuffer;
|
|
bgfx::TextureHandle m_frameBufferTex[FRAMEBUFFER_RENDER_TARGETS];
|
|
|
|
Mesh *m_meshes[BX_COUNTOF(s_meshPaths)];
|
|
bgfx::TextureHandle m_groundTexture;
|
|
bgfx::TextureHandle m_normalTexture;
|
|
|
|
uint32_t m_currFrame{UINT32_MAX};
|
|
float m_lightRotation = 0.0f;
|
|
float m_fovY = 60.0f;
|
|
float m_animationTime = 0.0f;
|
|
|
|
float m_view[16];
|
|
float m_proj[16];
|
|
int32_t m_size[2];
|
|
|
|
// UI parameters
|
|
bool m_renderNativeResolution = false;
|
|
bool m_animateScene = false;
|
|
int32_t m_antiAliasingSetting = 2;
|
|
|
|
Fsr m_fsr;
|
|
};
|
|
|
|
struct RenderTarget
|
|
{
|
|
void init(uint32_t _width, uint32_t _height, bgfx::TextureFormat::Enum _format, uint64_t _flags)
|
|
{
|
|
m_width = _width;
|
|
m_height = _height;
|
|
m_texture = bgfx::createTexture2D(uint16_t(_width), uint16_t(_height), false, 1, _format, _flags);
|
|
m_buffer = bgfx::createFrameBuffer(1, &m_texture, true);
|
|
}
|
|
|
|
void destroy()
|
|
{
|
|
// also responsible for destroying texture
|
|
bgfx::destroy(m_buffer);
|
|
}
|
|
|
|
uint32_t m_width;
|
|
uint32_t m_height;
|
|
bgfx::TextureHandle m_texture;
|
|
bgfx::FrameBufferHandle m_buffer;
|
|
};
|
|
|
|
struct MagnifierWidget
|
|
{
|
|
void init(uint32_t _width, uint32_t _height)
|
|
{
|
|
m_content.init(_width, _height, bgfx::TextureFormat::BGRA8, BGFX_TEXTURE_RT | BGFX_SAMPLER_MIN_POINT | BGFX_SAMPLER_MAG_POINT);
|
|
createWidgetTexture(_width + 6, _height + 6);
|
|
}
|
|
|
|
void destroy()
|
|
{
|
|
bgfx::destroy(m_widgetTexture);
|
|
m_content.destroy();
|
|
}
|
|
|
|
void setPosition(float x, float y)
|
|
{
|
|
m_position.x = x;
|
|
m_position.y = y;
|
|
}
|
|
|
|
void drawToScreen(bgfx::ViewId &view, AppState const &state)
|
|
{
|
|
float invScreenScaleX = 1.0f / float(state.m_width);
|
|
float invScreenScaleY = 1.0f / float(state.m_height);
|
|
float scaleX = m_widgetWidth * invScreenScaleX;
|
|
float scaleY = m_widgetHeight * invScreenScaleY;
|
|
float offsetX = -bx::min(bx::max(m_position.x - m_widgetWidth * 0.5f, -3.0f), float(state.m_width - m_widgetWidth + 3) ) * invScreenScaleX;
|
|
float offsetY = -bx::min(bx::max(m_position.y - m_widgetHeight * 0.5f, -3.0f), float(state.m_height - m_widgetHeight + 3) ) * invScreenScaleY;
|
|
|
|
bgfx::setState(0 | BGFX_STATE_WRITE_RGB | BGFX_STATE_WRITE_A | BGFX_STATE_DEPTH_TEST_ALWAYS | BGFX_STATE_BLEND_ALPHA);
|
|
bgfx::setTexture(0, state.s_color, m_widgetTexture);
|
|
screenSpaceQuad(false, scaleX, scaleY, offsetX, offsetY);
|
|
bgfx::submit(view, state.m_copyLinearToGammaProgram);
|
|
}
|
|
|
|
void updateContent(bgfx::ViewId &view, AppState const &state, const bgfx::Caps *caps, bgfx::TextureHandle srcTexture)
|
|
{
|
|
float orthoProj[16];
|
|
bx::mtxOrtho(orthoProj, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, caps->homogeneousDepth);
|
|
{
|
|
// clear out transform stack
|
|
float identity[16];
|
|
bx::mtxIdentity(identity);
|
|
bgfx::setTransform(identity);
|
|
}
|
|
|
|
const float verticalPos = caps->originBottomLeft ? state.m_height - m_position.y : m_position.y;
|
|
const float invMagScaleX = 1.0f / float(m_content.m_width);
|
|
const float invMagScaleY = 1.0f / float(m_content.m_height);
|
|
const float scaleX = state.m_width * invMagScaleX;
|
|
const float scaleY = state.m_height * invMagScaleY;
|
|
const float offsetX = bx::min(bx::max(m_position.x - m_content.m_width * 0.5f, 0.0f), float(state.m_width - m_content.m_width) ) * scaleX / state.m_width;
|
|
const float offsetY = bx::min(bx::max(verticalPos - m_content.m_height * 0.5f, 0.0f), float(state.m_height - m_content.m_height) ) * scaleY / state.m_height;
|
|
|
|
bgfx::setViewName(view, "magnifier");
|
|
bgfx::setViewRect(view, 0, 0, uint16_t(m_content.m_width), uint16_t(m_content.m_height) );
|
|
bgfx::setViewTransform(view, NULL, orthoProj);
|
|
bgfx::setViewFrameBuffer(view, m_content.m_buffer);
|
|
bgfx::setState(0 | BGFX_STATE_WRITE_RGB | BGFX_STATE_WRITE_A);
|
|
bgfx::setTexture(0, state.s_color, srcTexture, BGFX_SAMPLER_MIN_POINT | BGFX_SAMPLER_MAG_POINT | BGFX_SAMPLER_U_CLAMP | BGFX_SAMPLER_V_CLAMP);
|
|
screenSpaceQuad(false, scaleX, scaleY, offsetX, offsetY);
|
|
bgfx::submit(view, state.m_copyLinearToGammaProgram);
|
|
++view;
|
|
}
|
|
|
|
uint32_t m_widgetWidth{0};
|
|
uint32_t m_widgetHeight{0};
|
|
bgfx::TextureHandle m_widgetTexture;
|
|
RenderTarget m_content;
|
|
ImVec2 m_position;
|
|
|
|
private:
|
|
void createWidgetTexture(uint32_t _width, uint32_t _height)
|
|
{
|
|
const bgfx::Memory *mem = bgfx::alloc(_width * _height * sizeof(uint32_t) );
|
|
|
|
uint32_t *pixels = (uint32_t*)mem->data;
|
|
bx::memSet(pixels, 0, mem->size);
|
|
|
|
const uint32_t white = 0xFFFFFFFF;
|
|
const uint32_t black = 0xFF000000;
|
|
|
|
const uint32_t y0 = 1;
|
|
const uint32_t y1 = _height - 3;
|
|
|
|
for (uint32_t x = 0; x < _width - 4; x++)
|
|
{
|
|
pixels[(y0 + 0) * _width + x + 1] = white;
|
|
pixels[(y0 + 1) * _width + x + 2] = black;
|
|
pixels[(y1 + 0) * _width + x + 1] = white;
|
|
pixels[(y1 + 1) * _width + x + 2] = black;
|
|
}
|
|
|
|
const uint32_t x0 = 1;
|
|
const uint32_t x1 = _width - 3;
|
|
|
|
for (uint32_t y = 0; y < _height - 3; y++)
|
|
{
|
|
pixels[(y + 1) * _width + x0 + 0] = white;
|
|
pixels[(y + 2) * _width + x0 + 1] = black;
|
|
pixels[(y + 1) * _width + x1 + 0] = white;
|
|
pixels[(y + 2) * _width + x1 + 1] = black;
|
|
}
|
|
|
|
pixels[(y1 + 0) * _width + 2] = white;
|
|
|
|
m_widgetWidth = _width;
|
|
m_widgetHeight = _height;
|
|
m_widgetTexture = bgfx::createTexture2D(
|
|
uint16_t(_width)
|
|
, uint16_t(_height)
|
|
, false
|
|
, 1
|
|
, bgfx::TextureFormat::BGRA8
|
|
, BGFX_SAMPLER_MIN_POINT | BGFX_SAMPLER_MAG_POINT | BGFX_SAMPLER_U_CLAMP | BGFX_SAMPLER_V_CLAMP
|
|
, mem
|
|
);
|
|
}
|
|
};
|
|
|
|
class ExampleFsr : public entry::AppI
|
|
{
|
|
public:
|
|
ExampleFsr(const char *_name, const char *_description)
|
|
: entry::AppI(_name, _description)
|
|
{
|
|
}
|
|
|
|
void init(int32_t _argc, const char *const *_argv, uint32_t _width, uint32_t _height) override
|
|
{
|
|
Args args(_argc, _argv);
|
|
|
|
m_state.m_width = _width;
|
|
m_state.m_height = _height;
|
|
m_state.m_debug = BGFX_DEBUG_NONE;
|
|
m_state.m_reset = 0
|
|
| BGFX_RESET_VSYNC
|
|
| BGFX_RESET_MAXANISOTROPY
|
|
;
|
|
|
|
bgfx::Init init;
|
|
init.type = args.m_type;
|
|
init.vendorId = args.m_pciId;
|
|
init.platformData.nwh = entry::getNativeWindowHandle(entry::kDefaultWindowHandle);
|
|
init.platformData.ndt = entry::getNativeDisplayHandle();
|
|
init.resolution.width = m_state.m_width;
|
|
init.resolution.height = m_state.m_height;
|
|
init.resolution.reset = m_state.m_reset;
|
|
bgfx::init(init);
|
|
|
|
// Enable debug text.
|
|
bgfx::setDebug(m_state.m_debug);
|
|
|
|
// Create uniforms for screen passes and models
|
|
m_state.m_modelUniforms.init();
|
|
|
|
// Create texture sampler uniforms (used when we bind textures)
|
|
m_state.s_albedo = bgfx::createUniform("s_albedo", bgfx::UniformType::Sampler);
|
|
m_state.s_color = bgfx::createUniform("s_color", bgfx::UniformType::Sampler);
|
|
m_state.s_normal = bgfx::createUniform("s_normal", bgfx::UniformType::Sampler);
|
|
|
|
// Create program from shaders.
|
|
m_state.m_forwardProgram = loadProgram("vs_fsr_forward", "fs_fsr_forward");
|
|
m_state.m_gridProgram = loadProgram("vs_fsr_forward", "fs_fsr_forward_grid");
|
|
m_state.m_copyLinearToGammaProgram = loadProgram("vs_fsr_screenquad", "fs_fsr_copy_linear_to_gamma");
|
|
|
|
// Load some meshes
|
|
for (uint32_t ii = 0; ii < BX_COUNTOF(s_meshPaths); ++ii)
|
|
{
|
|
m_state.m_meshes[ii] = meshLoad(s_meshPaths[ii]);
|
|
}
|
|
|
|
m_state.m_groundTexture = loadTexture("textures/fieldstone-rgba.dds");
|
|
m_state.m_normalTexture = loadTexture("textures/fieldstone-n.dds");
|
|
|
|
createFramebuffers();
|
|
|
|
// Vertex decl
|
|
PosTexCoord0Vertex::init();
|
|
|
|
// Init camera
|
|
cameraCreate();
|
|
cameraSetPosition({-10.0f, 2.5f, -0.0f});
|
|
cameraSetVerticalAngle(-0.2f);
|
|
cameraSetHorizontalAngle(0.8f);
|
|
|
|
// Init "prev" matrices, will be same for first frame
|
|
cameraGetViewMtx(m_state.m_view);
|
|
bx::mtxProj(m_state.m_proj, m_state.m_fovY, float(m_state.m_size[0]) / float(m_state.m_size[1]), 0.01f, 100.0f, bgfx::getCaps()->homogeneousDepth);
|
|
|
|
const uint32_t magnifierSize = 32;
|
|
m_magnifierWidget.init(magnifierSize, magnifierSize);
|
|
m_magnifierWidget.setPosition(m_state.m_width * 0.5f, m_state.m_height * 0.5f);
|
|
|
|
imguiCreate();
|
|
|
|
m_state.m_fsr.init(_width, _height);
|
|
}
|
|
|
|
int32_t shutdown() override
|
|
{
|
|
m_state.m_fsr.destroy();
|
|
|
|
for (uint32_t ii = 0; ii < BX_COUNTOF(s_meshPaths); ++ii)
|
|
{
|
|
meshUnload(m_state.m_meshes[ii]);
|
|
}
|
|
|
|
bgfx::destroy(m_state.m_normalTexture);
|
|
bgfx::destroy(m_state.m_groundTexture);
|
|
|
|
bgfx::destroy(m_state.m_forwardProgram);
|
|
bgfx::destroy(m_state.m_gridProgram);
|
|
bgfx::destroy(m_state.m_copyLinearToGammaProgram);
|
|
|
|
m_state.m_modelUniforms.destroy();
|
|
|
|
m_magnifierWidget.destroy();
|
|
|
|
bgfx::destroy(m_state.s_albedo);
|
|
bgfx::destroy(m_state.s_color);
|
|
bgfx::destroy(m_state.s_normal);
|
|
|
|
destroyFramebuffers();
|
|
|
|
cameraDestroy();
|
|
|
|
imguiDestroy();
|
|
|
|
bgfx::shutdown();
|
|
|
|
return 0;
|
|
}
|
|
|
|
bool update() override
|
|
{
|
|
if (!entry::processEvents(m_state.m_width, m_state.m_height, m_state.m_debug, m_state.m_reset, &m_state.m_mouseState) )
|
|
{
|
|
// skip processing when minimized, otherwise crashing
|
|
if (0 == m_state.m_width
|
|
|| 0 == m_state.m_height)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (m_state.m_mouseState.m_buttons[entry::MouseButton::Left]
|
|
&& !ImGui::MouseOverArea() )
|
|
{
|
|
m_magnifierWidget.setPosition(
|
|
float(m_state.m_mouseState.m_mx)
|
|
, float(m_state.m_mouseState.m_my)
|
|
);
|
|
}
|
|
|
|
// 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 float deltaTime = float(frameTime / freq);
|
|
const bgfx::Caps* caps = bgfx::getCaps();
|
|
|
|
if (m_state.m_size[0] != (int32_t)m_state.m_width || m_state.m_size[1] != (int32_t)m_state.m_height)
|
|
{
|
|
resize();
|
|
}
|
|
|
|
// update animation time
|
|
const float rotationSpeed = 0.25f;
|
|
if (m_state.m_animateScene)
|
|
{
|
|
m_state.m_animationTime += deltaTime * rotationSpeed;
|
|
if (bx::kPi2 < m_state.m_animationTime)
|
|
{
|
|
m_state.m_animationTime -= bx::kPi2;
|
|
}
|
|
}
|
|
|
|
// Update camera
|
|
cameraUpdate(deltaTime * 0.15f, m_state.m_mouseState, ImGui::MouseOverArea() );
|
|
|
|
cameraGetViewMtx(m_state.m_view);
|
|
|
|
updateUniforms();
|
|
|
|
bx::mtxProj(
|
|
m_state.m_proj
|
|
, m_state.m_fovY
|
|
, float(m_state.m_size[0]) / float(m_state.m_size[1])
|
|
, 0.01f
|
|
, 100.0f
|
|
, caps->homogeneousDepth
|
|
);
|
|
|
|
bgfx::ViewId view = 0;
|
|
|
|
// Clear full frame buffer to avoid sampling into garbage during FSR pass
|
|
if (!m_state.m_renderNativeResolution)
|
|
{
|
|
bgfx::setViewRect(view, 0, 0, (uint16_t)m_state.m_width, (uint16_t)m_state.m_height);
|
|
bgfx::setViewClear(view, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x00000000, 1.0f, 0);
|
|
bgfx::setViewFrameBuffer(view, m_state.m_frameBuffer);
|
|
bgfx::touch(view);
|
|
|
|
++view;
|
|
}
|
|
|
|
// Draw models into scene
|
|
{
|
|
bgfx::setViewName(view, "forward scene");
|
|
bgfx::setViewClear(view, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x7fb8ffff, 1.0f, 0);
|
|
|
|
const float viewScale = m_state.m_renderNativeResolution
|
|
? 1.0f
|
|
: 1.0f / m_state.m_fsr.m_config.m_superSamplingFactor
|
|
;
|
|
const uint16_t viewRectWidth = uint16_t(bx::ceil(m_state.m_size[0] * viewScale) );
|
|
const uint16_t viewRectHeight = uint16_t(bx::ceil(m_state.m_size[1] * viewScale) );
|
|
const uint16_t viewRectY = uint16_t(caps->originBottomLeft ? m_state.m_size[1] - viewRectHeight : 0);
|
|
|
|
bgfx::setViewRect(view, 0, viewRectY, viewRectWidth, viewRectHeight);
|
|
bgfx::setViewTransform(view, m_state.m_view, m_state.m_proj);
|
|
bgfx::setViewFrameBuffer(view, m_state.m_frameBuffer);
|
|
|
|
bgfx::setState(0
|
|
| BGFX_STATE_WRITE_RGB
|
|
| BGFX_STATE_WRITE_A
|
|
| BGFX_STATE_WRITE_Z
|
|
| BGFX_STATE_DEPTH_TEST_LESS
|
|
);
|
|
|
|
drawAllModels(view, m_state.m_forwardProgram, m_state.m_modelUniforms);
|
|
|
|
++view;
|
|
}
|
|
|
|
// optionally run FSR
|
|
if (!m_state.m_renderNativeResolution)
|
|
{
|
|
view = m_state.m_fsr.computeFsr(view, m_state.m_frameBufferTex[FRAMEBUFFER_RT_COLOR]);
|
|
}
|
|
|
|
// render result to screen
|
|
{
|
|
bgfx::TextureHandle srcTexture = m_state.m_frameBufferTex[FRAMEBUFFER_RT_COLOR];
|
|
|
|
if (!m_state.m_renderNativeResolution)
|
|
{
|
|
srcTexture = m_state.m_fsr.getResultTexture();
|
|
}
|
|
|
|
m_magnifierWidget.updateContent(view, m_state, caps, srcTexture);
|
|
|
|
float orthoProj[16];
|
|
bx::mtxOrtho(orthoProj, 0.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, caps->homogeneousDepth);
|
|
|
|
bgfx::setViewName(view, "display");
|
|
bgfx::setViewClear(view, BGFX_CLEAR_NONE, 0, 1.0f, 0);
|
|
|
|
bgfx::setViewRect(view, 0, 0, uint16_t(m_state.m_width), uint16_t(m_state.m_height) );
|
|
bgfx::setViewTransform(view, NULL, orthoProj);
|
|
bgfx::setViewFrameBuffer(view, BGFX_INVALID_HANDLE);
|
|
bgfx::setState(0 | BGFX_STATE_WRITE_RGB | BGFX_STATE_WRITE_A);
|
|
bgfx::setTexture(0, m_state.s_color, srcTexture, BGFX_SAMPLER_MIN_POINT | BGFX_SAMPLER_MAG_POINT | BGFX_SAMPLER_U_CLAMP | BGFX_SAMPLER_V_CLAMP);
|
|
screenSpaceQuad(caps->originBottomLeft);
|
|
bgfx::submit(view, m_state.m_copyLinearToGammaProgram);
|
|
}
|
|
|
|
m_magnifierWidget.drawToScreen(view, m_state);
|
|
|
|
++view;
|
|
|
|
// Draw UI
|
|
imguiBeginFrame(m_state.m_mouseState.m_mx, m_state.m_mouseState.m_my, (m_state.m_mouseState.m_buttons[entry::MouseButton::Left] ? IMGUI_MBUT_LEFT : 0) | (m_state.m_mouseState.m_buttons[entry::MouseButton::Right] ? IMGUI_MBUT_RIGHT : 0) | (m_state.m_mouseState.m_buttons[entry::MouseButton::Middle] ? IMGUI_MBUT_MIDDLE : 0), m_state.m_mouseState.m_mz, uint16_t(m_state.m_width), uint16_t(m_state.m_height) );
|
|
|
|
showExampleDialog(this);
|
|
|
|
ImGui::SetNextWindowPos(ImVec2(m_state.m_width - m_state.m_width / 4.0f - 10.0f, 10.0f), ImGuiCond_FirstUseEver);
|
|
ImGui::SetNextWindowSize(ImVec2(m_state.m_width / 4.0f, m_state.m_height / 1.2f), ImGuiCond_FirstUseEver);
|
|
ImGui::Begin("Settings", NULL, 0);
|
|
ImGui::PushItemWidth(ImGui::GetWindowWidth() * 0.5f);
|
|
|
|
const ImVec2 itemSize = ImGui::GetItemRectSize();
|
|
|
|
{
|
|
ImGui::Checkbox("Animate scene", &m_state.m_animateScene);
|
|
|
|
if (ImGui::Combo("Antialiasing", &m_state.m_antiAliasingSetting, "none\0""4x\0""16x\0""\0") )
|
|
{
|
|
resize();
|
|
}
|
|
|
|
ImGui::Checkbox("Render native resolution", &m_state.m_renderNativeResolution);
|
|
|
|
if (ImGui::IsItemHovered() )
|
|
{
|
|
ImGui::SetTooltip("Disable super sampling and FSR.");
|
|
}
|
|
|
|
ImGui::Image(m_magnifierWidget.m_content.m_texture, ImVec2(itemSize.x * 0.94f, itemSize.x * 0.94f) );
|
|
|
|
if (!m_state.m_renderNativeResolution)
|
|
{
|
|
ImGui::SliderFloat("Super sampling", &m_state.m_fsr.m_config.m_superSamplingFactor, 1.0f, 2.0f);
|
|
|
|
if (ImGui::IsItemHovered() )
|
|
{
|
|
ImGui::BeginTooltip();
|
|
ImGui::Text("2.0 means the scene is rendered at half window resolution.");
|
|
ImGui::Text("1.0 means the scene is rendered at native window resolution.");
|
|
ImGui::EndTooltip();
|
|
}
|
|
|
|
ImGui::Separator();
|
|
|
|
if (m_state.m_fsr.supports16BitPrecision() )
|
|
{
|
|
ImGui::Checkbox("Use 16 Bit", &m_state.m_fsr.m_config.m_fsr16Bit);
|
|
|
|
if (ImGui::IsItemHovered() )
|
|
{
|
|
ImGui::BeginTooltip();
|
|
ImGui::Text("For better performance and less memory consumption use 16 Bit precision.");
|
|
ImGui::Text("If disabled use 32 Bit per channel precision for FSR which works better on older hardware.");
|
|
ImGui::Text("FSR in 16 Bit precision is also prone to be broken in Direct3D11, Direct3D12 works though.");
|
|
ImGui::EndTooltip();
|
|
}
|
|
}
|
|
|
|
ImGui::Checkbox("Apply FSR", &m_state.m_fsr.m_config.m_applyFsr);
|
|
|
|
if (ImGui::IsItemHovered() )
|
|
{
|
|
ImGui::SetTooltip("Compare between FSR and bilinear interpolation of source image.");
|
|
}
|
|
|
|
if (m_state.m_fsr.m_config.m_applyFsr)
|
|
{
|
|
ImGui::Checkbox("Apply FSR sharpening", &m_state.m_fsr.m_config.m_applyFsrRcas);
|
|
|
|
if (ImGui::IsItemHovered() )
|
|
{
|
|
ImGui::SetTooltip("Apply the FSR RCAS sharpening pass.");
|
|
}
|
|
|
|
if (m_state.m_fsr.m_config.m_applyFsrRcas)
|
|
{
|
|
ImGui::SliderFloat("Sharpening attenuation", &m_state.m_fsr.m_config.m_rcasAttenuation, 0.01f, 2.0f);
|
|
|
|
if (ImGui::IsItemHovered() )
|
|
{
|
|
ImGui::SetTooltip("Lower value means sharper.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ImGui::End();
|
|
|
|
imguiEndFrame();
|
|
|
|
// Advance to next frame. Rendering thread will be kicked to
|
|
// process submitted rendering primitives.
|
|
m_state.m_currFrame = bgfx::frame();
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void drawAllModels(bgfx::ViewId _pass, bgfx::ProgramHandle _program, ModelUniforms &_uniforms)
|
|
{
|
|
const int32_t width = 6;
|
|
const int32_t length = 20;
|
|
|
|
float c0[] = { 235.0f / 255.0f, 126.0f / 255.0f, 30.0f / 255.0f}; // orange
|
|
float c1[] = { 235.0f / 255.0f, 146.0f / 255.0f, 251.0f / 255.0f}; // purple
|
|
float c2[] = { 199.0f / 255.0f, 0.0f / 255.0f, 57.0f / 255.0f}; // pink
|
|
|
|
for (int32_t zz = 0; zz < length; ++zz)
|
|
{
|
|
// make a color gradient, nothing special about this for example
|
|
float *ca = c0;
|
|
float *cb = c1;
|
|
float lerpVal = float(zz) / float(length);
|
|
|
|
if (0.5f <= lerpVal)
|
|
{
|
|
ca = c1;
|
|
cb = c2;
|
|
}
|
|
lerpVal = bx::fract(2.0f * lerpVal);
|
|
|
|
float r = bx::lerp(ca[0], cb[0], lerpVal);
|
|
float g = bx::lerp(ca[1], cb[1], lerpVal);
|
|
float b = bx::lerp(ca[2], cb[2], lerpVal);
|
|
|
|
for (int32_t xx = 0; xx < width; ++xx)
|
|
{
|
|
const float angle = m_state.m_animationTime + float(zz) * (bx::kPi2 / length) + float(xx) * (bx::kPiHalf / width);
|
|
|
|
const float posX = 2.0f * xx - width + 1.0f;
|
|
const float posY = bx::sin(angle);
|
|
const float posZ = 2.0f * zz - length + 1.0f;
|
|
|
|
const float scale = s_meshScale[MeshHollowCube];
|
|
float mtx[16];
|
|
bx::mtxSRT(mtx, scale, scale, scale, 0.0f, 0.0f, 0.0f, posX, posY, posZ);
|
|
|
|
bgfx::setTexture(0, m_state.s_albedo, m_state.m_groundTexture);
|
|
bgfx::setTexture(1, m_state.s_normal, m_state.m_normalTexture);
|
|
_uniforms.m_color[0] = r;
|
|
_uniforms.m_color[1] = g;
|
|
_uniforms.m_color[2] = b;
|
|
_uniforms.submit();
|
|
|
|
meshSubmit(m_state.m_meshes[MeshHollowCube], _pass, _program, mtx);
|
|
}
|
|
}
|
|
|
|
// draw box as ground plane
|
|
{
|
|
const float posY = -2.0f;
|
|
const float scale = length;
|
|
float mtx[16];
|
|
bx::mtxSRT(mtx, scale, scale, scale, 0.0f, 0.0f, 0.0f, 0.0f, -scale + posY, 0.0f);
|
|
|
|
_uniforms.m_color[0] = 0.5f;
|
|
_uniforms.m_color[1] = 0.5f;
|
|
_uniforms.m_color[2] = 0.5f;
|
|
_uniforms.submit();
|
|
|
|
meshSubmit(m_state.m_meshes[MeshCube], _pass, m_state.m_gridProgram, mtx);
|
|
}
|
|
}
|
|
|
|
void resize()
|
|
{
|
|
destroyFramebuffers();
|
|
createFramebuffers();
|
|
m_state.m_fsr.resize(m_state.m_width, m_state.m_height);
|
|
}
|
|
|
|
void createFramebuffers()
|
|
{
|
|
m_state.m_size[0] = m_state.m_width;
|
|
m_state.m_size[1] = m_state.m_height;
|
|
|
|
constexpr uint64_t msaaFlags[] =
|
|
{
|
|
BGFX_TEXTURE_NONE,
|
|
BGFX_TEXTURE_RT_MSAA_X4,
|
|
BGFX_TEXTURE_RT_MSAA_X16,
|
|
};
|
|
|
|
const uint64_t msaa = msaaFlags[m_state.m_antiAliasingSetting];
|
|
const uint64_t colorFlags = 0
|
|
| BGFX_TEXTURE_RT
|
|
| BGFX_SAMPLER_U_CLAMP
|
|
| BGFX_SAMPLER_V_CLAMP
|
|
| msaa
|
|
;
|
|
const uint64_t depthFlags = 0
|
|
| BGFX_TEXTURE_RT_WRITE_ONLY
|
|
| msaa
|
|
;
|
|
|
|
m_state.m_frameBufferTex[FRAMEBUFFER_RT_COLOR] = bgfx::createTexture2D(
|
|
uint16_t(m_state.m_size[0])
|
|
, uint16_t(m_state.m_size[1])
|
|
, false
|
|
, 1
|
|
, bgfx::TextureFormat::RGBA16F
|
|
, colorFlags
|
|
);
|
|
|
|
m_state.m_frameBufferTex[FRAMEBUFFER_RT_DEPTH] = bgfx::createTexture2D(
|
|
uint16_t(m_state.m_size[0])
|
|
, uint16_t(m_state.m_size[1])
|
|
, false
|
|
, 1
|
|
, bgfx::TextureFormat::D32F
|
|
, depthFlags
|
|
);
|
|
|
|
m_state.m_frameBuffer = bgfx::createFrameBuffer(
|
|
BX_COUNTOF(m_state.m_frameBufferTex)
|
|
, m_state.m_frameBufferTex
|
|
, true
|
|
);
|
|
}
|
|
|
|
// all buffers set to destroy their textures
|
|
void destroyFramebuffers()
|
|
{
|
|
bgfx::destroy(m_state.m_frameBuffer);
|
|
}
|
|
|
|
void updateUniforms()
|
|
{
|
|
m_state.m_modelUniforms.m_lightPosition[0] = 0.0f;
|
|
m_state.m_modelUniforms.m_lightPosition[1] = 6.0f;
|
|
m_state.m_modelUniforms.m_lightPosition[2] = 10.0f;
|
|
}
|
|
|
|
AppState m_state;
|
|
MagnifierWidget m_magnifierWidget;
|
|
};
|
|
|
|
} // namespace
|
|
|
|
ENTRY_IMPLEMENT_MAIN(
|
|
ExampleFsr
|
|
, "46-fsr"
|
|
, "AMD FidelityFX Super Resolution (FSR)\n"
|
|
"\n"
|
|
"For an optimal FSR result high quality antialiasing for the low resolution source image and negative texture LOD bias is recommended."
|
|
);
|