fix merge conflicts texturehashing

port of https://git.do.srb2.org/STJr/SRB2/-/merge_requests/1725#c829d21709a4f5cd81d140271e883bc40dd00b1b

src/md5.c

@@ -1,6 +1,6 @@
 // SONIC ROBO BLAST 2
 //-----------------------------------------------------------------------------
-// Copyright (C) 1995-2025 by the Free Software Foundation, Inc.
+// Copyright (C) 1995-1996 by the Free Software Foundation, Inc.
 //
 // This program is free software distributed under the
 // terms of the GNU General Public License, version 2.
@@ -33,7 +33,7 @@
 #include "endian.h"
 
 #if defined (SRB2_BIG_ENDIAN)
- #define SWAP(n) \
+ #define SWAP(n)							\
     (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
 #else
  #define SWAP(n) (n)
@@ -46,31 +46,27 @@ static const unsigned char fillbuf[64] = { 0x80, 0 /*, 0, 0, ...  */ };
 /* Structure to save state of computation between the single steps.  */
 struct md5_ctx
 {
-	md5_uint32 A;
-	md5_uint32 B;
-	md5_uint32 C;
-	md5_uint32 D;
+  md5_uint32 A;
+  md5_uint32 B;
+  md5_uint32 C;
+  md5_uint32 D;
 
-	md5_uint32 total[2];
-	md5_uint32 buflen;
-	union
-	{
-		char buffer[128];
-		md5_uint32 buffer32[32];
-	};
+  md5_uint32 total[2];
+  md5_uint32 buflen;
+  char buffer[128];
 };
 
 /* Initialize structure containing state of computation.
    (RFC 1321, 3.3: Step 3)  */
-static void md5_init_ctx(struct md5_ctx *ctx)
+static void md5_init_ctx (struct md5_ctx *ctx)
 {
-	ctx->A = 0x67452301;
-	ctx->B = 0xefcdab89;
-	ctx->C = 0x98badcfe;
-	ctx->D = 0x10325476;
+  ctx->A = 0x67452301;
+  ctx->B = 0xefcdab89;
+  ctx->C = 0x98badcfe;
+  ctx->D = 0x10325476;
 
-	ctx->total[0] = ctx->total[1] = 0;
-	ctx->buflen = 0;
+  ctx->total[0] = ctx->total[1] = 0;
+  ctx->buflen = 0;
 }
 
 /* Put result from CTX in first 16 bytes following RESBUF.  The result
@@ -78,14 +74,14 @@ static void md5_init_ctx(struct md5_ctx *ctx)
 
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
-static void *md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
+static void *md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
 {
-	((md5_uint32 *) resbuf)[0] = SWAP(ctx->A);
-	((md5_uint32 *) resbuf)[1] = SWAP(ctx->B);
-	((md5_uint32 *) resbuf)[2] = SWAP(ctx->C);
-	((md5_uint32 *) resbuf)[3] = SWAP(ctx->D);
+  ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
+  ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
+  ((md5_uint32 *) resbuf)[2] = SWAP (ctx->C);
+  ((md5_uint32 *) resbuf)[3] = SWAP (ctx->D);
 
-	return resbuf;
+  return resbuf;
 }
 
 /* These are the four functions used in the four steps of the MD5 algorithm
@@ -100,215 +96,200 @@ static void *md5_read_ctx(const struct md5_ctx *ctx, void *resbuf)
 /* Process LEN bytes of BUFFER, accumulating context into CTX.
    It is assumed that LEN % 64 == 0.  */
 
-static void md5_process_block(const void *buffer, size_t len, struct md5_ctx *ctx)
+static void md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
 {
-	md5_uint32 correct_words[16];
-	const md5_uint32 *words = buffer;
-	size_t nwords = len / sizeof (md5_uint32);
-	const md5_uint32 *endp = words + nwords;
-	md5_uint32 A = ctx->A;
-	md5_uint32 B = ctx->B;
-	md5_uint32 C = ctx->C;
-	md5_uint32 D = ctx->D;
-	md5_uint32 lolen = len;
+  md5_uint32 correct_words[16];
+  const md5_uint32 *words = buffer;
+  size_t nwords = len / sizeof (md5_uint32);
+  const md5_uint32 *endp = words + nwords;
+  md5_uint32 A = ctx->A;
+  md5_uint32 B = ctx->B;
+  md5_uint32 C = ctx->C;
+  md5_uint32 D = ctx->D;
 
-	/* First increment the byte count.  RFC 1321 specifies the possible
-	length of the file up to 2^64 bits.  Here we only compute the
-	number of bytes.  Do a double word increment.  */
-	ctx->total[0] += lolen;
-	ctx->total[1] += (len >> 31 >> 1) + (ctx->total[0] < lolen);
+  /* First increment the byte count.  RFC 1321 specifies the possible
+     length of the file up to 2^64 bits.  Here we only compute the
+     number of bytes.  Do a double word increment.  */
+  ctx->total[0] = (md5_uint32)(len+ctx->total[0]);
+  if (ctx->total[0] < len)
+    ++ctx->total[1];
 
-	/* Process all bytes in the buffer with 64 bytes in each round of
-	the loop.  */
-	while (words < endp)
-	{
-		md5_uint32 *cwp = correct_words;
-		md5_uint32 A_save = A;
-		md5_uint32 B_save = B;
-		md5_uint32 C_save = C;
-		md5_uint32 D_save = D;
+  /* Process all bytes in the buffer with 64 bytes in each round of
+     the loop.  */
+  while (words < endp)
+    {
+      md5_uint32 *cwp = correct_words;
+      md5_uint32 A_save = A;
+      md5_uint32 B_save = B;
+      md5_uint32 C_save = C;
+      md5_uint32 D_save = D;
 
-		/* First round: using the given function, the context and a constant
-		the next context is computed.  Because the algorithms processing
-		unit is a 32-bit word and it is determined to work on words in
-		little endian byte order we perhaps have to change the byte order
-		before the computation.  To reduce the work for the next steps
-		we store the swapped words in the array CORRECT_WORDS.  */
+      /* First round: using the given function, the context and a constant
+	 the next context is computed.  Because the algorithms processing
+	 unit is a 32-bit word and it is determined to work on words in
+	 little endian byte order we perhaps have to change the byte order
+	 before the computation.  To reduce the work for the next steps
+	 we store the swapped words in the array CORRECT_WORDS.  */
 
-#define OP(a, b, c, d, s, T)									\
-		do														\
-		{														\
-			a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;	\
-			++words;											\
-			CYCLIC (a, s);										\
-			a += b;												\
-		}														\
-		while (0)
+#define OP(a, b, c, d, s, T)						\
+      do								\
+        {								\
+	  a += FF (b, c, d) + (*cwp++ = SWAP (*words)) + T;		\
+	  ++words;							\
+	  CYCLIC (a, s);						\
+	  a += b;							\
+        }								\
+      while (0)
 
-		/* It is unfortunate that C does not provide an operator for
-		cyclic rotation.  Hope the C compiler is smart enough.  */
+      /* It is unfortunate that C does not provide an operator for
+	 cyclic rotation.  Hope the C compiler is smart enough.  */
 #define CYCLIC(w, s) (w = (w << s) | (w >> (32 - s)))
 
-		/* Before we start, one word to the strange constants.
-		They are defined in RFC 1321 as
+      /* Before we start, one word to the strange constants.
+	 They are defined in RFC 1321 as
 
-		T[i] = (int) (4294967296.0 * fabs (sin (i))), i=1..64
-		*/
+	 T[i] = (int) (4294967296.0 * fabs (sin (i))), i = 1..64
+       */
 
-		/* Round 1.  */
-		OP (A, B, C, D,  7, 0xd76aa478);
-		OP (D, A, B, C, 12, 0xe8c7b756);
-		OP (C, D, A, B, 17, 0x242070db);
-		OP (B, C, D, A, 22, 0xc1bdceee);
-		OP (A, B, C, D,  7, 0xf57c0faf);
-		OP (D, A, B, C, 12, 0x4787c62a);
-		OP (C, D, A, B, 17, 0xa8304613);
-		OP (B, C, D, A, 22, 0xfd469501);
-		OP (A, B, C, D,  7, 0x698098d8);
-		OP (D, A, B, C, 12, 0x8b44f7af);
-		OP (C, D, A, B, 17, 0xffff5bb1);
-		OP (B, C, D, A, 22, 0x895cd7be);
-		OP (A, B, C, D,  7, 0x6b901122);
-		OP (D, A, B, C, 12, 0xfd987193);
-		OP (C, D, A, B, 17, 0xa679438e);
-		OP (B, C, D, A, 22, 0x49b40821);
+      /* Round 1.  */
+      OP (A, B, C, D,  7, 0xd76aa478);
+      OP (D, A, B, C, 12, 0xe8c7b756);
+      OP (C, D, A, B, 17, 0x242070db);
+      OP (B, C, D, A, 22, 0xc1bdceee);
+      OP (A, B, C, D,  7, 0xf57c0faf);
+      OP (D, A, B, C, 12, 0x4787c62a);
+      OP (C, D, A, B, 17, 0xa8304613);
+      OP (B, C, D, A, 22, 0xfd469501);
+      OP (A, B, C, D,  7, 0x698098d8);
+      OP (D, A, B, C, 12, 0x8b44f7af);
+      OP (C, D, A, B, 17, 0xffff5bb1);
+      OP (B, C, D, A, 22, 0x895cd7be);
+      OP (A, B, C, D,  7, 0x6b901122);
+      OP (D, A, B, C, 12, 0xfd987193);
+      OP (C, D, A, B, 17, 0xa679438e);
+      OP (B, C, D, A, 22, 0x49b40821);
 
-		/* For the second to fourth round we have the possibly swapped words
-		in CORRECT_WORDS.  Redefine the macro to take an additional first
-		argument specifying the function to use.  */
+      /* For the second to fourth round we have the possibly swapped words
+	 in CORRECT_WORDS.  Redefine the macro to take an additional first
+	 argument specifying the function to use.  */
 #undef OP
-#define OP(f, a, b, c, d, k, s, T)						\
-		do												\
-		{												\
-			a += f (b, c, d) + correct_words[k] + T;	\
-			CYCLIC (a, s);								\
-			a += b;										\
-		}												\
-		while (0)
+#define OP(f, a, b, c, d, k, s, T)               \
+	do                                           \
+	{                                            \
+		a += f (b, c, d) + correct_words[k] + T; \
+		CYCLIC (a, s);                           \
+		a += b;                                  \
+	}                                            \
+      while (0)
 
-		/* Round 2.  */
-		OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
-		OP (FG, D, A, B, C,  6,  9, 0xc040b340);
-		OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
-		OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
-		OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
-		OP (FG, D, A, B, C, 10,  9, 0x02441453);
-		OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
-		OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
-		OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
-		OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
-		OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
-		OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
-		OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
-		OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
-		OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
-		OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
+      /* Round 2.  */
+      OP (FG, A, B, C, D,  1,  5, 0xf61e2562);
+      OP (FG, D, A, B, C,  6,  9, 0xc040b340);
+      OP (FG, C, D, A, B, 11, 14, 0x265e5a51);
+      OP (FG, B, C, D, A,  0, 20, 0xe9b6c7aa);
+      OP (FG, A, B, C, D,  5,  5, 0xd62f105d);
+      OP (FG, D, A, B, C, 10,  9, 0x02441453);
+      OP (FG, C, D, A, B, 15, 14, 0xd8a1e681);
+      OP (FG, B, C, D, A,  4, 20, 0xe7d3fbc8);
+      OP (FG, A, B, C, D,  9,  5, 0x21e1cde6);
+      OP (FG, D, A, B, C, 14,  9, 0xc33707d6);
+      OP (FG, C, D, A, B,  3, 14, 0xf4d50d87);
+      OP (FG, B, C, D, A,  8, 20, 0x455a14ed);
+      OP (FG, A, B, C, D, 13,  5, 0xa9e3e905);
+      OP (FG, D, A, B, C,  2,  9, 0xfcefa3f8);
+      OP (FG, C, D, A, B,  7, 14, 0x676f02d9);
+      OP (FG, B, C, D, A, 12, 20, 0x8d2a4c8a);
 
-		/* Round 3.  */
-		OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
-		OP (FH, D, A, B, C,  8, 11, 0x8771f681);
-		OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
-		OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
-		OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
-		OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
-		OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
-		OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
-		OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
-		OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
-		OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
-		OP (FH, B, C, D, A,  6, 23, 0x04881d05);
-		OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
-		OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
-		OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
-		OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
+      /* Round 3.  */
+      OP (FH, A, B, C, D,  5,  4, 0xfffa3942);
+      OP (FH, D, A, B, C,  8, 11, 0x8771f681);
+      OP (FH, C, D, A, B, 11, 16, 0x6d9d6122);
+      OP (FH, B, C, D, A, 14, 23, 0xfde5380c);
+      OP (FH, A, B, C, D,  1,  4, 0xa4beea44);
+      OP (FH, D, A, B, C,  4, 11, 0x4bdecfa9);
+      OP (FH, C, D, A, B,  7, 16, 0xf6bb4b60);
+      OP (FH, B, C, D, A, 10, 23, 0xbebfbc70);
+      OP (FH, A, B, C, D, 13,  4, 0x289b7ec6);
+      OP (FH, D, A, B, C,  0, 11, 0xeaa127fa);
+      OP (FH, C, D, A, B,  3, 16, 0xd4ef3085);
+      OP (FH, B, C, D, A,  6, 23, 0x04881d05);
+      OP (FH, A, B, C, D,  9,  4, 0xd9d4d039);
+      OP (FH, D, A, B, C, 12, 11, 0xe6db99e5);
+      OP (FH, C, D, A, B, 15, 16, 0x1fa27cf8);
+      OP (FH, B, C, D, A,  2, 23, 0xc4ac5665);
 
-		/* Round 4.  */
-		OP (FI, A, B, C, D,  0,  6, 0xf4292244);
-		OP (FI, D, A, B, C,  7, 10, 0x432aff97);
-		OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
-		OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
-		OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
-		OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
-		OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
-		OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
-		OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
-		OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
-		OP (FI, C, D, A, B,  6, 15, 0xa3014314);
-		OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
-		OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
-		OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
-		OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
-		OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
+      /* Round 4.  */
+      OP (FI, A, B, C, D,  0,  6, 0xf4292244);
+      OP (FI, D, A, B, C,  7, 10, 0x432aff97);
+      OP (FI, C, D, A, B, 14, 15, 0xab9423a7);
+      OP (FI, B, C, D, A,  5, 21, 0xfc93a039);
+      OP (FI, A, B, C, D, 12,  6, 0x655b59c3);
+      OP (FI, D, A, B, C,  3, 10, 0x8f0ccc92);
+      OP (FI, C, D, A, B, 10, 15, 0xffeff47d);
+      OP (FI, B, C, D, A,  1, 21, 0x85845dd1);
+      OP (FI, A, B, C, D,  8,  6, 0x6fa87e4f);
+      OP (FI, D, A, B, C, 15, 10, 0xfe2ce6e0);
+      OP (FI, C, D, A, B,  6, 15, 0xa3014314);
+      OP (FI, B, C, D, A, 13, 21, 0x4e0811a1);
+      OP (FI, A, B, C, D,  4,  6, 0xf7537e82);
+      OP (FI, D, A, B, C, 11, 10, 0xbd3af235);
+      OP (FI, C, D, A, B,  2, 15, 0x2ad7d2bb);
+      OP (FI, B, C, D, A,  9, 21, 0xeb86d391);
 
-		/* Add the starting values of the context.  */
-		A += A_save;
-		B += B_save;
-		C += C_save;
-		D += D_save;
-	}
+      /* Add the starting values of the context.  */
+      A += A_save;
+      B += B_save;
+      C += C_save;
+      D += D_save;
+    }
 
-	/* Put checksum in context given as argument.  */
-	ctx->A = A;
-	ctx->B = B;
-	ctx->C = C;
-	ctx->D = D;
+  /* Put checksum in context given as argument.  */
+  ctx->A = A;
+  ctx->B = B;
+  ctx->C = C;
+  ctx->D = D;
 }
 
 
-static void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ctx)
+static void md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
 {
-	/* When we already have some bits in our internal buffer concatenate
-	*    both inputs first.  */
-	if (ctx->buflen != 0)
+  /* When we already have some bits in our internal buffer concatenate
+     both inputs first.  */
+  if (ctx->buflen != 0)
+    {
+      size_t left_over = ctx->buflen;
+      size_t add = 128 - left_over > len ? len : 128 - left_over;
+
+      memcpy (&ctx->buffer[left_over], buffer, add);
+      ctx->buflen = (md5_uint32)(add+ctx->buflen);
+
+      if (left_over + add > 64)
 	{
-		size_t left_over = ctx->buflen;
-		size_t add = 128 - left_over > len ? len : 128 - left_over;
-
-		memcpy (&ctx->buffer[left_over], buffer, add);
-		ctx->buflen += add;
-
-		if (ctx->buflen > 64)
-		{
-			md5_process_block(ctx->buffer, ctx->buflen & ~63, ctx);
-
-			ctx->buflen &= 63;
-			/* The regions in the following copy operation cannot overlap.  */
-			memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
-					ctx->buflen);
-		}
-
-		buffer = (const char *) buffer + add;
-		len -= add;
+	  md5_process_block (ctx->buffer, (left_over + add) & ~63, ctx);
+	  /* The regions in the following copy operation cannot overlap.  */
+	  memcpy (ctx->buffer, &ctx->buffer[(left_over + add) & ~63],
+		  (left_over + add) & 63);
+	  ctx->buflen = (md5_uint32)((left_over + add) & 63);
 	}
 
-	/* Process available complete blocks.  */
-	if (len >= 64)
-	{
-		while (len > 64)
-		{
-			md5_process_block(memcpy(ctx->buffer, buffer, 64), 64, ctx);
-			buffer = (const char *) buffer + 64;
-			len -= 64;
-		}
-	}
+      buffer = (const char *) buffer + add;
+      len -= add;
+    }
 
