2021-09-18 10:20:28 +00:00
|
|
|
/*
|
|
|
|
** 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 "gles_system.h"
|
|
|
|
#include "v_video.h"
|
|
|
|
#include "m_png.h"
|
2021-10-30 08:51:03 +00:00
|
|
|
|
2021-09-18 10:20:28 +00:00
|
|
|
#include "i_time.h"
|
|
|
|
|
|
|
|
#include "gles_framebuffer.h"
|
|
|
|
#include "gles_renderer.h"
|
|
|
|
#include "gles_samplers.h"
|
|
|
|
#include "gles_renderbuffers.h"
|
|
|
|
#include "hw_clock.h"
|
|
|
|
#include "hw_vrmodes.h"
|
|
|
|
#include "hw_skydome.h"
|
|
|
|
#include "hw_viewpointbuffer.h"
|
|
|
|
#include "hw_lightbuffer.h"
|
|
|
|
#include "gles_shaderprogram.h"
|
|
|
|
#include "r_videoscale.h"
|
|
|
|
#include "gles_buffers.h"
|
|
|
|
#include "gles_postprocessstate.h"
|
|
|
|
#include "v_draw.h"
|
|
|
|
#include "printf.h"
|
|
|
|
#include "gles_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);
|
|
|
|
|
|
|
|
EXTERN_CVAR(Bool, gl_sort_textures);
|
|
|
|
|
|
|
|
void Draw2D(F2DDrawer *drawer, FRenderState &state);
|
|
|
|
|
|
|
|
extern bool vid_hdr_active;
|
|
|
|
|
|
|
|
namespace OpenGLESRenderer
|
|
|
|
{
|
|
|
|
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;
|
|
|
|
|
2021-10-30 08:21:43 +00:00
|
|
|
mPipelineNbr = gl_pipeline_depth == 0? min(4, HW_MAX_PIPELINE_BUFFERS) : clamp(*gl_pipeline_depth, 1, HW_MAX_PIPELINE_BUFFERS);
|
2021-09-18 10:20:28 +00:00
|
|
|
mPipelineType = 1;
|
|
|
|
|
|
|
|
InitGLES();
|
|
|
|
|
|
|
|
// Move some state to the framebuffer object for easier access.
|
|
|
|
hwcaps = gles.flags;
|
|
|
|
vendorstring = gles.vendorstring;
|
|
|
|
|
|
|
|
glDepthFunc(GL_LESS);
|
|
|
|
|
|
|
|
glEnable(GL_DITHER);
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
glDisable(GL_POLYGON_OFFSET_FILL);
|
|
|
|
|
|
|
|
glEnable(GL_BLEND);
|
2021-12-07 23:19:49 +00:00
|
|
|
if (gles.depthClampAvailable) glEnable(GL_DEPTH_CLAMP);
|
2021-09-18 10:20:28 +00:00
|
|
|
|
|
|
|
glDisable(GL_DEPTH_TEST);
|
|
|
|
|
|
|
|
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
|
|
|
|
|
|
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
|
|
|
|
|
|
|
|
glClearDepthf(1.0f);
|
|
|
|
|
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
|
|
|
|
SetViewportRects(nullptr);
|
|
|
|
|
|
|
|
mVertexData = new FFlatVertexBuffer(GetWidth(), GetHeight(), mPipelineNbr);
|
|
|
|
mSkyData = new FSkyVertexBuffer;
|
|
|
|
mViewpoints = new HWViewpointBuffer(mPipelineNbr);
|
|
|
|
mLights = new FLightBuffer(mPipelineNbr);
|
|
|
|
GLRenderer = new FGLRenderer(this);
|
|
|
|
GLRenderer->Initialize(GetWidth(), GetHeight());
|
|
|
|
static_cast<GLDataBuffer*>(mLights->GetBuffer())->BindBase();
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// 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<void(IntRect &)> 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<OpenGLFrameBuffer*>(screen)->camtexcount++;
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//===========================================================================
|
|
|
|
|
|
|
|
const char* OpenGLFrameBuffer::DeviceName() const
|
|
|
|
{
|
|
|
|
return gles.modelstring;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// Swap the buffers
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
|
|
|
|
void OpenGLFrameBuffer::Swap()
|
|
|
|
{
|
|
|
|
|
|
|
|
Finish.Reset();
|
|
|
|
Finish.Clock();
|
|
|
|
|
2021-09-22 08:20:39 +00:00
|
|
|
mVertexData->DropSync();
|
2021-09-18 10:20:28 +00:00
|
|
|
|
|
|
|
FPSLimit();
|
|
|
|
SwapBuffers();
|
|
|
|
|
|
|
|
mVertexData->NextPipelineBuffer();
|
2021-09-22 08:20:39 +00:00
|
|
|
mVertexData->WaitSync();
|
2021-09-18 10:20:28 +00:00
|
|
|
|
|
|
|
RenderState()->SetVertexBuffer(screen->mVertexData); // Needed for Raze because it does not reset it
|
|
|
|
|
|
|
|
Finish.Unclock();
|
|
|
|
camtexcount = 0;
|
|
|
|
FHardwareTexture::UnbindAll();
|
|
|
|
gl_RenderState.ClearLastMaterial();
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// Enable/disable vertical sync
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void OpenGLFrameBuffer::SetVSync(bool vsync)
|
|
|
|
{
|
|
|
|
Super::SetVSync(vsync);
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//===========================================================================
|
|
|
|
|
|
|
|
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<FHardwareTexture*>(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<FHardwareTexture*>(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::SetViewportRects(IntRect *bounds)
|
|
|
|
{
|
|
|
|
Super::SetViewportRects(bounds);
|
|
|
|
if (!bounds)
|
|
|
|
{
|
|
|
|
auto vrmode = VRMode::GetVRMode(true);
|
|
|
|
vrmode->AdjustViewport(this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
FRenderState* OpenGLFrameBuffer::RenderState()
|
|
|
|
{
|
|
|
|
return &gl_RenderState;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
#ifndef NO_RENDER_BUFFER
|
|
|
|
GLRenderer->mBuffers->BindSceneFB(useSSAO);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void OpenGLFrameBuffer::WaitForCommands(bool finish)
|
|
|
|
{
|
|
|
|
glFinish();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//===========================================================================
|
|
|
|
|
|
|
|
void OpenGLFrameBuffer::BeginFrame()
|
|
|
|
{
|
|
|
|
SetViewportRects(nullptr);
|
|
|
|
if (GLRenderer != nullptr)
|
|
|
|
GLRenderer->BeginFrame();
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
//
|
|
|
|
// Takes a screenshot
|
|
|
|
//
|
|
|
|
//===========================================================================
|
|
|
|
|
|
|
|
TArray<uint8_t> 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<uint8_t> 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<uint8_t> 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<void()> &afterBloomDrawEndScene2D)
|
|
|
|
{
|
|
|
|
//if (!swscene) GLRenderer->mBuffers->BlitSceneToTexture(); // Copy the resulting scene to the current post process texture
|
|
|
|
GLRenderer->PostProcessScene(fixedcm, flash, afterBloomDrawEndScene2D);
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// 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<FHardwareTexture*>(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<FHardwareTexture*>(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;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|