mirror of
https://github.com/ZDoom/Raze.git
synced 2024-12-11 13:21:49 +00:00
457 lines
14 KiB
C++
457 lines
14 KiB
C++
/*
|
|
** hightile.cpp
|
|
** Handling hires replacement definitions
|
|
**
|
|
**---------------------------------------------------------------------------
|
|
** Copyright 2020 Christoph Oelckers
|
|
** All rights reserved.
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
**
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in the
|
|
** documentation and/or other materials provided with the distribution.
|
|
** 3. The name of the author may not be used to endorse or promote products
|
|
** derived from this software without specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
**---------------------------------------------------------------------------
|
|
**
|
|
**
|
|
*/
|
|
|
|
#include "files.h"
|
|
#include "zstring.h"
|
|
#include "buildtiles.h"
|
|
#include "image.h"
|
|
|
|
#include "palette.h"
|
|
#include "m_crc32.h"
|
|
#include "build.h"
|
|
#include "gamecontrol.h"
|
|
#include "palettecontainer.h"
|
|
#include "texturemanager.h"
|
|
#include "c_dispatch.h"
|
|
#include "sc_man.h"
|
|
#include "gamestruct.h"
|
|
#include "hw_renderstate.h"
|
|
#include "skyboxtexture.h"
|
|
|
|
CVARD(Bool, hw_shadeinterpolate, true, CVAR_ARCHIVE | CVAR_GLOBALCONFIG, "enable/disable shade interpolation")
|
|
|
|
struct HightileReplacement
|
|
{
|
|
FGameTexture* image;
|
|
FVector2 scale;
|
|
float alphacut, specpower, specfactor;
|
|
uint16_t palnum;
|
|
bool issky;
|
|
bool indexed;
|
|
};
|
|
|
|
static TMap<int, TArray<HightileReplacement>> tileReplacements;
|
|
static TMap<int, TArray<HightileReplacement>> textureReplacements;
|
|
|
|
static TMap<FGameTexture*, FGameTexture*> deferredChars;
|
|
|
|
FGameTexture* GetBaseForChar(FGameTexture* t)
|
|
{
|
|
auto c = deferredChars.CheckKey(t);
|
|
if (c) return *c;
|
|
return t;
|
|
}
|
|
|
|
void FontCharCreated(FGameTexture* base, FGameTexture* glyph)
|
|
{
|
|
if (base->GetName().IsNotEmpty())
|
|
deferredChars.Insert(glyph, base);
|
|
}
|
|
|
|
|
|
//===========================================================================
|
|
//
|
|
// Replacement textures
|
|
//
|
|
//===========================================================================
|
|
|
|
static void AddReplacement(int picnum, const HightileReplacement& replace)
|
|
{
|
|
auto& Hightiles = tileReplacements[picnum];
|
|
for (auto& ht : Hightiles)
|
|
{
|
|
if (replace.palnum == ht.palnum && replace.issky == ht.issky)
|
|
{
|
|
ht = replace;
|
|
return;
|
|
}
|
|
}
|
|
Hightiles.Push(replace);
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Remove a replacement
|
|
//
|
|
//==========================================================================
|
|
|
|
void tileRemoveReplacement(int picnum)
|
|
{
|
|
tileReplacements.Remove(picnum);
|
|
}
|
|
|
|
//===========================================================================
|
|
//
|
|
//
|
|
//
|
|
//===========================================================================
|
|
|
|
static HightileReplacement* FindReplacement(FTextureID picnum, int palnum, bool skybox)
|
|
{
|
|
auto Hightiles = textureReplacements.CheckKey(picnum.GetIndex());
|
|
if (!Hightiles) return nullptr;
|
|
for (;;)
|
|
{
|
|
for (auto& rep : *Hightiles)
|
|
{
|
|
if (rep.palnum == palnum && rep.issky == skybox) return &rep;
|
|
}
|
|
if (!palnum || palnum >= MAXPALOOKUPS - RESERVEDPALS) break;
|
|
palnum = 0;
|
|
}
|
|
return nullptr; // no replacement found
|
|
}
|
|
|
|
int checkTranslucentReplacement(FTextureID picnum, int pal)
|
|
{
|
|
FGameTexture* tex = nullptr;
|
|
auto si = FindReplacement(picnum, pal, 0);
|
|
if (si && hw_hightile) tex = si->image;
|
|
if (!tex || tex->GetTexelWidth() == 0 || tex->GetTexelHeight() == 0) return false;
|
|
return tex && tex->GetTranslucency();
|
|
}
|
|
|
|
FGameTexture* SkyboxReplacement(FTextureID picnum, int palnum)
|
|
{
|
|
auto hr = FindReplacement(picnum, palnum, true);
|
|
if (!hr) return nullptr;
|
|
return hr->image;
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
// Processes data from .def files into the textures
|
|
//
|
|
//==========================================================================
|
|
|
|
void highTileSetup()
|
|
{
|
|
for(int i=0;i<MAXTILES;i++)
|
|
{
|
|
auto tex = tileGetTexture(i);
|
|
if (!tex->isValid()) continue;
|
|
auto Hightile = tileReplacements.CheckKey(i);
|
|
if (!Hightile) continue;
|
|
textureReplacements.Insert(tex->GetID().GetIndex(), std::move(*Hightile));
|
|
}
|
|
tileReplacements.Clear();
|
|
|
|
decltype(deferredChars)::Iterator it(deferredChars);
|
|
decltype(deferredChars)::Pair* pair;
|
|
while (it.NextPair(pair))
|
|
{
|
|
auto rep = textureReplacements.CheckKey(pair->Value->GetID().GetIndex());
|
|
if (rep)
|
|
{
|
|
auto myrep = *rep; // don't create copies directly from the map we're inserting in!
|
|
auto chk = textureReplacements.CheckKey(pair->Key->GetID().GetIndex());
|
|
if (!chk) textureReplacements.Insert(pair->Key->GetID().GetIndex(), std::move(myrep));
|
|
}
|
|
}
|
|
deferredChars.Clear();
|
|
decltype(textureReplacements)::Iterator it2(textureReplacements);
|
|
decltype(textureReplacements)::Pair* pair2;
|
|
while (it2.NextPair(pair2))
|
|
{
|
|
auto tex = TexMan.GameByIndex(pair2->Key);
|
|
if (!tex->isValid()) continue;
|
|
auto Hightile = &pair2->Value;
|
|
if (!Hightile) continue;
|
|
|
|
FGameTexture* detailTex = nullptr, * glowTex = nullptr, * normalTex = nullptr, * specTex = nullptr;
|
|
float scalex = 1.f, scaley = 1.f;
|
|
for (auto& rep : *Hightile)
|
|
{
|
|
if (rep.palnum == GLOWPAL)
|
|
{
|
|
glowTex = rep.image;
|
|
}
|
|
if (rep.palnum == NORMALPAL)
|
|
{
|
|
normalTex = rep.image;
|
|
}
|
|
if (rep.palnum == SPECULARPAL)
|
|
{
|
|
specTex = rep.image;
|
|
}
|
|
if (rep.palnum == DETAILPAL)
|
|
{
|
|
detailTex = rep.image;
|
|
scalex = rep.scale.X;
|
|
scaley = rep.scale.Y;
|
|
}
|
|
}
|
|
|
|
if (detailTex || glowTex || normalTex || specTex)
|
|
{
|
|
for (auto& rep : *Hightile)
|
|
{
|
|
if (rep.issky) continue; // do not muck around with skyboxes (yet)
|
|
if (rep.palnum < NORMALPAL)
|
|
{
|
|
auto imgtex = rep.image;
|
|
// Make a copy so that multiple appearances of the same texture with different layers can be handled. They will all refer to the same internal texture anyway.
|
|
imgtex = MakeGameTexture(imgtex->GetTexture(), "", ETextureType::Any);
|
|
if (glowTex) imgtex->SetGlowmap(glowTex->GetTexture());
|
|
if (detailTex) imgtex->SetDetailmap(detailTex->GetTexture());
|
|
if (normalTex) imgtex->SetNormalmap(normalTex->GetTexture());
|
|
if (specTex) imgtex->SetSpecularmap(specTex->GetTexture());
|
|
imgtex->SetDetailScale(scalex, scaley);
|
|
rep.image = imgtex;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// Specifies a replacement texture for an ART tile.
|
|
//
|
|
//==========================================================================
|
|
|
|
int tileSetHightileReplacement(int picnum, int palnum, const char* filename, float alphacut, float xscale, float yscale, float specpower, float specfactor, bool indexed)
|
|
{
|
|
if ((uint32_t)picnum >= (uint32_t)MAXTILES) return -1;
|
|
if ((uint32_t)palnum >= (uint32_t)MAXPALOOKUPS) return -1;
|
|
|
|
auto tex = tileGetTexture(picnum);
|
|
if (tex->GetTexelWidth() <= 0 || tex->GetTexelHeight() <= 0)
|
|
{
|
|
Printf("Warning: defined hightile replacement for empty tile %d.", picnum);
|
|
return -1; // cannot add replacements to empty tiles, must create one beforehand
|
|
}
|
|
HightileReplacement replace = {};
|
|
|
|
FTextureID texid = TexMan.CheckForTexture(filename, ETextureType::Any, FTextureManager::TEXMAN_ForceLookup);
|
|
if (!texid.isValid())
|
|
{
|
|
Printf("%s: Replacement for tile %d does not exist or is invalid\n", filename, picnum);
|
|
return -1;
|
|
}
|
|
|
|
replace.image = TexMan.GetGameTexture(texid);
|
|
replace.alphacut = min(alphacut,1.f);
|
|
replace.scale = { xscale, yscale };
|
|
replace.specpower = specpower; // currently unused
|
|
replace.specfactor = specfactor; // currently unused
|
|
replace.issky = 0;
|
|
replace.indexed = indexed;
|
|
replace.palnum = (uint16_t)palnum;
|
|
AddReplacement(picnum, replace);
|
|
return 0;
|
|
}
|
|
|
|
|
|
//==========================================================================
|
|
//
|
|
// Define the faces of a skybox
|
|
//
|
|
//==========================================================================
|
|
|
|
int tileSetSkybox(int picnum, int palnum, FString* facenames, bool indexed)
|
|
{
|
|
if ((uint32_t)picnum >= (uint32_t)MAXTILES) return -1;
|
|
if ((uint32_t)palnum >= (uint32_t)MAXPALOOKUPS) return -1;
|
|
|
|
auto tex = tileGetTexture(picnum);
|
|
if (tex->GetTexelWidth() <= 0 || tex->GetTexelHeight() <= 0)
|
|
{
|
|
Printf("Warning: defined skybox replacement for empty tile %d.", picnum);
|
|
return -1; // cannot add replacements to empty tiles, must create one beforehand
|
|
}
|
|
HightileReplacement replace = {};
|
|
|
|
FGameTexture *faces[6];
|
|
for (int i = 0; i < 6; i++)
|
|
{
|
|
FTextureID texid = TexMan.CheckForTexture(facenames[i], ETextureType::Any, FTextureManager::TEXMAN_ForceLookup);
|
|
if (!texid.isValid())
|
|
{
|
|
Printf("%s: Skybox image for tile %d does not exist or is invalid\n", facenames[i].GetChars(), picnum);
|
|
return -1;
|
|
}
|
|
faces[i] = TexMan.GetGameTexture(texid);
|
|
}
|
|
FSkyBox* sbtex = new FSkyBox("");
|
|
memcpy(sbtex->faces, faces, sizeof(faces));
|
|
sbtex->previous = faces[0]; // won't ever be used, just to be safe.
|
|
sbtex->fliptop = true;
|
|
replace.image = MakeGameTexture(sbtex, "", ETextureType::Override);
|
|
TexMan.AddGameTexture(replace.image, false);
|
|
replace.issky = 1;
|
|
replace.indexed = indexed;
|
|
replace.palnum = (uint16_t)palnum;
|
|
AddReplacement(picnum, replace);
|
|
return 0;
|
|
}
|
|
|
|
//===========================================================================
|
|
//
|
|
// Picks a texture for rendering for a given tilenum/palette combination
|
|
//
|
|
//===========================================================================
|
|
|
|
bool PickTexture(FGameTexture* tex, int paletteid, TexturePick& pick, bool wantindexed)
|
|
{
|
|
if (!tex->isValid() || tex->GetTexelWidth() <= 0 || tex->GetTexelHeight() <= 0) return false;
|
|
|
|
int usepalette = 0, useremap = 0;
|
|
if (!IsLuminosityTranslation(paletteid))
|
|
{
|
|
usepalette = paletteid == 0 ? 0 : GetTranslationType(paletteid) - Translation_Remap;
|
|
useremap = GetTranslationIndex(paletteid);
|
|
}
|
|
int TextureType = wantindexed? TT_INDEXED : TT_TRUECOLOR;
|
|
|
|
pick.translation = paletteid;
|
|
pick.basepalTint = 0xffffff;
|
|
|
|
auto& h = lookups.tables[useremap];
|
|
bool applytint = false;
|
|
// Canvas textures must be treated like hightile replacements in the following code.
|
|
|
|
int hipalswap = usepalette >= 0 ? useremap : 0;
|
|
auto rep = (hw_hightile && !(h.tintFlags & TINTF_ALWAYSUSEART)) ? FindReplacement(tex->GetID(), hipalswap, false) : nullptr;
|
|
if (rep || tex->GetTexture()->isHardwareCanvas())
|
|
{
|
|
if (rep)
|
|
{
|
|
tex = rep->image;
|
|
}
|
|
if (rep && rep->indexed && TextureType == TT_INDEXED)
|
|
{
|
|
pick.translation |= 0x80000000;
|
|
}
|
|
else if (!rep || !rep->indexed)
|
|
{
|
|
if (usepalette > 0)
|
|
{
|
|
// This is a global setting for the entire scene, so let's do it here, right at the start. (Fixme: Store this in a static table instead of reusing the same entry for all palettes.)
|
|
auto& hh = lookups.tables[MAXPALOOKUPS - 1];
|
|
// This sets a tinting color for global palettes, e.g. water or slime - only used for hires replacements (also an option for low-resource hardware where duplicating the textures may be problematic.)
|
|
pick.basepalTint = hh.tintColor;
|
|
}
|
|
|
|
if (!rep || rep->palnum != hipalswap || (h.tintFlags & TINTF_APPLYOVERALTPAL))
|
|
applytint = true;
|
|
if (!IsLuminosityTranslation(paletteid)) pick.translation = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Only look up the palette if we really want to use it (i.e. when creating a true color texture of an ART tile.)
|
|
if (TextureType == TT_TRUECOLOR)
|
|
{
|
|
if (h.tintFlags & (TINTF_ALWAYSUSEART | TINTF_USEONART))
|
|
{
|
|
applytint = true;
|
|
if (!(h.tintFlags & TINTF_APPLYOVERPALSWAP)) useremap = 0;
|
|
}
|
|
pick.translation = IsLuminosityTranslation(paletteid)? paletteid : paletteid == 0? 0 : TRANSLATION(usepalette + Translation_Remap, useremap);
|
|
}
|
|
else pick.translation |= 0x80000000;
|
|
}
|
|
|
|
if (applytint && h.tintFlags)
|
|
{
|
|
pick.tintFlags = h.tintFlags;
|
|
pick.tintColor = h.tintColor;
|
|
}
|
|
else
|
|
{
|
|
pick.tintFlags = -1;
|
|
pick.tintColor = 0xffffff;
|
|
}
|
|
pick.texture = tex;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool PreBindTexture(FRenderState* state, FGameTexture*& tex, EUpscaleFlags& flags, int& scaleflags, int& clampmode, int& translation, int& overrideshader)
|
|
{
|
|
TexturePick pick;
|
|
auto t = tex;
|
|
|
|
if (tex->GetUseType() == ETextureType::Special) return true;
|
|
|
|
bool foggy = state && (state->GetFogColor() & 0xffffff);
|
|
if (PickTexture(tex, translation, pick, hw_int_useindexedcolortextures && !foggy))
|
|
{
|
|
int lookuppal = pick.translation & 0x7fffffff;
|
|
|
|
if (pick.translation & 0x80000000)
|
|
{
|
|
scaleflags |= CTF_Indexed;
|
|
if (state) state->EnableFog(0);
|
|
}
|
|
tex = pick.texture;
|
|
translation = lookuppal;
|
|
|
|
FVector4 addcol(0, 0, 0, 0);
|
|
FVector4 modcol(pick.basepalTint.r * (1.f / 255.f), pick.basepalTint.g * (1.f / 255.f), pick.basepalTint.b * (1.f / 255.f), 0);
|
|
FVector4 blendcol(0, 0, 0, 0);
|
|
int tmflags = 0;
|
|
|
|
if (pick.basepalTint != 0xffffff) tmflags |= TextureManipulation::ActiveBit;
|
|
if (pick.tintFlags != -1)
|
|
{
|
|
tmflags |= TextureManipulation::ActiveBit;
|
|
if (pick.tintFlags & TINTF_COLORIZE)
|
|
{
|
|
modcol.X *= pick.tintColor.r * (1.f / 64.f);
|
|
modcol.Y *= pick.tintColor.g * (1.f / 64.f);
|
|
modcol.Z *= pick.tintColor.b * (1.f / 64.f);
|
|
}
|
|
if (pick.tintFlags & TINTF_GRAYSCALE)
|
|
modcol.W = 1.f;
|
|
|
|
if (pick.tintFlags & TINTF_INVERT)
|
|
tmflags |= TextureManipulation::InvertBit;
|
|
|
|
if (pick.tintFlags & TINTF_BLENDMASK)
|
|
{
|
|
blendcol = modcol; // WTF???, but the tinting code really uses the same color for both!
|
|
tmflags |= (((pick.tintFlags & TINTF_BLENDMASK) >> 6) + 1) & TextureManipulation::BlendMask;
|
|
}
|
|
}
|
|
addcol.W = (float)tmflags;
|
|
if ((pick.translation & 0x80000000) && hw_shadeinterpolate) addcol.W += 16384; // hijack a free bit in here.
|
|
state->SetTextureColors(&modcol.X, &addcol.X, &blendcol.X);
|
|
}
|
|
return tex->GetTexelWidth() > t->GetTexelWidth() && tex->GetTexelHeight() > t->GetTexelHeight(); // returning 'true' means to disable programmatic upscaling.
|
|
}
|
|
|