SLADE Discussion - Latest: v3.2.5 (19/Dec/2023)

[Pandut]

Try to rename or delete the existing config files and see if it runs better. If it does you can try to compare the old config files with the new to try to find which line causes the problem.

Hmm neither renaming or deleting didn't seem to do anything. I still see the loading icon as if it's trying to open SLADE but then it just stops and only appears in Task Manager.

EDIT: I've defaulted to a previous version and it's running without any issues so it's likely just something herpyderpy with the new version.

[MaxED]

Can we have a bit more descriptive error messages?
I'm trying to write my own little FON2 maker. Something is definitely not right with it, cause Slade 3.1.0.4 displays me these helpful messages when I try to view the attached font generated by it:

sladee1.jpg (8.56 KiB) Viewed 1991 times

sladee2.jpg (9.87 KiB) Viewed 1991 times

[Gez]

You're getting an overflow. The RLE decoding continues past the end of the lump. The problem seems to originate from wrong character width data. Perhaps an endianness confusion, or an offset off by one? It aborts on the second character, trying to read 47872 pixels to fill a 2816x17 image. 2816 is 0x0B00, and I suppose the real value should be 0x000B to get a 17x17 image.

[MaxED]

Ugh... Can you provide some information about RLE algorithm used? Because either I'm doing something wrong, or it doesn't match the one wiki describes...

[Gez]

Here's the code used in SLADE, with some actual error messages added, and the temporary DPrintf line added to log some info to the console:

---

Code: Select all

bool SImage::loadFont2(const uint8_t* gfx_data, int size)
{
	// Clear current data if it exists
	clearData();

	// Initializes some stuff
	offset_x = offset_y = 0;
	has_palette = true;
	type = PALMASK;
	format = NULL;

	// Technically each character is its own image, though.
	numimages = 1;
	imgindex = 0;

	if (size < sizeof(Font2Header))
	{
		Global::error = "Entry too small (size lesser than FON2 header)";
		return false;
	}

	const Font2Header* header = (Font2Header*) gfx_data;
	width = 0;
	height = wxUINT16_SWAP_ON_BE(header->charheight);

	// We can't deal with a null height, of course
	if (height == 0)
	{
		Global::error = "FON2 entry with null height";
		return false;
	}

	const uint8_t* p = gfx_data + sizeof(Font2Header);

	// Skip kerning information which do not concern us.
	if (header->kerning)
		p+=2;

	// Start building the character table.
	size_t numchars = header->lastc - header->firstc +1;
	Font2Char* chars = new Font2Char[numchars];
	for (size_t i = 0; i < numchars; ++i)
	{
		chars[i].width = wxUINT16_SWAP_ON_BE(*(uint16_t*)p);
		// Let's increase the total width
		width+=chars[i].width;
		// The width information is enumerated for each character only if they are
		// not constant width. Regardless, move the read pointer away after the last.
		if (!(header->constantw) || (i == numchars - 1))
			p+=2;
	}

	// Let's build the palette now.
	for (size_t i = 0; i < header->palsize + 1u; ++i)
	{
		rgba_t color;
		color.r = *p++;
		color.g = *p++;
		color.b = *p++;
		palette.setColour(i, color);
	}

	// 0 is transparent, last is border color, the rest of the palette entries should
	// be increasingly bright
	palette.setTransIndex(0);

	// Clear current data if it exists
	clearData();

	// The picture data follows, using the same RLE as FON1 and IMGZ.
	for (size_t i = 0; i < numchars; ++i)
	{
		// A big font is not necessarily continuous; several characters
		// may be skipped; they are given a width of 0.
		if (chars[i].width)
		{
			size_t numpixels = chars[i].width * height;
			chars[i].data = new uint8_t[numpixels];
			uint8_t* d = chars[i].data;
			uint8_t code = 0; size_t length = 0;
			DPrintf("Char %i: %ix%i, %i pixels", i, chars[i].width, height, numpixels); 

			while (numpixels)
			{
				code = *p++;
				if (p >= gfx_data + size)
				{
					Global::error = S_FMT("End of entry reached, %d pixels remain unpainted for character %i", numpixels, i);
					return false;
				}
				if (code < 0x80)
				{
					length = code + 1;
					// Overflows shouldn't happen
					if (length > numpixels)
					{
						Global::error = S_FMT("RLE overflow at offset %u (code %02X, length %u, remaining pixels %u", p - gfx_data, code, length, numpixels);
						return false;
					}
					memcpy(d, p, length);
					d+=length;
					p+=length;
					numpixels -= length;
				}
				else if (code > 0x80)
				{
					length = 0x101 - code;
					// Overflows shouldn't happen
					if (length > numpixels)
					{
						Global::error = S_FMT("RLE overflow at offset %u (code %02X, length %u, remaining pixels %u", p - gfx_data, code, length, numpixels);
						return false;
					}
					code = *p++;
					memset(d, code, length);
					d+=length;
					numpixels -= length;
				}
			}
		}
	}

	// Now let's assemble all characters together in a single picture.
	if (!width)
	{
		Global::error = "FON2 entry with null width";
		return false;
	}

	// Clear current data if it exists
	clearData();

	data = new uint8_t[width*height];
	uint8_t* d = data;
	for (size_t i = 0; i < (unsigned)height; ++i)
	{
		for (size_t j = 0; j < numchars; ++j)
		{
			if (chars[j].width)
			{
				memcpy(d, chars[j].data+(i*chars[j].width), chars[j].width);
				d+=chars[j].width;
			}
		}
	}

	// Clean up the characters once the big picture is finished
	for (size_t i = 0; i < numchars; ++i)
	{
		if (chars[i].data)
			delete[] chars[i].data;
	}
	delete[] chars;

	// Now transparency for the mask
	mask = new uint8_t[width*height];
	memset(mask, 0xFF, width*height);
	for (size_t i = 0; i < (unsigned)(width*height); ++i)
		if (data[i] == 0)
			mask[i] = 0;

	// Announce change and return success
	announce("image_changed");
	return true;
}