-	/* Move remaining bytes in internal buffer.  */
-	if (len > 0)
-	{
-		size_t left_over = ctx->buflen;
+  /* Process available complete blocks.  */
+  if (len > 64)
+    {
+      md5_process_block (buffer, len & ~63, ctx);
+      buffer = (const char *) buffer + (len & ~63);
+      len &= 63;
+    }
 
-		memcpy(&ctx->buffer[left_over], buffer, len);
-		left_over += len;
-
-		if (left_over >= 64)
-		{
-			md5_process_block (ctx->buffer, 64, ctx);
-			left_over -= 64;
-			memcpy(ctx->buffer, &ctx->buffer[64], left_over);
-		}
-
-		ctx->buflen = left_over;
-	}
+  /* Move remaining bytes in internal buffer.  */
+  if (len > 0)
+    {
+      memcpy (ctx->buffer, buffer, len);
+      ctx->buflen = (md5_uint32)len;
+    }
 }
 
 
@@ -317,98 +298,100 @@ static void md5_process_bytes(const void *buffer, size_t len, struct md5_ctx *ct
 
    IMPORTANT: On some systems it is required that RESBUF is correctly
    aligned for a 32 bits value.  */
-static void *md5_finish_ctx(struct md5_ctx *ctx, void *resbuf)
+static void *md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
 {
-	/* Take yet unprocessed bytes into account.  */
-	md5_uint32 bytes = ctx->buflen;
-	size_t pad;
+  /* Take yet unprocessed bytes into account.  */
+  md5_uint32 bytes = ctx->buflen;
+  size_t pad;
+  md5_uint32 *buffer = NULL;
 
-	/* Now count remaining bytes.  */
-	ctx->total[0] += bytes;
-	if (ctx->total[0] < bytes)
-		++ctx->total[1];
+  /* Now count remaining bytes.  */
+  ctx->total[0] += bytes;
+  if (ctx->total[0] < bytes)
+    ++ctx->total[1];
 
-	pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
-	memcpy(&ctx->buffer[bytes], fillbuf, pad);
+  pad = bytes >= 56 ? 64 + 56 - bytes : 56 - bytes;
+  memcpy (&ctx->buffer[bytes], fillbuf, pad);
 
-	/* Put the 64-bit file length in *bits* at the end of the buffer.  */
-	ctx->buffer32[(bytes + pad) / 4] = SWAP (ctx->total[0] << 3);
-	ctx->buffer32[(bytes + pad + 4) / 4] = SWAP ((ctx->total[1] << 3)
-											| (ctx->total[0] >> 29));
+  /* Put the 64-bit file length in *bits* at the end of the buffer.  */
+  buffer = (void *)&ctx->buffer[bytes + pad];
+  *buffer = SWAP (ctx->total[0] << 3);
+  buffer = (void *)&ctx->buffer[bytes + pad + 4];
+  *buffer = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
 
-	/* Process last bytes.  */
-	md5_process_block(ctx->buffer, bytes + pad + 8, ctx);
+  /* Process last bytes.  */
+  md5_process_block (ctx->buffer, bytes + pad + 8, ctx);
 
-	return md5_read_ctx(ctx, resbuf);
+  return md5_read_ctx (ctx, resbuf);
 }
 
 /* Compute MD5 message digest for bytes read from STREAM.  The
    resulting message digest number will be written into the 16 bytes
    beginning at RESBLOCK.  */
-int md5_stream(FILE *stream, void *resblock)
+int md5_stream (FILE *stream, void *resblock)
 {
-	/* Important: BLOCKSIZE must be a multiple of 64.  */
+  /* Important: BLOCKSIZE must be a multiple of 64.  */
 #define BLOCKSIZE 4096
-	struct md5_ctx ctx;
-	char buffer[BLOCKSIZE + 72];
-	size_t sum = 0;
+  struct md5_ctx ctx;
+  char buffer[BLOCKSIZE + 72];
+  size_t sum = 0;
 
-	/* Initialize the computation context.  */
-	md5_init_ctx(&ctx);
+  /* Initialize the computation context.  */
+  md5_init_ctx (&ctx);
 
-	/* Iterate over full file contents.  */
-	while (1)
+  /* Iterate over full file contents.  */
+  while (1)
+    {
+      /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
+	 computation function processes the whole buffer so that with the
+	 next round of the loop another block can be read.  */
+      size_t n;
+      sum = 0;
+
+      /* Read block.  Take care for partial reads.  */
+      do
 	{
-		/* We read the file in blocks of BLOCKSIZE bytes.  One call of the
-		computation function processes the whole buffer so that with the
-		next round of the loop another block can be read.  */
-		size_t n;
-		sum = 0;
+	  n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
 
-		/* Read block.  Take care for partial reads.  */
-		do
-		{
-			n = fread(buffer + sum, 1, BLOCKSIZE - sum, stream);
-			sum += n;
-		}
-
-		while (sum < BLOCKSIZE && n != 0);
-		if (n == 0 && ferror(stream))
-		  return 1;
-
-		/* If end of file is reached, end the loop.  */
-		if (n == 0)
-			break;
-
-		/* Process buffer with BLOCKSIZE bytes.  Note that
-		BLOCKSIZE % 64 == 0
-		*/
-		md5_process_block(buffer, BLOCKSIZE, &ctx);
+	  sum += n;
 	}
+      while (sum < BLOCKSIZE && n != 0);
+      if (n == 0 && ferror (stream))
+        return 1;
 
-	/* Add the last bytes if necessary.  */
-	if (sum > 0)
-		md5_process_bytes(buffer, sum, &ctx);
+      /* If end of file is reached, end the loop.  */
+      if (n == 0)
+	break;
 
-	/* Construct result in desired memory.  */
-	md5_finish_ctx(&ctx, resblock);
-	return 0;
+      /* Process buffer with BLOCKSIZE bytes.  Note that
+			BLOCKSIZE % 64 == 0
+       */
+      md5_process_block (buffer, BLOCKSIZE, &ctx);
+    }
+
+  /* Add the last bytes if necessary.  */
+  if (sum > 0)
+    md5_process_bytes (buffer, sum, &ctx);
+
+  /* Construct result in desired memory.  */
+  md5_finish_ctx (&ctx, resblock);
+  return 0;
 }
 
 /* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
    result is always in little endian byte order, so that a byte-wise
    output yields to the wanted ASCII representation of the message
    digest.  */
-void *md5_buffer(const char *buffer, size_t len, void *resblock)
+void *md5_buffer (const char *buffer, size_t len, void *resblock)
 {
-	struct md5_ctx ctx;
+  struct md5_ctx ctx;
 
-	/* Initialize the computation context.  */
-	md5_init_ctx(&ctx);
+  /* Initialize the computation context.  */
+  md5_init_ctx (&ctx);
 
-	/* Process whole buffer but last len % 64 bytes.  */
-	md5_process_bytes (buffer, len, &ctx);
+  /* Process whole buffer but last len % 64 bytes.  */
+  md5_process_bytes (buffer, len, &ctx);
 
-	/* Put result in desired memory area.  */
-	return md5_finish_ctx(&ctx, resblock);
+  /* Put result in desired memory area.  */
+  return md5_finish_ctx (&ctx, resblock);
 }

src/md5.h

@@ -1,6 +1,6 @@
 // SONIC ROBO BLAST 2
 //-----------------------------------------------------------------------------
-// Copyright (C) 1995-2025 by the Free Software Foundation, Inc.
+// Copyright (C) 1995-1996 by the Free Software Foundation, Inc.
 //
 // This program is free software distributed under the
 // terms of the GNU General Public License, version 2.
@@ -24,32 +24,108 @@
 
 #define MD5_LEN 16
 
-/*	The following contortions are an attempt to use the C preprocessor
-	to determine an unsigned integral type that is 32 bits wide.  An
-	alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
-	doing that would require that the configure script compile and *run*
-	the resulting executable.  Locally running cross-compiled executables
-	is usually not possible.  */
+/* The following contortions are an attempt to use the C preprocessor
+   to determine an unsigned integral type that is 32 bits wide.  An
+   alternative approach is to use autoconf's AC_CHECK_SIZEOF macro, but
+   doing that would require that the configure script compile and *run*
+   the resulting executable.  Locally running cross-compiled executables
+   is usually not possible.  */
 
-#include <stdint.h>
-typedef uint32_t md5_uint32;
-typedef uintptr_t md5_uintptr;
-
-#if defined (__THROW)
-#define THROWFUNC __THROW
+#ifdef _LIBC
+# include <sys/types.h>
+typedef u_int32_t md5_uint32;
 #else
-#define THROWFUNC
+# if defined __STDC__ && __STDC__
+#  define UINT_MAX_32_BITS 4294967295U
+# else
+#  define UINT_MAX_32_BITS 0xFFFFFFFF
+# endif
+
+/* If UINT_MAX isn't defined, assume it's a 32-bit type.
+   This should be valid for all systems GNU cares about because
+   that doesn't include 16-bit systems, and only modern systems
+   (that certainly have <limits.h>) have 64+-bit integral types.  */
+
+# ifndef UINT_MAX
+#  define UINT_MAX UINT_MAX_32_BITS
+# endif
+
+# if UINT_MAX == UINT_MAX_32_BITS
+   typedef unsigned int md5_uint32;
+# else
+#  if USHRT_MAX == UINT_MAX_32_BITS
+    typedef unsigned short md5_uint32;
+#  else
+#   if ULONG_MAX == UINT_MAX_32_BITS
+     typedef unsigned long md5_uint32;
+#   else
+     /* The following line is intended to evoke an error.
+        Using #error is not portable enough.  */
+     "Cannot determine unsigned 32-bit data type."
+#   endif
+#  endif
+# endif
 #endif
 
-/*	Compute MD5 message digest for bytes read from STREAM.  The
-	resulting message digest number will be written into the 16 bytes
-	beginning at RESBLOCK.  */
-int md5_stream(FILE *stream, void *resblock) THROWFUNC;
+#undef __P
+#if defined (__STDC__) && __STDC__
+#define	__P(x) x
+#else
+#define	__P(x) ()
+#endif
 
-/*	Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
-	result is always in little endian byte order, so that a byte-wise
-	output yields to the wanted ASCII representation of the message
-	digest.  */
-extern void *md5_buffer(const char *buffer, size_t len, void *resblock) THROWFUNC;
+/*
+ * The following three functions are build up the low level used in
+ * the functions `md5_stream' and `md5_buffer'.
+ */
+#if 0
+/* Initialize structure containing state of computation.
+   (RFC 1321, 3.3: Step 3)  */
+extern void md5_init_ctx __P ((struct md5_ctx *ctx));
 
-#endif /* md5.h */
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is necessary that LEN is a multiple of 64!!! */
+extern void md5_process_block __P ((const void *buffer, size_t len,
+                                   struct md5_ctx *ctx));
+
+/* Starting with the result of former calls of this function (or the
+   initialization function update the context for the next LEN bytes
+   starting at BUFFER.
+   It is NOT required that LEN is a multiple of 64.  */
+extern void md5_process_bytes __P ((const void *buffer, size_t len,
+                                    struct md5_ctx *ctx));
+
+/* Process the remaining bytes in the buffer and put result from CTX
+   in first 16 bytes following RESBUF.  The result is always in little
+   endian byte order, so that a byte-wise output yields to the wanted
+   ASCII representation of the message digest.
+
+   IMPORTANT: On some systems it is required that RESBUF is correctly
+   aligned for a 32 bits value.  */
+extern void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
+
+
+/* Put result from CTX in first 16 bytes following RESBUF.  The result is
+   always in little endian byte order, so that a byte-wise output yields
+   to the wanted ASCII representation of the message digest.
+
+   IMPORTANT: On some systems it is required that RESBUF is correctly
+   aligned for a 32 bits value.  */
+extern void *md5_read_ctx __P ((const struct md5_ctx *ctx, void *resbuf));
+
+#endif
+
+/* Compute MD5 message digest for bytes read from STREAM.  The
+   resulting message digest number will be written into the 16 bytes
+   beginning at RESBLOCK.  */
+int md5_stream __P ((FILE *stream, void *resblock));
+
+/* Compute MD5 message digest for LEN bytes beginning at BUFFER.  The
+   result is always in little endian byte order, so that a byte-wise
+   output yields to the wanted ASCII representation of the message
+   digest.  */
+extern void *md5_buffer __P ((const char *buffer, size_t len, void *resblock));
+
+#endif

src/p_setup.c

@@ -2345,9 +2345,7 @@ static void P_RunLevelScript(const char *scriptname)
 		lumpnum_t lumpnum;
 		char newname[9];
 
-		strncpy(newname, scriptname, 8);
-
-		newname[8] = '\0';
+		strlcpy(newname, scriptname, sizeof(newname));
 
 		lumpnum = W_CheckNumForName(newname);
 
@@ -3314,6 +3312,12 @@ UINT16 P_PartialAddWadFile(const char *wadfilename, boolean local)
 	if (!mapsadded)
 		CONS_Printf(M_GetText("No maps added\n"));
 
+#ifdef HWRENDER
+	// Free GPU textures before freeing patches.
+	if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
+		HWR_ClearAllTextures();
+#endif
+
 	//
 	// search for sprite replacements
 	//
@@ -3324,7 +3328,7 @@ UINT16 P_PartialAddWadFile(const char *wadfilename, boolean local)
 	// Reload it all anyway, just in case they
 	// added some textures but didn't insert a
 	// TEXTURES/etc. list.
-	//R_LoadTexturesPwad(wadnum);
+	R_LoadTexturesPwad(wadnum);
 
 	// everything from MultiSetupWadFile until ST_Start was here originally
 
@@ -3388,13 +3392,8 @@ boolean P_MultiSetupWadFiles(boolean fullsetup)
 
 	if (partadd_stage == 1)
 	{
-#ifdef HWRENDER
-		// Free GPU textures before freeing patches.
-		if (rendermode == render_opengl && (vid.glstate == VID_GL_LIBRARY_LOADED))
-			HWR_ClearAllTextures();
-#endif
 		// Reload all textures, unconditionally for better or worse.
-		R_LoadTextures();
+		//R_LoadTextures();
 
 		if (fullsetup)
 			++partadd_stage;

src/r_data.c

@@ -235,6 +235,7 @@ UINT32 ASTBlendTexturePixel(RGBA_t background, RGBA_t foreground, int style, UIN
 // Painfully simple texture id cacheing to make maps load faster. :3
 static struct {
 	char name[9];
+	UINT32 hash;
 	INT32 id;
 } *tidcache = NULL;
 static INT32 tidcachelen = 0;
@@ -520,32 +521,151 @@ void R_FlushTextureCache(void)
 int R_CountTexturesInTEXTURESLump(UINT16 wadNum, UINT16 lumpNum);
 void R_ParseTEXTURESLump(UINT16 wadNum, UINT16 lumpNum, INT32 *index);
 
-//
-// R_LoadTextures
-// Initializes the texture list with the textures from the world map.
-//
 #define TX_START "TX_START"
 #define TX_END "TX_END"
-void R_LoadTextures(void)
+
+static INT32
+Rloadtextures (INT32 i, INT32 w)
 {
-	INT32 i, k, w;
 	UINT16 j;
+	INT32 k;
 	UINT16 texstart, texend, texturesLumpPos;
 	softwarepatch_t *patchlump;
 	texpatch_t *patch;
 	texture_t *texture;
 
-	// Free previous memory before numtextures change.
-	if (numtextures)
+	// Get the lump numbers for the markers in the WAD, if they exist.
+	if (W_FileHasFolders(wadfiles[w]))
 	{
-		for (i = 0; i < numtextures; i++)
+		texstart = W_CheckNumForFolderStartPK3("textures/", (UINT16)w, 0);
+		texend = W_CheckNumForFolderEndPK3("textures/", (UINT16)w, texstart);
+		texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
+		while (texturesLumpPos != INT16_MAX)
 		{
-			Z_Free(textures[i]);
-			Z_Free(texturecache[i]);
+			R_ParseTEXTURESLump(w, texturesLumpPos, &i);
+			texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, texturesLumpPos + 1);
 		}
-		Z_Free(texturetranslation);
-		Z_Free(textures);
 	}
+	else
+	{
+		texstart = W_CheckNumForMarkerStartPwad(TX_START, (UINT16)w, 0);
+		texend = W_CheckNumForNamePwad(TX_END, (UINT16)w, 0);
+		texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
+		if (texturesLumpPos != INT16_MAX)
+			R_ParseTEXTURESLump(w, texturesLumpPos, &i);
+	}
+
+	if (texstart == INT16_MAX || texend == INT16_MAX)
+		return i;
+
+	// Work through each lump between the markers in the WAD.
+	for (j = 0; j < (texend - texstart); j++)
+	{
+		UINT16 wadnum = (UINT16)w;
+		lumpnum_t lumpnum = texstart + j;
+
+		if (W_FileHasFolders(wadfiles[w]))
+		{
+			if (W_IsLumpFolder(wadnum, lumpnum)) // Check if lump is a folder
+				continue; // If it is then SKIP IT
+		}
+
+		patchlump = (softwarepatch_t *)W_CacheLumpNumPwad(wadnum, lumpnum, PU_STATIC);
+
+		//CONS_Printf("\n\"%s\" is a single patch, dimensions %d x %d",W_CheckNameForNumPwad((wadnum, lumpnum), patchlump->width, patchlump->height);
+		texture = textures[i] = Z_Calloc(sizeof(texture_t) + sizeof(texpatch_t), PU_STATIC, NULL);
+
+		// Set texture properties.
+		M_Memcpy(texture->name, W_CheckNameForNumPwad(wadnum, lumpnum), sizeof(texture->name));
+		texture->hash = quickncasehash(texture->name, 8);
+		texture->width = SHORT(patchlump->width);
+		texture->height = SHORT(patchlump->height);
+		texture->type = TEXTURETYPE_SINGLEPATCH;
+		texture->patchcount = 1;
+		texture->holes = false;
+
+		// Allocate information for the texture's patches.
+		patch = &texture->patches[0];
+
+		patch->originx = patch->originy = 0;
+		patch->wad = wadnum;
+		patch->lump = texstart + j;
+
+		Z_Free(patchlump);
+
+		// determine width power of 2
+#if 1
+        // [WDJ] only need to determine if exact power of 2.
+        k = 1;
+        while (k < texture->width)
+            k<<=1;
+#else
+		// Largest power of 2 that fits within width.
+		k = 1;
+		while (k << 1 <= texture->width)
+			k <<= 1;
+#endif
+		if (k != texture->width)
+		{
+			// Odd width
+			k = 1;  // make texturewidthmask = 0
+		}
+
+		texturewidthmask[i] = k - 1;
+		textureheight[i] = texture->height << FRACBITS;
+		i++;
+	}
+
+	return i;
+}
+
+static INT32
+count_range
+(		const char * marker_start,
+		const char * marker_end,
+		const char * folder,
+		UINT16 wadnum)
+{
+	UINT16 j;
+	UINT16 texstart, texend;
+	INT32 count = 0;
+
+	// Count flats
+	if (W_FileHasFolders(wadfiles[wadnum]))
+	{
+		texstart = W_CheckNumForFolderStartPK3(folder, wadnum, 0);
+		texend = W_CheckNumForFolderEndPK3(folder, wadnum, texstart);
+	}
+	else
+	{
+		texstart = W_CheckNumForMarkerStartPwad(marker_start, wadnum, 0);
+		texend = W_CheckNumForNamePwad(marker_end, wadnum, texstart);
+	}
+
+	if (texstart != INT16_MAX && texend != INT16_MAX)
+	{
+		// PK3s have subfolders, so we can't just make a simple sum
+		if (W_FileHasFolders(wadfiles[wadnum]))
+		{
+			for (j = texstart; j < texend; j++)
+			{
+				if (!W_IsLumpFolder(wadnum, j)) // Check if lump is a folder; if not, then count it
+					count++;
+			}
+		}
+		else // Add all the textures between markers
+		{
+			count += (texend - texstart);
+		}
+	}
+
+	return count;
+}
+
+static INT32 R_CountTextures(UINT16 wadnum)
+{
+	UINT16 texturesLumpPos;
+	INT32 count = 0;
 
 	// Load patches and textures.
 
@@ -554,159 +674,127 @@ void R_LoadTextures(void)
 	// the markers.
 	// This system will allocate memory for all duplicate/patched textures even if it never uses them,
 	// but the alternative is to spend a ton of time checking and re-checking all previous entries just to skip any potentially patched textures.
-	for (w = 0, numtextures = 0; w < numwadfiles; w++)
+
+	// Count the textures from TEXTURES lumps
+	texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", wadnum, 0);
+
+	while (texturesLumpPos != INT16_MAX)
 	{
-		if (W_FileHasFolders(wadfiles[w]))
-		{
-			texstart = W_CheckNumForFolderStartPK3("textures/", (UINT16)w, 0);
-			texend = W_CheckNumForFolderEndPK3("textures/", (UINT16)w, texstart);
-		}
-		else
-		{
-			texstart = W_CheckNumForNamePwad(TX_START, (UINT16)w, 0) + 1;
-			texend = W_CheckNumForNamePwad(TX_END, (UINT16)w, 0);
-		}
-
-		texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
-		while (texturesLumpPos != INT16_MAX)
-		{
-			numtextures += R_CountTexturesInTEXTURESLump((UINT16)w, (UINT16)texturesLumpPos);
-			texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, texturesLumpPos + 1);
-		}
-
-		// Add all the textures between TX_START and TX_END
-		if (texstart == INT16_MAX || texend == INT16_MAX)
-			continue;
-
-		// PK3s have subfolders, so we can't just make a simple sum
-		if (W_FileHasFolders(wadfiles[w]))
-		{
-			for (j = texstart; j < texend; j++)
-			{
-				if (W_IsLumpFolder((UINT16)w, j)) // Check if lump is a folder; if not, then count it
-					continue;
-
-				numtextures++;
-			}
-		}
-		else
-		{
-			numtextures += (UINT32)(texend - texstart);
-		}
+		count += R_CountTexturesInTEXTURESLump(wadnum, texturesLumpPos);
+		texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", wadnum, texturesLumpPos + 1);
 	}
 
-	// If no textures found by this point, bomb out
-	if (!numtextures)
-		I_Error("No textures detected in any WADs!\n");
+	// Count single-patch textures
+	count += count_range(TX_START, TX_END, "textures/", wadnum);
+
+	return count;
+}
+
+static void
+recallocuser
+(		void * user,
+		size_t old,
+		size_t new)
+{
+	char *p = Z_Realloc(*(void**)user,
+			new, PU_STATIC, user);
+
+	if (new > old)
+		memset(&p[old], 0, (new - old));
+}
+
+static void R_AllocateTextures(INT32 add)
+{
+	const INT32 newtextures = (numtextures + add);
+	const size_t newsize = newtextures * sizeof (void*);
+	const size_t oldsize = numtextures * sizeof (void*);
+
+	INT32 i;
 
 	// Allocate memory and initialize to 0 for all the textures we are initialising.
-	// There are actually 5 buffers allocated in one for convenience.
-	textures = Z_Calloc((numtextures * sizeof(void *)) * 5, PU_STATIC, NULL);
+	recallocuser(&textures, oldsize, newsize);
 
 	// Allocate texture column offset table.
-	texturecolumnofs = (void *)((UINT8 *)textures + (numtextures * sizeof(void *)));
+	recallocuser(&texturecolumnofs, oldsize, newsize);
 	// Allocate texture referencing cache.
-	texturecache     = (void *)((UINT8 *)textures + ((numtextures * sizeof(void *)) * 2));
-	// Allocate texture width mask table.
-	texturewidthmask = (void *)((UINT8 *)textures + ((numtextures * sizeof(void *)) * 3));
-	// Allocate texture height mask table.
-	textureheight    = (void *)((UINT8 *)textures + ((numtextures * sizeof(void *)) * 4));
+	recallocuser(&texturecache, oldsize, newsize);
+	// Allocate texture width table.
+	recallocuser(&texturewidthmask, oldsize, newsize);
+	// Allocate texture height table.
+	recallocuser(&textureheight, oldsize, newsize);
 	// Create translation table for global animation.
-	texturetranslation = Z_Malloc((numtextures + 1) * sizeof(*texturetranslation), PU_STATIC, NULL);
+	Z_Realloc(texturetranslation, (newtextures + 1) * sizeof(*texturetranslation), PU_STATIC, &texturetranslation);
 
-	for (i = 0; i < numtextures; i++)
-		texturetranslation[i] = i;
-
-	for (i = 0, w = 0; w < numwadfiles; w++)
+	for (i = 0; i < numtextures; ++i)
 	{
-		// Get the lump numbers for the markers in the WAD, if they exist.
-		if (W_FileHasFolders(wadfiles[w]))
-		{
-			texstart = W_CheckNumForFolderStartPK3("textures/", (UINT16)w, 0);
-			texend = W_CheckNumForFolderEndPK3("textures/", (UINT16)w, texstart);
-			texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
-			while (texturesLumpPos != INT16_MAX)
-			{
-				R_ParseTEXTURESLump(w, texturesLumpPos, &i);
-				texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, texturesLumpPos + 1);
-			}
-		}
-		else
-		{
-			texstart = W_CheckNumForNamePwad(TX_START, (UINT16)w, 0) + 1;
-			texend = W_CheckNumForNamePwad(TX_END, (UINT16)w, 0);
-			texturesLumpPos = W_CheckNumForNamePwad("TEXTURES", (UINT16)w, 0);
-			if (texturesLumpPos != INT16_MAX)
-				R_ParseTEXTURESLump(w, texturesLumpPos, &i);
-		}
-
-		if (texstart == INT16_MAX || texend == INT16_MAX)
-			continue;
-
-		// Work through each lump between the markers in the WAD.
-		for (j = 0; j < (texend - texstart); j++)
-		{
-			UINT16 wadnum = (UINT16)w;
-			lumpnum_t lumpnum = texstart + j;
-
-			if (W_FileHasFolders(wadfiles[w]))
-			{
-				if (W_IsLumpFolder(wadnum, lumpnum)) // Check if lump is a folder
-					continue; // If it is then SKIP IT
-			}
-
-			patchlump = (softwarepatch_t *)W_CacheLumpNumPwad(wadnum, lumpnum, PU_STATIC);
-
-			//CONS_Printf("\n\"%s\" is a single patch, dimensions %d x %d",W_CheckNameForNumPwad(wadnum, lumpnum), patchlump->width, patchlump->height);
-			texture = textures[i] = Z_Calloc(sizeof(texture_t) + sizeof(texpatch_t), PU_STATIC, NULL);
-
-			// Set texture properties.
-			M_Memcpy(texture->name, W_CheckNameForNumPwad(wadnum, lumpnum), sizeof(texture->name));
-			texture->width = SHORT(patchlump->width);
-			texture->height = SHORT(patchlump->height);
-			texture->type = TEXTURETYPE_SINGLEPATCH;
-			texture->patchcount = 1;
-			texture->holes = false;
-
-			// Allocate information for the texture's patches.
-			patch = &texture->patches[0];
-
-			patch->originx = patch->originy = 0;
-			patch->wad = wadnum;
-			patch->lump = texstart + j;
-
-			Z_Free(patchlump);
-
-			// determine width power of 2
-#if 1
-			// [WDJ] only need to determine if exact power of 2.
-			k = 1;
-			while (k < texture->width)
-				k<<=1;
-#else
-			// Largest power of 2 that fits within width.
-			k = 1;
-			while (k << 1 <= texture->width)
-				k <<= 1;
-#endif
-			if (k != texture->width)
-			{
-				// Odd width
-				k = 1;  // make texturewidthmask = 0
-			}
-
-			texturewidthmask[i] = k - 1;
-			textureheight[i] = texture->height << FRACBITS;
-			i++;
-		}
+		// R_FlushTextureCache relies on the user for
+		// Z_Free, texturecache has been reallocated so the
+		// user is now garbage memory.
+		Z_SetUser(texturecache[i], (void**)&texturecache[i]);
 	}
 
+	while (i < newtextures)
+	{
+		texturetranslation[i] = i;
+		i++;
+	}
+}
+
+static INT32 R_DefineTextures(INT32 i, UINT16 w)
+{
+	return Rloadtextures(i, w);
+}
+
+static void R_FinishLoadingTextures(INT32 add)
+{
+	numtextures += add;
+
 #ifdef HWRENDER
 	if (rendermode == render_opengl)
 		HWR_LoadMapTextures(numtextures);
 #endif
 }
 
