bd7476fb8d
Both files can now be included independently without causing problems. This also required moving some inline functions into separate files and splitting off the GC definitions from dobject.h to ensure that r_defs does not need to pull in any part of the object hierarchy.
506 lines
13 KiB
C++
506 lines
13 KiB
C++
#ifndef __GL_SWFRAMEBUFFER
|
|
#define __GL_SWFRAMEBUFFER
|
|
|
|
#ifdef _WIN32
|
|
#include "win32iface.h"
|
|
#include "win32gliface.h"
|
|
#endif
|
|
|
|
#include "SkylineBinPack.h"
|
|
#include "textures.h"
|
|
|
|
#include <memory>
|
|
|
|
class FGLDebug;
|
|
|
|
#ifdef _WIN32
|
|
class OpenGLSWFrameBuffer : public Win32GLFrameBuffer
|
|
{
|
|
typedef Win32GLFrameBuffer Super;
|
|
DECLARE_CLASS(OpenGLSWFrameBuffer, Win32GLFrameBuffer)
|
|
#else
|
|
#include "sdlglvideo.h"
|
|
class OpenGLSWFrameBuffer : public SDLGLFB
|
|
{
|
|
// typedef SDLGLFB Super; //[C]commented, DECLARE_CLASS defines this in linux
|
|
DECLARE_CLASS(OpenGLSWFrameBuffer, SDLGLFB)
|
|
#endif
|
|
|
|
|
|
public:
|
|
|
|
explicit OpenGLSWFrameBuffer() {}
|
|
OpenGLSWFrameBuffer(void *hMonitor, int width, int height, int bits, int refreshHz, bool fullscreen, bool bgra);
|
|
~OpenGLSWFrameBuffer();
|
|
|
|
|
|
bool IsValid() override;
|
|
bool Lock(bool buffered) override;
|
|
void Unlock() override;
|
|
void Update() override;
|
|
PalEntry *GetPalette() override;
|
|
void GetFlashedPalette(PalEntry palette[256]) override;
|
|
void UpdatePalette() override;
|
|
bool SetGamma(float gamma) override;
|
|
bool SetFlash(PalEntry rgb, int amount) override;
|
|
void GetFlash(PalEntry &rgb, int &amount) override;
|
|
int GetPageCount() override;
|
|
void SetVSync(bool vsync) override;
|
|
void NewRefreshRate() override;
|
|
void GetScreenshotBuffer(const uint8_t *&buffer, int &pitch, ESSType &color_type) override;
|
|
void ReleaseScreenshotBuffer() override;
|
|
void SetBlendingRect(int x1, int y1, int x2, int y2) override;
|
|
bool Begin2D(bool copy3d) override;
|
|
void DrawBlendingRect() override;
|
|
FNativeTexture *CreateTexture(FTexture *gametex, bool wrapping) override;
|
|
FNativePalette *CreatePalette(FRemapTable *remap) override;
|
|
void DrawTextureParms(FTexture *img, DrawParms &parms) override;
|
|
void Clear(int left, int top, int right, int bottom, int palcolor, uint32_t color) override;
|
|
void Dim(PalEntry color, float amount, int x1, int y1, int w, int h) override;
|
|
void FlatFill(int left, int top, int right, int bottom, FTexture *src, bool local_origin) override;
|
|
void DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor) override;
|
|
void DrawPixel(int x, int y, int palcolor, uint32_t rgbcolor) override;
|
|
void FillSimplePoly(FTexture *tex, FVector2 *points, int npoints, double originx, double originy, double scalex, double scaley, DAngle rotation, FDynamicColormap *colormap, PalEntry flatcolor, int lightlevel, int bottomclip) override;
|
|
bool WipeStartScreen(int type) override;
|
|
void WipeEndScreen() override;
|
|
bool WipeDo(int ticks) override;
|
|
void WipeCleanup() override;
|
|
|
|
#ifdef WIN32
|
|
void PaletteChanged() override { }
|
|
int QueryNewPalette() override { return 0; }
|
|
void Blank() override { }
|
|
bool PaintToWindow() override;
|
|
bool Is8BitMode() override { return false; }
|
|
int GetTrueHeight() override { return TrueHeight; }
|
|
#endif
|
|
|
|
private:
|
|
struct FBVERTEX
|
|
{
|
|
float x, y, z, rhw;
|
|
uint32_t color0, color1;
|
|
float tu, tv;
|
|
};
|
|
|
|
struct BURNVERTEX
|
|
{
|
|
float x, y, z, rhw;
|
|
float tu0, tv0;
|
|
float tu1, tv1;
|
|
};
|
|
|
|
enum
|
|
{
|
|
PSCONST_Desaturation,
|
|
PSCONST_PaletteMod,
|
|
PSCONST_Weights,
|
|
PSCONST_Gamma,
|
|
PSCONST_ScreenSize,
|
|
NumPSCONST
|
|
};
|
|
|
|
struct GammaRamp
|
|
{
|
|
uint16_t red[256], green[256], blue[256];
|
|
};
|
|
|
|
struct LTRBRect
|
|
{
|
|
int left, top, right, bottom;
|
|
};
|
|
|
|
class HWTexture
|
|
{
|
|
public:
|
|
HWTexture() { Buffers[0] = 0; Buffers[1] = 0; }
|
|
~HWTexture();
|
|
|
|
int Texture = 0;
|
|
int Buffers[2];
|
|
int CurrentBuffer = 0;
|
|
int WrapS = 0;
|
|
int WrapT = 0;
|
|
int Format = 0;
|
|
|
|
std::vector<uint8_t> MapBuffer;
|
|
};
|
|
|
|
class HWFrameBuffer
|
|
{
|
|
public:
|
|
~HWFrameBuffer();
|
|
|
|
int Framebuffer = 0;
|
|
HWTexture *Texture = nullptr;
|
|
};
|
|
|
|
|
|
class HWVertexBuffer
|
|
{
|
|
public:
|
|
~HWVertexBuffer();
|
|
|
|
FBVERTEX *Lock();
|
|
void Unlock();
|
|
|
|
int VertexArray = 0;
|
|
int Buffer = 0;
|
|
int Size = 0;
|
|
};
|
|
|
|
class HWIndexBuffer
|
|
{
|
|
public:
|
|
~HWIndexBuffer();
|
|
|
|
uint16_t *Lock();
|
|
void Unlock();
|
|
|
|
int Buffer = 0;
|
|
int Size = 0;
|
|
|
|
private:
|
|
int LockedOldBinding = 0;
|
|
};
|
|
|
|
class HWPixelShader
|
|
{
|
|
public:
|
|
~HWPixelShader();
|
|
|
|
int Program = 0;
|
|
int VertexShader = 0;
|
|
int FragmentShader = 0;
|
|
|
|
int ConstantLocations[NumPSCONST];
|
|
int ImageLocation = -1;
|
|
int PaletteLocation = -1;
|
|
int NewScreenLocation = -1;
|
|
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);
|
|
void SetGammaRamp(const GammaRamp *ramp);
|
|
void SetPixelShaderConstantF(int uniformIndex, const float *data, int vec4fcount);
|
|
void SetHWPixelShader(HWPixelShader *shader);
|
|
void SetStreamSource(HWVertexBuffer *vertexBuffer);
|
|
void SetIndices(HWIndexBuffer *indexBuffer);
|
|
void DrawTriangleFans(int count, const FBVERTEX *vertices);
|
|
void DrawTriangleFans(int count, const BURNVERTEX *vertices);
|
|
void DrawPoints(int count, const FBVERTEX *vertices);
|
|
void DrawLineList(int count);
|
|
void DrawTriangleList(int minIndex, int numVertices, int startIndex, int primitiveCount);
|
|
void Present();
|
|
|
|
static void BgraToRgba(uint32_t *dest, const uint32_t *src, int width, int height, int srcpitch);
|
|
|
|
void BindFBBuffer();
|
|
void *MappedMemBuffer = nullptr;
|
|
bool UseMappedMemBuffer = true;
|
|
|
|
static uint32_t ColorARGB(uint32_t a, uint32_t r, uint32_t g, uint32_t b) { return ((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | ((b) & 0xff); }
|
|
static uint32_t ColorRGBA(uint32_t r, uint32_t g, uint32_t b, uint32_t a) { return ColorARGB(a, r, g, b); }
|
|
static uint32_t ColorXRGB(uint32_t r, uint32_t g, uint32_t b) { return ColorARGB(0xff, r, g, b); }
|
|
static uint32_t ColorValue(float r, float g, float b, float a) { return ColorRGBA((uint32_t)(r * 255.0f), (uint32_t)(g * 255.0f), (uint32_t)(b * 255.0f), (uint32_t)(a * 255.0f)); }
|
|
|
|
static void *MapBuffer(int target, int size);
|
|
|
|
// The number of points for the vertex buffer.
|
|
enum { NUM_VERTS = 10240 };
|
|
|
|
// The number of indices for the index buffer.
|
|
enum { NUM_INDEXES = ((NUM_VERTS * 6) / 4) };
|
|
|
|
// The number of quads we can batch together.
|
|
enum { MAX_QUAD_BATCH = (NUM_INDEXES / 6) };
|
|
|
|
// The default size for a texture atlas.
|
|
enum { DEF_ATLAS_WIDTH = 512 };
|
|
enum { DEF_ATLAS_HEIGHT = 512 };
|
|
|
|
// 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;
|
|
HWTexture *Tex;
|
|
int Format;
|
|
PackedTexture *UsedList; // Boxes that contain images
|
|
int Width, Height;
|
|
bool OneUse;
|
|
};
|
|
|
|
class OpenGLTex : public FNativeTexture
|
|
{
|
|
public:
|
|
OpenGLTex(FTexture *tex, OpenGLSWFrameBuffer *fb, bool wrapping);
|
|
~OpenGLTex();
|
|
|
|
FTexture *GameTex;
|
|
PackedTexture *Box;
|
|
|
|
OpenGLTex **Prev;
|
|
OpenGLTex *Next;
|
|
|
|
bool IsGray;
|
|
|
|
bool Create(OpenGLSWFrameBuffer *fb, bool wrapping);
|
|
bool Update();
|
|
bool CheckWrapping(bool wrapping);
|
|
int GetTexFormat();
|
|
FTextureFormat ToTexFmt(int fmt);
|
|
};
|
|
|
|
class OpenGLPal : public FNativePalette
|
|
{
|
|
public:
|
|
OpenGLPal(FRemapTable *remap, OpenGLSWFrameBuffer *fb);
|
|
~OpenGLPal();
|
|
|
|
OpenGLPal **Prev;
|
|
OpenGLPal *Next;
|
|
|
|
HWTexture *Tex;
|
|
uint32_t BorderColor;
|
|
bool DoColorSkip;
|
|
|
|
bool Update();
|
|
|
|
FRemapTable *Remap;
|
|
int RoundedPaletteSize;
|
|
};
|
|
|
|
// Flags for a buffered quad
|
|
enum
|
|
{
|
|
BQF_GamePalette = 1,
|
|
BQF_CustomPalette = 7,
|
|
BQF_Paletted = 7,
|
|
BQF_Bilinear = 8,
|
|
BQF_WrapUV = 16,
|
|
BQF_InvertSource = 32,
|
|
BQF_DisableAlphaTest = 64,
|
|
BQF_Desaturated = 128,
|
|
};
|
|
|
|
// Shaders for a buffered quad
|
|
enum
|
|
{
|
|
BQS_PalTex,
|
|
BQS_Plain,
|
|
BQS_RedToAlpha,
|
|
BQS_ColorOnly,
|
|
BQS_SpecialColormap,
|
|
BQS_InGameColormap,
|
|
};
|
|
|
|
struct BufferedTris
|
|
{
|
|
uint8_t Flags;
|
|
uint8_t ShaderNum;
|
|
int BlendOp;
|
|
int SrcBlend;
|
|
int DestBlend;
|
|
|
|
uint8_t Desat;
|
|
OpenGLPal *Palette;
|
|
HWTexture *Texture;
|
|
uint16_t NumVerts; // Number of _unique_ vertices used by this set.
|
|
uint16_t NumTris; // Number of triangles used by this set.
|
|
|
|
void ClearSetup()
|
|
{
|
|
Flags = 0;
|
|
ShaderNum = 0;
|
|
BlendOp = 0;
|
|
SrcBlend = 0;
|
|
DestBlend = 0;
|
|
}
|
|
|
|
bool IsSameSetup(const BufferedTris &other) const
|
|
{
|
|
return Flags == other.Flags && ShaderNum == other.ShaderNum && BlendOp == other.BlendOp && SrcBlend == other.SrcBlend && DestBlend == other.DestBlend;
|
|
}
|
|
};
|
|
|
|
enum
|
|
{
|
|
SHADER_NormalColor,
|
|
SHADER_NormalColorPal,
|
|
SHADER_NormalColorInv,
|
|
SHADER_NormalColorPalInv,
|
|
|
|
SHADER_RedToAlpha,
|
|
SHADER_RedToAlphaInv,
|
|
|
|
SHADER_VertexColor,
|
|
|
|
SHADER_SpecialColormap,
|
|
SHADER_SpecialColormapPal,
|
|
|
|
SHADER_InGameColormap,
|
|
SHADER_InGameColormapDesat,
|
|
SHADER_InGameColormapInv,
|
|
SHADER_InGameColormapInvDesat,
|
|
SHADER_InGameColormapPal,
|
|
SHADER_InGameColormapPalDesat,
|
|
SHADER_InGameColormapPalInv,
|
|
SHADER_InGameColormapPalInvDesat,
|
|
|
|
SHADER_BurnWipe,
|
|
SHADER_GammaCorrection,
|
|
|
|
NUM_SHADERS
|
|
};
|
|
static const char *const ShaderDefines[NUM_SHADERS];
|
|
|
|
void Flip();
|
|
void SetInitialState();
|
|
bool CreateResources();
|
|
void ReleaseResources();
|
|
bool LoadShaders();
|
|
bool CreateFBTexture();
|
|
bool CreatePaletteTexture();
|
|
bool CreateVertexes();
|
|
void UploadPalette();
|
|
void CalcFullscreenCoords(FBVERTEX verts[4], bool viewarea_only, uint32_t color0, uint32_t color1) const;
|
|
bool Reset();
|
|
HWTexture *CopyCurrentScreen();
|
|
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);
|
|
static int GetStyleAlpha(int type);
|
|
static void SetColorOverlay(uint32_t color, float alpha, uint32_t &color0, uint32_t &color1);
|
|
void AddColorOnlyQuad(int left, int top, int width, int height, uint32_t color);
|
|
void AddColorOnlyRect(int left, int top, int width, int height, uint32_t color);
|
|
void CheckQuadBatch(int numtris = 2, int numverts = 4);
|
|
void BeginQuadBatch();
|
|
void EndQuadBatch();
|
|
void BeginLineBatch();
|
|
void EndLineBatch();
|
|
void EndBatch();
|
|
|
|
// State
|
|
void EnableAlphaTest(bool enabled);
|
|
void SetAlphaBlend(int op, int srcblend = 0, int destblend = 0);
|
|
void SetConstant(int cnum, float r, float g, float b, float a);
|
|
void SetPixelShader(HWPixelShader *shader);
|
|
void SetTexture(int tnum, HWTexture *texture);
|
|
void SetSamplerWrapS(int tnum, int mode);
|
|
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;
|
|
|
|
std::unique_ptr<HWVertexBuffer> StreamVertexBuffer, StreamVertexBufferBurn;
|
|
float ShaderConstants[NumPSCONST * 4];
|
|
HWPixelShader *CurrentShader = nullptr;
|
|
|
|
HWFrameBuffer *OutputFB = nullptr;
|
|
|
|
bool AlphaTestEnabled = false;
|
|
bool AlphaBlendEnabled = false;
|
|
int AlphaBlendOp = 0;
|
|
int AlphaSrcBlend = 0;
|
|
int AlphaDestBlend = 0;
|
|
float Constant[3][4];
|
|
uint32_t CurBorderColor;
|
|
HWPixelShader *CurPixelShader;
|
|
HWTexture *Texture[5];
|
|
int SamplerWrapS[5], SamplerWrapT[5];
|
|
|
|
PalEntry SourcePalette[256];
|
|
uint32_t BorderColor;
|
|
uint32_t FlashColor0, FlashColor1;
|
|
PalEntry FlashColor;
|
|
int FlashAmount;
|
|
int TrueHeight;
|
|
int PixelDoubling;
|
|
float Gamma;
|
|
bool UpdatePending;
|
|
bool NeedPalUpdate;
|
|
bool NeedGammaUpdate;
|
|
LTRBRect BlendingRect;
|
|
int In2D;
|
|
bool InScene;
|
|
bool GatheringWipeScreen;
|
|
bool AALines;
|
|
uint8_t BlockNum;
|
|
OpenGLPal *Palettes = nullptr;
|
|
OpenGLTex *Textures = nullptr;
|
|
Atlas *Atlases = nullptr;
|
|
|
|
HWTexture *FBTexture = nullptr;
|
|
HWTexture *PaletteTexture = nullptr;
|
|
HWTexture *ScreenshotTexture = nullptr;
|
|
|
|
HWVertexBuffer *VertexBuffer = nullptr;
|
|
FBVERTEX *VertexData = nullptr;
|
|
HWIndexBuffer *IndexBuffer = nullptr;
|
|
uint16_t *IndexData = nullptr;
|
|
BufferedTris *QuadExtra = nullptr;
|
|
int VertexPos;
|
|
int IndexPos;
|
|
int QuadBatchPos;
|
|
enum { BATCH_None, BATCH_Quads, BATCH_Lines } BatchType;
|
|
|
|
HWPixelShader *Shaders[NUM_SHADERS];
|
|
|
|
HWTexture *InitialWipeScreen = nullptr, *FinalWipeScreen = nullptr;
|
|
|
|
class Wiper
|
|
{
|
|
public:
|
|
virtual ~Wiper();
|
|
virtual bool Run(int ticks, OpenGLSWFrameBuffer *fb) = 0;
|
|
|
|
void DrawScreen(OpenGLSWFrameBuffer *fb, HWTexture *tex, int blendop = 0, uint32_t color0 = 0, uint32_t color1 = 0xFFFFFFF);
|
|
};
|
|
|
|
class Wiper_Melt; friend class Wiper_Melt;
|
|
class Wiper_Burn; friend class Wiper_Burn;
|
|
class Wiper_Crossfade; friend class Wiper_Crossfade;
|
|
|
|
Wiper *ScreenWipe;
|
|
};
|
|
|
|
|
|
#endif //__GL_SWFRAMEBUFFER
|