Merge pull request ddnet#9015 from Robyt3/Style-Parameter-Class-Struc…

…t-Name-Fixes

Remove most clang-tidy parameter and class/struct name exceptions

.clang-tidy

@@ -130,19 +130,19 @@ CheckOptions:
   - key:             readability-identifier-naming.StructPrefix
     value:           S
   - key:             readability-identifier-naming.StructIgnoredRegexp
-    value:           '^([CS]|MapObject$|EnvelopedQuad$).*'
+    value:           '^C.*'
   - key:             readability-identifier-naming.ClassIgnoredRegexp
     value:           '^(I|CCommandProcessorFragment_Vulkan$).*'
   - key:             readability-identifier-naming.ParameterCase
     value:           CamelCase
   - key:             readability-identifier-naming.ParameterIgnoredRegexp
-    value:           '^(p|a|v|[a-z]$|s[hw]$|warning_msg$|error_msg$|string$|integer$|boolean$|object$|index$|rhs$|lhs$|[xy]off$|id$|mode$|rgb$|[xy][0123]$|width$|height$|[sdw][xy]$|ownId$|fnMatchCallback$).*'
+    value:           '^(p|a|v|[a-z]$|[xy][0123]$).*'
   - key:             readability-identifier-naming.ClassMethodIgnoredRegexp
     value:           '^(Con_).*'
   - key:             readability-identifier-naming.ClassMemberIgnoredRegexp
     value:           '^(m_a|m_v|m_p|ms_p|ms_a|ms_v|s_1024x1024ImgSize$|s_ImageBufferCacheId$|s_VertexBufferCacheId$|s_StagingBufferImageCacheId$|REPLACEMENT_CHARACTER$|(MAX|MIN)_FONT_SIZE$|MAXIMUM_ATLAS_DIMENSION$|INITIAL_ATLAS_DIMENSION$|MAX_SECTION_DIMENSION_MAPPED$|MIN_SECTION_DIMENSION$|s_StagingBufferCacheId$).*'
   - key:             readability-identifier-naming.LocalConstantIgnoredRegexp
     value:           '^(p|a|v|s_|MAX_ANIM_SPEED$|DATA_OFFSET$|HEADER_LEN$|MIN_ANIM_SPEED$|[hwdcbqstf]$|[xt][0123]$|result$|sub$|it$|len$|d[xy]$).*'
   - key:             readability-identifier-naming.LocalVariableIgnoredRegexp
-    value:           '^(p|a|s_|FT_|TB_|s_|ul_|v|[xy]i$|[zijklxyhmrgbacwestnduvqf]$|[dmpwsitcf][xy]$|(ch|skel)[0-2]?$|it$|tw$|dt$|th$|ls$|func$|res$|shader$|len$|maxLength$|length$|offset$|offpos$|result$|bg$|sp$|url$|index$|ctxt$|key$|null$|logger$|LAST_MODIFIED$|teleNr$|target$|id$|hit$|hsl[0-2]?$|rgb[0-2]?$|dir$|tmp$|sub$|ret$|rendered$|(lower|upper)(16|26|24|32)|size$|isWeaponCollide$|zerochar$|dist$|sound$|match$|best_matches$|matches$|nohook$|btn$|savedLayers$|l[hw]$|evilz$|sec$|min$|to2$|delay$|mode$|maxModes$|numModes$|[xy]Fract$|[xy]Int$|imgg[xy]$|skip$|localPlayer$|fdratio$|[rgbat][0-2]$|[xy][0-3]$|x[rl]$).*'
+    value:           '^(p|a|s_|FT_|TB_|s_|ul_|v|[xy]i$|[zijklxyhmrgbacwestnduvqf]$|[dmpwsitcf][xy]$|(ch|skel)[0-2]?$|it$|tw$|dt$|th$|ls$|func$|res$|shader$|len$|maxLength$|length$|offset$|offpos$|result$|bg$|sp$|url$|index$|ctxt$|key$|null$|logger$|LAST_MODIFIED$|teleNr$|target$|id$|hit$|hsl[0-2]?$|rgb[0-2]?$|dir$|tmp$|sub$|ret$|rendered$|size$|isWeaponCollide$|zerochar$|dist$|sound$|match$|best_matches$|matches$|nohook$|btn$|savedLayers$|l[hw]$|evilz$|sec$|min$|to2$|delay$|[xy]Fract$|[xy]Int$|imgg[xy]$|skip$|localPlayer$|fdratio$|[rgbat][0-2]$|[xy][0-3]$|x[rl]$).*'
 

