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

- made some changes to the FImageSource interface that allows forwarding the bRemap0 flag, but do it so that it doesn't permanently alter how the image looks.

Browse source 
In ZDoom this would affect everything using a patch that got used in a front sky layer, even if the texture was totally unrelated. It is only owed to the low usability of such patches for other purposes that this hasn't caused problems.
This commit is contained in:
Christoph Oelckers 2018-12-09 08:15:05 +01:00
parent 583a740441
commit 91f7121452
18 changed files with 90 additions and 105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
src/r_data/models/models_voxel.cpp
View file

@ -52,8 +52,8 @@ class FVoxelTexture : public FImageSource
public:
FVoxelTexture(FVoxel *voxel);
int CopyPixels(FBitmap *bmp) override;
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
protected:
FVoxel *SourceVox;
@ -79,7 +79,7 @@ FVoxelTexture::FVoxelTexture(FVoxel *vox)
//
//===========================================================================
TArray<uint8_t> FVoxelTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FVoxelTexture::GetPalettedPixels(int conversion)
{
// GetPixels gets called when a translated palette is used so we still need to implement it here.
TArray<uint8_t> Pixels(256, true);
@ -94,7 +94,7 @@ TArray<uint8_t> FVoxelTexture::Get8BitPixels(bool alphatex)
pe.g = (pp[1] << 2) | (pp[1] >> 4);
pe.b = (pp[2] << 2) | (pp[2] >> 4);
// Alphatexture handling is just for completeness, but rather unlikely to be used ever.
Pixels[i] = alphatex? pe.r : ColorMatcher.Pick(pe);
Pixels[i] = conversion == luminance ? pe.r : ColorMatcher.Pick(pe);
}
}
else
@ -116,7 +116,7 @@ TArray<uint8_t> FVoxelTexture::Get8BitPixels(bool alphatex)
//
//===========================================================================
int FVoxelTexture::CopyPixels(FBitmap *bmp)
int FVoxelTexture::CopyPixels(FBitmap *bmp, int conversion)
{
PalEntry pe[256];
uint8_t bitmap[256];

6
src/textures/formats/automaptexture.cpp
View file

@ -52,7 +52,7 @@ class FAutomapTexture : public FImageSource
{
public:
FAutomapTexture(int lumpnum);
TArray<uint8_t> Get8BitPixels(bool alphatex);
TArray<uint8_t> GetPalettedPixels(int conversion) override;
};
@ -91,7 +91,7 @@ FAutomapTexture::FAutomapTexture (int lumpnum)
//
//==========================================================================
TArray<uint8_t> FAutomapTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FAutomapTexture::GetPalettedPixels(int conversion)
{
int x, y;
FMemLump data = Wads.ReadLump (SourceLump);
@ -99,7 +99,7 @@ TArray<uint8_t> FAutomapTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> Pixels(Width * Height, true);
const uint8_t *remap = ImageHelpers::GetRemap(alphatex);
const uint8_t *remap = ImageHelpers::GetRemap(conversion == luminance);
for (x = 0; x < Width; ++x)
{
for (y = 0; y < Height; ++y)

4
src/textures/formats/brightmaptexture.cpp
View file

@ -46,7 +46,7 @@ class FBrightmapTexture : public FImageSource
public:
FBrightmapTexture (FImageSource *source);
int CopyPixels(FBitmap *bmp) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
protected:
FImageSource *SourcePic;
@ -68,7 +68,7 @@ FBrightmapTexture::FBrightmapTexture (FImageSource *source)
bMasked = false;
}
int FBrightmapTexture::CopyPixels(FBitmap *bmp)
int FBrightmapTexture::CopyPixels(FBitmap *bmp, int conversion)
{
SourcePic->CopyTranslatedPixels(bmp, TexMan.GlobalBrightmap.Palette);
return 0;

10
src/textures/formats/buildtexture.cpp
View file

@ -57,8 +57,8 @@ class FBuildTexture : public FImageSource
{
public:
FBuildTexture (const FString &pathprefix, int tilenum, const uint8_t *pixels, int translation, int width, int height, int left, int top);
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
int CopyPixels(FBitmap *bmp) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
protected:
const uint8_t *RawPixels;
@ -81,19 +81,19 @@ FBuildTexture::FBuildTexture(const FString &pathprefix, int tilenum, const uint8
TopOffset = top;
}
TArray<uint8_t> FBuildTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FBuildTexture::GetPalettedPixels(int conversion)
{
TArray<uint8_t> Pixels(Width * Height, true);
FRemapTable *Remap = translationtables[TRANSLATION_Standard][Translation];
for (int i = 0; i < Width*Height; i++)
{
auto c = RawPixels[i];
Pixels[i] = alphatex ? Remap->Palette[c].Luminance() : Remap->Remap[c];
Pixels[i] = conversion == luminance ? Remap->Palette[c].Luminance() : Remap->Remap[c];
}
return Pixels;
}
int FBuildTexture::CopyPixels(FBitmap *bmp)
int FBuildTexture::CopyPixels(FBitmap *bmp, int conversion)
{
PalEntry *Remap = translationtables[TRANSLATION_Standard][Translation]->Palette;
bmp->CopyPixelData(0, 0, RawPixels, Width, Height, Height, 1, 0, Remap);

10
src/textures/formats/ddstexture.cpp
View file

@ -164,7 +164,7 @@ class FDDSTexture : public FImageSource
public:
FDDSTexture (FileReader &lump, int lumpnum, void *surfdesc);
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
protected:
uint32_t Format;
@ -183,7 +183,7 @@ protected:
void DecompressDXT3 (FileReader &lump, bool premultiplied, uint8_t *buffer, int pixelmode);
void DecompressDXT5 (FileReader &lump, bool premultiplied, uint8_t *buffer, int pixelmode);
int CopyPixels(FBitmap *bmp) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
bool UseBasePalette();
friend class FTexture;
@ -373,7 +373,7 @@ void FDDSTexture::CalcBitShift (uint32_t mask, uint8_t *lshiftp, uint8_t *rshift
//
//==========================================================================
TArray<uint8_t> FDDSTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FDDSTexture::GetPalettedPixels(int conversion)
{
auto lump = Wads.OpenLumpReader (SourceLump);
@ -381,7 +381,7 @@ TArray<uint8_t> FDDSTexture::Get8BitPixels(bool alphatex)
lump.Seek (sizeof(DDSURFACEDESC2) + 4, FileReader::SeekSet);
int pmode = alphatex ? PIX_Alphatex : PIX_Palette;
int pmode = conversion == luminance ? PIX_Alphatex : PIX_Palette;
if (Format >= 1 && Format <= 4) // RGB: Format is # of bytes per pixel
{
ReadRGB (lump, Pixels.Data(), pmode);
@ -782,7 +782,7 @@ void FDDSTexture::DecompressDXT5 (FileReader &lump, bool premultiplied, uint8_t
//
//===========================================================================
int FDDSTexture::CopyPixels(FBitmap *bmp)
int FDDSTexture::CopyPixels(FBitmap *bmp, int conversion)
{
auto lump = Wads.OpenLumpReader (SourceLump);

4
src/textures/formats/emptytexture.cpp
View file

@ -51,7 +51,7 @@ class FEmptyTexture : public FImageSource
{
public:
FEmptyTexture (int lumpnum);
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
};
//==========================================================================
@ -91,7 +91,7 @@ FEmptyTexture::FEmptyTexture (int lumpnum)
//
//==========================================================================
TArray<uint8_t> FEmptyTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FEmptyTexture::GetPalettedPixels(int conversion)
{
TArray<uint8_t> Pixel(1, true);
Pixel[0] = 0;

6
src/textures/formats/flattexture.cpp
View file

@ -50,7 +50,7 @@ class FFlatTexture : public FImageSource
{
public:
FFlatTexture (int lumpnum);
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
};
@ -104,7 +104,7 @@ FFlatTexture::FFlatTexture (int lumpnum)
//
//==========================================================================
TArray<uint8_t> FFlatTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FFlatTexture::GetPalettedPixels(int conversion)
{
auto lump = Wads.OpenLumpReader (SourceLump);
TArray<uint8_t> Pixels(Width*Height, true);
@ -113,7 +113,7 @@ TArray<uint8_t> FFlatTexture::Get8BitPixels(bool alphatex)
{
memset (Pixels.Data() + numread, 0xBB, Width*Height - numread);
}
ImageHelpers::FlipSquareBlockRemap(Pixels.Data(), Width, ImageHelpers::GetRemap(alphatex));
ImageHelpers::FlipSquareBlockRemap(Pixels.Data(), Width, ImageHelpers::GetRemap(conversion == luminance));
return Pixels;
}

12
src/textures/formats/imgztexture.cpp
View file

@ -68,8 +68,8 @@ class FIMGZTexture : public FImageSource
public:
FIMGZTexture (int lumpnum, uint16_t w, uint16_t h, int16_t l, int16_t t, bool isalpha);
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
int CopyPixels(FBitmap *bmp) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
};
@ -120,7 +120,7 @@ FIMGZTexture::FIMGZTexture (int lumpnum, uint16_t w, uint16_t h, int16_t l, int1
//
//==========================================================================
TArray<uint8_t> FIMGZTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FIMGZTexture::GetPalettedPixels(int conversion)
{
FMemLump lump = Wads.ReadLump (SourceLump);
const ImageHeader *imgz = (const ImageHeader *)lump.GetMem();
@ -133,7 +133,7 @@ TArray<uint8_t> FIMGZTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> Pixels(Width*Height, true);
dest_p = Pixels.Data();
const uint8_t *remap = ImageHelpers::GetRemap(alphatex, isalpha);
const uint8_t *remap = ImageHelpers::GetRemap(conversion == luminance, isalpha);
// Convert the source image from row-major to column-major format and remap it
if (!imgz->Compression)
@ -200,9 +200,9 @@ TArray<uint8_t> FIMGZTexture::Get8BitPixels(bool alphatex)
//
//==========================================================================
int FIMGZTexture::CopyPixels(FBitmap *bmp)
int FIMGZTexture::CopyPixels(FBitmap *bmp, int conversion)
{
if (!isalpha) return FImageSource::CopyPixels(bmp);
if (!isalpha) return FImageSource::CopyPixels(bmp, conversion);
else return CopyTranslatedPixels(bmp, translationtables[TRANSLATION_Standard][STD_Grayscale]->Palette);
}

9
src/textures/formats/jpegtexture.cpp
View file

@ -185,8 +185,8 @@ class FJPEGTexture : public FImageSource
public:
FJPEGTexture (int lumpnum, int width, int height);
int CopyPixels(FBitmap *bmp) override;
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
};
//==========================================================================
@ -260,7 +260,7 @@ FJPEGTexture::FJPEGTexture (int lumpnum, int width, int height)
//
//==========================================================================
TArray<uint8_t> FJPEGTexture::Get8BitPixels(bool doalpha)
TArray<uint8_t> FJPEGTexture::GetPalettedPixels(int conversion)
{
auto lump = Wads.OpenLumpReader (SourceLump);
JSAMPLE *buff = NULL;
@ -279,6 +279,7 @@ TArray<uint8_t> FJPEGTexture::Get8BitPixels(bool doalpha)
FLumpSourceMgr sourcemgr(&lump, &cinfo);
try
{
bool doalpha = conversion == luminance;
jpeg_read_header(&cinfo, TRUE);
if (!((cinfo.out_color_space == JCS_RGB && cinfo.num_components == 3) ||
(cinfo.out_color_space == JCS_CMYK && cinfo.num_components == 4) ||
@ -381,7 +382,7 @@ TArray<uint8_t> FJPEGTexture::Get8BitPixels(bool doalpha)
//
//===========================================================================
int FJPEGTexture::CopyPixels(FBitmap *bmp)
int FJPEGTexture::CopyPixels(FBitmap *bmp, int conversion)
{
PalEntry pe[256];

15
src/textures/formats/patchtexture.cpp
View file

@ -62,11 +62,10 @@ class FPatchTexture : public FImageSource
{
bool badflag = false;
bool isalpha = false;
bool bNoRemap0 = false; // Unfortunately this was done as a very bad hack in ZDoom and will need impovement
public:
FPatchTexture (int lumpnum, patch_t *header, bool isalphatex);
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
int CopyPixels(FBitmap *bmp) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
void DetectBadPatches();
};
@ -164,7 +163,7 @@ FPatchTexture::FPatchTexture (int lumpnum, patch_t * header, bool isalphatex)
//
//==========================================================================
TArray<uint8_t> FPatchTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FPatchTexture::GetPalettedPixels(int conversion)
{
uint8_t *remap, remaptable[256];
int numspans;
@ -176,9 +175,9 @@ TArray<uint8_t> FPatchTexture::Get8BitPixels(bool alphatex)
maxcol = (const column_t *)((const uint8_t *)patch + Wads.LumpLength (SourceLump) - 3);
remap = ImageHelpers::GetRemap(alphatex, isalpha);
remap = ImageHelpers::GetRemap(conversion == luminance, isalpha);
// Special case for skies
if (bNoRemap0 && remap == GPalette.Remap)
if (conversion == noremap0 && remap == GPalette.Remap)
{
memcpy(remaptable, GPalette.Remap, 256);
remaptable[0] = 0;
@ -261,9 +260,9 @@ TArray<uint8_t> FPatchTexture::Get8BitPixels(bool alphatex)
//
//==========================================================================
int FPatchTexture::CopyPixels(FBitmap *bmp)
int FPatchTexture::CopyPixels(FBitmap *bmp, int conversion)
{
if (!isalpha) return FImageSource::CopyPixels(bmp);
if (!isalpha) return FImageSource::CopyPixels(bmp, conversion);
else return CopyTranslatedPixels(bmp, translationtables[TRANSLATION_Standard][STD_Grayscale]->Palette);
}

9
src/textures/formats/pcxtexture.cpp
View file

@ -85,7 +85,7 @@ class FPCXTexture : public FImageSource
public:
FPCXTexture (int lumpnum, PCXHeader &);
int CopyPixels(FBitmap *bmp) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
protected:
void ReadPCX1bit (uint8_t *dst, FileReader & lump, PCXHeader *hdr);
@ -93,7 +93,7 @@ protected:
void ReadPCX8bits (uint8_t *dst, FileReader & lump, PCXHeader *hdr);
void ReadPCX24bits (uint8_t *dst, FileReader & lump, PCXHeader *hdr, int planes);
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
};
@ -358,7 +358,7 @@ void FPCXTexture::ReadPCX24bits (uint8_t *dst, FileReader & lump, PCXHeader *hdr
//
//==========================================================================
TArray<uint8_t> FPCXTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FPCXTexture::GetPalettedPixels(int conversion)
{
uint8_t PaletteMap[256];
PCXHeader header;
@ -371,6 +371,7 @@ TArray<uint8_t> FPCXTexture::Get8BitPixels(bool alphatex)
bitcount = header.bitsPerPixel * header.numColorPlanes;
TArray<uint8_t> Pixels(Width*Height, true);
bool alphatex = conversion == luminance;
if (bitcount < 24)
{
if (bitcount < 8)
@ -446,7 +447,7 @@ TArray<uint8_t> FPCXTexture::Get8BitPixels(bool alphatex)
//
//===========================================================================
int FPCXTexture::CopyPixels(FBitmap *bmp)
int FPCXTexture::CopyPixels(FBitmap *bmp, int conversion)
{
PalEntry pe[256];
PCXHeader header;

37
src/textures/formats/pngtexture.cpp
View file

@ -54,9 +54,8 @@ public:
FPNGTexture (FileReader &lump, int lumpnum, const FString &filename, int width, int height, uint8_t bitdepth, uint8_t colortype, uint8_t interlace);
~FPNGTexture();
int CopyPixels(FBitmap *bmp) override;
bool UseBasePalette() override;
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
protected:
void ReadAlphaRemap(FileReader *lump, uint8_t *alpharemap);
@ -182,7 +181,7 @@ FTexture *PNGTexture_CreateFromFile(PNGHandle *png, const FString &filename)
return NULL;
}
return new FPNGTexture (png->File, -1, filename, width, height, bitdepth, colortype, interlace);
return new FImageTexture(new FPNGTexture (png->File, -1, filename, width, height, bitdepth, colortype, interlace));
}
//==========================================================================
@ -193,7 +192,7 @@ FTexture *PNGTexture_CreateFromFile(PNGHandle *png, const FString &filename)
FPNGTexture::FPNGTexture (FileReader &lump, int lumpnum, const FString &filename, int width, int height,
uint8_t depth, uint8_t colortype, uint8_t interlace)
: FWorldTexture(NULL, lumpnum), SourceFile(filename),
: FImageSource(lumpnum), SourceFile(filename),
BitDepth(depth), ColorType(colortype), Interlace(interlace), HaveTrans(false)
{
union
@ -205,7 +204,6 @@ FPNGTexture::FPNGTexture (FileReader &lump, int lumpnum, const FString &filename
uint32_t len, id;
int i;
UseType = ETextureType::MiscPatch;
bMasked = false;
Width = width;
@ -247,8 +245,8 @@ FPNGTexture::FPNGTexture (FileReader &lump, int lumpnum, const FString &filename
Printf ("Y-Offset for PNG texture %s is bad: %d (0x%08x)\n", Wads.GetLumpFullName (lumpnum), ihoty, ihoty);
ihoty = 0;
}
_LeftOffset[1] = _LeftOffset[0] = ihotx;
_TopOffset[1] = _TopOffset[0] = ihoty;
LeftOffset = ihotx;
TopOffset = ihoty;
}
break;
@ -369,7 +367,7 @@ void FPNGTexture::ReadAlphaRemap(FileReader *lump, uint8_t *alpharemap)
//
//==========================================================================
TArray<uint8_t> FPNGTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FPNGTexture::GetPalettedPixels(int conversion)
{
FileReader *lump;
FileReader lfr;
@ -396,13 +394,14 @@ TArray<uint8_t> FPNGTexture::Get8BitPixels(bool alphatex)
lump->Read(&len, 4);
lump->Read(&id, 4);
bool alphatex = conversion == luminance;
if (ColorType == 0 || ColorType == 3) /* Grayscale and paletted */
{
M_ReadIDAT (*lump, Pixels.Data(), Width, Height, Width, BitDepth, ColorType, Interlace, BigLong((unsigned int)len));
if (Width == Height)
{
if (!alphatex)
if (conversion != luminance)
{
ImageHelpers::FlipSquareBlockRemap (Pixels.Data(), Width, PaletteMap);
}
@ -420,7 +419,7 @@ TArray<uint8_t> FPNGTexture::Get8BitPixels(bool alphatex)
else
{
TArray<uint8_t> newpix(Width*Height, true);
if (!alphatex)
if (conversion != luminance)
{
ImageHelpers::FlipNonSquareBlockRemap (newpix.Data(), Pixels.Data(), Width, Height, Width, PaletteMap);
}
@ -513,7 +512,7 @@ TArray<uint8_t> FPNGTexture::Get8BitPixels(bool alphatex)
//
//===========================================================================
int FPNGTexture::CopyPixels(FBitmap *bmp)
int FPNGTexture::CopyPixels(FBitmap *bmp, int conversion)
{
// Parse pre-IDAT chunks. I skip the CRCs. Is that bad?
PalEntry pe[256];
@ -631,17 +630,3 @@ int FPNGTexture::CopyPixels(FBitmap *bmp)
delete[] Pixels;
return transpal;
}
//===========================================================================
//
// This doesn't check if the palette is identical with the base palette
// I don't think it's worth the hassle because it's only of importance
// when compositing multipatch textures.
//
//===========================================================================
bool FPNGTexture::UseBasePalette()
{
return false;
}

12
src/textures/formats/rawpagetexture.cpp
View file

@ -54,8 +54,8 @@ class FRawPageTexture : public FImageSource
int mPaletteLump = -1;
public:
FRawPageTexture (int lumpnum);
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
int CopyPixels(FBitmap *bmp) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
};
//==========================================================================
@ -173,7 +173,7 @@ FRawPageTexture::FRawPageTexture (int lumpnum)
//
//==========================================================================
TArray<uint8_t> FRawPageTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FRawPageTexture::GetPalettedPixels(int conversion)
{
FMemLump lump = Wads.ReadLump (SourceLump);
const uint8_t *source = (const uint8_t *)lump.GetMem();
@ -183,7 +183,7 @@ TArray<uint8_t> FRawPageTexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> Pixels(Width*Height, true);
dest_p = Pixels.Data();
const uint8_t *remap = ImageHelpers::GetRemap(alphatex);
const uint8_t *remap = ImageHelpers::GetRemap(conversion == luminance);
// This does not handle the custom palette.
// User maps are encouraged to use a real image format when replacing E2END and the original could never be used anywhere else.
@ -202,9 +202,9 @@ TArray<uint8_t> FRawPageTexture::Get8BitPixels(bool alphatex)
return Pixels;
}
int FRawPageTexture::CopyPixels(FBitmap *bmp)
int FRawPageTexture::CopyPixels(FBitmap *bmp, int conversion)
{
if (mPaletteLump < 0) return FImageSource::CopyPixels(bmp);
if (mPaletteLump < 0) return FImageSource::CopyPixels(bmp, conversion);
else
{
FMemLump lump = Wads.ReadLump(SourceLump);

9
src/textures/formats/shadertexture.cpp
View file

@ -100,10 +100,10 @@ public:
}
}
TArray<uint8_t> Get8BitPixels(bool alphatex) override
TArray<uint8_t> GetPalettedPixels(int conversion) override
{
TArray<uint8_t> Pix(512, true);
if (alphatex)
if (conversion == luminance)
{
memcpy(Pix.Data(), Pixels, 512);
}
@ -120,7 +120,7 @@ public:
return Pix;
}
int CopyPixels(FBitmap *bmp) override
int CopyPixels(FBitmap *bmp, int conversion) override
{
bmp->CopyPixelData(0, 0, Pixels, Width, Height, Height, 1, 0, translationtables[TRANSLATION_Standard][8]->Palette);
return 0;
@ -134,5 +134,6 @@ private:
FTexture *CreateShaderTexture(bool vertical, bool reverse)
{
FStringf name("BarShader%c%c", vertical ? 'v' : 'h', reverse ? 'r' : 'f');
auto tex = new FImageTexture(new FBarShader(vertical, reverse), name.GetChars());
return new FImageTexture(new FBarShader(vertical, reverse), name.GetChars());
}

20
src/textures/formats/tgatexture.cpp
View file

@ -81,11 +81,11 @@ class FTGATexture : public FImageSource
public:
FTGATexture (int lumpnum, TGAHeader *);
int CopyPixels(FBitmap *bmp) override;
int CopyPixels(FBitmap *bmp, int conversion) override;
protected:
void ReadCompressed(FileReader &lump, uint8_t * buffer, int bytesperpixel);
TArray<uint8_t> Get8BitPixels(bool alphatex) override;
TArray<uint8_t> GetPalettedPixels(int conversion) override;
};
//==========================================================================
@ -179,7 +179,7 @@ void FTGATexture::ReadCompressed(FileReader &lump, uint8_t * buffer, int bytespe
//
//==========================================================================
TArray<uint8_t> FTGATexture::Get8BitPixels(bool alphatex)
TArray<uint8_t> FTGATexture::GetPalettedPixels(int conversion)
{
uint8_t PaletteMap[256];
auto lump = Wads.OpenLumpReader (SourceLump);
@ -232,7 +232,7 @@ TArray<uint8_t> FTGATexture::Get8BitPixels(bool alphatex)
r=g=b=a=0;
break;
}
PaletteMap[i] = ImageHelpers::RGBToPalettePrecise(alphatex, r, g, b, a);
PaletteMap[i] = ImageHelpers::RGBToPalettePrecise(conversion == luminance, r, g, b, a);
}
}
@ -291,7 +291,7 @@ TArray<uint8_t> FTGATexture::Get8BitPixels(bool alphatex)
for(int x=0;x<Width;x++)
{
int v = LittleShort(*p);
Pixels[x*Height + y] = ImageHelpers::RGBToPalette(alphatex, ((v >> 10) & 0x1f) * 8, ((v >> 5) & 0x1f) * 8, (v & 0x1f) * 8);
Pixels[x*Height + y] = ImageHelpers::RGBToPalette(conversion == luminance, ((v >> 10) & 0x1f) * 8, ((v >> 5) & 0x1f) * 8, (v & 0x1f) * 8);
p+=step_x;
}
}
@ -303,7 +303,7 @@ TArray<uint8_t> FTGATexture::Get8BitPixels(bool alphatex)
uint8_t * p = ptr + y * Pitch;
for(int x=0;x<Width;x++)
{
Pixels[x*Height + y] = ImageHelpers::RGBToPalette(alphatex, p[2], p[1], p[0]);
Pixels[x*Height + y] = ImageHelpers::RGBToPalette(conversion == luminance, p[2], p[1], p[0]);
p+=step_x;
}
}
@ -317,7 +317,7 @@ TArray<uint8_t> FTGATexture::Get8BitPixels(bool alphatex)
uint8_t * p = ptr + y * Pitch;
for(int x=0;x<Width;x++)
{
Pixels[x*Height + y] = ImageHelpers::RGBToPalette(alphatex, p[2], p[1], p[0]);
Pixels[x*Height + y] = ImageHelpers::RGBToPalette(conversion == luminance, p[2], p[1], p[0]);
p+=step_x;
}
}
@ -329,7 +329,7 @@ TArray<uint8_t> FTGATexture::Get8BitPixels(bool alphatex)
uint8_t * p = ptr + y * Pitch;
for(int x=0;x<Width;x++)
{
Pixels[x*Height + y] = ImageHelpers::RGBToPalette(alphatex, p[2], p[1], p[0], p[3]);
Pixels[x*Height + y] = ImageHelpers::RGBToPalette(conversion == luminance, p[2], p[1], p[0], p[3]);
p+=step_x;
}
}
@ -343,7 +343,7 @@ TArray<uint8_t> FTGATexture::Get8BitPixels(bool alphatex)
case 3: // Grayscale
{
auto remap = ImageHelpers::GetRemap(alphatex, true);
auto remap = ImageHelpers::GetRemap(conversion == luminance, true);
switch (hdr.bpp)
{
case 8:
@ -388,7 +388,7 @@ TArray<uint8_t> FTGATexture::Get8BitPixels(bool alphatex)
//
//===========================================================================
int FTGATexture::CopyPixels(FBitmap *bmp)
int FTGATexture::CopyPixels(FBitmap *bmp, int conversion)
{
PalEntry pe[256];
auto lump = Wads.OpenLumpReader (SourceLump);

10
src/textures/image.cpp
View file

@ -45,7 +45,7 @@
//
//===========================================================================
TArray<uint8_t> FImageSource::Get8BitPixels(bool alphatex)
TArray<uint8_t> FImageSource::GetPalettedPixels(int conversion)
{
TArray<uint8_t> Pixels(Width * Height, true);
memset(Pixels.Data(), 0, Width * Height);
@ -65,11 +65,12 @@ TArray<uint8_t> FImageSource::Get8BitPixels(bool alphatex)
//
//===========================================================================
int FImageSource::CopyPixels(FBitmap *bmp)
int FImageSource::CopyPixels(FBitmap *bmp, int conversion)
{
if (conversion == luminance) conversion = normal; // luminance images have no use as an RGB source.
PalEntry *palette = screen->GetPalette();
for(int i=1;i<256;i++) palette[i].a = 255; // set proper alpha values
auto ppix = Get8BitPixels(false); // should use composition cache
auto ppix = GetPalettedPixels(conversion); // should use composition cache
bmp->CopyPixelData(0, 0, ppix.Data(), Width, Height, Height, 1, 0, palette, nullptr);
for(int i=1;i<256;i++) palette[i].a = 0;
return 0;
@ -77,8 +78,7 @@ int FImageSource::CopyPixels(FBitmap *bmp)
int FImageSource::CopyTranslatedPixels(FBitmap *bmp, PalEntry *remap)
{
auto ppix = Get8BitPixels(false); // should use composition cache
auto ppix = GetPalettedPixels(false); // should use composition cache
bmp->CopyPixelData(0, 0, ppix.Data(), Width, Height, Height, 1, 0, remap, nullptr);
return 0;
}

6
src/textures/image.h
View file

@ -16,16 +16,14 @@ protected:
int LeftOffset = 0, TopOffset = 0; // Offsets stored in the image.
bool bUseGamePalette = false; // true if this is an image without its own color set.
// internal builder functions for true color textures.
public:
bool bMasked = true; // Image (might) have holes (Assume true unless proven otherwise!)
int8_t bTranslucent = -1; // Image has pixels with a non-0/1 value. (-1 means the user needs to do a real check)
// Returns the whole texture, paletted and true color versions respectively.
virtual TArray<uint8_t> Get8BitPixels(bool alphatex);
virtual int CopyPixels(FBitmap *bmp);
virtual TArray<uint8_t> GetPalettedPixels(int conversion); // 'noremap0' will only be looked at by FPatchTexture and forwarded by FMultipatchTexture.
virtual int CopyPixels(FBitmap *bmp, int conversion); // This will always ignore 'luminance'.
int CopyTranslatedPixels(FBitmap *bmp, PalEntry *remap);
// Conversion option

6
src/textures/imagetexture.cpp
View file

@ -49,7 +49,7 @@
//==========================================================================
FImageTexture::FImageTexture(FImageSource *img, const char *name)
: FWorldTexture(name, img->LumpNum())
: FTexture(name, img->LumpNum())
{
mImage = img;
Wads.GetLumpName (Name, img->LumpNum());
@ -72,7 +72,7 @@ FImageTexture::FImageTexture(FImageSource *img, const char *name)
int FImageTexture::CopyPixels(FBitmap *bmp)
{
return mImage->CopyPixels(bmp);
return mImage->CopyPixels(bmp, bNoRemap0? FImageSource::noremap0 : FImageSource::normal);
}
//===========================================================================
@ -83,7 +83,7 @@ int FImageTexture::CopyPixels(FBitmap *bmp)
TArray<uint8_t> FImageTexture::Get8BitPixels(bool alpha)
{
return mImage->Get8BitPixels(alpha);
return mImage->GetPalettedPixels(alpha? alpha : bNoRemap0 ? FImageSource::noremap0 : FImageSource::normal);
}
//===========================================================================