zdoom
/
qzdoom
mirror of https://github.com/ZDoom/qzdoom.git
0
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- stripped out the entire software 2D renderer and moved all 2D drawing functions to DFrameBuffer so that they cannot be used with software DSimpleCanvas anymore.

This commit is contained in:
Christoph Oelckers 2018-03-26 23:16:27 +02:00
parent e0039179cb
commit d650e37497
10 changed files with 283 additions and 765 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/d_main.cpp
View File

@ -833,7 +833,7 @@ void D_Display ()
} }
if (!automapactive || viewactive) if (!automapactive || viewactive)
{ {
V_RefreshViewBorder (); screen->RefreshViewBorder ();
} }
// for timing the statusbar code. // for timing the statusbar code.

402
src/f_wipe.cpp
View File

@ -32,148 +32,6 @@
#include "templates.h" #include "templates.h"
#include "v_palette.h" #include "v_palette.h"
EXTERN_CVAR(Bool, r_blendmethod)
//
// SCREEN WIPE PACKAGE
//
static int CurrentWipeType;
static short *wipe_scr_start;
static short *wipe_scr_end;
static int *y;
// [RH] Fire Wipe
#define FIREWIDTH 64
#define FIREHEIGHT 64
static uint8_t *burnarray;
static int density;
static int burntime;
// [RH] Crossfade
static int fade;
// Melt -------------------------------------------------------------
// Match the strip sizes that oldschool Doom used on a 320x200 screen.
#define MELT_WIDTH 160
#define MELT_HEIGHT 200
void wipe_shittyColMajorXform (short *array)
{
int x, y;
short *dest;
int width = SCREENWIDTH / 2;
dest = new short[width*SCREENHEIGHT*2];
for(y = 0; y < SCREENHEIGHT; y++)
for(x = 0; x < width; x++)
dest[x*SCREENHEIGHT+y] = array[y*width+x];
memcpy(array, dest, SCREENWIDTH*SCREENHEIGHT);
delete[] dest;
}
bool wipe_initMelt (int ticks)
{
int i, r;
// copy start screen to main screen
screen->DrawBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_start);
// makes this wipe faster (in theory)
// to have stuff in column-major format
wipe_shittyColMajorXform (wipe_scr_start);
wipe_shittyColMajorXform (wipe_scr_end);
// setup initial column positions
// (y<0 => not ready to scroll yet)
y = new int[MELT_WIDTH];
y[0] = -(M_Random() & 15);
for (i = 1; i < MELT_WIDTH; i++)
{
r = (M_Random()%3) - 1;
y[i] = clamp(y[i-1] + r, -15, 0);
}
return 0;
}
bool wipe_doMelt (int ticks)
{
int i, j, dy, x;
const short *s;
short *d;
bool done = true;
while (ticks--)
{
done = true;
for (i = 0; i < MELT_WIDTH; i++)
{
if (y[i] < 0)
{
y[i]++;
done = false;
}
else if (y[i] < MELT_HEIGHT)
{
dy = (y[i] < 16) ? y[i]+1 : 8;
y[i] = MIN(y[i] + dy, MELT_HEIGHT);
done = false;
}
if (ticks == 0 && y[i] >= 0)
{ // Only draw for the final tick.
const int pitch = screen->GetPitch() / 2;
int sy = y[i] * SCREENHEIGHT / MELT_HEIGHT;
for (x = i * (SCREENWIDTH/2) / MELT_WIDTH; x < (i + 1) * (SCREENWIDTH/2) / MELT_WIDTH; ++x)
{
s = &wipe_scr_end[x*SCREENHEIGHT];
d = &((short *)screen->GetBuffer())[x];
for (j = sy; j != 0; --j)
{
*d = *(s++);
d += pitch;
}
s = &wipe_scr_start[x*SCREENHEIGHT];
for (j = SCREENHEIGHT - sy; j != 0; --j)
{
*d = *(s++);
d += pitch;
}
}
}
}
}
return done;
}
bool wipe_exitMelt (int ticks)
{
delete[] y;
return 0;
}
// Burn -------------------------------------------------------------
bool wipe_initBurn (int ticks)
{
burnarray = new uint8_t[FIREWIDTH * (FIREHEIGHT+5)];
memset (burnarray, 0, FIREWIDTH * (FIREHEIGHT+5));
density = 4;
burntime = 0;
return 0;
}
int wipe_CalcBurn (uint8_t *burnarray, int width, int height, int density) int wipe_CalcBurn (uint8_t *burnarray, int width, int height, int density)
{ {
// This is a modified version of the fire that was once used // This is a modified version of the fire that was once used
@ -258,263 +116,3 @@ int wipe_CalcBurn (uint8_t *burnarray, int width, int height, int density)
return -1; return -1;
} }
bool wipe_doBurn (int ticks)
{
bool done;
burntime += ticks;
ticks *= 2;
// Make the fire burn
done = false;
while (!done && ticks--)
{
density = wipe_CalcBurn(burnarray, FIREWIDTH, FIREHEIGHT, density);
done = (density < 0);
}
// Draw the screen
int xstep, ystep, firex, firey;
int x, y;
uint8_t *to, *fromold, *fromnew;
const int SHIFT = 16;
xstep = (FIREWIDTH << SHIFT) / SCREENWIDTH;
ystep = (FIREHEIGHT << SHIFT) / SCREENHEIGHT;
to = screen->GetBuffer();
fromold = (uint8_t *)wipe_scr_start;
fromnew = (uint8_t *)wipe_scr_end;
if (!r_blendmethod)
{
for (y = 0, firey = 0; y < SCREENHEIGHT; y++, firey += ystep)
{
for (x = 0, firex = 0; x < SCREENWIDTH; x++, firex += xstep)
{
int fglevel;
fglevel = burnarray[(firex>>SHIFT)+(firey>>SHIFT)*FIREWIDTH] / 2;
if (fglevel >= 63)
{
to[x] = fromnew[x];
}
else if (fglevel == 0)
{
to[x] = fromold[x];
done = false;
}
else
{
int bglevel = 64-fglevel;
uint32_t *fg2rgb = Col2RGB8[fglevel];
uint32_t *bg2rgb = Col2RGB8[bglevel];
uint32_t fg = fg2rgb[fromnew[x]];
uint32_t bg = bg2rgb[fromold[x]];
fg = (fg+bg) | 0x1f07c1f;
to[x] = RGB32k.All[fg & (fg>>15)];
done = false;
}
}
fromold += SCREENWIDTH;
fromnew += SCREENWIDTH;
to += SCREENPITCH;
}
}
else
{
for (y = 0, firey = 0; y < SCREENHEIGHT; y++, firey += ystep)
{
for (x = 0, firex = 0; x < SCREENWIDTH; x++, firex += xstep)
{
int fglevel;
fglevel = burnarray[(firex>>SHIFT)+(firey>>SHIFT)*FIREWIDTH] / 2;
if (fglevel >= 63)
{
to[x] = fromnew[x];
}
else if (fglevel == 0)
{
to[x] = fromold[x];
done = false;
}
else
{
int bglevel = 64-fglevel;
const PalEntry* pal = GPalette.BaseColors;
uint32_t fg = fromnew[x];
uint32_t bg = fromold[x];
int r = MIN((pal[fg].r * fglevel + pal[bg].r * bglevel) >> 8, 63);
int g = MIN((pal[fg].g * fglevel + pal[bg].g * bglevel) >> 8, 63);
int b = MIN((pal[fg].b * fglevel + pal[bg].b * bglevel) >> 8, 63);
to[x] = RGB256k.RGB[r][g][b];
done = false;
}
}
fromold += SCREENWIDTH;
fromnew += SCREENWIDTH;
to += SCREENPITCH;
}
}
return done || (burntime > 40);
}
bool wipe_exitBurn (int ticks)
{
delete[] burnarray;
return 0;
}
// Crossfade --------------------------------------------------------
bool wipe_initFade (int ticks)
{
fade = 0;
return 0;
}
bool wipe_doFade (int ticks)
{
fade += ticks * 2;
if (fade > 64)
{
screen->DrawBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_end);
return true;
}
else
{
int x, y;
int bglevel = 64 - fade;
uint32_t *fg2rgb = Col2RGB8[fade];
uint32_t *bg2rgb = Col2RGB8[bglevel];
uint8_t *fromnew = (uint8_t *)wipe_scr_end;
uint8_t *fromold = (uint8_t *)wipe_scr_start;
uint8_t *to = screen->GetBuffer();
const PalEntry *pal = GPalette.BaseColors;
if (!r_blendmethod)
{
for (y = 0; y < SCREENHEIGHT; y++)
{
for (x = 0; x < SCREENWIDTH; x++)
{
uint32_t fg = fg2rgb[fromnew[x]];
uint32_t bg = bg2rgb[fromold[x]];
fg = (fg+bg) | 0x1f07c1f;
to[x] = RGB32k.All[fg & (fg>>15)];
}
fromnew += SCREENWIDTH;
fromold += SCREENWIDTH;
to += SCREENPITCH;
}
}
else
{
for (y = 0; y < SCREENHEIGHT; y++)
{
for (x = 0; x < SCREENWIDTH; x++)
{
uint32_t fg = fromnew[x];
uint32_t bg = fromold[x];
int r = MIN((pal[fg].r * (64-bglevel) + pal[bg].r * bglevel) >> 8, 63);
int g = MIN((pal[fg].g * (64-bglevel) + pal[bg].g * bglevel) >> 8, 63);
int b = MIN((pal[fg].b * (64-bglevel) + pal[bg].b * bglevel) >> 8, 63);
to[x] = RGB256k.RGB[r][g][b];
}
fromnew += SCREENWIDTH;
fromold += SCREENWIDTH;
to += SCREENPITCH;
}
}
}
return false;
}
bool wipe_exitFade (int ticks)
{
return 0;
}
// General Wipe Functions -------------------------------------------
static bool (*wipes[])(int) =
{
wipe_initMelt, wipe_doMelt, wipe_exitMelt,
wipe_initBurn, wipe_doBurn, wipe_exitBurn,
wipe_initFade, wipe_doFade, wipe_exitFade
};
// Returns true if the wipe should be performed.
bool wipe_StartScreen (int type)
{
if (screen->IsBgra())
return false;
CurrentWipeType = clamp(type, 0, wipe_NUMWIPES - 1);
if (CurrentWipeType)
{
wipe_scr_start = new short[SCREENWIDTH * SCREENHEIGHT / 2];
screen->GetBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_start);
return true;
}
return false;
}
void wipe_EndScreen (void)
{
if (screen->IsBgra())
return;
if (CurrentWipeType)
{
wipe_scr_end = new short[SCREENWIDTH * SCREENHEIGHT / 2];
screen->GetBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_end);
screen->DrawBlock (0, 0, SCREENWIDTH, SCREENHEIGHT, (uint8_t *)wipe_scr_start); // restore start scr.
// Initialize the wipe
(*wipes[(CurrentWipeType-1)*3])(0);
}
}
// Returns true if the wipe is done.
bool wipe_ScreenWipe (int ticks)
{
bool rc;
if (screen->IsBgra())
return true;
if (CurrentWipeType == wipe_None)
return true;
// do a piece of wipe-in
rc = (*wipes[(CurrentWipeType-1)*3+1])(ticks);
return rc;
}
// Final things for the wipe
void wipe_Cleanup()
{
if (screen->IsBgra())
return;
if (wipe_scr_start != NULL)
{
delete[] wipe_scr_start;
wipe_scr_start = NULL;
}
if (wipe_scr_end != NULL)
{
delete[] wipe_scr_end;
wipe_scr_end = NULL;
}
if (CurrentWipeType > 0)
{
(*wipes[(CurrentWipeType-1)*3+2])(0);
}
}

