1585 lines
43 KiB
C
1585 lines
43 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 MD2 Handling
|
||
/// Inspired from md2.c by Mete Ciragan (mete@swissquake.ch)
|
||
|
||
|
||
#ifdef __GNUC__
|
||
#include <unistd.h>
|
||
#endif
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <math.h>
|
||
|
||
#include "../doomdef.h"
|
||
#include "../doomstat.h"
|
||
|
||
#ifdef HWRENDER
|
||
|
||
#include "hw_gl.h"
|
||
#include "hw_md2.h"
|
||
#include "../d_main.h"
|
||
#include "../r_bsp.h"
|
||
#include "../r_fps.h"
|
||
#include "../r_main.h"
|
||
#include "../p_setup.h"
|
||
#include "../m_misc.h"
|
||
#include "../w_wad.h"
|
||
#include "../z_zone.h"
|
||
#include "../r_things.h"
|
||
#include "../r_draw.h"
|
||
#include "../p_tick.h"
|
||
#include "../k_kart.h" // colortranslations
|
||
#include "../g_game.h" // cv_sloperoll
|
||
#include "hw_model.h"
|
||
|
||
#include "hw_main.h"
|
||
#include "../v_video.h"
|
||
|
||
#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"
|
||
#ifndef PNG_READ_SUPPORTED
|
||
#undef HAVE_PNG
|
||
#endif
|
||
#if PNG_LIBPNG_VER < 100207
|
||
//#undef HAVE_PNG
|
||
#endif
|
||
#endif
|
||
|
||
#ifndef errno
|
||
#include <errno.h>
|
||
#endif
|
||
|
||
md2_t md2_models[NUMSPRITES] = {};
|
||
md2_t md2_playermodels[MAXSKINS] = {};
|
||
md2_t md2_localplayermodels[MAXLOCALSKINS] = {};
|
||
|
||
/*
|
||
* free model
|
||
*/
|
||
#if 0
|
||
static void md2_freeModel (model_t *model)
|
||
{
|
||
UnloadModel(model);
|
||
}
|
||
#endif
|
||
|
||
//
|
||
// load model
|
||
//
|
||
// Hurdler: the current path is the Legacy.exe path
|
||
static model_t *md2_readModel(const char *filename)
|
||
{
|
||
//Filename checking fixed ~Monster Iestyn and Golden
|
||
if (FIL_FileExists(va("%s"PATHSEP"%s", srb2home, filename)))
|
||
return LoadModel(va("%s"PATHSEP"%s", srb2home, filename), PU_STATIC);
|
||
else if (FIL_FileExists(va("%s"PATHSEP"%s", srb2path, filename)))
|
||
return LoadModel(va("%s"PATHSEP"%s", srb2path, filename), PU_STATIC);
|
||
return NULL;
|
||
}
|
||
|
||
static inline void md2_printModelInfo (model_t *model)
|
||
{
|
||
#if 0
|
||
INT32 i;
|
||
|
||
CONS_Debug(DBG_RENDER, "magic:\t\t\t%c%c%c%c\n", model->header.magic>>24,
|
||
(model->header.magic>>16)&0xff,
|
||
(model->header.magic>>8)&0xff,
|
||
model->header.magic&0xff);
|
||
CONS_Debug(DBG_RENDER, "version:\t\t%d\n", model->header.version);
|
||
CONS_Debug(DBG_RENDER, "skinWidth:\t\t%d\n", model->header.skinWidth);
|
||
CONS_Debug(DBG_RENDER, "skinHeight:\t\t%d\n", model->header.skinHeight);
|
||
CONS_Debug(DBG_RENDER, "frameSize:\t\t%d\n", model->header.frameSize);
|
||
CONS_Debug(DBG_RENDER, "numSkins:\t\t%d\n", model->header.numSkins);
|
||
CONS_Debug(DBG_RENDER, "numVertices:\t\t%d\n", model->header.numVertices);
|
||
CONS_Debug(DBG_RENDER, "numTexCoords:\t\t%d\n", model->header.numTexCoords);
|
||
CONS_Debug(DBG_RENDER, "numTriangles:\t\t%d\n", model->header.numTriangles);
|
||
CONS_Debug(DBG_RENDER, "numGlCommands:\t\t%d\n", model->header.numGlCommands);
|
||
CONS_Debug(DBG_RENDER, "numFrames:\t\t%d\n", model->header.numFrames);
|
||
CONS_Debug(DBG_RENDER, "offsetSkins:\t\t%d\n", model->header.offsetSkins);
|
||
CONS_Debug(DBG_RENDER, "offsetTexCoords:\t%d\n", model->header.offsetTexCoords);
|
||
CONS_Debug(DBG_RENDER, "offsetTriangles:\t%d\n", model->header.offsetTriangles);
|
||
CONS_Debug(DBG_RENDER, "offsetFrames:\t\t%d\n", model->header.offsetFrames);
|
||
CONS_Debug(DBG_RENDER, "offsetGlCommands:\t%d\n", model->header.offsetGlCommands);
|
||
CONS_Debug(DBG_RENDER, "offsetEnd:\t\t%d\n", model->header.offsetEnd);
|
||
|
||
for (i = 0; i < model->header.numFrames; i++)
|
||
CONS_Debug(DBG_RENDER, "%s ", model->frames[i].name);
|
||
CONS_Debug(DBG_RENDER, "\n");
|
||
#else
|
||
(void)model;
|
||
#endif
|
||
}
|
||
|
||
#ifdef HAVE_PNG
|
||
static void PNG_error(png_structp PNG, png_const_charp pngtext)
|
||
{
|
||
CONS_Debug(DBG_RENDER, "libpng error at %p: %s", PNG, pngtext);
|
||
//I_Error("libpng error at %p: %s", PNG, pngtext);
|
||
}
|
||
|
||
static void PNG_warn(png_structp PNG, png_const_charp pngtext)
|
||
{
|
||
CONS_Debug(DBG_RENDER, "libpng warning at %p: %s", PNG, pngtext);
|
||
}
|
||
|
||
static GLTextureFormat_t PNG_Load(const char *filename, int *w, int *h, GLPatch_t *glpatch)
|
||
{
|
||
png_structp png_ptr;
|
||
png_infop png_info_ptr;
|
||
png_uint_32 width, height;
|
||
int bit_depth, color_type;
|
||
#ifdef PNG_SETJMP_SUPPORTED
|
||
#ifdef USE_FAR_KEYWORD
|
||
jmp_buf jmpbuf;
|
||
#endif
|
||
#endif
|
||
volatile png_FILE_p png_FILE;
|
||
//Filename checking fixed ~Monster Iestyn and Golden
|
||
char *pngfilename = va("%s"PATHSEP"mdls"PATHSEP"%s", srb2home, filename);
|
||
|
||
FIL_ForceExtension(pngfilename, ".png");
|
||
png_FILE = fopen(pngfilename, "rb");
|
||
if (!png_FILE)
|
||
{
|
||
pngfilename = va("%s"PATHSEP"mdls"PATHSEP"%s", srb2path, filename);
|
||
FIL_ForceExtension(pngfilename, ".png");
|
||
png_FILE = fopen(pngfilename, "rb");
|
||
//CONS_Debug(DBG_RENDER, "M_SavePNG: Error on opening %s for loading\n", filename);
|
||
if (!png_FILE)
|
||
return 0;
|
||
}
|
||
|
||
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
|
||
PNG_error, PNG_warn);
|
||
if (!png_ptr)
|
||
{
|
||
CONS_Debug(DBG_RENDER, "PNG_Load: Error on initialize libpng\n");
|
||
fclose(png_FILE);
|
||
return 0;
|
||
}
|
||
|
||
png_info_ptr = png_create_info_struct(png_ptr);
|
||
if (!png_info_ptr)
|
||
{
|
||
CONS_Debug(DBG_RENDER, "PNG_Load: Error on allocate for libpng\n");
|
||
png_destroy_read_struct(&png_ptr, NULL, NULL);
|
||
fclose(png_FILE);
|
||
return 0;
|
||
}
|
||
|
||
#ifdef USE_FAR_KEYWORD
|
||
if (setjmp(jmpbuf))
|
||
#else
|
||
if (setjmp(png_jmpbuf(png_ptr)))
|
||
#endif
|
||
{
|
||
//CONS_Debug(DBG_RENDER, "libpng load error on %s\n", filename);
|
||
png_destroy_read_struct(&png_ptr, &png_info_ptr, NULL);
|
||
fclose(png_FILE);
|
||
Z_Free(glpatch->mipmap->data);
|
||
return 0;
|
||
}
|
||
#ifdef USE_FAR_KEYWORD
|
||
png_memcpy(png_jmpbuf(png_ptr), jmpbuf, sizeof jmp_buf);
|
||
#endif
|
||
|
||
png_init_io(png_ptr, png_FILE);
|
||
|
||
#ifdef PNG_SET_USER_LIMITS_SUPPORTED
|
||
png_set_user_limits(png_ptr, 2048, 2048);
|
||
#endif
|
||
|
||
png_read_info(png_ptr, png_info_ptr);
|
||
|
||
png_get_IHDR(png_ptr, png_info_ptr, &width, &height, &bit_depth, &color_type,
|
||
NULL, NULL, NULL);
|
||
|
||
if (bit_depth == 16)
|
||
png_set_strip_16(png_ptr);
|
||
|
||
if (color_type == PNG_COLOR_TYPE_GRAY || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
|
||
png_set_gray_to_rgb(png_ptr);
|
||
else if (color_type == PNG_COLOR_TYPE_PALETTE)
|
||
png_set_palette_to_rgb(png_ptr);
|
||
|
||
if (png_get_valid(png_ptr, png_info_ptr, PNG_INFO_tRNS))
|
||
png_set_tRNS_to_alpha(png_ptr);
|
||
else if (color_type != PNG_COLOR_TYPE_RGB_ALPHA && color_type != PNG_COLOR_TYPE_GRAY_ALPHA)
|
||
{
|
||
#if PNG_LIBPNG_VER < 10207
|
||
png_set_filler(png_ptr, 0xFF, PNG_FILLER_AFTER);
|
||
#else
|
||
png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER);
|
||
#endif
|
||
}
|
||
|
||
png_read_update_info(png_ptr, png_info_ptr);
|
||
|
||
{
|
||
png_uint_32 i, pitch = png_get_rowbytes(png_ptr, png_info_ptr);
|
||
png_bytep PNG_image = Z_Malloc(pitch*height, PU_HWRMODELTEXTURE, &glpatch->mipmap->data);
|
||
png_bytepp row_pointers = png_malloc(png_ptr, height * sizeof (png_bytep));
|
||
for (i = 0; i < height; i++)
|
||
row_pointers[i] = PNG_image + i*pitch;
|
||
png_read_image(png_ptr, row_pointers);
|
||
png_free(png_ptr, (png_voidp)row_pointers);
|
||
}
|
||
|
||
png_destroy_read_struct(&png_ptr, &png_info_ptr, NULL);
|
||
|
||
fclose(png_FILE);
|
||
*w = (int)width;
|
||
*h = (int)height;
|
||
return GL_TEXFMT_RGBA;
|
||
}
|
||
#endif
|
||
|
||
typedef struct
|
||
{
|
||
UINT8 manufacturer;
|
||
UINT8 version;
|
||
UINT8 encoding;
|
||
UINT8 bitsPerPixel;
|
||
INT16 xmin;
|
||
INT16 ymin;
|
||
INT16 xmax;
|
||
INT16 ymax;
|
||
INT16 hDpi;
|
||
INT16 vDpi;
|
||
UINT8 colorMap[48];
|
||
UINT8 reserved;
|
||
UINT8 numPlanes;
|
||
INT16 bytesPerLine;
|
||
INT16 paletteInfo;
|
||
INT16 hScreenSize;
|
||
INT16 vScreenSize;
|
||
UINT8 filler[54];
|
||
} PcxHeader;
|
||
|
||
static GLTextureFormat_t PCX_Load(const char *filename, int *w, int *h,
|
||
GLPatch_t *glpatch)
|
||
{
|
||
PcxHeader header;
|
||
#define PALSIZE 768
|
||
UINT8 palette[PALSIZE];
|
||
const UINT8 *pal;
|
||
RGBA_t *image;
|
||
size_t pw, ph, size, ptr = 0;
|
||
INT32 ch, rep;
|
||
FILE *file;
|
||
//Filename checking fixed ~Monster Iestyn and Golden
|
||
char *pcxfilename = va("%s"PATHSEP"mdls"PATHSEP"%s", srb2home, filename);
|
||
|
||
FIL_ForceExtension(pcxfilename, ".pcx");
|
||
file = fopen(pcxfilename, "rb");
|
||
if (!file)
|
||
{
|
||
pcxfilename = va("%s"PATHSEP"mdls"PATHSEP"%s", srb2path, filename);
|
||
FIL_ForceExtension(pcxfilename, ".pcx");
|
||
file = fopen(pcxfilename, "rb");
|
||
if (!file)
|
||
return 0;
|
||
}
|
||
|
||
if (fread(&header, sizeof (PcxHeader), 1, file) != 1)
|
||
{
|
||
fclose(file);
|
||
return 0;
|
||
}
|
||
|
||
if (header.bitsPerPixel != 8)
|
||
{
|
||
fclose(file);
|
||
return 0;
|
||
}
|
||
|
||
fseek(file, -PALSIZE, SEEK_END);
|
||
|
||
pw = *w = header.xmax - header.xmin + 1;
|
||
ph = *h = header.ymax - header.ymin + 1;
|
||
image = Z_Malloc(pw*ph*4, PU_HWRMODELTEXTURE, &glpatch->mipmap->data);
|
||
|
||
if (fread(palette, sizeof (UINT8), PALSIZE, file) != PALSIZE)
|
||
{
|
||
Z_Free(image);
|
||
fclose(file);
|
||
return 0;
|
||
}
|
||
fseek(file, sizeof (PcxHeader), SEEK_SET);
|
||
|
||
size = pw * ph;
|
||
while (ptr < size)
|
||
{
|
||
ch = fgetc(file); //Hurdler: beurk
|
||
if (ch >= 192)
|
||
{
|
||
rep = ch - 192;
|
||
ch = fgetc(file);
|
||
}
|
||
else
|
||
{
|
||
rep = 1;
|
||
}
|
||
while (rep--)
|
||
{
|
||
pal = palette + ch*3;
|
||
image[ptr].s.red = *pal++;
|
||
image[ptr].s.green = *pal++;
|
||
image[ptr].s.blue = *pal++;
|
||
image[ptr].s.alpha = 0xFF;
|
||
ptr++;
|
||
}
|
||
}
|
||
fclose(file);
|
||
return GL_TEXFMT_RGBA;
|
||
}
|
||
|
||
// -----------------+
|
||
// md2_loadTexture : Download a pcx or png texture for MD2 models
|
||
// -----------------+
|
||
static void md2_loadTexture(md2_t *model)
|
||
{
|
||
patch_t *patch;
|
||
GLPatch_t *glPatch = NULL;
|
||
const char *filename = model->filename;
|
||
|
||
if (model->glpatch)
|
||
{
|
||
patch = model->glpatch;
|
||
glPatch = (GLPatch_t *)(patch->hardware);
|
||
if (glPatch)
|
||
Z_Free(glPatch->mipmap->data);
|
||
}
|
||
else
|
||
model->glpatch = patch = Patch_Create(NULL, 0, NULL);
|
||
|
||
if (!patch->hardware)
|
||
Patch_AllocateHardwarePatch(patch);
|
||
|
||
if (glPatch == NULL)
|
||
glPatch = (GLPatch_t *)(patch->hardware);
|
||
|
||
if (!glPatch->mipmap->downloaded && !glPatch->mipmap->data)
|
||
{
|
||
int w = 0, h = 0;
|
||
|
||
#ifdef HAVE_PNG
|
||
glPatch->mipmap->format = PNG_Load(filename, &w, &h, glPatch);
|
||
if (glPatch->mipmap->format == 0)
|
||
#endif
|
||
glPatch->mipmap->format = PCX_Load(filename, &w, &h, glPatch);
|
||
if (glPatch->mipmap->format == 0)
|
||
{
|
||
model->notexturefile = true; // mark it so its not searched for again repeatedly
|
||
return;
|
||
}
|
||
|
||
glPatch->mipmap->downloaded = 0;
|
||
glPatch->mipmap->flags = 0;
|
||
|
||
patch->width = (INT16)w;
|
||
patch->height = (INT16)h;
|
||
glPatch->mipmap->width = (UINT16)w;
|
||
glPatch->mipmap->height = (UINT16)h;
|
||
|
||
// for palette rendering, color cube is applied in post-processing instead of here
|
||
if (!HWR_ShouldUsePaletteRendering())
|
||
{
|
||
UINT32 size;
|
||
RGBA_t *image;
|
||
// Lactozilla: Apply colour cube
|
||
image = glPatch->mipmap->data;
|
||
size = w*h;
|
||
while (size--)
|
||
{
|
||
V_CubeApply(image);
|
||
image++;
|
||
}
|
||
}
|
||
}
|
||
GL_SetTexture(glPatch->mipmap);
|
||
HWR_UnlockCachedPatch(glPatch);
|
||
}
|
||
|
||
// -----------------+
|
||
// md2_loadBlendTexture : Download a pcx or png texture for blending MD2 models
|
||
// -----------------+
|
||
static void md2_loadBlendTexture(md2_t *model)
|
||
{
|
||
patch_t *patch;
|
||
GLPatch_t *glPatch = NULL;
|
||
|
||
char *filename = Z_Malloc(strlen(model->filename)+7, PU_STATIC, NULL);
|
||
|
||
strcpy(filename, model->filename);
|
||
|
||
FIL_ForceExtension(filename, "_blend.png");
|
||
|
||
if (model->blendglpatch)
|
||
{
|
||
patch = model->blendglpatch;
|
||
glPatch = (GLPatch_t *)(patch->hardware);
|
||
if (glPatch)
|
||
Z_Free(glPatch->mipmap->data);
|
||
}
|
||
else
|
||
model->blendglpatch = patch = Patch_Create(NULL, 0, NULL);
|
||
|
||
if (!patch->hardware)
|
||
Patch_AllocateHardwarePatch(patch);
|
||
|
||
if (glPatch == NULL)
|
||
glPatch = (GLPatch_t *)(patch->hardware);
|
||
|
||
if (!glPatch->mipmap->downloaded && !glPatch->mipmap->data)
|
||
{
|
||
int w = 0, h = 0;
|
||
#ifdef HAVE_PNG
|
||
glPatch->mipmap->format = PNG_Load(filename, &w, &h, glPatch);
|
||
if (glPatch->mipmap->format == 0)
|
||
#endif
|
||
glPatch->mipmap->format = PCX_Load(filename, &w, &h, glPatch);
|
||
if (glPatch->mipmap->format == 0)
|
||
{
|
||
model->noblendfile = true; // mark it so its not searched for again repeatedly
|
||
Z_Free(filename);
|
||
return;
|
||
}
|
||
|
||
glPatch->mipmap->downloaded = 0;
|
||
glPatch->mipmap->flags = 0;
|
||
|
||
patch->width = (INT16)w;
|
||
patch->height = (INT16)h;
|
||
glPatch->mipmap->width = (UINT16)w;
|
||
glPatch->mipmap->height = (UINT16)h;
|
||
}
|
||
GL_SetTexture(glPatch->mipmap); // We do need to do this so that it can be cleared and knows to recreate it when necessary
|
||
HWR_UnlockCachedPatch(glPatch);
|
||
|
||
Z_Free(filename);
|
||
}
|
||
|
||
// Don't spam the console, or the OS with fopen requests!
|
||
static boolean nomd2s = false;
|
||
|
||
void HWR_InitMD2(void)
|
||
{
|
||
size_t i;
|
||
INT32 s;
|
||
FILE *f;
|
||
char name[20], filename[32];
|
||
float scale, offset;
|
||
|
||
CONS_Printf("InitMD2()...\n");
|
||
for (s = 0; s < MAXSKINS; s++)
|
||
{
|
||
md2_playermodels[s].scale = -1.0f;
|
||
md2_playermodels[s].model = NULL;
|
||
md2_playermodels[s].glpatch = NULL;
|
||
md2_playermodels[s].skin = -1;
|
||
md2_playermodels[s].notexturefile = false;
|
||
md2_playermodels[s].noblendfile = false;
|
||
md2_playermodels[s].notfound = true;
|
||
md2_playermodels[s].error = false;
|
||
}
|
||
for (s = 0; s < MAXLOCALSKINS; s++)
|
||
{
|
||
md2_localplayermodels[s].scale = -1.0f;
|
||
md2_localplayermodels[s].model = NULL;
|
||
md2_localplayermodels[s].glpatch = NULL;
|
||
md2_localplayermodels[s].skin = -1;
|
||
md2_localplayermodels[s].notexturefile = false;
|
||
md2_localplayermodels[s].noblendfile = false;
|
||
md2_localplayermodels[s].notfound = true;
|
||
md2_localplayermodels[s].error = false;
|
||
}
|
||
for (i = 0; i < NUMSPRITES; i++)
|
||
{
|
||
md2_models[i].scale = -1.0f;
|
||
md2_models[i].model = NULL;
|
||
md2_models[i].glpatch = NULL;
|
||
md2_models[i].skin = -1;
|
||
md2_models[s].notexturefile = false;
|
||
md2_models[s].noblendfile = false;
|
||
md2_models[i].notfound = true;
|
||
md2_models[i].error = false;
|
||
}
|
||
|
||
// read the mdls.dat file
|
||
//Filename checking fixed ~Monster Iestyn and Golden
|
||
f = fopen(va("%s"PATHSEP"%s", srb2home, "mdls.dat"), "rt");
|
||
|
||
if (!f)
|
||
{
|
||
f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
|
||
if (!f)
|
||
{
|
||
CONS_Printf("%s %s\n", M_GetText("Error while loading mdls.dat:"), strerror(errno));
|
||
nomd2s = true;
|
||
return;
|
||
}
|
||
}
|
||
while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
|
||
{
|
||
for (i = 0; i < NUMSPRITES; i++)
|
||
{
|
||
if (fasticmp(name, sprnames[i]))
|
||
{
|
||
md2_models[i].scale = scale;
|
||
md2_models[i].offset = offset;
|
||
md2_models[i].notfound = false;
|
||
strcpy(md2_models[i].filename, filename);
|
||
goto md2found;
|
||
}
|
||
}
|
||
|
||
for (s = 0; s < MAXSKINS; s++)
|
||
{
|
||
if (fasticmp(name, skins[s].name))
|
||
{
|
||
md2_playermodels[s].skin = s;
|
||
md2_playermodels[s].scale = scale;
|
||
md2_playermodels[s].offset = offset;
|
||
md2_playermodels[s].notfound = false;
|
||
strcpy(md2_playermodels[s].filename, filename);
|
||
goto md2found;
|
||
}
|
||
}
|
||
// no sprite/player skin name found?!?D
|
||
CONS_Printf("Unknown sprite/player skin %s detected in mdls.dat\n", name);
|
||
md2found:
|
||
// move on to next line...
|
||
continue;
|
||
}
|
||
fclose(f);
|
||
}
|
||
|
||
void HWR_AddPlayerMD2(INT32 skin, boolean local) // For MD2's that were added after startup
|
||
{
|
||
FILE *f;
|
||
char name[20], filename[32];
|
||
float scale, offset;
|
||
md2_t *md2s;
|
||
|
||
if (nomd2s)
|
||
return;
|
||
|
||
CONS_Printf("AddPlayerMD2()...\n");
|
||
|
||
// read the mdls.dat file
|
||
//Filename checking fixed ~Monster Iestyn and Golden
|
||
f = fopen(va("%s"PATHSEP"%s", srb2home, "mdls.dat"), "rt");
|
||
|
||
if (!f)
|
||
{
|
||
f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
|
||
if (!f)
|
||
{
|
||
CONS_Printf("%s %s\n", M_GetText("Error while loading mdls.dat:"), strerror(errno));
|
||
nomd2s = true;
|
||
return;
|
||
}
|
||
}
|
||
|
||
md2s = (local ? md2_localplayermodels : md2_playermodels);
|
||
|
||
// Check for any MD2s that match the names of player skins!
|
||
while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
|
||
{
|
||
if (fasticmp(name, K_GetSkinArray(local)[skin].name))
|
||
{
|
||
md2s[skin].skin = skin;
|
||
md2s[skin].scale = scale;
|
||
md2s[skin].offset = offset;
|
||
md2s[skin].notfound = false;
|
||
strcpy(md2s[skin].filename, filename);
|
||
goto playermd2found;
|
||
}
|
||
}
|
||
|
||
//CONS_Printf("MD2 for player skin %s not found\n", skins[skin].name);
|
||
md2s[skin].notfound = true;
|
||
playermd2found:
|
||
fclose(f);
|
||
}
|
||
|
||
|
||
void HWR_AddSpriteMD2(size_t spritenum) // For MD2s that were added after startup
|
||
{
|
||
FILE *f;
|
||
// name[18] is used to check for names in the mdls.dat file that match with sprites or player skins
|
||
// sprite names are always 4 characters long, and names is for player skins can be up to 19 characters long
|
||
char name[20], filename[32];
|
||
float scale, offset;
|
||
|
||
if (nomd2s)
|
||
return;
|
||
|
||
if (spritenum == SPR_PLAY) // Handled already NEWMD2: Per sprite, per-skin check
|
||
return;
|
||
|
||
// Read the md2.dat file
|
||
//Filename checking fixed ~Monster Iestyn and Golden
|
||
f = fopen(va("%s"PATHSEP"%s", srb2home, "mdls.dat"), "rt");
|
||
|
||
if (!f)
|
||
{
|
||
f = fopen(va("%s"PATHSEP"%s", srb2path, "mdls.dat"), "rt");
|
||
|
||
if (!f)
|
||
{
|
||
CONS_Printf("%s %s\n", M_GetText("Error while loading mdls.dat:"), strerror(errno));
|
||
nomd2s = true;
|
||
return;
|
||
}
|
||
}
|
||
|
||
// Check for any MD2s that match the names of sprite names!
|
||
while (fscanf(f, "%19s %31s %f %f", name, filename, &scale, &offset) == 4)
|
||
{
|
||
if (fasticmp(name, sprnames[spritenum]))
|
||
{
|
||
md2_models[spritenum].scale = scale;
|
||
md2_models[spritenum].offset = offset;
|
||
md2_models[spritenum].notfound = false;
|
||
strcpy(md2_models[spritenum].filename, filename);
|
||
goto spritemd2found;
|
||
}
|
||
}
|
||
|
||
//CONS_Printf("MD2 for sprite %s not found\n", sprnames[spritenum]);
|
||
md2_models[spritenum].notfound = true;
|
||
spritemd2found:
|
||
fclose(f);
|
||
}
|
||
|
||
// Define for getting accurate color brightness readings according to how the human eye sees them.
|
||
// https://en.wikipedia.org/wiki/Relative_luminance
|
||
// 0.2126 to red
|
||
// 0.7152 to green
|
||
// 0.0722 to blue
|
||
// (See this same define in k_kart.c!)
|
||
#define SETBRIGHTNESS(brightness,r,g,b) \
|
||
brightness = (UINT8)(((1063*(UINT32)(r))/5000) + ((3576*(UINT32)(g))/5000) + ((361*(UINT32)(b))/5000))
|
||
|
||
static void HWR_CreateBlendedTexture(patch_t *gpatch, patch_t *blendgpatch, GLMipmap_t *glMipmap, INT32 skinnum, skincolors_t color)
|
||
{
|
||
GLPatch_t *hwrPatch = gpatch->hardware;
|
||
GLPatch_t *hwrBlendPatch = blendgpatch->hardware;
|
||
UINT16 w = gpatch->width, h = gpatch->height;
|
||
UINT32 size = w*h;
|
||
RGBA_t *image, *blendimage, *cur;
|
||
RGBA_t blendcolor = {};
|
||
RGBA_t *palette = HWR_GetTexturePalette();
|
||
UINT8 translation[17] = {}; // First the color index
|
||
UINT8 cutoff[17] = {}; // Brightness cutoff before using the next color
|
||
UINT8 translen = 0;
|
||
UINT8 i;
|
||
UINT8 colorbrightnesses[17] = {};
|
||
UINT8 color_match_lookup[256] = {}; // optimization attempt
|
||
|
||
if (glMipmap->width == 0)
|
||
{
|
||
glMipmap->width = gpatch->width;
|
||
glMipmap->height = gpatch->height;
|
||
|
||
// no wrap around, no chroma key
|
||
glMipmap->flags = 0;
|
||
// setup the texture info
|
||
glMipmap->format = GL_TEXFMT_RGBA;
|
||
}
|
||
|
||
Z_Free(glMipmap->data);
|
||
glMipmap->data = NULL;
|
||
|
||
cur = Z_Calloc(size*4, PU_HWRMODELTEXTURE, &glMipmap->data);
|
||
|
||
image = hwrPatch->mipmap->data;
|
||
blendimage = hwrBlendPatch->mipmap->data;
|
||
|
||
// TC_METALSONIC includes an actual skincolor translation, on top of its flashing.
|
||
if (skinnum == TC_METALSONIC)
|
||
color = SKINCOLOR_BLUEBERRY;
|
||
|
||
if (color != SKINCOLOR_NONE)
|
||
{
|
||
UINT8 numdupes = 1;
|
||
UINT8 prevdupes = numdupes;
|
||
|
||
translation[translen] = colortranslations[color][0];
|
||
cutoff[translen] = 255;
|
||
|
||
for (i = 1; i < 16; i++)
|
||
{
|
||
if (translation[translen] == colortranslations[color][i])
|
||
{
|
||
numdupes++;
|
||
continue;
|
||
}
|
||
|
||
if (translen > 0)
|
||
{
|
||
INT16 newcutoff = cutoff[translen-1] - (255 / (16 / prevdupes));
|
||
|
||
if (newcutoff < 0)
|
||
newcutoff = 0;
|
||
|
||
cutoff[translen] = (UINT8)newcutoff;
|
||
}
|
||
|
||
prevdupes = numdupes;
|
||
numdupes = 1;
|
||
translen++;
|
||
|
||
translation[translen] = (UINT8)colortranslations[color][i];
|
||
}
|
||
|
||
translen++;
|
||
}
|
||
|
||
if (translen > 0)
|
||
translation[translen] = translation[translen-1]; // extended to accomodate secondi if firsti equal to translen-1
|
||
if (translen > 1)
|
||
cutoff[translen] = cutoff[translen-1] = 0; // as above
|
||
|
||
if (skinnum == TC_RAINBOW && translen > 0)
|
||
{
|
||
UINT16 b;
|
||
INT32 compare;
|
||
|
||
for (i = 0; i < translen; i++) // moved from inside the loop to here
|
||
{
|
||
RGBA_t tempc = palette[translation[i]];
|
||
SETBRIGHTNESS(colorbrightnesses[i], tempc.s.red, tempc.s.green, tempc.s.blue); // store brightnesses for comparison
|
||
}
|
||
// generate lookup table for color brightness matching
|
||
for (b = 0; b < 256; b++)
|
||
{
|
||
UINT16 brightdif = 256;
|
||
|
||
color_match_lookup[b] = 0;
|
||
for (i = 0; i < translen; i++)
|
||
{
|
||
if (b > colorbrightnesses[i]) // don't allow greater matches (because calculating a makeshift gradient for this is already a huge mess as is)
|
||
continue;
|
||
|
||
compare = abs((INT16)(colorbrightnesses[i]) - (INT16)(b));
|
||
|
||
if (compare < brightdif)
|
||
{
|
||
brightdif = (UINT16)compare;
|
||
color_match_lookup[b] = i; // best matching color that's equal brightness or darker
|
||
}
|
||
}
|
||
}
|
||
|
||
colorbrightnesses[translen] = colorbrightnesses[translen-1];
|
||
}
|
||
|
||
while (size--)
|
||
{
|
||
if (skinnum == TC_BOSS)
|
||
{
|
||
// Turn everything below a certain threshold white
|
||
if ((image->s.red == image->s.green) && (image->s.green == image->s.blue) && image->s.blue < 127)
|
||
{
|
||
// Lactozilla: Invert the colors
|
||
cur->s.red = cur->s.green = cur->s.blue = (255 - image->s.blue);
|
||
}
|
||
else
|
||
{
|
||
cur->s.red = image->s.red;
|
||
cur->s.green = image->s.green;
|
||
cur->s.blue = image->s.blue;
|
||
}
|
||
|
||
cur->s.alpha = image->s.alpha;
|
||
}
|
||
else if (skinnum == TC_ALLWHITE)
|
||
{
|
||
// Turn everything white
|
||
cur->s.red = cur->s.green = cur->s.blue = 255;
|
||
cur->s.alpha = image->s.alpha;
|
||
}
|
||
else
|
||
{
|
||
// All settings that use skincolors!
|
||
UINT16 brightness;
|
||
|
||
// Everything below requires a blend image
|
||
if (blendimage == NULL)
|
||
{
|
||
cur->rgba = image->rgba;
|
||
goto skippixel;
|
||
}
|
||
|
||
if (translen <= 0)
|
||
{
|
||
cur->rgba = image->rgba;
|
||
goto skippixel;
|
||
}
|
||
|
||
// Don't bother with blending the pixel if the alpha of the blend pixel is 0
|
||
if (skinnum == TC_RAINBOW)
|
||
{
|
||
if (image->s.alpha == 0 && blendimage->s.alpha == 0)
|
||
{
|
||
cur->rgba = image->rgba;
|
||
goto skippixel;
|
||
}
|
||
else
|
||
{
|
||
UINT16 imagebright, blendbright;
|
||
SETBRIGHTNESS(imagebright,image->s.red,image->s.green,image->s.blue);
|
||
SETBRIGHTNESS(blendbright,blendimage->s.red,blendimage->s.green,blendimage->s.blue);
|
||
// slightly dumb average between the blend image color and base image colour, usually one or the other will be fully opaque anyway
|
||
brightness = (imagebright*(255-blendimage->s.alpha))/255 + (blendbright*blendimage->s.alpha)/255;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (blendimage->s.alpha == 0)
|
||
{
|
||
cur->rgba = image->rgba;
|
||
goto skippixel; // for metal sonic blend
|
||
}
|
||
else
|
||
{
|
||
SETBRIGHTNESS(brightness,blendimage->s.red,blendimage->s.green,blendimage->s.blue);
|
||
}
|
||
}
|
||
|
||
// Calculate a sort of "gradient" for the skincolor
|
||
// (Me splitting this into a function didn't work, so I had to ruin this entire function's groove...)
|
||
{
|
||
RGBA_t nextcolor;
|
||
UINT8 firsti, secondi, mul, mulmax;
|
||
INT32 r, g, b;
|
||
|
||
// Rainbow needs to find the closest match to the textures themselves, instead of matching brightnesses to other colors.
|
||
// Ensue horrible mess.
|
||
if (skinnum == TC_RAINBOW)
|
||
{
|
||
//UINT16 brightdif = 256;
|
||
INT32 /*compare,*/ m, d;
|
||
|
||
// Ignore pure white & pitch black
|
||
if (brightness > 253 || brightness < 2)
|
||
{
|
||
cur->rgba = image->rgba;
|
||
cur++; image++; blendimage++;
|
||
continue;
|
||
}
|
||
|
||
firsti = color_match_lookup[brightness];
|
||
secondi = firsti+1; // next color in line
|
||
|
||
m = (INT16)brightness - (INT16)colorbrightnesses[secondi];
|
||
d = (INT16)colorbrightnesses[firsti] - (INT16)colorbrightnesses[secondi];
|
||
|
||
if (m >= d)
|
||
m = d-1;
|
||
|
||
mulmax = 16;
|
||
|
||
// calculate the "gradient" multiplier based on how close this color is to the one next in line
|
||
if (m <= 0 || d <= 0)
|
||
mul = 0;
|
||
else
|
||
mul = (mulmax-1) - ((m * mulmax) / d);
|
||
}
|
||
else
|
||
{
|
||
// Just convert brightness to a skincolor value, use distance to next position to find the gradient multipler
|
||
firsti = 0;
|
||
|
||
for (i = 1; i < translen; i++)
|
||
{
|
||
if (brightness >= cutoff[i])
|
||
break;
|
||
firsti = i;
|
||
}
|
||
|
||
secondi = firsti+1;
|
||
|
||
mulmax = cutoff[firsti] - cutoff[secondi];
|
||
if (mulmax == 0)
|
||
mulmax = 1; // don't divide by zero on equal cutoffs (however unlikely)
|
||
mul = cutoff[firsti] - brightness;
|
||
}
|
||
|
||
blendcolor = palette[translation[firsti]];
|
||
|
||
if (mul > 0) // If it's 0, then we only need the first color.
|
||
{
|
||
nextcolor = palette[translation[secondi]];
|
||
|
||
// Find difference between points
|
||
r = (INT32)(nextcolor.s.red - blendcolor.s.red);
|
||
g = (INT32)(nextcolor.s.green - blendcolor.s.green);
|
||
b = (INT32)(nextcolor.s.blue - blendcolor.s.blue);
|
||
|
||
// Find the gradient of the two points
|
||
r = ((mul * r) / mulmax);
|
||
g = ((mul * g) / mulmax);
|
||
b = ((mul * b) / mulmax);
|
||
|
||
// Add gradient value to color
|
||
blendcolor.s.red += r;
|
||
blendcolor.s.green += g;
|
||
blendcolor.s.blue += b;
|
||
}
|
||
}
|
||
|
||
if (skinnum == TC_RAINBOW)
|
||
{
|
||
UINT32 tempcolor;
|
||
UINT16 colorbright;
|
||
|
||
SETBRIGHTNESS(colorbright, blendcolor.s.red, blendcolor.s.green, blendcolor.s.blue);
|
||
if (colorbright == 0)
|
||
colorbright = 1; // no dividing by 0 please
|
||
|
||
tempcolor = (brightness * blendcolor.s.red) / colorbright;
|
||
tempcolor = min(255, tempcolor);
|
||
cur->s.red = (UINT8)tempcolor;
|
||
|
||
tempcolor = (brightness * blendcolor.s.green) / colorbright;
|
||
tempcolor = min(255, tempcolor);
|
||
cur->s.green = (UINT8)tempcolor;
|
||
|
||
tempcolor = (brightness * blendcolor.s.blue) / colorbright;
|
||
tempcolor = min(255, tempcolor);
|
||
cur->s.blue = (UINT8)tempcolor;
|
||
cur->s.alpha = image->s.alpha;
|
||
}
|
||
else
|
||
{
|
||
// Color strength depends on image alpha
|
||
INT32 tempcolor;
|
||
|
||
tempcolor = ((image->s.red * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.red * blendimage->s.alpha) / 255);
|
||
tempcolor = min(255, tempcolor);
|
||
cur->s.red = (UINT8)tempcolor;
|
||
|
||
tempcolor = ((image->s.green * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.green * blendimage->s.alpha) / 255);
|
||
tempcolor = min(255, tempcolor);
|
||
cur->s.green = (UINT8)tempcolor;
|
||
|
||
tempcolor = ((image->s.blue * (255-blendimage->s.alpha)) / 255) + ((blendcolor.s.blue * blendimage->s.alpha) / 255);
|
||
tempcolor = min(255, tempcolor);
|
||
cur->s.blue = (UINT8)tempcolor;
|
||
cur->s.alpha = image->s.alpha;
|
||
}
|
||
|
||
skippixel:
|
||
|
||
// *Now* we can do Metal Sonic's flashing
|
||
if (skinnum == TC_METALSONIC)
|
||
{
|
||
// Blend dark blue into white
|
||
if (cur->s.alpha > 0 && cur->s.red == 0 && cur->s.green == 0 && cur->s.blue < 255 && cur->s.blue > 31)
|
||
{
|
||
// Sal: Invert non-blue
|
||
cur->s.red = cur->s.green = (255 - cur->s.blue);
|
||
cur->s.blue = 255;
|
||
}
|
||
|
||
cur->s.alpha = image->s.alpha;
|
||
}
|
||
}
|
||
|
||
cur++; image++;
|
||
|
||
if (blendimage != NULL)
|
||
blendimage++;
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
#undef SETBRIGHTNESS
|
||
|
||
static void HWR_GetBlendedTexture(patch_t *patch, patch_t *blendgpatch, INT32 skinnum, const UINT8 *colormap, skincolors_t color)
|
||
{
|
||
// mostly copied from HWR_GetMappedPatch, hence the similarities and comment
|
||
GLPatch_t *glPatch = patch->hardware;
|
||
GLMipmap_t *glMipmap, *newMipmap;
|
||
|
||
if (blendgpatch == NULL || colormap == colormaps || colormap == NULL)
|
||
{
|
||
// Don't do any blending
|
||
GL_SetTexture(glPatch->mipmap);
|
||
return;
|
||
}
|
||
|
||
// search for the Mipmap
|
||
// skip the first (no colormap translated)
|
||
for (glMipmap = glPatch->mipmap; glMipmap->nextcolormap; )
|
||
{
|
||
glMipmap = glMipmap->nextcolormap;
|
||
|
||
if (glMipmap->colormap && glMipmap->colormap->source == colormap)
|
||
{
|
||
if (glMipmap->downloaded && glMipmap->data)
|
||
{
|
||
if (memcmp(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8)))
|
||
{
|
||
memcpy(glMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
|
||
HWR_CreateBlendedTexture(patch, blendgpatch, glMipmap, skinnum, color);
|
||
GL_UpdateTexture(glMipmap);
|
||
}
|
||
else
|
||
GL_SetTexture(glMipmap); // found the colormap, set it to the correct texture
|
||
|
||
Z_ChangeTag(glMipmap->data, PU_HWRMODELTEXTURE_UNLOCKED);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
// If here, the blended texture has not been created
|
||
// So we create it
|
||
|
||
//BP: WARNING: don't free it manually without clearing the cache of harware renderer
|
||
// (it have a liste of mipmap)
|
||
// this malloc is cleared in HWR_FreeTextureCache
|
||
// (...) unfortunately z_malloc fragment alot the memory :(so malloc is better
|
||
newMipmap = calloc(1, sizeof (*newMipmap));
|
||
if (newMipmap == NULL)
|
||
I_Error("%s: Out of memory", "HWR_GetBlendedTexture");
|
||
glMipmap->nextcolormap = newMipmap;
|
||
|
||
newMipmap->colormap = Z_Calloc(sizeof(*newMipmap->colormap), PU_HWRPATCHCOLMIPMAP, NULL);
|
||
newMipmap->colormap->source = colormap;
|
||
memcpy(newMipmap->colormap->data, colormap, 256 * sizeof(UINT8));
|
||
|
||
HWR_CreateBlendedTexture(patch, blendgpatch, newMipmap, skinnum, color);
|
||
|
||
GL_SetTexture(newMipmap);
|
||
Z_ChangeTag(newMipmap->data, PU_HWRMODELTEXTURE_UNLOCKED);
|
||
}
|
||
|
||
// -----------------+
|
||
// HWR_DrawMD2 : Draw MD2
|
||
// :
|
||
// Returns :
|
||
// -----------------+
|
||
|
||
void HWR_DrawMD2(gl_vissprite_t *spr)
|
||
{
|
||
md2_t *md2;
|
||
|
||
char filename[64];
|
||
INT32 frame = 0;
|
||
INT32 nextFrame = -1;
|
||
FTransform p;
|
||
FSurfaceInfo Surf = {};
|
||
|
||
if (!cv_glmdls.value || spr->precip)
|
||
return;
|
||
|
||
memset(&p, 0x00, sizeof(FTransform));
|
||
|
||
// MD2 colormap fix
|
||
// colormap test
|
||
if (spr->mobj->subsector)
|
||
{
|
||
sector_t *sector = spr->mobj->subsector->sector;
|
||
extracolormap_t *colormap = sector->extra_colormap;
|
||
INT32 lightlevel = 255;
|
||
|
||
if (sector->numlights)
|
||
{
|
||
INT32 light;
|
||
|
||
light = R_GetPlaneLight(sector, spr->mobj->z + spr->mobj->height, false); // Always use the light at the top instead of whatever I was doing before
|
||
|
||
if (!(spr->mobj->frame & FF_FULLBRIGHT))
|
||
lightlevel = *sector->lightlist[light].lightlevel;
|
||
|
||
if (sector->lightlist[light].extra_colormap)
|
||
colormap = sector->lightlist[light].extra_colormap;
|
||
}
|
||
else
|
||
{
|
||
if (!(spr->mobj->frame & FF_FULLBRIGHT))
|
||
lightlevel = sector->lightlevel;
|
||
|
||
if (sector->extra_colormap)
|
||
colormap = sector->extra_colormap;
|
||
}
|
||
|
||
HWR_ObjectLightLevelPost(spr, sector, &lightlevel, true);
|
||
|
||
HWR_Lighting(&Surf, lightlevel, colormap, P_SectorUsesDirectionalLighting(sector) && !(spr->mobj->frame & FF_FULLBRIGHT));
|
||
}
|
||
else
|
||
{
|
||
Surf.PolyColor.rgba = 0xFFFFFFFF;
|
||
}
|
||
|
||
// Look at HWR_ProjectSprite for more
|
||
{
|
||
md2_t *md2s;
|
||
int skinnum;
|
||
patch_t *gpatch, *blendgpatch;
|
||
GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
|
||
INT32 durs = spr->mobj->state->tics;
|
||
INT32 tics = spr->mobj->tics;
|
||
//mdlframe_t *next = NULL;
|
||
|
||
//const UINT8 flip = (UINT8)(!(spr->mobj->eflags & MFE_VERTICALFLIP) != !R_ThingVerticallyFlipped(spr->mobj)); // :chaosleep:
|
||
const UINT8 flip = (UINT8)((spr->mobj->eflags & MFE_VERTICALFLIP) == MFE_VERTICALFLIP);
|
||
const UINT8 hflip = (UINT8)(!(spr->mobj->mirrored) != !R_ThingHorizontallyFlipped(spr->mobj));
|
||
|
||
spritedef_t *sprdef;
|
||
spriteframe_t *sprframe;
|
||
spriteinfo_t *sprinfo;
|
||
interpmobjstate_t interp;
|
||
|
||
R_InterpolateMobjState(spr->mobj, R_GetMobjTimeFrac(spr->mobj), &interp);
|
||
|
||
// Apparently people don't like jump frames like that, so back it goes
|
||
//if (tics > durs)
|
||
//durs = tics;
|
||
|
||
INT32 blendmode;
|
||
if (spr->mobj->frame & FF_BLENDMASK)
|
||
blendmode = ((spr->mobj->frame & FF_BLENDMASK) >> FF_BLENDSHIFT) + 1;
|
||
else
|
||
blendmode = spr->mobj->blendmode;
|
||
|
||
blendmode = min(AST_MODULATE, blendmode);
|
||
|
||
if (spr->mobj->flags2 & MF2_SHADOW)
|
||
{
|
||
Surf.PolyColor.s.alpha = 0x40;
|
||
Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode);
|
||
}
|
||
else if (spr->mobj->frame & FF_TRANSMASK)
|
||
{
|
||
HWR_TranstableToAlpha((spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT, &Surf);
|
||
Surf.PolyFlags = HWR_SurfaceBlend(blendmode, (spr->mobj->frame & FF_TRANSMASK)>>FF_TRANSSHIFT, &Surf);
|
||
}
|
||
else
|
||
{
|
||
// this hack is dumb, but the blendmodes refuse to work otherwise
|
||
Surf.PolyColor.s.alpha = (blendmode == AST_TRANSLUCENT) ? 0xFF : 0xFE;
|
||
Surf.PolyFlags = HWR_GetBlendModeFlag(blendmode);
|
||
}
|
||
|
||
if (spr->mobj->player)
|
||
{
|
||
// make hyu´d players translucent with reducevfx, could be done better, but im lazy as crap
|
||
if (cv_reducevfx.value && spr->mobj->player->kartstuff[k_hyudorotimer] > 0)
|
||
Surf.PolyColor.s.alpha = FixedMul(FRACUNIT/2, Surf.PolyColor.s.alpha);
|
||
|
||
if (cv_playerfade.value)
|
||
Surf.PolyColor.s.alpha = FixedMul(R_DoPlayerFade(spr->mobj), Surf.PolyColor.s.alpha);
|
||
}
|
||
|
||
// dont forget to enabled the depth test because we can't do this like
|
||
// before: polygons models are not sorted
|
||
|
||
/* fuck you */
|
||
if (spr->mobj->localskin)
|
||
{
|
||
if (spr->mobj->skinlocal)
|
||
{
|
||
md2s = md2_localplayermodels;
|
||
skinnum = (skin_t *)spr->mobj->localskin - localskins;
|
||
}
|
||
else
|
||
{
|
||
md2s = md2_playermodels;
|
||
skinnum = (skin_t *)spr->mobj->localskin - skins;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
md2s = md2_playermodels;
|
||
skinnum = (skin_t *)spr->mobj->skin - skins;
|
||
}
|
||
|
||
// 1. load model+texture if not already loaded
|
||
// 2. draw model with correct position, rotation,...
|
||
if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY && !md2s[skinnum].notfound) // Use the player MD2 list if the mobj has a skin and is using the player sprites
|
||
{
|
||
md2 = &md2s[skinnum];
|
||
md2->skin = skinnum;
|
||
sprinfo = &spriteinfo[spr->mobj->sprite];
|
||
}
|
||
else
|
||
{ // if we can't find the player md2, use SPR_PLAY's MD2.
|
||
md2 = &md2_models[spr->mobj->sprite];
|
||
sprinfo = &spriteinfo[spr->mobj->sprite];
|
||
}
|
||
|
||
if (md2->error)
|
||
return; // we already failed loading this before :(
|
||
|
||
if (!md2->model)
|
||
{
|
||
CONS_Debug(DBG_RENDER, "Loading model... (%s, %s)", sprnames[spr->mobj->sprite], md2->filename);
|
||
sprintf(filename, "mdls/%s", md2->filename);
|
||
md2->model = md2_readModel(filename);
|
||
|
||
if (md2->model)
|
||
{
|
||
md2_printModelInfo(md2->model);
|
||
GL_CreateModelVBOs(md2->model);
|
||
}
|
||
else
|
||
{
|
||
//CONS_Debug(DBG_RENDER, " FAILED\n");
|
||
md2->error = true; // prevent endless fail
|
||
return;
|
||
}
|
||
}
|
||
|
||
//Hurdler: arf, I don't like that implementation at all... too much crappy
|
||
gpatch = md2->glpatch;
|
||
if (gpatch)
|
||
hwrPatch = ((GLPatch_t *)gpatch->hardware);
|
||
|
||
if (!gpatch || !hwrPatch
|
||
|| ((!hwrPatch->mipmap->format || !hwrPatch->mipmap->downloaded) && !md2->notexturefile))
|
||
md2_loadTexture(md2);
|
||
|
||
// Load it again, because it isn't being loaded into gpatch after md2_loadtexture...
|
||
gpatch = md2->glpatch;
|
||
if (gpatch)
|
||
hwrPatch = ((GLPatch_t *)gpatch->hardware);
|
||
|
||
// Load blend texture
|
||
blendgpatch = md2->blendglpatch;
|
||
if (blendgpatch)
|
||
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
|
||
|
||
if ((gpatch && hwrPatch && hwrPatch->mipmap->format) // don't load the blend texture if the base texture isn't available
|
||
&& (!blendgpatch || !hwrBlendPatch
|
||
|| ((!hwrBlendPatch->mipmap->format || !hwrBlendPatch->mipmap->downloaded) && !md2->noblendfile)))
|
||
md2_loadBlendTexture(md2);
|
||
|
||
// Load it again, because it isn't being loaded into blendgpatch after md2_loadblendtexture...
|
||
blendgpatch = md2->blendglpatch;
|
||
if (blendgpatch)
|
||
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
|
||
|
||
if (gpatch && hwrPatch && hwrPatch->mipmap->format) // else if meant that if a texture couldn't be loaded, it would just end up using something else's texture
|
||
{
|
||
if ((skincolors_t)spr->mobj->color != SKINCOLOR_NONE &&
|
||
blendgpatch && hwrBlendPatch->mipmap->format
|
||
&& gpatch->width == blendgpatch->width && gpatch->height == blendgpatch->height)
|
||
{
|
||
INT32 tcskinnum = TC_DEFAULT;
|
||
if ((spr->mobj->flags & MF_BOSS) && (spr->mobj->flags2 & MF2_FRET) && (leveltime & 1)) // Bosses "flash"
|
||
{
|
||
if (spr->mobj->type == MT_CYBRAKDEMON)
|
||
tcskinnum = TC_ALLWHITE;
|
||
else if (spr->mobj->type == MT_METALSONIC_BATTLE)
|
||
tcskinnum = TC_METALSONIC;
|
||
else
|
||
tcskinnum = TC_BOSS;
|
||
}
|
||
else if (spr->mobj->color)
|
||
{
|
||
if (spr->mobj->skin && spr->mobj->sprite == SPR_PLAY)
|
||
{
|
||
if (spr->mobj->colorized)
|
||
tcskinnum = TC_RAINBOW;
|
||
else
|
||
{
|
||
tcskinnum = (INT32)(K_GetMobjSkinNum(K_GetMobjSkin(spr->mobj), spr->mobj->skinlocal));
|
||
}
|
||
}
|
||
else tcskinnum = TC_DEFAULT;
|
||
}
|
||
|
||
HWR_GetBlendedTexture(gpatch, blendgpatch, tcskinnum, spr->colormap, (skincolors_t)spr->mobj->color);
|
||
}
|
||
else
|
||
{
|
||
// This is safe, since we know the texture has been downloaded
|
||
GL_SetTexture(hwrPatch->mipmap);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Sprite
|
||
HWR_GetMappedPatch(spr->gpatch, spr->colormap);
|
||
}
|
||
|
||
if (spr->mobj->frame & FF_ANIMATE)
|
||
{
|
||
// set duration and tics to be the correct values for FF_ANIMATE states
|
||
durs = spr->mobj->state->var2;
|
||
tics = (INT32)spr->mobj->anim_duration;
|
||
}
|
||
|
||
//FIXME: this is not yet correct
|
||
frame = (spr->mobj->frame & FF_FRAMEMASK) % md2->model->meshes[0].numFrames;
|
||
|
||
#ifdef USE_MODEL_NEXTFRAME
|
||
// Interpolate the model interpolation. (lol)
|
||
tics -= FixedToFloat(R_GetTimeFrac(RTF_LEVEL));
|
||
|
||
if (cv_glmdls.value == 1 && tics <= durs)
|
||
{
|
||
// frames are handled differently for states with FF_ANIMATE, so get the next frame differently for the interpolation
|
||
if (spr->mobj->frame & FF_ANIMATE)
|
||
{
|
||
nextFrame = (spr->mobj->frame & FF_FRAMEMASK) + 1;
|
||
if (nextFrame >= spr->mobj->state->var1)
|
||
nextFrame = (spr->mobj->state->frame & FF_FRAMEMASK);
|
||
nextFrame %= md2->model->meshes[0].numFrames;
|
||
//next = &md2->model->meshes[0].frames[nextFrame];
|
||
}
|
||
else
|
||
{
|
||
if (spr->mobj->state->nextstate != S_NULL && states[spr->mobj->state->nextstate].sprite != SPR_NULL
|
||
&& !(spr->mobj->player && (spr->mobj->state->nextstate == S_PLAY_TAP1 || spr->mobj->state->nextstate == S_PLAY_TAP2) && spr->mobj->state == &states[S_PLAY_STND]))
|
||
{
|
||
nextFrame = (states[spr->mobj->state->nextstate].frame & FF_FRAMEMASK) % md2->model->meshes[0].numFrames;
|
||
//next = &md2->model->meshes[0].frames[nextFrame];
|
||
}
|
||
}
|
||
}
|
||
#endif
|
||
|
||
//Hurdler: it seems there is still a small problem with mobj angle
|
||
p.x = FIXED_TO_FLOAT(interp.x);
|
||
p.y = FIXED_TO_FLOAT(interp.y)+md2->offset;
|
||
|
||
if (flip)
|
||
p.z = FIXED_TO_FLOAT(interp.z + spr->mobj->height);
|
||
else
|
||
p.z = FIXED_TO_FLOAT(interp.z);
|
||
|
||
if ((spr->mobj->skin || spr->mobj->localskin) && spr->mobj->sprite == SPR_PLAY)
|
||
sprdef = &K_GetMobjSkin(spr->mobj)->spritedef;
|
||
else
|
||
sprdef = &sprites[spr->mobj->sprite];
|
||
|
||
sprframe = &sprdef->spriteframes[spr->mobj->frame & FF_FRAMEMASK];
|
||
|
||
if (sprframe->rotate)
|
||
{
|
||
fixed_t anglef = AngleFixed(interp.angle);
|
||
|
||
p.angley = FIXED_TO_FLOAT(anglef);
|
||
}
|
||
else
|
||
{
|
||
const fixed_t anglef = AngleFixed((R_PointToAngle(interp.x, interp.y))-ANGLE_180);
|
||
p.angley = FIXED_TO_FLOAT(anglef);
|
||
}
|
||
|
||
const angle_t sliptideroll = ((cv_sliptideroll.value && spr->mobj->player) ? spr->mobj->player->sliproll : 0);
|
||
const SINT8 flipfactor = flip ? -1 : 1;
|
||
const angle_t thingrollangle = (spr->mobj->rollangle - spr->mobj->temprollangle);
|
||
|
||
if (thingrollangle || sliptideroll)
|
||
{
|
||
angle_t rollang = sliptideroll ? (thingrollangle + (sliptideroll * spr->mobj->player->kartstuff[k_aizdriftstrat])) : thingrollangle;
|
||
|
||
rollang *= flipfactor;
|
||
|
||
fixed_t anglef = AngleFixed(rollang);
|
||
|
||
p.rollangle = 0.0f;
|
||
|
||
if (anglef)
|
||
{
|
||
fixed_t camAngleDiff = AngleFixed(viewangle) - FLOAT_TO_FIXED(p.angley); // dumb reconversion back, I know
|
||
|
||
p.rollangle = FIXED_TO_FLOAT(anglef);
|
||
p.roll = true;
|
||
|
||
// rotation pivot
|
||
if (sprinfo->available)
|
||
{
|
||
p.centerx = FIXED_TO_FLOAT(sprinfo->pivot[frame].x);
|
||
p.centery = FIXED_TO_FLOAT(sprinfo->pivot[frame].y);
|
||
}
|
||
else
|
||
{
|
||
p.centerx = FIXED_TO_FLOAT(spr->mobj->radius/2);
|
||
p.centery = FIXED_TO_FLOAT(spr->mobj->height/2);
|
||
}
|
||
|
||
// rotation axes relative to camera
|
||
p.rollx = FIXED_TO_FLOAT(FINECOSINE(FixedAngle(camAngleDiff) >> ANGLETOFINESHIFT));
|
||
p.rollz = FIXED_TO_FLOAT(FINESINE(FixedAngle(camAngleDiff) >> ANGLETOFINESHIFT));
|
||
}
|
||
}
|
||
|
||
// slope pitch and roll
|
||
p.anglex += flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.sloperoll));
|
||
p.anglez -= flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.slopepitch));
|
||
|
||
// pitch and roll
|
||
p.anglex += flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.roll));
|
||
p.anglez -= flipfactor*FIXED_TO_FLOAT(AngleFixed(interp.pitch));
|
||
|
||
p.fliptype = atransform.fliptype;
|
||
|
||
GL_SetShader(SHADER_MODEL); // model shader
|
||
{
|
||
float this_scale = FIXED_TO_FLOAT(interp.scale);
|
||
|
||
float xs = this_scale * FIXED_TO_FLOAT(interp.spritexscale);
|
||
float ys = this_scale * FIXED_TO_FLOAT(interp.spriteyscale);
|
||
|
||
float ox = xs * flipfactor*FIXED_TO_FLOAT(interp.spritexoffset);
|
||
float oy = ys * flipfactor*FIXED_TO_FLOAT(interp.spriteyoffset);
|
||
|
||
// offset perpendicular to the camera angle
|
||
p.x -= ox * gl_viewsin;
|
||
p.y += ox * gl_viewcos;
|
||
p.z += oy;
|
||
|
||
GL_DrawModel(md2->model, frame, durs, tics, nextFrame, &p, md2->scale * xs, md2->scale * ys, flip, hflip, &Surf);
|
||
}
|
||
}
|
||
}
|
||
|
||
// mostly copy paste of HWR_DrawMD2
|
||
// very ugly but our model code kinda sucks
|
||
void HWR_Draw2DModel(md2_t *md2, INT32 x, INT32 y, INT32 skinnum, skincolors_t color, const UINT8 *colormap, fixed_t scale, INT32 frame, angle_t angle)
|
||
{
|
||
patch_t *gpatch, *blendgpatch;
|
||
GLPatch_t *hwrPatch = NULL, *hwrBlendPatch = NULL;
|
||
FTransform p;
|
||
FSurfaceInfo Surf = {};
|
||
|
||
if (!md2->model)
|
||
{
|
||
char filename[64];
|
||
CONS_Debug(DBG_RENDER, "Loading model... (%s)\n", md2->filename);
|
||
sprintf(filename, "mdls/%s", md2->filename);
|
||
md2->model = md2_readModel(filename);
|
||
|
||
if (md2->model)
|
||
{
|
||
md2_printModelInfo(md2->model);
|
||
GL_CreateModelVBOs(md2->model);
|
||
}
|
||
else
|
||
{
|
||
md2->error = true;
|
||
return;
|
||
}
|
||
}
|
||
|
||
if (md2->model->meshes[0].numFrames > 0)
|
||
frame = frame % md2->model->meshes[0].numFrames;
|
||
else
|
||
frame = 0;
|
||
|
||
gpatch = (patch_t *)(md2->glpatch);
|
||
if (gpatch)
|
||
hwrPatch = ((GLPatch_t *)gpatch->hardware);
|
||
|
||
if (!gpatch || !hwrPatch ||
|
||
((!hwrPatch->mipmap->format || !hwrPatch->mipmap->downloaded) && !md2->notexturefile))
|
||
md2_loadTexture(md2);
|
||
|
||
gpatch = (patch_t*)(md2->glpatch);
|
||
if (gpatch)
|
||
hwrPatch = ((GLPatch_t *)gpatch->hardware);
|
||
|
||
blendgpatch = (patch_t*)(md2->blendglpatch);
|
||
if (blendgpatch)
|
||
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
|
||
|
||
if ((gpatch && hwrPatch && hwrPatch->mipmap->format) &&
|
||
(!blendgpatch || !hwrBlendPatch ||
|
||
((!hwrBlendPatch->mipmap->format || !hwrBlendPatch->mipmap->downloaded) && !md2->noblendfile)))
|
||
md2_loadBlendTexture(md2);
|
||
|
||
blendgpatch = (patch_t*)(md2->blendglpatch);
|
||
if (blendgpatch)
|
||
hwrBlendPatch = ((GLPatch_t *)blendgpatch->hardware);
|
||
|
||
Surf.PolyColor.rgba = 0xFFFFFFFF;
|
||
Surf.PolyFlags = PF_Occlude | PF_Modulated;
|
||
|
||
Surf.LightInfo.light_level = 255;
|
||
Surf.LightInfo.fade_start = 0;
|
||
Surf.LightInfo.fade_end = 31;
|
||
|
||
if (color != SKINCOLOR_NONE &&
|
||
blendgpatch && hwrBlendPatch->mipmap->format &&
|
||
gpatch->width == blendgpatch->width && gpatch->height == blendgpatch->height)
|
||
{
|
||
INT32 tcskinnum = TC_DEFAULT;
|
||
|
||
if (color)
|
||
tcskinnum = skinnum;
|
||
|
||
HWR_GetBlendedTexture(gpatch, blendgpatch, tcskinnum, colormap, color);
|
||
}
|
||
else if (hwrPatch && hwrPatch->mipmap->format)
|
||
{
|
||
GL_SetTexture(hwrPatch->mipmap);
|
||
}
|
||
|
||
memset(&p, 0x00, sizeof(FTransform));
|
||
|
||
p.x = x*vid.dup + (float)(vid.width - BASEVIDWIDTH*vid.dup)/2.f;
|
||
p.y = -420.f; // push it back to prevent wonky culling, idk lul
|
||
p.z = y*vid.dup + (float)(vid.height - BASEVIDHEIGHT*vid.dup)/2.f;
|
||
|
||
p.angley = FixedToFloat(AngleFixed(angle));
|
||
p.anglex = 0.f;
|
||
p.anglez = 0.f;
|
||
|
||
p.roll = false;
|
||
p.fliptype = TRANSFORM_NONE;
|
||
|
||
const float fscale = FixedToFloat(scale*vid.dup);
|
||
|
||
GL_Draw2DModel(
|
||
md2->model,
|
||
frame,
|
||
0.f,
|
||
0.f,
|
||
-1,
|
||
&p,
|
||
fscale,
|
||
fscale,
|
||
true, // flip it vertically lul
|
||
false,
|
||
&Surf
|
||
);
|
||
}
|
||
|
||
#endif //HWRENDER
|