mirror of
https://github.com/ZDoom/qzdoom.git
synced 2024-11-24 13:01:47 +00:00
- Reduce the number of naked new/delete calls in OpenGLSWFrameBuffer
This commit is contained in:
Magnus Norddahl
parent
67d313cf25
commit
3f991429d1
3 changed files with 116 additions and 120 deletions
|
|
@ -272,7 +272,7 @@ void *OpenGLSWFrameBuffer::MapBuffer(int target, int size)
|
|||
OpenGLSWFrameBuffer::HWFrameBuffer::~HWFrameBuffer()
|
||||
{
|
||||
if (Framebuffer != 0) glDeleteFramebuffers(1, (GLuint*)&Framebuffer);
|
||||
delete Texture;
|
||||
Texture.reset();
|
||||
}
|
||||
|
||||
OpenGLSWFrameBuffer::HWTexture::~HWTexture()
|
||||
|
|
@ -324,17 +324,17 @@ OpenGLSWFrameBuffer::HWPixelShader::~HWPixelShader()
|
|||
if (FragmentShader != 0) glDeleteShader(FragmentShader);
|
||||
}
|
||||
|
||||
bool OpenGLSWFrameBuffer::CreateFrameBuffer(const FString &name, int width, int height, HWFrameBuffer **outFramebuffer)
|
||||
std::unique_ptr<OpenGLSWFrameBuffer::HWFrameBuffer> OpenGLSWFrameBuffer::CreateFrameBuffer(const FString &name, int width, int height)
|
||||
{
|
||||
std::unique_ptr<HWFrameBuffer> fb(new HWFrameBuffer());
|
||||
|
||||
GLint format = GL_RGBA16F;
|
||||
if (gl.es) format = GL_RGB;
|
||||
|
||||
if (!CreateTexture(name, width, height, 1, format, &fb->Texture))
|
||||
fb->Texture = CreateTexture(name, width, height, 1, format);
|
||||
if (!fb->Texture)
|
||||
{
|
||||
outFramebuffer = nullptr;
|
||||
return false;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
glGenFramebuffers(1, (GLuint*)&fb->Framebuffer);
|
||||
|
|
@ -357,24 +357,22 @@ bool OpenGLSWFrameBuffer::CreateFrameBuffer(const FString &name, int width, int
|
|||
if (result != GL_FRAMEBUFFER_COMPLETE)
|
||||
{
|
||||
Printf("Framebuffer is not complete\n");
|
||||
outFramebuffer = nullptr;
|
||||
return false;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
*outFramebuffer = fb.release();
|
||||
return true;
|
||||
return std::move(fb);
|
||||
}
|
||||
|
||||
bool OpenGLSWFrameBuffer::CreatePixelShader(FString vertexsrc, FString fragmentsrc, const FString &defines, HWPixelShader **outShader)
|
||||
std::unique_ptr<OpenGLSWFrameBuffer::HWPixelShader> OpenGLSWFrameBuffer::CreatePixelShader(FString vertexsrc, FString fragmentsrc, const FString &defines)
|
||||
{
|
||||
std::unique_ptr<HWPixelShader> shader(new HWPixelShader());
|
||||
|
||||
shader->Program = glCreateProgram();
|
||||
if (shader->Program == 0) { Printf("glCreateProgram failed. Disabling OpenGL hardware acceleration.\n"); return false; }
|
||||
if (shader->Program == 0) { Printf("glCreateProgram failed. Disabling OpenGL hardware acceleration.\n"); return nullptr; }
|
||||
shader->VertexShader = glCreateShader(GL_VERTEX_SHADER);
|
||||
if (shader->VertexShader == 0) { Printf("glCreateShader(GL_VERTEX_SHADER) failed. Disabling OpenGL hardware acceleration.\n"); return false; }
|
||||
if (shader->VertexShader == 0) { Printf("glCreateShader(GL_VERTEX_SHADER) failed. Disabling OpenGL hardware acceleration.\n"); return nullptr; }
|
||||
shader->FragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
|
||||
if (shader->FragmentShader == 0) { Printf("glCreateShader(GL_FRAGMENT_SHADER) failed. Disabling OpenGL hardware acceleration.\n"); return false; }
|
||||
if (shader->FragmentShader == 0) { Printf("glCreateShader(GL_FRAGMENT_SHADER) failed. Disabling OpenGL hardware acceleration.\n"); return nullptr; }
|
||||
|
||||
int maxGlslVersion = 330;
|
||||
int shaderVersion = MIN((int)round(gl.glslversion * 10) * 10, maxGlslVersion);
|
||||
|
|
@ -412,8 +410,7 @@ bool OpenGLSWFrameBuffer::CreatePixelShader(FString vertexsrc, FString fragments
|
|||
glGetShaderInfoLog(errorShader, 10000, &length, buffer);
|
||||
//Printf("Shader compile failed: %s", buffer);
|
||||
|
||||
*outShader = nullptr;
|
||||
return false;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
glAttachShader(shader->Program, shader->VertexShader);
|
||||
|
|
@ -433,8 +430,7 @@ bool OpenGLSWFrameBuffer::CreatePixelShader(FString vertexsrc, FString fragments
|
|||
glGetProgramInfoLog(shader->Program, 10000, &length, buffer);
|
||||
//Printf("Shader link failed: %s", buffer);
|
||||
|
||||
*outShader = nullptr;
|
||||
return false;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
shader->ConstantLocations[PSCONST_Desaturation] = glGetUniformLocation(shader->Program, "Desaturation");
|
||||
|
|
@ -447,11 +443,10 @@ bool OpenGLSWFrameBuffer::CreatePixelShader(FString vertexsrc, FString fragments
|
|||
shader->NewScreenLocation = glGetUniformLocation(shader->Program, "NewScreen");
|
||||
shader->BurnLocation = glGetUniformLocation(shader->Program, "Burn");
|
||||
|
||||
*outShader = shader.release();
|
||||
return true;
|
||||
return std::move(shader);
|
||||
}
|
||||
|
||||
bool OpenGLSWFrameBuffer::CreateVertexBuffer(int size, HWVertexBuffer **outVertexBuffer)
|
||||
std::unique_ptr<OpenGLSWFrameBuffer::HWVertexBuffer> OpenGLSWFrameBuffer::CreateVertexBuffer(int size)
|
||||
{
|
||||
std::unique_ptr<HWVertexBuffer> obj(new HWVertexBuffer());
|
||||
|
||||
|
|
@ -478,11 +473,10 @@ bool OpenGLSWFrameBuffer::CreateVertexBuffer(int size, HWVertexBuffer **outVerte
|
|||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
glBindVertexArray(oldBinding);
|
||||
|
||||
*outVertexBuffer = obj.release();
|
||||
return true;
|
||||
return std::move(obj);
|
||||
}
|
||||
|
||||
bool OpenGLSWFrameBuffer::CreateIndexBuffer(int size, HWIndexBuffer **outIndexBuffer)
|
||||
std::unique_ptr<OpenGLSWFrameBuffer::HWIndexBuffer> OpenGLSWFrameBuffer::CreateIndexBuffer(int size)
|
||||
{
|
||||
std::unique_ptr<HWIndexBuffer> obj(new HWIndexBuffer());
|
||||
|
||||
|
|
@ -498,11 +492,10 @@ bool OpenGLSWFrameBuffer::CreateIndexBuffer(int size, HWIndexBuffer **outIndexBu
|
|||
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, oldBinding);
|
||||
|
||||
*outIndexBuffer = obj.release();
|
||||
return true;
|
||||
return std::move(obj);
|
||||
}
|
||||
|
||||
bool OpenGLSWFrameBuffer::CreateTexture(const FString &name, int width, int height, int levels, int format, HWTexture **outTexture)
|
||||
std::unique_ptr<OpenGLSWFrameBuffer::HWTexture> OpenGLSWFrameBuffer::CreateTexture(const FString &name, int width, int height, int levels, int format)
|
||||
{
|
||||
std::unique_ptr<HWTexture> obj(new HWTexture());
|
||||
|
||||
|
|
@ -536,11 +529,10 @@ bool OpenGLSWFrameBuffer::CreateTexture(const FString &name, int width, int heig
|
|||
|
||||
glBindTexture(GL_TEXTURE_2D, oldBinding);
|
||||
|
||||
*outTexture = obj.release();
|
||||
return true;
|
||||
return std::move(obj);
|
||||
}
|
||||
|
||||
OpenGLSWFrameBuffer::HWTexture *OpenGLSWFrameBuffer::CopyCurrentScreen()
|
||||
std::unique_ptr<OpenGLSWFrameBuffer::HWTexture> OpenGLSWFrameBuffer::CopyCurrentScreen()
|
||||
{
|
||||
std::unique_ptr<HWTexture> obj(new HWTexture());
|
||||
obj->Format = GL_RGBA16F;
|
||||
|
|
@ -559,7 +551,7 @@ OpenGLSWFrameBuffer::HWTexture *OpenGLSWFrameBuffer::CopyCurrentScreen()
|
|||
|
||||
glBindTexture(GL_TEXTURE_2D, oldBinding);
|
||||
|
||||
return obj.release();
|
||||
return std::move(obj);
|
||||
}
|
||||
|
||||
void OpenGLSWFrameBuffer::SetGammaRamp(const GammaRamp *ramp)
|
||||
|
|
@ -747,8 +739,8 @@ void OpenGLSWFrameBuffer::Present()
|
|||
|
||||
FBVERTEX verts[4];
|
||||
CalcFullscreenCoords(verts, false, 0, 0xFFFFFFFF);
|
||||
SetTexture(0, OutputFB->Texture);
|
||||
SetPixelShader(Shaders[SHADER_GammaCorrection]);
|
||||
SetTexture(0, OutputFB->Texture.get());
|
||||
SetPixelShader(Shaders[SHADER_GammaCorrection].get());
|
||||
SetAlphaBlend(0);
|
||||
EnableAlphaTest(false);
|
||||
DrawTriangleFans(2, verts);
|
||||
|
|
@ -823,7 +815,8 @@ bool OpenGLSWFrameBuffer::CreateResources()
|
|||
if (!LoadShaders())
|
||||
return false;
|
||||
|
||||
if (!CreateFrameBuffer("OutputFB", Width, Height, &OutputFB))
|
||||
OutputFB = CreateFrameBuffer("OutputFB", Width, Height);
|
||||
if (!OutputFB)
|
||||
return false;
|
||||
|
||||
glBindFramebuffer(GL_FRAMEBUFFER, OutputFB->Framebuffer);
|
||||
|
|
@ -865,7 +858,8 @@ bool OpenGLSWFrameBuffer::LoadShaders()
|
|||
for (i = 0; i < NUM_SHADERS; ++i)
|
||||
{
|
||||
shaderpath = shaderdir;
|
||||
if (!CreatePixelShader(vertsource, fragsource, ShaderDefines[i], &Shaders[i]) && i < SHADER_BurnWipe)
|
||||
Shaders[i] = CreatePixelShader(vertsource, fragsource, ShaderDefines[i]);
|
||||
if (!Shaders[i] && i < SHADER_BurnWipe)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
|
@ -884,7 +878,7 @@ bool OpenGLSWFrameBuffer::LoadShaders()
|
|||
// Failure. Release whatever managed to load (which is probably nothing.)
|
||||
for (i = 0; i < NUM_SHADERS; ++i)
|
||||
{
|
||||
SafeRelease(Shaders[i]);
|
||||
Shaders[i].reset();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
|
@ -903,11 +897,11 @@ void OpenGLSWFrameBuffer::ReleaseResources()
|
|||
KillNativeTexs();
|
||||
KillNativePals();
|
||||
ReleaseDefaultPoolItems();
|
||||
SafeRelease(ScreenshotTexture);
|
||||
SafeRelease(PaletteTexture);
|
||||
ScreenshotTexture.reset();
|
||||
PaletteTexture.reset();
|
||||
for (int i = 0; i < NUM_SHADERS; ++i)
|
||||
{
|
||||
SafeRelease(Shaders[i]);
|
||||
Shaders[i].reset();
|
||||
}
|
||||
if (ScreenWipe != nullptr)
|
||||
{
|
||||
|
|
@ -925,19 +919,20 @@ void OpenGLSWFrameBuffer::ReleaseResources()
|
|||
|
||||
void OpenGLSWFrameBuffer::ReleaseDefaultPoolItems()
|
||||
{
|
||||
SafeRelease(FBTexture);
|
||||
SafeRelease(FinalWipeScreen);
|
||||
SafeRelease(InitialWipeScreen);
|
||||
SafeRelease(VertexBuffer);
|
||||
SafeRelease(IndexBuffer);
|
||||
SafeRelease(OutputFB);
|
||||
FBTexture.reset();
|
||||
FinalWipeScreen.reset();
|
||||
InitialWipeScreen.reset();
|
||||
VertexBuffer.reset();
|
||||
IndexBuffer.reset();
|
||||
OutputFB.reset();
|
||||
}
|
||||
|
||||
bool OpenGLSWFrameBuffer::Reset()
|
||||
{
|
||||
ReleaseDefaultPoolItems();
|
||||
|
||||
if (!CreateFrameBuffer("OutputFB", Width, Height, &OutputFB) || !CreateFBTexture() || !CreateVertexes())
|
||||
OutputFB = CreateFrameBuffer("OutputFB", Width, Height);
|
||||
if (!OutputFB || !CreateFBTexture() || !CreateVertexes())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
|
@ -983,7 +978,8 @@ void OpenGLSWFrameBuffer::KillNativeTexs()
|
|||
|
||||
bool OpenGLSWFrameBuffer::CreateFBTexture()
|
||||
{
|
||||
return CreateTexture("FBTexture", Width, Height, 1, IsBgra() ? GL_RGBA8 : GL_R8, &FBTexture);
|
||||
FBTexture = CreateTexture("FBTexture", Width, Height, 1, IsBgra() ? GL_RGBA8 : GL_R8);
|
||||
return FBTexture != nullptr;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
|
@ -994,7 +990,8 @@ bool OpenGLSWFrameBuffer::CreateFBTexture()
|
|||
|
||||
bool OpenGLSWFrameBuffer::CreatePaletteTexture()
|
||||
{
|
||||
return CreateTexture("PaletteTexture", 256, 1, 1, GL_RGBA8, &PaletteTexture);
|
||||
PaletteTexture = CreateTexture("PaletteTexture", 256, 1, 1, GL_RGBA8);
|
||||
return PaletteTexture != nullptr;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
|
@ -1009,11 +1006,13 @@ bool OpenGLSWFrameBuffer::CreateVertexes()
|
|||
IndexPos = -1;
|
||||
QuadBatchPos = -1;
|
||||
BatchType = BATCH_None;
|
||||
if (!CreateVertexBuffer(sizeof(FBVERTEX)*NUM_VERTS, &VertexBuffer))
|
||||
VertexBuffer = CreateVertexBuffer(sizeof(FBVERTEX)*NUM_VERTS);
|
||||
if (!VertexBuffer)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (!CreateIndexBuffer(sizeof(uint16_t)*NUM_INDEXES, &IndexBuffer))
|
||||
IndexBuffer = CreateIndexBuffer(sizeof(uint16_t)*NUM_INDEXES);
|
||||
if (!IndexBuffer)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1421,15 +1420,15 @@ void OpenGLSWFrameBuffer::Draw3DPart(bool copy3d)
|
|||
else
|
||||
glDisable(GL_LINE_SMOOTH);
|
||||
|
||||
SetTexture(0, FBTexture);
|
||||
SetPaletteTexture(PaletteTexture, 256, BorderColor);
|
||||
SetTexture(0, FBTexture.get());
|
||||
SetPaletteTexture(PaletteTexture.get(), 256, BorderColor);
|
||||
memset(Constant, 0, sizeof(Constant));
|
||||
SetAlphaBlend(0);
|
||||
EnableAlphaTest(false);
|
||||
if (IsBgra())
|
||||
SetPixelShader(Shaders[SHADER_NormalColor]);
|
||||
SetPixelShader(Shaders[SHADER_NormalColor].get());
|
||||
else
|
||||
SetPixelShader(Shaders[SHADER_NormalColorPal]);
|
||||
SetPixelShader(Shaders[SHADER_NormalColorPal].get());
|
||||
if (copy3d)
|
||||
{
|
||||
FBVERTEX verts[4];
|
||||
|
|
@ -1447,9 +1446,9 @@ void OpenGLSWFrameBuffer::Draw3DPart(bool copy3d)
|
|||
color0 = ColorValue(map->ColorizeStart[0] / 2, map->ColorizeStart[1] / 2, map->ColorizeStart[2] / 2, 0);
|
||||
color1 = ColorValue(map->ColorizeEnd[0] / 2, map->ColorizeEnd[1] / 2, map->ColorizeEnd[2] / 2, 1);
|
||||
if (IsBgra())
|
||||
SetPixelShader(Shaders[SHADER_SpecialColormap]);
|
||||
SetPixelShader(Shaders[SHADER_SpecialColormap].get());
|
||||
else
|
||||
SetPixelShader(Shaders[SHADER_SpecialColormapPal]);
|
||||
SetPixelShader(Shaders[SHADER_SpecialColormapPal].get());
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -1461,9 +1460,9 @@ void OpenGLSWFrameBuffer::Draw3DPart(bool copy3d)
|
|||
DrawTriangleFans(2, verts);
|
||||
}
|
||||
if (IsBgra())
|
||||
SetPixelShader(Shaders[SHADER_NormalColor]);
|
||||
SetPixelShader(Shaders[SHADER_NormalColor].get());
|
||||
else
|
||||
SetPixelShader(Shaders[SHADER_NormalColorPal]);
|
||||
SetPixelShader(Shaders[SHADER_NormalColorPal].get());
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
|
@ -1696,7 +1695,7 @@ void OpenGLSWFrameBuffer::ReleaseScreenshotBuffer()
|
|||
{
|
||||
Super::ReleaseScreenshotBuffer();
|
||||
}
|
||||
SafeRelease(ScreenshotTexture);
|
||||
ScreenshotTexture.reset();
|
||||
}
|
||||
|
||||
/**************************************************************************/
|
||||
|
|
@ -1782,7 +1781,7 @@ void OpenGLSWFrameBuffer::DrawPackedTextures(int packnum)
|
|||
quad->ShaderNum = BQS_Plain;
|
||||
}
|
||||
quad->Palette = nullptr;
|
||||
quad->Texture = pack->Tex;
|
||||
quad->Texture = pack->Tex.get();
|
||||
quad->NumVerts = 4;
|
||||
quad->NumTris = 2;
|
||||
|
||||
|
|
@ -1911,7 +1910,6 @@ OpenGLSWFrameBuffer::PackedTexture *OpenGLSWFrameBuffer::AllocPackedTexture(int
|
|||
OpenGLSWFrameBuffer::Atlas::Atlas(OpenGLSWFrameBuffer *fb, int w, int h, int format)
|
||||
: Packer(w, h, true)
|
||||
{
|
||||
Tex = nullptr;
|
||||
Format = format;
|
||||
UsedList = nullptr;
|
||||
OneUse = false;
|
||||
|
|
@ -1927,7 +1925,7 @@ OpenGLSWFrameBuffer::Atlas::Atlas(OpenGLSWFrameBuffer *fb, int w, int h, int for
|
|||
}
|
||||
*prev = this;
|
||||
|
||||
fb->CreateTexture("Atlas", w, h, 1, format, &Tex);
|
||||
Tex = fb->CreateTexture("Atlas", w, h, 1, format);
|
||||
Width = w;
|
||||
Height = h;
|
||||
}
|
||||
|
|
@ -1942,7 +1940,7 @@ OpenGLSWFrameBuffer::Atlas::~Atlas()
|
|||
{
|
||||
PackedTexture *box, *next;
|
||||
|
||||
SafeRelease(Tex);
|
||||
Tex.reset();
|
||||
for (box = UsedList; box != nullptr; box = next)
|
||||
{
|
||||
next = box->Next;
|
||||
|
|
@ -2293,7 +2291,7 @@ FTextureFormat OpenGLSWFrameBuffer::OpenGLTex::ToTexFmt(int fmt)
|
|||
//==========================================================================
|
||||
|
||||
OpenGLSWFrameBuffer::OpenGLPal::OpenGLPal(FRemapTable *remap, OpenGLSWFrameBuffer *fb)
|
||||
: Tex(nullptr), Remap(remap)
|
||||
: Remap(remap)
|
||||
{
|
||||
int count;
|
||||
|
||||
|
|
@ -2317,12 +2315,12 @@ OpenGLSWFrameBuffer::OpenGLPal::OpenGLPal(FRemapTable *remap, OpenGLSWFrameBuffe
|
|||
|
||||
BorderColor = 0;
|
||||
RoundedPaletteSize = count;
|
||||
if (fb->CreateTexture("Pal", count, 1, 1, GL_RGBA8, &Tex))
|
||||
Tex = fb->CreateTexture("Pal", count, 1, 1, GL_RGBA8);
|
||||
if (Tex)
|
||||
{
|
||||
if (!Update())
|
||||
{
|
||||
delete Tex;
|
||||
Tex = nullptr;
|
||||
Tex.reset();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -2335,7 +2333,7 @@ OpenGLSWFrameBuffer::OpenGLPal::OpenGLPal(FRemapTable *remap, OpenGLSWFrameBuffe
|
|||
|
||||
OpenGLSWFrameBuffer::OpenGLPal::~OpenGLPal()
|
||||
{
|
||||
SafeRelease(Tex);
|
||||
Tex.reset();
|
||||
// Detach from the palette list
|
||||
*Prev = Next;
|
||||
if (Next != nullptr)
|
||||
|
|
@ -2639,9 +2637,9 @@ void OpenGLSWFrameBuffer::EndLineBatch()
|
|||
VertexBuffer->Unlock();
|
||||
if (VertexPos > 0)
|
||||
{
|
||||
SetPixelShader(Shaders[SHADER_VertexColor]);
|
||||
SetPixelShader(Shaders[SHADER_VertexColor].get());
|
||||
SetAlphaBlend(GL_FUNC_ADD, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
SetStreamSource(VertexBuffer);
|
||||
SetStreamSource(VertexBuffer.get());
|
||||
DrawLineList(VertexPos / 2);
|
||||
}
|
||||
VertexPos = -1;
|
||||
|
|
@ -2718,7 +2716,7 @@ void OpenGLSWFrameBuffer::DrawPixel(int x, int y, int palcolor, uint32_t color)
|
|||
float(x), float(y), 0, 1, color
|
||||
};
|
||||
EndBatch(); // Draw out any batched operations.
|
||||
SetPixelShader(Shaders[SHADER_VertexColor]);
|
||||
SetPixelShader(Shaders[SHADER_VertexColor].get());
|
||||
SetAlphaBlend(GL_FUNC_ADD, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
DrawPoints(1, &pt);
|
||||
}
|
||||
|
|
@ -2829,7 +2827,7 @@ void OpenGLSWFrameBuffer::DrawTextureParms(FTexture *img, DrawParms &parms)
|
|||
goto done;
|
||||
}
|
||||
|
||||
quad->Texture = tex->Box->Owner->Tex;
|
||||
quad->Texture = tex->Box->Owner->Tex.get();
|
||||
if (parms.bilinear)
|
||||
{
|
||||
quad->Flags |= BQF_Bilinear;
|
||||
|
|
@ -2956,7 +2954,7 @@ void OpenGLSWFrameBuffer::FlatFill(int left, int top, int right, int bottom, FTe
|
|||
quad->ShaderNum = BQS_Plain;
|
||||
}
|
||||
quad->Palette = nullptr;
|
||||
quad->Texture = tex->Box->Owner->Tex;
|
||||
quad->Texture = tex->Box->Owner->Tex.get();
|
||||
quad->NumVerts = 4;
|
||||
quad->NumTris = 2;
|
||||
|
||||
|
|
@ -3085,7 +3083,7 @@ void OpenGLSWFrameBuffer::FillSimplePoly(FTexture *texture, FVector2 *points, in
|
|||
quad->ShaderNum = BQS_Plain;
|
||||
}
|
||||
quad->Palette = nullptr;
|
||||
quad->Texture = tex->Box->Owner->Tex;
|
||||
quad->Texture = tex->Box->Owner->Tex.get();
|
||||
quad->NumVerts = npoints;
|
||||
quad->NumTris = npoints - 2;
|
||||
|
||||
|
|
@ -3295,8 +3293,8 @@ void OpenGLSWFrameBuffer::EndQuadBatch()
|
|||
IndexPos = -1;
|
||||
return;
|
||||
}
|
||||
SetStreamSource(VertexBuffer);
|
||||
SetIndices(IndexBuffer);
|
||||
SetStreamSource(VertexBuffer.get());
|
||||
SetIndices(IndexBuffer.get());
|
||||
bool uv_wrapped = false;
|
||||
bool uv_should_wrap;
|
||||
int indexpos, vertpos;
|
||||
|
|
@ -3335,12 +3333,12 @@ void OpenGLSWFrameBuffer::EndQuadBatch()
|
|||
// Set the palette (if one)
|
||||
if ((quad->Flags & BQF_Paletted) == BQF_GamePalette)
|
||||
{
|
||||
SetPaletteTexture(PaletteTexture, 256, BorderColor);
|
||||
SetPaletteTexture(PaletteTexture.get(), 256, BorderColor);
|
||||
}
|
||||
else if ((quad->Flags & BQF_Paletted) == BQF_CustomPalette)
|
||||
{
|
||||
assert(quad->Palette != nullptr);
|
||||
SetPaletteTexture(quad->Palette->Tex, quad->Palette->RoundedPaletteSize, quad->Palette->BorderColor);
|
||||
SetPaletteTexture(quad->Palette->Tex.get(), quad->Palette->RoundedPaletteSize, quad->Palette->BorderColor);
|
||||
}
|
||||
|
||||
// Set the alpha blending
|
||||
|
|
@ -3352,29 +3350,26 @@ void OpenGLSWFrameBuffer::EndQuadBatch()
|
|||
// Set the pixel shader
|
||||
if (quad->ShaderNum == BQS_PalTex)
|
||||
{
|
||||
SetPixelShader(Shaders[(quad->Flags & BQF_InvertSource) ?
|
||||
SHADER_NormalColorPalInv : SHADER_NormalColorPal]);
|
||||
SetPixelShader(Shaders[(quad->Flags & BQF_InvertSource) ? SHADER_NormalColorPalInv : SHADER_NormalColorPal].get());
|
||||
}
|
||||
else if (quad->ShaderNum == BQS_Plain)
|
||||
{
|
||||
SetPixelShader(Shaders[(quad->Flags & BQF_InvertSource) ?
|
||||
SHADER_NormalColorInv : SHADER_NormalColor]);
|
||||
SetPixelShader(Shaders[(quad->Flags & BQF_InvertSource) ? SHADER_NormalColorInv : SHADER_NormalColor].get());
|
||||
}
|
||||
else if (quad->ShaderNum == BQS_RedToAlpha)
|
||||
{
|
||||
SetPixelShader(Shaders[(quad->Flags & BQF_InvertSource) ?
|
||||
SHADER_RedToAlphaInv : SHADER_RedToAlpha]);
|
||||
SetPixelShader(Shaders[(quad->Flags & BQF_InvertSource) ? SHADER_RedToAlphaInv : SHADER_RedToAlpha].get());
|
||||
}
|
||||
else if (quad->ShaderNum == BQS_ColorOnly)
|
||||
{
|
||||
SetPixelShader(Shaders[SHADER_VertexColor]);
|
||||
SetPixelShader(Shaders[SHADER_VertexColor].get());
|
||||
}
|
||||
else if (quad->ShaderNum == BQS_SpecialColormap)
|
||||
{
|
||||
int select;
|
||||
|
||||
select = !!(quad->Flags & BQF_Paletted);
|
||||
SetPixelShader(Shaders[SHADER_SpecialColormap + select]);
|
||||
SetPixelShader(Shaders[SHADER_SpecialColormap + select].get());
|
||||
}
|
||||
else if (quad->ShaderNum == BQS_InGameColormap)
|
||||
{
|
||||
|
|
@ -3387,7 +3382,7 @@ void OpenGLSWFrameBuffer::EndQuadBatch()
|
|||
{
|
||||
SetConstant(PSCONST_Desaturation, quad->Desat / 255.f, (255 - quad->Desat) / 255.f, 0, 0);
|
||||
}
|
||||
SetPixelShader(Shaders[SHADER_InGameColormap + select]);
|
||||
SetPixelShader(Shaders[SHADER_InGameColormap + select].get());
|
||||
}
|
||||
|
||||
// Set the texture clamp addressing mode
|
||||
|
|
|
|||
|
|
@ -129,7 +129,7 @@ private:
|
|||
~HWFrameBuffer();
|
||||
|
||||
int Framebuffer = 0;
|
||||
HWTexture *Texture = nullptr;
|
||||
std::unique_ptr<HWTexture> Texture;
|
||||
};
|
||||
|
||||
|
||||
|
|
@ -177,11 +177,12 @@ private:
|
|||
int BurnLocation = -1;
|
||||
};
|
||||
|
||||
bool CreateFrameBuffer(const FString &name, int width, int height, HWFrameBuffer **outFramebuffer);
|
||||
bool CreatePixelShader(FString vertexsrc, FString fragmentsrc, const FString &defines, HWPixelShader **outShader);
|
||||
bool CreateVertexBuffer(int size, HWVertexBuffer **outVertexBuffer);
|
||||
bool CreateIndexBuffer(int size, HWIndexBuffer **outIndexBuffer);
|
||||
bool CreateTexture(const FString &name, int width, int height, int levels, int format, HWTexture **outTexture);
|
||||
std::unique_ptr<HWFrameBuffer> CreateFrameBuffer(const FString &name, int width, int height);
|
||||
std::unique_ptr<HWPixelShader> CreatePixelShader(FString vertexsrc, FString fragmentsrc, const FString &defines);
|
||||
std::unique_ptr<HWVertexBuffer> CreateVertexBuffer(int size);
|
||||
std::unique_ptr<HWIndexBuffer> CreateIndexBuffer(int size);
|
||||
std::unique_ptr<HWTexture> CreateTexture(const FString &name, int width, int height, int levels, int format);
|
||||
|
||||
void SetGammaRamp(const GammaRamp *ramp);
|
||||
void SetPixelShaderConstantF(int uniformIndex, const float *data, int vec4fcount);
|
||||
void SetHWPixelShader(HWPixelShader *shader);
|
||||
|
|
@ -250,7 +251,7 @@ private:
|
|||
|
||||
SkylineBinPack Packer;
|
||||
Atlas *Next;
|
||||
HWTexture *Tex;
|
||||
std::unique_ptr<HWTexture> Tex;
|
||||
int Format;
|
||||
PackedTexture *UsedList; // Boxes that contain images
|
||||
int Width, Height;
|
||||
|
|
@ -287,7 +288,7 @@ private:
|
|||
OpenGLPal **Prev;
|
||||
OpenGLPal *Next;
|
||||
|
||||
HWTexture *Tex;
|
||||
std::unique_ptr<HWTexture> Tex;
|
||||
uint32_t BorderColor;
|
||||
bool DoColorSkip;
|
||||
|
||||
|
|
@ -392,7 +393,7 @@ private:
|
|||
void UploadPalette();
|
||||
void CalcFullscreenCoords(FBVERTEX verts[4], bool viewarea_only, uint32_t color0, uint32_t color1) const;
|
||||
bool Reset();
|
||||
HWTexture *CopyCurrentScreen();
|
||||
std::unique_ptr<HWTexture> CopyCurrentScreen();
|
||||
void ReleaseDefaultPoolItems();
|
||||
void KillNativePals();
|
||||
void KillNativeTexs();
|
||||
|
|
@ -422,8 +423,6 @@ private:
|
|||
void SetSamplerWrapT(int tnum, int mode);
|
||||
void SetPaletteTexture(HWTexture *texture, int count, uint32_t border_color);
|
||||
|
||||
template<typename T> static void SafeRelease(T &x) { if (x != nullptr) { delete x; x = nullptr; } }
|
||||
|
||||
bool Valid = false;
|
||||
std::shared_ptr<FGLDebug> Debug;
|
||||
|
||||
|
|
@ -431,7 +430,7 @@ private:
|
|||
float ShaderConstants[NumPSCONST * 4];
|
||||
HWPixelShader *CurrentShader = nullptr;
|
||||
|
||||
HWFrameBuffer *OutputFB = nullptr;
|
||||
std::unique_ptr<HWFrameBuffer> OutputFB;
|
||||
|
||||
bool AlphaTestEnabled = false;
|
||||
bool AlphaBlendEnabled = false;
|
||||
|
|
@ -467,13 +466,13 @@ private:
|
|||
OpenGLTex *Textures = nullptr;
|
||||
Atlas *Atlases = nullptr;
|
||||
|
||||
HWTexture *FBTexture = nullptr;
|
||||
HWTexture *PaletteTexture = nullptr;
|
||||
HWTexture *ScreenshotTexture = nullptr;
|
||||
std::unique_ptr<HWTexture> FBTexture;
|
||||
std::unique_ptr<HWTexture> PaletteTexture;
|
||||
std::unique_ptr<HWTexture> ScreenshotTexture;
|
||||
|
||||
HWVertexBuffer *VertexBuffer = nullptr;
|
||||
std::unique_ptr<HWVertexBuffer> VertexBuffer;
|
||||
FBVERTEX *VertexData = nullptr;
|
||||
HWIndexBuffer *IndexBuffer = nullptr;
|
||||
std::unique_ptr<HWIndexBuffer> IndexBuffer;
|
||||
uint16_t *IndexData = nullptr;
|
||||
BufferedTris *QuadExtra = nullptr;
|
||||
int VertexPos;
|
||||
|
|
@ -481,9 +480,9 @@ private:
|
|||
int QuadBatchPos;
|
||||
enum { BATCH_None, BATCH_Quads, BATCH_Lines } BatchType;
|
||||
|
||||
HWPixelShader *Shaders[NUM_SHADERS];
|
||||
std::unique_ptr<HWPixelShader> Shaders[NUM_SHADERS];
|
||||
|
||||
HWTexture *InitialWipeScreen = nullptr, *FinalWipeScreen = nullptr;
|
||||
std::unique_ptr<HWTexture> InitialWipeScreen, FinalWipeScreen;
|
||||
|
||||
class Wiper
|
||||
{
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ public:
|
|||
private:
|
||||
static const int WIDTH = 64, HEIGHT = 64;
|
||||
uint8_t BurnArray[WIDTH * (HEIGHT + 5)];
|
||||
HWTexture *BurnTexture;
|
||||
std::unique_ptr<HWTexture> BurnTexture;
|
||||
int Density;
|
||||
int BurnTime;
|
||||
};
|
||||
|
|
@ -247,8 +247,8 @@ void OpenGLSWFrameBuffer::WipeCleanup()
|
|||
delete ScreenWipe;
|
||||
ScreenWipe = NULL;
|
||||
}
|
||||
SafeRelease( InitialWipeScreen );
|
||||
SafeRelease( FinalWipeScreen );
|
||||
InitialWipeScreen.reset();
|
||||
FinalWipeScreen.reset();
|
||||
GatheringWipeScreen = false;
|
||||
if (!Accel2D)
|
||||
{
|
||||
|
|
@ -283,7 +283,7 @@ void OpenGLSWFrameBuffer::Wiper::DrawScreen(OpenGLSWFrameBuffer *fb, HWTexture *
|
|||
fb->CalcFullscreenCoords(verts, false, color0, color1);
|
||||
fb->SetTexture(0, tex);
|
||||
fb->SetAlphaBlend(blendop, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
fb->SetPixelShader(fb->Shaders[SHADER_NormalColor]);
|
||||
fb->SetPixelShader(fb->Shaders[SHADER_NormalColor].get());
|
||||
fb->DrawTriangleFans(2, verts);
|
||||
}
|
||||
|
||||
|
|
@ -313,10 +313,10 @@ bool OpenGLSWFrameBuffer::Wiper_Crossfade::Run(int ticks, OpenGLSWFrameBuffer *f
|
|||
Clock += ticks;
|
||||
|
||||
// Put the initial screen back to the buffer.
|
||||
DrawScreen(fb, fb->InitialWipeScreen);
|
||||
DrawScreen(fb, fb->InitialWipeScreen.get());
|
||||
|
||||
// Draw the new screen on top of it.
|
||||
DrawScreen(fb, fb->FinalWipeScreen, GL_FUNC_ADD, ColorValue(0,0,0,Clock / 32.f), ColorRGBA(255,255,255,0));
|
||||
DrawScreen(fb, fb->FinalWipeScreen.get(), GL_FUNC_ADD, ColorValue(0,0,0,Clock / 32.f), ColorRGBA(255,255,255,0));
|
||||
|
||||
return Clock >= 32;
|
||||
}
|
||||
|
|
@ -354,7 +354,7 @@ OpenGLSWFrameBuffer::Wiper_Melt::Wiper_Melt()
|
|||
bool OpenGLSWFrameBuffer::Wiper_Melt::Run(int ticks, OpenGLSWFrameBuffer *fb)
|
||||
{
|
||||
// Draw the new screen on the bottom.
|
||||
DrawScreen(fb, fb->FinalWipeScreen);
|
||||
DrawScreen(fb, fb->FinalWipeScreen.get());
|
||||
|
||||
int i, dy;
|
||||
int fbwidth = fb->Width;
|
||||
|
|
@ -401,7 +401,7 @@ bool OpenGLSWFrameBuffer::Wiper_Melt::Run(int ticks, OpenGLSWFrameBuffer *fb)
|
|||
quad->Flags = BQF_DisableAlphaTest;
|
||||
quad->ShaderNum = BQS_Plain;
|
||||
quad->Palette = NULL;
|
||||
quad->Texture = fb->InitialWipeScreen;
|
||||
quad->Texture = fb->InitialWipeScreen.get();
|
||||
quad->NumVerts = 4;
|
||||
quad->NumTris = 2;
|
||||
|
||||
|
|
@ -485,10 +485,12 @@ OpenGLSWFrameBuffer::Wiper_Burn::Wiper_Burn(OpenGLSWFrameBuffer *fb)
|
|||
Density = 4;
|
||||
BurnTime = 0;
|
||||
memset(BurnArray, 0, sizeof(BurnArray));
|
||||
if (fb->Shaders[SHADER_BurnWipe] == NULL || !fb->CreateTexture("BurnWipe", WIDTH, HEIGHT, 1, GL_R8, &BurnTexture))
|
||||
if (fb->Shaders[SHADER_BurnWipe] == nullptr)
|
||||
{
|
||||
BurnTexture = NULL;
|
||||
BurnTexture = nullptr;
|
||||
}
|
||||
|
||||
BurnTexture = fb->CreateTexture("BurnWipe", WIDTH, HEIGHT, 1, GL_R8);
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
|
@ -499,7 +501,7 @@ OpenGLSWFrameBuffer::Wiper_Burn::Wiper_Burn(OpenGLSWFrameBuffer *fb)
|
|||
|
||||
OpenGLSWFrameBuffer::Wiper_Burn::~Wiper_Burn()
|
||||
{
|
||||
SafeRelease( BurnTexture );
|
||||
BurnTexture.reset();
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
|
@ -555,7 +557,7 @@ bool OpenGLSWFrameBuffer::Wiper_Burn::Run(int ticks, OpenGLSWFrameBuffer *fb)
|
|||
}
|
||||
|
||||
// Put the initial screen back to the buffer.
|
||||
DrawScreen(fb, fb->InitialWipeScreen);
|
||||
DrawScreen(fb, fb->InitialWipeScreen.get());
|
||||
|
||||
// Burn the new screen on top of it.
|
||||
float right = float(fb->Width);
|
||||
|
|
@ -569,10 +571,10 @@ bool OpenGLSWFrameBuffer::Wiper_Burn::Run(int ticks, OpenGLSWFrameBuffer *fb)
|
|||
{ 0.f, bot, 0.f, 1.f, 0.f, 1.f, 0, 1 }
|
||||
};
|
||||
|
||||
fb->SetTexture(0, fb->FinalWipeScreen);
|
||||
fb->SetTexture(1, BurnTexture);
|
||||
fb->SetTexture(0, fb->FinalWipeScreen.get());
|
||||
fb->SetTexture(1, BurnTexture.get());
|
||||
fb->SetAlphaBlend(GL_FUNC_ADD, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
||||
fb->SetPixelShader(fb->Shaders[SHADER_BurnWipe]);
|
||||
fb->SetPixelShader(fb->Shaders[SHADER_BurnWipe].get());
|
||||
glActiveTexture(GL_TEXTURE1);
|
||||
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
||||
fb->DrawTriangleFans(2, verts);
|
||||
|
|
|
|||
Loading…
Reference in a new issue