+//
+// R_LoadTextures
+// Initializes the texture list with the textures from the world map.
+//
+void R_LoadTextures(void)
+{
+	INT32 i, w;
+	INT32 newtextures = 0;
+
+	for (w = 0; w < numwadfiles; w++)
+	{
+		newtextures += R_CountTextures((UINT16)w);
+	}
+
+	// If no textures found by this point, bomb out
+	if (!newtextures)
+		I_Error("No textures detected in any WADs!\n");
+
+	R_AllocateTextures(newtextures);
+
+	for (i = 0, w = 0; w < numwadfiles; w++)
+	{
+		i = R_DefineTextures(i, w);
+	}
+
+	R_FinishLoadingTextures(i);
+}
+
+void R_LoadTexturesPwad(UINT16 wadnum)
+{
+	INT32 newtextures = R_CountTextures(wadnum);
+
+	if (!newtextures)
+		return;
+
+	R_AllocateTextures(newtextures);
+	newtextures = R_DefineTextures(numtextures, wadnum) - numtextures;
+	R_FinishLoadingTextures(newtextures);
+}
+
 static texpatch_t *R_ParsePatch(boolean actuallyLoadPatch)
 {
 	char *texturesToken;
@@ -958,6 +1046,7 @@ static texture_t *R_ParseTexture(boolean actuallyLoadTexture)
 			// Allocate memory for a zero-patch texture. Obviously, we'll be adding patches momentarily.
 			resultTexture = (texture_t *)Z_Calloc(sizeof(texture_t), PU_STATIC, NULL);
 			M_Memcpy(resultTexture->name, newTextureName, 8);
+			resultTexture->hash = quickncasehash(newTextureName, 8);
 			resultTexture->width = newTextureWidth;
 			resultTexture->height = newTextureHeight;
 			resultTexture->type = TEXTURETYPE_COMPOSITE;
@@ -1741,19 +1830,22 @@ void R_ClearTextureNumCache(boolean btell)
 INT32 R_CheckTextureNumForName(const char *name)
 {
 	INT32 i;
+	UINT32 hash;
 
 	// "NoTexture" marker.
 	if (name[0] == '-')
 		return 0;
 
+	hash = quickncasehash(name, 8);
+
 	for (i = 0; i < tidcachelen; i++)
-		if (!strncasecmp(tidcache[i].name, name, 8))
+		if (tidcache[i].hash == hash && !strncasecmp(tidcache[i].name, name, 8))
 			return tidcache[i].id;
 
 	// Need to parse the list backwards, so textures loaded more recently are used in lieu of ones loaded earlier
 	//for (i = 0; i < numtextures; i++) <- old
 	for (i = (numtextures - 1); i >= 0; i--) // <- new
-		if (!strncasecmp(textures[i]->name, name, 8))
+		if (textures[i]->hash == hash && !strncasecmp(textures[i]->name, name, 8))
 		{
 			tidcachelen++;
 			Z_Realloc(tidcache, tidcachelen * sizeof(*tidcache), PU_STATIC, &tidcache);
@@ -1762,6 +1854,7 @@ INT32 R_CheckTextureNumForName(const char *name)
 #ifndef ZDEBUG
 			CONS_Debug(DBG_SETUP, "texture #%s: %s\n", sizeu1(tidcachelen), tidcache[tidcachelen-1].name);
 #endif
+			tidcache[tidcachelen-1].hash = hash;
 			tidcache[tidcachelen-1].id = i;
 			return i;
 		}

src/r_data.h

@@ -53,6 +53,7 @@ typedef struct
 	// Keep name for switch changing, etc.
 	char name[8];
 	UINT8 type; // TEXTURETYPE_
+	UINT32 hash;
 	INT16 width, height;
 	boolean holes;
 	// All the patches[patchcount] are drawn back to front into the cached texture.
@@ -76,6 +77,7 @@ extern CV_PossibleValue_t Color_cons_t[];
 
 // Load TEXTURE1/TEXTURE2/PNAMES definitions, create lookup tables
 void R_LoadTextures(void);
+void R_LoadTexturesPwad(UINT16 wadnum);
 void R_FlushTextureCache(void);
 
 UINT8 *R_GenerateTexture(size_t texnum);