1033 lines
25 KiB
C
1033 lines
25 KiB
C
// SONIC ROBO BLAST 2
|
|
//-----------------------------------------------------------------------------
|
|
// Copyright (C) 1993-1996 by id Software, Inc.
|
|
// Copyright (C) 1998-2000 by DooM Legacy Team.
|
|
// Copyright (C) 1999-2019 by Sonic Team Junior.
|
|
//
|
|
// This program is free software distributed under the
|
|
// terms of the GNU General Public License, version 2.
|
|
// See the 'LICENSE' file for more details.
|
|
//-----------------------------------------------------------------------------
|
|
/// \file
|
|
/// \brief miscellaneous drawing (mainly 2d)
|
|
|
|
#ifdef __GNUC__
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#include "../doomdef.h"
|
|
|
|
#ifdef HWRENDER
|
|
|
|
#include "hw_main.h"
|
|
#include "hw_glob.h"
|
|
#include "hw_gl.h"
|
|
|
|
#include "../r_draw.h" //viewborderlump
|
|
#include "../r_main.h"
|
|
#include "../w_wad.h"
|
|
#include "../z_zone.h"
|
|
#include "../v_video.h"
|
|
#include "../st_stuff.h"
|
|
|
|
#include <fcntl.h>
|
|
|
|
static const UINT8 softwaretranstogl[11] = { 0, 25, 51, 76,102,127,153,178,204,229,255};
|
|
static const UINT8 softwaretranstogl_hi[11] = { 0, 51,102,153,204,255,255,255,255,255,255};
|
|
static const UINT8 softwaretranstogl_lo[11] = { 0, 12, 24, 36, 48, 60, 71, 83, 95,111,127};
|
|
|
|
static const float FLOATBASEVIDWIDTH = (float)BASEVIDWIDTH;
|
|
static const float FLOATBASEVIDHEIGHT = (float)BASEVIDHEIGHT;
|
|
|
|
void HWR_DrawStretchyFixedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, fixed_t vscale, INT32 option, const UINT8 *colormap, INT32 bflags)
|
|
{
|
|
FOutVector v[4];
|
|
FBITFIELD flags;
|
|
float cx, cy;
|
|
UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
|
|
UINT8 blendmode = ((bflags & V_BLENDMASK) >> V_BLENDSHIFT);
|
|
GLPatch_t *hwrPatch;
|
|
|
|
// 3--2
|
|
// | /|
|
|
// |/ |
|
|
// 0--1
|
|
float dup, fscalew, fscaleh, fwidth, fheight;
|
|
|
|
if (alphalevel >= 10 && alphalevel < 13)
|
|
return;
|
|
|
|
cx = FIXED_TO_FLOAT(x);
|
|
cy = FIXED_TO_FLOAT(y);
|
|
|
|
const float fvw = (float)vid.width;
|
|
const float fvh = (float)vid.height;
|
|
|
|
// make patch ready in hardware cache
|
|
if (!colormap)
|
|
HWR_GetPatch(gpatch);
|
|
else
|
|
HWR_GetMappedPatch(gpatch, colormap);
|
|
|
|
hwrPatch = ((GLPatch_t *)gpatch->hardware);
|
|
|
|
dup = (float)vid.dup;
|
|
|
|
switch (option & V_SCALEPATCHMASK)
|
|
{
|
|
case V_NOSCALEPATCH:
|
|
dup = 1.0f;
|
|
break;
|
|
case V_SMALLSCALEPATCH:
|
|
dup = (float)vid.smalldup;
|
|
break;
|
|
case V_MEDSCALEPATCH:
|
|
dup = (float)vid.meddup;
|
|
break;
|
|
}
|
|
|
|
fscalew = fscaleh = FIXED_TO_FLOAT(pscale);
|
|
if (vscale != pscale)
|
|
fscaleh = FIXED_TO_FLOAT(vscale);
|
|
|
|
// See my comments in v_video.c's V_DrawFixedPatch
|
|
// -- Monster Iestyn 29/10/18
|
|
{
|
|
float offsetx = 0.0f, offsety = 0.0f;
|
|
|
|
// left offset
|
|
if (option & V_FLIP)
|
|
offsetx = (float)(gpatch->width - gpatch->leftoffset) * fscalew;
|
|
else
|
|
offsetx = (float)(gpatch->leftoffset) * fscalew;
|
|
|
|
// top offset
|
|
// TODO: make some kind of vertical version of V_FLIP, maybe by deprecating V_OFFSET in future?!?
|
|
offsety = (float)(gpatch->topoffset) * fscaleh;
|
|
|
|
if ((option & (V_NOSCALESTART|V_OFFSET)) == (V_NOSCALESTART|V_OFFSET)) // Multiply by dup for crosshairs
|
|
{
|
|
offsetx *= dup;
|
|
offsety *= dup;
|
|
}
|
|
|
|
cx -= offsetx;
|
|
cy -= offsety;
|
|
}
|
|
|
|
if (option & V_SPLITSCREEN)
|
|
cy += FIXED_TO_FLOAT((BASEVIDHEIGHT/2)<<FRACBITS);
|
|
|
|
if (option & V_HORZSCREEN)
|
|
cx += FIXED_TO_FLOAT((BASEVIDWIDTH/2)<<FRACBITS);
|
|
|
|
if (!(option & V_NOSCALESTART))
|
|
{
|
|
cx = cx * dup;
|
|
cy = cy * dup;
|
|
|
|
if (!(option & V_SCALEPATCHMASK))
|
|
{
|
|
// if it's meant to cover the whole screen, black out the rest
|
|
// cx and cy are possibly *slightly* off from float maths
|
|
// This is done before here compared to software because we directly alter cx and cy to centre
|
|
if (cx >= -0.1f && cx <= 0.1f && gpatch->width == BASEVIDWIDTH && cy >= -0.1f && cy <= 0.1f && gpatch->height == BASEVIDHEIGHT)
|
|
{
|
|
const column_t *column = (const column_t *)((const UINT8 *)(gpatch->columns) + (gpatch->columnofs[0]));
|
|
|
|
if (!column->topdelta)
|
|
{
|
|
const UINT8 *source = (const UINT8 *)(column) + 3;
|
|
HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]);
|
|
}
|
|
}
|
|
|
|
// centre screen
|
|
if (fabsf(fvw - FLOATBASEVIDWIDTH * dup) > 1.0E-36f)
|
|
{
|
|
if (option & V_SNAPTORIGHT)
|
|
cx += (fvw - (FLOATBASEVIDWIDTH * dup));
|
|
else if (!(option & V_SNAPTOLEFT))
|
|
cx += (fvw - (FLOATBASEVIDWIDTH * dup))/2.0f;
|
|
}
|
|
|
|
if (fabsf(fvh - FLOATBASEVIDHEIGHT * dup) > 1.0E-36f)
|
|
{
|
|
if ((option & (V_SPLITSCREEN|V_SNAPTOTOP)) == (V_SPLITSCREEN|V_SNAPTOTOP))
|
|
cy += (fvh/2.0f - (FLOATBASEVIDHEIGHT/2.0f * dup));
|
|
else if (option & V_SNAPTOBOTTOM)
|
|
cy += (fvh - (FLOATBASEVIDHEIGHT * dup));
|
|
else if (!(option & V_SNAPTOTOP))
|
|
cy += (fvh - (FLOATBASEVIDHEIGHT * dup))/2.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
fwidth = (float)(gpatch->width) * fscalew * dup;
|
|
fheight = (float)(gpatch->height) * fscaleh * dup;
|
|
|
|
// positions of the cx, cy, are between 0 and vid.width/vid.height now, we need them to be between -1 and 1
|
|
cx = -1.0f + (cx / (fvw / 2.0f));
|
|
cy = 1.0f - (cy / (fvh / 2.0f));
|
|
|
|
// fwidth and fheight are similar
|
|
fwidth /= fvw / 2.0f;
|
|
fheight /= fvh / 2.0f;
|
|
|
|
// set the polygon vertices to the right positions
|
|
v[0].x = v[3].x = cx;
|
|
v[2].x = v[1].x = cx + fwidth;
|
|
|
|
v[0].y = v[1].y = cy;
|
|
v[2].y = v[3].y = cy - fheight;
|
|
|
|
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
|
|
|
if (option & V_FLIP)
|
|
{
|
|
v[0].s = v[3].s = hwrPatch->max_s;
|
|
v[2].s = v[1].s = 0.0f;
|
|
}
|
|
else
|
|
{
|
|
v[0].s = v[3].s = 0.0f;
|
|
v[2].s = v[1].s = hwrPatch->max_s;
|
|
}
|
|
|
|
v[0].t = v[1].t = 0.0f;
|
|
v[2].t = v[3].t = hwrPatch->max_t;
|
|
|
|
// clip it since it is used for bunny scroll in doom I
|
|
if (blendmode)
|
|
flags = HWR_GetBlendModeFlag(blendmode+1)|PF_NoDepthTest;
|
|
else
|
|
flags = PF_Translucent|PF_NoDepthTest;
|
|
|
|
if (option & V_WRAPX)
|
|
flags |= PF_ForceWrapX;
|
|
if (option & V_WRAPY)
|
|
flags |= PF_ForceWrapY;
|
|
|
|
if (alphalevel)
|
|
{
|
|
FSurfaceInfo Surf = {};
|
|
Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
|
|
|
|
switch (alphalevel)
|
|
{
|
|
case 13: Surf.PolyColor.s.alpha = softwaretranstogl_lo[hudtrans]; break;
|
|
case 14: Surf.PolyColor.s.alpha = softwaretranstogl[hudtrans]; break;
|
|
case 15: Surf.PolyColor.s.alpha = softwaretranstogl_hi[hudtrans]; break;
|
|
default: Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel]; break;
|
|
}
|
|
|
|
flags |= PF_Modulated;
|
|
GL_DrawPolygon(&Surf, v, 4, flags);
|
|
}
|
|
else
|
|
GL_DrawPolygon(NULL, v, 4, flags);
|
|
}
|
|
|
|
void HWR_DrawCroppedPatch(patch_t *gpatch, fixed_t x, fixed_t y, fixed_t pscale, INT32 option, fixed_t sx, fixed_t sy, fixed_t w, fixed_t h)
|
|
{
|
|
FOutVector v[4];
|
|
FBITFIELD flags;
|
|
float cx, cy;
|
|
UINT8 alphalevel = ((option & V_ALPHAMASK) >> V_ALPHASHIFT);
|
|
GLPatch_t *hwrPatch;
|
|
|
|
// 3--2
|
|
// | /|
|
|
// |/ |
|
|
// 0--1
|
|
float dup, fscale, fwidth, fheight;
|
|
|
|
if (alphalevel >= 10 && alphalevel < 13)
|
|
return;
|
|
|
|
cx = FIXED_TO_FLOAT(x);
|
|
cy = FIXED_TO_FLOAT(y);
|
|
|
|
const float fvw = (float)vid.width;
|
|
const float fvh = (float)vid.height;
|
|
|
|
// make patch ready in hardware cache
|
|
HWR_GetPatch(gpatch);
|
|
hwrPatch = ((GLPatch_t *)gpatch->hardware);
|
|
|
|
dup = (float)vid.dup;
|
|
|
|
switch (option & V_SCALEPATCHMASK)
|
|
{
|
|
case V_NOSCALEPATCH:
|
|
dup = 1.0f;
|
|
break;
|
|
case V_SMALLSCALEPATCH:
|
|
dup = (float)vid.smalldup;
|
|
break;
|
|
case V_MEDSCALEPATCH:
|
|
dup = (float)vid.meddup;
|
|
break;
|
|
}
|
|
|
|
fscale = FIXED_TO_FLOAT(pscale);
|
|
|
|
cy -= (float)(gpatch->topoffset) * fscale;
|
|
cx -= (float)(gpatch->leftoffset) * fscale;
|
|
|
|
if (!(option & V_NOSCALESTART))
|
|
{
|
|
cx = cx * dup;
|
|
cy = cy * dup;
|
|
|
|
if (!(option & V_SCALEPATCHMASK))
|
|
{
|
|
// if it's meant to cover the whole screen, black out the rest
|
|
// cx and cy are possibly *slightly* off from float maths
|
|
// This is done before here compared to software because we directly alter cx and cy to centre
|
|
if (cx >= -0.1f && cx <= 0.1f && gpatch->width == BASEVIDWIDTH && cy >= -0.1f && cy <= 0.1f && gpatch->height == BASEVIDHEIGHT)
|
|
{
|
|
const column_t *column = (const column_t *)((const UINT8 *)(gpatch->columns) + (gpatch->columnofs[0]));
|
|
|
|
if (!column->topdelta)
|
|
{
|
|
const UINT8 *source = (const UINT8 *)(column) + 3;
|
|
HWR_DrawFill(0, 0, BASEVIDWIDTH, BASEVIDHEIGHT, source[0]);
|
|
}
|
|
}
|
|
|
|
// centre screen
|
|
if (fabsf(fvw - FLOATBASEVIDWIDTH * dup) > 1.0E-36f)
|
|
{
|
|
if (option & V_SNAPTORIGHT)
|
|
cx += (fvw - (FLOATBASEVIDWIDTH * dup));
|
|
else if (!(option & V_SNAPTOLEFT))
|
|
cx += (fvw - (FLOATBASEVIDWIDTH * dup))/2.0f;
|
|
}
|
|
|
|
if (fabsf(fvh - FLOATBASEVIDHEIGHT * dup) > 1.0E-36f)
|
|
{
|
|
if ((option & (V_SPLITSCREEN|V_SNAPTOTOP)) == (V_SPLITSCREEN|V_SNAPTOTOP))
|
|
cy += (fvh/2.0f - (FLOATBASEVIDHEIGHT/2.0f * dup));
|
|
else if (option & V_SNAPTOBOTTOM)
|
|
cy += (fvh - (FLOATBASEVIDHEIGHT * dup));
|
|
else if (!(option & V_SNAPTOTOP))
|
|
cy += (fvh - (FLOATBASEVIDHEIGHT * dup))/2.0f;
|
|
}
|
|
}
|
|
}
|
|
|
|
fwidth = w;
|
|
fheight = h;
|
|
|
|
if (fwidth > w - sx)
|
|
fwidth = w - sx;
|
|
|
|
if (fheight > h - sy)
|
|
fheight = h - sy;
|
|
|
|
if (fwidth > gpatch->width)
|
|
fwidth = gpatch->width;
|
|
|
|
if (fheight > gpatch->height)
|
|
fheight = gpatch->height;
|
|
|
|
if (pscale != FRACUNIT)
|
|
{
|
|
fwidth *= fscale * dup;
|
|
fheight *= fscale * dup;
|
|
}
|
|
else
|
|
{
|
|
fwidth *= dup;
|
|
fheight *= dup;
|
|
}
|
|
|
|
// positions of the cx, cy, are between 0 and vid.width/vid.height now, we need them to be between -1 and 1
|
|
cx = -1.0f + (cx / (fvw / 2.0f));
|
|
cy = 1.0f - (cy / (fvh / 2.0f));
|
|
|
|
// fwidth and fheight are similar
|
|
fwidth /= fvw / 2.0f;
|
|
fheight /= fvh / 2.0f;
|
|
|
|
// set the polygon vertices to the right positions
|
|
v[0].x = v[3].x = cx;
|
|
v[2].x = v[1].x = cx + fwidth;
|
|
|
|
v[0].y = v[1].y = cy;
|
|
v[2].y = v[3].y = cy - fheight;
|
|
|
|
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
|
|
|
v[0].s = v[3].s = ((sx)/(float)(gpatch->width) )*hwrPatch->max_s;
|
|
v[2].s = v[1].s = ((w )/(float)(gpatch->width) )*hwrPatch->max_s;
|
|
v[0].t = v[1].t = ((sy)/(float)(gpatch->height))*hwrPatch->max_t;
|
|
v[2].t = v[3].t = ((h )/(float)(gpatch->height))*hwrPatch->max_t;
|
|
|
|
flags = PF_Translucent|PF_NoDepthTest;
|
|
|
|
if (option & V_WRAPX)
|
|
flags |= PF_ForceWrapX;
|
|
if (option & V_WRAPY)
|
|
flags |= PF_ForceWrapY;
|
|
|
|
// clip it since it is used for bunny scroll in doom I
|
|
if (alphalevel)
|
|
{
|
|
FSurfaceInfo Surf = {};
|
|
Surf.PolyColor.s.red = Surf.PolyColor.s.green = Surf.PolyColor.s.blue = 0xff;
|
|
|
|
switch (alphalevel)
|
|
{
|
|
case 13: Surf.PolyColor.s.alpha = softwaretranstogl_lo[cv_translucenthud.value]; break;
|
|
case 14: Surf.PolyColor.s.alpha = softwaretranstogl[cv_translucenthud.value]; break;
|
|
case 15: Surf.PolyColor.s.alpha = softwaretranstogl_hi[cv_translucenthud.value]; break;
|
|
default: Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel]; break;
|
|
}
|
|
|
|
flags |= PF_Modulated;
|
|
GL_DrawPolygon(&Surf, v, 4, flags);
|
|
}
|
|
else
|
|
GL_DrawPolygon(NULL, v, 4, flags);
|
|
}
|
|
|
|
// ==========================================================================
|
|
// V_VIDEO.C STUFF
|
|
// ==========================================================================
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Fills a box of pixels using a flat texture as a pattern
|
|
// --------------------------------------------------------------------------
|
|
void HWR_DrawFlatFill(INT32 x, INT32 y, INT32 w, INT32 h, lumpnum_t flatlumpnum)
|
|
{
|
|
FOutVector v[4];
|
|
float dflatsize;
|
|
INT32 flatflag;
|
|
const size_t len = W_LumpLength(flatlumpnum);
|
|
|
|
switch (len)
|
|
{
|
|
case 4194304: // 2048x2048 lump
|
|
dflatsize = 2048.0f;
|
|
flatflag = 2047;
|
|
break;
|
|
case 1048576: // 1024x1024 lump
|
|
dflatsize = 1024.0f;
|
|
flatflag = 1023;
|
|
break;
|
|
case 262144:// 512x512 lump
|
|
dflatsize = 512.0f;
|
|
flatflag = 511;
|
|
break;
|
|
case 65536: // 256x256 lump
|
|
dflatsize = 256.0f;
|
|
flatflag = 255;
|
|
break;
|
|
case 16384: // 128x128 lump
|
|
dflatsize = 128.0f;
|
|
flatflag = 127;
|
|
break;
|
|
case 1024: // 32x32 lump
|
|
dflatsize = 32.0f;
|
|
flatflag = 31;
|
|
break;
|
|
default: // 64x64 lump
|
|
dflatsize = 64.0f;
|
|
flatflag = 63;
|
|
break;
|
|
}
|
|
|
|
// 3--2
|
|
// | /|
|
|
// |/ |
|
|
// 0--1
|
|
|
|
v[0].x = v[3].x = (x - 160.0f)/160.0f;
|
|
v[2].x = v[1].x = ((x+w) - 160.0f)/160.0f;
|
|
v[0].y = v[1].y = -(y - 100.0f)/100.0f;
|
|
v[2].y = v[3].y = -((y+h) - 100.0f)/100.0f;
|
|
|
|
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
|
|
|
// flat is 64x64 lod and texture offsets are [0.0, 1.0]
|
|
v[0].s = v[3].s = (float)((x & flatflag)/dflatsize);
|
|
v[2].s = v[1].s = (float)(v[0].s + w/dflatsize);
|
|
v[0].t = v[1].t = (float)((y & flatflag)/dflatsize);
|
|
v[2].t = v[3].t = (float)(v[0].t + h/dflatsize);
|
|
|
|
HWR_GetFlat(flatlumpnum, false); // Never Encore map drawflatfill, duh.
|
|
|
|
//Hurdler: Boris, the same comment as above... but maybe for pics
|
|
// it not a problem since they don't have any transparent pixel
|
|
// if I'm right !?
|
|
// BTW, I see we put 0 for PFs, and If I'm right, that
|
|
// means we take the previous PFs as default
|
|
// how can we be sure they are ok?
|
|
GL_DrawPolygon(NULL, v, 4, PF_NoDepthTest); //PF_Translucent);
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Fade down the screen so that the menu drawn on top of it looks brighter
|
|
// --------------------------------------------------------------------------
|
|
// 3--2
|
|
// | /|
|
|
// |/ |
|
|
// 0--1
|
|
void HWR_FadeScreenMenuBack(UINT16 color, UINT8 strength)
|
|
{
|
|
FOutVector v[4];
|
|
FSurfaceInfo Surf = {};
|
|
FBITFIELD poly_flags = PF_NoTexture|PF_Modulated|PF_NoDepthTest;
|
|
|
|
v[0].x = v[3].x = -1.0f;
|
|
v[2].x = v[1].x = 1.0f;
|
|
v[0].y = v[1].y = -1.0f;
|
|
v[2].y = v[3].y = 1.0f;
|
|
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
|
|
|
v[0].s = v[3].s = 0.0f;
|
|
v[2].s = v[1].s = 1.0f;
|
|
v[0].t = v[1].t = 1.0f;
|
|
v[2].t = v[3].t = 0.0f;
|
|
|
|
if (color & 0xFF00) // Do COLORMAP fade.
|
|
{
|
|
if (cv_glscreentextures.value && HWR_ShouldUsePaletteRendering())
|
|
{
|
|
const hwdscreentexture_t scr_tex = HWD_SCREENTEXTURE_GENERIC2;
|
|
|
|
Surf.LightTableId = HWR_GetLightTableID(NULL);
|
|
Surf.LightInfo.light_level = strength;
|
|
GL_MakeScreenTexture(scr_tex);
|
|
GL_SetShader(HWR_GetShaderFromTarget(SHADER_UI_COLORMAP_FADE));
|
|
GL_DrawScreenTexture(scr_tex, &Surf, PF_ColorMapped|PF_NoDepthTest);
|
|
GL_UnSetShader();
|
|
return;
|
|
}
|
|
|
|
Surf.PolyColor.rgba = UINT2RGBA(0x01010160);
|
|
Surf.PolyColor.s.alpha = (strength*8);
|
|
poly_flags |= PF_Translucent;
|
|
}
|
|
else // Do TRANSMAP** fade.
|
|
{
|
|
const RGBA_t *palette = HWR_GetTexturePalette();
|
|
Surf.PolyColor.rgba = palette[color&0xFF].rgba;
|
|
|
|
if (HWR_ShouldUsePaletteRendering())
|
|
Surf.PolyColor.s.alpha = softwaretranstogl[strength];
|
|
else
|
|
Surf.PolyColor.s.alpha = (UINT8)(strength*25.5f);
|
|
|
|
poly_flags |= PF_Translucent;
|
|
}
|
|
|
|
GL_DrawPolygon(&Surf, v, 4, poly_flags);
|
|
}
|
|
|
|
// Draw the console background with translucency support
|
|
void HWR_DrawConsoleBack(UINT32 color, INT32 height)
|
|
{
|
|
FOutVector v[4];
|
|
FSurfaceInfo Surf = {};
|
|
|
|
// setup some neat-o translucency effect
|
|
if (!height) //cool hack 0 height is full height
|
|
height = vid.height;
|
|
|
|
v[0].x = v[3].x = -1.0f;
|
|
v[2].x = v[1].x = 1.0f;
|
|
v[0].y = v[1].y = 1.0f-((height<<1)/(float)vid.height);
|
|
v[2].y = v[3].y = 1.0f;
|
|
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
|
|
|
v[0].s = v[3].s = 0.0f;
|
|
v[2].s = v[1].s = 1.0f;
|
|
v[0].t = v[1].t = 1.0f;
|
|
v[2].t = v[3].t = 0.0f;
|
|
|
|
Surf.PolyColor.rgba = UINT2RGBA(color);
|
|
Surf.PolyColor.s.alpha = 0x80;
|
|
|
|
GL_DrawPolygon(&Surf, v, 4, PF_NoTexture|PF_Modulated|PF_Translucent|PF_NoDepthTest);
|
|
}
|
|
|
|
|
|
// ==========================================================================
|
|
// AM_MAP.C DRAWING STUFF
|
|
// ==========================================================================
|
|
|
|
// -----------------+
|
|
// HWR_drawAMline : draw a line of the automap (the clipping is already done in automap code)
|
|
// Arg : color is a RGB 888 value
|
|
// -----------------+
|
|
void HWR_drawAMline(const fline_t *fl, INT32 color)
|
|
{
|
|
F2DCoord v1, v2;
|
|
RGBA_t color_rgba;
|
|
const RGBA_t *palette = HWR_GetTexturePalette();
|
|
|
|
color_rgba = palette[color&0xFF];
|
|
|
|
v1.x = ((float)fl->a.x-(vid.width/2.0f))*(2.0f/vid.width);
|
|
v1.y = ((float)fl->a.y-(vid.height/2.0f))*(2.0f/vid.height);
|
|
|
|
v2.x = ((float)fl->b.x-(vid.width/2.0f))*(2.0f/vid.width);
|
|
v2.y = ((float)fl->b.y-(vid.height/2.0f))*(2.0f/vid.height);
|
|
|
|
GL_Draw2DLine(&v1, &v2, color_rgba);
|
|
}
|
|
|
|
// -----------------+
|
|
// HWR_DrawDiag : draw flat coloured rectangle, with no texture
|
|
// -----------------+
|
|
void HWR_DrawDiag(INT32 x, INT32 y, INT32 wh, INT32 color)
|
|
{
|
|
FOutVector v[4];
|
|
FSurfaceInfo Surf = {};
|
|
float fx, fy, fw, fh, fwait = 0;
|
|
RGBA_t *palette;
|
|
|
|
if (wh < 0)
|
|
return; // consistency w/ software
|
|
|
|
// 3--2
|
|
// | /|
|
|
// |/ |
|
|
// 0--1
|
|
|
|
fx = (float)x;
|
|
fy = (float)y;
|
|
fw = fh = (float)wh;
|
|
|
|
const float fvw = (float)vid.width;
|
|
const float fvh = (float)vid.height;
|
|
|
|
if (!(color & V_NOSCALESTART))
|
|
{
|
|
const float dup = (float)vid.dup;
|
|
|
|
fx *= dup;
|
|
fy *= dup;
|
|
fw *= dup;
|
|
fh *= dup;
|
|
|
|
if (fabsf(fvw - (FLOATBASEVIDWIDTH * dup)) > 1.0E-36f)
|
|
{
|
|
if (color & V_SNAPTORIGHT)
|
|
fx += (fvw - (FLOATBASEVIDWIDTH * dup));
|
|
else if (!(color & V_SNAPTOLEFT))
|
|
fx += (fvw - (FLOATBASEVIDWIDTH * dup)) / 2.0f;
|
|
}
|
|
|
|
if (fabsf(fvh - (FLOATBASEVIDHEIGHT * dup)) > 1.0E-36f)
|
|
{
|
|
// same thing here
|
|
if (color & V_SNAPTOBOTTOM)
|
|
fy += (fvh - (FLOATBASEVIDHEIGHT * dup));
|
|
else if (!(color & V_SNAPTOTOP))
|
|
fy += (fvh - (FLOATBASEVIDHEIGHT * dup)) / 2.0f;
|
|
}
|
|
}
|
|
|
|
if (fx >= vid.width || fy >= vid.height)
|
|
return;
|
|
|
|
if (fx < 0)
|
|
{
|
|
fw += fx;
|
|
fx = 0;
|
|
}
|
|
|
|
if (fy < 0)
|
|
{
|
|
fh += fy;
|
|
fy = 0;
|
|
}
|
|
|
|
if (fw <= 0 || fh <= 0)
|
|
return;
|
|
|
|
if (fx + fw > vid.width)
|
|
{
|
|
fwait = fw - (fvw- fx);
|
|
fw = fvw - fx;
|
|
}
|
|
|
|
if (fy + fh > vid.height)
|
|
fh = fvh - fy;
|
|
|
|
fx = -1.0f + fx / (fvw / 2.0f);
|
|
fy = 1.0f - fy / (fvh / 2.0f);
|
|
fw = fw / (fvw / 2.0f);
|
|
fh = fh / (fvh / 2.0f);
|
|
|
|
v[0].x = v[3].x = fx;
|
|
v[2].x = v[1].x = fx + fw;
|
|
v[0].y = v[1].y = fy;
|
|
v[3].y = fy - fh;
|
|
v[2].y = fy - fwait;
|
|
|
|
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
|
|
|
v[0].s = v[3].s = 0.0f;
|
|
v[2].s = v[1].s = 1.0f;
|
|
v[0].t = v[1].t = 0.0f;
|
|
v[2].t = v[3].t = 1.0f;
|
|
|
|
palette = HWR_GetTexturePalette();
|
|
|
|
Surf.PolyColor = palette[color&0xFF];
|
|
|
|
GL_DrawPolygon(&Surf, v, 4, PF_Modulated|PF_NoTexture|PF_NoDepthTest);
|
|
}
|
|
|
|
// -------------------+
|
|
// HWR_DrawConsoleFill : draw flat coloured transparent rectangle because that's cool, and hw sucks less than sw for that.
|
|
// -------------------+
|
|
void HWR_DrawConsoleFill(INT32 x, INT32 y, INT32 w, INT32 h, UINT32 color, INT32 options)
|
|
{
|
|
FOutVector v[4];
|
|
FSurfaceInfo Surf = {};
|
|
float fx, fy, fw, fh;
|
|
|
|
if (w < 0 || h < 0)
|
|
return; // consistency w/ software
|
|
|
|
// 3--2
|
|
// | /|
|
|
// |/ |
|
|
// 0--1
|
|
|
|
fx = (float)x;
|
|
fy = (float)y;
|
|
fw = (float)w;
|
|
fh = (float)h;
|
|
|
|
const float fvw = (float)vid.width;
|
|
const float fvh = (float)vid.height;
|
|
|
|
if (!(options & V_NOSCALESTART))
|
|
{
|
|
const float dup = (float)vid.dup;
|
|
|
|
if (x == 0 && y == 0 && w == BASEVIDWIDTH && h == BASEVIDHEIGHT)
|
|
{
|
|
RGBA_t *palette = HWR_GetTexturePalette();
|
|
RGBA_t rgbaColour = palette[color&0xFF];
|
|
FRGBAFloat clearColour;
|
|
clearColour.red = (float)rgbaColour.s.red / 255;
|
|
clearColour.green = (float)rgbaColour.s.green / 255;
|
|
clearColour.blue = (float)rgbaColour.s.blue / 255;
|
|
clearColour.alpha = 1;
|
|
GL_ClearBuffer(true, false, false, &clearColour);
|
|
return;
|
|
}
|
|
|
|
fx *= dup;
|
|
fy *= dup;
|
|
fw *= dup;
|
|
fh *= dup;
|
|
|
|
if (fabsf(fvw - (FLOATBASEVIDWIDTH * dup)) > 1.0E-36f)
|
|
{
|
|
if (options & V_SNAPTORIGHT)
|
|
fx += (fvw - (FLOATBASEVIDWIDTH * dup));
|
|
else if (!(options & V_SNAPTOLEFT))
|
|
fx += (fvw - (FLOATBASEVIDWIDTH * dup)) / 2;
|
|
}
|
|
|
|
if (fabsf(fvh - (FLOATBASEVIDHEIGHT * dup)) > 1.0E-36f)
|
|
{
|
|
// same thing here
|
|
if (options & V_SNAPTOBOTTOM)
|
|
fy += (fvh - (FLOATBASEVIDHEIGHT * dup));
|
|
else if (!(options & V_SNAPTOTOP))
|
|
fy += (fvh - (FLOATBASEVIDHEIGHT * dup)) / 2;
|
|
}
|
|
|
|
if (options & V_SPLITSCREEN)
|
|
fy += (FLOATBASEVIDHEIGHT * dup)/2;
|
|
if (options & V_HORZSCREEN)
|
|
fx += (FLOATBASEVIDWIDTH * dup)/2;
|
|
}
|
|
|
|
if (fx >= vid.width || fy >= vid.height)
|
|
return;
|
|
|
|
if (fx < 0)
|
|
{
|
|
fw += fx;
|
|
fx = 0;
|
|
}
|
|
|
|
if (fy < 0)
|
|
{
|
|
fh += fy;
|
|
fy = 0;
|
|
}
|
|
|
|
if (fw <= 0 || fh <= 0)
|
|
return;
|
|
|
|
if (fx + fw > vid.width)
|
|
fw = fvw - fx;
|
|
|
|
if (fy + fh > vid.height)
|
|
fh = fvh - fy;
|
|
|
|
fx = -1.0f + fx / (fvw / 2.0f);
|
|
fy = 1.0f - fy / (fvh / 2.0f);
|
|
fw = fw / (fvw / 2.0f);
|
|
fh = fh / (fvh / 2.0f);
|
|
|
|
v[0].x = v[3].x = fx;
|
|
v[2].x = v[1].x = fx + fw;
|
|
v[0].y = v[1].y = fy;
|
|
v[2].y = v[3].y = fy - fh;
|
|
|
|
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
|
|
|
v[0].s = v[3].s = 0.0f;
|
|
v[2].s = v[1].s = 1.0f;
|
|
v[0].t = v[1].t = 0.0f;
|
|
v[2].t = v[3].t = 1.0f;
|
|
|
|
Surf.PolyColor.rgba = UINT2RGBA(color);
|
|
Surf.PolyColor.s.alpha = 0x80;
|
|
|
|
GL_DrawPolygon(&Surf, v, 4, PF_NoTexture|PF_Modulated|PF_Translucent|PF_NoDepthTest);
|
|
}
|
|
|
|
// -----------------+
|
|
// HWR_DrawFill : draw flat coloured rectangle, with no texture
|
|
// -----------------+
|
|
// alug: now with translucency support X)
|
|
void HWR_DrawFill(INT32 x, INT32 y, INT32 w, INT32 h, INT32 color)
|
|
{
|
|
FOutVector v[4];
|
|
FSurfaceInfo Surf = {};
|
|
float fx, fy, fw, fh;
|
|
|
|
if (w < 0 || h < 0)
|
|
return; // consistency w/ software
|
|
|
|
const UINT8 alphalevel = ((color & V_ALPHAMASK) >> V_ALPHASHIFT);
|
|
const RGBA_t *palette = HWR_GetTexturePalette();
|
|
|
|
// 3--2
|
|
// | /|
|
|
// |/ |
|
|
// 0--1
|
|
|
|
fx = (float)x;
|
|
fy = (float)y;
|
|
fw = (float)w;
|
|
fh = (float)h;
|
|
|
|
const float fvw = (float)vid.width;
|
|
const float fvh = (float)vid.height;
|
|
|
|
if (!(color & V_NOSCALESTART))
|
|
{
|
|
const float dup = (float)vid.dup;
|
|
|
|
if (x == 0 && y == 0 && w == BASEVIDWIDTH && h == BASEVIDHEIGHT)
|
|
{
|
|
RGBA_t rgbaColour = palette[color&0xFF];
|
|
FRGBAFloat clearColour;
|
|
clearColour.red = (float)rgbaColour.s.red / 255;
|
|
clearColour.green = (float)rgbaColour.s.green / 255;
|
|
clearColour.blue = (float)rgbaColour.s.blue / 255;
|
|
clearColour.alpha = 1;
|
|
GL_ClearBuffer(true, false, false, &clearColour);
|
|
return;
|
|
}
|
|
|
|
fx *= dup;
|
|
fy *= dup;
|
|
fw *= dup;
|
|
fh *= dup;
|
|
|
|
if (fabsf(fvw - FLOATBASEVIDWIDTH * dup) > 1.0E-36f)
|
|
{
|
|
if (color & V_SNAPTORIGHT)
|
|
fx += (fvw - (FLOATBASEVIDWIDTH * dup));
|
|
else if (!(color & V_SNAPTOLEFT))
|
|
fx += (fvw - (FLOATBASEVIDWIDTH * dup)) / 2;
|
|
}
|
|
|
|
if (fabsf(fvh - FLOATBASEVIDHEIGHT * dup) > 1.0E-36f)
|
|
{
|
|
// same thing here
|
|
if (color & V_SNAPTOBOTTOM)
|
|
fy += (fvh - (FLOATBASEVIDHEIGHT * dup));
|
|
else if (!(color & V_SNAPTOTOP))
|
|
fy += (fvh - (FLOATBASEVIDHEIGHT * dup)) / 2;
|
|
}
|
|
|
|
if (color & V_SPLITSCREEN)
|
|
fy += (FLOATBASEVIDHEIGHT * dup)/2;
|
|
if (color & V_HORZSCREEN)
|
|
fx += (FLOATBASEVIDWIDTH * dup)/2;
|
|
}
|
|
|
|
if (fx >= vid.width || fy >= vid.height)
|
|
return;
|
|
|
|
if (fx < 0)
|
|
{
|
|
fw += fx;
|
|
fx = 0;
|
|
}
|
|
|
|
if (fy < 0)
|
|
{
|
|
fh += fy;
|
|
fy = 0;
|
|
}
|
|
|
|
if (fw <= 0 || fh <= 0)
|
|
return;
|
|
|
|
if (fx + fw > vid.width)
|
|
fw = fvw - fx;
|
|
|
|
if (fy + fh > vid.height)
|
|
fh = fvh - fy;
|
|
|
|
fx = -1.0f + fx / (fvw / 2.0f);
|
|
fy = 1.0f - fy / (fvh / 2.0f);
|
|
fw = fw / (fvw / 2.0f);
|
|
fh = fh / (fvh / 2.0f);
|
|
|
|
v[0].x = v[3].x = fx;
|
|
v[2].x = v[1].x = fx + fw;
|
|
v[0].y = v[1].y = fy;
|
|
v[2].y = v[3].y = fy - fh;
|
|
|
|
v[0].z = v[1].z = v[2].z = v[3].z = 1.0f;
|
|
|
|
v[0].s = v[3].s = 0.0f;
|
|
v[2].s = v[1].s = 1.0f;
|
|
v[0].t = v[1].t = 0.0f;
|
|
v[2].t = v[3].t = 1.0f;
|
|
|
|
Surf.PolyColor = palette[color&0xFF];
|
|
|
|
if (alphalevel)
|
|
{
|
|
switch (alphalevel)
|
|
{
|
|
case 13: Surf.PolyColor.s.alpha = softwaretranstogl_lo[hudtrans]; break;
|
|
case 14: Surf.PolyColor.s.alpha = softwaretranstogl[hudtrans]; break;
|
|
case 15: Surf.PolyColor.s.alpha = softwaretranstogl_hi[hudtrans]; break;
|
|
default: Surf.PolyColor.s.alpha = softwaretranstogl[10-alphalevel]; break;
|
|
}
|
|
}
|
|
|
|
GL_DrawPolygon(&Surf, v, 4, PF_NoTexture|PF_Modulated|PF_Translucent|PF_NoDepthTest);
|
|
}
|
|
|
|
#ifdef HAVE_PNG
|
|
|
|
#ifndef _LARGEFILE64_SOURCE
|
|
#define _LARGEFILE64_SOURCE
|
|
#endif
|
|
|
|
#ifndef _LFS64_LARGEFILE
|
|
#define _LFS64_LARGEFILE
|
|
#endif
|
|
|
|
#ifndef _FILE_OFFSET_BITS
|
|
#define _FILE_OFFSET_BITS 0
|
|
#endif
|
|
|
|
#include "png.h"
|
|
#ifdef PNG_WRITE_SUPPORTED
|
|
#define USE_PNG // PNG is only used if write is supported (see ../m_misc.c)
|
|
#endif
|
|
#endif
|
|
|
|
#ifndef USE_PNG
|
|
typedef struct
|
|
{
|
|
UINT8 id_field_length ; // 1
|
|
UINT8 color_map_type ; // 2
|
|
UINT8 image_type ; // 3
|
|
UINT8 dummy[5] ; // 4, 8
|
|
INT16 x_origin ; // 9, 10
|
|
INT16 y_origin ; //11, 12
|
|
INT16 width ; //13, 14
|
|
INT16 height ; //15, 16
|
|
UINT8 image_pix_size ; //17
|
|
UINT8 image_descriptor; //18
|
|
} ATTRPACK TGAHeader; // sizeof is 18
|
|
|
|
// --------------------------------------------------------------------------
|
|
// save screenshots with TGA format
|
|
// --------------------------------------------------------------------------
|
|
static inline boolean saveTGA(const char *file_name, void *buffer,
|
|
INT32 width, INT32 height)
|
|
{
|
|
INT32 fd;
|
|
TGAHeader tga_hdr;
|
|
INT32 i;
|
|
UINT8 *buf8 = buffer;
|
|
|
|
fd = open(file_name, O_WRONLY | O_CREAT | O_TRUNC, 0666);
|
|
if (fd < 0)
|
|
return false;
|
|
|
|
memset(&tga_hdr, 0, sizeof (tga_hdr));
|
|
tga_hdr.width = SHORT(width);
|
|
tga_hdr.height = SHORT(height);
|
|
tga_hdr.image_pix_size = 24;
|
|
tga_hdr.image_type = 2;
|
|
tga_hdr.image_descriptor = 32;
|
|
|
|
if ( -1 == write(fd, &tga_hdr, sizeof (TGAHeader)))
|
|
{
|
|
close(fd);
|
|
return false;
|
|
}
|
|
// format to 888 BGR
|
|
for (i = 0; i < width * height * 3; i+=3)
|
|
{
|
|
const UINT8 temp = buf8[i];
|
|
buf8[i] = buf8[i+2];
|
|
buf8[i+2] = temp;
|
|
}
|
|
if ( -1 == write(fd, buffer, width * height * 3))
|
|
{
|
|
close(fd);
|
|
return false;
|
|
}
|
|
close(fd);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
// --------------------------------------------------------------------------
|
|
// screen shot
|
|
// --------------------------------------------------------------------------
|
|
UINT8 *HWR_GetScreenshot(INT32 scale)
|
|
{
|
|
static UINT8 *buf = NULL;
|
|
|
|
buf = realloc(buf, (vid.width/scale)*(vid.height/scale)*3);
|
|
|
|
if (!buf)
|
|
return NULL;
|
|
|
|
// returns 24bit 888 RGB
|
|
GL_ReadScreenTexture(HWD_SCREENTEXTURE_GENERIC2, (void *)buf, scale);
|
|
return buf;
|
|
}
|
|
|
|
#endif //HWRENDER
|