zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2024-11-11 07:11:54 +00:00
Code Issues Projects Releases Packages Wiki Activity

- minimalized the interface to the translation tables to a small set of functions.

Browse source 
Now the internals can be refactored without affecting all using code.
This commit is contained in:
Christoph Oelckers 2020-04-11 12:42:07 +02:00
parent 0a7344e432
commit 520a96033b
4 changed files with 127 additions and 134 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/p_setup.cpp
View file

@ -406,7 +406,7 @@ void P_SetupLevel(FLevelLocals *Level, int position, bool newGame)
{ {
Level->Players[i]->mo = nullptr; Level->Players[i]->mo = nullptr;
} }
ClearScriptedTranslations(); ClearTranslationSlot(TRANSLATION_LevelScripted);
// Initial height of PointOfView will be set by player think. // Initial height of PointOfView will be set by player think.

1
src/playsim/p_acs.cpp
View file

@ -9591,6 +9591,7 @@ scriptwait:
if (translation != NULL) if (translation != NULL)
{ {
UpdateTranslation(TRANSLATION(TRANSLATION_LevelScripted, transi), translation); UpdateTranslation(TRANSLATION(TRANSLATION_LevelScripted, transi), translation);
delete translation;
translation = NULL; translation = NULL;
} }
break; break;

254
src/r_data/r_translate.cpp
View file