4
src/f_wipe.h
View File

@ -30,6 +30,7 @@
// SCREEN WIPE PACKAGE // SCREEN WIPE PACKAGE
// //
#if 0
bool wipe_StartScreen (int type); bool wipe_StartScreen (int type);
void wipe_EndScreen (void); void wipe_EndScreen (void);
bool wipe_ScreenWipe (int ticks); bool wipe_ScreenWipe (int ticks);
@ -37,7 +38,8 @@ void wipe_Cleanup ();
// The buffer must have an additional 5 rows not included in height // The buffer must have an additional 5 rows not included in height
// to use for a seeding area. // to use for a seeding area.
int wipe_CalcBurn (uint8_t *buffer, int width, int height, int density); #endif
int wipe_CalcBurn(uint8_t *buffer, int width, int height, int density);
enum enum
{ {

8
src/g_statusbar/shared_sbar.cpp
View File

@ -835,8 +835,8 @@ void DBaseStatusBar::RefreshBackground () const
{ {
if(y < SCREENHEIGHT) if(y < SCREENHEIGHT)
{ {
V_DrawBorder (x+1, y, SCREENWIDTH, y+1); screen->DrawBorder (x+1, y, SCREENWIDTH, y+1);
V_DrawBorder (x+1, SCREENHEIGHT-1, SCREENWIDTH, SCREENHEIGHT); screen->DrawBorder (x+1, SCREENHEIGHT-1, SCREENWIDTH, SCREENHEIGHT);
} }
} }
else else
@ -855,8 +855,8 @@ void DBaseStatusBar::RefreshBackground () const
x2 = SCREENWIDTH; x2 = SCREENWIDTH;
} }
V_DrawBorder (0, y, x+1, SCREENHEIGHT); screen->DrawBorder (0, y, x+1, SCREENHEIGHT);
V_DrawBorder (x2-1, y, SCREENWIDTH, SCREENHEIGHT); screen->DrawBorder (x2-1, y, SCREENWIDTH, SCREENHEIGHT);
if (setblocks >= 10) if (setblocks >= 10)
{ {

22
src/swrenderer/r_swcanvas.h
View File

@ -1,22 +0,0 @@
#pragma once
#include "v_video.h"
#include "r_data/colormaps.h"
class SWCanvas
{
public:
static void DrawTexture(DCanvas *canvas, FTexture *img, DrawParms &parms);
static void FillSimplePoly(DCanvas *canvas, FTexture *tex, FVector2 *points, int npoints,
double originx, double originy, double scalex, double scaley, DAngle rotation,
const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip);
static void DrawLine(DCanvas *canvas, int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor);
static void DrawPixel(DCanvas *canvas, int x, int y, int palColor, uint32_t realcolor);
static void Clear(DCanvas *canvas, int left, int top, int right, int bottom, int palcolor, uint32_t color);
static void Dim(DCanvas *canvas, PalEntry color, float damount, int x1, int y1, int w, int h);
private:
static void PUTTRANSDOT(DCanvas *canvas, int xx, int yy, int basecolor, int level);
static int PalFromRGB(uint32_t rgb);
};

10
src/swrenderer/scene/r_portal.cpp
View File

@ -69,7 +69,9 @@
#include "swrenderer/r_renderthread.h" #include "swrenderer/r_renderthread.h"
CVAR(Int, r_portal_recursions, 4, CVAR_ARCHIVE) CVAR(Int, r_portal_recursions, 4, CVAR_ARCHIVE)
CVAR(Bool, r_highlight_portals, false, CVAR_ARCHIVE) #if 0
CVAR(Bool, r_highlight_portals, false, 0)
#endif
CVAR(Bool, r_skyboxes, true, 0) CVAR(Bool, r_skyboxes, true, 0)
// Avoid infinite recursion with stacked sectors by limiting them. // Avoid infinite recursion with stacked sectors by limiting them.
@ -321,8 +323,10 @@ namespace swrenderer
} }
} }
#if 0
if (r_highlight_portals) if (r_highlight_portals)
RenderLinePortalHighlight(pds); RenderLinePortalHighlight(pds);
#endif
return; return;
} }
@ -462,9 +466,11 @@ namespace swrenderer
Thread->Clip3D->LeaveSkybox(); // pop 3D floor height map Thread->Clip3D->LeaveSkybox(); // pop 3D floor height map
CurrentPortalUniq = prevuniq2; CurrentPortalUniq = prevuniq2;
#if 0
// draw a red line around a portal if it's being highlighted // draw a red line around a portal if it's being highlighted
if (r_highlight_portals) if (r_highlight_portals)
RenderLinePortalHighlight(pds); RenderLinePortalHighlight(pds);
#endif
CurrentPortal = prevpds; CurrentPortal = prevpds;
MirrorFlags = prevmf; MirrorFlags = prevmf;
@ -474,6 +480,7 @@ namespace swrenderer
viewpoint.Path[1] = savedpath[1]; viewpoint.Path[1] = savedpath[1];
} }
#if 0
void RenderPortal::RenderLinePortalHighlight(PortalDrawseg* pds) void RenderPortal::RenderLinePortalHighlight(PortalDrawseg* pds)
{ {
// [ZZ] NO OVERFLOW CHECKS HERE // [ZZ] NO OVERFLOW CHECKS HERE
@ -515,6 +522,7 @@ namespace swrenderer
else *(pixels + Ybottom * viewport->RenderTarget->GetPitch() + x) = color; else *(pixels + Ybottom * viewport->RenderTarget->GetPitch() + x) = color;
} }
} }
#endif
void RenderPortal::CopyStackedViewParameters() void RenderPortal::CopyStackedViewParameters()
{ {

364
src/v_draw.cpp
View File

@ -32,8 +32,6 @@
** **
*/ */
// #define NO_SWRENDER // set this if you want to exclude the software renderer. Without the software renderer software canvas drawing does nothing.
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
@ -43,9 +41,6 @@
#include "r_defs.h" #include "r_defs.h"
#include "r_utility.h" #include "r_utility.h"
#include "r_renderer.h" #include "r_renderer.h"
#ifndef NO_SWRENDER
#include "swrenderer/r_swcanvas.h"
#endif
#include "r_data/r_translate.h" #include "r_data/r_translate.h"
#include "doomstat.h" #include "doomstat.h"
#include "v_palette.h" #include "v_palette.h"
@ -64,6 +59,19 @@
#include "textures.h" #include "textures.h"
#include "vm.h" #include "vm.h"
CUSTOM_CVAR(Float, dimamount, -1.f, CVAR_ARCHIVE)
{
if (self < 0.f && self != -1.f)
{
self = -1.f;
}
else if (self > 1.f)
{
self = 1.f;
}
}
CVAR(Color, dimcolor, 0xffd700, CVAR_ARCHIVE)
CUSTOM_CVAR(Int, uiscale, 0, CVAR_ARCHIVE | CVAR_NOINITCALL) CUSTOM_CVAR(Int, uiscale, 0, CVAR_ARCHIVE | CVAR_NOINITCALL)
{ {
if (self < 0) if (self < 0)
@ -109,6 +117,12 @@ int CleanWidth, CleanHeight;
int CleanXfac_1, CleanYfac_1, CleanWidth_1, CleanHeight_1; int CleanXfac_1, CleanYfac_1, CleanWidth_1, CleanHeight_1;
//==========================================================================
//
// ZScript wrappers for inlines
//
//==========================================================================
DEFINE_ACTION_FUNCTION(_Screen, GetWidth) DEFINE_ACTION_FUNCTION(_Screen, GetWidth)
{ {
PARAM_PROLOGUE; PARAM_PROLOGUE;
@ -130,7 +144,13 @@ DEFINE_ACTION_FUNCTION(_Screen, PaletteColor)
ACTION_RETURN_INT(index); ACTION_RETURN_INT(index);
} }
void DCanvas::DrawTexture (FTexture *img, double x, double y, int tags_first, ...) //==========================================================================
//
// Internal texture drawing function
//
//==========================================================================
void DFrameBuffer::DrawTexture (FTexture *img, double x, double y, int tags_first, ...)
{ {
Va_List tags; Va_List tags;
va_start(tags.list, tags_first); va_start(tags.list, tags_first);
@ -145,9 +165,15 @@ void DCanvas::DrawTexture (FTexture *img, double x, double y, int tags_first, ..
DrawTextureParms(img, parms); DrawTextureParms(img, parms);
} }
//==========================================================================
//
// ZScript texture drawing function
//
//==========================================================================
int ListGetInt(VMVa_List &tags); int ListGetInt(VMVa_List &tags);
void DCanvas::DrawTexture(FTexture *img, double x, double y, VMVa_List &args) void DFrameBuffer::DrawTexture(FTexture *img, double x, double y, VMVa_List &args)
{ {
DrawParms parms; DrawParms parms;
uint32_t tag = ListGetInt(args); uint32_t tag = ListGetInt(args);
@ -172,19 +198,23 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawTexture)
return 0; return 0;
} }
void DCanvas::DrawTextureParms(FTexture *img, DrawParms &parms) //==========================================================================
{ //
#ifndef NO_SWRENDER // common drawing function
SWCanvas::DrawTexture(this, img, parms); //
#endif //==========================================================================
if (ticdup != 0 && menuactive == MENU_Off) void DFrameBuffer::DrawTextureParms(FTexture *img, DrawParms &parms)
{ {
NetUpdate();
}
} }
void DCanvas::SetClipRect(int x, int y, int w, int h) //==========================================================================
//
// Clipping rect
//
//==========================================================================
void DFrameBuffer::SetClipRect(int x, int y, int w, int h)
{ {
clipleft = clamp(x, 0, GetWidth()); clipleft = clamp(x, 0, GetWidth());
clipwidth = clamp(w, -1, GetWidth() - x); clipwidth = clamp(w, -1, GetWidth() - x);
@ -210,7 +240,7 @@ DEFINE_ACTION_FUNCTION(_Screen, ClearClipRect)
return 0; return 0;
} }
void DCanvas::GetClipRect(int *x, int *y, int *w, int *h) void DFrameBuffer::GetClipRect(int *x, int *y, int *w, int *h)
{ {
if (x) *x = clipleft; if (x) *x = clipleft;
if (y) *y = cliptop; if (y) *y = cliptop;
@ -240,7 +270,13 @@ DEFINE_ACTION_FUNCTION(_Screen, GetViewWindow)
return MIN(numret, 4); return MIN(numret, 4);
} }
bool DCanvas::SetTextureParms(DrawParms *parms, FTexture *img, double xx, double yy) const //==========================================================================
//
// Draw parameter parsing
//
//==========================================================================
bool DFrameBuffer::SetTextureParms(DrawParms *parms, FTexture *img, double xx, double yy) const
{ {
if (img != NULL) if (img != NULL)
{ {
@ -322,6 +358,12 @@ bool DCanvas::SetTextureParms(DrawParms *parms, FTexture *img, double xx, double
return false; return false;
} }
//==========================================================================
//
// template helpers
//
//==========================================================================
static void ListEnd(Va_List &tags) static void ListEnd(Va_List &tags)
{ {
va_end(tags.list); va_end(tags.list);
@ -387,8 +429,14 @@ static inline FColormapStyle * ListGetColormapStyle(VMVa_List &tags)
return nullptr; return nullptr;
} }
//==========================================================================
//
// Main taglist parsing
//
//==========================================================================
template<class T> template<class T>
bool DCanvas::ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t tag, T& tags, DrawParms *parms, bool fortext) const bool DFrameBuffer::ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t tag, T& tags, DrawParms *parms, bool fortext) const
{ {
INTBOOL boolval; INTBOOL boolval;
int intval; int intval;
@ -836,10 +884,16 @@ bool DCanvas::ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t t
} }
// explicitly instantiate both versions for v_text.cpp. // explicitly instantiate both versions for v_text.cpp.
template bool DCanvas::ParseDrawTextureTags<Va_List>(FTexture *img, double x, double y, uint32_t tag, Va_List& tags, DrawParms *parms, bool fortext) const; template bool DFrameBuffer::ParseDrawTextureTags<Va_List>(FTexture *img, double x, double y, uint32_t tag, Va_List& tags, DrawParms *parms, bool fortext) const;
template bool DCanvas::ParseDrawTextureTags<VMVa_List>(FTexture *img, double x, double y, uint32_t tag, VMVa_List& tags, DrawParms *parms, bool fortext) const; template bool DFrameBuffer::ParseDrawTextureTags<VMVa_List>(FTexture *img, double x, double y, uint32_t tag, VMVa_List& tags, DrawParms *parms, bool fortext) const;
void DCanvas::VirtualToRealCoords(double &x, double &y, double &w, double &h, //==========================================================================
//
// Coordinate conversion
//
//==========================================================================
void DFrameBuffer::VirtualToRealCoords(double &x, double &y, double &w, double &h,
double vwidth, double vheight, bool vbottom, bool handleaspect) const double vwidth, double vheight, bool vbottom, bool handleaspect) const
{ {
float myratio = handleaspect ? ActiveRatio (Width, Height) : (4.0f / 3.0f); float myratio = handleaspect ? ActiveRatio (Width, Height) : (4.0f / 3.0f);
@ -899,7 +953,7 @@ DEFINE_ACTION_FUNCTION(_Screen, VirtualToRealCoords)
return MIN(numret, 2); return MIN(numret, 2);
} }
void DCanvas::VirtualToRealCoordsInt(int &x, int &y, int &w, int &h, void DFrameBuffer::VirtualToRealCoordsInt(int &x, int &y, int &w, int &h,
int vwidth, int vheight, bool vbottom, bool handleaspect) const int vwidth, int vheight, bool vbottom, bool handleaspect) const
{ {
double dx, dy, dw, dh; double dx, dy, dw, dh;
@ -915,7 +969,13 @@ void DCanvas::VirtualToRealCoordsInt(int &x, int &y, int &w, int &h,
h = int(dy + dh + 0.5) - y; h = int(dy + dh + 0.5) - y;
} }
void DCanvas::FillBorder (FTexture *img) //==========================================================================
//
//
//
//==========================================================================
void DFrameBuffer::FillBorder (FTexture *img)
{ {
float myratio = ActiveRatio (Width, Height); float myratio = ActiveRatio (Width, Height);
@ -961,11 +1021,14 @@ void DCanvas::FillBorder (FTexture *img)
} }
} }
void DCanvas::DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor) //==========================================================================
//
// Draw a line
//
//==========================================================================
void DFrameBuffer::DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor)
{ {
#ifndef NO_SWRENDER
SWCanvas::DrawLine(this, x0, y0, x1, y1, palColor, realcolor);
#endif
} }
DEFINE_ACTION_FUNCTION(_Screen, DrawLine) DEFINE_ACTION_FUNCTION(_Screen, DrawLine)
@ -981,11 +1044,14 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawLine)
return 0; return 0;
} }
void DCanvas::DrawPixel(int x, int y, int palColor, uint32_t realcolor) //==========================================================================
//
// Draw a single pixel
//
//==========================================================================
void DFrameBuffer::DrawPixel(int x, int y, int palColor, uint32_t realcolor)
{ {
#ifndef NO_SWRENDER
SWCanvas::DrawPixel(this, x, y, palColor, realcolor);
#endif
} }
//========================================================================== //==========================================================================
@ -996,21 +1062,11 @@ void DCanvas::DrawPixel(int x, int y, int palColor, uint32_t realcolor)
// //
//========================================================================== //==========================================================================
void DCanvas::DoClear (int left, int top, int right, int bottom, int palcolor, uint32_t color) void DFrameBuffer::DoClear (int left, int top, int right, int bottom, int palcolor, uint32_t color)
{ {
#ifndef NO_SWRENDER
if (palcolor < 0 && APART(color) != 255)
{
Dim(color, APART(color) / 255.f, left, top, right - left, bottom - top);
}
else
{
SWCanvas::Clear(this, left, top, right, bottom, palcolor, color);
}
#endif
} }
void DCanvas::Clear(int left, int top, int right, int bottom, int palcolor, uint32_t color) void DFrameBuffer::Clear(int left, int top, int right, int bottom, int palcolor, uint32_t color)
{ {
if (clipwidth >= 0 && clipheight >= 0) if (clipwidth >= 0 && clipheight >= 0)
{ {
@ -1059,14 +1115,11 @@ DEFINE_ACTION_FUNCTION(_Screen, Clear)
// //
//========================================================================== //==========================================================================
void DCanvas::DoDim(PalEntry color, float damount, int x1, int y1, int w, int h) void DFrameBuffer::DoDim(PalEntry color, float damount, int x1, int y1, int w, int h)
{ {
#ifndef NO_SWRENDER
SWCanvas::Dim(this, color, damount, x1, y1, w, h);
#endif
} }
void DCanvas::Dim(PalEntry color, float damount, int x1, int y1, int w, int h) void DFrameBuffer::Dim(PalEntry color, float damount, int x1, int y1, int w, int h)
{ {
if (clipwidth >= 0 && clipheight >= 0) if (clipwidth >= 0 && clipheight >= 0)
{ {
@ -1118,112 +1171,84 @@ DEFINE_ACTION_FUNCTION(_Screen, Dim)
// //
//========================================================================== //==========================================================================
void DCanvas::FillSimplePoly(FTexture *tex, FVector2 *points, int npoints, void DFrameBuffer::FillSimplePoly(FTexture *tex, FVector2 *points, int npoints,
double originx, double originy, double scalex, double scaley, DAngle rotation, double originx, double originy, double scalex, double scaley, DAngle rotation,
const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip) const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip)
{ {
#ifndef NO_SWRENDER
SWCanvas::FillSimplePoly(this, tex, points, npoints, originx, originy, scalex, scaley, rotation, colormap, flatcolor, lightlevel, bottomclip);
#endif
} }
//==========================================================================
/********************************/
/* */
/* Other miscellaneous routines */
/* */
/********************************/
// //
// V_DrawBlock // DCanvas :: FlatFill
// Draw a linear block of pixels into the view buffer.
// //
void DCanvas::DrawBlock (int x, int y, int _width, int _height, const uint8_t *src) const // Fill an area with a texture. If local_origin is false, then the origin
// used for the wrapping is (0,0). Otherwise, (left,right) is used.
//
//==========================================================================
void DFrameBuffer::FlatFill(int left, int top, int right, int bottom, FTexture *src, bool local_origin)
{ {
if (IsBgra()) int w = src->GetWidth();
return; int h = src->GetHeight();
int srcpitch = _width; // Repeatedly draw the texture, left-to-right, top-to-bottom.
int destpitch; for (int y = local_origin ? top : (top / h * h); y < bottom; y += h)
uint8_t *dest;
if (ClipBox (x, y, _width, _height, src, srcpitch))
{ {
return; // Nothing to draw for (int x = local_origin ? left : (left / w * w); x < right; x += w)
{
DrawTexture(src, x, y,
DTA_ClipLeft, left,
DTA_ClipRight, right,
DTA_ClipTop, top,
DTA_ClipBottom, bottom,
DTA_TopOffset, 0,
DTA_LeftOffset, 0,
TAG_DONE);
}
} }
destpitch = Pitch;
dest = Buffer + y*Pitch + x;
do
{
memcpy (dest, src, _width);
src += srcpitch;
dest += destpitch;
} while (--_height);
} }
//==========================================================================
// //
// V_GetBlock // DCanvas :: Dim
// Gets a linear block of pixels from the view buffer.
// //
void DCanvas::GetBlock (int x, int y, int _width, int _height, uint8_t *dest) const // Applies a colored overlay to the entire screen, with the opacity
// determined by the dimamount cvar.
//
//==========================================================================
void DFrameBuffer::Dim(PalEntry color)
{ {
if (IsBgra()) PalEntry dimmer;
return; float amount;
const uint8_t *src; if (dimamount >= 0)
#ifdef RANGECHECK
if (x<0
||x+_width > Width
|| y<0
|| y+_height>Height)
{ {
I_Error ("Bad V_GetBlock"); dimmer = PalEntry(dimcolor);
amount = dimamount;
} }
#endif else
src = Buffer + y*Pitch + x;
while (_height--)
{ {
memcpy (dest, src, _width); dimmer = gameinfo.dimcolor;
src += Pitch; amount = gameinfo.dimamount;
dest += _width;
} }
if (gameinfo.gametype == GAME_Hexen && gamestate == GS_DEMOSCREEN)
{ // On the Hexen title screen, the default dimming is not
// enough to make the menus readable.
amount = MIN<float>(1.f, amount*2.f);
}
// Add the cvar's dimming on top of the color passed to the function
if (color.a != 0)
{
float dim[4] = { color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f };
V_AddBlend(dimmer.r / 255.f, dimmer.g / 255.f, dimmer.b / 255.f, amount, dim);
dimmer = PalEntry(uint8_t(dim[0] * 255), uint8_t(dim[1] * 255), uint8_t(dim[2] * 255));
amount = dim[3];
}
Dim(dimmer, amount, 0, 0, Width, Height);
} }
// Returns true if the box was completely clipped. False otherwise.
bool DCanvas::ClipBox (int &x, int &y, int &w, int &h, const uint8_t *&src, const int srcpitch) const
{
if (x >= Width || y >= Height || x+w <= 0 || y+h <= 0)
{ // Completely clipped off screen
return true;
}
if (x < 0) // clip left edge
{
src -= x;
w += x;
x = 0;
}
if (x+w > Width) // clip right edge
{
w = Width - x;
}
if (y < 0) // clip top edge
{
src -= y*srcpitch;
h += y;
y = 0;
}
if (y+h > Height) // clip bottom edge
{
h = Height - y;
}
return false;
}
//========================================================================== //==========================================================================
// //
@ -1251,7 +1276,7 @@ void V_SetBorderNeedRefresh()
// //
//========================================================================== //==========================================================================
void V_DrawFrame (int left, int top, int width, int height) void DFrameBuffer::DrawFrame (int left, int top, int width, int height)
{ {
FTexture *p; FTexture *p;
const gameborder_t *border = &gameinfo.Border; const gameborder_t *border = &gameinfo.Border;
@ -1264,21 +1289,21 @@ void V_DrawFrame (int left, int top, int width, int height)
// Draw top and bottom sides. // Draw top and bottom sides.
p = TexMan[border->t]; p = TexMan[border->t];
screen->FlatFill(left, top - p->GetHeight(), right, top, p, true); FlatFill(left, top - p->GetHeight(), right, top, p, true);
p = TexMan[border->b]; p = TexMan[border->b];
screen->FlatFill(left, bottom, right, bottom + p->GetHeight(), p, true); FlatFill(left, bottom, right, bottom + p->GetHeight(), p, true);
// Draw left and right sides. // Draw left and right sides.
p = TexMan[border->l]; p = TexMan[border->l];
screen->FlatFill(left - p->GetWidth(), top, left, bottom, p, true); FlatFill(left - p->GetWidth(), top, left, bottom, p, true);
p = TexMan[border->r]; p = TexMan[border->r];
screen->FlatFill(right, top, right + p->GetWidth(), bottom, p, true); FlatFill(right, top, right + p->GetWidth(), bottom, p, true);
// Draw beveled corners. // Draw beveled corners.
screen->DrawTexture (TexMan[border->tl], left-offset, top-offset, TAG_DONE); DrawTexture (TexMan[border->tl], left-offset, top-offset, TAG_DONE);
screen->DrawTexture (TexMan[border->tr], left+width, top-offset, TAG_DONE); DrawTexture (TexMan[border->tr], left+width, top-offset, TAG_DONE);
screen->DrawTexture (TexMan[border->bl], left-offset, top+height, TAG_DONE); DrawTexture (TexMan[border->bl], left-offset, top+height, TAG_DONE);
screen->DrawTexture (TexMan[border->br], left+width, top+height, TAG_DONE); DrawTexture (TexMan[border->br], left+width, top+height, TAG_DONE);
} }
DEFINE_ACTION_FUNCTION(_Screen, DrawFrame) DEFINE_ACTION_FUNCTION(_Screen, DrawFrame)
@ -1288,17 +1313,17 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawFrame)
PARAM_INT(y); PARAM_INT(y);
PARAM_INT(w); PARAM_INT(w);
PARAM_INT(h); PARAM_INT(h);
V_DrawFrame(x, y, w, h); screen->DrawFrame(x, y, w, h);
return 0; return 0;
} }
//========================================================================== //==========================================================================
// //
// V_DrawBorder // screen->DrawBorder
// //
//========================================================================== //==========================================================================
void V_DrawBorder (int x1, int y1, int x2, int y2) void DFrameBuffer::DrawBorder (int x1, int y1, int x2, int y2)
{ {
FTextureID picnum; FTextureID picnum;
@ -1313,11 +1338,11 @@ void V_DrawBorder (int x1, int y1, int x2, int y2)
if (picnum.isValid()) if (picnum.isValid())
{ {
screen->FlatFill (x1, y1, x2, y2, TexMan(picnum)); FlatFill (x1, y1, x2, y2, TexMan(picnum));
} }
else else
{ {
screen->Clear (x1, y1, x2, y2, 0, 0); Clear (x1, y1, x2, y2, 0, 0);
} }
} }
@ -1332,19 +1357,19 @@ void V_DrawBorder (int x1, int y1, int x2, int y2)
int BorderNeedRefresh; int BorderNeedRefresh;
static void V_DrawViewBorder (void) void DFrameBuffer::DrawViewBorder (void)
{ {
if (viewwidth == SCREENWIDTH) if (viewwidth == Width)
{ {
return; return;
} }
V_DrawBorder (0, 0, SCREENWIDTH, viewwindowy); DrawBorder (0, 0, Width, viewwindowy);
V_DrawBorder (0, viewwindowy, viewwindowx, viewheight + viewwindowy); DrawBorder (0, viewwindowy, viewwindowx, viewheight + viewwindowy);
V_DrawBorder (viewwindowx + viewwidth, viewwindowy, SCREENWIDTH, viewheight + viewwindowy); DrawBorder (viewwindowx + viewwidth, viewwindowy, Width, viewheight + viewwindowy);
V_DrawBorder (0, viewwindowy + viewheight, SCREENWIDTH, StatusBar->GetTopOfStatusbar()); DrawBorder (0, viewwindowy + viewheight, Width, StatusBar->GetTopOfStatusbar());
V_DrawFrame (viewwindowx, viewwindowy, viewwidth, viewheight); DrawFrame (viewwindowx, viewwindowy, viewwidth, viewheight);
} }
//========================================================================== //==========================================================================
@ -1355,41 +1380,38 @@ static void V_DrawViewBorder (void)
// //
//========================================================================== //==========================================================================
static void V_DrawTopBorder () void DFrameBuffer::DrawTopBorder ()
{ {
FTexture *p; FTexture *p;
int offset; int offset;
if (viewwidth == SCREENWIDTH) if (viewwidth == Width)
return; return;
offset = gameinfo.Border.offset; offset = gameinfo.Border.offset;
if (viewwindowy < 34) if (viewwindowy < 34)
{ {
V_DrawBorder (0, 0, viewwindowx, 34); DrawBorder (0, 0, viewwindowx, 34);
V_DrawBorder (viewwindowx, 0, viewwindowx + viewwidth, viewwindowy); DrawBorder (viewwindowx, 0, viewwindowx + viewwidth, viewwindowy);
V_DrawBorder (viewwindowx + viewwidth, 0, SCREENWIDTH, 34); DrawBorder (viewwindowx + viewwidth, 0, Width, 34);
p = TexMan(gameinfo.Border.t); p = TexMan(gameinfo.Border.t);
screen->FlatFill(viewwindowx, viewwindowy - p->GetHeight(), FlatFill(viewwindowx, viewwindowy - p->GetHeight(), viewwindowx + viewwidth, viewwindowy, p, true);
viewwindowx + viewwidth, viewwindowy, p, true);
p = TexMan(gameinfo.Border.l); p = TexMan(gameinfo.Border.l);
screen->FlatFill(viewwindowx - p->GetWidth(), viewwindowy, FlatFill(viewwindowx - p->GetWidth(), viewwindowy, viewwindowx, 35, p, true);
viewwindowx, 35, p, true);
p = TexMan(gameinfo.Border.r); p = TexMan(gameinfo.Border.r);
screen->FlatFill(viewwindowx + viewwidth, viewwindowy, FlatFill(viewwindowx + viewwidth, viewwindowy, viewwindowx + viewwidth + p->GetWidth(), 35, p, true);
viewwindowx + viewwidth + p->GetWidth(), 35, p, true);
p = TexMan(gameinfo.Border.tl); p = TexMan(gameinfo.Border.tl);
screen->DrawTexture (p, viewwindowx - offset, viewwindowy - offset, TAG_DONE); DrawTexture (p, viewwindowx - offset, viewwindowy - offset, TAG_DONE);
p = TexMan(gameinfo.Border.tr); p = TexMan(gameinfo.Border.tr);
screen->DrawTexture (p, viewwindowx + viewwidth, viewwindowy - offset, TAG_DONE); DrawTexture (p, viewwindowx + viewwidth, viewwindowy - offset, TAG_DONE);
} }
else else
{ {
V_DrawBorder (0, 0, SCREENWIDTH, 34); DrawBorder (0, 0, Width, 34);
} }
} }
@ -1401,7 +1423,7 @@ static void V_DrawTopBorder ()
// //
//========================================================================== //==========================================================================
void V_RefreshViewBorder () void DFrameBuffer::RefreshViewBorder ()
{ {
if (setblocks < 10) if (setblocks < 10)
{ {
@ -1412,12 +1434,12 @@ void V_RefreshViewBorder ()
{ {
BorderTopRefresh--; BorderTopRefresh--;
} }
V_DrawViewBorder(); DrawViewBorder();
} }
else if (BorderTopRefresh) else if (BorderTopRefresh)
{ {
BorderTopRefresh--; BorderTopRefresh--;
V_DrawTopBorder(); DrawTopBorder();
} }
} }
} }

10
src/v_text.cpp
View File

@ -132,7 +132,7 @@ int GetCharFromString(const uint8_t *&string)
// //
//========================================================================== //==========================================================================
void DCanvas::DrawChar (FFont *font, int normalcolor, double x, double y, int character, int tag_first, ...) void DFrameBuffer::DrawChar (FFont *font, int normalcolor, double x, double y, int character, int tag_first, ...)
{ {
if (font == NULL) if (font == NULL)
return; return;
@ -161,7 +161,7 @@ void DCanvas::DrawChar (FFont *font, int normalcolor, double x, double y, int ch
} }
} }
void DCanvas::DrawChar(FFont *font, int normalcolor, double x, double y, int character, VMVa_List &args) void DFrameBuffer::DrawChar(FFont *font, int normalcolor, double x, double y, int character, VMVa_List &args)
{ {
if (font == NULL) if (font == NULL)
return; return;
@ -208,7 +208,7 @@ DEFINE_ACTION_FUNCTION(_Screen, DrawChar)
// //
//========================================================================== //==========================================================================
void DCanvas::DrawTextCommon(FFont *font, int normalcolor, double x, double y, const char *string, DrawParms &parms) void DFrameBuffer::DrawTextCommon(FFont *font, int normalcolor, double x, double y, const char *string, DrawParms &parms)
{ {
int w; int w;
const uint8_t *ch; const uint8_t *ch;
@ -281,7 +281,7 @@ void DCanvas::DrawTextCommon(FFont *font, int normalcolor, double x, double y, c
} }
} }
void DCanvas::DrawText(FFont *font, int normalcolor, double x, double y, const char *string, int tag_first, ...) void DFrameBuffer::DrawText(FFont *font, int normalcolor, double x, double y, const char *string, int tag_first, ...)
{ {
Va_List tags; Va_List tags;
DrawParms parms; DrawParms parms;
@ -299,7 +299,7 @@ void DCanvas::DrawText(FFont *font, int normalcolor, double x, double y, const c
DrawTextCommon(font, normalcolor, x, y, string, parms); DrawTextCommon(font, normalcolor, x, y, string, parms);
} }
void DCanvas::DrawText(FFont *font, int normalcolor, double x, double y, const char *string, VMVa_List &args) void DFrameBuffer::DrawText(FFont *font, int normalcolor, double x, double y, const char *string, VMVa_List &args)
{ {
DrawParms parms; DrawParms parms;

93
src/v_video.cpp
View File

@ -191,19 +191,6 @@ CUSTOM_CVAR (Int, vid_refreshrate, 0, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
} }
} }
CUSTOM_CVAR (Float, dimamount, -1.f, CVAR_ARCHIVE)
{
if (self < 0.f && self != -1.f)
{
self = -1.f;
}
else if (self > 1.f)
{
self = 1.f;
}
}
CVAR (Color, dimcolor, 0xffd700, CVAR_ARCHIVE)
// [RH] Set true when vid_setmode command has been executed // [RH] Set true when vid_setmode command has been executed
bool setmodeneeded = false; bool setmodeneeded = false;
// [RH] Resolution to change to when setmodeneeded is true // [RH] Resolution to change to when setmodeneeded is true
@ -248,78 +235,6 @@ bool DCanvas::IsValid ()
return false; return false;
} }
//==========================================================================
//
// DCanvas :: FlatFill
//
// Fill an area with a texture. If local_origin is false, then the origin
// used for the wrapping is (0,0). Otherwise, (left,right) is used.
//
//==========================================================================
void DCanvas::FlatFill (int left, int top, int right, int bottom, FTexture *src, bool local_origin)
{
int w = src->GetWidth();
int h = src->GetHeight();
// Repeatedly draw the texture, left-to-right, top-to-bottom.
for (int y = local_origin ? top : (top / h * h); y < bottom; y += h)
{
for (int x = local_origin ? left : (left / w * w); x < right; x += w)
{
DrawTexture (src, x, y,
DTA_ClipLeft, left,
DTA_ClipRight, right,
DTA_ClipTop, top,
DTA_ClipBottom, bottom,
DTA_TopOffset, 0,
DTA_LeftOffset, 0,
TAG_DONE);
}
}
}
//==========================================================================
//
// DCanvas :: Dim
//
// Applies a colored overlay to the entire screen, with the opacity
// determined by the dimamount cvar.
//
//==========================================================================
void DCanvas::Dim (PalEntry color)
{
PalEntry dimmer;
float amount;
if (dimamount >= 0)
{
dimmer = PalEntry(dimcolor);
amount = dimamount;
}
else
{
dimmer = gameinfo.dimcolor;
amount = gameinfo.dimamount;
}
if (gameinfo.gametype == GAME_Hexen && gamestate == GS_DEMOSCREEN)
{ // On the Hexen title screen, the default dimming is not
// enough to make the menus readable.
amount = MIN<float> (1.f, amount*2.f);
}
// Add the cvar's dimming on top of the color passed to the function
if (color.a != 0)
{
float dim[4] = { color.r/255.f, color.g/255.f, color.b/255.f, color.a/255.f };
V_AddBlend (dimmer.r/255.f, dimmer.g/255.f, dimmer.b/255.f, amount, dim);
dimmer = PalEntry (uint8_t(dim[0]*255), uint8_t(dim[1]*255), uint8_t(dim[2]*255));
amount = dim[3];
}
Dim (dimmer, amount, 0, 0, Width, Height);
}
//========================================================================== //==========================================================================
// //
// DCanvas :: GetScreenshotBuffer // DCanvas :: GetScreenshotBuffer
@ -1196,7 +1111,7 @@ FNativePalette *DFrameBuffer::CreatePalette(FRemapTable *remap)
bool DFrameBuffer::WipeStartScreen(int type) bool DFrameBuffer::WipeStartScreen(int type)
{ {
return wipe_StartScreen(type); return false;
} }
//========================================================================== //==========================================================================
@ -1210,8 +1125,6 @@ bool DFrameBuffer::WipeStartScreen(int type)
void DFrameBuffer::WipeEndScreen() void DFrameBuffer::WipeEndScreen()
{ {
wipe_EndScreen();
Unlock();
} }
//========================================================================== //==========================================================================
@ -1226,8 +1139,7 @@ void DFrameBuffer::WipeEndScreen()
bool DFrameBuffer::WipeDo(int ticks) bool DFrameBuffer::WipeDo(int ticks)
{ {
Lock(true); return false;
return wipe_ScreenWipe(ticks);
} }
//========================================================================== //==========================================================================
@ -1238,7 +1150,6 @@ bool DFrameBuffer::WipeDo(int ticks)
void DFrameBuffer::WipeCleanup() void DFrameBuffer::WipeCleanup()
{ {
wipe_Cleanup();
} }
//========================================================================== //==========================================================================

133
src/v_video.h
View File

@ -219,36 +219,6 @@ public:
virtual void Unlock () = 0; virtual void Unlock () = 0;
virtual bool IsLocked () { return Buffer != NULL; } // Returns true if the surface is locked virtual bool IsLocked () { return Buffer != NULL; } // Returns true if the surface is locked
// Draw a linear block of pixels into the canvas
virtual void DrawBlock (int x, int y, int width, int height, const uint8_t *src) const;
// Reads a linear block of pixels into the view buffer.
virtual void GetBlock (int x, int y, int width, int height, uint8_t *dest) const;
// Dim the entire canvas for the menus
virtual void Dim (PalEntry color = 0);
// Dim part of the canvas
virtual void Dim (PalEntry color, float amount, int x1, int y1, int w, int h) final;
virtual void DoDim(PalEntry color, float amount, int x1, int y1, int w, int h);
// Fill an area with a texture
virtual void FlatFill (int left, int top, int right, int bottom, FTexture *src, bool local_origin=false);
// Fill a simple polygon with a texture
virtual void FillSimplePoly(FTexture *tex, FVector2 *points, int npoints,
double originx, double originy, double scalex, double scaley, DAngle rotation,
const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip);
// Set an area to a specified color
virtual void Clear (int left, int top, int right, int bottom, int palcolor, uint32_t color) final;
virtual void DoClear(int left, int top, int right, int bottom, int palcolor, uint32_t color);
// Draws a line
virtual void DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor);
// Draws a single pixel
virtual void DrawPixel(int x, int y, int palcolor, uint32_t rgbcolor);
// Calculate gamma table // Calculate gamma table
void CalcGamma (float gamma, uint8_t gammalookup[256]); void CalcGamma (float gamma, uint8_t gammalookup[256]);
@ -262,31 +232,6 @@ public:
// Releases the screenshot buffer. // Releases the screenshot buffer.
virtual void ReleaseScreenshotBuffer(); virtual void ReleaseScreenshotBuffer();
// Text drawing functions -----------------------------------------------
// 2D Texture drawing
void ClearClipRect() { clipleft = cliptop = 0; clipwidth = clipheight = -1; }
void SetClipRect(int x, int y, int w, int h);
void GetClipRect(int *x, int *y, int *w, int *h);
bool SetTextureParms(DrawParms *parms, FTexture *img, double x, double y) const;
void DrawTexture (FTexture *img, double x, double y, int tags, ...);
void DrawTexture(FTexture *img, double x, double y, VMVa_List &);
void FillBorder (FTexture *img); // Fills the border around a 4:3 part of the screen on non-4:3 displays
void VirtualToRealCoords(double &x, double &y, double &w, double &h, double vwidth, double vheight, bool vbottom=false, bool handleaspect=true) const;
// Code that uses these (i.e. SBARINFO) should probably be evaluated for using doubles all around instead.
void VirtualToRealCoordsInt(int &x, int &y, int &w, int &h, int vwidth, int vheight, bool vbottom=false, bool handleaspect=true) const;
#ifdef DrawText
#undef DrawText // See WinUser.h for the definition of DrawText as a macro
#endif
// 2D Text drawing
void DrawText(FFont *font, int normalcolor, double x, double y, const char *string, int tag_first, ...);
void DrawText(FFont *font, int normalcolor, double x, double y, const char *string, VMVa_List &args);
void DrawChar(FFont *font, int normalcolor, double x, double y, int character, int tag_first, ...);
void DrawChar(FFont *font, int normalcolor, double x, double y, int character, VMVa_List &args);
protected: protected:
uint8_t *Buffer; uint8_t *Buffer;
int Width; int Width;
@ -296,14 +241,6 @@ protected:
bool Bgra; bool Bgra;
int clipleft = 0, cliptop = 0, clipwidth = -1, clipheight = -1; int clipleft = 0, cliptop = 0, clipwidth = -1, clipheight = -1;
void DrawTextCommon(FFont *font, int normalcolor, double x, double y, const char *string, DrawParms &parms);
bool ClipBox (int &left, int &top, int &width, int &height, const uint8_t *&src, const int srcpitch) const;
void DrawTextureV(FTexture *img, double x, double y, uint32_t tag, va_list tags) = delete;
virtual void DrawTextureParms(FTexture *img, DrawParms &parms);
template<class T>
bool ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t tag, T& tags, DrawParms *parms, bool fortext) const;
DCanvas() {} DCanvas() {}
@ -362,6 +299,15 @@ public:
class DFrameBuffer : public DSimpleCanvas class DFrameBuffer : public DSimpleCanvas
{ {
typedef DSimpleCanvas Super; typedef DSimpleCanvas Super;
protected:
void DrawTextureV(FTexture *img, double x, double y, uint32_t tag, va_list tags) = delete;
virtual void DrawTextureParms(FTexture *img, DrawParms &parms);
template<class T>
bool ParseDrawTextureTags(FTexture *img, double x, double y, uint32_t tag, T& tags, DrawParms *parms, bool fortext) const;
void DrawTextCommon(FFont *font, int normalcolor, double x, double y, const char *string, DrawParms &parms);
public: public:
DFrameBuffer (int width, int height, bool bgra); DFrameBuffer (int width, int height, bool bgra);
@ -450,6 +396,63 @@ public:
uint64_t GetLastFPS() const { return LastCount; } uint64_t GetLastFPS() const { return LastCount; }
// 2D Texture drawing
void ClearClipRect() { clipleft = cliptop = 0; clipwidth = clipheight = -1; }
void SetClipRect(int x, int y, int w, int h);
void GetClipRect(int *x, int *y, int *w, int *h);
// Dim the entire canvas for the menus
virtual void Dim(PalEntry color = 0);
// Dim part of the canvas
virtual void Dim(PalEntry color, float amount, int x1, int y1, int w, int h) final;
virtual void DoDim(PalEntry color, float amount, int x1, int y1, int w, int h);
// Fill an area with a texture
virtual void FlatFill(int left, int top, int right, int bottom, FTexture *src, bool local_origin = false);
// Fill a simple polygon with a texture
virtual void FillSimplePoly(FTexture *tex, FVector2 *points, int npoints,
double originx, double originy, double scalex, double scaley, DAngle rotation,
const FColormap &colormap, PalEntry flatcolor, int lightlevel, int bottomclip);
// Set an area to a specified color
virtual void Clear(int left, int top, int right, int bottom, int palcolor, uint32_t color) final;
virtual void DoClear(int left, int top, int right, int bottom, int palcolor, uint32_t color);
// Draws a line
virtual void DrawLine(int x0, int y0, int x1, int y1, int palColor, uint32_t realcolor);
// Draws a single pixel
virtual void DrawPixel(int x, int y, int palcolor, uint32_t rgbcolor);
bool SetTextureParms(DrawParms *parms, FTexture *img, double x, double y) const;
void DrawTexture(FTexture *img, double x, double y, int tags, ...);
void DrawTexture(FTexture *img, double x, double y, VMVa_List &);
void FillBorder(FTexture *img); // Fills the border around a 4:3 part of the screen on non-4:3 displays
void VirtualToRealCoords(double &x, double &y, double &w, double &h, double vwidth, double vheight, bool vbottom = false, bool handleaspect = true) const;
// Code that uses these (i.e. SBARINFO) should probably be evaluated for using doubles all around instead.
void VirtualToRealCoordsInt(int &x, int &y, int &w, int &h, int vwidth, int vheight, bool vbottom = false, bool handleaspect = true) const;
// Text drawing functions -----------------------------------------------
#ifdef DrawText
#undef DrawText // See WinUser.h for the definition of DrawText as a macro
#endif
// 2D Text drawing
void DrawText(FFont *font, int normalcolor, double x, double y, const char *string, int tag_first, ...);
void DrawText(FFont *font, int normalcolor, double x, double y, const char *string, VMVa_List &args);
void DrawChar(FFont *font, int normalcolor, double x, double y, int character, int tag_first, ...);
void DrawChar(FFont *font, int normalcolor, double x, double y, int character, VMVa_List &args);
void DrawFrame(int left, int top, int width, int height);
void DrawBorder(int x1, int y1, int x2, int y2);
void DrawViewBorder();
void DrawTopBorder();
void RefreshViewBorder();
#ifdef _WIN32 #ifdef _WIN32
virtual void PaletteChanged () = 0; virtual void PaletteChanged () = 0;
virtual int QueryNewPalette () = 0; virtual int QueryNewPalette () = 0;
@ -552,12 +555,8 @@ FString V_GetColorStringByName (const char *name, FScriptPosition *sc = nullptr)
// Tries to get color by name, then by string // Tries to get color by name, then by string
int V_GetColor (const uint32_t *palette, const char *str, FScriptPosition *sc = nullptr); int V_GetColor (const uint32_t *palette, const char *str, FScriptPosition *sc = nullptr);
int V_GetColor(const uint32_t *palette, FScanner &sc); int V_GetColor(const uint32_t *palette, FScanner &sc);
void V_DrawFrame (int left, int top, int width, int height);
// If the view size is not full screen, draws a border around it. // If the view size is not full screen, draws a border around it.
void V_DrawBorder (int x1, int y1, int x2, int y2);
void V_RefreshViewBorder ();
void V_SetBorderNeedRefresh(); void V_SetBorderNeedRefresh();
int CheckRatio (int width, int height, int *trueratio=NULL); int CheckRatio (int width, int height, int *trueratio=NULL);