mirror of
https://github.com/ZDoom/gzdoom-gles.git
synced 2024-11-10 23:01:59 +00:00
. removed the texture atlases from the OpenGLSWFrameBuffer.
# Conflicts: # src/gl/system/gl_swframebuffer.cpp
This commit is contained in:
Christoph Oelckers
parent
41a0e6af4a
commit
a350c43c87
2 changed files with 21 additions and 485 deletions
|
|
@ -94,9 +94,7 @@ EXTERN_CVAR(Bool, vid_vsync)
|
|||
EXTERN_CVAR(Float, transsouls)
|
||||
EXTERN_CVAR(Int, vid_refreshrate)
|
||||
|
||||
#ifdef WIN32
|
||||
cycle_t BlitCycles;
|
||||
#endif
|
||||
|
||||
void gl_LoadExtensions();
|
||||
void gl_PrintStartupLog();
|
||||
|
|
@ -165,7 +163,6 @@ OpenGLSWFrameBuffer::OpenGLSWFrameBuffer(void *hMonitor, int width, int height,
|
|||
InScene = false;
|
||||
QuadExtra = new BufferedTris[MAX_QUAD_BATCH];
|
||||
memset(QuadExtra, 0, sizeof(BufferedTris) * MAX_QUAD_BATCH);
|
||||
Atlases = nullptr;
|
||||
PixelDoubling = 0;
|
||||
|
||||
Gamma = 1.0;
|
||||
|
|
@ -827,7 +824,6 @@ void OpenGLSWFrameBuffer::SetInitialState()
|
|||
|
||||
bool OpenGLSWFrameBuffer::CreateResources()
|
||||
{
|
||||
Atlases = nullptr;
|
||||
if (!LoadShaders())
|
||||
return false;
|
||||
|
||||
|
|
@ -924,12 +920,6 @@ void OpenGLSWFrameBuffer::ReleaseResources()
|
|||
delete ScreenWipe;
|
||||
ScreenWipe = nullptr;
|
||||
}
|
||||
Atlas *pack, *next;
|
||||
for (pack = Atlases; pack != nullptr; pack = next)
|
||||
{
|
||||
next = pack->Next;
|
||||
delete pack;
|
||||
}
|
||||
GatheringWipeScreen = false;
|
||||
}
|
||||
|
||||
|
|
@ -1216,7 +1206,6 @@ void OpenGLSWFrameBuffer::Update()
|
|||
if (InScene)
|
||||
{
|
||||
DrawRateStuff();
|
||||
DrawPackedTextures(gl_showpacks);
|
||||
EndBatch(); // Make sure all batched primitives are drawn.
|
||||
Flip();
|
||||
}
|
||||
|
|
@ -1727,323 +1716,6 @@ void OpenGLSWFrameBuffer::ReleaseScreenshotBuffer()
|
|||
/* 2D Stuff */
|
||||
/**************************************************************************/
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// OpenGLSWFrameBuffer :: DrawPackedTextures
|
||||
//
|
||||
// DEBUG: Draws the texture atlases to the screen, starting with the
|
||||
// 1-based packnum. Ignores atlases that are flagged for use by one
|
||||
// texture only.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void OpenGLSWFrameBuffer::DrawPackedTextures(int packnum)
|
||||
{
|
||||
uint32_t empty_colors[8] =
|
||||
{
|
||||
0x50FF0000, 0x5000FF00, 0x500000FF, 0x50FFFF00,
|
||||
0x50FF00FF, 0x5000FFFF, 0x50FF8000, 0x500080FF
|
||||
};
|
||||
Atlas *pack;
|
||||
int x = 8, y = 8;
|
||||
|
||||
if (packnum <= 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
pack = Atlases;
|
||||
// Find the first texture atlas that is an actual atlas.
|
||||
while (pack != nullptr && pack->OneUse)
|
||||
{ // Skip textures that aren't used as atlases
|
||||
pack = pack->Next;
|
||||
}
|
||||
// Skip however many atlases we would have otherwise drawn
|
||||
// until we've skipped <packnum> of them.
|
||||
while (pack != nullptr && packnum != 1)
|
||||
{
|
||||
if (!pack->OneUse)
|
||||
{ // Skip textures that aren't used as atlases
|
||||
packnum--;
|
||||
}
|
||||
pack = pack->Next;
|
||||
}
|
||||
// Draw atlases until we run out of room on the screen.
|
||||
while (pack != nullptr)
|
||||
{
|
||||
if (pack->OneUse)
|
||||
{ // Skip textures that aren't used as atlases
|
||||
pack = pack->Next;
|
||||
continue;
|
||||
}
|
||||
|
||||
AddColorOnlyRect(x - 1, y - 1, 258, 258, ColorXRGB(255, 255, 0));
|
||||
int back = 0;
|
||||
for (PackedTexture *box = pack->UsedList; box != nullptr; box = box->Next)
|
||||
{
|
||||
AddColorOnlyQuad(
|
||||
x + box->Area.left * 256 / pack->Width,
|
||||
y + box->Area.top * 256 / pack->Height,
|
||||
(box->Area.right - box->Area.left) * 256 / pack->Width,
|
||||
(box->Area.bottom - box->Area.top) * 256 / pack->Height, empty_colors[back]);
|
||||
back = (back + 1) & 7;
|
||||
}
|
||||
// AddColorOnlyQuad(x, y-LBOffsetI, 256, 256, ColorARGB(180,0,0,0));
|
||||
|
||||
CheckQuadBatch();
|
||||
|
||||
BufferedTris *quad = &QuadExtra[QuadBatchPos];
|
||||
FBVERTEX *vert = &VertexData[VertexPos];
|
||||
|
||||
quad->ClearSetup();
|
||||
if (pack->Format == GL_R8/* && !tex->IsGray*/)
|
||||
{
|
||||
quad->Flags = BQF_WrapUV | BQF_GamePalette/* | BQF_DisableAlphaTest*/;
|
||||
quad->ShaderNum = BQS_PalTex;
|
||||
}
|
||||
else
|
||||
{
|
||||
quad->Flags = BQF_WrapUV/* | BQF_DisableAlphaTest*/;
|
||||
quad->ShaderNum = BQS_Plain;
|
||||
}
|
||||
quad->Palette = nullptr;
|
||||
quad->Texture = pack->Tex.get();
|
||||
quad->NumVerts = 4;
|
||||
quad->NumTris = 2;
|
||||
|
||||
float x0 = float(x);
|
||||
float y0 = float(y);
|
||||
float x1 = x0 + 256.f;
|
||||
float y1 = y0 + 256.f;
|
||||
|
||||
vert[0].x = x0;
|
||||
vert[0].y = y0;
|
||||
vert[0].z = 0;
|
||||
vert[0].rhw = 1;
|
||||
vert[0].color0 = 0;
|
||||
vert[0].color1 = 0xFFFFFFFF;
|
||||
vert[0].tu = 0;
|
||||
vert[0].tv = 0;
|
||||
|
||||
vert[1].x = x1;
|
||||
vert[1].y = y0;
|
||||
vert[1].z = 0;
|
||||
vert[1].rhw = 1;
|
||||
vert[1].color0 = 0;
|
||||
vert[1].color1 = 0xFFFFFFFF;
|
||||
vert[1].tu = 1;
|
||||
vert[1].tv = 0;
|
||||
|
||||
vert[2].x = x1;
|
||||
vert[2].y = y1;
|
||||
vert[2].z = 0;
|
||||
vert[2].rhw = 1;
|
||||
vert[2].color0 = 0;
|
||||
vert[2].color1 = 0xFFFFFFFF;
|
||||
vert[2].tu = 1;
|
||||
vert[2].tv = 1;
|
||||
|
||||
vert[3].x = x0;
|
||||
vert[3].y = y1;
|
||||
vert[3].z = 0;
|
||||
vert[3].rhw = 1;
|
||||
vert[3].color0 = 0;
|
||||
vert[3].color1 = 0xFFFFFFFF;
|
||||
vert[3].tu = 0;
|
||||
vert[3].tv = 1;
|
||||
|
||||
IndexData[IndexPos] = VertexPos;
|
||||
IndexData[IndexPos + 1] = VertexPos + 1;
|
||||
IndexData[IndexPos + 2] = VertexPos + 2;
|
||||
IndexData[IndexPos + 3] = VertexPos;
|
||||
IndexData[IndexPos + 4] = VertexPos + 2;
|
||||
IndexData[IndexPos + 5] = VertexPos + 3;
|
||||
|
||||
QuadBatchPos++;
|
||||
VertexPos += 4;
|
||||
IndexPos += 6;
|
||||
|
||||
x += 256 + 8;
|
||||
if (x > Width - 256)
|
||||
{
|
||||
x = 8;
|
||||
y += 256 + 8;
|
||||
if (y > Height - 256)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
pack = pack->Next;
|
||||
}
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// OpenGLSWFrameBuffer :: AllocPackedTexture
|
||||
//
|
||||
// Finds space to pack an image inside a texture atlas and returns it.
|
||||
// Large images and those that need to wrap always get their own textures.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
OpenGLSWFrameBuffer::PackedTexture *OpenGLSWFrameBuffer::AllocPackedTexture(int w, int h, bool wrapping, int format)
|
||||
{
|
||||
Atlas *pack;
|
||||
Rect box;
|
||||
bool padded;
|
||||
|
||||
// The - 2 to account for padding
|
||||
if (w > 256 - 2 || h > 256 - 2 || wrapping)
|
||||
{ // Create a new texture atlas.
|
||||
pack = new Atlas(this, w, h, format);
|
||||
pack->OneUse = true;
|
||||
box = pack->Packer.Insert(w, h);
|
||||
padded = false;
|
||||
}
|
||||
else
|
||||
{ // Try to find space in an existing texture atlas.
|
||||
w += 2; // Add padding
|
||||
h += 2;
|
||||
for (pack = Atlases; pack != nullptr; pack = pack->Next)
|
||||
{
|
||||
// Use the first atlas it fits in.
|
||||
if (pack->Format == format)
|
||||
{
|
||||
box = pack->Packer.Insert(w, h);
|
||||
if (box.width != 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (pack == nullptr)
|
||||
{ // Create a new texture atlas.
|
||||
pack = new Atlas(this, DEF_ATLAS_WIDTH, DEF_ATLAS_HEIGHT, format);
|
||||
box = pack->Packer.Insert(w, h);
|
||||
}
|
||||
padded = true;
|
||||
}
|
||||
assert(box.width != 0 && box.height != 0);
|
||||
return pack->AllocateImage(box, padded);
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// Atlas Constructor
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
OpenGLSWFrameBuffer::Atlas::Atlas(OpenGLSWFrameBuffer *fb, int w, int h, int format)
|
||||
: Packer(w, h, true)
|
||||
{
|
||||
Format = format;
|
||||
UsedList = nullptr;
|
||||
OneUse = false;
|
||||
Width = 0;
|
||||
Height = 0;
|
||||
Next = nullptr;
|
||||
|
||||
// Attach to the end of the atlas list
|
||||
Atlas **prev = &fb->Atlases;
|
||||
while (*prev != nullptr)
|
||||
{
|
||||
prev = &((*prev)->Next);
|
||||
}
|
||||
*prev = this;
|
||||
|
||||
Tex = fb->CreateTexture("Atlas", w, h, 1, format);
|
||||
Width = w;
|
||||
Height = h;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// Atlas Destructor
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
OpenGLSWFrameBuffer::Atlas::~Atlas()
|
||||
{
|
||||
PackedTexture *box, *next;
|
||||
|
||||
Tex.reset();
|
||||
for (box = UsedList; box != nullptr; box = next)
|
||||
{
|
||||
next = box->Next;
|
||||
delete box;
|
||||
}
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// Atlas :: AllocateImage
|
||||
//
|
||||
// Moves the box from the empty list to the used list, sizing it to the
|
||||
// requested dimensions and adding additional boxes to the empty list if
|
||||
// needed.
|
||||
//
|
||||
// The passed box *MUST* be in this texture atlas's empty list.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
OpenGLSWFrameBuffer::PackedTexture *OpenGLSWFrameBuffer::Atlas::AllocateImage(const Rect &rect, bool padded)
|
||||
{
|
||||
PackedTexture *box = new PackedTexture;
|
||||
|
||||
box->Owner = this;
|
||||
box->Area.left = rect.x;
|
||||
box->Area.top = rect.y;
|
||||
box->Area.right = rect.x + rect.width;
|
||||
box->Area.bottom = rect.y + rect.height;
|
||||
|
||||
box->Left = float(box->Area.left + padded) / Width;
|
||||
box->Right = float(box->Area.right - padded) / Width;
|
||||
box->Top = float(box->Area.top + padded) / Height;
|
||||
box->Bottom = float(box->Area.bottom - padded) / Height;
|
||||
|
||||
box->Padded = padded;
|
||||
|
||||
// Add it to the used list.
|
||||
box->Next = UsedList;
|
||||
if (box->Next != nullptr)
|
||||
{
|
||||
box->Next->Prev = &box->Next;
|
||||
}
|
||||
UsedList = box;
|
||||
box->Prev = &UsedList;
|
||||
|
||||
return box;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// Atlas :: FreeBox
|
||||
//
|
||||
// Removes a box from the used list and deletes it. Space is returned to the
|
||||
// waste list. Once all boxes for this atlas are freed, the entire bin
|
||||
// packer is reinitialized for maximum efficiency.
|
||||
//
|
||||
//==========================================================================
|
||||
|
||||
void OpenGLSWFrameBuffer::Atlas::FreeBox(OpenGLSWFrameBuffer::PackedTexture *box)
|
||||
{
|
||||
*(box->Prev) = box->Next;
|
||||
if (box->Next != nullptr)
|
||||
{
|
||||
box->Next->Prev = box->Prev;
|
||||
}
|
||||
Rect waste;
|
||||
waste.x = box->Area.left;
|
||||
waste.y = box->Area.top;
|
||||
waste.width = box->Area.right - box->Area.left;
|
||||
waste.height = box->Area.bottom - box->Area.top;
|
||||
box->Owner->Packer.AddWaste(waste);
|
||||
delete box;
|
||||
if (UsedList == nullptr)
|
||||
{
|
||||
Packer.Init(Width, Height, true);
|
||||
}
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
//
|
||||
// OpenGLTex Constructor
|
||||
|
|
@ -2063,7 +1735,6 @@ OpenGLSWFrameBuffer::OpenGLTex::OpenGLTex(FTexture *tex, FTextureFormat fmt, Ope
|
|||
fb->Textures = this;
|
||||
|
||||
GameTex = tex;
|
||||
Box = nullptr;
|
||||
IsGray = false;
|
||||
|
||||
Create(fb, wrapping);
|
||||
|
|
@ -2077,11 +1748,6 @@ OpenGLSWFrameBuffer::OpenGLTex::OpenGLTex(FTexture *tex, FTextureFormat fmt, Ope
|
|||
|
||||
OpenGLSWFrameBuffer::OpenGLTex::~OpenGLTex()
|
||||
{
|
||||
if (Box != nullptr)
|
||||
{
|
||||
Box->Owner->FreeBox(Box);
|
||||
Box = nullptr;
|
||||
}
|
||||
// Detach from the texture list
|
||||
*Prev = Next;
|
||||
if (Next != nullptr)
|
||||
|
|
@ -2106,13 +1772,7 @@ OpenGLSWFrameBuffer::OpenGLTex::~OpenGLTex()
|
|||
|
||||
bool OpenGLSWFrameBuffer::OpenGLTex::CheckWrapping(bool wrapping)
|
||||
{
|
||||
// If it doesn't need to wrap, then it works.
|
||||
if (!wrapping)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
// If it needs to wrap, then it can't be packed inside another texture.
|
||||
return Box->Owner->OneUse;
|
||||
return true;
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
|
@ -2126,25 +1786,8 @@ bool OpenGLSWFrameBuffer::OpenGLTex::CheckWrapping(bool wrapping)
|
|||
|
||||
bool OpenGLSWFrameBuffer::OpenGLTex::Create(OpenGLSWFrameBuffer *fb, bool wrapping)
|
||||
{
|
||||
assert(Box == nullptr);
|
||||
if (Box != nullptr)
|
||||
{
|
||||
Box->Owner->FreeBox(Box);
|
||||
}
|
||||
|
||||
Box = fb->AllocPackedTexture(GameTex->GetWidth(), GameTex->GetHeight(), wrapping, GetTexFormat());
|
||||
|
||||
if (Box == nullptr)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (!Update())
|
||||
{
|
||||
Box->Owner->FreeBox(Box);
|
||||
Box = nullptr;
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
Tex = fb->CreateTexture("Atlas", GameTex->GetWidth(), GameTex->GetHeight(), 1, GetTexFormat());
|
||||
return Update();
|
||||
}
|
||||
|
||||
//==========================================================================
|
||||
|
|
@ -2160,17 +1803,14 @@ bool OpenGLSWFrameBuffer::OpenGLTex::Update()
|
|||
LTRBRect rect;
|
||||
uint8_t *dest;
|
||||
|
||||
assert(Box != nullptr);
|
||||
assert(Box->Owner != nullptr);
|
||||
assert(Box->Owner->Tex != nullptr);
|
||||
assert(GameTex != nullptr);
|
||||
|
||||
int format = Box->Owner->Tex->Format;
|
||||
int format = Tex->Format;
|
||||
|
||||
rect = Box->Area;
|
||||
rect = { 0, 0, GameTex->GetWidth(), GameTex->GetHeight() };
|
||||
|
||||
if (Box->Owner->Tex->Buffers[0] == 0)
|
||||
glGenBuffers(2, (GLuint*)Box->Owner->Tex->Buffers);
|
||||
if (Tex->Buffers[0] == 0)
|
||||
glGenBuffers(2, (GLuint*)Tex->Buffers);
|
||||
|
||||
int bytesPerPixel = 4;
|
||||
switch (format)
|
||||
|
|
@ -2181,9 +1821,9 @@ bool OpenGLSWFrameBuffer::OpenGLTex::Update()
|
|||
}
|
||||
|
||||
int buffersize = (rect.right - rect.left) * (rect.bottom - rect.top) * bytesPerPixel;
|
||||
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, Box->Owner->Tex->Buffers[Box->Owner->Tex->CurrentBuffer]);
|
||||
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, Tex->Buffers[Tex->CurrentBuffer]);
|
||||
glBufferData(GL_PIXEL_UNPACK_BUFFER, buffersize, nullptr, GL_STREAM_DRAW);
|
||||
Box->Owner->Tex->CurrentBuffer = (Box->Owner->Tex->CurrentBuffer + 1) & 1;
|
||||
Tex->CurrentBuffer ^= 1;
|
||||
|
||||
static std::vector<uint8_t> tempbuffer;
|
||||
if (gl.es)
|
||||
|
|
@ -2196,44 +1836,7 @@ bool OpenGLSWFrameBuffer::OpenGLTex::Update()
|
|||
{
|
||||
return false;
|
||||
}
|
||||
if (Box->Padded)
|
||||
{
|
||||
dest += pitch + (format == GL_R8 ? 1 : 4);
|
||||
}
|
||||
GameTex->FillBuffer(dest, pitch, GameTex->GetHeight(), mFormat);
|
||||
if (Box->Padded)
|
||||
{
|
||||
// Clear top padding row.
|
||||
dest = bits;
|
||||
int numbytes = GameTex->GetWidth() + 2;
|
||||
if (format != GL_R8)
|
||||
{
|
||||
numbytes <<= 2;
|
||||
}
|
||||
memset(dest, 0, numbytes);
|
||||
dest += pitch;
|
||||
// Clear left and right padding columns.
|
||||
if (format == GL_R8)
|
||||
{
|
||||
for (int y = Box->Area.bottom - Box->Area.top - 2; y > 0; --y)
|
||||
{
|
||||
dest[0] = 0;
|
||||
dest[numbytes - 1] = 0;
|
||||
dest += pitch;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (int y = Box->Area.bottom - Box->Area.top - 2; y > 0; --y)
|
||||
{
|
||||
*(uint32_t *)dest = 0;
|
||||
*(uint32_t *)(dest + numbytes - 4) = 0;
|
||||
dest += pitch;
|
||||
}
|
||||
}
|
||||
// Clear bottom padding row.
|
||||
memset(dest, 0, numbytes);
|
||||
}
|
||||
|
||||
if (gl.es && format == GL_RGBA8)
|
||||
{
|
||||
|
|
@ -2246,7 +1849,7 @@ bool OpenGLSWFrameBuffer::OpenGLTex::Update()
|
|||
glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
|
||||
GLint oldBinding = 0;
|
||||
glGetIntegerv(GL_TEXTURE_BINDING_2D, &oldBinding);
|
||||
glBindTexture(GL_TEXTURE_2D, Box->Owner->Tex->Texture);
|
||||
glBindTexture(GL_TEXTURE_2D, Tex->Texture);
|
||||
if (format == GL_RGBA8)
|
||||
glTexSubImage2D(GL_TEXTURE_2D, 0, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, gl.es ? GL_RGBA : GL_BGRA, GL_UNSIGNED_BYTE, 0);
|
||||
else
|
||||
|
|
@ -2511,11 +2114,6 @@ void OpenGLSWFrameBuffer::DrawBlendingRect()
|
|||
FNativeTexture *OpenGLSWFrameBuffer::CreateTexture(FTexture *gametex, FTextureFormat fmt, bool wrapping)
|
||||
{
|
||||
OpenGLTex *tex = new OpenGLTex(gametex, fmt, this, wrapping);
|
||||
if (tex->Box == nullptr)
|
||||
{
|
||||
delete tex;
|
||||
return nullptr;
|
||||
}
|
||||
return tex;
|
||||
}
|
||||
|
||||
|
|
@ -2756,11 +2354,11 @@ void OpenGLSWFrameBuffer::DrawTextureParms(FTexture *img, DrawParms &parms)
|
|||
double y0 = parms.y - parms.top * yscale;
|
||||
double x1 = x0 + parms.destwidth;
|
||||
double y1 = y0 + parms.destheight;
|
||||
float u0 = tex->Box->Left;
|
||||
float v0 = tex->Box->Top;
|
||||
float u1 = tex->Box->Right;
|
||||
float v1 = tex->Box->Bottom;
|
||||
double uscale = 1.f / tex->Box->Owner->Width;
|
||||
float u0 = 0;
|
||||
float v0 = 0;
|
||||
float u1 = 1;
|
||||
float v1 = 1;
|
||||
double uscale = 1.f;
|
||||
bool scissoring = false;
|
||||
FBVERTEX *vert;
|
||||
|
||||
|
|
@ -2777,32 +2375,8 @@ void OpenGLSWFrameBuffer::DrawTextureParms(FTexture *img, DrawParms &parms)
|
|||
u1 = float(u1 - (parms.texwidth - wi) * uscale);
|
||||
}
|
||||
|
||||
#if 0
|
||||
float vscale = 1.f / tex->Box->Owner->Height / yscale;
|
||||
if (y0 < parms.uclip)
|
||||
{
|
||||
v0 += (float(parms.uclip) - y0) * vscale;
|
||||
y0 = float(parms.uclip);
|
||||
}
|
||||
if (y1 > parms.dclip)
|
||||
{
|
||||
v1 -= (y1 - float(parms.dclip)) * vscale;
|
||||
y1 = float(parms.dclip);
|
||||
}
|
||||
if (x0 < parms.lclip)
|
||||
{
|
||||
u0 += float(parms.lclip - x0) * uscale / xscale * 2;
|
||||
x0 = float(parms.lclip);
|
||||
}
|
||||
if (x1 > parms.rclip)
|
||||
{
|
||||
u1 -= (x1 - parms.rclip) * uscale / xscale * 2;
|
||||
x1 = float(parms.rclip);
|
||||
}
|
||||
#else
|
||||
// Use a scissor test because the math above introduces some jitter
|
||||
// that is noticeable at low resolutions. Unfortunately, this means this
|
||||
// quad has to be in a batch by itself.
|
||||
// that is noticeable at low resolutions.
|
||||
if (y0 < parms.uclip || y1 > parms.dclip || x0 < parms.lclip || x1 > parms.rclip)
|
||||
{
|
||||
scissoring = true;
|
||||
|
|
@ -2814,7 +2388,6 @@ void OpenGLSWFrameBuffer::DrawTextureParms(FTexture *img, DrawParms &parms)
|
|||
glEnable(GL_SCISSOR_TEST);
|
||||
glScissor(parms.lclip, parms.uclip, parms.rclip - parms.lclip, parms.dclip - parms.uclip);
|
||||
}
|
||||
#endif
|
||||
parms.bilinear = false;
|
||||
|
||||
uint32_t color0, color1;
|
||||
|
|
@ -2825,7 +2398,7 @@ void OpenGLSWFrameBuffer::DrawTextureParms(FTexture *img, DrawParms &parms)
|
|||
goto done;
|
||||
}
|
||||
|
||||
quad->Texture = tex->Box->Owner->Tex.get();
|
||||
quad->Texture = tex->Tex.get();
|
||||
if (parms.bilinear)
|
||||
{
|
||||
quad->Flags |= BQF_Bilinear;
|
||||
|
|
@ -2952,7 +2525,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.get();
|
||||
quad->Texture = tex->Tex.get();
|
||||
quad->NumVerts = 4;
|
||||
quad->NumTris = 2;
|
||||
|
||||
|
|
@ -3081,7 +2654,7 @@ void OpenGLSWFrameBuffer::FillSimplePoly(FTexture *texture, FVector2 *points, in
|
|||
quad->ShaderNum = BQS_Plain;
|
||||
}
|
||||
quad->Palette = nullptr;
|
||||
quad->Texture = tex->Box->Owner->Tex.get();
|
||||
quad->Texture = tex->Tex.get();
|
||||
quad->NumVerts = npoints;
|
||||
quad->NumTris = npoints - 2;
|
||||
|
||||
|
|
|
|||
|
|
@ -227,49 +227,15 @@ private:
|
|||
|
||||
// TYPES -------------------------------------------------------------------
|
||||
|
||||
struct Atlas;
|
||||
|
||||
struct PackedTexture
|
||||
{
|
||||
Atlas *Owner;
|
||||
|
||||
PackedTexture **Prev, *Next;
|
||||
|
||||
// Pixels this image covers
|
||||
LTRBRect Area;
|
||||
|
||||
// Texture coordinates for this image
|
||||
float Left, Top, Right, Bottom;
|
||||
|
||||
// Texture has extra space on the border?
|
||||
bool Padded;
|
||||
};
|
||||
|
||||
struct Atlas
|
||||
{
|
||||
Atlas(OpenGLSWFrameBuffer *fb, int width, int height, int format);
|
||||
~Atlas();
|
||||
|
||||
PackedTexture *AllocateImage(const Rect &rect, bool padded);
|
||||
void FreeBox(PackedTexture *box);
|
||||
|
||||
SkylineBinPack Packer;
|
||||
Atlas *Next;
|
||||
std::unique_ptr<HWTexture> Tex;
|
||||
int Format;
|
||||
PackedTexture *UsedList; // Boxes that contain images
|
||||
int Width, Height;
|
||||
bool OneUse;
|
||||
};
|
||||
|
||||
class OpenGLTex : public FNativeTexture
|
||||
{
|
||||
public:
|
||||
OpenGLTex(FTexture *tex, FTextureFormat fmt, OpenGLSWFrameBuffer *fb, bool wrapping);
|
||||
~OpenGLTex();
|
||||
|
||||
std::unique_ptr<HWTexture> Tex;
|
||||
|
||||
FTexture *GameTex;
|
||||
PackedTexture *Box;
|
||||
|
||||
OpenGLTex **Prev;
|
||||
OpenGLTex *Next;
|
||||
|
|
@ -399,8 +365,6 @@ private:
|
|||
void ReleaseDefaultPoolItems();
|
||||
void KillNativePals();
|
||||
void KillNativeTexs();
|
||||
PackedTexture *AllocPackedTexture(int width, int height, bool wrapping, int format);
|
||||
void DrawPackedTextures(int packnum);
|
||||
void DrawLetterbox(int x, int y, int width, int height);
|
||||
void Draw3DPart(bool copy3d);
|
||||
bool SetStyle(OpenGLTex *tex, DrawParms &parms, uint32_t &color0, uint32_t &color1, BufferedTris &quad);
|
||||
|
|
@ -466,7 +430,6 @@ private:
|
|||
uint8_t BlockNum;
|
||||
OpenGLPal *Palettes = nullptr;
|
||||
OpenGLTex *Textures = nullptr;
|
||||
Atlas *Atlases = nullptr;
|
||||
|
||||
std::unique_ptr<HWTexture> FBTexture;
|
||||
std::unique_ptr<HWTexture> PaletteTexture;
|
||||
|
|
|
|||
Loading…
Reference in a new issue