@ -53,18 +53,33 @@
#include "gi.h" #include "gi.h"
static FMemArena remapArena;
static TAutoGrowArray<FRemapTablePtr, FRemapTable *> TranslationTables[NUM_TRANSLATION_TABLES]; static TAutoGrowArray<FRemapTablePtr, FRemapTable *> TranslationTables[NUM_TRANSLATION_TABLES];
inline FRemapTable* AllocRemap(FRemapTable *remap)
{
auto newremap = (FRemapTable*)remapArena.Alloc(sizeof(FRemapTable));
if (remap) *newremap = *remap;
else newremap->MakeIdentity();
return newremap;
}
void UpdateTranslation(int trans, FRemapTable* remap) void UpdateTranslation(int trans, FRemapTable* remap)
{ {
TranslationTables[GetTranslationType(trans)].SetVal(GetTranslationIndex(trans), remap); auto newremap = AllocRemap(remap);
TranslationTables[GetTranslationType(trans)].SetVal(GetTranslationIndex(trans), newremap);
remap->UpdateNative(); remap->UpdateNative();
} }
int AddTranslation(int slot, FRemapTable* remap) int AddTranslation(int slot, FRemapTable* remap, int count)
{ {
auto i = TranslationTables[slot].Push(remap); uint32_t id;
return TRANSLATION(slot, i); for (int i = 0; i < count; i++)
{
auto newremap = AllocRemap(&remap[i]);
id = TranslationTables[slot].Push(newremap);
}
return TRANSLATION(slot, id);
} }
FRemapTable* GetTranslation(int slot, int index) FRemapTable* GetTranslation(int slot, int index)
@ -78,19 +93,14 @@ void CopyTranslation(int dest, int src)
TranslationTables[GetTranslationType(dest)][GetTranslationType(src)]->UpdateNative(); TranslationTables[GetTranslationType(dest)][GetTranslationType(src)]->UpdateNative();
} }
void ClearScriptedTranslations() void ClearTranslationSlot(int slot)
{ {
// [RH] Clear any scripted translation colors the previous level may have set. TranslationTables[slot].Clear();
for (unsigned i = 0; i < TranslationTables[TRANSLATION_LevelScripted].Size(); ++i) }
{
FRemapTable* table = TranslationTables[TRANSLATION_LevelScripted][i]; unsigned NumTranslations(int slot)
if (table != nullptr) {
{ return TranslationTables[slot].Size();
delete table;
TranslationTables[TRANSLATION_LevelScripted][i] = nullptr;
}
}
TranslationTables[TRANSLATION_LevelScripted].Clear();
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -103,18 +113,12 @@ FRemapTable *TranslationToTable(int translation)
{ {
unsigned int type = GetTranslationType(translation); unsigned int type = GetTranslationType(translation);
unsigned int index = GetTranslationIndex(translation); unsigned int index = GetTranslationIndex(translation);
TAutoGrowArray<FRemapTablePtr, FRemapTable *> *slots;
if (type <= 0 || type >= NUM_TRANSLATION_TABLES) if (type <= 0 || type >= NUM_TRANSLATION_TABLES || index >= NumTranslations(type))
{ {
return NULL; return NULL;
} }
slots = &TranslationTables[type]; return GetTranslation(type, index);
if (index >= slots->Size())
{
return NULL;
}
return slots->operator[](index);
} }
@ -253,9 +257,10 @@ void FRemapTable::StaticSerializeTranslations(FSerializer &arc)
int w; int w;
if (arc.isWriting()) if (arc.isWriting())
{ {
for (unsigned int i = 0; i < TranslationTables[TRANSLATION_LevelScripted].Size(); ++i) auto size = NumTranslations(TRANSLATION_LevelScripted);
for (unsigned int i = 0; i < size; ++i)
{ {
trans = TranslationTables[TRANSLATION_LevelScripted][i]; trans = TranslationToTable(TRANSLATION(TRANSLATION_LevelScripted, i));
if (trans != NULL && !trans->IsIdentity()) if (trans != NULL && !trans->IsIdentity())
{ {
if (arc.BeginObject(nullptr)) if (arc.BeginObject(nullptr))
@ -272,13 +277,9 @@ void FRemapTable::StaticSerializeTranslations(FSerializer &arc)
while (arc.BeginObject(nullptr)) while (arc.BeginObject(nullptr))
{ {
arc("index", w); arc("index", w);
trans = TranslationTables[TRANSLATION_LevelScripted].GetVal(w); FRemapTable remap;
if (trans == NULL) remap.Serialize(arc);
{ UpdateTranslation(TRANSLATION(TRANSLATION_LevelScripted, w), &remap);
trans = new FRemapTable;
TranslationTables[TRANSLATION_LevelScripted].SetVal(w, trans);
}
trans->Serialize(arc);
arc.EndObject(); arc.EndObject();
} }
} }
@ -770,25 +771,36 @@ int FRemapTable::StoreTranslation(int slot)
{ {
unsigned int i; unsigned int i;
for (i = 0; i < TranslationTables[slot].Size(); i++) auto size = NumTranslations(slot);
for (i = 0; i < size; i++)
{ {
if (*this == *TranslationTables[slot][i]) if (*this == *TranslationToTable(TRANSLATION(slot, i)))
{ {
// A duplicate of this translation already exists // A duplicate of this translation already exists
return TRANSLATION(slot, i); return TRANSLATION(slot, i);
} }
} }
if (TranslationTables[slot].Size() >= MAX_DECORATE_TRANSLATIONS) if (size >= MAX_DECORATE_TRANSLATIONS)
{ {
I_Error("Too many DECORATE translations"); I_Error("Too many DECORATE translations");
} }
FRemapTable *newtrans = new FRemapTable; return AddTranslation(slot, this);
*newtrans = *this;
i = TranslationTables[slot].Push(newtrans);
return TRANSLATION(slot, i);
} }
//----------------------------------------------------------------------------
//
//
//
//----------------------------------------------------------------------------
static void PushIdentityTable(int slot)
{
FRemapTable table;
table.MakeIdentity();
AddTranslation(slot, &table);
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// //
// //
@ -804,7 +816,7 @@ int CreateBloodTranslation(PalEntry color)
if (BloodTranslationColors.Size() == 0) if (BloodTranslationColors.Size() == 0)
{ {
// Don't use the first slot. // Don't use the first slot.
TranslationTables[TRANSLATION_Blood].Push(NULL); PushIdentityTable(TRANSLATION_Blood);
BloodTranslationColors.Push(0); BloodTranslationColors.Push(0);
} }
@ -822,35 +834,22 @@ int CreateBloodTranslation(PalEntry color)
{ {
I_Error("Too many blood colors"); I_Error("Too many blood colors");
} }
FRemapTable *trans = new FRemapTable; FRemapTable trans;
trans->Palette[0] = 0; trans.Palette[0] = 0;
trans->Remap[0] = 0; trans.Remap[0] = 0;
for (i = 1; i < 256; i++) for (i = 1; i < 256; i++)
{ {
int bright = MAX(MAX(GPalette.BaseColors[i].r, GPalette.BaseColors[i].g), GPalette.BaseColors[i].b); int bright = std::max(std::max(GPalette.BaseColors[i].r, GPalette.BaseColors[i].g), GPalette.BaseColors[i].b);
PalEntry pe = PalEntry(255, color.r*bright/255, color.g*bright/255, color.b*bright/255); PalEntry pe = PalEntry(255, color.r*bright/255, color.g*bright/255, color.b*bright/255);
int entry = ColorMatcher.Pick(pe.r, pe.g, pe.b); int entry = ColorMatcher.Pick(pe.r, pe.g, pe.b);
trans->Palette[i] = pe; trans.Palette[i] = pe;
trans->Remap[i] = entry; trans.Remap[i] = entry;
} }
TranslationTables[TRANSLATION_Blood].Push(trans); AddTranslation(TRANSLATION_Blood, &trans);
return BloodTranslationColors.Push(color); return BloodTranslationColors.Push(color);
} }
//----------------------------------------------------------------------------
//
//
//
//----------------------------------------------------------------------------
static void PushIdentityTable(int slot)
{
FRemapTable *table = new FRemapTable;
table->MakeIdentity();
TranslationTables[slot].Push(table);
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
// //
// R_InitTranslationTables // R_InitTranslationTables
@ -878,9 +877,10 @@ void R_InitTranslationTables ()
// The three standard translations from Doom or Heretic (seven for Strife), // The three standard translations from Doom or Heretic (seven for Strife),
// plus the generic ice translation. // plus the generic ice translation.
FRemapTable stdremaps[10];
for (i = 0; i < 8; ++i) for (i = 0; i < 8; ++i)
{ {
PushIdentityTable(TRANSLATION_Standard); stdremaps[i].MakeIdentity();
} }
// Each player corpse has its own translation so they won't change // Each player corpse has its own translation so they won't change
@ -895,84 +895,84 @@ void R_InitTranslationTables ()
{ {
for (i = 0x70; i < 0x80; i++) for (i = 0x70; i < 0x80; i++)
{ // map green ramp to gray, brown, red { // map green ramp to gray, brown, red
TranslationTables[TRANSLATION_Standard][0]->Remap[i] = 0x60 + (i&0xf); stdremaps[0].Remap[i] = 0x60 + (i&0xf);
TranslationTables[TRANSLATION_Standard][1]->Remap[i] = 0x40 + (i&0xf); stdremaps[1].Remap[i] = 0x40 + (i&0xf);
TranslationTables[TRANSLATION_Standard][2]->Remap[i] = 0x20 + (i&0xf); stdremaps[2].Remap[i] = 0x20 + (i&0xf);
TranslationTables[TRANSLATION_Standard][0]->Palette[i] = GPalette.BaseColors[0x60 + (i&0xf)] | MAKEARGB(255,0,0,0); stdremaps[0].Palette[i] = GPalette.BaseColors[0x60 + (i&0xf)] | MAKEARGB(255,0,0,0);
TranslationTables[TRANSLATION_Standard][1]->Palette[i] = GPalette.BaseColors[0x40 + (i&0xf)] | MAKEARGB(255,0,0,0); stdremaps[1].Palette[i] = GPalette.BaseColors[0x40 + (i&0xf)] | MAKEARGB(255,0,0,0);
TranslationTables[TRANSLATION_Standard][2]->Palette[i] = GPalette.BaseColors[0x20 + (i&0xf)] | MAKEARGB(255,0,0,0); stdremaps[2].Palette[i] = GPalette.BaseColors[0x20 + (i&0xf)] | MAKEARGB(255,0,0,0);
} }
} }
else if (gameinfo.gametype == GAME_Heretic) else if (gameinfo.gametype == GAME_Heretic)
{ {
for (i = 225; i <= 240; i++) for (i = 225; i <= 240; i++)
{ {
TranslationTables[TRANSLATION_Standard][0]->Remap[i] = 114+(i-225); // yellow stdremaps[0].Remap[i] = 114+(i-225); // yellow
TranslationTables[TRANSLATION_Standard][1]->Remap[i] = 145+(i-225); // red stdremaps[1].Remap[i] = 145+(i-225); // red
TranslationTables[TRANSLATION_Standard][2]->Remap[i] = 190+(i-225); // blue stdremaps[2].Remap[i] = 190+(i-225); // blue
TranslationTables[TRANSLATION_Standard][0]->Palette[i] = GPalette.BaseColors[114+(i-225)] | MAKEARGB(255,0,0,0); stdremaps[0].Palette[i] = GPalette.BaseColors[114+(i-225)] | MAKEARGB(255,0,0,0);
TranslationTables[TRANSLATION_Standard][1]->Palette[i] = GPalette.BaseColors[145+(i-225)] | MAKEARGB(255,0,0,0); stdremaps[1].Palette[i] = GPalette.BaseColors[145+(i-225)] | MAKEARGB(255,0,0,0);
TranslationTables[TRANSLATION_Standard][2]->Palette[i] = GPalette.BaseColors[190+(i-225)] | MAKEARGB(255,0,0,0); stdremaps[2].Palette[i] = GPalette.BaseColors[190+(i-225)] | MAKEARGB(255,0,0,0);
} }
} }
else if (gameinfo.gametype == GAME_Strife) else if (gameinfo.gametype == GAME_Strife)
{ {
for (i = 0x20; i <= 0x3F; ++i) for (i = 0x20; i <= 0x3F; ++i)
{ {
TranslationTables[TRANSLATION_Standard][0]->Remap[i] = i - 0x20; stdremaps[0].Remap[i] = i - 0x20;
TranslationTables[TRANSLATION_Standard][1]->Remap[i] = i - 0x20; stdremaps[1].Remap[i] = i - 0x20;
TranslationTables[TRANSLATION_Standard][2]->Remap[i] = 0xD0 + (i&0xf); stdremaps[2].Remap[i] = 0xD0 + (i&0xf);
TranslationTables[TRANSLATION_Standard][3]->Remap[i] = 0xD0 + (i&0xf); stdremaps[3].Remap[i] = 0xD0 + (i&0xf);
TranslationTables[TRANSLATION_Standard][4]->Remap[i] = i - 0x20; stdremaps[4].Remap[i] = i - 0x20;
TranslationTables[TRANSLATION_Standard][5]->Remap[i] = i - 0x20; stdremaps[5].Remap[i] = i - 0x20;
TranslationTables[TRANSLATION_Standard][6]->Remap[i] = i - 0x20; stdremaps[6].Remap[i] = i - 0x20;
} }
for (i = 0x50; i <= 0x5F; ++i) for (i = 0x50; i <= 0x5F; ++i)
{ {
// Merchant hair // Merchant hair
TranslationTables[TRANSLATION_Standard][4]->Remap[i] = 0x80 + (i&0xf); stdremaps[4].Remap[i] = 0x80 + (i&0xf);
TranslationTables[TRANSLATION_Standard][5]->Remap[i] = 0x10 + (i&0xf); stdremaps[5].Remap[i] = 0x10 + (i&0xf);
TranslationTables[TRANSLATION_Standard][6]->Remap[i] = 0x40 + (i&0xf); stdremaps[6].Remap[i] = 0x40 + (i&0xf);
} }
for (i = 0x80; i <= 0x8F; ++i) for (i = 0x80; i <= 0x8F; ++i)
{ {
TranslationTables[TRANSLATION_Standard][0]->Remap[i] = 0x40 + (i&0xf); // red stdremaps[0].Remap[i] = 0x40 + (i&0xf); // red
TranslationTables[TRANSLATION_Standard][1]->Remap[i] = 0xB0 + (i&0xf); // rust stdremaps[1].Remap[i] = 0xB0 + (i&0xf); // rust
TranslationTables[TRANSLATION_Standard][2]->Remap[i] = 0x10 + (i&0xf); // gray stdremaps[2].Remap[i] = 0x10 + (i&0xf); // gray
TranslationTables[TRANSLATION_Standard][3]->Remap[i] = 0x30 + (i&0xf); // dark green stdremaps[3].Remap[i] = 0x30 + (i&0xf); // dark green
TranslationTables[TRANSLATION_Standard][4]->Remap[i] = 0x50 + (i&0xf); // gold stdremaps[4].Remap[i] = 0x50 + (i&0xf); // gold
TranslationTables[TRANSLATION_Standard][5]->Remap[i] = 0x60 + (i&0xf); // bright green stdremaps[5].Remap[i] = 0x60 + (i&0xf); // bright green
TranslationTables[TRANSLATION_Standard][6]->Remap[i] = 0x90 + (i&0xf); // blue stdremaps[6].Remap[i] = 0x90 + (i&0xf); // blue
} }
for (i = 0xC0; i <= 0xCF; ++i) for (i = 0xC0; i <= 0xCF; ++i)
{ {
TranslationTables[TRANSLATION_Standard][4]->Remap[i] = 0xA0 + (i&0xf); stdremaps[4].Remap[i] = 0xA0 + (i&0xf);
TranslationTables[TRANSLATION_Standard][5]->Remap[i] = 0x20 + (i&0xf); stdremaps[5].Remap[i] = 0x20 + (i&0xf);
TranslationTables[TRANSLATION_Standard][6]->Remap[i] = (i&0xf); stdremaps[6].Remap[i] = (i&0xf);
} }
TranslationTables[TRANSLATION_Standard][6]->Remap[0xC0] = 1; stdremaps[6].Remap[0xC0] = 1;
for (i = 0xD0; i <= 0xDF; ++i) for (i = 0xD0; i <= 0xDF; ++i)
{ {
TranslationTables[TRANSLATION_Standard][4]->Remap[i] = 0xB0 + (i&0xf); stdremaps[4].Remap[i] = 0xB0 + (i&0xf);
TranslationTables[TRANSLATION_Standard][5]->Remap[i] = 0x30 + (i&0xf); stdremaps[5].Remap[i] = 0x30 + (i&0xf);
TranslationTables[TRANSLATION_Standard][6]->Remap[i] = 0x10 + (i&0xf); stdremaps[6].Remap[i] = 0x10 + (i&0xf);
} }
for (i = 0xF1; i <= 0xF6; ++i) for (i = 0xF1; i <= 0xF6; ++i)
{ {
TranslationTables[TRANSLATION_Standard][0]->Remap[i] = 0xDF + (i&0xf); stdremaps[0].Remap[i] = 0xDF + (i&0xf);
} }
for (i = 0xF7; i <= 0xFB; ++i) for (i = 0xF7; i <= 0xFB; ++i)
{ {
TranslationTables[TRANSLATION_Standard][0]->Remap[i] = i - 6; stdremaps[0].Remap[i] = i - 6;
} }
for (i = 0; i < 7; ++i) for (i = 0; i < 7; ++i)
{ {
for (int j = 0x20; j <= 0xFB; ++j) for (int j = 0x20; j <= 0xFB; ++j)
{ {
TranslationTables[TRANSLATION_Standard][i]->Palette[j] = stdremaps[i].Palette[j] =
GPalette.BaseColors[TranslationTables[TRANSLATION_Standard][i]->Remap[j]] | MAKEARGB(255,0,0,0); GPalette.BaseColors[stdremaps[i].Remap[j]] | MAKEARGB(255,0,0,0);
} }
} }
} }
@ -986,7 +986,7 @@ void R_InitTranslationTables ()
{ {
IcePaletteRemap[i] = ColorMatcher.Pick (IcePalette[i][0], IcePalette[i][1], IcePalette[i][2]); IcePaletteRemap[i] = ColorMatcher.Pick (IcePalette[i][0], IcePalette[i][1], IcePalette[i][2]);
} }
FRemapTable *remap = TranslationTables[TRANSLATION_Standard][STD_Ice]; FRemapTable *remap = &stdremaps[STD_Ice];
remap->Remap[0] = 0; remap->Remap[0] = 0;
remap->Palette[0] = 0; remap->Palette[0] = 0;
for (i = 1; i < 256; ++i) for (i = 1; i < 256; ++i)
@ -1000,8 +1000,7 @@ void R_InitTranslationTables ()
} }
// The alphatexture translation. This is just a standard index as gray mapping. // The alphatexture translation. This is just a standard index as gray mapping.
PushIdentityTable(TRANSLATION_Standard); remap = &stdremaps[STD_Gray];
remap = TranslationTables[TRANSLATION_Standard][STD_Gray];
remap->Remap[0] = 0; remap->Remap[0] = 0;
remap->Palette[0] = 0; remap->Palette[0] = 0;
for (i = 1; i < 256; i++) for (i = 1; i < 256; i++)
@ -1011,8 +1010,7 @@ void R_InitTranslationTables ()
} }
// Palette to grayscale ramp. For internal use only, because the remap does not map to the palette. // Palette to grayscale ramp. For internal use only, because the remap does not map to the palette.
PushIdentityTable(TRANSLATION_Standard); remap = &stdremaps[STD_Grayscale];
remap = TranslationTables[TRANSLATION_Standard][STD_Grayscale];
remap->Remap[0] = 0; remap->Remap[0] = 0;
remap->Palette[0] = 0; remap->Palette[0] = 0;
for (i = 1; i < 256; i++) for (i = 1; i < 256; i++)
@ -1025,6 +1023,7 @@ void R_InitTranslationTables ()
remap->Remap[i] = v; remap->Remap[i] = v;
remap->Palette[i] = PalEntry(255, v, v, v); remap->Palette[i] = PalEntry(255, v, v, v);
} }
AddTranslation(TRANSLATION_Standard, stdremaps, 10);
} }
@ -1038,17 +1037,10 @@ void R_DeinitTranslationTables()
{ {
for (int i = 0; i < NUM_TRANSLATION_TABLES; ++i) for (int i = 0; i < NUM_TRANSLATION_TABLES; ++i)
{ {
for (unsigned int j = 0; j < TranslationTables[i].Size(); ++j) ClearTranslationSlot(i);
{
if (TranslationTables[i][j] != NULL)
{
delete TranslationTables[i][j];
TranslationTables[i][j] = NULL;
}
}
TranslationTables[i].Clear();
} }
BloodTranslationColors.Clear(); BloodTranslationColors.Clear();
remapArena.FreeAllBlocks();
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -1326,12 +1318,12 @@ void R_BuildPlayerTranslation (int player)
D_GetPlayerColor (player, &h, &s, &v, &colorset); D_GetPlayerColor (player, &h, &s, &v, &colorset);
R_CreatePlayerTranslation (h, s, v, colorset, FRemapTable remaps[3];
&Skins[players[player].userinfo.GetSkin()], R_CreatePlayerTranslation (h, s, v, colorset, &Skins[players[player].userinfo.GetSkin()], &remaps[0], &remaps[1], &remaps[2]);
TranslationTables[TRANSLATION_Players][player],
TranslationTables[TRANSLATION_PlayersExtra][player], UpdateTranslation(TRANSLATION(TRANSLATION_Players, player), &remaps[0]);
TranslationTables[TRANSLATION_RainPillar][player] UpdateTranslation(TRANSLATION(TRANSLATION_PlayersExtra, player), &remaps[1]);
); UpdateTranslation(TRANSLATION(TRANSLATION_RainPillar, player), &remaps[2]);
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -1363,7 +1355,7 @@ DEFINE_ACTION_FUNCTION(_Translation, SetPlayerTranslation)
PARAM_UINT(pnum); PARAM_UINT(pnum);
PARAM_POINTER(cls, FPlayerClass); PARAM_POINTER(cls, FPlayerClass);
if (pnum >= MAXPLAYERS || tgroup >= NUM_TRANSLATION_TABLES || tnum >= TranslationTables[tgroup].Size()) if (pnum >= MAXPLAYERS || tgroup >= NUM_TRANSLATION_TABLES)
{ {
ACTION_RETURN_BOOL(false); ACTION_RETURN_BOOL(false);
} }
@ -1375,8 +1367,10 @@ DEFINE_ACTION_FUNCTION(_Translation, SetPlayerTranslation)
if (cls != nullptr) if (cls != nullptr)
{ {
PlayerSkin = R_FindSkin(Skins[PlayerSkin].Name, int(cls - &PlayerClasses[0])); PlayerSkin = R_FindSkin(Skins[PlayerSkin].Name, int(cls - &PlayerClasses[0]));
FRemapTable remap;
R_GetPlayerTranslation(PlayerColor, GetColorSet(cls->Type, PlayerColorset), R_GetPlayerTranslation(PlayerColor, GetColorSet(cls->Type, PlayerColorset),
&Skins[PlayerSkin], TranslationTables[tgroup][tnum]); &Skins[PlayerSkin], &remap);
UpdateTranslation(TRANSLATION(tgroup, tnum), &remap);
} }
ACTION_RETURN_BOOL(true); ACTION_RETURN_BOOL(true);
} }
@ -1440,7 +1434,7 @@ DEFINE_ACTION_FUNCTION(_Translation, GetID)
void R_ParseTrnslate() void R_ParseTrnslate()
{ {
customTranslationMap.Clear(); customTranslationMap.Clear();
TranslationTables[TRANSLATION_Custom].Clear(); ClearTranslationSlot(TRANSLATION_Custom);
int lump; int lump;
int lastlump = 0; int lastlump = 0;
@ -1452,7 +1446,7 @@ void R_ParseTrnslate()
sc.TokenMustBe(TK_Identifier); sc.TokenMustBe(TK_Identifier);
FName newtrans = sc.String; FName newtrans = sc.String;
FRemapTable *base = nullptr; FRemapTable NewTranslation;
if (sc.CheckToken(':')) if (sc.CheckToken(':'))
{ {
sc.MustGetAnyToken(); sc.MustGetAnyToken();
@ -1463,7 +1457,7 @@ void R_ParseTrnslate()
{ {
sc.ScriptError("Translation must be in the range [0,%d]", max); sc.ScriptError("Translation must be in the range [0,%d]", max);
} }
base = TranslationTables[TRANSLATION_Standard][sc.Number]; NewTranslation = *TranslationToTable(TRANSLATION(TRANSLATION_Standard, sc.Number));
} }
else if (sc.TokenType == TK_Identifier) else if (sc.TokenType == TK_Identifier)
{ {
@ -1472,7 +1466,7 @@ void R_ParseTrnslate()
{ {
sc.ScriptError("Base translation '%s' not found in '%s'", sc.String, newtrans.GetChars()); sc.ScriptError("Base translation '%s' not found in '%s'", sc.String, newtrans.GetChars());
} }
base = TranslationTables[GetTranslationType(tnum)][GetTranslationIndex(tnum)]; NewTranslation = *TranslationToTable(tnum);
} }
else else
{ {
@ -1480,10 +1474,8 @@ void R_ParseTrnslate()
sc.TokenMustBe(TK_Identifier); sc.TokenMustBe(TK_Identifier);
} }
} }
sc.MustGetToken('=');
FRemapTable NewTranslation;
if (base != nullptr) NewTranslation = *base;
else NewTranslation.MakeIdentity(); else NewTranslation.MakeIdentity();
sc.MustGetToken('=');
do do
{ {
sc.MustGetToken(TK_StringConst); sc.MustGetToken(TK_StringConst);

4
src/r_data/r_translate.h
View file

@ -128,10 +128,10 @@ inline int GetTranslationIndex(uint32_t trans)
// Retrieve the FRemapTable that an actor's translation value maps to. // Retrieve the FRemapTable that an actor's translation value maps to.
FRemapTable *TranslationToTable(int translation); FRemapTable *TranslationToTable(int translation);
void UpdateTranslation(int trans, FRemapTable* remap); void UpdateTranslation(int trans, FRemapTable* remap);
int AddTranslation(int slot, FRemapTable* remap); int AddTranslation(int slot, FRemapTable* remap, int count = 1);
FRemapTable* GetTranslation(int slot, int index); FRemapTable* GetTranslation(int slot, int index);
void CopyTranslation(int dest, int src); void CopyTranslation(int dest, int src);
void ClearScriptedTranslations(); void ClearTranslationSlot(int slot);
#define MAX_ACS_TRANSLATIONS 65535 #define MAX_ACS_TRANSLATIONS 65535