diff options
Diffstat (limited to '3rdparty/bgfx/examples/46-fsr/app.cpp')
-rw-r--r-- | 3rdparty/bgfx/examples/46-fsr/app.cpp | 858 |
1 files changed, 858 insertions, 0 deletions
diff --git a/3rdparty/bgfx/examples/46-fsr/app.cpp b/3rdparty/bgfx/examples/46-fsr/app.cpp new file mode 100644 index 00000000000..4049d3e1e7e --- /dev/null +++ b/3rdparty/bgfx/examples/46-fsr/app.cpp @@ -0,0 +1,858 @@ +/* + * 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 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 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_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); + 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); + 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); + } + + 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); + 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 = (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); + + // 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( + 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); + 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); + + ++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." + ); |