src/engine/client/backend_sdl.cpp

@@ -905,8 +905,7 @@ static void DisplayToVideoMode(CVideoMode *pVMode, SDL_DisplayMode *pMode, int H
 void CGraphicsBackend_SDL_GL::GetVideoModes(CVideoMode *pModes, int MaxModes, int *pNumModes, int HiDPIScale, int MaxWindowWidth, int MaxWindowHeight, int ScreenId)
 {
 	SDL_DisplayMode DesktopMode;
-	int maxModes = SDL_GetNumDisplayModes(ScreenId);
-	int numModes = 0;
+	int MaxModesAvailable = SDL_GetNumDisplayModes(ScreenId);
 
 	// Only collect fullscreen modes when requested, that makes sure in windowed mode no refresh rates are shown that aren't supported without
 	// fullscreen anyway(except fullscreen desktop)
@@ -921,49 +920,50 @@ void CGraphicsBackend_SDL_GL::GetVideoModes(CVideoMode *pModes, int MaxModes, in
 	constexpr int ModeCount = 256;
 	SDL_DisplayMode aModes[ModeCount];
 	int NumModes = 0;
-	for(int i = 0; i < maxModes && NumModes < ModeCount; i++)
+	for(int i = 0; i < MaxModesAvailable && NumModes < ModeCount; i++)
 	{
-		SDL_DisplayMode mode;
-		if(SDL_GetDisplayMode(ScreenId, i, &mode) < 0)
+		SDL_DisplayMode Mode;
+		if(SDL_GetDisplayMode(ScreenId, i, &Mode) < 0)
 		{
 			dbg_msg("gfx", "unable to get display mode: %s", SDL_GetError());
 			continue;
 		}
 
-		aModes[NumModes] = mode;
+		aModes[NumModes] = Mode;
 		++NumModes;
 	}
 
-	auto &&ModeInsert = [&](SDL_DisplayMode &mode) {
-		if(numModes < MaxModes)
+	int NumModesInserted = 0;
+	auto &&ModeInsert = [&](SDL_DisplayMode &Mode) {
+		if(NumModesInserted < MaxModes)
 		{
 			// if last mode was equal, ignore this one --- in fullscreen this can really only happen if the screen
 			// supports different color modes
 			// in non fullscren these are the modes that show different refresh rate, but are basically the same
-			if(numModes > 0 && pModes[numModes - 1].m_WindowWidth == mode.w && pModes[numModes - 1].m_WindowHeight == mode.h && (pModes[numModes - 1].m_RefreshRate == mode.refresh_rate || (mode.refresh_rate != DesktopMode.refresh_rate && !CollectFullscreenModes)))
+			if(NumModesInserted > 0 && pModes[NumModesInserted - 1].m_WindowWidth == Mode.w && pModes[NumModesInserted - 1].m_WindowHeight == Mode.h && (pModes[NumModesInserted - 1].m_RefreshRate == Mode.refresh_rate || (Mode.refresh_rate != DesktopMode.refresh_rate && !CollectFullscreenModes)))
 				return;
 
-			DisplayToVideoMode(&pModes[numModes], &mode, HiDPIScale, !CollectFullscreenModes ? DesktopMode.refresh_rate : mode.refresh_rate);
-			numModes++;
+			DisplayToVideoMode(&pModes[NumModesInserted], &Mode, HiDPIScale, !CollectFullscreenModes ? DesktopMode.refresh_rate : Mode.refresh_rate);
+			NumModesInserted++;
 		}
 	};
 
 	for(int i = 0; i < NumModes; i++)
 	{
-		SDL_DisplayMode &mode = aModes[i];
+		SDL_DisplayMode &Mode = aModes[i];
 
-		if(mode.w > MaxWindowWidth || mode.h > MaxWindowHeight)
+		if(Mode.w > MaxWindowWidth || Mode.h > MaxWindowHeight)
 			continue;
 
-		ModeInsert(mode);
+		ModeInsert(Mode);
 
 		if(IsFullscreenDestkop)
 			break;
 
-		if(numModes >= MaxModes)
+		if(NumModesInserted >= MaxModes)
 			break;
 	}
-	*pNumModes = numModes;
+	*pNumModes = NumModesInserted;
 }
 
 void CGraphicsBackend_SDL_GL::GetCurrentVideoMode(CVideoMode &CurMode, int HiDPIScale, int MaxWindowWidth, int MaxWindowHeight, int ScreenId)

src/engine/client/text.cpp

@@ -1353,9 +1353,9 @@ class CTextRender : public IEngineTextRender
 		m_Color.a = a;
 	}
 
-	void TextColor(ColorRGBA rgb) override
+	void TextColor(ColorRGBA Color) override
 	{
-		m_Color = rgb;
+		m_Color = Color;
 	}
 
 	void TextOutlineColor(float r, float g, float b, float a) override
@@ -1366,9 +1366,9 @@ class CTextRender : public IEngineTextRender
 		m_OutlineColor.a = a;
 	}
 
-	void TextOutlineColor(ColorRGBA rgb) override
+	void TextOutlineColor(ColorRGBA Color) override
 	{
-		m_OutlineColor = rgb;
+		m_OutlineColor = Color;
 	}
 
 	void TextSelectionColor(float r, float g, float b, float a) override
@@ -1379,9 +1379,9 @@ class CTextRender : public IEngineTextRender
 		m_SelectionColor.a = a;
 	}
 
