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

- store the material layers in reference counted pointers in the FGameTexture object.

Browse source 
Reference counting is used because a texture image may be shared by more than one game texture.
This commit is contained in:
Christoph Oelckers 2020-04-17 01:03:21 +02:00
parent 70ec20c137
commit 42304d9680
5 changed files with 244 additions and 139 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
src/common/textures/hw_material.cpp
View file

@ -60,17 +60,18 @@ FMaterial::FMaterial(FGameTexture * tx, int scaleflags)
{
mShaderIndex = tx->isWarped(); // This picks SHADER_Warp1 or SHADER_Warp2
}
else if (imgtex->Normal && imgtex->Specular)
// Note that the material takes no ownership of the texture!
else if (tx->Normal.get() && tx->Specular.get())
{
for (auto &texture : { imgtex->Normal, imgtex->Specular })
for (auto &texture : { tx->Normal.get(), tx->Specular.get() })
{
mTextureLayers.Push(texture);
}
mShaderIndex = SHADER_Specular;
}
else if (imgtex->Normal && imgtex->Metallic && imgtex->Roughness && imgtex->AmbientOcclusion)
else if (tx->Normal.get() && tx->Metallic.get() && tx->Roughness.get() && tx->AmbientOcclusion.get())
{
for (auto &texture : { imgtex->Normal, imgtex->Metallic, imgtex->Roughness, imgtex->AmbientOcclusion })
for (auto &texture : { tx->Normal.get(), tx->Metallic.get(), tx->Roughness.get(), tx->AmbientOcclusion.get() })
{
mTextureLayers.Push(texture);
}
@ -80,27 +81,27 @@ FMaterial::FMaterial(FGameTexture * tx, int scaleflags)
// Note that these layers must present a valid texture even if not used, because empty TMUs in the shader are an undefined condition.
tx->CreateDefaultBrightmap();
auto placeholder = TexMan.GameByIndex(1);
if (imgtex->Brightmap)
if (tx->Brightmap.get())
{
mTextureLayers.Push(imgtex->Brightmap);
mTextureLayers.Push(tx->Brightmap.get());
mLayerFlags |= TEXF_Brightmap;
}
else
{
mTextureLayers.Push(placeholder->GetTexture());
}
if (imgtex->Detailmap)
if (tx->Detailmap.get())
{
mTextureLayers.Push(imgtex->Detailmap);
mTextureLayers.Push(tx->Detailmap.get());
mLayerFlags |= TEXF_Detailmap;
}
else
{
mTextureLayers.Push(placeholder->GetTexture());
}
if (imgtex->Glowmap)
if (tx->Glowmap.get())
{
mTextureLayers.Push(imgtex->Glowmap);
mTextureLayers.Push(tx->Glowmap.get());
mLayerFlags |= TEXF_Glowmap;
}
else
@ -113,10 +114,10 @@ FMaterial::FMaterial(FGameTexture * tx, int scaleflags)
const UserShaderDesc &usershader = usershaders[imgtex->shaderindex - FIRST_USER_SHADER];
if (usershader.shaderType == mShaderIndex) // Only apply user shader if it matches the expected material
{
for (auto &texture : imgtex->CustomShaderTextures)
for (auto &texture : tx->CustomShaderTextures)
{
if (texture == nullptr) continue;
mTextureLayers.Push(texture);
mTextureLayers.Push(texture.get());
}
mShaderIndex = tx->GetShaderIndex();
}
@ -167,7 +168,7 @@ FMaterial * FMaterial::ValidateTexture(FGameTexture * gtex, int scaleflags, bool
if (gtex && gtex->isValid())
{
auto tex = gtex->GetTexture();
if (!tex->ShouldExpandSprite()) scaleflags &= ~CTF_Expand;
if (!gtex->ShouldExpandSprite()) scaleflags &= ~CTF_Expand;
FMaterial *hwtex = tex->Material[scaleflags];
if (hwtex == NULL && create)

65
src/common/textures/texture.cpp
View file

@ -288,30 +288,30 @@ int FTexture::CheckRealHeight()
//
//==========================================================================
void FTexture::AddAutoMaterials()
void FGameTexture::AddAutoMaterials()
{
struct AutoTextureSearchPath
{
const char *path;
FTexture *FTexture::*pointer;
RefCountedPtr<FTexture> FGameTexture::*pointer;
};
static AutoTextureSearchPath autosearchpaths[] =
{
{ "brightmaps/", &FTexture::Brightmap }, // For backwards compatibility, only for short names
{ "materials/brightmaps/", &FTexture::Brightmap },
{ "materials/normalmaps/", &FTexture::Normal },
{ "materials/specular/", &FTexture::Specular },
{ "materials/metallic/", &FTexture::Metallic },
{ "materials/roughness/", &FTexture::Roughness },
{ "materials/ao/", &FTexture::AmbientOcclusion }
{ "brightmaps/", &FGameTexture::Brightmap }, // For backwards compatibility, only for short names
{ "materials/brightmaps/", &FGameTexture::Brightmap },
{ "materials/normalmaps/", &FGameTexture::Normal },
{ "materials/specular/", &FGameTexture::Specular },
{ "materials/metallic/", &FGameTexture::Metallic },
{ "materials/roughness/", &FGameTexture::Roughness },
{ "materials/ao/", &FGameTexture::AmbientOcclusion }
};
int startindex = bFullNameTexture ? 1 : 0;
FString searchname = Name;
int startindex = Base->bFullNameTexture ? 1 : 0;
FString searchname = GetName();
if (bFullNameTexture)
if (Base->bFullNameTexture)
{
auto dot = searchname.LastIndexOf('.');
auto slash = searchname.LastIndexOf('/');
@ -323,7 +323,7 @@ void FTexture::AddAutoMaterials()
auto &layer = autosearchpaths[i];
if (this->*(layer.pointer) == nullptr) // only if no explicit assignment had been done.
{
FStringf lookup("%s%s%s", layer.path, bFullNameTexture ? "" : "auto/", searchname.GetChars());
FStringf lookup("%s%s%s", layer.path, Base->bFullNameTexture ? "" : "auto/", searchname.GetChars());
auto lump = fileSystem.CheckNumForFullName(lookup, false, ns_global, true);
if (lump != -1)
{
@ -351,7 +351,7 @@ void FGameTexture::CreateDefaultBrightmap()
// Check for brightmaps
if (tex->GetImage() && tex->GetImage()->UseGamePalette() && GPalette.HasGlobalBrightmap &&
GetUseType() != ETextureType::Decal && GetUseType() != ETextureType::MiscPatch && GetUseType() != ETextureType::FontChar &&
tex->Brightmap == NULL)
Brightmap == nullptr)
{
// May have one - let's check when we use this texture
auto texbuf = tex->Get8BitPixels(false);
@ -364,7 +364,7 @@ void FGameTexture::CreateDefaultBrightmap()
{
// Create a brightmap
DPrintf(DMSG_NOTIFY, "brightmap created for texture '%s'\n", GetName().GetChars());
tex->Brightmap = CreateBrightmapTexture(static_cast<FImageTexture*>(tex)->GetImage());
Brightmap = CreateBrightmapTexture(tex->GetImage());
tex->bBrightmapChecked = true;
//TexMan.AddGameTexture(MakeGameTexture(tex->Brightmap));
return;
@ -743,21 +743,21 @@ TArray<uint8_t> FTexture::Get8BitPixels(bool alphatex)
//
//===========================================================================
bool FTexture::ShouldExpandSprite()
bool FGameTexture::ShouldExpandSprite()
{
if (bExpandSprite != -1) return bExpandSprite;
if (isWarped() || isHardwareCanvas() || shaderindex != SHADER_Default)
if (Base->bExpandSprite != -1) return Base->bExpandSprite;
if (isWarped() || isHardwareCanvas() || GetShaderIndex() != SHADER_Default)
{
bExpandSprite = false;
Base->bExpandSprite = false;
return false;
}
if (Brightmap != NULL && (GetTexelWidth() != Brightmap->GetTexelWidth() || GetTexelHeight() != Brightmap->GetTexelHeight()))
{
// do not expand if the brightmap's size differs.
bExpandSprite = false;
Base->bExpandSprite = false;
return false;
}
bExpandSprite = true;
Base->bExpandSprite = true;
return true;
}
@ -857,14 +857,14 @@ outl:
//
//===========================================================================
void FTexture::SetupSpriteData()
void FGameTexture::SetupSpriteData()
{
// Since this is only needed for real sprites it gets allocated on demand.
// It also allocates from the image memory arena because it has the same lifetime and to reduce maintenance.
if (spi == nullptr) spi = (SpritePositioningInfo*)ImageArena.Alloc(2 * sizeof(SpritePositioningInfo));
if (Base->spi == nullptr) Base->spi = (SpritePositioningInfo*)ImageArena.Alloc(2 * sizeof(SpritePositioningInfo));
for (int i = 0; i < 2; i++)
{
auto& spi = this->spi[i];
auto& spi = Base->spi[i];
spi.mSpriteU[0] = spi.mSpriteV[0] = 0.f;
spi.mSpriteU[1] = spi.mSpriteV[1] = 1.f;
spi.spriteWidth = GetTexelWidth();
@ -872,7 +872,7 @@ void FTexture::SetupSpriteData()
if (i == 1 && ShouldExpandSprite())
{
spi.mTrimResult = TrimBorders(spi.trim); // get the trim size before adding the empty frame
spi.mTrimResult = Base->TrimBorders(spi.trim); // get the trim size before adding the empty frame
spi.spriteWidth += 2;
spi.spriteHeight += 2;
}
@ -886,19 +886,19 @@ void FTexture::SetupSpriteData()
//
//===========================================================================
void FTexture::SetSpriteRect()
void FGameTexture::SetSpriteRect()
{
if (!spi) return;
if (!Base->spi) return;
auto leftOffset = GetLeftOffsetHW();
auto topOffset = GetTopOffsetHW();
float fxScale = (float)Scale.X;
float fyScale = (float)Scale.Y;
float fxScale = (float)Base->Scale.X;
float fyScale = (float)Base->Scale.Y;
for (int i = 0; i < 2; i++)
{
auto& spi = this->spi[i];
auto& spi = Base->spi[i];
// mSpriteRect is for positioning the sprite in the scene.
spi.mSpriteRect.left = -leftOffset / fxScale;
@ -1087,12 +1087,13 @@ FGameTexture::~FGameTexture()
{
FGameTexture* link = fileSystem.GetLinkedTexture(GetSourceLump());
if (link == this) fileSystem.SetLinkedTexture(GetSourceLump(), nullptr);
delete wrapped;
auto str = GetName();
Printf("Deleting texture %s\n", str.GetChars());
}
bool FGameTexture::isUserContent() const
{
int filenum = fileSystem.GetFileContainer(wrapped->GetSourceLump());
int filenum = fileSystem.GetFileContainer(Base->GetSourceLump());
return (filenum > fileSystem.GetMaxIwadNum());
}

3
src/common/textures/texturemanager.cpp
View file

@ -1093,9 +1093,6 @@ void FTextureManager::Init(void (*progressFunc_)(), void (*checkForHacks)(BuildI
DeleteAll();
//if (BuildTileFiles.Size() == 0) CountBuildTiles ();
// Texture 0 is a dummy texture used to indicate "no texture"
auto nulltex = MakeGameTexture(new FImageTexture(nullptr, ""), ETextureType::Null);
AddGameTexture (nulltex);
// This is for binding to unused texture units, because accessing an unbound texture unit is undefined. It's a one pixel empty texture.
auto emptytex = MakeGameTexture(new FImageTexture(CreateEmptyTexture(), ""), ETextureType::Override);
emptytex->SetSize(1, 1);

185
src/common/textures/textures.h
View file

@ -42,6 +42,7 @@
#include "textureid.h"
#include <vector>
#include "hw_texcontainer.h"
#include "refcounted.h"
// 15 because 0th texture is our texture
#define MAX_CUSTOM_HW_SHADER_TEXTURES 15
@ -235,7 +236,7 @@ struct SpritePositioningInfo
};
// Base texture class
class FTexture
class FTexture : public RefCountedBase
{
friend class FGameTexture; // only for the porting work
friend class FTexture;
@ -253,9 +254,9 @@ public:
static FTexture *CreateTexture(const char *name, int lumpnum, ETextureType UseType);
virtual ~FTexture ();
virtual FImageSource *GetImage() const { return nullptr; }
void AddAutoMaterials();
void CreateUpsampledTextureBuffer(FTextureBuffer &texbuffer, bool hasAlpha, bool checkonly);
void CleanHardwareTextures(bool reallyclean);
void SetSpriteRect();
// These are mainly meant for 2D code which only needs logical information about the texture to position it properly.
int GetDisplayWidth() { int foo = int((Width * 2) / Scale.X); return (foo >> 1) + (foo & 1); }
@ -325,9 +326,6 @@ public:
}
bool TrimBorders(uint16_t* rect);
void SetSpriteRect();
bool ShouldExpandSprite();
void SetupSpriteData();
int GetAreas(FloatRect** pAreas) const;
// Returns the whole texture, stored in column-major order
@ -360,19 +358,6 @@ public:
protected:
ISoftwareTexture *SoftwareTexture = nullptr;
public:
// Material layers
FTexture *Brightmap = nullptr;
FTexture* Detailmap = nullptr;
FTexture* Glowmap = nullptr;
FTexture *Normal = nullptr; // Normal map texture
FTexture *Specular = nullptr; // Specular light texture for the diffuse+normal+specular light model
FTexture *Metallic = nullptr; // Metalness texture for the physically based rendering (PBR) light model
FTexture *Roughness = nullptr; // Roughness texture for PBR
FTexture *AmbientOcclusion = nullptr; // Ambient occlusion texture for PBR
FTexture *CustomShaderTextures[MAX_CUSTOM_HW_SHADER_TEXTURES] = { nullptr }; // Custom texture maps for custom hardware shaders
protected:
FString Name;
@ -623,127 +608,145 @@ public:
// Refactoring helper to allow piece by piece adjustment of the API
class FGameTexture
{
FTexture *wrapped;
friend class FMaterial;
// Material layers
RefCountedPtr<FTexture> Base;
RefCountedPtr<FTexture> Brightmap;
RefCountedPtr<FTexture> Detailmap;
RefCountedPtr<FTexture> Glowmap;
RefCountedPtr<FTexture> Normal; // Normal map texture
RefCountedPtr<FTexture> Specular; // Specular light texture for the diffuse+normal+specular light model
RefCountedPtr<FTexture> Metallic; // Metalness texture for the physically based rendering (PBR) light model
RefCountedPtr<FTexture> Roughness; // Roughness texture for PBR
RefCountedPtr<FTexture> AmbientOcclusion; // Ambient occlusion texture for PBR
RefCountedPtr<FTexture> CustomShaderTextures[MAX_CUSTOM_HW_SHADER_TEXTURES]; // Custom texture maps for custom hardware shaders
int8_t shouldUpscaleFlag = 0; // Without explicit setup, scaling is disabled for a texture.
ETextureType UseType = ETextureType::Wall; // This texture's primary purpose
public:
FGameTexture(FTexture* wrap) : wrapped(wrap) {}
FGameTexture(FTexture* wrap) : Base(wrap) {}
~FGameTexture();
void CreateDefaultBrightmap();
void AddAutoMaterials();
bool ShouldExpandSprite();
void SetupSpriteData();
void SetSpriteRect();
ETextureType GetUseType() const { return UseType; }
void SetUpscaleFlag(int what) { shouldUpscaleFlag = what; }
int GetUpscaleFlag() { return shouldUpscaleFlag; }
FTexture* GetTexture() { return wrapped; }
int GetSourceLump() const { return wrapped->GetSourceLump(); }
void SetBrightmap(FGameTexture* tex) { wrapped->Brightmap = tex->GetTexture(); }
FTexture* GetTexture() { return Base.get(); }
int GetSourceLump() const { return Base->GetSourceLump(); }
void SetBrightmap(FGameTexture* tex) { Brightmap = tex->GetTexture(); }
double GetDisplayWidth() /*const*/ { return wrapped->GetDisplayWidthDouble(); }
double GetDisplayHeight() /*const*/ { return wrapped->GetDisplayHeightDouble(); }
int GetTexelWidth() /*const*/ { return wrapped->GetTexelWidth(); }
int GetTexelHeight() /*const*/ { return wrapped->GetTexelHeight(); }
int GetTexelLeftOffset(int adjusted = 0) /*const*/ { return wrapped->GetTexelLeftOffset(adjusted); }
int GetTexelTopOffset(int adjusted = 0) /*const*/ { return wrapped->GetTexelTopOffset(adjusted); }
double GetDisplayLeftOffset(int adjusted = 0) /*const*/ { return wrapped->GetDisplayLeftOffsetDouble(adjusted); }
double GetDisplayTopOffset(int adjusted = 0) /*const*/ { return wrapped->GetDisplayTopOffsetDouble(adjusted); }
double GetDisplayWidth() /*const*/ { return Base->GetDisplayWidthDouble(); }
double GetDisplayHeight() /*const*/ { return Base->GetDisplayHeightDouble(); }
int GetTexelWidth() /*const*/ { return Base->GetTexelWidth(); }
int GetTexelHeight() /*const*/ { return Base->GetTexelHeight(); }
int GetTexelLeftOffset(int adjusted = 0) /*const*/ { return Base->GetTexelLeftOffset(adjusted); }
int GetTexelTopOffset(int adjusted = 0) /*const*/ { return Base->GetTexelTopOffset(adjusted); }
double GetDisplayLeftOffset(int adjusted = 0) /*const*/ { return Base->GetDisplayLeftOffsetDouble(adjusted); }
double GetDisplayTopOffset(int adjusted = 0) /*const*/ { return Base->GetDisplayTopOffsetDouble(adjusted); }
// For the hardware renderer. The software renderer's have been offloaded to FSoftwareTexture
int GetLeftOffsetHW() { return GetTexelLeftOffset(r_spriteadjustHW); }
int GetTopOffsetHW() { return GetTexelTopOffset(r_spriteadjustHW); }
bool isValid() const { return UseType != ETextureType::Null; }
int isWarped() { return wrapped->isWarped(); }
void SetWarpStyle(int style) { wrapped->bWarped = style; }
bool isMasked() { return wrapped->isMasked(); }
bool isHardwareCanvas() const { return wrapped->isHardwareCanvas(); } // There's two here so that this can deal with software canvases in the hardware renderer later.
bool isSoftwareCanvas() const { return wrapped->isCanvas(); }
int isWarped() { return Base->isWarped(); }
void SetWarpStyle(int style) { Base->bWarped = style; }
bool isMasked() { return Base->isMasked(); }
bool isHardwareCanvas() const { return Base->isHardwareCanvas(); } // There's two here so that this can deal with software canvases in the hardware renderer later.
bool isSoftwareCanvas() const { return Base->isCanvas(); }
bool isMiscPatch() const { return GetUseType() == ETextureType::MiscPatch; } // only used by the intermission screen to decide whether to tile the background image or not.
bool isMultiPatch() const { return wrapped->bMultiPatch; }
bool isFullbrightDisabled() const { return wrapped->isFullbrightDisabled(); }
bool isFullbright() const { return wrapped->isFullbright(); }
bool isFullNameTexture() const { return wrapped->bFullNameTexture; }
bool expandSprites() const { return wrapped->bExpandSprite; }
bool useWorldPanning() const { return wrapped->UseWorldPanning(); }
void SetWorldPanning(bool on) { wrapped->SetWorldPanning(on); }
bool allowNoDecals() const { return wrapped->allowNoDecals(); }
void SetNoDecals(bool on) { wrapped->bNoDecals = on; }
void SetTranslucent(bool on) { wrapped->bTranslucent = on; }
bool isMultiPatch() const { return Base->bMultiPatch; }
bool isFullbrightDisabled() const { return Base->isFullbrightDisabled(); }
bool isFullbright() const { return Base->isFullbright(); }
bool isFullNameTexture() const { return Base->bFullNameTexture; }
bool expandSprites() const { return Base->bExpandSprite; }
bool useWorldPanning() const { return Base->UseWorldPanning(); }
void SetWorldPanning(bool on) { Base->SetWorldPanning(on); }
bool allowNoDecals() const { return Base->allowNoDecals(); }
void SetNoDecals(bool on) { Base->bNoDecals = on; }
void SetTranslucent(bool on) { Base->bTranslucent = on; }
void SetUseType(ETextureType type) { UseType = type; }
int GetShaderIndex() const { return wrapped->shaderindex; }
float GetShaderSpeed() const { return wrapped->GetShaderSpeed(); }
uint16_t GetRotations() const { return wrapped->GetRotations(); }
void SetRotations(int index) { wrapped->SetRotations(index); }
void SetSkyOffset(int ofs) { wrapped->SetSkyOffset(ofs); }
int GetSkyOffset() const { return wrapped->GetSkyOffset(); }
FTextureID GetID() const { return wrapped->GetID(); }
ISoftwareTexture* GetSoftwareTexture() { return wrapped->GetSoftwareTexture(); }
void SetSoftwareTexture(ISoftwareTexture* swtex) { wrapped->SetSoftwareTextue(swtex); }
void SetScale(DVector2 vec) { wrapped->SetScale(vec); }
const FString& GetName() const { return wrapped->GetName(); }
void SetShaderSpeed(float speed) { wrapped->shaderspeed = speed; }
void SetShaderIndex(int index) { wrapped->shaderindex = index; }
int GetShaderIndex() const { return Base->shaderindex; }
float GetShaderSpeed() const { return Base->GetShaderSpeed(); }
uint16_t GetRotations() const { return Base->GetRotations(); }
void SetRotations(int index) { Base->SetRotations(index); }
void SetSkyOffset(int ofs) { Base->SetSkyOffset(ofs); }
int GetSkyOffset() const { return Base->GetSkyOffset(); }
FTextureID GetID() const { return Base->GetID(); }
ISoftwareTexture* GetSoftwareTexture() { return Base->GetSoftwareTexture(); }
void SetSoftwareTexture(ISoftwareTexture* swtex) { Base->SetSoftwareTextue(swtex); }
void SetScale(DVector2 vec) { Base->SetScale(vec); }
const FString& GetName() const { return Base->GetName(); }
void SetShaderSpeed(float speed) { Base->shaderspeed = speed; }
void SetShaderIndex(int index) { Base->shaderindex = index; }
void SetShaderLayers(MaterialLayers& lay)
{
// Only update layers that have something defind.
if (lay.Glossiness > -1000) wrapped->Glossiness = lay.Glossiness;
if (lay.SpecularLevel > -1000) wrapped->SpecularLevel = lay.SpecularLevel;
if (lay.Brightmap) wrapped->Brightmap = lay.Brightmap->GetTexture();
if (lay.Normal) wrapped->Normal = lay.Normal->GetTexture();
if (lay.Specular) wrapped->Specular = lay.Specular->GetTexture();
if (lay.Metallic) wrapped->Metallic = lay.Metallic->GetTexture();
if (lay.Roughness) wrapped->Roughness = lay.Roughness->GetTexture();
if (lay.AmbientOcclusion) wrapped->AmbientOcclusion = lay.AmbientOcclusion->GetTexture();
if (lay.Glossiness > -1000) Base->Glossiness = lay.Glossiness;
if (lay.SpecularLevel > -1000) Base->SpecularLevel = lay.SpecularLevel;
if (lay.Brightmap) Brightmap = lay.Brightmap->GetTexture();
if (lay.Normal) Normal = lay.Normal->GetTexture();
if (lay.Specular) Specular = lay.Specular->GetTexture();
if (lay.Metallic) Metallic = lay.Metallic->GetTexture();
if (lay.Roughness) Roughness = lay.Roughness->GetTexture();
if (lay.AmbientOcclusion) AmbientOcclusion = lay.AmbientOcclusion->GetTexture();
for (int i = 0; i < MAX_CUSTOM_HW_SHADER_TEXTURES; i++)
{
if (lay.CustomShaderTextures[i]) wrapped->CustomShaderTextures[i] = lay.CustomShaderTextures[i]->GetTexture();
if (lay.CustomShaderTextures[i]) CustomShaderTextures[i] = lay.CustomShaderTextures[i]->GetTexture();
}
}
float GetGlossiness() const { return wrapped->Glossiness; }
float GetSpecularLevel() const { return wrapped->SpecularLevel; }
float GetGlossiness() const { return Base->Glossiness; }
float GetSpecularLevel() const { return Base->SpecularLevel; }
void CopySize(FGameTexture* BaseTexture)
{
wrapped->CopySize(BaseTexture->wrapped);
Base->CopySize(BaseTexture->Base.get());
}
// Glowing is a pure material property that should not filter down to the actual texture objects.
void GetGlowColor(float* data) { wrapped->GetGlowColor(data); }
bool isGlowing() const { return wrapped->isGlowing(); }
bool isAutoGlowing() const { return wrapped->isAutoGlowing(); }
int GetGlowHeight() const { return wrapped->GetGlowHeight(); }
void GetGlowColor(float* data) { Base->GetGlowColor(data); }
bool isGlowing() const { return Base->isGlowing(); }
bool isAutoGlowing() const { return Base->isAutoGlowing(); }
int GetGlowHeight() const { return Base->GetGlowHeight(); }
void SetAutoGlowing() { auto tex = GetTexture(); tex->bAutoGlowing = tex->bGlowing = tex->bFullbright = true; }
void SetGlowHeight(int v) { wrapped->GlowHeight = v; }
void SetFullbright() { wrapped->bFullbright = true; }
void SetDisableFullbright(bool on) { wrapped->bDisableFullbright = on; }
void SetGlowHeight(int v) { Base->GlowHeight = v; }
void SetFullbright() { Base->bFullbright = true; }
void SetDisableFullbright(bool on) { Base->bDisableFullbright = on; }
void SetGlowing(PalEntry color) { auto tex = GetTexture(); tex->bAutoGlowing = false; tex->bGlowing = true; tex->GlowColor = color; }
bool isUserContent() const;
void AddAutoMaterials() { wrapped->AddAutoMaterials(); }
int CheckRealHeight() { return wrapped->CheckRealHeight(); }
bool isSkybox() const { return wrapped->isSkybox(); }
void SetSize(int x, int y) { wrapped->SetSize(x, y); }
void SetDisplaySize(float w, float h) { wrapped->SetSize((int)w, (int)h); }
int CheckRealHeight() { return Base->CheckRealHeight(); }
bool isSkybox() const { return Base->isSkybox(); }
void SetSize(int x, int y) { Base->SetSize(x, y); }
void SetDisplaySize(float w, float h) { Base->SetSize((int)w, (int)h); }
void SetSpriteRect() { wrapped->SetSpriteRect(); }
const SpritePositioningInfo& GetSpritePositioning(int which) { if (wrapped->spi == nullptr) wrapped->SetupSpriteData(); return wrapped->spi[which]; }
int GetAreas(FloatRect** pAreas) const { return wrapped->GetAreas(pAreas); }
PalEntry GetSkyCapColor(bool bottom) { return wrapped->GetSkyCapColor(bottom); }
const SpritePositioningInfo& GetSpritePositioning(int which) { if (Base->spi == nullptr) SetupSpriteData(); return Base->spi[which]; }
int GetAreas(FloatRect** pAreas) const { return Base->GetAreas(pAreas); }
PalEntry GetSkyCapColor(bool bottom) { return Base->GetSkyCapColor(bottom); }
bool GetTranslucency()
{
return wrapped->GetTranslucency();
return Base->GetTranslucency();
}
// Since these properties will later piggyback on existing members of FGameTexture, the accessors need to be here.
FGameTexture *GetSkyFace(int num)
{
return (isSkybox() ? static_cast<FSkyBox*>(wrapped)->faces[num] : nullptr);
return (isSkybox() ? static_cast<FSkyBox*>(Base.get())->faces[num] : nullptr);
}
bool GetSkyFlip() { return isSkybox() ? static_cast<FSkyBox*>(wrapped)->fliptop : false; }
bool GetSkyFlip() { return isSkybox() ? static_cast<FSkyBox*>(Base.get())->fliptop : false; }
int GetClampMode(int clampmode)
{
if (GetUseType() == ETextureType::SWCanvas) clampmode = CLAMP_NOFILTER;
else if (isHardwareCanvas()) clampmode = CLAMP_CAMTEX;
else if ((isWarped() || wrapped->shaderindex >= FIRST_USER_SHADER) && clampmode <= CLAMP_XY) clampmode = CLAMP_NONE;
else if ((isWarped() || Base->shaderindex >= FIRST_USER_SHADER) && clampmode <= CLAMP_XY) clampmode = CLAMP_NONE;
return clampmode;
}
};

103
src/common/utility/refcounted.h Normal file
View file

@ -0,0 +1,103 @@
#pragma once
// Simple lightweight reference counting pointer alternative for std::shared_ptr which stores the reference counter in the handled object itself.
// Base class for handled objects
class RefCountedBase
{
public:
void IncRef() { refCount++; }
void DecRef() { if (--refCount <= 0) delete this; }
private:
int refCount = 0;
protected:
virtual ~RefCountedBase() = default;
};
// The actual pointer object
template<class T>
class RefCountedPtr
{
public:
~RefCountedPtr()
{
if (ptr) ptr->DecRef();
}
RefCountedPtr() : ptr(nullptr)
{}
explicit RefCountedPtr(T* p) : ptr(p)
{
if (ptr) ptr->IncRef();
}
RefCountedPtr & operator=(const RefCountedPtr& r)
{
if (ptr != r.ptr)
{
if (ptr) ptr->DecRef();
ptr = r.ptr;
if (ptr) ptr->IncRef();
}
return *this;
}
RefCountedPtr& operator=(T* r)
{
if (ptr != r)
{
if (ptr) ptr->DecRef();
ptr = r;
if (ptr) ptr->IncRef();
}
return *this;
}
RefCountedPtr & operator=(const RefCountedPtr&& r)
{
if (ptr) ptr->DecRef();
ptr = r.ptr;
r.ptr = nullptr;
return *this;
}
bool operator==(T* p) const
{
return ptr == p;
}
bool operator!=(T* p) const
{
return ptr != p;
}
bool operator==(const RefCountedPtr &p) const
{
return ptr == p.ptr;
}
bool operator!=(const RefCountedPtr& p) const
{
return ptr != p.ptr;
}
T& operator* () const
{
return *ptr;
}
T* operator-> () const
{
return ptr;
}
T* get() const
{
return ptr;
}
private:
T * ptr;
};