OrdinaryMagician/vkdoom_m
OrdinaryMagician/vkdoom_m
1
Fork 0
Code Activity

- the fourth.

Browse source
This commit is contained in:
Christoph Oelckers 2017-03-08 18:47:52 +01:00
commit 8ab562ef13
107 changed files with 1041 additions and 1041 deletions
Download patch file Download diff file Expand all files Collapse all files

160
src/v_font.cpp
View file

@ -101,15 +101,15 @@ The FON2 header is followed by variable length data:
#define DEFAULT_LOG_COLOR PalEntry(223,223,223)
// TYPES -------------------------------------------------------------------
void RecordTextureColors (FTexture *pic, BYTE *colorsused);
void RecordTextureColors (FTexture *pic, uint8_t *colorsused);
// This structure is used by BuildTranslations() to hold color information.
struct TranslationParm
{
short RangeStart; // First level for this range
short RangeEnd; // Last level for this range
BYTE Start[3]; // Start color for this range
BYTE End[3]; // End color for this range
uint8_t Start[3]; // Start color for this range
uint8_t End[3]; // End color for this range
};
struct TranslationMap
@ -126,12 +126,12 @@ public:
protected:
void CheckFON1Chars (double *luminosity);
void BuildTranslations2 ();
void FixupPalette (BYTE *identity, double *luminosity, const BYTE *palette,
void FixupPalette (uint8_t *identity, double *luminosity, const uint8_t *palette,
bool rescale, PalEntry *out_palette);
void LoadTranslations ();
void LoadFON1 (int lump, const BYTE *data);
void LoadFON2 (int lump, const BYTE *data);
void LoadBMF (int lump, const BYTE *data);
void LoadFON1 (int lump, const uint8_t *data);
void LoadFON2 (int lump, const uint8_t *data);
void LoadBMF (int lump, const uint8_t *data);
void CreateFontFromPic (FTextureID picnum);
static int BMFCompare(const void *a, const void *b);
@ -142,7 +142,7 @@ protected:
FONT2,
BMFFONT
} FontType;
BYTE PaletteData[768];
uint8_t PaletteData[768];
bool RescalePalette;
};
@ -176,9 +176,9 @@ class FFontChar1 : public FTexture
{
public:
FFontChar1 (FTexture *sourcelump);
const BYTE *GetColumn (unsigned int column, const Span **spans_out);
const BYTE *GetPixels ();
void SetSourceRemap(const BYTE *sourceremap);
const uint8_t *GetColumn (unsigned int column, const Span **spans_out);
const uint8_t *GetPixels ();
void SetSourceRemap(const uint8_t *sourceremap);
void Unload ();
~FFontChar1 ();
@ -186,8 +186,8 @@ protected:
void MakeTexture ();
FTexture *BaseTexture;
BYTE *Pixels;
const BYTE *SourceRemap;
uint8_t *Pixels;
const uint8_t *SourceRemap;
};
// This is a font character that reads RLE compressed data.
@ -197,17 +197,17 @@ public:
FFontChar2 (int sourcelump, int sourcepos, int width, int height, int leftofs=0, int topofs=0);
~FFontChar2 ();
const BYTE *GetColumn (unsigned int column, const Span **spans_out);
const BYTE *GetPixels ();
void SetSourceRemap(const BYTE *sourceremap);
const uint8_t *GetColumn (unsigned int column, const Span **spans_out);
const uint8_t *GetPixels ();
void SetSourceRemap(const uint8_t *sourceremap);
void Unload ();
protected:
int SourceLump;
int SourcePos;
BYTE *Pixels;
uint8_t *Pixels;
Span **Spans;
const BYTE *SourceRemap;
const uint8_t *SourceRemap;
void MakeTexture ();
};
@ -371,7 +371,7 @@ FFont::FFont (const char *name, const char *nametemplate, int first, int count,
Lump = fdlump;
Chars = new CharData[count];
charlumps = new FTexture *[count];
PatchRemap = new BYTE[256];
PatchRemap = new uint8_t[256];
FirstChar = first;
LastChar = first + count - 1;
FontHeight = 0;
@ -550,18 +550,18 @@ DEFINE_ACTION_FUNCTION(FFont, FindFont)
//
//==========================================================================
void RecordTextureColors (FTexture *pic, BYTE *usedcolors)
void RecordTextureColors (FTexture *pic, uint8_t *usedcolors)
{
int x;
for (x = pic->GetWidth() - 1; x >= 0; x--)
{
const FTexture::Span *spans;
const BYTE *column = pic->GetColumn (x, &spans);
const uint8_t *column = pic->GetColumn (x, &spans);
while (spans->Length != 0)
{
const BYTE *source = column + spans->TopOffset;
const uint8_t *source = column + spans->TopOffset;
int count = spans->Length;
do
@ -584,12 +584,12 @@ void RecordTextureColors (FTexture *pic, BYTE *usedcolors)
static int compare (const void *arg1, const void *arg2)
{
if (RPART(GPalette.BaseColors[*((BYTE *)arg1)]) * 299 +
GPART(GPalette.BaseColors[*((BYTE *)arg1)]) * 587 +
BPART(GPalette.BaseColors[*((BYTE *)arg1)]) * 114 <
RPART(GPalette.BaseColors[*((BYTE *)arg2)]) * 299 +
GPART(GPalette.BaseColors[*((BYTE *)arg2)]) * 587 +
BPART(GPalette.BaseColors[*((BYTE *)arg2)]) * 114)
if (RPART(GPalette.BaseColors[*((uint8_t *)arg1)]) * 299 +
GPART(GPalette.BaseColors[*((uint8_t *)arg1)]) * 587 +
BPART(GPalette.BaseColors[*((uint8_t *)arg1)]) * 114 <
RPART(GPalette.BaseColors[*((uint8_t *)arg2)]) * 299 +
GPART(GPalette.BaseColors[*((uint8_t *)arg2)]) * 587 +
BPART(GPalette.BaseColors[*((uint8_t *)arg2)]) * 114)
return -1;
else
return 1;
@ -614,7 +614,7 @@ static int compare (const void *arg1, const void *arg2)
//
//==========================================================================
int FFont::SimpleTranslation (BYTE *colorsused, BYTE *translation, BYTE *reverse, double **luminosity)
int FFont::SimpleTranslation (uint8_t *colorsused, uint8_t *translation, uint8_t *reverse, double **luminosity)
{
double min, max, diver;
int i, j;
@ -671,7 +671,7 @@ int FFont::SimpleTranslation (BYTE *colorsused, BYTE *translation, BYTE *reverse
//
//==========================================================================
void FFont::BuildTranslations (const double *luminosity, const BYTE *identity,
void FFont::BuildTranslations (const double *luminosity, const uint8_t *identity,
const void *ranges, int total_colors, const PalEntry *palette)
{
int i, j;
@ -871,7 +871,7 @@ DEFINE_ACTION_FUNCTION(FFont, GetHeight)
//
//==========================================================================
int FFont::StringWidth(const BYTE *string) const
int FFont::StringWidth(const uint8_t *string) const
{
int w = 0;
int maxw = 0;
@ -926,7 +926,7 @@ DEFINE_ACTION_FUNCTION(FFont, StringWidth)
void FFont::LoadTranslations()
{
unsigned int count = LastChar - FirstChar + 1;
BYTE usedcolors[256], identity[256];
uint8_t usedcolors[256], identity[256];
double *luminosity;
memset (usedcolors, 0, 256);
@ -1029,7 +1029,7 @@ FSingleLumpFont::FSingleLumpFont (const char *name, int lump) : FFont(lump)
FontName = name;
FMemLump data1 = Wads.ReadLump (lump);
const BYTE *data = (const BYTE *)data1.GetMem();
const uint8_t *data = (const uint8_t *)data1.GetMem();
if (data[0] == 0xE1 && data[1] == 0xE6 && data[2] == 0xD5 && data[3] == 0x1A)
{
@ -1089,7 +1089,7 @@ void FSingleLumpFont::CreateFontFromPic (FTextureID picnum)
void FSingleLumpFont::LoadTranslations()
{
double luminosity[256];
BYTE identity[256];
uint8_t identity[256];
PalEntry local_palette[256];
bool useidentity = true;
bool usepalette = false;
@ -1135,7 +1135,7 @@ void FSingleLumpFont::LoadTranslations()
//
//==========================================================================
void FSingleLumpFont::LoadFON1 (int lump, const BYTE *data)
void FSingleLumpFont::LoadFON1 (int lump, const uint8_t *data)
{
int w, h;
@ -1150,7 +1150,7 @@ void FSingleLumpFont::LoadFON1 (int lump, const BYTE *data)
FirstChar = 0;
LastChar = 255;
GlobalKerning = 0;
PatchRemap = new BYTE[256];
PatchRemap = new uint8_t[256];
for(unsigned int i = 0;i < 256;++i)
Chars[i].Pic = NULL;
@ -1167,13 +1167,13 @@ void FSingleLumpFont::LoadFON1 (int lump, const BYTE *data)
//
//==========================================================================
void FSingleLumpFont::LoadFON2 (int lump, const BYTE *data)
void FSingleLumpFont::LoadFON2 (int lump, const uint8_t *data)
{
int count, i, totalwidth;
int *widths2;
WORD *widths;
const BYTE *palette;
const BYTE *data_p;
uint16_t *widths;
const uint8_t *palette;
const uint8_t *data_p;
FontType = FONT2;
FontHeight = data[4] + data[5]*256;
@ -1188,13 +1188,13 @@ void FSingleLumpFont::LoadFON2 (int lump, const BYTE *data)
widths2 = new int[count];
if (data[11] & 1)
{ // Font specifies a kerning value.
GlobalKerning = LittleShort(*(SWORD *)&data[12]);
widths = (WORD *)(data + 14);
GlobalKerning = LittleShort(*(int16_t *)&data[12]);
widths = (uint16_t *)(data + 14);
}
else
{ // Font does not specify a kerning value.
GlobalKerning = 0;
widths = (WORD *)(data + 12);
widths = (uint16_t *)(data + 12);
}
totalwidth = 0;
@ -1206,7 +1206,7 @@ void FSingleLumpFont::LoadFON2 (int lump, const BYTE *data)
widths2[i] = totalwidth;
}
totalwidth *= count;
palette = (BYTE *)&widths[1];
palette = (uint8_t *)&widths[1];
}
else
{ // Font has varying character widths.
@ -1215,7 +1215,7 @@ void FSingleLumpFont::LoadFON2 (int lump, const BYTE *data)
widths2[i] = LittleShort(widths[i]);
totalwidth += widths2[i];
}
palette = (BYTE *)(widths + i);
palette = (uint8_t *)(widths + i);
}
if (FirstChar <= ' ' && LastChar >= ' ')
@ -1248,7 +1248,7 @@ void FSingleLumpFont::LoadFON2 (int lump, const BYTE *data)
Chars[i].Pic = new FFontChar2 (lump, int(data_p - data), widths2[i], FontHeight);
do
{
SBYTE code = *data_p++;
int8_t code = *data_p++;
if (code >= 0)
{
data_p += code+1;
@ -1281,18 +1281,18 @@ void FSingleLumpFont::LoadFON2 (int lump, const BYTE *data)
//
//==========================================================================
void FSingleLumpFont::LoadBMF(int lump, const BYTE *data)
void FSingleLumpFont::LoadBMF(int lump, const uint8_t *data)
{
const BYTE *chardata;
const uint8_t *chardata;
int numchars, count, totalwidth, nwidth;
int infolen;
int i, chari;
BYTE raw_palette[256*3];
uint8_t raw_palette[256*3];
PalEntry sort_palette[256];
FontType = BMFFONT;
FontHeight = data[5];
GlobalKerning = (SBYTE)data[8];
GlobalKerning = (int8_t)data[8];
ActiveColors = data[16];
SpaceWidth = -1;
nwidth = -1;
@ -1354,7 +1354,7 @@ void FSingleLumpFont::LoadBMF(int lump, const BYTE *data)
qsort(sort_palette + 1, ActiveColors - 1, sizeof(PalEntry), BMFCompare);
// Create the PatchRemap table from the sorted "alpha" values.
PatchRemap = new BYTE[ActiveColors];
PatchRemap = new uint8_t[ActiveColors];
PatchRemap[0] = 0;
for (i = 1; i < ActiveColors; ++i)
{
@ -1384,8 +1384,8 @@ void FSingleLumpFont::LoadBMF(int lump, const BYTE *data)
Chars[chardata[chari] - FirstChar].Pic = new FFontChar2(lump, int(chardata + chari + 6 - data),
chardata[chari+1], // width
chardata[chari+2], // height
-(SBYTE)chardata[chari+3], // x offset
-(SBYTE)chardata[chari+4] // y offset
-(int8_t)chardata[chari+3], // x offset
-(int8_t)chardata[chari+4] // y offset
);
}
@ -1436,10 +1436,10 @@ int FSingleLumpFont::BMFCompare(const void *a, const void *b)
void FSingleLumpFont::CheckFON1Chars (double *luminosity)
{
FMemLump memLump = Wads.ReadLump(Lump);
const BYTE* data = (const BYTE*) memLump.GetMem();
const uint8_t* data = (const uint8_t*) memLump.GetMem();
BYTE used[256], reverse[256];
const BYTE *data_p;
uint8_t used[256], reverse[256];
const uint8_t *data_p;
int i, j;
memset (used, 0, 256);
@ -1458,7 +1458,7 @@ void FSingleLumpFont::CheckFON1Chars (double *luminosity)
// Advance to next char's data and count the used colors.
do
{
SBYTE code = *data_p++;
int8_t code = *data_p++;
if (code >= 0)
{
destSize -= code+1;
@ -1501,7 +1501,7 @@ void FSingleLumpFont::CheckFON1Chars (double *luminosity)
//
//==========================================================================
void FSingleLumpFont::FixupPalette (BYTE *identity, double *luminosity, const BYTE *palette, bool rescale, PalEntry *out_palette)
void FSingleLumpFont::FixupPalette (uint8_t *identity, double *luminosity, const uint8_t *palette, bool rescale, PalEntry *out_palette)
{
int i;
double maxlum = 0.0;
@ -1639,7 +1639,7 @@ FFontChar1::FFontChar1 (FTexture *sourcelump)
//
//==========================================================================
const BYTE *FFontChar1::GetPixels ()
const uint8_t *FFontChar1::GetPixels ()
{
if (Pixels == NULL)
{
@ -1658,8 +1658,8 @@ void FFontChar1::MakeTexture ()
{
// Make the texture as normal, then remap it so that all the colors
// are at the low end of the palette
Pixels = new BYTE[Width*Height];
const BYTE *pix = BaseTexture->GetPixels();
Pixels = new uint8_t[Width*Height];
const uint8_t *pix = BaseTexture->GetPixels();
if (!SourceRemap)
{
@ -1680,7 +1680,7 @@ void FFontChar1::MakeTexture ()
//
//==========================================================================
const BYTE *FFontChar1::GetColumn (unsigned int column, const Span **spans_out)
const uint8_t *FFontChar1::GetColumn (unsigned int column, const Span **spans_out)
{
if (Pixels == NULL)
{
@ -1697,7 +1697,7 @@ const BYTE *FFontChar1::GetColumn (unsigned int column, const Span **spans_out)
//
//==========================================================================
void FFontChar1::SetSourceRemap(const BYTE *sourceremap)
void FFontChar1::SetSourceRemap(const uint8_t *sourceremap)
{
Unload();
SourceRemap = sourceremap;
@ -1785,7 +1785,7 @@ void FFontChar2::Unload ()
//
//==========================================================================
const BYTE *FFontChar2::GetPixels ()
const uint8_t *FFontChar2::GetPixels ()
{
if (Pixels == NULL)
{
@ -1800,7 +1800,7 @@ const BYTE *FFontChar2::GetPixels ()
//
//==========================================================================
const BYTE *FFontChar2::GetColumn (unsigned int column, const Span **spans_out)
const uint8_t *FFontChar2::GetColumn (unsigned int column, const Span **spans_out)
{
if (Pixels == NULL)
{
@ -1827,7 +1827,7 @@ const BYTE *FFontChar2::GetColumn (unsigned int column, const Span **spans_out)
//
//==========================================================================
void FFontChar2::SetSourceRemap(const BYTE *sourceremap)
void FFontChar2::SetSourceRemap(const uint8_t *sourceremap)
{
Unload();
SourceRemap = sourceremap;
@ -1843,12 +1843,12 @@ void FFontChar2::MakeTexture ()
{
FWadLump lump = Wads.OpenLumpNum (SourceLump);
int destSize = Width * Height;
BYTE max = 255;
uint8_t max = 255;
bool rle = true;
// This is to "fix" bad fonts
{
BYTE buff[16];
uint8_t buff[16];
lump.Read (buff, 4);
if (buff[3] == '2')
{
@ -1869,11 +1869,11 @@ void FFontChar2::MakeTexture ()
}
}
Pixels = new BYTE[destSize];
Pixels = new uint8_t[destSize];
int runlen = 0, setlen = 0;
BYTE setval = 0; // Shut up, GCC!
BYTE *dest_p = Pixels;
uint8_t setval = 0; // Shut up, GCC!
uint8_t *dest_p = Pixels;
int dest_adv = Height;
int dest_rew = destSize - 1;
@ -1885,7 +1885,7 @@ void FFontChar2::MakeTexture ()
{
if (runlen != 0)
{
BYTE color;
uint8_t color;
lump >> color;
color = MIN (color, max);
@ -1907,7 +1907,7 @@ void FFontChar2::MakeTexture ()
}
else
{
SBYTE code;
int8_t code;
lump >> code;
if (code >= 0)
@ -1916,7 +1916,7 @@ void FFontChar2::MakeTexture ()
}
else if (code != -128)
{
BYTE color;
uint8_t color;
lump >> color;
setlen = (-code) + 1;
@ -1937,7 +1937,7 @@ void FFontChar2::MakeTexture ()
{
for (int x = Width; x != 0; --x)
{
BYTE color;
uint8_t color;
lump >> color;
if (color > max)
{
@ -1982,7 +1982,7 @@ FSpecialFont::FSpecialFont (const char *name, int first, int count, FTexture **l
FontName = name;
Chars = new CharData[count];
charlumps = new FTexture*[count];
PatchRemap = new BYTE[256];
PatchRemap = new uint8_t[256];
FirstChar = first;
LastChar = first + count - 1;
FontHeight = 0;
@ -2050,7 +2050,7 @@ FSpecialFont::FSpecialFont (const char *name, int first, int count, FTexture **l
void FSpecialFont::LoadTranslations()
{
int count = LastChar - FirstChar + 1;
BYTE usedcolors[256], identity[256];
uint8_t usedcolors[256], identity[256];
double *luminosity;
int TotalColors;
int i, j;
@ -2607,9 +2607,9 @@ PalEntry V_LogColorFromColorRange (EColorRange range)
//
//==========================================================================
EColorRange V_ParseFontColor (const BYTE *&color_value, int normalcolor, int boldcolor)
EColorRange V_ParseFontColor (const uint8_t *&color_value, int normalcolor, int boldcolor)
{
const BYTE *ch = color_value;
const uint8_t *ch = color_value;
int newcolor = *ch++;
if (newcolor == '-') // Normal
@ -2630,7 +2630,7 @@ EColorRange V_ParseFontColor (const BYTE *&color_value, int normalcolor, int bol
}
else if (newcolor == '[') // Named
{
const BYTE *namestart = ch;
const uint8_t *namestart = ch;
while (*ch != ']' && *ch != '\0')
{
ch++;