Mirrors/bgfx
1
0
Fork 0
mirror of https://github.com/bkaradzic/bgfx.git synced 2026-02-17 20:52:36 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
fc513e163bd08716a0ec5cd83862ddaabd7e167e
bgfx/examples/46-fsr/app.cpp
Richard Schubert fc513e163b Add new Example - AMD FidelityFX-FSR (#2612) 
* Add new sample

* Add FSR shaders

* Add example template

* Add Antialiasing

* Add multi resolution rendering

* Implement magnifier

* Implement FSR EASU pass

* Implement FSR RCAS pass

* Improve wording of comments and UI

* Remove use of ffx_a.h in cpp

* Remove example external files

* Perform bilinear upsampling by compute shader

* Add FSR 16 Bit support

* Improve magnifier picking

* Fix magnifier picking

* Render magnifier widget

* Renaming of stuff

* Separate magnifier functionality

* Move FSR into separate class

* Reduce scope of FSR resources

* Fix FSR for Vulkan

* Fix OpenGL support

* Update sample screenshot
2021-10-05 09:01:50 -07:00

769 lines
24 KiB
C++
Raw Blame History

/*
* Copyright 2021 Richard Schubert. All rights reserved.
* License: https://github.com/bkaradzic/bgfx#license-bsd-2-clause
*
* 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 <cmath>
#include <algorithm>
#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 screenSpaceTriangle(float _textureWidth, float _textureHeight, float _texelHalf, 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 texelHalfW = _texelHalf / _textureWidth;
const float texelHalfH = _texelHalf / _textureHeight;
const float minu = -1.0f + texelHalfW;
const float maxu = 1.0f + texelHalfW;
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(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 indentify 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_texelHalf = 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);
const bool destroyTextures = true;
m_buffer = bgfx::createFrameBuffer(1, &m_texture, destroyTextures);
}
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, const bgfx::Caps *caps)
{
float invScreenScaleX = 1.0f / static_cast<float>(state.m_width);
float invScreenScaleY = 1.0f / static_cast<float>(state.m_height);
float scaleX = m_widgetWidth * invScreenScaleX;
float scaleY = m_widgetHeight * invScreenScaleY;
float offsetX = -std::min(std::max(m_position.x - m_widgetWidth * 0.5f, -3.0f), static_cast<float>(state.m_width - m_widgetWidth + 3)) * invScreenScaleX;
float offsetY = -std::min(std::max(m_position.y - m_widgetHeight * 0.5f, -3.0f), static_cast<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);
screenSpaceTriangle(float(m_widgetWidth), float(m_widgetHeight), state.m_texelHalf, 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);
}
float const verticalPos = caps->originBottomLeft ? state.m_height - m_position.y : m_position.y;
float const invMagScaleX = 1.0f / static_cast<float>(m_content.m_width);
float const invMagScaleY = 1.0f / static_cast<float>(m_content.m_height);
float const scaleX = state.m_width * invMagScaleX;
float const scaleY = state.m_height * invMagScaleY;
float const offsetX = std::min(std::max(m_position.x - m_content.m_width * 0.5f, 0.0f), static_cast<float>(state.m_width - m_content.m_width)) * scaleX / state.m_width;
float const offsetY = std::min(std::max(verticalPos - m_content.m_height * 0.5f, 0.0f), static_cast<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);
screenSpaceTriangle(float(state.m_width), float(state.m_height), state.m_texelHalf, 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 = const_cast<uint32_t *>((uint32_t *const)(mem->data));
memset(pixels, 0, mem->size);
uint32_t const white = 0xFFFFFFFF;
uint32_t const black = 0xFF000000;
uint32_t const y0 = 1;
uint32_t const 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;
}
uint32_t const x0 = 1;
uint32_t const 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 = BGFX_RESET_MAXANISOTROPY;
bgfx::Init init;
init.type = args.m_type;
init.vendorId = args.m_pciId;
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);
// Get renderer capabilities info.
const bgfx::RendererType::Enum renderer = bgfx::getRendererType();
m_state.m_texelHalf = bgfx::RendererType::Direct3D9 == renderer ? 0.5f : 0.0f;
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(static_cast<float>(m_state.m_mouseState.m_mx),
static_cast<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;
// Draw models into scene
{
bgfx::setViewName(view, "forward scene");
bgfx::setViewClear(view, BGFX_CLEAR_COLOR | BGFX_CLEAR_DEPTH, 0x7fb8ffff, 1.0f, 0);
float const viewScale = m_state.m_renderNativeResolution ? 1.0f : 1.0f / m_state.m_fsr.m_config.m_superSamplingFactor;
uint16_t const viewRectWidth = uint16_t(ceilf(m_state.m_size[0] * viewScale));
uint16_t const viewRectHeight = uint16_t(ceilf(m_state.m_size[1] * viewScale));
uint16_t const viewRectY = 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);
{
// clear out transform stack
float identity[16];
bx::mtxIdentity(identity);
bgfx::setTransform(identity);
}
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);
screenSpaceTriangle(float(m_state.m_width), float(m_state.m_height), m_state.m_texelHalf, caps->originBottomLeft);
bgfx::submit(view, m_state.m_copyLinearToGammaProgram);
}
m_magnifierWidget.drawToScreen(view, m_state, caps);
++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);
ImVec2 const 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;
uint64_t constexpr 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::D24S8, 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\nFor an optimal FSR result high quality antialiasing for the low resolution source image and negative texture LOD bias is recommended.");
Reference in New Issue View Git Blame Copy Permalink