If I change the code to read character widths as big endian, then it still fails to load, so it's not the only problem.

Also, [wiki]ImageTool[/wiki]'s source code can no longer be found, but I had downloaded it a long while ago so here's font.c from it:

---

Code: Select all

/*
** font.c
** Routines for producing FON1 and FON2 files.
**
**---------------------------------------------------------------------------
** Copyright 2001 Randy Heit
** 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 "afx.h"

#define FONT_BORDER		255

typedef struct
{
	UWORD x, y, w;
} CharRect;

static int compare (const void *arg1, const void *arg2);

FontHeader Font;
char *FontName;
UBYTE FontPalette[768];
CharRect Chars[256];
int FontWidth, FontHeight, FontPitch;
UBYTE *FontBitmap;
UBYTE Font255Remap;

void StartFont (const char *fontname, UBYTE *data, int width, int height,
				int srcwidth, UBYTE palette[768])
{
	UBYTE used[256];
	UBYTE remap[256], unmap[256];
	int x, y;
	UBYTE color255;
	int color255best;

	// Set up font book keeping
	memset (&Font, 0, sizeof(Font));
	memset (Chars, 0, sizeof(Chars));
	memcpy (FontPalette, palette, 768);
	FontName = strdup (fontname);
	FontWidth = srcwidth;
	FontPitch = width;
	FontHeight = height;
	FontBitmap = data;
	Font.FirstChar = 255;

	// Find out which of the image's colors are actually used
	memset (used, 0, 256);
	for (y = 0; y < height; ++y)
	{
		UBYTE *colors = data + y*width;
		for (x = 0; x < srcwidth; ++x)
		{
			used[*colors++] = 1;
		}
	}

	// Move those colors to the front of the palette.
	// Color 0 is left alone, because it is the transparent color.
	// Also leave 255 alone, because it is the glyph delimiter.
	memset (remap, 0, 256);
	memset (unmap, 0, 256);
	remap[255] = 255;
	used[0] = 1;
	for (x = y = 0; x < 255; ++x)
	{
		if (used[x])
		{
			remap[x] = y;
			unmap[y] = x;
			y++;
		}
	}

	// Sort the palette by increasing brightness
	Font.PaletteSize = y;
	qsort (unmap+1, y-1, 1, compare);
	color255 = 0;
	color255best = 256*256*4;
	for (x = 1; x < y; ++x)
	{
		int dist, rd, gd, bd;

		remap[unmap[x]] = x;
		rd = FontPalette[x*3  ] = palette[unmap[x]*3  ];
		gd = FontPalette[x*3+1] = palette[unmap[x]*3+1];
		bd = FontPalette[x*3+2] = palette[unmap[x]*3+2];

		rd -= palette[255*3  ];
		gd -= palette[255*3+1];
		bd -= palette[255*3+2];

		dist = rd*rd + gd*gd + bd*bd;
		if (dist < color255best)
		{
			color255best = dist;
			color255 = x;
		}
	}

	// Fix fonts that include palette entry 255 within
	// a glyph's bounding box.
	Font255Remap = color255;

	// Now remap the source image to use the new colors.
	for (y = 0; y < height; ++y)
	{
		UBYTE *colors = data + y*width;
		for (x = 0; x < srcwidth; ++x)
		{
			colors[x] = remap[colors[x]];
		}
	}
}

void GrabFont (int xl, int yl, int firstchar)
{
	int glyph = firstchar;
	int x, y, r, h;

	// Skip top and left box line
	yl++;
	xl++;

	for (y = yl; y < FontHeight; )
	{
		for (x = xl; x < FontWidth; )
		{
			if (glyph < 0 || glyph > 255)
			{
				fprintf (stderr, "%s has glyphs out of range\n", FontName);
				return;
			}

			if (FontBitmap[x+y*FontPitch] == FONT_BORDER)
			{ // Character is empty, so skip it
				glyph++;
				x++;
				continue;
			}

			// Determine glyph height
			for (r = y+1; r < FontHeight; ++r)
			{
				if (FontBitmap[x+r*FontPitch] == FONT_BORDER)
					break;
			}
			if (Font.FontHeight == 0)
			{
				if (r - y == 0)
				{
					fprintf (stderr, "Font has 0 height!\n");
					return;
				}
				Font.FontHeight = h = r - y;
			}
			else
			{
				h = r - y;
			}

			// Determine glyph width
			for (r = x+1; r < FontWidth; ++r)
			{
				if (FontBitmap[r+y*FontPitch] == FONT_BORDER)
					break;
			}

			if (FontBitmap[r-1+(y-1)*FontPitch] != FONT_BORDER)
			{ // If the top border was not present, skip to the next row
				break;
			}

			if (Font.FontHeight != h)
			{
				fprintf (stderr, "Char #%d (%c) has height %d instead of %d\n",
					glyph, glyph, h, Font.FontHeight);
				return;
			}

			// Store glyph position and size
			Chars[glyph].x = x;
			Chars[glyph].y = y;
			Chars[glyph].w = r-x;

			glyph++;
			x = r + 1;
		}
		// Advance to next row of image
		y += Font.FontHeight + 1;
		x = xl;
	}

	glyph--;

	if (glyph >= firstchar)
	{
		if (firstchar < Font.FirstChar)
		{
			Font.FirstChar = firstchar;
		}
		if (glyph > Font.LastChar)
		{
			Font.LastChar = glyph;
		}
	}
}

bool EndFont (void)
{
	BYTE *PackBytes;
	FILE *f;
	UWORD swizzle;
	int i;
	int totalwidth;

	if (Font.FirstChar > Font.LastChar)
	{
		GrabFont (0, 0, ' ');
		if (Font.FirstChar > Font.LastChar || Font.PaletteSize == 0)
		{
			fprintf (stderr, "%s: Nothing to save\n", FontName);
			free (FontName);
			return true;
		}
	}

	f = fopen (FontName, "wb");
	if (f == NULL)
	{
		fprintf (stderr, "Could not open %s\n", FontName);
		free (FontName);
		return true;
	}

	PackBytes = malloc (FontWidth * FontHeight);
	if (PackBytes == NULL)
	{
		fprintf (stderr, "Out of memory\n");
		free (FontName);
		fclose (f);
		return true;
	}

	Font.bConstantWidth = 1;

	for (i = Font.FirstChar+1; i <= Font.LastChar; ++i)
	{
		if (Chars[Font.FirstChar].w != Chars[i].w)
		{
			Font.bConstantWidth = 0;
			break;
		}
	}

	fwrite ("FON2", 4, 1, f);
	swizzle = LittleShort (Font.FontHeight);
	fwrite (&swizzle, 2, 1, f);
	fwrite (&Font.FirstChar, 1, 6, f);
	if (Font.bConstantWidth)
	{
		swizzle = LittleShort (Chars[Font.FirstChar].w);
		fwrite (&swizzle, 2, 1, f);
	}
	else
	{
		for (i = Font.FirstChar; i <= Font.LastChar; ++i)
		{
			swizzle = LittleShort (Chars[i].w);
			fwrite (&swizzle, 2, 1, f);
		}
	}

	fwrite (FontPalette, 3, Font.PaletteSize, f);

	// Write out the color of the delimiter (color 255) so that the source
	// image can be reconstructed with all used colors intact. This color
	// is not included in the PaletteSize count in the header.
	fwrite (FontPalette+255*3, 3, 1, f);

	totalwidth = 0;
	for (i = Font.FirstChar; i <= Font.LastChar; ++i)
	{
		if (Chars[i].w)
		{
			int y;
			UBYTE *glyph = FontBitmap + Chars[i].x + Chars[i].y*FontPitch;
			BYTE *pack_p = PackBytes;
			
			for (y = 0; y < Font.FontHeight; ++y)
			{
				int x;
				for (x = 0; x < Chars[i].w; ++x)
				{
					pack_p[x] = glyph[x] != 255 ? glyph[x] : Font255Remap;
				}
				pack_p += Chars[i].w;
				glyph += FontPitch;
			}
			pack_p = PackBytes;
			packrow (&pack_p, f, Chars[i].w*y);
			totalwidth += Chars[i].w;
		}
	}

	printf ("%s: %d pixels of font glyphs stored\n", FontName, totalwidth * Font.FontHeight);

	free (PackBytes);
	free (FontName);
	fclose (f);

	return false;
}

void SetFontShading (ShadeType shade)
{
	Font.ShadingType = shade;
}

static int compare (const void *arg1, const void *arg2)
{
	if (FontPalette[*((UBYTE *)arg1)*3  ] * 299 +
		FontPalette[*((UBYTE *)arg1)*3+1] * 587 +
		FontPalette[*((UBYTE *)arg1)*3+2] * 114  <
		FontPalette[*((UBYTE *)arg2)*3  ] * 299 +
		FontPalette[*((UBYTE *)arg2)*3+1] * 587 +
		FontPalette[*((UBYTE *)arg2)*3+2] * 114)
		return -1;
	else
		return 1;
}

int WriteConFont (const char *name, UBYTE *data, int width, int height, int srcwidth)
{
	int charwidth = srcwidth / 16;
	int charheight = height / 16;
	int x, y;
	BYTE *shifted = malloc (srcwidth * height);
	BYTE *shift_p;
	FILE *f;

	if (shifted == NULL)
	{
		printf ("out of memory\n");
		return 1;
	}

	shift_p = shifted;
	for (x = 0; x < 256; x++)
	{
		UBYTE *offset = data + (x>>4)*charheight*width + (x&15)*charwidth;
		for (y = 0; y < charheight; y++)
		{
			memcpy (shift_p, offset, charwidth);
			shift_p += charwidth;
			offset += width;
		}
	}

	f = fopen (name, "wb");
	if (f == NULL)
	{
		printf ("could not open %s\n", name);
		return 1;
	}

	fwrite ("FON1", 1, 4, f);
	charwidth = LittleShort(charwidth);
	fwrite (&charwidth, 2, 1, f);
	charwidth = LittleShort(charwidth);
	charheight = LittleShort(charheight);
	fwrite (&charheight, 2, 1, f);
	charheight = LittleShort(charheight);
	shift_p = shifted;
	for (x = 0; x < 256; x++)
	{
		packrow (&shift_p, f, charwidth*charheight);
	}
	fclose (f);
	free (shifted);
	return 0;
}

[Kappes Buur]

Also, [wiki]ImageTool[/wiki]'s source code can no longer be found, ...

Isn't that the source code?
http://zdoom.org/files/utils/

[Gez]

Looks like it is, thanks.

[Hindsight2020]

Among many issues I've been having with 3.1.0.4 I've been most frustrated with the following:

-Why can't I make my .wad / .pk3 open with Slade by default? It was working just fine with Slade 3.0.2... When I updated it installed In a new folder and I had 2 instances of Slade installed. Lacking an uninstall option for v3.0.2 I just deleted it. When I use "open with" and attemp to select the new Slade3 it won't even recognize it and allow me to set it.

-At random times when I open Slade3 it runs me thru the initial setup and all of my preferences are gone. I've had to do this multiple times.

Please help. I love some of the new features I've been able to use, but I've resorted back to v3.0.2 for the time being.

[Kinsie]

Sometimes, whenever I import a 256-colour PNG and adjust the offsets, it loses all the transparency data. It will always effect that specific image forever. If I make adjustments and reimport, it will still mess up once I edit the offsets. 99% of images are fine, but the 1% are the ones I always need.

Any ideas? This has been affecting me for literal years, but this can't just be affecting me...?

[Gez]

Can you upload some of these pictures, then?

[Kinsie]

The first image imports just fine. The second breaks once offsets are added.

[Eevee]

Can you upload the images to a non-image host, so you know for sure that they aren't being re-encoded? I suspect this might be a problem with PNGs that use indexed color but 8-bit transparency — it's an uncommon combination and I've seen tools choke on it before.

[Tekmon_Xonic]

I believe I have a very crippling bug to report in the latest version of Slade.

I was in the middle of rearranging my doom mod folder with Slade still open, and I had moved around Slade .bak files as well. Now it seems that every time I save a wad or PK3 I'm working on, all files are overwritten with the files of another mod I was working on previously. Which happened to be Brutal Doom.

I believe that Slade is in a glitched state, and is overwriting all the files on mods I'm working with a temporary .bak file from one of the files when I save any progress while I have slade open while rearranging mods. I'm going to try and see if I can fix it, but I thought it would be a good idea to give you a heads up in the process.

////////////////
// !!!Update!!! //
///////////////

I got Slade Working again. I remove all of the .bak files I had lying around, I uninstalled slade, deleted the SLADE3 folder in appdata/roaming, and now mods save properly.

I don't know what happened, but I'm glad its fixed. Still, keep this post for reference. This may be a bug that needs fixed.

[Kinsie]

Can you upload the images to a non-image host, so you know for sure that they aren't being re-encoded? I suspect this might be a problem with PNGs that use indexed color but 8-bit transparency — it's an uncommon combination and I've seen tools choke on it before.

https://dl.dropboxusercontent.com/u/258 ... HWEPA0.png
https://dl.dropboxusercontent.com/u/258 ... HWEPB0.png

I'm just using the Indexed Color and Save For Web > PNG-8 settings in Photoshop.

[Hindsight2020]

FEATURE REQUEST

Is it possible (or would it be possible) to view all textures in a grid format like the DB2/GZDB texture selector?

It'd be nice to see all the textures at once instead of scrolling thru them so its easier to find what you're looking for when the name of the textures are numbered instead of descriptive. I'm currently looking thru the Counterstrike texture pack(http://realm667.com/index.php/en/textur ... e-textures) to decide what I need, but there are thousands of textures (amazing textures, btw) and none are descriptively named. So I have to scroll thru each one individually to know what it is.

Thanks!