-	void TextSelectionColor(ColorRGBA rgb) override
+	void TextSelectionColor(ColorRGBA Color) override
 	{
-		m_SelectionColor = rgb;
+		m_SelectionColor = Color;
 	}
 
 	ColorRGBA GetTextColor() const override

src/engine/gfx/image_loader.cpp

@@ -44,17 +44,17 @@ class CUserErrorStruct
 	std::jmp_buf m_JmpBuf;
 };
 
-[[noreturn]] static void PngErrorCallback(png_structp png_ptr, png_const_charp error_msg)
+[[noreturn]] static void PngErrorCallback(png_structp pPngStruct, png_const_charp pErrorMessage)
 {
-	CUserErrorStruct *pUserStruct = static_cast<CUserErrorStruct *>(png_get_error_ptr(png_ptr));
-	log_error("png", "error for file \"%s\": %s", pUserStruct->m_pContextName, error_msg);
+	CUserErrorStruct *pUserStruct = static_cast<CUserErrorStruct *>(png_get_error_ptr(pPngStruct));
+	log_error("png", "error for file \"%s\": %s", pUserStruct->m_pContextName, pErrorMessage);
 	std::longjmp(pUserStruct->m_JmpBuf, 1);
 }
 
-static void PngWarningCallback(png_structp png_ptr, png_const_charp warning_msg)
+static void PngWarningCallback(png_structp pPngStruct, png_const_charp pWarningMessage)
 {
-	CUserErrorStruct *pUserStruct = static_cast<CUserErrorStruct *>(png_get_error_ptr(png_ptr));
-	log_warn("png", "warning for file \"%s\": %s", pUserStruct->m_pContextName, warning_msg);
+	CUserErrorStruct *pUserStruct = static_cast<CUserErrorStruct *>(png_get_error_ptr(pPngStruct));
+	log_warn("png", "warning for file \"%s\": %s", pUserStruct->m_pContextName, pWarningMessage);
 }
 
 static void PngReadDataCallback(png_structp pPngStruct, png_bytep pOutBytes, png_size_t ByteCountToRead)
@@ -307,7 +307,7 @@ static void PngWriteDataCallback(png_structp pPngStruct, png_bytep pOutBytes, pn
 	pWriter->Write(pOutBytes, ByteCountToWrite);
 }
 
-static void PngOutputFlushCallback(png_structp png_ptr)
+static void PngOutputFlushCallback(png_structp pPngStruct)
 {
 	// no need to flush memory buffer
 }

src/engine/gfx/image_manipulation.cpp

@@ -157,41 +157,41 @@ void DilateImage(const CImageInfo &Image)
 	DilateImage(Image.m_pData, Image.m_Width, Image.m_Height);
 }
 
