/* * 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 #include #include #include #include #include #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); 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 / static_cast(state.m_width); float invScreenScaleY = 1.0f / static_cast(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), static_cast(state.m_width - m_widgetWidth + 3) ) * invScreenScaleX; float offsetY = -bx::min(bx::max(m_position.y - m_widgetHeight * 0.5f, -3.0f), static_cast(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 / static_cast(m_content.m_width); const float invMagScaleY = 1.0f / static_cast(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), static_cast(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), static_cast(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.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." );