2016-03-01 15:47:10 +00:00
|
|
|
// Emacs style mode select -*- C++ -*-
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//
|
|
|
|
// $Id:$
|
|
|
|
//
|
|
|
|
// Copyright (C) 1993-1996 by id Software, Inc.
|
|
|
|
//
|
|
|
|
// This source is available for distribution and/or modification
|
|
|
|
// only under the terms of the DOOM Source Code License as
|
|
|
|
// published by id Software. All rights reserved.
|
|
|
|
//
|
|
|
|
// The source is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
|
|
|
|
// for more details.
|
|
|
|
//
|
|
|
|
// $Log:$
|
|
|
|
//
|
|
|
|
// DESCRIPTION:
|
|
|
|
// Functions to draw patches (by post) directly to screen->
|
|
|
|
// Functions to blit a block to the screen->
|
|
|
|
//
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
#include "i_system.h"
|
|
|
|
#include "x86.h"
|
|
|
|
#include "i_video.h"
|
|
|
|
#include "r_state.h"
|
|
|
|
|
|
|
|
#include "doomdef.h"
|
|
|
|
#include "doomdata.h"
|
|
|
|
#include "doomstat.h"
|
|
|
|
|
|
|
|
#include "c_console.h"
|
|
|
|
#include "hu_stuff.h"
|
|
|
|
|
|
|
|
#include "m_argv.h"
|
|
|
|
#include "m_bbox.h"
|
|
|
|
#include "m_swap.h"
|
|
|
|
|
|
|
|
#include "i_video.h"
|
|
|
|
#include "v_video.h"
|
|
|
|
#include "v_text.h"
|
2016-12-03 15:27:53 +00:00
|
|
|
#include "sc_man.h"
|
2016-03-01 15:47:10 +00:00
|
|
|
|
|
|
|
#include "w_wad.h"
|
|
|
|
|
|
|
|
#include "c_cvars.h"
|
|
|
|
#include "c_dispatch.h"
|
|
|
|
#include "cmdlib.h"
|
|
|
|
#include "gi.h"
|
|
|
|
#include "templates.h"
|
|
|
|
#include "sbar.h"
|
|
|
|
#include "hardware.h"
|
|
|
|
#include "r_data/r_translate.h"
|
|
|
|
#include "f_wipe.h"
|
|
|
|
#include "m_png.h"
|
|
|
|
#include "colormatcher.h"
|
|
|
|
#include "v_palette.h"
|
|
|
|
#include "r_sky.h"
|
|
|
|
#include "r_utility.h"
|
|
|
|
#include "r_renderer.h"
|
|
|
|
#include "menu/menu.h"
|
|
|
|
#include "r_data/voxels.h"
|
2017-04-12 23:12:04 +00:00
|
|
|
#include "vm.h"
|
2016-03-01 15:47:10 +00:00
|
|
|
|
2016-12-24 15:15:02 +00:00
|
|
|
EXTERN_CVAR(Bool, r_blendmethod)
|
2016-12-24 09:01:50 +00:00
|
|
|
|
2016-09-07 09:34:49 +00:00
|
|
|
int active_con_scale();
|
2016-03-01 15:47:10 +00:00
|
|
|
|
|
|
|
FRenderer *Renderer;
|
|
|
|
|
2016-09-14 10:28:39 +00:00
|
|
|
EXTERN_CVAR (Bool, swtruecolor)
|
2017-03-03 17:48:56 +00:00
|
|
|
EXTERN_CVAR (Bool, fullscreen)
|
2016-03-01 15:47:10 +00:00
|
|
|
|
2016-11-23 02:22:39 +00:00
|
|
|
#if defined(_DEBUG) && defined(_M_IX86) && !defined(__MINGW32__)
|
2016-03-01 15:47:10 +00:00
|
|
|
#define DBGBREAK { __asm int 3 }
|
|
|
|
#else
|
|
|
|
#define DBGBREAK
|
|
|
|
#endif
|
|
|
|
|
|
|
|
class DDummyFrameBuffer : public DFrameBuffer
|
|
|
|
{
|
2017-04-14 08:48:18 +00:00
|
|
|
typedef DFrameBuffer Super;
|
2016-03-01 15:47:10 +00:00
|
|
|
public:
|
|
|
|
DDummyFrameBuffer (int width, int height)
|
2016-05-31 07:36:18 +00:00
|
|
|
: DFrameBuffer (0, 0, false)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
Width = width;
|
|
|
|
Height = height;
|
|
|
|
}
|
|
|
|
bool Lock(bool buffered) { DBGBREAK; return false; }
|
|
|
|
void Update() { DBGBREAK; }
|
|
|
|
PalEntry *GetPalette() { DBGBREAK; return NULL; }
|
|
|
|
void GetFlashedPalette(PalEntry palette[256]) { DBGBREAK; }
|
|
|
|
void UpdatePalette() { DBGBREAK; }
|
|
|
|
bool SetGamma(float gamma) { Gamma = gamma; return true; }
|
|
|
|
bool SetFlash(PalEntry rgb, int amount) { DBGBREAK; return false; }
|
|
|
|
void GetFlash(PalEntry &rgb, int &amount) { DBGBREAK; }
|
|
|
|
int GetPageCount() { DBGBREAK; return 0; }
|
|
|
|
bool IsFullscreen() { DBGBREAK; return 0; }
|
|
|
|
#ifdef _WIN32
|
|
|
|
void PaletteChanged() {}
|
|
|
|
int QueryNewPalette() { return 0; }
|
|
|
|
bool Is8BitMode() { return false; }
|
|
|
|
#endif
|
|
|
|
|
|
|
|
float Gamma;
|
|
|
|
};
|
|
|
|
|
|
|
|
class FPaletteTester : public FTexture
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
FPaletteTester ();
|
|
|
|
|
2017-03-09 18:54:41 +00:00
|
|
|
const uint8_t *GetColumn(unsigned int column, const Span **spans_out);
|
|
|
|
const uint8_t *GetPixels();
|
2016-03-01 15:47:10 +00:00
|
|
|
bool CheckModified();
|
|
|
|
void SetTranslation(int num);
|
|
|
|
|
|
|
|
protected:
|
2017-03-09 18:54:41 +00:00
|
|
|
uint8_t Pixels[16*16];
|
2016-03-01 15:47:10 +00:00
|
|
|
int CurTranslation;
|
|
|
|
int WantTranslation;
|
|
|
|
static const Span DummySpan[2];
|
|
|
|
|
|
|
|
void MakeTexture();
|
|
|
|
};
|
|
|
|
|
|
|
|
const FTexture::Span FPaletteTester::DummySpan[2] = { { 0, 16 }, { 0, 0 } };
|
|
|
|
|
|
|
|
int DisplayWidth, DisplayHeight, DisplayBits;
|
|
|
|
|
|
|
|
FFont *SmallFont, *SmallFont2, *BigFont, *ConFont, *IntermissionFont;
|
|
|
|
|
2017-03-09 19:19:55 +00:00
|
|
|
uint32_t Col2RGB8[65][256];
|
|
|
|
uint32_t *Col2RGB8_LessPrecision[65];
|
|
|
|
uint32_t Col2RGB8_Inverse[65][256];
|
2016-03-01 15:47:10 +00:00
|
|
|
ColorTable32k RGB32k;
|
2016-12-19 12:18:20 +00:00
|
|
|
ColorTable256k RGB256k;
|
2016-03-01 15:47:10 +00:00
|
|
|
|
2016-12-19 12:18:20 +00:00
|
|
|
|
2017-03-09 19:19:55 +00:00
|
|
|
static uint32_t Col2RGB8_2[63][256];
|
2016-03-01 15:47:10 +00:00
|
|
|
|
|
|
|
// [RH] The framebuffer is no longer a mere byte array.
|
|
|
|
// There's also only one, not four.
|
|
|
|
DFrameBuffer *screen;
|
|
|
|
|
|
|
|
CVAR (Int, vid_defwidth, 640, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
CVAR (Int, vid_defheight, 480, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
CVAR (Int, vid_defbits, 8, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
CVAR (Bool, vid_fps, false, 0)
|
|
|
|
CVAR (Bool, ticker, false, 0)
|
|
|
|
CVAR (Int, vid_showpalette, 0, 0)
|
|
|
|
|
|
|
|
CUSTOM_CVAR (Bool, vid_vsync, false, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
{
|
|
|
|
if (screen != NULL)
|
|
|
|
{
|
|
|
|
screen->SetVSync (*self);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CUSTOM_CVAR (Int, vid_refreshrate, 0, CVAR_ARCHIVE|CVAR_GLOBALCONFIG)
|
|
|
|
{
|
|
|
|
if (screen != NULL)
|
|
|
|
{
|
|
|
|
screen->NewRefreshRate();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
bool setmodeneeded = false;
|
|
|
|
// [RH] Resolution to change to when setmodeneeded is true
|
|
|
|
int NewWidth, NewHeight, NewBits;
|
|
|
|
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DCanvas Constructor
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2016-05-31 07:36:18 +00:00
|
|
|
DCanvas::DCanvas (int _width, int _height, bool _bgra)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
// Init member vars
|
|
|
|
Buffer = NULL;
|
|
|
|
LockCount = 0;
|
|
|
|
Width = _width;
|
|
|
|
Height = _height;
|
2016-05-31 07:36:18 +00:00
|
|
|
Bgra = _bgra;
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DCanvas Destructor
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
DCanvas::~DCanvas ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DCanvas :: IsValid
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
bool DCanvas::IsValid ()
|
|
|
|
{
|
|
|
|
// A nun-subclassed DCanvas is never valid
|
|
|
|
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);
|
2017-03-09 18:54:41 +00:00
|
|
|
dimmer = PalEntry (uint8_t(dim[0]*255), uint8_t(dim[1]*255), uint8_t(dim[2]*255));
|
2016-03-01 15:47:10 +00:00
|
|
|
amount = dim[3];
|
|
|
|
}
|
|
|
|
Dim (dimmer, amount, 0, 0, Width, Height);
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DCanvas :: GetScreenshotBuffer
|
|
|
|
//
|
|
|
|
// Returns a buffer containing the most recently displayed frame. The
|
|
|
|
// width and height of this buffer are the same as the canvas.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2017-03-09 18:54:41 +00:00
|
|
|
void DCanvas::GetScreenshotBuffer(const uint8_t *&buffer, int &pitch, ESSType &color_type)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
Lock(true);
|
|
|
|
buffer = GetBuffer();
|
2016-06-17 09:24:21 +00:00
|
|
|
pitch = IsBgra() ? GetPitch() * 4 : GetPitch();
|
2016-05-31 07:36:18 +00:00
|
|
|
color_type = IsBgra() ? SS_BGRA : SS_PAL;
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DCanvas :: ReleaseScreenshotBuffer
|
|
|
|
//
|
|
|
|
// Releases the buffer obtained through GetScreenshotBuffer. These calls
|
|
|
|
// must not be nested.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DCanvas::ReleaseScreenshotBuffer()
|
|
|
|
{
|
|
|
|
Unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// V_GetColorFromString
|
|
|
|
//
|
|
|
|
// Passed a string of the form "#RGB", "#RRGGBB", "R G B", or "RR GG BB",
|
|
|
|
// returns a number representing that color. If palette is non-NULL, the
|
|
|
|
// index of the best match in the palette is returned, otherwise the
|
|
|
|
// RRGGBB value is returned directly.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2017-03-09 19:19:55 +00:00
|
|
|
int V_GetColorFromString (const uint32_t *palette, const char *cstr, FScriptPosition *sc)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
int c[3], i, p;
|
|
|
|
char val[3];
|
|
|
|
|
|
|
|
val[2] = '\0';
|
|
|
|
|
|
|
|
// Check for HTML-style #RRGGBB or #RGB color string
|
|
|
|
if (cstr[0] == '#')
|
|
|
|
{
|
|
|
|
size_t len = strlen (cstr);
|
|
|
|
|
|
|
|
if (len == 7)
|
|
|
|
{
|
|
|
|
// Extract each eight-bit component into c[].
|
|
|
|
for (i = 0; i < 3; ++i)
|
|
|
|
{
|
|
|
|
val[0] = cstr[1 + i*2];
|
|
|
|
val[1] = cstr[2 + i*2];
|
2016-12-03 15:27:53 +00:00
|
|
|
c[i] = ParseHex (val, sc);
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (len == 4)
|
|
|
|
{
|
|
|
|
// Extract each four-bit component into c[], expanding to eight bits.
|
|
|
|
for (i = 0; i < 3; ++i)
|
|
|
|
{
|
|
|
|
val[1] = val[0] = cstr[1 + i];
|
2016-12-03 15:27:53 +00:00
|
|
|
c[i] = ParseHex (val, sc);
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// Bad HTML-style; pretend it's black.
|
|
|
|
c[2] = c[1] = c[0] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (strlen(cstr) == 6)
|
|
|
|
{
|
|
|
|
char *p;
|
|
|
|
int color = strtol(cstr, &p, 16);
|
|
|
|
if (*p == 0)
|
|
|
|
{
|
|
|
|
// RRGGBB string
|
|
|
|
c[0] = (color & 0xff0000) >> 16;
|
|
|
|
c[1] = (color & 0xff00) >> 8;
|
|
|
|
c[2] = (color & 0xff);
|
|
|
|
}
|
|
|
|
else goto normal;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
normal:
|
|
|
|
// Treat it as a space-delimited hexadecimal string
|
|
|
|
for (i = 0; i < 3; ++i)
|
|
|
|
{
|
|
|
|
// Skip leading whitespace
|
|
|
|
while (*cstr <= ' ' && *cstr != '\0')
|
|
|
|
{
|
|
|
|
cstr++;
|
|
|
|
}
|
|
|
|
// Extract a component and convert it to eight-bit
|
|
|
|
for (p = 0; *cstr > ' '; ++p, ++cstr)
|
|
|
|
{
|
|
|
|
if (p < 2)
|
|
|
|
{
|
|
|
|
val[p] = *cstr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (p == 0)
|
|
|
|
{
|
|
|
|
c[i] = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (p == 1)
|
|
|
|
{
|
|
|
|
val[1] = val[0];
|
|
|
|
}
|
2016-12-03 15:27:53 +00:00
|
|
|
c[i] = ParseHex (val, sc);
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (palette)
|
|
|
|
return ColorMatcher.Pick (c[0], c[1], c[2]);
|
|
|
|
else
|
|
|
|
return MAKERGB(c[0], c[1], c[2]);
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// V_GetColorStringByName
|
|
|
|
//
|
|
|
|
// Searches for the given color name in x11r6rgb.txt and returns an
|
|
|
|
// HTML-ish "#RRGGBB" string for it if found or the empty string if not.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2016-12-03 15:27:53 +00:00
|
|
|
FString V_GetColorStringByName (const char *name, FScriptPosition *sc)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
FMemLump rgbNames;
|
|
|
|
char *rgbEnd;
|
|
|
|
char *rgb, *endp;
|
|
|
|
int rgblump;
|
|
|
|
int c[3], step;
|
|
|
|
size_t namelen;
|
|
|
|
|
|
|
|
if (Wads.GetNumLumps()==0) return FString();
|
|
|
|
|
|
|
|
rgblump = Wads.CheckNumForName ("X11R6RGB");
|
|
|
|
if (rgblump == -1)
|
|
|
|
{
|
2016-12-03 15:27:53 +00:00
|
|
|
if (!sc) Printf ("X11R6RGB lump not found\n");
|
|
|
|
else sc->Message(MSG_WARNING, "X11R6RGB lump not found");
|
2016-03-01 15:47:10 +00:00
|
|
|
return FString();
|
|
|
|
}
|
|
|
|
|
|
|
|
rgbNames = Wads.ReadLump (rgblump);
|
|
|
|
rgb = (char *)rgbNames.GetMem();
|
|
|
|
rgbEnd = rgb + Wads.LumpLength (rgblump);
|
|
|
|
step = 0;
|
|
|
|
namelen = strlen (name);
|
|
|
|
|
|
|
|
while (rgb < rgbEnd)
|
|
|
|
{
|
|
|
|
// Skip white space
|
|
|
|
if (*rgb <= ' ')
|
|
|
|
{
|
|
|
|
do
|
|
|
|
{
|
|
|
|
rgb++;
|
|
|
|
} while (rgb < rgbEnd && *rgb <= ' ');
|
|
|
|
}
|
|
|
|
else if (step == 0 && *rgb == '!')
|
|
|
|
{ // skip comment lines
|
|
|
|
do
|
|
|
|
{
|
|
|
|
rgb++;
|
|
|
|
} while (rgb < rgbEnd && *rgb != '\n');
|
|
|
|
}
|
|
|
|
else if (step < 3)
|
|
|
|
{ // collect RGB values
|
|
|
|
c[step++] = strtoul (rgb, &endp, 10);
|
|
|
|
if (endp == rgb)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
rgb = endp;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // Check color name
|
|
|
|
endp = rgb;
|
|
|
|
// Find the end of the line
|
|
|
|
while (endp < rgbEnd && *endp != '\n')
|
|
|
|
endp++;
|
|
|
|
// Back up over any whitespace
|
|
|
|
while (endp > rgb && *endp <= ' ')
|
|
|
|
endp--;
|
|
|
|
if (endp == rgb)
|
|
|
|
{
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
size_t checklen = ++endp - rgb;
|
|
|
|
if (checklen == namelen && strnicmp (rgb, name, checklen) == 0)
|
|
|
|
{
|
|
|
|
FString descr;
|
|
|
|
descr.Format ("#%02x%02x%02x", c[0], c[1], c[2]);
|
|
|
|
return descr;
|
|
|
|
}
|
|
|
|
rgb = endp;
|
|
|
|
step = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (rgb < rgbEnd)
|
|
|
|
{
|
2016-12-03 15:27:53 +00:00
|
|
|
if (!sc) Printf ("X11R6RGB lump is corrupt\n");
|
|
|
|
else sc->Message(MSG_WARNING, "X11R6RGB lump is corrupt");
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
return FString();
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// V_GetColor
|
|
|
|
//
|
|
|
|
// Works like V_GetColorFromString(), but also understands X11 color names.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2017-03-09 19:19:55 +00:00
|
|
|
int V_GetColor (const uint32_t *palette, const char *str, FScriptPosition *sc)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
2016-12-03 15:27:53 +00:00
|
|
|
FString string = V_GetColorStringByName (str, sc);
|
2016-03-01 15:47:10 +00:00
|
|
|
int res;
|
|
|
|
|
|
|
|
if (!string.IsEmpty())
|
|
|
|
{
|
2016-12-03 15:27:53 +00:00
|
|
|
res = V_GetColorFromString (palette, string, sc);
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-12-03 15:27:53 +00:00
|
|
|
res = V_GetColorFromString (palette, str, sc);
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2017-03-09 19:19:55 +00:00
|
|
|
int V_GetColor(const uint32_t *palette, FScanner &sc)
|
2016-12-03 15:27:53 +00:00
|
|
|
{
|
|
|
|
FScriptPosition scc = sc;
|
|
|
|
return V_GetColor(palette, sc.String, &scc);
|
|
|
|
}
|
|
|
|
|
2016-03-01 15:47:10 +00:00
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// BuildTransTable
|
|
|
|
//
|
|
|
|
// Build the tables necessary for blending
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
static void BuildTransTable (const PalEntry *palette)
|
|
|
|
{
|
|
|
|
int r, g, b;
|
|
|
|
|
|
|
|
// create the RGB555 lookup table
|
|
|
|
for (r = 0; r < 32; r++)
|
|
|
|
for (g = 0; g < 32; g++)
|
|
|
|
for (b = 0; b < 32; b++)
|
|
|
|
RGB32k.RGB[r][g][b] = ColorMatcher.Pick ((r<<3)|(r>>2), (g<<3)|(g>>2), (b<<3)|(b>>2));
|
2016-12-19 12:18:20 +00:00
|
|
|
// create the RGB666 lookup table
|
|
|
|
for (r = 0; r < 64; r++)
|
|
|
|
for (g = 0; g < 64; g++)
|
|
|
|
for (b = 0; b < 64; b++)
|
|
|
|
RGB256k.RGB[r][g][b] = ColorMatcher.Pick ((r<<2)|(r>>4), (g<<2)|(g>>4), (b<<2)|(b>>4));
|
2016-03-01 15:47:10 +00:00
|
|
|
|
|
|
|
int x, y;
|
|
|
|
|
|
|
|
// create the swizzled palette
|
|
|
|
for (x = 0; x < 65; x++)
|
|
|
|
for (y = 0; y < 256; y++)
|
|
|
|
Col2RGB8[x][y] = (((palette[y].r*x)>>4)<<20) |
|
|
|
|
((palette[y].g*x)>>4) |
|
|
|
|
(((palette[y].b*x)>>4)<<10);
|
|
|
|
|
|
|
|
// create the swizzled palette with the lsb of red and blue forced to 0
|
|
|
|
// (for green, a 1 is okay since it never gets added into)
|
|
|
|
for (x = 1; x < 64; x++)
|
|
|
|
{
|
|
|
|
Col2RGB8_LessPrecision[x] = Col2RGB8_2[x-1];
|
|
|
|
for (y = 0; y < 256; y++)
|
|
|
|
{
|
|
|
|
Col2RGB8_2[x-1][y] = Col2RGB8[x][y] & 0x3feffbff;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Col2RGB8_LessPrecision[0] = Col2RGB8[0];
|
|
|
|
Col2RGB8_LessPrecision[64] = Col2RGB8[64];
|
|
|
|
|
|
|
|
// create the inverse swizzled palette
|
|
|
|
for (x = 0; x < 65; x++)
|
|
|
|
for (y = 0; y < 256; y++)
|
|
|
|
{
|
|
|
|
Col2RGB8_Inverse[x][y] = (((((255-palette[y].r)*x)>>4)<<20) |
|
|
|
|
(((255-palette[y].g)*x)>>4) |
|
|
|
|
((((255-palette[y].b)*x)>>4)<<10)) & 0x3feffbff;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DCanvas :: CalcGamma
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2017-03-09 18:54:41 +00:00
|
|
|
void DCanvas::CalcGamma (float gamma, uint8_t gammalookup[256])
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
// I found this formula on the web at
|
|
|
|
// <http://panda.mostang.com/sane/sane-gamma.html>,
|
|
|
|
// but that page no longer exits.
|
|
|
|
double invgamma = 1.f / gamma;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < 256; i++)
|
|
|
|
{
|
2017-03-09 18:54:41 +00:00
|
|
|
gammalookup[i] = (uint8_t)(255.0 * pow (i / 255.0, invgamma) + 0.5);
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DSimpleCanvas Constructor
|
|
|
|
//
|
|
|
|
// A simple canvas just holds a buffer in main memory.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2016-05-31 07:36:18 +00:00
|
|
|
DSimpleCanvas::DSimpleCanvas (int width, int height, bool bgra)
|
|
|
|
: DCanvas (width, height, bgra)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
2016-09-12 11:04:36 +00:00
|
|
|
MemBuffer = nullptr;
|
|
|
|
Resize(width, height);
|
|
|
|
}
|
|
|
|
|
|
|
|
void DSimpleCanvas::Resize(int width, int height)
|
|
|
|
{
|
|
|
|
Width = width;
|
|
|
|
Height = height;
|
|
|
|
|
|
|
|
if (MemBuffer != NULL)
|
|
|
|
{
|
|
|
|
delete[] MemBuffer;
|
|
|
|
MemBuffer = NULL;
|
|
|
|
}
|
|
|
|
|
2016-03-01 15:47:10 +00:00
|
|
|
// Making the pitch a power of 2 is very bad for performance
|
|
|
|
// Try to maximize the number of cache lines that can be filled
|
|
|
|
// for each column drawing operation by making the pitch slightly
|
|
|
|
// longer than the width. The values used here are all based on
|
|
|
|
// empirical evidence.
|
|
|
|
|
|
|
|
if (width <= 640)
|
|
|
|
{
|
|
|
|
// For low resolutions, just keep the pitch the same as the width.
|
|
|
|
// Some speedup can be seen using the technique below, but the speedup
|
|
|
|
// is so marginal that I don't consider it worthwhile.
|
|
|
|
Pitch = width;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// If we couldn't figure out the CPU's L1 cache line size, assume
|
|
|
|
// it's 32 bytes wide.
|
|
|
|
if (CPU.DataL1LineSize == 0)
|
|
|
|
{
|
|
|
|
CPU.DataL1LineSize = 32;
|
|
|
|
}
|
|
|
|
// The Athlon and P3 have very different caches, apparently.
|
|
|
|
// I am going to generalize the Athlon's performance to all AMD
|
|
|
|
// processors and the P3's to all non-AMD processors. I don't know
|
|
|
|
// how smart that is, but I don't have a vast plethora of
|
|
|
|
// processors to test with.
|
|
|
|
if (CPU.bIsAMD)
|
|
|
|
{
|
|
|
|
Pitch = width + CPU.DataL1LineSize;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Pitch = width + MAX(0, CPU.DataL1LineSize - 8);
|
|
|
|
}
|
|
|
|
}
|
2016-09-19 21:55:15 +00:00
|
|
|
int bytes_per_pixel = Bgra ? 4 : 1;
|
2017-03-09 18:54:41 +00:00
|
|
|
MemBuffer = new uint8_t[Pitch * height * bytes_per_pixel];
|
2016-05-31 07:36:18 +00:00
|
|
|
memset (MemBuffer, 0, Pitch * height * bytes_per_pixel);
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DSimpleCanvas Destructor
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
DSimpleCanvas::~DSimpleCanvas ()
|
|
|
|
{
|
|
|
|
if (MemBuffer != NULL)
|
|
|
|
{
|
|
|
|
delete[] MemBuffer;
|
|
|
|
MemBuffer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DSimpleCanvas :: IsValid
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
bool DSimpleCanvas::IsValid ()
|
|
|
|
{
|
|
|
|
return (MemBuffer != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DSimpleCanvas :: Lock
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
bool DSimpleCanvas::Lock (bool)
|
|
|
|
{
|
|
|
|
if (LockCount == 0)
|
|
|
|
{
|
|
|
|
Buffer = MemBuffer;
|
|
|
|
}
|
|
|
|
LockCount++;
|
|
|
|
return false; // System surfaces are never lost
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DSimpleCanvas :: Unlock
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DSimpleCanvas::Unlock ()
|
|
|
|
{
|
|
|
|
if (--LockCount <= 0)
|
|
|
|
{
|
|
|
|
LockCount = 0;
|
|
|
|
Buffer = NULL; // Enforce buffer access only between Lock/Unlock
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer Constructor
|
|
|
|
//
|
|
|
|
// A frame buffer canvas is the most common and represents the image that
|
|
|
|
// gets drawn to the screen.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2016-05-31 07:36:18 +00:00
|
|
|
DFrameBuffer::DFrameBuffer (int width, int height, bool bgra)
|
|
|
|
: DSimpleCanvas (width, height, bgra)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
LastMS = LastSec = FrameCount = LastCount = LastTic = 0;
|
|
|
|
Accel2D = false;
|
2016-09-14 21:38:11 +00:00
|
|
|
|
|
|
|
VideoWidth = width;
|
|
|
|
VideoHeight = height;
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
|
2016-06-11 16:41:56 +00:00
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: PostprocessBgra
|
|
|
|
//
|
|
|
|
// Copies data to destination buffer while performing gamma and flash.
|
|
|
|
// This is only needed if a target cannot do this with shaders.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2017-03-09 18:54:41 +00:00
|
|
|
void DFrameBuffer::CopyWithGammaBgra(void *output, int pitch, const uint8_t *gammared, const uint8_t *gammagreen, const uint8_t *gammablue, PalEntry flash, int flash_amount)
|
2016-06-11 16:41:56 +00:00
|
|
|
{
|
2017-03-09 18:54:41 +00:00
|
|
|
const uint8_t *gammatables[3] = { gammared, gammagreen, gammablue };
|
2016-06-11 16:41:56 +00:00
|
|
|
|
|
|
|
if (flash_amount > 0)
|
|
|
|
{
|
|
|
|
uint16_t inv_flash_amount = 256 - flash_amount;
|
|
|
|
uint16_t flash_red = flash.r * flash_amount;
|
|
|
|
uint16_t flash_green = flash.g * flash_amount;
|
|
|
|
uint16_t flash_blue = flash.b * flash_amount;
|
|
|
|
|
|
|
|
for (int y = 0; y < Height; y++)
|
|
|
|
{
|
2017-03-09 18:54:41 +00:00
|
|
|
uint8_t *dest = (uint8_t*)output + y * pitch;
|
|
|
|
uint8_t *src = MemBuffer + y * Pitch * 4;
|
2016-06-11 16:41:56 +00:00
|
|
|
for (int x = 0; x < Width; x++)
|
|
|
|
{
|
|
|
|
uint16_t fg_red = src[2];
|
|
|
|
uint16_t fg_green = src[1];
|
|
|
|
uint16_t fg_blue = src[0];
|
|
|
|
uint16_t red = (fg_red * inv_flash_amount + flash_red) >> 8;
|
|
|
|
uint16_t green = (fg_green * inv_flash_amount + flash_green) >> 8;
|
|
|
|
uint16_t blue = (fg_blue * inv_flash_amount + flash_blue) >> 8;
|
|
|
|
|
|
|
|
dest[0] = gammatables[2][blue];
|
|
|
|
dest[1] = gammatables[1][green];
|
|
|
|
dest[2] = gammatables[0][red];
|
|
|
|
dest[3] = 0xff;
|
|
|
|
|
|
|
|
dest += 4;
|
|
|
|
src += 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (int y = 0; y < Height; y++)
|
|
|
|
{
|
2017-03-09 18:54:41 +00:00
|
|
|
uint8_t *dest = (uint8_t*)output + y * pitch;
|
|
|
|
uint8_t *src = MemBuffer + y * Pitch * 4;
|
2016-06-11 16:41:56 +00:00
|
|
|
for (int x = 0; x < Width; x++)
|
|
|
|
{
|
|
|
|
dest[0] = gammatables[2][src[0]];
|
|
|
|
dest[1] = gammatables[1][src[1]];
|
|
|
|
dest[2] = gammatables[0][src[2]];
|
|
|
|
dest[3] = 0xff;
|
|
|
|
|
|
|
|
dest += 4;
|
|
|
|
src += 4;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-03-01 15:47:10 +00:00
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: DrawRateStuff
|
|
|
|
//
|
|
|
|
// Draws the fps counter, dot ticker, and palette debug.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DFrameBuffer::DrawRateStuff ()
|
|
|
|
{
|
|
|
|
// Draws frame time and cumulative fps
|
|
|
|
if (vid_fps)
|
|
|
|
{
|
2017-03-09 19:19:55 +00:00
|
|
|
uint32_t ms = I_FPSTime();
|
|
|
|
uint32_t howlong = ms - LastMS;
|
2016-03-01 15:47:10 +00:00
|
|
|
if ((signed)howlong >= 0)
|
|
|
|
{
|
|
|
|
char fpsbuff[40];
|
|
|
|
int chars;
|
|
|
|
int rate_x;
|
|
|
|
|
2016-09-07 09:34:49 +00:00
|
|
|
int textScale = active_con_scale();
|
2016-09-06 19:35:57 +00:00
|
|
|
|
2016-03-01 15:47:10 +00:00
|
|
|
chars = mysnprintf (fpsbuff, countof(fpsbuff), "%2u ms (%3u fps)", howlong, LastCount);
|
2016-09-06 19:35:57 +00:00
|
|
|
rate_x = Width / textScale - ConFont->StringWidth(&fpsbuff[0]);
|
|
|
|
Clear (rate_x * textScale, 0, Width, ConFont->GetHeight() * textScale, GPalette.BlackIndex, 0);
|
2017-03-30 00:16:23 +00:00
|
|
|
DrawText (ConFont, CR_WHITE, rate_x, 0, (char *)&fpsbuff[0],
|
|
|
|
DTA_VirtualWidth, screen->GetWidth() / textScale,
|
|
|
|
DTA_VirtualHeight, screen->GetHeight() / textScale,
|
|
|
|
DTA_KeepRatio, true, TAG_DONE);
|
2016-03-01 15:47:10 +00:00
|
|
|
|
2017-03-09 19:19:55 +00:00
|
|
|
uint32_t thisSec = ms/1000;
|
2016-03-01 15:47:10 +00:00
|
|
|
if (LastSec < thisSec)
|
|
|
|
{
|
|
|
|
LastCount = FrameCount / (thisSec - LastSec);
|
|
|
|
LastSec = thisSec;
|
|
|
|
FrameCount = 0;
|
|
|
|
}
|
|
|
|
FrameCount++;
|
|
|
|
}
|
|
|
|
LastMS = ms;
|
|
|
|
}
|
|
|
|
|
|
|
|
// draws little dots on the bottom of the screen
|
|
|
|
if (ticker)
|
|
|
|
{
|
|
|
|
int i = I_GetTime(false);
|
|
|
|
int tics = i - LastTic;
|
2017-03-09 18:54:41 +00:00
|
|
|
uint8_t *buffer = GetBuffer();
|
2016-03-01 15:47:10 +00:00
|
|
|
|
|
|
|
LastTic = i;
|
|
|
|
if (tics > 20) tics = 20;
|
|
|
|
|
|
|
|
// Buffer can be NULL if we're doing hardware accelerated 2D
|
|
|
|
if (buffer != NULL)
|
|
|
|
{
|
2016-05-31 07:36:18 +00:00
|
|
|
if (IsBgra())
|
2016-05-31 03:31:32 +00:00
|
|
|
{
|
|
|
|
uint32_t *buffer32 = (uint32_t*)buffer;
|
|
|
|
buffer32 += (GetHeight() - 1) * GetPitch();
|
|
|
|
|
|
|
|
for (i = 0; i < tics * 2; i += 2) buffer32[i] = 0xffffffff;
|
|
|
|
for (; i < 20 * 2; i += 2) buffer32[i] = 0xff000000;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
buffer += (GetHeight() - 1) * GetPitch();
|
|
|
|
|
|
|
|
for (i = 0; i < tics * 2; i += 2) buffer[i] = 0xff;
|
|
|
|
for (; i < 20 * 2; i += 2) buffer[i] = 0x00;
|
|
|
|
}
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (i = 0; i < tics*2; i += 2) Clear(i, Height-1, i+1, Height, 255, 0);
|
|
|
|
for ( ; i < 20*2; i += 2) Clear(i, Height-1, i+1, Height, 0, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// draws the palette for debugging
|
|
|
|
if (vid_showpalette)
|
|
|
|
{
|
|
|
|
// This used to just write the palette to the display buffer.
|
|
|
|
// With hardware-accelerated 2D, that doesn't work anymore.
|
|
|
|
// Drawing it as a texture does and continues to show how
|
|
|
|
// well the PalTex shader is working.
|
|
|
|
static FPaletteTester palette;
|
2016-08-28 07:55:04 +00:00
|
|
|
int size = screen->GetHeight() < 800 ? 16 * 7 : 16 * 7 * 2;
|
2016-03-01 15:47:10 +00:00
|
|
|
|
|
|
|
palette.SetTranslation(vid_showpalette);
|
|
|
|
DrawTexture(&palette, 0, 0,
|
2016-08-28 07:55:04 +00:00
|
|
|
DTA_DestWidth, size,
|
|
|
|
DTA_DestHeight, size,
|
2016-03-01 15:47:10 +00:00
|
|
|
DTA_Masked, false,
|
|
|
|
TAG_DONE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// FPaleteTester Constructor
|
|
|
|
//
|
|
|
|
// This is just a 16x16 image with every possible color value.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
FPaletteTester::FPaletteTester()
|
|
|
|
{
|
|
|
|
Width = 16;
|
|
|
|
Height = 16;
|
|
|
|
WidthBits = 4;
|
|
|
|
HeightBits = 4;
|
|
|
|
WidthMask = 15;
|
|
|
|
CurTranslation = 0;
|
|
|
|
WantTranslation = 1;
|
|
|
|
MakeTexture();
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// FPaletteTester :: CheckModified
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
bool FPaletteTester::CheckModified()
|
|
|
|
{
|
|
|
|
return CurTranslation != WantTranslation;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// FPaletteTester :: SetTranslation
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void FPaletteTester::SetTranslation(int num)
|
|
|
|
{
|
|
|
|
if (num >= 1 && num <= 9)
|
|
|
|
{
|
|
|
|
WantTranslation = num;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// FPaletteTester :: GetColumn
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2017-03-09 18:54:41 +00:00
|
|
|
const uint8_t *FPaletteTester::GetColumn (unsigned int column, const Span **spans_out)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
if (CurTranslation != WantTranslation)
|
|
|
|
{
|
|
|
|
MakeTexture();
|
|
|
|
}
|
|
|
|
column &= 15;
|
|
|
|
if (spans_out != NULL)
|
|
|
|
{
|
|
|
|
*spans_out = DummySpan;
|
|
|
|
}
|
|
|
|
return Pixels + column*16;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// FPaletteTester :: GetPixels
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2017-03-09 18:54:41 +00:00
|
|
|
const uint8_t *FPaletteTester::GetPixels ()
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
if (CurTranslation != WantTranslation)
|
|
|
|
{
|
|
|
|
MakeTexture();
|
|
|
|
}
|
|
|
|
return Pixels;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// FPaletteTester :: MakeTexture
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void FPaletteTester::MakeTexture()
|
|
|
|
{
|
|
|
|
int i, j, k, t;
|
2017-03-09 18:54:41 +00:00
|
|
|
uint8_t *p;
|
2016-03-01 15:47:10 +00:00
|
|
|
|
|
|
|
t = WantTranslation;
|
|
|
|
p = Pixels;
|
|
|
|
k = 0;
|
|
|
|
for (i = 0; i < 16; ++i)
|
|
|
|
{
|
|
|
|
for (j = 0; j < 16; ++j)
|
|
|
|
{
|
|
|
|
*p++ = (t > 1) ? translationtables[TRANSLATION_Standard][t - 2]->Remap[k] : k;
|
|
|
|
k += 16;
|
|
|
|
}
|
|
|
|
k -= 255;
|
|
|
|
}
|
|
|
|
CurTranslation = t;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: CopyFromBuff
|
|
|
|
//
|
|
|
|
// Copies pixels from main memory to video memory. This is only used by
|
|
|
|
// DDrawFB.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
2017-03-09 18:54:41 +00:00
|
|
|
void DFrameBuffer::CopyFromBuff (uint8_t *src, int srcPitch, int width, int height, uint8_t *dest)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
if (Pitch == width && Pitch == Width && srcPitch == width)
|
|
|
|
{
|
|
|
|
memcpy (dest, src, Width * Height);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for (int y = 0; y < height; y++)
|
|
|
|
{
|
|
|
|
memcpy (dest, src, width);
|
|
|
|
dest += Pitch;
|
|
|
|
src += srcPitch;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: SetVSync
|
|
|
|
//
|
|
|
|
// Turns vertical sync on and off, if supported.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DFrameBuffer::SetVSync (bool vsync)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: NewRefreshRate
|
|
|
|
//
|
|
|
|
// Sets the fullscreen display to the new refresh rate in vid_refreshrate,
|
|
|
|
// if possible.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DFrameBuffer::NewRefreshRate ()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: SetBlendingRect
|
|
|
|
//
|
|
|
|
// Defines the area of the screen containing the 3D view.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DFrameBuffer::SetBlendingRect (int x1, int y1, int x2, int y2)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: Begin2D
|
|
|
|
//
|
|
|
|
// Signal that 3D rendering is complete, and the rest of the operations on
|
|
|
|
// the canvas until Unlock() will be 2D ones.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
bool DFrameBuffer::Begin2D (bool copy3d)
|
|
|
|
{
|
2017-04-01 10:59:58 +00:00
|
|
|
isIn2D = true;
|
2017-03-28 11:06:24 +00:00
|
|
|
ClearClipRect();
|
2016-03-01 15:47:10 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: DrawBlendingRect
|
|
|
|
//
|
|
|
|
// In hardware 2D modes, the blending rect needs to be drawn separately
|
|
|
|
// from transferring the 3D scene to video memory, because the weapon
|
|
|
|
// sprite is drawn on top of that.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DFrameBuffer::DrawBlendingRect()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: CreateTexture
|
|
|
|
//
|
|
|
|
// Creates a native texture for a game texture, if supported.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
FNativeTexture *DFrameBuffer::CreateTexture(FTexture *gametex, bool wrapping)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: CreatePalette
|
|
|
|
//
|
|
|
|
// Creates a native palette from a remap table, if supported.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
FNativePalette *DFrameBuffer::CreatePalette(FRemapTable *remap)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: WipeStartScreen
|
|
|
|
//
|
|
|
|
// Grabs a copy of the screen currently displayed to serve as the initial
|
|
|
|
// frame of a screen wipe. Also determines which screenwipe will be
|
|
|
|
// performed.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
bool DFrameBuffer::WipeStartScreen(int type)
|
|
|
|
{
|
|
|
|
return wipe_StartScreen(type);
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: WipeEndScreen
|
|
|
|
//
|
|
|
|
// Grabs a copy of the most-recently drawn, but not yet displayed, screen
|
|
|
|
// to serve as the final frame of a screen wipe.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DFrameBuffer::WipeEndScreen()
|
|
|
|
{
|
|
|
|
wipe_EndScreen();
|
|
|
|
Unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: WipeDo
|
|
|
|
//
|
|
|
|
// Draws one frame of a screenwipe. Should be called no more than 35
|
|
|
|
// times per second. If called less than that, ticks indicates how many
|
|
|
|
// ticks have passed since the last call.
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
bool DFrameBuffer::WipeDo(int ticks)
|
|
|
|
{
|
|
|
|
Lock(true);
|
|
|
|
return wipe_ScreenWipe(ticks);
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: WipeCleanup
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DFrameBuffer::WipeCleanup()
|
|
|
|
{
|
|
|
|
wipe_Cleanup();
|
|
|
|
}
|
|
|
|
|
|
|
|
//==========================================================================
|
|
|
|
//
|
|
|
|
// DFrameBuffer :: GameRestart
|
|
|
|
//
|
|
|
|
//==========================================================================
|
|
|
|
|
|
|
|
void DFrameBuffer::GameRestart()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//===========================================================================
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//
|
|
|
|
//===========================================================================
|
|
|
|
|
|
|
|
FNativePalette::~FNativePalette()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
FNativeTexture::~FNativeTexture()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
bool FNativeTexture::CheckWrapping(bool wrapping)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
CCMD(clean)
|
|
|
|
{
|
|
|
|
Printf ("CleanXfac: %d\nCleanYfac: %d\n", CleanXfac, CleanYfac);
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// V_SetResolution
|
|
|
|
//
|
|
|
|
bool V_DoModeSetup (int width, int height, int bits)
|
|
|
|
{
|
|
|
|
DFrameBuffer *buff = I_SetMode (width, height, screen);
|
|
|
|
|
|
|
|
if (buff == NULL)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
screen = buff;
|
|
|
|
screen->SetGamma (Gamma);
|
|
|
|
|
|
|
|
// Load fonts now so they can be packed into textures straight away,
|
|
|
|
// if D3DFB is being used for the display.
|
|
|
|
FFont::StaticPreloadFonts();
|
|
|
|
|
2016-09-12 11:04:36 +00:00
|
|
|
DisplayBits = bits;
|
|
|
|
V_UpdateModeSize(width, height);
|
|
|
|
|
|
|
|
M_RefreshModesList ();
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void V_UpdateModeSize (int width, int height)
|
|
|
|
{
|
|
|
|
int cx1, cx2;
|
2016-03-01 15:47:10 +00:00
|
|
|
V_CalcCleanFacs(320, 200, width, height, &CleanXfac, &CleanYfac, &cx1, &cx2);
|
|
|
|
|
|
|
|
CleanWidth = width / CleanXfac;
|
|
|
|
CleanHeight = height / CleanYfac;
|
|
|
|
assert(CleanWidth >= 320);
|
|
|
|
assert(CleanHeight >= 200);
|
|
|
|
|
|
|
|
if (width < 800 || width >= 960)
|
|
|
|
{
|
|
|
|
if (cx1 < cx2)
|
|
|
|
{
|
|
|
|
// Special case in which we don't need to scale down.
|
|
|
|
CleanXfac_1 =
|
|
|
|
CleanYfac_1 = cx1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CleanXfac_1 = MAX(CleanXfac - 1, 1);
|
|
|
|
CleanYfac_1 = MAX(CleanYfac - 1, 1);
|
|
|
|
// On larger screens this is not enough so make sure it's at most 3/4 of the screen's width
|
|
|
|
while (CleanXfac_1 * 320 > screen->GetWidth()*3/4 && CleanXfac_1 > 2)
|
|
|
|
{
|
|
|
|
CleanXfac_1--;
|
|
|
|
CleanYfac_1--;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
CleanWidth_1 = width / CleanXfac_1;
|
|
|
|
CleanHeight_1 = height / CleanYfac_1;
|
|
|
|
}
|
|
|
|
else // if the width is between 800 and 960 the ratio between the screensize and CleanXFac-1 becomes too large.
|
|
|
|
{
|
|
|
|
CleanXfac_1 = CleanXfac;
|
|
|
|
CleanYfac_1 = CleanYfac;
|
|
|
|
CleanWidth_1 = CleanWidth;
|
|
|
|
CleanHeight_1 = CleanHeight;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
DisplayWidth = width;
|
|
|
|
DisplayHeight = height;
|
|
|
|
|
|
|
|
R_OldBlend = ~0;
|
|
|
|
Renderer->OnModeSet();
|
2016-09-12 11:04:36 +00:00
|
|
|
}
|
2016-03-01 15:47:10 +00:00
|
|
|
|
2016-09-12 11:04:36 +00:00
|
|
|
void V_OutputResized (int width, int height)
|
|
|
|
{
|
|
|
|
V_UpdateModeSize(width, height);
|
|
|
|
setsizeneeded = true;
|
|
|
|
if (StatusBar != NULL)
|
|
|
|
{
|
2017-03-21 19:09:09 +00:00
|
|
|
StatusBar->CallScreenSizeChanged();
|
2016-09-12 11:04:36 +00:00
|
|
|
}
|
2016-09-14 21:38:11 +00:00
|
|
|
C_NewModeAdjust();
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void V_CalcCleanFacs (int designwidth, int designheight, int realwidth, int realheight, int *cleanx, int *cleany, int *_cx1, int *_cx2)
|
|
|
|
{
|
2016-09-12 13:51:50 +00:00
|
|
|
float ratio;
|
2016-03-01 15:47:10 +00:00
|
|
|
int cwidth;
|
|
|
|
int cheight;
|
|
|
|
int cx1, cy1, cx2, cy2;
|
|
|
|
|
2017-03-19 17:38:16 +00:00
|
|
|
// For larger screems always use at least a 16:9 ratio for clean factor calculation, even if the actual ratio is narrower.
|
|
|
|
if (realwidth > 1280 && (double)realwidth / realheight < 16./9)
|
|
|
|
{
|
|
|
|
realheight = realwidth * 9 / 16;
|
|
|
|
}
|
|
|
|
|
2016-09-12 13:51:50 +00:00
|
|
|
ratio = ActiveRatio(realwidth, realheight);
|
2016-09-13 21:26:30 +00:00
|
|
|
if (AspectTallerThanWide(ratio))
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
cwidth = realwidth;
|
2016-09-12 13:51:50 +00:00
|
|
|
cheight = realheight * AspectMultiplier(ratio) / 48;
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-09-12 13:51:50 +00:00
|
|
|
cwidth = realwidth * AspectMultiplier(ratio) / 48;
|
2016-03-01 15:47:10 +00:00
|
|
|
cheight = realheight;
|
|
|
|
}
|
|
|
|
// Use whichever pair of cwidth/cheight or width/height that produces less difference
|
|
|
|
// between CleanXfac and CleanYfac.
|
|
|
|
cx1 = MAX(cwidth / designwidth, 1);
|
|
|
|
cy1 = MAX(cheight / designheight, 1);
|
|
|
|
cx2 = MAX(realwidth / designwidth, 1);
|
|
|
|
cy2 = MAX(realheight / designheight, 1);
|
2017-03-19 17:38:16 +00:00
|
|
|
if (abs(cx1 - cy1) <= abs(cx2 - cy2) || MAX(cx1, cx2) >= 4)
|
2016-03-01 15:47:10 +00:00
|
|
|
{ // e.g. 640x360 looks better with this.
|
|
|
|
*cleanx = cx1;
|
|
|
|
*cleany = cy1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // e.g. 720x480 looks better with this.
|
|
|
|
*cleanx = cx2;
|
|
|
|
*cleany = cy2;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*cleanx < *cleany)
|
|
|
|
*cleany = *cleanx;
|
|
|
|
else
|
|
|
|
*cleanx = *cleany;
|
|
|
|
|
|
|
|
if (_cx1 != NULL) *_cx1 = cx1;
|
|
|
|
if (_cx2 != NULL) *_cx2 = cx2;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool IVideo::SetResolution (int width, int height, int bits)
|
|
|
|
{
|
|
|
|
int oldwidth, oldheight;
|
|
|
|
int oldbits;
|
|
|
|
|
|
|
|
if (screen)
|
|
|
|
{
|
|
|
|
oldwidth = SCREENWIDTH;
|
|
|
|
oldheight = SCREENHEIGHT;
|
|
|
|
oldbits = DisplayBits;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{ // Harmless if screen wasn't allocated
|
|
|
|
oldwidth = width;
|
|
|
|
oldheight = height;
|
|
|
|
oldbits = bits;
|
|
|
|
}
|
|
|
|
|
|
|
|
I_ClosestResolution (&width, &height, bits);
|
|
|
|
if (!I_CheckResolution (width, height, bits))
|
|
|
|
{ // Try specified resolution
|
|
|
|
if (!I_CheckResolution (oldwidth, oldheight, oldbits))
|
|
|
|
{ // Try previous resolution (if any)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
width = oldwidth;
|
|
|
|
height = oldheight;
|
|
|
|
bits = oldbits;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return V_DoModeSetup (width, height, bits);
|
|
|
|
}
|
|
|
|
|
|
|
|
CCMD (vid_setmode)
|
|
|
|
{
|
|
|
|
bool goodmode = false;
|
|
|
|
int width = 0, height = SCREENHEIGHT;
|
|
|
|
int bits = DisplayBits;
|
|
|
|
|
|
|
|
if (argv.argc() > 1)
|
|
|
|
{
|
|
|
|
width = atoi (argv[1]);
|
|
|
|
if (argv.argc() > 2)
|
|
|
|
{
|
|
|
|
height = atoi (argv[2]);
|
|
|
|
if (argv.argc() > 3)
|
|
|
|
{
|
|
|
|
bits = atoi (argv[3]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (width && I_CheckResolution (width, height, bits))
|
|
|
|
{
|
|
|
|
goodmode = true;
|
|
|
|
}
|
|
|
|
|
2017-03-03 17:48:56 +00:00
|
|
|
if (!fullscreen)
|
|
|
|
goodmode = true;
|
|
|
|
|
2016-03-01 15:47:10 +00:00
|
|
|
if (goodmode)
|
|
|
|
{
|
|
|
|
// The actual change of resolution will take place
|
|
|
|
// near the beginning of D_Display().
|
|
|
|
if (gamestate != GS_STARTUP)
|
|
|
|
{
|
|
|
|
setmodeneeded = true;
|
|
|
|
NewWidth = width;
|
|
|
|
NewHeight = height;
|
|
|
|
NewBits = bits;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (width)
|
|
|
|
{
|
|
|
|
Printf ("Unknown resolution %d x %d x %d\n", width, height, bits);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Printf ("Usage: vid_setmode <width> <height> <mode>\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
|
|
// V_Init
|
|
|
|
//
|
|
|
|
|
|
|
|
void V_Init (bool restart)
|
|
|
|
{
|
|
|
|
const char *i;
|
|
|
|
int width, height, bits;
|
|
|
|
|
|
|
|
atterm (V_Shutdown);
|
|
|
|
|
|
|
|
// [RH] Initialize palette management
|
|
|
|
InitPalette ();
|
|
|
|
|
|
|
|
if (!restart)
|
|
|
|
{
|
|
|
|
width = height = bits = 0;
|
|
|
|
|
|
|
|
if ( (i = Args->CheckValue ("-width")) )
|
|
|
|
width = atoi (i);
|
|
|
|
|
|
|
|
if ( (i = Args->CheckValue ("-height")) )
|
|
|
|
height = atoi (i);
|
|
|
|
|
|
|
|
if ( (i = Args->CheckValue ("-bits")) )
|
|
|
|
bits = atoi (i);
|
|
|
|
|
|
|
|
if (width == 0)
|
|
|
|
{
|
|
|
|
if (height == 0)
|
|
|
|
{
|
|
|
|
width = vid_defwidth;
|
|
|
|
height = vid_defheight;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
width = (height * 8) / 6;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (height == 0)
|
|
|
|
{
|
|
|
|
height = (width * 6) / 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (bits == 0)
|
|
|
|
{
|
|
|
|
bits = vid_defbits;
|
|
|
|
}
|
|
|
|
screen = new DDummyFrameBuffer (width, height);
|
|
|
|
}
|
|
|
|
// Update screen palette when restarting
|
|
|
|
else
|
|
|
|
{
|
|
|
|
PalEntry *palette = screen->GetPalette ();
|
|
|
|
for (int i = 0; i < 256; ++i)
|
|
|
|
*palette++ = GPalette.BaseColors[i];
|
|
|
|
screen->UpdatePalette();
|
|
|
|
}
|
|
|
|
|
|
|
|
BuildTransTable (GPalette.BaseColors);
|
|
|
|
}
|
|
|
|
|
|
|
|
void V_Init2()
|
|
|
|
{
|
|
|
|
int width = screen->GetWidth();
|
|
|
|
int height = screen->GetHeight();
|
|
|
|
float gamma = static_cast<DDummyFrameBuffer *>(screen)->Gamma;
|
|
|
|
|
|
|
|
{
|
|
|
|
DFrameBuffer *s = screen;
|
|
|
|
screen = NULL;
|
|
|
|
delete s;
|
|
|
|
}
|
|
|
|
|
|
|
|
I_InitGraphics();
|
|
|
|
I_ClosestResolution (&width, &height, 8);
|
|
|
|
|
|
|
|
if (!Video->SetResolution (width, height, 8))
|
|
|
|
I_FatalError ("Could not set resolution to %d x %d x %d", width, height, 8);
|
|
|
|
else
|
|
|
|
Printf ("Resolution: %d x %d\n", SCREENWIDTH, SCREENHEIGHT);
|
|
|
|
|
|
|
|
screen->SetGamma (gamma);
|
|
|
|
Renderer->RemapVoxels();
|
|
|
|
FBaseCVar::ResetColors ();
|
|
|
|
C_NewModeAdjust();
|
|
|
|
M_InitVideoModesMenu();
|
|
|
|
V_SetBorderNeedRefresh();
|
|
|
|
setsizeneeded = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void V_Shutdown()
|
|
|
|
{
|
|
|
|
if (screen)
|
|
|
|
{
|
|
|
|
DFrameBuffer *s = screen;
|
|
|
|
screen = NULL;
|
|
|
|
delete s;
|
|
|
|
}
|
|
|
|
V_ClearFonts();
|
|
|
|
}
|
|
|
|
|
|
|
|
EXTERN_CVAR (Bool, vid_tft)
|
|
|
|
CUSTOM_CVAR (Bool, vid_nowidescreen, false, CVAR_GLOBALCONFIG|CVAR_ARCHIVE)
|
|
|
|
{
|
|
|
|
setsizeneeded = true;
|
|
|
|
if (StatusBar != NULL)
|
|
|
|
{
|
2017-03-21 19:09:09 +00:00
|
|
|
StatusBar->CallScreenSizeChanged();
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
CUSTOM_CVAR (Int, vid_aspect, 0, CVAR_GLOBALCONFIG|CVAR_ARCHIVE)
|
|
|
|
{
|
|
|
|
setsizeneeded = true;
|
|
|
|
if (StatusBar != NULL)
|
|
|
|
{
|
2017-03-21 19:09:09 +00:00
|
|
|
StatusBar->CallScreenSizeChanged();
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-12 11:59:01 +00:00
|
|
|
// Helper for ActiveRatio and CheckRatio. Returns the forced ratio type, or -1 if none.
|
|
|
|
int ActiveFakeRatio(int width, int height)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
int fakeratio = -1;
|
2016-03-02 10:31:12 +00:00
|
|
|
if ((vid_aspect >= 1) && (vid_aspect <= 6))
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
|
|
|
// [SP] User wants to force aspect ratio; let them.
|
|
|
|
fakeratio = int(vid_aspect);
|
|
|
|
if (fakeratio == 3)
|
|
|
|
{
|
|
|
|
fakeratio = 0;
|
|
|
|
}
|
|
|
|
else if (fakeratio == 5)
|
|
|
|
{
|
|
|
|
fakeratio = 3;
|
2016-09-12 11:59:01 +00:00
|
|
|
}
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
if (vid_nowidescreen)
|
|
|
|
{
|
|
|
|
if (!vid_tft)
|
|
|
|
{
|
|
|
|
fakeratio = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-09-12 11:59:01 +00:00
|
|
|
fakeratio = (height * 5 / 4 == width) ? 4 : 0;
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
}
|
2016-09-12 11:59:01 +00:00
|
|
|
return fakeratio;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Active screen ratio based on cvars and size
|
|
|
|
float ActiveRatio(int width, int height, float *trueratio)
|
|
|
|
{
|
|
|
|
static float forcedRatioTypes[] =
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
2016-09-12 11:59:01 +00:00
|
|
|
4 / 3.0f,
|
|
|
|
16 / 9.0f,
|
|
|
|
16 / 10.0f,
|
|
|
|
17 / 10.0f,
|
|
|
|
5 / 4.0f,
|
|
|
|
17 / 10.0f,
|
|
|
|
21 / 9.0f
|
|
|
|
};
|
|
|
|
|
|
|
|
float ratio = width / (float)height;
|
|
|
|
int fakeratio = ActiveFakeRatio(width, height);
|
|
|
|
|
|
|
|
if (trueratio)
|
|
|
|
*trueratio = ratio;
|
|
|
|
return (fakeratio != -1) ? forcedRatioTypes[fakeratio] : ratio;
|
|
|
|
}
|
|
|
|
|
2017-03-22 23:25:26 +00:00
|
|
|
DEFINE_ACTION_FUNCTION(_Screen, GetAspectRatio)
|
|
|
|
{
|
|
|
|
ACTION_RETURN_FLOAT(ActiveRatio(screen->GetWidth(), screen->GetHeight(), nullptr));
|
|
|
|
}
|
|
|
|
|
2016-03-01 15:47:10 +00:00
|
|
|
// Tries to guess the physical dimensions of the screen based on the
|
|
|
|
// screen's pixel dimensions. Can return:
|
|
|
|
// 0: 4:3
|
|
|
|
// 1: 16:9
|
|
|
|
// 2: 16:10
|
|
|
|
// 3: 17:10
|
|
|
|
// 4: 5:4
|
2016-09-12 11:37:05 +00:00
|
|
|
// 5: 17:10 (redundant, never returned)
|
2016-03-02 10:31:12 +00:00
|
|
|
// 6: 21:9
|
2016-03-01 15:47:10 +00:00
|
|
|
int CheckRatio (int width, int height, int *trueratio)
|
|
|
|
{
|
2016-09-12 11:37:05 +00:00
|
|
|
float aspect = width / (float)height;
|
|
|
|
|
|
|
|
static std::pair<float, int> ratioTypes[] =
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
2016-09-12 11:37:05 +00:00
|
|
|
{ 21 / 9.0f , 6 },
|
|
|
|
{ 16 / 9.0f , 1 },
|
|
|
|
{ 17 / 10.0f , 3 },
|
|
|
|
{ 16 / 10.0f , 2 },
|
|
|
|
{ 4 / 3.0f , 0 },
|
|
|
|
{ 5 / 4.0f , 4 },
|
|
|
|
{ 0.0f, 0 }
|
|
|
|
};
|
2016-03-01 15:47:10 +00:00
|
|
|
|
2016-09-12 11:37:05 +00:00
|
|
|
int ratio = ratioTypes[0].second;
|
2016-09-12 16:44:04 +00:00
|
|
|
float distance = fabs(ratioTypes[0].first - aspect);
|
2016-09-12 11:37:05 +00:00
|
|
|
for (int i = 1; ratioTypes[i].first != 0.0f; i++)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
2016-09-12 16:44:04 +00:00
|
|
|
float d = fabs(ratioTypes[i].first - aspect);
|
2016-09-12 11:37:05 +00:00
|
|
|
if (d < distance)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
2016-09-12 11:37:05 +00:00
|
|
|
ratio = ratioTypes[i].second;
|
|
|
|
distance = d;
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-12 11:59:01 +00:00
|
|
|
int fakeratio = ActiveFakeRatio(width, height);
|
|
|
|
if (fakeratio == -1)
|
|
|
|
fakeratio = ratio;
|
2016-03-01 15:47:10 +00:00
|
|
|
|
2016-09-12 11:37:05 +00:00
|
|
|
if (trueratio)
|
2016-03-01 15:47:10 +00:00
|
|
|
*trueratio = ratio;
|
2016-09-12 11:37:05 +00:00
|
|
|
return fakeratio;
|
2016-03-01 15:47:10 +00:00
|
|
|
}
|
|
|
|
|
2016-09-12 12:37:10 +00:00
|
|
|
int AspectBaseWidth(float aspect)
|
|
|
|
{
|
2016-09-13 21:26:30 +00:00
|
|
|
return (int)round(240.0f * aspect * 3.0f);
|
2016-09-12 12:37:10 +00:00
|
|
|
}
|
2016-03-01 15:47:10 +00:00
|
|
|
|
2016-09-12 12:37:10 +00:00
|
|
|
int AspectBaseHeight(float aspect)
|
2016-03-01 15:47:10 +00:00
|
|
|
{
|
2016-09-13 21:26:30 +00:00
|
|
|
if (!AspectTallerThanWide(aspect))
|
|
|
|
return (int)round(200.0f * (320.0f / (AspectBaseWidth(aspect) / 3.0f)) * 3.0f);
|
|
|
|
else
|
|
|
|
return (int)round((200.0f * (4.0f / 3.0f)) / aspect * 3.0f);
|
2016-09-12 12:37:10 +00:00
|
|
|
}
|
|
|
|
|
2016-09-13 09:46:05 +00:00
|
|
|
double AspectPspriteOffset(float aspect)
|
2016-09-12 12:37:10 +00:00
|
|
|
{
|
2016-09-13 21:26:30 +00:00
|
|
|
if (!AspectTallerThanWide(aspect))
|
|
|
|
return 0.0;
|
|
|
|
else
|
|
|
|
return ((4.0 / 3.0) / aspect - 1.0) * 97.5;
|
2016-09-12 12:37:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int AspectMultiplier(float aspect)
|
|
|
|
{
|
2016-09-13 21:26:30 +00:00
|
|
|
if (!AspectTallerThanWide(aspect))
|
|
|
|
return (int)round(320.0f / (AspectBaseWidth(aspect) / 3.0f) * 48.0f);
|
|
|
|
else
|
|
|
|
return (int)round(200.0f / (AspectBaseHeight(aspect) / 3.0f) * 48.0f);
|
2016-09-13 09:46:05 +00:00
|
|
|
}
|
|
|
|
|
2016-09-13 21:26:30 +00:00
|
|
|
bool AspectTallerThanWide(float aspect)
|
2016-09-13 09:46:05 +00:00
|
|
|
{
|
2016-09-13 21:26:30 +00:00
|
|
|
return aspect < 1.333f;
|
2016-09-12 12:37:10 +00:00
|
|
|
}
|
2016-03-01 15:47:10 +00:00
|
|
|
|
|
|
|
void IVideo::DumpAdapters ()
|
|
|
|
{
|
|
|
|
Printf("Multi-monitor support unavailable.\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
CCMD(vid_listadapters)
|
|
|
|
{
|
|
|
|
if (Video != NULL)
|
|
|
|
Video->DumpAdapters();
|
|
|
|
}
|
2017-03-13 13:42:14 +00:00
|
|
|
|
|
|
|
DEFINE_GLOBAL(SmallFont)
|
|
|
|
DEFINE_GLOBAL(SmallFont2)
|
|
|
|
DEFINE_GLOBAL(BigFont)
|
|
|
|
DEFINE_GLOBAL(ConFont)
|
|
|
|
DEFINE_GLOBAL(IntermissionFont)
|
|
|
|
DEFINE_GLOBAL(CleanXfac)
|
|
|
|
DEFINE_GLOBAL(CleanYfac)
|
|
|
|
DEFINE_GLOBAL(CleanWidth)
|
|
|
|
DEFINE_GLOBAL(CleanHeight)
|
|
|
|
DEFINE_GLOBAL(CleanXfac_1)
|
|
|
|
DEFINE_GLOBAL(CleanYfac_1)
|
|
|
|
DEFINE_GLOBAL(CleanWidth_1)
|
|
|
|
DEFINE_GLOBAL(CleanHeight_1)
|