-void DilateImageSub(uint8_t *pImageBuff, int w, int h, int x, int y, int sw, int sh)
+void DilateImageSub(uint8_t *pImageBuff, int w, int h, int x, int y, int SubWidth, int SubHeight)
 {
 	uint8_t *apBuffer[2] = {nullptr, nullptr};
 
-	const size_t ImageSize = (size_t)sw * sh * sizeof(uint8_t) * DILATE_BPP;
+	const size_t ImageSize = (size_t)SubWidth * SubHeight * sizeof(uint8_t) * DILATE_BPP;
 	apBuffer[0] = (uint8_t *)malloc(ImageSize);
 	apBuffer[1] = (uint8_t *)malloc(ImageSize);
 	uint8_t *pBufferOriginal = (uint8_t *)malloc(ImageSize);
 
-	for(int Y = 0; Y < sh; ++Y)
+	for(int Y = 0; Y < SubHeight; ++Y)
 	{
 		int SrcImgOffset = ((y + Y) * w * DILATE_BPP) + (x * DILATE_BPP);
-		int DstImgOffset = (Y * sw * DILATE_BPP);
-		int CopySize = sw * DILATE_BPP;
+		int DstImgOffset = (Y * SubWidth * DILATE_BPP);
+		int CopySize = SubWidth * DILATE_BPP;
 		mem_copy(&pBufferOriginal[DstImgOffset], &pImageBuff[SrcImgOffset], CopySize);
 	}
 
-	Dilate(sw, sh, pBufferOriginal, apBuffer[0]);
+	Dilate(SubWidth, SubHeight, pBufferOriginal, apBuffer[0]);
 
 	for(int i = 0; i < 5; i++)
 	{
-		Dilate(sw, sh, apBuffer[0], apBuffer[1]);
-		Dilate(sw, sh, apBuffer[1], apBuffer[0]);
+		Dilate(SubWidth, SubHeight, apBuffer[0], apBuffer[1]);
+		Dilate(SubWidth, SubHeight, apBuffer[1], apBuffer[0]);
 	}
 
-	CopyColorValues(sw, sh, apBuffer[0], pBufferOriginal);
+	CopyColorValues(SubWidth, SubHeight, apBuffer[0], pBufferOriginal);
 
 	free(apBuffer[0]);
 	free(apBuffer[1]);
 
-	for(int Y = 0; Y < sh; ++Y)
+	for(int Y = 0; Y < SubHeight; ++Y)
 	{
 		int SrcImgOffset = ((y + Y) * w * DILATE_BPP) + (x * DILATE_BPP);
-		int DstImgOffset = (Y * sw * DILATE_BPP);
-		int CopySize = sw * DILATE_BPP;
+		int DstImgOffset = (Y * SubWidth * DILATE_BPP);
+		int CopySize = SubWidth * DILATE_BPP;
 		mem_copy(&pImageBuff[SrcImgOffset], &pBufferOriginal[DstImgOffset], CopySize);
 	}
 

src/engine/gfx/image_manipulation.h

@@ -18,7 +18,7 @@ void ConvertToGrayscale(const CImageInfo &Image);
 // These functions assume that the image data is 4 bytes per pixel RGBA
 void DilateImage(uint8_t *pImageBuff, int w, int h);
 void DilateImage(const CImageInfo &Image);
-void DilateImageSub(uint8_t *pImageBuff, int w, int h, int x, int y, int sw, int sh);
+void DilateImageSub(uint8_t *pImageBuff, int w, int h, int x, int y, int SubWidth, int SubHeight);
 
 // Returned buffer is allocated with malloc, must be freed by caller
 uint8_t *ResizeImage(const uint8_t *pImageData, int Width, int Height, int NewWidth, int NewHeight, int BPP);

src/engine/shared/filecollection.cpp

@@ -19,7 +19,7 @@ void CFileCollection::Init(IStorage *pStorage, const char *pPath, const char *pF
 	m_pStorage = pStorage;
 
 	m_pStorage->ListDirectory(IStorage::TYPE_SAVE, m_aPath, FilelistCallback, this);
-	std::sort(m_vFileEntries.begin(), m_vFileEntries.end(), [](const CFileEntry &lhs, const CFileEntry &rhs) { return lhs.m_Timestamp < rhs.m_Timestamp; });
+	std::sort(m_vFileEntries.begin(), m_vFileEntries.end(), [](const CFileEntry &Lhs, const CFileEntry &Rhs) { return Lhs.m_Timestamp < Rhs.m_Timestamp; });
 
 	int FilesDeleted = 0;
 	for(auto FileEntry : m_vFileEntries)

src/engine/shared/json.cpp

@@ -1,46 +1,46 @@
 #include <base/system.h>
 #include <engine/shared/json.h>
 
-const struct _json_value *json_object_get(const json_value *object, const char *index)
+const struct _json_value *json_object_get(const json_value *pObject, const char *pIndex)
 {
 	unsigned int i;
 
-	if(object->type != json_object)
+	if(pObject->type != json_object)
 		return &json_value_none;
 
-	for(i = 0; i < object->u.object.length; ++i)
-		if(!str_comp(object->u.object.values[i].name, index))
-			return object->u.object.values[i].value;
+	for(i = 0; i < pObject->u.object.length; ++i)
+		if(!str_comp(pObject->u.object.values[i].name, pIndex))
+			return pObject->u.object.values[i].value;
 
 	return &json_value_none;
 }
 
-const struct _json_value *json_array_get(const json_value *array, int index)
+const struct _json_value *json_array_get(const json_value *pArray, int Index)
 {
-	if(array->type != json_array || index >= (int)array->u.array.length)
+	if(pArray->type != json_array || Index >= (int)pArray->u.array.length)
 		return &json_value_none;
 
-	return array->u.array.values[index];
+	return pArray->u.array.values[Index];
 }
 
-int json_array_length(const json_value *array)
+int json_array_length(const json_value *pArray)
 {
-	return array->u.array.length;
+	return pArray->u.array.length;
 }
 
-const char *json_string_get(const json_value *string)
+const char *json_string_get(const json_value *pString)
 {
-	return string->u.string.ptr;
+	return pString->u.string.ptr;
 }
 
-int json_int_get(const json_value *integer)
+int json_int_get(const json_value *pInteger)
 {
-	return integer->u.integer;
+	return pInteger->u.integer;
 }
 
-int json_boolean_get(const json_value *boolean)
+int json_boolean_get(const json_value *pBoolean)
 {
-	return boolean->u.boolean != 0;
+	return pBoolean->u.boolean != 0;
 }
 
 static char EscapeJsonChar(char c)

src/engine/textrender.h

@@ -352,11 +352,11 @@ class ITextRender : public IInterface
 
 	// old foolish interface
 	virtual void TextColor(float r, float g, float b, float a) = 0;
-	virtual void TextColor(ColorRGBA rgb) = 0;
+	virtual void TextColor(ColorRGBA Color) = 0;
 	virtual void TextOutlineColor(float r, float g, float b, float a) = 0;
-	virtual void TextOutlineColor(ColorRGBA rgb) = 0;
+	virtual void TextOutlineColor(ColorRGBA Color) = 0;
 	virtual void TextSelectionColor(float r, float g, float b, float a) = 0;
-	virtual void TextSelectionColor(ColorRGBA rgb) = 0;
+	virtual void TextSelectionColor(ColorRGBA Color) = 0;
 	virtual void Text(float x, float y, float Size, const char *pText, float LineWidth = -1.0f) = 0;
 	virtual float TextWidth(float Size, const char *pText, int StrLength = -1, float LineWidth = -1.0f, int Flags = 0, const STextSizeProperties &TextSizeProps = {}) = 0;
 	virtual STextBoundingBox TextBoundingBox(float Size, const char *pText, int StrLength = -1, float LineWidth = -1.0f, float LineSpacing = 0.0f, int Flags = 0) = 0;

src/game/alloc.h

@@ -22,9 +22,9 @@
 public: \
 	void *operator new(size_t Size) \
 	{ \
-		void *p = malloc(Size); \
-		mem_zero(p, Size); \
-		return p; \
+		void *pObj = malloc(Size); \
+		mem_zero(pObj, Size); \
+		return pObj; \
 	} \
 	void operator delete(void *pPtr) \
 	{ \
@@ -35,9 +35,9 @@ public: \
 
 #define MACRO_ALLOC_POOL_ID() \
 public: \
-	void *operator new(size_t Size, int id); \
-	void operator delete(void *p, int id); \
-	void operator delete(void *p); /* NOLINT(misc-new-delete-overloads) */ \
+	void *operator new(size_t Size, int Id); \
+	void operator delete(void *pObj, int Id); \
+	void operator delete(void *pObj); /* NOLINT(misc-new-delete-overloads) */ \
 \
 private:
 
@@ -51,30 +51,30 @@ public: \
 	static char gs_PoolData##POOLTYPE[PoolSize][MACRO_ALLOC_GET_SIZE(POOLTYPE)] = {{0}}; \
 	static int gs_PoolUsed##POOLTYPE[PoolSize] = {0}; \
 	MAYBE_UNUSED static int gs_PoolDummy##POOLTYPE = (ASAN_POISON_MEMORY_REGION(gs_PoolData##POOLTYPE, sizeof(gs_PoolData##POOLTYPE)), 0); \
-	void *POOLTYPE::operator new(size_t Size, int id) \
+	void *POOLTYPE::operator new(size_t Size, int Id) \
 	{ \
 		dbg_assert(sizeof(POOLTYPE) >= Size, "size error"); \
-		dbg_assert(!gs_PoolUsed##POOLTYPE[id], "already used"); \
-		ASAN_UNPOISON_MEMORY_REGION(gs_PoolData##POOLTYPE[id], sizeof(gs_PoolData##POOLTYPE[id])); \
-		gs_PoolUsed##POOLTYPE[id] = 1; \
-		mem_zero(gs_PoolData##POOLTYPE[id], sizeof(gs_PoolData##POOLTYPE[id])); \
-		return gs_PoolData##POOLTYPE[id]; \
+		dbg_assert(!gs_PoolUsed##POOLTYPE[Id], "already used"); \
+		ASAN_UNPOISON_MEMORY_REGION(gs_PoolData##POOLTYPE[Id], sizeof(gs_PoolData##POOLTYPE[Id])); \
+		gs_PoolUsed##POOLTYPE[Id] = 1; \
+		mem_zero(gs_PoolData##POOLTYPE[Id], sizeof(gs_PoolData##POOLTYPE[Id])); \
+		return gs_PoolData##POOLTYPE[Id]; \
 	} \
-	void POOLTYPE::operator delete(void *p, int id) \
+	void POOLTYPE::operator delete(void *pObj, int Id) \
 	{ \
-		dbg_assert(gs_PoolUsed##POOLTYPE[id], "not used"); \
-		dbg_assert(id == (POOLTYPE *)p - (POOLTYPE *)gs_PoolData##POOLTYPE, "invalid id"); \
-		gs_PoolUsed##POOLTYPE[id] = 0; \
-		mem_zero(gs_PoolData##POOLTYPE[id], sizeof(gs_PoolData##POOLTYPE[id])); \
-		ASAN_POISON_MEMORY_REGION(gs_PoolData##POOLTYPE[id], sizeof(gs_PoolData##POOLTYPE[id])); \
+		dbg_assert(gs_PoolUsed##POOLTYPE[Id], "not used"); \
+		dbg_assert(Id == (POOLTYPE *)pObj - (POOLTYPE *)gs_PoolData##POOLTYPE, "invalid id"); \
+		gs_PoolUsed##POOLTYPE[Id] = 0; \
+		mem_zero(gs_PoolData##POOLTYPE[Id], sizeof(gs_PoolData##POOLTYPE[Id])); \
+		ASAN_POISON_MEMORY_REGION(gs_PoolData##POOLTYPE[Id], sizeof(gs_PoolData##POOLTYPE[Id])); \
 	} \
-	void POOLTYPE::operator delete(void *p) /* NOLINT(misc-new-delete-overloads) */ \
+	void POOLTYPE::operator delete(void *pObj) /* NOLINT(misc-new-delete-overloads) */ \
 	{ \
-		int id = (POOLTYPE *)p - (POOLTYPE *)gs_PoolData##POOLTYPE; \
-		dbg_assert(gs_PoolUsed##POOLTYPE[id], "not used"); \
-		gs_PoolUsed##POOLTYPE[id] = 0; \
-		mem_zero(gs_PoolData##POOLTYPE[id], sizeof(gs_PoolData##POOLTYPE[id])); \
-		ASAN_POISON_MEMORY_REGION(gs_PoolData##POOLTYPE[id], sizeof(gs_PoolData##POOLTYPE[id])); \
+		int Id = (POOLTYPE *)pObj - (POOLTYPE *)gs_PoolData##POOLTYPE; \
+		dbg_assert(gs_PoolUsed##POOLTYPE[Id], "not used"); \
+		gs_PoolUsed##POOLTYPE[Id] = 0; \
+		mem_zero(gs_PoolData##POOLTYPE[Id], sizeof(gs_PoolData##POOLTYPE[Id])); \
+		ASAN_POISON_MEMORY_REGION(gs_PoolData##POOLTYPE[Id], sizeof(gs_PoolData##POOLTYPE[Id])); \
 	}
 
 #endif