/* ** gl_framebuffer.cpp ** Implementation of the non-hardware specific parts of the ** OpenGL frame buffer ** **--------------------------------------------------------------------------- ** Copyright 2010-2020 Christoph Oelckers ** All rights reserved. ** ** Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions ** are met: ** ** 1. Redistributions of source code must retain the above copyright ** notice, this list of conditions and the following disclaimer. ** 2. Redistributions in binary form must reproduce the above copyright ** notice, this list of conditions and the following disclaimer in the ** documentation and/or other materials provided with the distribution. ** 3. The name of the author may not be used to endorse or promote products ** derived from this software without specific prior written permission. ** ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. ** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT ** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF ** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. **--------------------------------------------------------------------------- ** */ #include "gl_system.h" #include "v_video.h" #include "m_png.h" #include "i_time.h" #include "gl_interface.h" #include "gl_framebuffer.h" #include "gl_renderer.h" #include "gl_renderbuffers.h" #include "gl_samplers.h" #include "hw_clock.h" #include "hw_vrmodes.h" #include "hw_skydome.h" #include "hw_viewpointbuffer.h" #include "hw_lightbuffer.h" #include "gl_shaderprogram.h" #include "gl_debug.h" #include "r_videoscale.h" #include "gl_buffers.h" #include "gl_postprocessstate.h" #include "v_draw.h" #include "printf.h" #include "gl_hwtexture.h" #include "flatvertices.h" #include "hw_cvars.h" EXTERN_CVAR (Bool, vid_vsync) EXTERN_CVAR(Bool, r_drawvoxels) EXTERN_CVAR(Int, gl_tonemap) EXTERN_CVAR(Bool, cl_capfps) EXTERN_CVAR(Int, gl_pipeline_depth); void gl_LoadExtensions(); void gl_PrintStartupLog(); extern bool vid_hdr_active; namespace OpenGLRenderer { FGLRenderer *GLRenderer; //========================================================================== // // // //========================================================================== OpenGLFrameBuffer::OpenGLFrameBuffer(void *hMonitor, bool fullscreen) : Super(hMonitor, fullscreen) { // SetVSync needs to be at the very top to workaround a bug in Nvidia's OpenGL driver. // If wglSwapIntervalEXT is called after glBindFramebuffer in a frame the setting is not changed! Super::SetVSync(vid_vsync); FHardwareTexture::InitGlobalState(); // Make sure all global variables tracking OpenGL context state are reset.. gl_RenderState.Reset(); GLRenderer = nullptr; } OpenGLFrameBuffer::~OpenGLFrameBuffer() { PPResource::ResetAll(); if (mVertexData != nullptr) delete mVertexData; if (mSkyData != nullptr) delete mSkyData; if (mViewpoints != nullptr) delete mViewpoints; if (mLights != nullptr) delete mLights; mShadowMap.Reset(); if (GLRenderer) { delete GLRenderer; GLRenderer = nullptr; } } //========================================================================== // // Initializes the GL renderer // //========================================================================== void OpenGLFrameBuffer::InitializeState() { static bool first=true; if (first) { if (ogl_LoadFunctions() == ogl_LOAD_FAILED) { I_FatalError("Failed to load OpenGL functions."); } } gl_LoadExtensions(); mPipelineNbr = clamp(*gl_pipeline_depth, 1, HW_MAX_PIPELINE_BUFFERS); mPipelineType = gl_pipeline_depth > 0; // Move some state to the framebuffer object for easier access. hwcaps = gl.flags; glslversion = gl.glslversion; uniformblockalignment = gl.uniformblockalignment; maxuniformblock = gl.maxuniformblock; vendorstring = gl.vendorstring; if (first) { first=false; gl_PrintStartupLog(); } glDepthFunc(GL_LESS); glEnable(GL_DITHER); glDisable(GL_CULL_FACE); glDisable(GL_POLYGON_OFFSET_FILL); glEnable(GL_POLYGON_OFFSET_LINE); glEnable(GL_BLEND); glEnable(GL_DEPTH_CLAMP); glDisable(GL_DEPTH_TEST); glDisable(GL_LINE_SMOOTH); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); glClearColor(0.0f, 0.0f, 0.0f, 0.0f); glClearDepth(1.0f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); SetViewportRects(nullptr); mVertexData = new FFlatVertexBuffer(GetWidth(), GetHeight(), screen->mPipelineNbr); mSkyData = new FSkyVertexBuffer; mViewpoints = new HWViewpointBuffer(screen->mPipelineNbr); mLights = new FLightBuffer(screen->mPipelineNbr); GLRenderer = new FGLRenderer(this); GLRenderer->Initialize(GetWidth(), GetHeight()); static_cast(mLights->GetBuffer())->BindBase(); mDebug = std::make_unique(); mDebug->Update(); } //========================================================================== // // Updates the screen // //========================================================================== void OpenGLFrameBuffer::Update() { twoD.Reset(); Flush3D.Reset(); Flush3D.Clock(); GLRenderer->Flush(); Flush3D.Unclock(); Swap(); Super::Update(); } void OpenGLFrameBuffer::CopyScreenToBuffer(int width, int height, uint8_t* scr) { IntRect bounds; bounds.left = 0; bounds.top = 0; bounds.width = width; bounds.height = height; GLRenderer->CopyToBackbuffer(&bounds, false); // strictly speaking not needed as the glReadPixels should block until the scene is rendered, but this is to safeguard against shitty drivers glFinish(); glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, scr); } //=========================================================================== // // Camera texture rendering // //=========================================================================== void OpenGLFrameBuffer::RenderTextureView(FCanvasTexture* tex, std::function renderFunc) { GLRenderer->StartOffscreen(); GLRenderer->BindToFrameBuffer(tex); IntRect bounds; bounds.left = bounds.top = 0; bounds.width = FHardwareTexture::GetTexDimension(tex->GetWidth()); bounds.height = FHardwareTexture::GetTexDimension(tex->GetHeight()); renderFunc(bounds); GLRenderer->EndOffscreen(); tex->SetUpdated(true); static_cast(screen)->camtexcount++; } //=========================================================================== // // // //=========================================================================== const char* OpenGLFrameBuffer::DeviceName() const { return gl.modelstring; } //========================================================================== // // Swap the buffers // //========================================================================== CVAR(Bool, gl_finishbeforeswap, false, CVAR_ARCHIVE|CVAR_GLOBALCONFIG); void OpenGLFrameBuffer::Swap() { bool swapbefore = gl_finishbeforeswap && camtexcount == 0; Finish.Reset(); Finish.Clock(); if (gl_pipeline_depth < 1) { if (swapbefore) glFinish(); FPSLimit(); SwapBuffers(); if (!swapbefore) glFinish(); } else { mVertexData->DropSync(); FPSLimit(); SwapBuffers(); mVertexData->NextPipelineBuffer(); mVertexData->WaitSync(); RenderState()->SetVertexBuffer(screen->mVertexData); // Needed for Raze because it does not reset it } Finish.Unclock(); camtexcount = 0; FHardwareTexture::UnbindAll(); gl_RenderState.ClearLastMaterial(); mDebug->Update(); } //========================================================================== // // Enable/disable vertical sync // //========================================================================== void OpenGLFrameBuffer::SetVSync(bool vsync) { // Switch to the default frame buffer because some drivers associate the vsync state with the bound FB object. GLint oldDrawFramebufferBinding = 0, oldReadFramebufferBinding = 0; glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &oldDrawFramebufferBinding); glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &oldReadFramebufferBinding); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); glBindFramebuffer(GL_READ_FRAMEBUFFER, 0); Super::SetVSync(vsync); glBindFramebuffer(GL_DRAW_FRAMEBUFFER, oldDrawFramebufferBinding); glBindFramebuffer(GL_READ_FRAMEBUFFER, oldReadFramebufferBinding); } //=========================================================================== // // //=========================================================================== void OpenGLFrameBuffer::SetTextureFilterMode() { if (GLRenderer != nullptr && GLRenderer->mSamplerManager != nullptr) GLRenderer->mSamplerManager->SetTextureFilterMode(); } IHardwareTexture *OpenGLFrameBuffer::CreateHardwareTexture(int numchannels) { return new FHardwareTexture(numchannels); } void OpenGLFrameBuffer::PrecacheMaterial(FMaterial *mat, int translation) { if (mat->Source()->GetUseType() == ETextureType::SWCanvas) return; int numLayers = mat->NumLayers(); MaterialLayerInfo* layer; auto base = static_cast(mat->GetLayer(0, translation, &layer)); if (base->BindOrCreate(layer->layerTexture, 0, CLAMP_NONE, translation, layer->scaleFlags)) { for (int i = 1; i < numLayers; i++) { auto systex = static_cast(mat->GetLayer(i, 0, &layer)); systex->BindOrCreate(layer->layerTexture, i, CLAMP_NONE, 0, layer->scaleFlags); } } // unbind everything. FHardwareTexture::UnbindAll(); gl_RenderState.ClearLastMaterial(); } IVertexBuffer *OpenGLFrameBuffer::CreateVertexBuffer() { return new GLVertexBuffer; } IIndexBuffer *OpenGLFrameBuffer::CreateIndexBuffer() { return new GLIndexBuffer; } IDataBuffer *OpenGLFrameBuffer::CreateDataBuffer(int bindingpoint, bool ssbo, bool needsresize) { return new GLDataBuffer(bindingpoint, ssbo); } void OpenGLFrameBuffer::BlurScene(float amount) { GLRenderer->BlurScene(amount); } void OpenGLFrameBuffer::InitLightmap(int LMTextureSize, int LMTextureCount, TArray& LMTextureData) { if (LMTextureData.Size() > 0) { GLint activeTex = 0; glGetIntegerv(GL_ACTIVE_TEXTURE, &activeTex); glActiveTexture(GL_TEXTURE0 + 17); if (GLRenderer->mLightMapID == 0) glGenTextures(1, (GLuint*)&GLRenderer->mLightMapID); glBindTexture(GL_TEXTURE_2D_ARRAY, GLRenderer->mLightMapID); glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGB16F, LMTextureSize, LMTextureSize, LMTextureCount, 0, GL_RGB, GL_HALF_FLOAT, &LMTextureData[0]); glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glGenerateMipmap(GL_TEXTURE_2D_ARRAY); glActiveTexture(activeTex); LMTextureData.Reset(); // We no longer need this, release the memory } } void OpenGLFrameBuffer::SetViewportRects(IntRect *bounds) { Super::SetViewportRects(bounds); if (!bounds) { auto vrmode = VRMode::GetVRMode(true); vrmode->AdjustViewport(this); } } void OpenGLFrameBuffer::UpdatePalette() { if (GLRenderer) GLRenderer->ClearTonemapPalette(); } FRenderState* OpenGLFrameBuffer::RenderState() { return &gl_RenderState; } void OpenGLFrameBuffer::AmbientOccludeScene(float m5) { gl_RenderState.EnableDrawBuffers(1); GLRenderer->AmbientOccludeScene(m5); glViewport(screen->mSceneViewport.left, mSceneViewport.top, mSceneViewport.width, mSceneViewport.height); GLRenderer->mBuffers->BindSceneFB(true); gl_RenderState.EnableDrawBuffers(gl_RenderState.GetPassDrawBufferCount()); gl_RenderState.Apply(); } void OpenGLFrameBuffer::FirstEye() { GLRenderer->mBuffers->CurrentEye() = 0; // always begin at zero, in case eye count changed } void OpenGLFrameBuffer::NextEye(int eyecount) { GLRenderer->mBuffers->NextEye(eyecount); } void OpenGLFrameBuffer::SetSceneRenderTarget(bool useSSAO) { GLRenderer->mBuffers->BindSceneFB(useSSAO); } void OpenGLFrameBuffer::UpdateShadowMap() { if (mShadowMap.PerformUpdate()) { FGLDebug::PushGroup("ShadowMap"); FGLPostProcessState savedState; static_cast(screen->mShadowMap.mLightList)->BindBase(); static_cast(screen->mShadowMap.mNodesBuffer)->BindBase(); static_cast(screen->mShadowMap.mLinesBuffer)->BindBase(); GLRenderer->mBuffers->BindShadowMapFB(); GLRenderer->mShadowMapShader->Bind(); GLRenderer->mShadowMapShader->Uniforms->ShadowmapQuality = gl_shadowmap_quality; GLRenderer->mShadowMapShader->Uniforms->NodesCount = screen->mShadowMap.NodesCount(); GLRenderer->mShadowMapShader->Uniforms.SetData(); static_cast(GLRenderer->mShadowMapShader->Uniforms.GetBuffer())->BindBase(); glViewport(0, 0, gl_shadowmap_quality, 1024); GLRenderer->RenderScreenQuad(); const auto& viewport = screen->mScreenViewport; glViewport(viewport.left, viewport.top, viewport.width, viewport.height); GLRenderer->mBuffers->BindShadowMapTexture(16); FGLDebug::PopGroup(); screen->mShadowMap.FinishUpdate(); } } void OpenGLFrameBuffer::WaitForCommands(bool finish) { glFinish(); } void OpenGLFrameBuffer::SetSaveBuffers(bool yes) { if (!GLRenderer) return; if (yes) GLRenderer->mBuffers = GLRenderer->mSaveBuffers; else GLRenderer->mBuffers = GLRenderer->mScreenBuffers; } //=========================================================================== // // // //=========================================================================== void OpenGLFrameBuffer::BeginFrame() { SetViewportRects(nullptr); if (GLRenderer != nullptr) GLRenderer->BeginFrame(); } //=========================================================================== // // Takes a screenshot // //=========================================================================== TArray OpenGLFrameBuffer::GetScreenshotBuffer(int &pitch, ESSType &color_type, float &gamma) { const auto &viewport = mOutputLetterbox; // Grab what is in the back buffer. // We cannot rely on SCREENWIDTH/HEIGHT here because the output may have been scaled. TArray pixels; pixels.Resize(viewport.width * viewport.height * 3); glPixelStorei(GL_PACK_ALIGNMENT, 1); glReadPixels(viewport.left, viewport.top, viewport.width, viewport.height, GL_RGB, GL_UNSIGNED_BYTE, &pixels[0]); glPixelStorei(GL_PACK_ALIGNMENT, 4); // Copy to screenshot buffer: int w = SCREENWIDTH; int h = SCREENHEIGHT; TArray ScreenshotBuffer(w * h * 3, true); float rcpWidth = 1.0f / w; float rcpHeight = 1.0f / h; for (int y = 0; y < h; y++) { for (int x = 0; x < w; x++) { float u = (x + 0.5f) * rcpWidth; float v = (y + 0.5f) * rcpHeight; int sx = u * viewport.width; int sy = v * viewport.height; int sindex = (sx + sy * viewport.width) * 3; int dindex = (x + (h - y - 1) * w) * 3; ScreenshotBuffer[dindex] = pixels[sindex]; ScreenshotBuffer[dindex + 1] = pixels[sindex + 1]; ScreenshotBuffer[dindex + 2] = pixels[sindex + 2]; } } pitch = w * 3; color_type = SS_RGB; // Screenshot should not use gamma correction if it was already applied to rendered image gamma = 1; if (vid_hdr_active && vid_fullscreen) gamma *= 2.2f; return ScreenshotBuffer; } //=========================================================================== // // 2D drawing // //=========================================================================== void OpenGLFrameBuffer::Draw2D() { if (GLRenderer != nullptr) { GLRenderer->mBuffers->BindCurrentFB(); ::Draw2D(twod, gl_RenderState); } } void OpenGLFrameBuffer::PostProcessScene(bool swscene, int fixedcm, float flash, const std::function &afterBloomDrawEndScene2D) { if (!swscene) GLRenderer->mBuffers->BlitSceneToTexture(); // Copy the resulting scene to the current post process texture GLRenderer->PostProcessScene(fixedcm, flash, afterBloomDrawEndScene2D); } bool OpenGLFrameBuffer::CompileNextShader() { return GLRenderer->mShaderManager->CompileNextShader(); } //========================================================================== // // OpenGLFrameBuffer :: WipeStartScreen // // Called before the current screen has started rendering. This needs to // save what was drawn the previous frame so that it can be animated into // what gets drawn this frame. // //========================================================================== FTexture *OpenGLFrameBuffer::WipeStartScreen() { const auto &viewport = screen->mScreenViewport; auto tex = new FWrapperTexture(viewport.width, viewport.height, 1); tex->GetSystemTexture()->CreateTexture(nullptr, viewport.width, viewport.height, 0, false, "WipeStartScreen"); glFinish(); static_cast(tex->GetSystemTexture())->Bind(0, false); GLRenderer->mBuffers->BindCurrentFB(); glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, viewport.left, viewport.top, viewport.width, viewport.height); return tex; } //========================================================================== // // OpenGLFrameBuffer :: WipeEndScreen // // The screen we want to animate to has just been drawn. // //========================================================================== FTexture *OpenGLFrameBuffer::WipeEndScreen() { GLRenderer->Flush(); const auto &viewport = screen->mScreenViewport; auto tex = new FWrapperTexture(viewport.width, viewport.height, 1); tex->GetSystemTexture()->CreateTexture(NULL, viewport.width, viewport.height, 0, false, "WipeEndScreen"); glFinish(); static_cast(tex->GetSystemTexture())->Bind(0, false); GLRenderer->mBuffers->BindCurrentFB(); glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, viewport.left, viewport.top, viewport.width, viewport.height); return tex; } }