From e95516032f4e44ea35b7358f60c464c0faa1df91 Mon Sep 17 00:00:00 2001
From: withmorten <morten.with@gmail.com>
Date: Thu, 29 Oct 2020 19:01:09 +0100
Subject: fix FINAL build, add DEBUGMENU and other simple qol defines to FINAL,
 add extra defines for menu and game version text

---
 src/rw/RwHelper.cpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'src/rw')

diff --git a/src/rw/RwHelper.cpp b/src/rw/RwHelper.cpp
index 4b598e9b..dbadae6a 100644
--- a/src/rw/RwHelper.cpp
+++ b/src/rw/RwHelper.cpp
@@ -6,8 +6,10 @@
 #include "Timecycle.h"
 #include "skeleton.h"
 #include "Debug.h"
-#ifndef FINAL
+#if !defined(FINAL) || defined(DEBUGMENU)
 #include "rtcharse.h"
+#endif
+#ifndef FINAL
 RtCharset *debugCharset;
 #endif
 
@@ -17,7 +19,7 @@ bool gPS2alphaTest = true;
 bool gPS2alphaTest = false;
 #endif
 
-#ifndef FINAL
+#if !defined(FINAL) || defined(DEBUGMENU)
 static bool charsetOpen;
 void OpenCharsetSafe()
 {
-- 
cgit v1.2.3


From 546ed0ff07cad63cb07612d8aff8d63213f71ecd Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Wed, 11 Nov 2020 09:42:30 +0100
Subject: changes to RW layer so loading foreign files works

---
 src/rw/RwHelper.cpp | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/rw/RwHelper.h   |  2 ++
 2 files changed, 79 insertions(+)

(limited to 'src/rw')

diff --git a/src/rw/RwHelper.cpp b/src/rw/RwHelper.cpp
index 35af1ebd..0069934f 100644
--- a/src/rw/RwHelper.cpp
+++ b/src/rw/RwHelper.cpp
@@ -649,6 +649,83 @@ WRAPPER void _TexturePoolsInitialise() { EAXJMP(0x598B10); }
 WRAPPER void _TexturePoolsShutdown() { EAXJMP(0x598B30); }
 #endif
 
+#ifdef LIBRW
+#include <rpmatfx.h>
+#include "VehicleModelInfo.h"
+
+int32
+findPlatform(rw::Atomic *a)
+{
+	rw::Geometry *g = a->geometry;
+	if(g->instData)
+		return g->instData->platform;
+	return 0;
+}
+
+// in CVehicleModelInfo in VC
+static RpMaterial*
+GetMatFXEffectMaterialCB(RpMaterial *material, void *data)
+{
+	if(RpMatFXMaterialGetEffects(material) == rpMATFXEFFECTNULL)
+		return material;
+	*(int*)data = RpMatFXMaterialGetEffects(material);
+	return nil;
+}
+
+// Game doesn't read atomic extensions so we never get any other than the default pipe,
+// but we need it for uninstancing
+void
+attachPipe(rw::Atomic *atomic)
+{
+	if(RpSkinGeometryGetSkin(RpAtomicGetGeometry(atomic)))
+		atomic->pipeline = rw::skinGlobals.pipelines[rw::platform];
+	else{
+		int fx = rpMATFXEFFECTNULL;
+		RpGeometryForAllMaterials(RpAtomicGetGeometry(atomic), GetMatFXEffectMaterialCB, &fx);
+		if(fx != rpMATFXEFFECTNULL)
+			RpMatFXAtomicEnableEffects(atomic);
+	}
+}
+
+// Attach pipes for the platform we have native data for so we can uninstance
+void
+switchPipes(rw::Atomic *a, int32 platform)
+{
+	if(a->pipeline && a->pipeline->platform != platform){
+		uint32 plgid = a->pipeline->pluginID;
+		switch(plgid){
+		// assume default pipe won't be attached explicitly
+		case rw::ID_SKIN:
+			a->pipeline = rw::skinGlobals.pipelines[platform];
+			break;
+		case rw::ID_MATFX:
+			a->pipeline = rw::matFXGlobals.pipelines[platform];
+			break;
+		}
+	}
+}
+
+RpAtomic*
+ConvertPlatformAtomic(RpAtomic *atomic, void *data)
+{
+	int32 driver = rw::platform;
+	int32 platform = findPlatform(atomic);
+	if(platform != 0 && platform != driver){
+		attachPipe(atomic);	// kludge
+		rw::ObjPipeline *origPipe = atomic->pipeline;
+		rw::platform = platform;
+		switchPipes(atomic, rw::platform);
+		if(atomic->geometry->flags & rw::Geometry::NATIVE)
+			atomic->uninstance();
+		// no ADC in this game
+		//rw::ps2::unconvertADC(atomic->geometry);
+		rw::platform = driver;
+		atomic->pipeline = origPipe;
+	}
+	return atomic;
+}
+#endif
+
 #if defined(FIX_BUGS) && defined(GTA_PC)
 RwUInt32 saved_alphafunc, saved_alpharef;
 
diff --git a/src/rw/RwHelper.h b/src/rw/RwHelper.h
index 130eb636..523a7732 100644
--- a/src/rw/RwHelper.h
+++ b/src/rw/RwHelper.h
@@ -56,6 +56,8 @@ RwCamera *CameraCreate(RwInt32 width,
 void _TexturePoolsInitialise();
 void _TexturePoolsShutdown();
 
+RpAtomic *ConvertPlatformAtomic(RpAtomic *atomic, void *data);
+
 #if defined(FIX_BUGS) && defined (GTA_PC)
 void SetAlphaTest(RwUInt32 alpharef);
 void RestoreAlphaTest();
-- 
cgit v1.2.3


From 82b0103c6789041b721b1de30746ce21a556ab4d Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Wed, 18 Nov 2020 10:27:55 +0100
Subject: changes to librw layer, GLES now runtime choice

---
 src/rw/TexRead.cpp | 92 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 88 insertions(+), 4 deletions(-)

(limited to 'src/rw')

diff --git a/src/rw/TexRead.cpp b/src/rw/TexRead.cpp
index 33d9a4cb..0a0ed04b 100644
--- a/src/rw/TexRead.cpp
+++ b/src/rw/TexRead.cpp
@@ -150,11 +150,80 @@ RwTexDictionaryGtaStreamRead2(RwStream *stream, RwTexDictionary *texDict)
 }
 
 #ifdef GTA_PC
-#ifdef RWLIBS
-extern "C" RwInt32 _rwD3D8FindCorrectRasterFormat(RwRasterType type, RwInt32 flags);
-#else
-RwInt32 _rwD3D8FindCorrectRasterFormat(RwRasterType type, RwInt32 flags);
+
+#ifdef LIBRW
+
+#define CAPSVERSION 0
+
+struct GPUcaps
+{
+	uint32 version;	// so we can force regeneration easily
+	uint32 platform;
+	uint32 subplatform;
+	uint32 dxtSupport;
+};
+
+static void
+GetGPUcaps(GPUcaps *caps)
+{
+	caps->version = CAPSVERSION;
+	caps->platform = rw::platform;
+	caps->subplatform = 0;
+	caps->dxtSupport = 0;
+	// TODO: more later
+#ifdef RW_GL3
+	caps->subplatform = rw::gl3::gl3Caps.gles;
+	caps->dxtSupport = rw::gl3::gl3Caps.dxtSupported;
+#endif
+#ifdef RW_D3D9
+	caps->dxtSupport = 1;	// TODO, probably
 #endif
+}
+
+void
+ReadVideoCardCapsFile(GPUcaps *caps)
+{
+	memset(caps, 0, sizeof(GPUcaps));
+
+	int32 file = CFileMgr::OpenFile("DATA\\CAPS.DAT", "rb");
+	if (file != 0) {
+		CFileMgr::Read(file, (char*)&caps->version, 4);
+		CFileMgr::Read(file, (char*)&caps->platform, 4);
+		CFileMgr::Read(file, (char*)&caps->subplatform, 4);
+		CFileMgr::Read(file, (char*)&caps->dxtSupport, 4);
+		CFileMgr::CloseFile(file);
+	}
+}
+
+bool
+CheckVideoCardCaps(void)
+{
+	GPUcaps caps, fcaps;
+	GetGPUcaps(&caps);
+	ReadVideoCardCapsFile(&fcaps);
+	return caps.version != fcaps.version ||
+		caps.platform != fcaps.platform ||
+		caps.subplatform != fcaps.subplatform ||
+		caps.dxtSupport != fcaps.dxtSupport;
+}
+
+void
+WriteVideoCardCapsFile(void)
+{
+	GPUcaps caps;
+	GetGPUcaps(&caps);
+	int32 file = CFileMgr::OpenFile("DATA\\CAPS.DAT", "wb");
+	if (file != 0) {
+		CFileMgr::Write(file, (char*)&caps.version, 4);
+		CFileMgr::Write(file, (char*)&caps.platform, 4);
+		CFileMgr::Write(file, (char*)&caps.subplatform, 4);
+		CFileMgr::Write(file, (char*)&caps.dxtSupport, 4);
+		CFileMgr::CloseFile(file);
+	}
+}
+
+#else
+extern "C" RwInt32 _rwD3D8FindCorrectRasterFormat(RwRasterType type, RwInt32 flags);
 void
 ReadVideoCardCapsFile(uint32 &cap32, uint32 &cap24, uint32 &cap16, uint32 &cap8)
 {
@@ -201,6 +270,7 @@ WriteVideoCardCapsFile(void)
 		CFileMgr::CloseFile(file);
 	}
 }
+#endif
 
 void
 ConvertingTexturesScreen(uint32 num, uint32 count, const char *text)
@@ -281,6 +351,13 @@ CreateTxdImageForVideoCard()
 		return false;
 	}
 
+#ifdef LIBRW
+	// so we can read back DXT with GLES
+	// only works for textures that are not yet loaded
+	// so let's hope that is the case for all
+	rw::gl3::needToReadBackTextures = true;
+#endif
+
 	int32 i;
 	for (i = 0; i < TXDSTORESIZE; i++) {
 		ConvertingTexturesScreen(i, TXDSTORESIZE, "CVT_MSG");
@@ -308,6 +385,9 @@ CreateTxdImageForVideoCard()
 					delete []buf;
 					delete pDir;
 					CStreaming::RemoveTxd(i);
+#ifdef LIBRW
+					rw::gl3::needToReadBackTextures = false;
+#endif
 					return false;
 				}
 
@@ -334,6 +414,10 @@ CreateTxdImageForVideoCard()
 	RwStreamClose(img, nil);
 	delete []buf;
 
+#ifdef LIBRW
+	rw::gl3::needToReadBackTextures = false;
+#endif
+
 	if (!pDir->WriteDirFile("models\\txd.dir")) {
 		DealWithTxdWriteError(i, TXDSTORESIZE, "CVT_ERR");
 		delete pDir;
-- 
cgit v1.2.3


From 9826fdf6d5a324b316e59a34feeb0da9ffca56cc Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Wed, 18 Nov 2020 11:16:02 +0100
Subject: more fixes to librw stuff

---
 src/rw/TexRead.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'src/rw')

diff --git a/src/rw/TexRead.cpp b/src/rw/TexRead.cpp
index 0a0ed04b..72d2ae17 100644
--- a/src/rw/TexRead.cpp
+++ b/src/rw/TexRead.cpp
@@ -351,7 +351,7 @@ CreateTxdImageForVideoCard()
 		return false;
 	}
 
-#ifdef LIBRW
+#ifdef RW_GL3
 	// so we can read back DXT with GLES
 	// only works for textures that are not yet loaded
 	// so let's hope that is the case for all
@@ -385,7 +385,7 @@ CreateTxdImageForVideoCard()
 					delete []buf;
 					delete pDir;
 					CStreaming::RemoveTxd(i);
-#ifdef LIBRW
+#ifdef RW_GL3
 					rw::gl3::needToReadBackTextures = false;
 #endif
 					return false;
@@ -414,7 +414,7 @@ CreateTxdImageForVideoCard()
 	RwStreamClose(img, nil);
 	delete []buf;
 
-#ifdef LIBRW
+#ifdef RW_GL3
 	rw::gl3::needToReadBackTextures = false;
 #endif
 
-- 
cgit v1.2.3


From 07303c62d12959927cbb72d4beb131f2647350fa Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Sun, 22 Nov 2020 00:13:07 +0100
Subject: finished cullzones

---
 src/rw/VisibilityPlugins.cpp | 2 --
 1 file changed, 2 deletions(-)

(limited to 'src/rw')

diff --git a/src/rw/VisibilityPlugins.cpp b/src/rw/VisibilityPlugins.cpp
index 8878a26a..3f10d12a 100644
--- a/src/rw/VisibilityPlugins.cpp
+++ b/src/rw/VisibilityPlugins.cpp
@@ -11,8 +11,6 @@
 #include "World.h"
 #include "custompipes.h"
 
-#define FADE_DISTANCE 20.0f
-
 CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaList;
 CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaEntityList;
 
-- 
cgit v1.2.3


From b6da31cfaa021559939ed596d18a27f4db6acebc Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Mon, 23 Nov 2020 09:38:51 +0100
Subject: two unused functions

---
 src/rw/Lights.cpp | 41 +++++++++++++++++++++++++++++++++++++++++
 src/rw/Lights.h   |  2 ++
 2 files changed, 43 insertions(+)

(limited to 'src/rw')

diff --git a/src/rw/Lights.cpp b/src/rw/Lights.cpp
index 5a253854..b3cef6d4 100644
--- a/src/rw/Lights.cpp
+++ b/src/rw/Lights.cpp
@@ -3,6 +3,7 @@
 #include <rpworld.h>
 
 #include "Lights.h"
+#include "Timer.h"
 #include "Timecycle.h"
 #include "Coronas.h"
 #include "Weather.h"
@@ -248,6 +249,46 @@ SetAmbientAndDirectionalColours(float f)
 	RpLightSetColor(pDirect, &DirectionalLightColour);
 }
 
+// unused
+void
+SetFlashyColours(float f)
+{
+	if(CTimer::GetTimeInMilliseconds() & 0x100){
+		AmbientLightColour.red = 1.0f;
+		AmbientLightColour.green = 1.0f;
+		AmbientLightColour.blue = 1.0f;
+
+		DirectionalLightColour.red = DirectionalLightColourForFrame.red;
+		DirectionalLightColour.green = DirectionalLightColourForFrame.green;
+		DirectionalLightColour.blue = DirectionalLightColourForFrame.blue;
+
+		RpLightSetColor(pAmbient, &AmbientLightColour);
+		RpLightSetColor(pDirect, &DirectionalLightColour);
+	}else{
+		SetAmbientAndDirectionalColours(f * 0.75f);
+	}
+}
+
+// unused
+void
+SetFlashyColours_Mild(float f)
+{
+	if(CTimer::GetTimeInMilliseconds() & 0x100){
+		AmbientLightColour.red = 0.65f;
+		AmbientLightColour.green = 0.65f;
+		AmbientLightColour.blue = 0.65f;
+
+		DirectionalLightColour.red = DirectionalLightColourForFrame.red;
+		DirectionalLightColour.green = DirectionalLightColourForFrame.green;
+		DirectionalLightColour.blue = DirectionalLightColourForFrame.blue;
+
+		RpLightSetColor(pAmbient, &AmbientLightColour);
+		RpLightSetColor(pDirect, &DirectionalLightColour);
+	}else{
+		SetAmbientAndDirectionalColours(f * 0.9f);
+	}
+}
+
 void
 SetBrightMarkerColours(float f)
 {
diff --git a/src/rw/Lights.h b/src/rw/Lights.h
index b296816b..5057f1d0 100644
--- a/src/rw/Lights.h
+++ b/src/rw/Lights.h
@@ -14,6 +14,8 @@ void WorldReplaceScorchedLightsWithNormal(RpWorld *world);
 void AddAnExtraDirectionalLight(RpWorld *world, float dirx, float diry, float dirz, float red, float green, float blue);
 void RemoveExtraDirectionalLights(RpWorld *world);
 void SetAmbientAndDirectionalColours(float f);
+void SetFlashyColours(float f);
+void SetFlashyColours_Mild(float f);
 void SetBrightMarkerColours(float f);
 void ReSetAmbientAndDirectionalColours(void);
 void DeActivateDirectional(void);
-- 
cgit v1.2.3


From 88baa9ce5f22a788a1033040040185001a87f922 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Wed, 25 Nov 2020 20:03:44 +0100
Subject: implemented CMemoryHeap, not used or tested yet

---
 src/rw/MemoryHeap.cpp | 548 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/rw/MemoryHeap.h   | 188 +++++++++++++++++
 2 files changed, 736 insertions(+)
 create mode 100644 src/rw/MemoryHeap.cpp
 create mode 100644 src/rw/MemoryHeap.h

(limited to 'src/rw')

diff --git a/src/rw/MemoryHeap.cpp b/src/rw/MemoryHeap.cpp
new file mode 100644
index 00000000..d613a708
--- /dev/null
+++ b/src/rw/MemoryHeap.cpp
@@ -0,0 +1,548 @@
+#include "common.h"
+#include "main.h"
+#include "FileMgr.h"
+#include "Timer.h"
+#include "ModelInfo.h"
+#include "Streaming.h"
+#include "FileLoader.h"
+#include "MemoryHeap.h"
+
+#ifdef USE_CUSTOM_ALLOCATOR
+
+#define MEMORYHEAP_ASSERT(cond) { if (!(cond)) { printf("ASSERT File:%s Line:%d\n", __FILE__, __LINE__); exit(1); } }
+#define MEMORYHEAP_ASSERT_MESSAGE(cond, message) { if (!(cond)) { printf("ASSERT File:%s Line:%d:\n\t%s\n", __FILE__, __LINE__, message); exit(1); } }
+
+// registered pointers that we keep track of
+void **gPtrList[4000];
+int32 numPtrs;
+int32 gPosnInList;
+// indices into the ptr list in here are free
+CStack<int32, 4000> m_ptrListIndexStack;
+// how much memory we've moved
+uint32 memMoved;
+
+CMemoryHeap gMainHeap;
+
+void
+CMemoryHeap::Init(uint32 total)
+{
+	MEMORYHEAP_ASSERT((total != 0xF) != 0);
+
+	m_totalMemUsed = 0;
+	m_memUsed = nil;
+	m_currentMemID = MEMID_FREE;
+	m_blocksUsed = nil;
+	m_totalBlocksUsed = 0;
+	m_unkMemId = -1;
+
+	uint8 *mem = (uint8*)malloc(total);
+	assert(((uintptr)mem & 0xF) == 0);
+	m_start = (HeapBlockDesc*)mem;
+	m_end = (HeapBlockDesc*)(mem + total - sizeof(HeapBlockDesc));
+	m_start->m_memId = MEMID_FREE;
+	m_start->m_size = total - 2*sizeof(HeapBlockDesc);
+	m_end->m_memId = MEMID_ID1;
+	m_end->m_size = 0;
+
+	m_freeList.m_last.m_size = INT_MAX;
+	m_freeList.Init();
+	m_freeList.Insert(m_start);
+
+	// TODO: figure out what these are and use sizeof
+	m_fixedSize[0].Init(0x10);
+	m_fixedSize[1].Init(0x20);
+	m_fixedSize[2].Init(0xE0);
+	m_fixedSize[3].Init(0x60);
+	m_fixedSize[4].Init(0x1C0);
+	m_fixedSize[5].Init(0x50);
+
+	m_currentMemID = MEMID_FREE;	// disable registration
+	m_memUsed = (uint32*)Malloc(NUM_MEMIDS * sizeof(uint32));
+	m_blocksUsed = (uint32*)Malloc(NUM_MEMIDS * sizeof(uint32));
+	RegisterMalloc(GetDescFromHeapPointer(m_memUsed));
+	RegisterMalloc(GetDescFromHeapPointer(m_blocksUsed));
+
+	m_currentMemID = MEMID_ID1;
+	for(int i = 0; i < NUM_MEMIDS; i++){
+		m_memUsed[i] = 0;
+		m_blocksUsed[i] = 0;
+	}
+}
+
+void
+CMemoryHeap::RegisterMalloc(HeapBlockDesc *block)
+{
+	block->m_memId = m_currentMemID;
+	if(m_currentMemID == MEMID_FREE)
+		return;
+	m_totalMemUsed += block->m_size + sizeof(HeapBlockDesc);
+	m_memUsed[m_currentMemID] += block->m_size + sizeof(HeapBlockDesc);
+	m_blocksUsed[m_currentMemID]++;
+	m_totalBlocksUsed++;
+}
+
+void
+CMemoryHeap::RegisterFree(HeapBlockDesc *block)
+{
+	if(block->m_memId == MEMID_FREE)
+		return;
+	m_totalMemUsed -= block->m_size + sizeof(HeapBlockDesc);
+	m_memUsed[m_currentMemID] -= block->m_size + sizeof(HeapBlockDesc);
+	m_blocksUsed[m_currentMemID]--;
+	m_totalBlocksUsed--;
+}
+
+void*
+CMemoryHeap::Malloc(uint32 size)
+{
+	static int recursion = 0;
+
+	// weird way to round up
+	if((size & 0xF) != 0)
+		size = (size&~0xF) + 0x10;
+
+	recursion++;
+
+	// See if we can allocate from one of the fixed-size lists
+	for(int i = 0; i < NUM_FIXED_MEMBLOCKS; i++){
+		CommonSize *list = &m_fixedSize[i];
+		if(m_fixedSize[i].m_size == size){
+			HeapBlockDesc *block = list->Malloc();
+			if(block){
+				RegisterMalloc(block);
+				recursion--;
+				return block->GetDataPointer();
+			}
+			break;
+		}
+	}
+
+	// now try the normal free list
+	HeapBlockDesc *next;
+	for(HeapBlockDesc *block = m_freeList.m_first.m_next;
+	    block != &m_freeList.m_last;
+	    block = next){
+		MEMORYHEAP_ASSERT(block->m_memId == MEMID_FREE);
+		MEMORYHEAP_ASSERT_MESSAGE(block >= m_start && block <= m_end, "Block outside of memory");
+
+		// make sure block has maximum size
+		uint32 initialsize = block->m_size;
+		uint32 blocksize = CombineFreeBlocks(block);
+#ifdef FIX_BUGS
+		// has to be done here because block can be moved
+		next = block->m_next;
+#endif
+		if(initialsize != blocksize){
+			block->RemoveHeapFreeBlock();
+			HeapBlockDesc *pos = block->m_prev->FindSmallestFreeBlock(block->m_size);
+			block->InsertHeapFreeBlock(pos->m_prev);
+		}
+		if(block->m_size >= size){
+			// got space to allocate from!
+			block->RemoveHeapFreeBlock();
+			FillInBlockData(block, block->GetNextConsecutive(), size);
+			recursion--;
+			return block->GetDataPointer();
+		}
+#ifndef FIX_BUGS
+		next = block->m_next;
+#endif
+	}
+
+	// oh no, we're losing, try to free some stuff
+	static bool removeCollision = false;
+	static bool removeIslands = false;
+	static bool removeBigBuildings = false;
+	size_t initialMemoryUsed = CStreaming::ms_memoryUsed;
+	CStreaming::MakeSpaceFor(0xCFE800 - CStreaming::ms_memoryUsed);
+	if (recursion > 10)
+		CGame::TidyUpMemory(true, false);
+	else if (recursion > 6)
+		CGame::TidyUpMemory(false, true);
+	if (initialMemoryUsed == CStreaming::ms_memoryUsed && recursion > 11) {
+		if (!removeCollision && !CGame::playingIntro) {
+			CModelInfo::RemoveColModelsFromOtherLevels(LEVEL_GENERIC);
+			removeCollision = true;
+		}
+		else if (!removeIslands && !CGame::playingIntro) {
+			CStreaming::RemoveIslandsNotUsed(LEVEL_INDUSTRIAL);
+			CStreaming::RemoveIslandsNotUsed(LEVEL_COMMERCIAL);
+			CStreaming::RemoveIslandsNotUsed(LEVEL_SUBURBAN);
+			removeIslands = true;
+		}
+		else if (!removeBigBuildings) {
+			CStreaming::RemoveBigBuildings(LEVEL_INDUSTRIAL);
+			CStreaming::RemoveBigBuildings(LEVEL_COMMERCIAL);
+			CStreaming::RemoveBigBuildings(LEVEL_SUBURBAN);
+		}
+		else {
+			LoadingScreen("NO MORE MEMORY", nil, nil);
+			LoadingScreen("NO MORE MEMORY", nil, nil);
+		}
+		CGame::TidyUpMemory(true, false);
+	}
+	void *mem = Malloc(size);
+	if (removeCollision) {
+		CTimer::Stop();
+		// different on PS2
+		CFileLoader::LoadCollisionFromDatFile(CCollision::ms_collisionInMemory);
+		removeCollision = false;
+		CTimer::Update();
+	}
+	if (removeBigBuildings || removeIslands) {
+		CTimer::Stop();
+		if (!CGame::playingIntro)
+			CStreaming::RequestBigBuildings(CGame::currLevel);
+		CStreaming::LoadAllRequestedModels(true);
+		removeBigBuildings = false;
+		removeIslands = false;
+		CTimer::Update();
+	}
+	recursion--;
+	return mem;
+}
+
+void*
+CMemoryHeap::Realloc(void *ptr, uint32 size)
+{
+	if(ptr == nil)
+		return Malloc(size);
+
+	// weird way to round up
+	if((size & 0xF) != 0)
+		size = (size&~0xF) + 0x10;
+
+	HeapBlockDesc *block = GetDescFromHeapPointer(ptr);
+
+#ifdef FIX_BUGS
+	// better handling of size < block->m_size
+	if(size == 0){
+		Free(ptr);
+		return nil;
+	}
+	if(block->m_size >= size){
+		// shrink allocated block
+		RegisterFree(block);
+		PushMemId(block->m_memId);
+		FillInBlockData(block, block->GetNextConsecutive(), size);
+		PopMemId();
+		return ptr;
+	}
+#else
+	// not growing. just returning here is a bit cheap though
+	if(block->m_size >= size)
+		return ptr;
+#endif
+
+	// have to grow allocated block
+	HeapBlockDesc *next = block->GetNextConsecutive();
+	MEMORYHEAP_ASSERT_MESSAGE(next >= m_start && next <= m_end, "Block outside of memory");
+	if(next->m_memId == MEMID_FREE){
+		// try to grow the current block
+		// make sure the next free block has maximum size
+		uint32 freespace = CombineFreeBlocks(next);
+		HeapBlockDesc *end = next->GetNextConsecutive();
+		MEMORYHEAP_ASSERT_MESSAGE(end >= m_start && end <= m_end, "Block outside of memory");
+		// why the sizeof here?
+		if(block->m_size + next->m_size + sizeof(HeapBlockDesc) >= size){
+			// enough space to grow
+			next->RemoveHeapFreeBlock();
+			RegisterFree(block);
+			PushMemId(block->m_memId);
+			FillInBlockData(block, next->GetNextConsecutive(), size);
+			PopMemId();
+			return ptr;
+		}
+	}
+
+	// can't grow the existing block, have to get a new one and copy
+	PushMemId(block->m_memId);
+	void *dst = Malloc(size);
+	PopMemId();
+	memcpy(dst, ptr, block->m_size);
+	Free(ptr);
+	return dst;
+}
+
+void
+CMemoryHeap::Free(void *ptr)
+{
+	HeapBlockDesc *block = GetDescFromHeapPointer(ptr);
+	MEMORYHEAP_ASSERT_MESSAGE(block->m_memId != MEMID_FREE, "MemoryHeap corrupt");
+	MEMORYHEAP_ASSERT(m_unkMemId == -1 || m_unkMemId == block->m_memId);
+
+	RegisterFree(block);
+	CombineFreeBlocks(block);
+	FreeBlock(block);
+	if(block->m_ptrListIndex != -1){
+		int32 idx = block->m_ptrListIndex;
+		gPtrList[idx] = nil;
+		m_ptrListIndexStack.push(idx);
+	}
+	block->m_ptrListIndex = -1;
+}
+
+// allocate 'size' bytes from 'block'
+void
+CMemoryHeap::FillInBlockData(HeapBlockDesc *block, HeapBlockDesc *end, uint32 size)
+{
+	block->m_size = size;
+	block->m_ptrListIndex = -1;
+	HeapBlockDesc *remainder = block->GetNextConsecutive();
+	MEMORYHEAP_ASSERT(remainder <= end);
+
+	if(remainder < end-1){
+		RegisterMalloc(block);
+
+		// can fit another block in the remaining space
+		remainder->m_size = GetSizeBetweenBlocks(remainder, end);
+		remainder->m_memId = MEMID_FREE;
+		MEMORYHEAP_ASSERT(remainder->m_size != 0);
+		FreeBlock(remainder);
+	}else{
+		// fully allocate this one
+		if(remainder < end)
+			// no gaps allowed
+			block->m_size = GetSizeBetweenBlocks(block, end);
+		RegisterMalloc(block);
+	}
+}
+
+// Make sure free block has no other free blocks after it
+uint32
+CMemoryHeap::CombineFreeBlocks(HeapBlockDesc *block)
+{
+	HeapBlockDesc *next = block->GetNextConsecutive();
+	if(next->m_memId == MEMID_FREE)
+		return block->m_size;
+	// get rid of free blocks after this one and adjust size
+	for(; next->m_memId == MEMID_FREE; next = next->GetNextConsecutive())
+		next->RemoveHeapFreeBlock();
+	block->m_size = GetSizeBetweenBlocks(block, next);
+	return block->m_size;
+}
+
+// Try to move all registered memory blocks into more optimal location
+void
+CMemoryHeap::TidyHeap(void)
+{
+	for(int i = 0; i < numPtrs; i++){
+		if(gPtrList[i] == nil || *gPtrList[i] == nil)
+			continue;
+		HeapBlockDesc *newblock = WhereShouldMemoryMove(*gPtrList[i]);
+		if(newblock)
+			*gPtrList[i] = MoveHeapBlock(newblock, GetDescFromHeapPointer(*gPtrList[i]));
+	}
+}
+
+// 
+void
+CMemoryHeap::RegisterMemPointer(void *ptr)
+{
+	HeapBlockDesc *block = GetDescFromHeapPointer(*(void**)ptr);
+
+	if(block->m_ptrListIndex != -1)
+		return;		// already registered
+
+	int index;
+	if(m_ptrListIndexStack.sp > 0){
+		// re-use a previously free'd index
+		index = m_ptrListIndexStack.pop();
+	}else{
+		// have to find a new index
+		index = gPosnInList;
+
+		void **pp = gPtrList[index];
+		// we're replacing an old pointer here??
+		if(pp && *pp && *pp != (void*)0xDDDDDDDD)
+			GetDescFromHeapPointer(*pp)->m_ptrListIndex = -1;
+
+		gPosnInList++;
+		if(gPosnInList == 4000)
+			gPosnInList = 0;
+		if(numPtrs < 4000)
+			numPtrs++;
+	}
+	gPtrList[index] = (void**)ptr;
+	block->m_ptrListIndex = index;
+}
+
+void*
+CMemoryHeap::MoveMemory(void *ptr)
+{
+	HeapBlockDesc *newblock = WhereShouldMemoryMove(ptr);
+	if(newblock)
+		return MoveHeapBlock(newblock, GetDescFromHeapPointer(ptr));
+	else
+		return ptr;
+}
+
+HeapBlockDesc*
+CMemoryHeap::WhereShouldMemoryMove(void *ptr)
+{
+	HeapBlockDesc *block = GetDescFromHeapPointer(ptr);
+	MEMORYHEAP_ASSERT(block->m_memId != MEMID_FREE);
+
+	HeapBlockDesc *next = block->GetNextConsecutive();
+	if(next->m_memId != MEMID_FREE)
+		return nil;
+
+	// we want to move the block into another block
+	// such that the free space between this and the next block can be minimized
+	HeapBlockDesc *newblock = m_freeList.m_first.FindSmallestFreeBlock(block->m_size);
+	// size of free space wouldn't decrease, so return
+	if(newblock->m_size >= block->m_size + next->m_size)
+		return nil;
+	// size of free space wouldn't decrease enough
+	if(newblock->m_size >= 16 + 1.125f*block->m_size)	// what are 16 and 1.125 here? sizeof(HeapBlockDesc)?
+		return nil;
+	return newblock;
+}
+
+void*
+CMemoryHeap::MoveHeapBlock(HeapBlockDesc *dst, HeapBlockDesc *src)
+{
+	PushMemId(src->m_memId);
+	dst->RemoveHeapFreeBlock();
+	FillInBlockData(dst, dst->GetNextConsecutive(), src->m_size);
+	PopMemId();
+	memcpy(dst->GetDataPointer(), src->GetDataPointer(), src->m_size);
+	memMoved += src->m_size;
+	dst->m_ptrListIndex = src->m_ptrListIndex;
+	src->m_ptrListIndex = -1;
+	Free(src->GetDataPointer());
+	return dst->GetDataPointer();
+}
+
+uint32
+CMemoryHeap::GetMemoryUsed(int32 id)
+{
+	return m_memUsed[id];
+}
+
+uint32
+CMemoryHeap::GetBlocksUsed(int32 id)
+{
+	return m_blocksUsed[id];
+}
+
+void
+CMemoryHeap::PopMemId(void)
+{
+	m_currentMemID = m_idStack.pop();
+}
+
+void
+CMemoryHeap::PushMemId(int32 id)
+{
+	MEMORYHEAP_ASSERT(id != MEMID_FREE);
+	m_idStack.push(m_currentMemID);
+	m_currentMemID = id;
+}
+
+void
+CMemoryHeap::ParseHeap(void)
+{
+	char tmp[16];
+	int fd = CFileMgr::OpenFileForWriting("heap.txt");
+	CTimer::Stop();
+
+	// CMemoryHeap::IntegrityCheck();
+
+	uint32 addrQW = 0;
+	for(HeapBlockDesc *block = m_start; block < m_end; block = block->GetNextConsecutive()){
+		char chr = '*';	// free
+		if(block->m_memId != MEMID_FREE)
+			chr = block->m_memId-MEMID_ID1 + 'A';
+		int numQW = block->m_size>>4;
+
+		if((addrQW & 0x3F) == 0){
+			sprintf(tmp, "\n%5dK:", addrQW>>6);
+			CFileMgr::Write(fd, tmp, 8);
+		}
+		CFileMgr::Write(fd, "#", 1);	// the descriptor, has to be 16 bytes!!!!
+		addrQW++;
+
+		while(numQW--){
+			if((addrQW & 0x3F) == 0){
+				sprintf(tmp, "\n%5dK:", addrQW>>6);
+				CFileMgr::Write(fd, tmp, 8);
+			}
+			CFileMgr::Write(fd, &chr, 1);
+			addrQW++;
+		}
+	}
+
+	CTimer::Update();
+	CFileMgr::CloseFile(fd);
+}
+
+
+void
+CommonSize::Init(uint32 size)
+{
+	m_freeList.Init();
+	m_size = size;
+	m_failed = 0;
+	m_remaining = 0;
+}
+
+
+
+void *pMemoryTop;
+
+void
+InitMemoryMgr(void)
+{
+#ifdef GTA_PS2
+#error "finish this"
+#else
+	// randomly allocate 128mb
+	gMainHeap.Init(128*1024*1024);
+#endif
+}
+
+void*
+MemoryMgrMalloc(uint32 size)
+{
+	void *mem = gMainHeap.Malloc(size);
+	if(mem > pMemoryTop)
+		pMemoryTop = mem;
+	return mem;
+}
+
+void*
+MemoryMgrRealloc(void *ptr, uint32 size)
+{
+	void *mem = gMainHeap.Realloc(ptr, size);
+	if(mem > pMemoryTop)
+		pMemoryTop = mem;
+	return mem;
+}
+
+void*
+MemoryMgrCalloc(uint32 num, uint32 size)
+{
+	void *mem = gMainHeap.Malloc(num*size);
+	if(mem > pMemoryTop)
+		pMemoryTop = mem;
+#ifdef FIX_BUGS
+	memset(mem, 0, num*size);
+#endif
+	return mem;
+}
+
+void
+MemoryMgrFree(void *ptr)
+{
+	gMainHeap.Free(ptr);
+}
+
+RwMemoryFunctions memFuncs = {
+	MemoryMgrMalloc,
+	MemoryMgrFree,
+	MemoryMgrRealloc,
+	MemoryMgrCalloc
+};
+
+#endif
diff --git a/src/rw/MemoryHeap.h b/src/rw/MemoryHeap.h
new file mode 100644
index 00000000..840e016a
--- /dev/null
+++ b/src/rw/MemoryHeap.h
@@ -0,0 +1,188 @@
+#pragma once
+
+extern RwMemoryFunctions memFuncs;
+
+template<typename T, uint32 N>
+class CStack
+{
+public:
+	T values[N];
+	uint32 sp;
+
+	CStack() : sp(0) {}
+	void push(const T& val) { values[sp++] = val; }
+	T& pop() { return values[sp--]; }
+};
+
+
+struct HeapBlockDesc
+{
+	uint32 m_size;
+	int16 m_memId;
+	int16 m_ptrListIndex;
+	HeapBlockDesc *m_next;
+	HeapBlockDesc *m_prev;
+
+	HeapBlockDesc *GetNextConsecutive(void)
+	{
+		return (HeapBlockDesc*)((uintptr)this + sizeof(HeapBlockDesc) + m_size);
+	}
+
+	void *GetDataPointer(void)
+	{
+		return (void*)((uintptr)this + sizeof(HeapBlockDesc));
+	}
+
+	void RemoveHeapFreeBlock(void)
+	{
+		m_next->m_prev = m_prev;
+		m_prev->m_next = m_next;
+	}
+
+	// after node
+	void InsertHeapFreeBlock(HeapBlockDesc *node)
+	{
+		m_next = node->m_next;
+		node->m_next->m_prev = this;
+		m_prev = node;
+		node->m_next = this;
+	}
+
+	HeapBlockDesc *FindSmallestFreeBlock(uint32 size)
+	{
+		HeapBlockDesc *b;
+		for(b = m_next; b->m_size < size; b = b->m_next);
+		return b;
+	}
+};
+
+static_assert(sizeof(HeapBlockDesc) == 0x10, "HeapBlockDesc must have 0x10 size otherwise most of assumptions don't make sense");
+
+struct HeapBlockList
+{
+	HeapBlockDesc m_first;
+	HeapBlockDesc m_last;
+
+	void Init(void)
+	{
+		m_first.m_next = &m_last;
+		m_last.m_prev = &m_first;
+	}
+
+	void Insert(HeapBlockDesc *node)
+	{
+		node->InsertHeapFreeBlock(&m_first);
+	}
+};
+
+struct CommonSize
+{
+	HeapBlockList m_freeList;
+	uint32 m_size;
+	uint32 m_failed;
+	uint32 m_remaining;
+
+	void Init(uint32 size);
+	void Free(HeapBlockDesc *node)
+	{
+		m_freeList.Insert(node);
+		m_remaining++;
+	}
+	HeapBlockDesc *Malloc(void)
+	{
+		if(m_freeList.m_first.m_next == &m_freeList.m_last){
+			m_failed++;
+			return nil;
+		}
+		HeapBlockDesc *block = m_freeList.m_first.m_next;
+		m_remaining--;
+		block->RemoveHeapFreeBlock();
+		block->m_ptrListIndex = -1;
+		return block;
+	}
+};
+
+enum {
+	MEMID_FREE,
+	// IDs from LCS:
+	MEMID_ID1,	// "Game"
+	MEMID_ID2,	// "World"
+	MEMID_ID3,	// "Animation"
+	MEMID_ID4,	// "Pools"
+	MEMID_ID5,	// "Default Models"
+	MEMID_ID6,	// "Streaming"
+	MEMID_ID7,	// "Streamed Models"
+	MEMID_ID8,	// "Streamed LODs"
+	MEMID_ID9,	// "Streamed Textures"
+	MEMID_ID10,	// "Streamed Collision"
+	MEMID_ID11,	// "Streamed Animation"
+	MEMID_ID12,	// "Textures"
+	MEMID_ID13,	// "Collision"
+	MEMID_ID14,	// "PreAlloc"
+	MEMID_ID15,	// "Game Process"
+	MEMID_ID16,	// "Script"
+	MEMID_ID17,	// "Cars"
+	MEMID_ID18,	// "Render"
+	MEMID_ID19,	// "Ped Attr"
+
+	NUM_MEMIDS,
+
+	NUM_FIXED_MEMBLOCKS = 6
+};
+
+class CMemoryHeap
+{
+public:
+	HeapBlockDesc *m_start;
+	HeapBlockDesc *m_end;
+	HeapBlockList m_freeList;
+	CommonSize m_fixedSize[NUM_FIXED_MEMBLOCKS];
+	uint32 m_totalMemUsed;
+	CStack<int32, 16> m_idStack;
+	uint32 m_currentMemID;
+	uint32 *m_memUsed;
+	uint32 m_totalBlocksUsed;
+	uint32 *m_blocksUsed;
+	uint32 m_unkMemId;
+
+	CMemoryHeap(void) : m_start(nil) {}
+	void Init(uint32 total);
+	void RegisterMalloc(HeapBlockDesc *block);
+	void RegisterFree(HeapBlockDesc *block);
+	void *Malloc(uint32 size);
+	void *Realloc(void *ptr, uint32 size);
+	void Free(void *ptr);
+	void FillInBlockData(HeapBlockDesc *block, HeapBlockDesc *end, uint32 size);
+	uint32 CombineFreeBlocks(HeapBlockDesc *block);
+	void *MoveMemory(void *ptr);
+	HeapBlockDesc *WhereShouldMemoryMove(void *ptr);
+	void *MoveHeapBlock(HeapBlockDesc *dst, HeapBlockDesc *src);
+	void PopMemId(void);
+	void PushMemId(int32 id);
+	void RegisterMemPointer(void *ptr);
+	void TidyHeap(void);
+	uint32 GetMemoryUsed(int32 id);
+	uint32 GetBlocksUsed(int32 id);
+
+	void ParseHeap(void);
+
+	HeapBlockDesc *GetDescFromHeapPointer(void *block)
+	{
+		return (HeapBlockDesc*)((uintptr)block - sizeof(HeapBlockDesc));
+	}
+	uint32 GetSizeBetweenBlocks(HeapBlockDesc *first, HeapBlockDesc *second)
+	{
+		return (uintptr)second - (uintptr)first - sizeof(HeapBlockDesc);
+	}
+	void FreeBlock(HeapBlockDesc *block){
+		for(int i = 0; i < NUM_FIXED_MEMBLOCKS; i++){
+			if(m_fixedSize[i].m_size == block->m_size){
+				m_fixedSize[i].Free(block);
+				return;
+			}
+		}
+		HeapBlockDesc *it;
+		for(it = m_freeList.m_first.m_next; it->m_size < block->m_size; it = it->m_next);
+		block->InsertHeapFreeBlock(it->m_prev);
+	}
+};
-- 
cgit v1.2.3


From 4ddc35634160da5779c46ab63a5b3d351af50b83 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Wed, 25 Nov 2020 22:49:50 +0100
Subject: memory heap starting to work

---
 src/rw/MemoryHeap.cpp | 14 +++++++++++---
 src/rw/MemoryHeap.h   | 14 +++++++++++---
 2 files changed, 22 insertions(+), 6 deletions(-)

(limited to 'src/rw')

diff --git a/src/rw/MemoryHeap.cpp b/src/rw/MemoryHeap.cpp
index d613a708..2a484df4 100644
--- a/src/rw/MemoryHeap.cpp
+++ b/src/rw/MemoryHeap.cpp
@@ -9,8 +9,11 @@
 
 #ifdef USE_CUSTOM_ALLOCATOR
 
-#define MEMORYHEAP_ASSERT(cond) { if (!(cond)) { printf("ASSERT File:%s Line:%d\n", __FILE__, __LINE__); exit(1); } }
-#define MEMORYHEAP_ASSERT_MESSAGE(cond, message) { if (!(cond)) { printf("ASSERT File:%s Line:%d:\n\t%s\n", __FILE__, __LINE__, message); exit(1); } }
+//#define MEMORYHEAP_ASSERT(cond) { if (!(cond)) { printf("ASSERT File:%s Line:%d\n", __FILE__, __LINE__); exit(1); } }
+//#define MEMORYHEAP_ASSERT_MESSAGE(cond, message) { if (!(cond)) { printf("ASSERT File:%s Line:%d:\n\t%s\n", __FILE__, __LINE__, message); exit(1); } }
+
+#define MEMORYHEAP_ASSERT(cond) assert(cond)
+#define MEMORYHEAP_ASSERT_MESSAGE(cond, message) assert(cond)
 
 // registered pointers that we keep track of
 void **gPtrList[4000];
@@ -272,6 +275,7 @@ CMemoryHeap::Free(void *ptr)
 	MEMORYHEAP_ASSERT(m_unkMemId == -1 || m_unkMemId == block->m_memId);
 
 	RegisterFree(block);
+	block->m_memId = MEMID_FREE;
 	CombineFreeBlocks(block);
 	FreeBlock(block);
 	if(block->m_ptrListIndex != -1){
@@ -313,7 +317,7 @@ uint32
 CMemoryHeap::CombineFreeBlocks(HeapBlockDesc *block)
 {
 	HeapBlockDesc *next = block->GetNextConsecutive();
-	if(next->m_memId == MEMID_FREE)
+	if(next->m_memId != MEMID_FREE)
 		return block->m_size;
 	// get rid of free blocks after this one and adjust size
 	for(; next->m_memId == MEMID_FREE; next = next->GetNextConsecutive())
@@ -535,6 +539,10 @@ MemoryMgrCalloc(uint32 num, uint32 size)
 void
 MemoryMgrFree(void *ptr)
 {
+#ifdef FIX_BUGS
+	// i don't suppose this is handled by RW?
+	if(ptr == nil) return;
+#endif
 	gMainHeap.Free(ptr);
 }
 
diff --git a/src/rw/MemoryHeap.h b/src/rw/MemoryHeap.h
index 840e016a..3f6fb5a0 100644
--- a/src/rw/MemoryHeap.h
+++ b/src/rw/MemoryHeap.h
@@ -1,6 +1,12 @@
 #pragma once
 
+// some windows shit
+#ifdef MoveMemory
+#undef MoveMemory
+#endif
+
 extern RwMemoryFunctions memFuncs;
+void InitMemoryMgr(void);
 
 template<typename T, uint32 N>
 class CStack
@@ -56,7 +62,10 @@ struct HeapBlockDesc
 	}
 };
 
+#ifdef USE_CUSTOM_ALLOCATOR
+// TODO: figure something out for 64 bit pointers
 static_assert(sizeof(HeapBlockDesc) == 0x10, "HeapBlockDesc must have 0x10 size otherwise most of assumptions don't make sense");
+#endif
 
 struct HeapBlockList
 {
@@ -181,8 +190,7 @@ public:
 				return;
 			}
 		}
-		HeapBlockDesc *it;
-		for(it = m_freeList.m_first.m_next; it->m_size < block->m_size; it = it->m_next);
-		block->InsertHeapFreeBlock(it->m_prev);
+		HeapBlockDesc *b = m_freeList.m_first.FindSmallestFreeBlock(block->m_size);
+		block->InsertHeapFreeBlock(b->m_prev);
 	}
 };
-- 
cgit v1.2.3


From d857758c167ee06840ec806524191e95ff37f98a Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Thu, 26 Nov 2020 16:47:19 +0100
Subject: start using CMemoryHeap

---
 src/rw/MemoryHeap.cpp        | 88 ++++++++++++++++++++++++++++++++++-----
 src/rw/MemoryHeap.h          | 98 +++++++++++++++++++++++++++++++-------------
 src/rw/RwHelper.cpp          | 39 ------------------
 src/rw/RwHelper.h            |  3 --
 src/rw/VisibilityPlugins.cpp | 87 +++++++++++++++++++++++++++------------
 5 files changed, 207 insertions(+), 108 deletions(-)

(limited to 'src/rw')

diff --git a/src/rw/MemoryHeap.cpp b/src/rw/MemoryHeap.cpp
index 2a484df4..2cf173b6 100644
--- a/src/rw/MemoryHeap.cpp
+++ b/src/rw/MemoryHeap.cpp
@@ -44,7 +44,7 @@ CMemoryHeap::Init(uint32 total)
 	m_end = (HeapBlockDesc*)(mem + total - sizeof(HeapBlockDesc));
 	m_start->m_memId = MEMID_FREE;
 	m_start->m_size = total - 2*sizeof(HeapBlockDesc);
-	m_end->m_memId = MEMID_ID1;
+	m_end->m_memId = MEMID_GAME;
 	m_end->m_size = 0;
 
 	m_freeList.m_last.m_size = INT_MAX;
@@ -65,7 +65,7 @@ CMemoryHeap::Init(uint32 total)
 	RegisterMalloc(GetDescFromHeapPointer(m_memUsed));
 	RegisterMalloc(GetDescFromHeapPointer(m_blocksUsed));
 
-	m_currentMemID = MEMID_ID1;
+	m_currentMemID = MEMID_GAME;
 	for(int i = 0; i < NUM_MEMIDS; i++){
 		m_memUsed[i] = 0;
 		m_blocksUsed[i] = 0;
@@ -90,8 +90,8 @@ CMemoryHeap::RegisterFree(HeapBlockDesc *block)
 	if(block->m_memId == MEMID_FREE)
 		return;
 	m_totalMemUsed -= block->m_size + sizeof(HeapBlockDesc);
-	m_memUsed[m_currentMemID] -= block->m_size + sizeof(HeapBlockDesc);
-	m_blocksUsed[m_currentMemID]--;
+	m_memUsed[block->m_memId] -= block->m_size + sizeof(HeapBlockDesc);
+	m_blocksUsed[block->m_memId]--;
 	m_totalBlocksUsed--;
 }
 
@@ -433,13 +433,16 @@ CMemoryHeap::GetBlocksUsed(int32 id)
 void
 CMemoryHeap::PopMemId(void)
 {
+	assert(m_idStack.sp > 0);
 	m_currentMemID = m_idStack.pop();
+	assert(m_currentMemID != MEMID_FREE);
 }
 
 void
 CMemoryHeap::PushMemId(int32 id)
 {
 	MEMORYHEAP_ASSERT(id != MEMID_FREE);
+	assert(m_idStack.sp < 16);
 	m_idStack.push(m_currentMemID);
 	m_currentMemID = id;
 }
@@ -457,7 +460,7 @@ CMemoryHeap::ParseHeap(void)
 	for(HeapBlockDesc *block = m_start; block < m_end; block = block->GetNextConsecutive()){
 		char chr = '*';	// free
 		if(block->m_memId != MEMID_FREE)
-			chr = block->m_memId-MEMID_ID1 + 'A';
+			chr = block->m_memId-1 + 'A';
 		int numQW = block->m_size>>4;
 
 		if((addrQW & 0x3F) == 0){
@@ -506,10 +509,31 @@ InitMemoryMgr(void)
 #endif
 }
 
+
+RwMemoryFunctions memFuncs = {
+	MemoryMgrMalloc,
+	MemoryMgrFree,
+	MemoryMgrRealloc,
+	MemoryMgrCalloc
+};
+
+#ifdef USE_CUSTOM_ALLOCATOR
+// game seems to be using heap directly here, but this is nicer
+void *operator new(size_t sz) { return MemoryMgrMalloc(sz); }
+void *operator new[](size_t sz) { return MemoryMgrMalloc(sz); }
+void operator delete(void *ptr) noexcept { MemoryMgrFree(ptr); }
+void operator delete[](void *ptr) noexcept { MemoryMgrFree(ptr); }
+#endif
+#endif
+
 void*
 MemoryMgrMalloc(uint32 size)
 {
+#ifdef USE_CUSTOM_ALLOCATOR
 	void *mem = gMainHeap.Malloc(size);
+#else
+	void *mem = malloc(size);
+#endif
 	if(mem > pMemoryTop)
 		pMemoryTop = mem;
 	return mem;
@@ -518,7 +542,11 @@ MemoryMgrMalloc(uint32 size)
 void*
 MemoryMgrRealloc(void *ptr, uint32 size)
 {
+#ifdef USE_CUSTOM_ALLOCATOR
 	void *mem = gMainHeap.Realloc(ptr, size);
+#else
+	void *mem = realloc(ptr, size);
+#endif
 	if(mem > pMemoryTop)
 		pMemoryTop = mem;
 	return mem;
@@ -527,7 +555,11 @@ MemoryMgrRealloc(void *ptr, uint32 size)
 void*
 MemoryMgrCalloc(uint32 num, uint32 size)
 {
+#ifdef USE_CUSTOM_ALLOCATOR
 	void *mem = gMainHeap.Malloc(num*size);
+#else
+	void *mem = calloc(num, size);
+#endif
 	if(mem > pMemoryTop)
 		pMemoryTop = mem;
 #ifdef FIX_BUGS
@@ -539,18 +571,52 @@ MemoryMgrCalloc(uint32 num, uint32 size)
 void
 MemoryMgrFree(void *ptr)
 {
+#ifdef USE_CUSTOM_ALLOCATOR
 #ifdef FIX_BUGS
 	// i don't suppose this is handled by RW?
 	if(ptr == nil) return;
 #endif
 	gMainHeap.Free(ptr);
+#else
+	free(ptr);
+#endif
 }
 
-RwMemoryFunctions memFuncs = {
-	MemoryMgrMalloc,
-	MemoryMgrFree,
-	MemoryMgrRealloc,
-	MemoryMgrCalloc
-};
+void *
+RwMallocAlign(RwUInt32 size, RwUInt32 align)
+{
+#ifdef FIX_BUGS
+	uintptr ptralign = align-1;
+	void *mem = (void *)MemoryMgrMalloc(size + sizeof(uintptr) + ptralign);
+
+	ASSERT(mem != nil);
+
+	void *addr = (void *)((((uintptr)mem) + sizeof(uintptr) + ptralign) & ~ptralign);
+
+	ASSERT(addr != nil);
+#else
+	void *mem = (void *)MemoryMgrMalloc(size + align);
 
+	ASSERT(mem != nil);
+
+	void *addr = (void *)((((uintptr)mem) + align) & ~(align - 1));
+
+	ASSERT(addr != nil);
 #endif
+
+	*(((void **)addr) - 1) = mem;
+
+	return addr;
+}
+
+void
+RwFreeAlign(void *mem)
+{
+	ASSERT(mem != nil);
+
+	void *addr = *(((void **)mem) - 1);
+
+	ASSERT(addr != nil);
+
+	MemoryMgrFree(addr);
+}
diff --git a/src/rw/MemoryHeap.h b/src/rw/MemoryHeap.h
index 3f6fb5a0..22e13617 100644
--- a/src/rw/MemoryHeap.h
+++ b/src/rw/MemoryHeap.h
@@ -5,9 +5,75 @@
 #undef MoveMemory
 #endif
 
+#ifdef USE_CUSTOM_ALLOCATOR
+#define PUSH_MEMID(id) gMainHeap.PushMemId(id)
+#define POP_MEMID() gMainHeap.PopMemId()
+#define REGISTER_MEMPTR(ptr) gMainHeap.RegisterMemPointer(ptr)
+#else
+#define PUSH_MEMID(id)
+#define POP_MEMID()
+#define REGISTER_MEMPTR(ptr)
+#endif
+
+enum {
+	MEMID_FREE,
+	// IDs from LCS:
+/*
+	MEMID_GAME = 1,	// "Game"
+	MEMID_WORLD = 2,	// "World"
+	MEMID_ANIMATION = 3,	// "Animation"
+	MEMID_POOLS = 4,	// "Pools"
+	MEMID_DEF_MODELS = 5,	// "Default Models"
+	MEMID_STREAM = 6,	// "Streaming"
+	MEMID_STREAM_MODELS = 7,	// "Streamed Models"
+	MEMID_STREAM_LODS = 8,	// "Streamed LODs"
+	MEMID_STREAM_TEXUTRES = 9,	// "Streamed Textures"
+	MEMID_STREAM_COLLISION = 10,	// "Streamed Collision"
+	MEMID_STREAM_ANIMATION = 11,	// "Streamed Animation"
+	MEMID_TEXTURES = 12,	// "Textures"
+	MEMID_COLLISION = 13,	// "Collision"
+	MEMID_PRE_ALLOC = 14,	// "PreAlloc"
+	MEMID_GAME_PROCESS = 15,	// "Game Process"
+	MEMID_SCRIPT = 16,	// "Script"
+	MEMID_CARS = 17,	// "Cars"
+	MEMID_RENDER = 18,	// "Render"
+	MEMID_PED_ATTR = 19,	// "Ped Attr"
+*/
+	// III:
+	MEMID_GAME = 1,	// "Game"
+	MEMID_WORLD = 2,	// "World"
+	MEMID_ANIMATION = 3,	// "Animation"
+	MEMID_POOLS = 4,	// "Pools"
+	MEMID_DEF_MODELS = 5,	// "Default Models"
+	MEMID_STREAM = 6,	// "Streaming"
+	MEMID_STREAM_MODELS = 7,	// "Streamed Models" (instance)
+	MEMID_STREAM_TEXUTRES = 8,	// "Streamed Textures"
+	MEMID_TEXTURES = 9,	// "Textures"
+	MEMID_COLLISION = 10,	// "Collision"
+	MEMID_RENDERLIST = 11,	// ?
+	MEMID_GAME_PROCESS = 12,	// "Game Process"
+	MEMID_SCRIPT = 13,	// "Script"
+	MEMID_CARS = 14,	// "Cars"
+	MEMID_RENDER = 15,	// "Render"
+	MEMID_FRONTEND = 17,	// ?
+
+	NUM_MEMIDS,
+
+	NUM_FIXED_MEMBLOCKS = 6
+};
+
 extern RwMemoryFunctions memFuncs;
 void InitMemoryMgr(void);
 
+void *MemoryMgrMalloc(uint32 size);
+void *MemoryMgrRealloc(void *ptr, uint32 size);
+void *MemoryMgrCalloc(uint32 num, uint32 size);
+void MemoryMgrFree(void *ptr);
+
+void *RwMallocAlign(RwUInt32 size, RwUInt32 align);
+void RwFreeAlign(void *mem);
+
+
 template<typename T, uint32 N>
 class CStack
 {
@@ -17,7 +83,7 @@ public:
 
 	CStack() : sp(0) {}
 	void push(const T& val) { values[sp++] = val; }
-	T& pop() { return values[sp--]; }
+	T& pop() { return values[--sp]; }
 };
 
 
@@ -111,34 +177,6 @@ struct CommonSize
 	}
 };
 
-enum {
-	MEMID_FREE,
-	// IDs from LCS:
-	MEMID_ID1,	// "Game"
-	MEMID_ID2,	// "World"
-	MEMID_ID3,	// "Animation"
-	MEMID_ID4,	// "Pools"
-	MEMID_ID5,	// "Default Models"
-	MEMID_ID6,	// "Streaming"
-	MEMID_ID7,	// "Streamed Models"
-	MEMID_ID8,	// "Streamed LODs"
-	MEMID_ID9,	// "Streamed Textures"
-	MEMID_ID10,	// "Streamed Collision"
-	MEMID_ID11,	// "Streamed Animation"
-	MEMID_ID12,	// "Textures"
-	MEMID_ID13,	// "Collision"
-	MEMID_ID14,	// "PreAlloc"
-	MEMID_ID15,	// "Game Process"
-	MEMID_ID16,	// "Script"
-	MEMID_ID17,	// "Cars"
-	MEMID_ID18,	// "Render"
-	MEMID_ID19,	// "Ped Attr"
-
-	NUM_MEMIDS,
-
-	NUM_FIXED_MEMBLOCKS = 6
-};
-
 class CMemoryHeap
 {
 public:
@@ -194,3 +232,5 @@ public:
 		block->InsertHeapFreeBlock(b->m_prev);
 	}
 };
+
+extern CMemoryHeap gMainHeap;
diff --git a/src/rw/RwHelper.cpp b/src/rw/RwHelper.cpp
index 0069934f..ee370c37 100644
--- a/src/rw/RwHelper.cpp
+++ b/src/rw/RwHelper.cpp
@@ -64,45 +64,6 @@ void FlushObrsPrintfs()
 #endif
 }
 
-void *
-RwMallocAlign(RwUInt32 size, RwUInt32 align)
-{
-#ifdef FIX_BUGS
-	uintptr ptralign = align-1;
-	void *mem = (void *)malloc(size + sizeof(uintptr) + ptralign);
-
-	ASSERT(mem != nil);
-
-	void *addr = (void *)((((uintptr)mem) + sizeof(uintptr) + ptralign) & ~ptralign);
-
-	ASSERT(addr != nil);
-#else
-	void *mem = (void *)malloc(size + align);
-
-	ASSERT(mem != nil);
-
-	void *addr = (void *)((((uintptr)mem) + align) & ~(align - 1));
-
-	ASSERT(addr != nil);
-#endif
-
-	*(((void **)addr) - 1) = mem;
-
-	return addr;
-}
-
-void
-RwFreeAlign(void *mem)
-{
-	ASSERT(mem != nil);
-
-	void *addr = *(((void **)mem) - 1);
-
-	ASSERT(addr != nil);
-
-	free(addr);
-}
-
 void
 DefinedState(void)
 {
diff --git a/src/rw/RwHelper.h b/src/rw/RwHelper.h
index 523a7732..ed9b03ab 100644
--- a/src/rw/RwHelper.h
+++ b/src/rw/RwHelper.h
@@ -2,9 +2,6 @@
 
 extern bool gPS2alphaTest;
 
-void *RwMallocAlign(RwUInt32 size, RwUInt32 align);
-void RwFreeAlign(void *mem);
-
 void OpenCharsetSafe();
 void CreateDebugFont();
 void DestroyDebugFont();
diff --git a/src/rw/VisibilityPlugins.cpp b/src/rw/VisibilityPlugins.cpp
index 3f10d12a..68775c72 100644
--- a/src/rw/VisibilityPlugins.cpp
+++ b/src/rw/VisibilityPlugins.cpp
@@ -10,6 +10,7 @@
 #include "VisibilityPlugins.h"
 #include "World.h"
 #include "custompipes.h"
+#include "MemoryHeap.h"
 
 CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaList;
 CLinkList<CVisibilityPlugins::AlphaObjectInfo> CVisibilityPlugins::m_alphaEntityList;
@@ -30,6 +31,41 @@ float CVisibilityPlugins::ms_pedLod0Dist;
 float CVisibilityPlugins::ms_pedLod1Dist;
 float CVisibilityPlugins::ms_pedFadeDist;
 
+#ifdef GTA_PS2
+void
+rpDefaultGeometryInstance(RpGeometry *geo, void *atomic, int unk)
+{
+	// TODO
+	// this function seems to delete the original geometry data
+	// and only keep the instanced data
+	AtomicDefaultRenderCallBack((RpAtomic*)atomic);
+}
+
+RpAtomic*
+PreInstanceRenderCB(RpAtomic *atomic)
+{
+	RpGeometry *geo = RpAtomicGetGeometry(atomic);
+	if(RpGeometryGetTriangles(geo)){
+		PUSH_MEMID(MEMID_STREAM_MODELS);
+		rpDefaultGeometryInstance(geo, atomic, 1);
+		POP_MEMID();
+	}else
+		AtomicDefaultRenderCallBack(atomic);
+	return atomic;
+}
+#define RENDERCALLBACK PreInstanceRenderCB
+#else
+RpAtomic*
+DefaultRenderCB_pushid(RpAtomic *atomic)
+{
+	PUSH_MEMID(MEMID_STREAM_MODELS);
+	AtomicDefaultRenderCallBack(atomic);
+	POP_MEMID();
+	return atomic;
+}
+#define RENDERCALLBACK DefaultRenderCB_pushid
+#endif
+
 void
 CVisibilityPlugins::Initialise(void)
 {
@@ -132,7 +168,7 @@ CVisibilityPlugins::RenderAlphaAtomics(void)
 	for(node = m_alphaList.tail.prev;
 	    node != &m_alphaList.head;
 	    node = node->prev)
-		AtomicDefaultRenderCallBack(node->item.atomic);
+		RENDERCALLBACK(node->item.atomic);
 }
 
 void
@@ -201,7 +237,7 @@ CVisibilityPlugins::RenderWheelAtomicCB(RpAtomic *atomic)
 	if(lodatm){
 		if(RpAtomicGetGeometry(lodatm) != RpAtomicGetGeometry(atomic))
 			RpAtomicSetGeometry(atomic, RpAtomicGetGeometry(lodatm), rpATOMICSAMEBOUNDINGSPHERE);
-		AtomicDefaultRenderCallBack(atomic);
+		RENDERCALLBACK(atomic);
 	}
 	return atomic;
 }
@@ -218,7 +254,7 @@ CVisibilityPlugins::RenderObjNormalAtomic(RpAtomic *atomic)
 	len = RwV3dLength(&view);
 	if(RwV3dDotProduct(&view, RwMatrixGetUp(m)) < -0.3f*len && len > 8.0f)
 		return atomic;
-	AtomicDefaultRenderCallBack(atomic);
+	RENDERCALLBACK(atomic);
 	return atomic;
 }
 
@@ -232,7 +268,7 @@ CVisibilityPlugins::RenderAlphaAtomic(RpAtomic *atomic, int alpha)
 	flags = RpGeometryGetFlags(geo);
 	RpGeometrySetFlags(geo, flags | rpGEOMETRYMODULATEMATERIALCOLOR);
 	RpGeometryForAllMaterials(geo, SetAlphaCB, (void*)alpha);
-	AtomicDefaultRenderCallBack(atomic);
+	RENDERCALLBACK(atomic);
 	RpGeometryForAllMaterials(geo, SetAlphaCB, (void*)255);
 	RpGeometrySetFlags(geo, flags);
 	return atomic;
@@ -250,7 +286,7 @@ CVisibilityPlugins::RenderFadingAtomic(RpAtomic *atomic, float camdist)
 	lodatm = mi->GetAtomicFromDistance(camdist - FADE_DISTANCE);
 	if(mi->m_additive){
 		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDONE);
-		AtomicDefaultRenderCallBack(atomic);
+		RENDERCALLBACK(atomic);
 		RwRenderStateSet(rwRENDERSTATEDESTBLEND, (void*)rwBLENDINVSRCALPHA);
 	}else{
 		fadefactor = (mi->GetLargestLodDistance() - (camdist - FADE_DISTANCE))/FADE_DISTANCE;
@@ -258,7 +294,7 @@ CVisibilityPlugins::RenderFadingAtomic(RpAtomic *atomic, float camdist)
 			fadefactor = 1.0f;
 		alpha = mi->m_alpha * fadefactor;
 		if(alpha == 255)
-			AtomicDefaultRenderCallBack(atomic);
+			RENDERCALLBACK(atomic);
 		else{
 			RpGeometry *geo = RpAtomicGetGeometry(lodatm);
 			uint32 flags = RpGeometryGetFlags(geo);
@@ -266,7 +302,7 @@ CVisibilityPlugins::RenderFadingAtomic(RpAtomic *atomic, float camdist)
 			RpGeometryForAllMaterials(geo, SetAlphaCB, (void*)alpha);
 			if(geo != RpAtomicGetGeometry(atomic))
 				RpAtomicSetGeometry(atomic, geo, rpATOMICSAMEBOUNDINGSPHERE); // originally 5 (mistake?)
-			AtomicDefaultRenderCallBack(atomic);
+			RENDERCALLBACK(atomic);
 			RpGeometryForAllMaterials(geo, SetAlphaCB, (void*)255);
 			RpGeometrySetFlags(geo, flags);
 		}
@@ -293,7 +329,7 @@ CVisibilityPlugins::RenderVehicleHiDetailCB(RpAtomic *atomic)
 			if(dot > 0.0f && ((flags & ATOMIC_FLAG_ANGLECULL) || 0.1f*distsq < dot*dot))
 				return atomic;
 		}
-		AtomicDefaultRenderCallBack(atomic);
+		RENDERCALLBACK(atomic);
 	}
 	return atomic;
 }
@@ -318,10 +354,10 @@ CVisibilityPlugins::RenderVehicleHiDetailAlphaCB(RpAtomic *atomic)
 		if(flags & ATOMIC_FLAG_DRAWLAST){
 			// sort before clump
 			if(!InsertAtomicIntoSortedList(atomic, distsq - 0.0001f))
-				AtomicDefaultRenderCallBack(atomic);
+				RENDERCALLBACK(atomic);
 		}else{
 			if(!InsertAtomicIntoSortedList(atomic, distsq + dot))
-				AtomicDefaultRenderCallBack(atomic);
+				RENDERCALLBACK(atomic);
 		}
 	}
 	return atomic;
@@ -344,7 +380,7 @@ CVisibilityPlugins::RenderVehicleHiDetailCB_BigVehicle(RpAtomic *atomic)
 			if(dot > 0.0f)
 				return atomic;
 		}
-		AtomicDefaultRenderCallBack(atomic);
+		RENDERCALLBACK(atomic);
 	}
 	return atomic;
 }
@@ -367,7 +403,7 @@ CVisibilityPlugins::RenderVehicleHiDetailAlphaCB_BigVehicle(RpAtomic *atomic)
 				return atomic;
 
 		if(!InsertAtomicIntoSortedList(atomic, distsq + dot))
-			AtomicDefaultRenderCallBack(atomic);
+			RENDERCALLBACK(atomic);
 	}
 	return atomic;
 }
@@ -381,7 +417,7 @@ CVisibilityPlugins::RenderVehicleHiDetailCB_Boat(RpAtomic *atomic)
 	clumpframe = RpClumpGetFrame(RpAtomicGetClump(atomic));
 	distsq = GetDistanceSquaredFromCamera(clumpframe);
 	if(distsq < ms_bigVehicleLod1Dist)
-		AtomicDefaultRenderCallBack(atomic);
+		RENDERCALLBACK(atomic);
 	return atomic;
 }
 
@@ -403,7 +439,7 @@ CVisibilityPlugins::RenderVehicleLowDetailCB_BigVehicle(RpAtomic *atomic)
 			if(dot > 0.0f)
 				return atomic;
 		}
-		AtomicDefaultRenderCallBack(atomic);
+		RENDERCALLBACK(atomic);
 	}
 	return atomic;
 }
@@ -427,7 +463,7 @@ CVisibilityPlugins::RenderVehicleLowDetailAlphaCB_BigVehicle(RpAtomic *atomic)
 				return atomic;
 
 		if(!InsertAtomicIntoSortedList(atomic, distsq + dot))
-			AtomicDefaultRenderCallBack(atomic);
+			RENDERCALLBACK(atomic);
 	}
 	return atomic;
 }
@@ -444,7 +480,7 @@ CVisibilityPlugins::RenderVehicleReallyLowDetailCB(RpAtomic *atomic)
 	if(dist >= ms_vehicleLod0Dist){
 		alpha = GetClumpAlpha(clump);
 		if(alpha == 255)
-			AtomicDefaultRenderCallBack(atomic);
+			RENDERCALLBACK(atomic);
 		else
 			RenderAlphaAtomic(atomic, alpha);
 	}
@@ -461,7 +497,7 @@ CVisibilityPlugins::RenderVehicleReallyLowDetailCB_BigVehicle(RpAtomic *atomic)
 	clumpframe = RpClumpGetFrame(RpAtomicGetClump(atomic));
 	distsq = GetDistanceSquaredFromCamera(clumpframe);
 	if(distsq >= ms_bigVehicleLod1Dist)
-		AtomicDefaultRenderCallBack(atomic);
+		RENDERCALLBACK(atomic);
 	return atomic;
 }
 
@@ -482,7 +518,7 @@ CVisibilityPlugins::RenderTrainHiDetailCB(RpAtomic *atomic)
 			if(dot > 0.0f && ((flags & ATOMIC_FLAG_ANGLECULL) || 0.1f*distsq < dot*dot))
 				return atomic;
 		}
-		AtomicDefaultRenderCallBack(atomic);
+		RENDERCALLBACK(atomic);
 	}
 	return atomic;
 }
@@ -507,10 +543,10 @@ CVisibilityPlugins::RenderTrainHiDetailAlphaCB(RpAtomic *atomic)
 		if(flags & ATOMIC_FLAG_DRAWLAST){
 			// sort before clump
 			if(!InsertAtomicIntoSortedList(atomic, distsq - 0.0001f))
-				AtomicDefaultRenderCallBack(atomic);
+				RENDERCALLBACK(atomic);
 		}else{
 			if(!InsertAtomicIntoSortedList(atomic, distsq + dot))
-				AtomicDefaultRenderCallBack(atomic);
+				RENDERCALLBACK(atomic);
 		}
 	}
 	return atomic;
@@ -521,7 +557,7 @@ CVisibilityPlugins::RenderPlayerCB(RpAtomic *atomic)
 {
 	if(CWorld::Players[0].m_pSkinTexture)
 		RpGeometryForAllMaterials(RpAtomicGetGeometry(atomic), SetTextureCB, CWorld::Players[0].m_pSkinTexture);
-	AtomicDefaultRenderCallBack(atomic);
+	RENDERCALLBACK(atomic);
 	return atomic;
 }
 
@@ -537,7 +573,7 @@ CVisibilityPlugins::RenderPedLowDetailCB(RpAtomic *atomic)
 	if(dist >= ms_pedLod0Dist){
 		alpha = GetClumpAlpha(clump);
 		if(alpha == 255)
-			AtomicDefaultRenderCallBack(atomic);
+			RENDERCALLBACK(atomic);
 		else
 			RenderAlphaAtomic(atomic, alpha);
 	}
@@ -556,7 +592,7 @@ CVisibilityPlugins::RenderPedHiDetailCB(RpAtomic *atomic)
 	if(dist < ms_pedLod0Dist){
 		alpha = GetClumpAlpha(clump);
 		if(alpha == 255)
-			AtomicDefaultRenderCallBack(atomic);
+			RENDERCALLBACK(atomic);
 		else
 			RenderAlphaAtomic(atomic, alpha);
 	}
@@ -575,7 +611,7 @@ CVisibilityPlugins::RenderPedCB(RpAtomic *atomic)
 	if(RwV3dDotProduct(&cam2atm, &cam2atm) < ms_pedLod1Dist){
 		alpha = GetClumpAlpha(RpAtomicGetClump(atomic));
 		if(alpha == 255)
-			AtomicDefaultRenderCallBack(atomic);
+			RENDERCALLBACK(atomic);
 		else
 			RenderAlphaAtomic(atomic, alpha);
 	}
@@ -775,12 +811,11 @@ CVisibilityPlugins::GetAtomicId(RpAtomic *atomic)
 	return ATOMICEXT(atomic)->flags;
 }
 
-// This is rather useless, but whatever
 void
 CVisibilityPlugins::SetAtomicRenderCallback(RpAtomic *atomic, RpAtomicCallBackRender cb)
 {
 	if(cb == nil)
-		cb = AtomicDefaultRenderCallBack;	// not necessary
+		cb = RENDERCALLBACK;
 	RpAtomicSetRenderCallBack(atomic, cb);
 }
 
-- 
cgit v1.2.3


From ad48b9cde01522938590aab444bb09275ff5359d Mon Sep 17 00:00:00 2001
From: Sergeanur <s.anureev@yandex.ua>
Date: Sat, 28 Nov 2020 16:29:45 +0200
Subject: Make texture conversion work a bit faster

---
 src/rw/TexRead.cpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

(limited to 'src/rw')

diff --git a/src/rw/TexRead.cpp b/src/rw/TexRead.cpp
index 72d2ae17..7403ae1d 100644
--- a/src/rw/TexRead.cpp
+++ b/src/rw/TexRead.cpp
@@ -18,6 +18,7 @@
 #include "Sprite2d.h"
 #include "Text.h"
 #include "RwHelper.h"
+#include "Frontend.h"
 #endif //GTA_PC
 
 float texLoadTime;
@@ -357,6 +358,15 @@ CreateTxdImageForVideoCard()
 	// so let's hope that is the case for all
 	rw::gl3::needToReadBackTextures = true;
 #endif
+	
+#ifdef DISABLE_VSYNC_ON_TEXTURE_CONVERSION
+	// let's disable vsync and frame limiter to speed up texture conversion
+	// (actually we probably don't need to disable frame limiter in here, but let's do it just in case =P)
+	int8 vsyncState = CMenuManager::m_PrefsVsync;
+	int8 frameLimiterState = CMenuManager::m_PrefsFrameLimiter;
+	CMenuManager::m_PrefsVsync = 0;
+	CMenuManager::m_PrefsFrameLimiter = 0;
+#endif
 
 	int32 i;
 	for (i = 0; i < TXDSTORESIZE; i++) {
@@ -411,6 +421,12 @@ CreateTxdImageForVideoCard()
 		}
 	}
 
+#ifdef DISABLE_VSYNC_ON_TEXTURE_CONVERSION
+	// restore vsync and frame limiter states
+	CMenuManager::m_PrefsVsync = vsyncState;
+	CMenuManager::m_PrefsFrameLimiter = frameLimiterState;
+#endif
+
 	RwStreamClose(img, nil);
 	delete []buf;
 
-- 
cgit v1.2.3


From a8035b64662e9b9fe6689ec60e5087ff95bc2672 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Sat, 28 Nov 2020 16:16:15 +0100
Subject: moved some stuff to MemoryMgr

---
 src/rw/MemoryHeap.cpp | 125 ------------------------------------------------
 src/rw/MemoryHeap.h   |  12 -----
 src/rw/MemoryMgr.cpp  | 130 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/rw/MemoryMgr.h    |  12 +++++
 4 files changed, 142 insertions(+), 137 deletions(-)
 create mode 100644 src/rw/MemoryMgr.cpp
 create mode 100644 src/rw/MemoryMgr.h

(limited to 'src/rw')

diff --git a/src/rw/MemoryHeap.cpp b/src/rw/MemoryHeap.cpp
index 2cf173b6..0b333ce1 100644
--- a/src/rw/MemoryHeap.cpp
+++ b/src/rw/MemoryHeap.cpp
@@ -494,129 +494,4 @@ CommonSize::Init(uint32 size)
 	m_remaining = 0;
 }
 
-
-
-void *pMemoryTop;
-
-void
-InitMemoryMgr(void)
-{
-#ifdef GTA_PS2
-#error "finish this"
-#else
-	// randomly allocate 128mb
-	gMainHeap.Init(128*1024*1024);
-#endif
-}
-
-
-RwMemoryFunctions memFuncs = {
-	MemoryMgrMalloc,
-	MemoryMgrFree,
-	MemoryMgrRealloc,
-	MemoryMgrCalloc
-};
-
-#ifdef USE_CUSTOM_ALLOCATOR
-// game seems to be using heap directly here, but this is nicer
-void *operator new(size_t sz) { return MemoryMgrMalloc(sz); }
-void *operator new[](size_t sz) { return MemoryMgrMalloc(sz); }
-void operator delete(void *ptr) noexcept { MemoryMgrFree(ptr); }
-void operator delete[](void *ptr) noexcept { MemoryMgrFree(ptr); }
-#endif
-#endif
-
-void*
-MemoryMgrMalloc(uint32 size)
-{
-#ifdef USE_CUSTOM_ALLOCATOR
-	void *mem = gMainHeap.Malloc(size);
-#else
-	void *mem = malloc(size);
-#endif
-	if(mem > pMemoryTop)
-		pMemoryTop = mem;
-	return mem;
-}
-
-void*
-MemoryMgrRealloc(void *ptr, uint32 size)
-{
-#ifdef USE_CUSTOM_ALLOCATOR
-	void *mem = gMainHeap.Realloc(ptr, size);
-#else
-	void *mem = realloc(ptr, size);
-#endif
-	if(mem > pMemoryTop)
-		pMemoryTop = mem;
-	return mem;
-}
-
-void*
-MemoryMgrCalloc(uint32 num, uint32 size)
-{
-#ifdef USE_CUSTOM_ALLOCATOR
-	void *mem = gMainHeap.Malloc(num*size);
-#else
-	void *mem = calloc(num, size);
 #endif
-	if(mem > pMemoryTop)
-		pMemoryTop = mem;
-#ifdef FIX_BUGS
-	memset(mem, 0, num*size);
-#endif
-	return mem;
-}
-
-void
-MemoryMgrFree(void *ptr)
-{
-#ifdef USE_CUSTOM_ALLOCATOR
-#ifdef FIX_BUGS
-	// i don't suppose this is handled by RW?
-	if(ptr == nil) return;
-#endif
-	gMainHeap.Free(ptr);
-#else
-	free(ptr);
-#endif
-}
-
-void *
-RwMallocAlign(RwUInt32 size, RwUInt32 align)
-{
-#ifdef FIX_BUGS
-	uintptr ptralign = align-1;
-	void *mem = (void *)MemoryMgrMalloc(size + sizeof(uintptr) + ptralign);
-
-	ASSERT(mem != nil);
-
-	void *addr = (void *)((((uintptr)mem) + sizeof(uintptr) + ptralign) & ~ptralign);
-
-	ASSERT(addr != nil);
-#else
-	void *mem = (void *)MemoryMgrMalloc(size + align);
-
-	ASSERT(mem != nil);
-
-	void *addr = (void *)((((uintptr)mem) + align) & ~(align - 1));
-
-	ASSERT(addr != nil);
-#endif
-
-	*(((void **)addr) - 1) = mem;
-
-	return addr;
-}
-
-void
-RwFreeAlign(void *mem)
-{
-	ASSERT(mem != nil);
-
-	void *addr = *(((void **)mem) - 1);
-
-	ASSERT(addr != nil);
-
-	MemoryMgrFree(addr);
-}
diff --git a/src/rw/MemoryHeap.h b/src/rw/MemoryHeap.h
index 22e13617..484cbfab 100644
--- a/src/rw/MemoryHeap.h
+++ b/src/rw/MemoryHeap.h
@@ -62,18 +62,6 @@ enum {
 	NUM_FIXED_MEMBLOCKS = 6
 };
 
-extern RwMemoryFunctions memFuncs;
-void InitMemoryMgr(void);
-
-void *MemoryMgrMalloc(uint32 size);
-void *MemoryMgrRealloc(void *ptr, uint32 size);
-void *MemoryMgrCalloc(uint32 num, uint32 size);
-void MemoryMgrFree(void *ptr);
-
-void *RwMallocAlign(RwUInt32 size, RwUInt32 align);
-void RwFreeAlign(void *mem);
-
-
 template<typename T, uint32 N>
 class CStack
 {
diff --git a/src/rw/MemoryMgr.cpp b/src/rw/MemoryMgr.cpp
new file mode 100644
index 00000000..ef0ecbdf
--- /dev/null
+++ b/src/rw/MemoryMgr.cpp
@@ -0,0 +1,130 @@
+#include "common.h"
+#include "MemoryHeap.h"
+#include "MemoryMgr.h"
+
+
+void *pMemoryTop;
+
+void
+InitMemoryMgr(void)
+{
+#ifdef USE_CUSTOM_ALLOCATOR
+#ifdef GTA_PS2
+#error "finish this"
+#else
+	// randomly allocate 128mb
+	gMainHeap.Init(128*1024*1024);
+#endif
+#endif
+}
+
+
+RwMemoryFunctions memFuncs = {
+	MemoryMgrMalloc,
+	MemoryMgrFree,
+	MemoryMgrRealloc,
+	MemoryMgrCalloc
+};
+
+#ifdef USE_CUSTOM_ALLOCATOR
+// game seems to be using heap directly here, but this is nicer
+void *operator new(size_t sz) { return MemoryMgrMalloc(sz); }
+void *operator new[](size_t sz) { return MemoryMgrMalloc(sz); }
+void operator delete(void *ptr) noexcept { MemoryMgrFree(ptr); }
+void operator delete[](void *ptr) noexcept { MemoryMgrFree(ptr); }
+#endif
+
+void*
+MemoryMgrMalloc(size_t size)
+{
+#ifdef USE_CUSTOM_ALLOCATOR
+	void *mem = gMainHeap.Malloc(size);
+#else
+	void *mem = malloc(size);
+#endif
+	if(mem > pMemoryTop)
+		pMemoryTop = mem;
+	return mem;
+}
+
+void*
+MemoryMgrRealloc(void *ptr, size_t size)
+{
+#ifdef USE_CUSTOM_ALLOCATOR
+	void *mem = gMainHeap.Realloc(ptr, size);
+#else
+	void *mem = realloc(ptr, size);
+#endif
+	if(mem > pMemoryTop)
+		pMemoryTop = mem;
+	return mem;
+}
+
+void*
+MemoryMgrCalloc(size_t num, size_t size)
+{
+#ifdef USE_CUSTOM_ALLOCATOR
+	void *mem = gMainHeap.Malloc(num*size);
+#else
+	void *mem = calloc(num, size);
+#endif
+	if(mem > pMemoryTop)
+		pMemoryTop = mem;
+#ifdef FIX_BUGS
+	memset(mem, 0, num*size);
+#endif
+	return mem;
+}
+
+void
+MemoryMgrFree(void *ptr)
+{
+#ifdef USE_CUSTOM_ALLOCATOR
+#ifdef FIX_BUGS
+	// i don't suppose this is handled by RW?
+	if(ptr == nil) return;
+#endif
+	gMainHeap.Free(ptr);
+#else
+	free(ptr);
+#endif
+}
+
+void *
+RwMallocAlign(RwUInt32 size, RwUInt32 align)
+{
+#ifdef FIX_BUGS
+	uintptr ptralign = align-1;
+	void *mem = (void *)MemoryMgrMalloc(size + sizeof(uintptr) + ptralign);
+
+	ASSERT(mem != nil);
+
+	void *addr = (void *)((((uintptr)mem) + sizeof(uintptr) + ptralign) & ~ptralign);
+
+	ASSERT(addr != nil);
+#else
+	void *mem = (void *)MemoryMgrMalloc(size + align);
+
+	ASSERT(mem != nil);
+
+	void *addr = (void *)((((uintptr)mem) + align) & ~(align - 1));
+
+	ASSERT(addr != nil);
+#endif
+
+	*(((void **)addr) - 1) = mem;
+
+	return addr;
+}
+
+void
+RwFreeAlign(void *mem)
+{
+	ASSERT(mem != nil);
+
+	void *addr = *(((void **)mem) - 1);
+
+	ASSERT(addr != nil);
+
+	MemoryMgrFree(addr);
+}
diff --git a/src/rw/MemoryMgr.h b/src/rw/MemoryMgr.h
new file mode 100644
index 00000000..e2962806
--- /dev/null
+++ b/src/rw/MemoryMgr.h
@@ -0,0 +1,12 @@
+#pragma once
+
+extern RwMemoryFunctions memFuncs;
+void InitMemoryMgr(void);
+
+void *MemoryMgrMalloc(size_t size);
+void *MemoryMgrRealloc(void *ptr, size_t size);
+void *MemoryMgrCalloc(size_t num, size_t size);
+void MemoryMgrFree(void *ptr);
+
+void *RwMallocAlign(RwUInt32 size, RwUInt32 align);
+void RwFreeAlign(void *mem);
-- 
cgit v1.2.3


From 83bbb631d1105502fb3c5b3af90578226ba35583 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Tue, 1 Dec 2020 17:42:18 +0100
Subject: some more GTA_VERSIONs and CGame tidy-up (not much actual memory
 moving yet)

---
 src/rw/MemoryHeap.cpp | 2 +-
 src/rw/MemoryHeap.h   | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

(limited to 'src/rw')

diff --git a/src/rw/MemoryHeap.cpp b/src/rw/MemoryHeap.cpp
index 0b333ce1..469262d3 100644
--- a/src/rw/MemoryHeap.cpp
+++ b/src/rw/MemoryHeap.cpp
@@ -187,7 +187,7 @@ CMemoryHeap::Malloc(uint32 size)
 	void *mem = Malloc(size);
 	if (removeCollision) {
 		CTimer::Stop();
-		// different on PS2
+		// TODO: different on PS2
 		CFileLoader::LoadCollisionFromDatFile(CCollision::ms_collisionInMemory);
 		removeCollision = false;
 		CTimer::Update();
diff --git a/src/rw/MemoryHeap.h b/src/rw/MemoryHeap.h
index 484cbfab..23163c1c 100644
--- a/src/rw/MemoryHeap.h
+++ b/src/rw/MemoryHeap.h
@@ -198,6 +198,7 @@ public:
 	void TidyHeap(void);
 	uint32 GetMemoryUsed(int32 id);
 	uint32 GetBlocksUsed(int32 id);
+	int32 GetLargestFreeBlock(void) { return m_freeList.m_last.m_prev->m_size; }
 
 	void ParseHeap(void);
 
-- 
cgit v1.2.3


From 9461998304219f91b3b24484d0cee5b5c5d4523c Mon Sep 17 00:00:00 2001
From: Sergeanur <s.anureev@yandex.ua>
Date: Mon, 23 Nov 2020 22:46:07 +0200
Subject: TexturePools

---
 src/rw/RwHelper.cpp     |   5 --
 src/rw/RwHelper.h       |   2 -
 src/rw/TexturePools.cpp | 221 ++++++++++++++++++++++++++++++++++++++++++++++++
 src/rw/TexturePools.h   |  42 +++++++++
 4 files changed, 263 insertions(+), 7 deletions(-)
 create mode 100644 src/rw/TexturePools.cpp
 create mode 100644 src/rw/TexturePools.h

(limited to 'src/rw')

diff --git a/src/rw/RwHelper.cpp b/src/rw/RwHelper.cpp
index ee370c37..e0133985 100644
--- a/src/rw/RwHelper.cpp
+++ b/src/rw/RwHelper.cpp
@@ -605,11 +605,6 @@ CameraCreate(RwInt32 width, RwInt32 height, RwBool zBuffer)
 	return (nil);
 }
 
-#ifdef USE_TEXTURE_POOL
-WRAPPER void _TexturePoolsInitialise() { EAXJMP(0x598B10); }
-WRAPPER void _TexturePoolsShutdown() { EAXJMP(0x598B30); }
-#endif
-
 #ifdef LIBRW
 #include <rpmatfx.h>
 #include "VehicleModelInfo.h"
diff --git a/src/rw/RwHelper.h b/src/rw/RwHelper.h
index ed9b03ab..1a5f64b1 100644
--- a/src/rw/RwHelper.h
+++ b/src/rw/RwHelper.h
@@ -50,8 +50,6 @@ RwCamera *CameraCreate(RwInt32 width,
                        RwBool zBuffer);
 
 					   
-void _TexturePoolsInitialise();
-void _TexturePoolsShutdown();
 
 RpAtomic *ConvertPlatformAtomic(RpAtomic *atomic, void *data);
 
diff --git a/src/rw/TexturePools.cpp b/src/rw/TexturePools.cpp
new file mode 100644
index 00000000..c2ba6cf9
--- /dev/null
+++ b/src/rw/TexturePools.cpp
@@ -0,0 +1,221 @@
+#ifndef LIBRW
+
+#include <d3d8.h>
+#define WITHD3D
+#include "common.h"
+#include "TexturePools.h"
+
+// TODO: this needs to be integrated into RW
+
+extern "C" LPDIRECT3DDEVICE8 _RwD3DDevice;
+
+CTexturePool aTexturePools[12];
+CPaletteList PaletteList;
+int numTexturePools;
+int MaxPaletteIndex;
+bool bUsePaletteIndex = true;
+
+
+void
+CTexturePool::Create(D3DFORMAT _Format, int _size, uint32 mipmapLevels, int32 numTextures)
+{
+	Format = _Format;
+	size = _size;
+	levels = mipmapLevels;
+	pTextures = new IDirect3DTexture8 *[numTextures];
+	texturesMax = numTextures;
+	texturesNum = 0;
+	texturesUsed = 0;
+}
+
+void
+CTexturePool::Release()
+{
+	int i = 0;
+	while (i < texturesNum) {
+		pTextures[i]->Release();
+		i++;
+	}
+
+	delete[] pTextures;
+
+	pTextures = nil;
+	texturesNum = 0;
+	texturesUsed = 0;
+}
+
+IDirect3DTexture8 *
+CTexturePool::FindTexture()
+{
+	if (texturesNum == 0)
+		return nil;
+	texturesUsed--;
+	return pTextures[--texturesNum];
+}
+
+bool
+CTexturePool::AddTexture(IDirect3DTexture8 *texture)
+{
+	++texturesUsed;
+	if (texturesNum >= texturesMax)
+		return false;
+	pTextures[texturesNum] = texture;
+	++texturesNum;
+	return true;
+}
+
+void
+CTexturePool::Resize(int numTextures)
+{
+	if (numTextures == texturesMax)
+		return;
+
+	IDirect3DTexture8 **newTextures = new IDirect3DTexture8 *[numTextures];
+
+	for (int i = 0; i < texturesNum && i < numTextures; i++)
+		newTextures[i] = pTextures[i];
+
+	if (numTextures < texturesNum) {
+		for (int i = numTextures; i < texturesNum; i++)
+			pTextures[i]->Release();
+	}
+	delete[] pTextures;
+	pTextures = newTextures;
+	texturesMax = numTextures;
+}
+
+void
+CPaletteList::Alloc(int max)
+{
+	Data = new int[max];
+	Max = max;
+	Num = 0;
+}
+
+void
+CPaletteList::Free()
+{
+	delete[] Data;
+	Data = nil;
+	Num = 0;
+}
+
+int
+CPaletteList::Find()
+{
+	if (Num == 0)
+		return -1;
+	return Data[--Num];
+}
+
+void
+CPaletteList::Add(int item)
+{
+	if (Num < Max)
+		Data[Num++] = item;
+	else {
+		Resize(2 * Max);
+		Add(item);
+	}
+}
+
+void
+CPaletteList::Resize(int max)
+{
+	if (max == Max)
+		return;
+
+	int *newData = new int[4 * max];
+	for (int i = 0; i < Num && i < max; i++)
+		newData[i] = Data[i];
+	delete[] Data;
+	Data = newData;
+	Max = max;
+}
+
+HRESULT
+CreateTexture(int width, int height, int levels, D3DFORMAT Format, IDirect3DTexture8 **texture)
+{
+	if (width == height) {
+		for (int i = 0; i < numTexturePools; i++) {
+			if (width != aTexturePools[i].GetSize() && levels == aTexturePools[i].levels && Format == aTexturePools[i].Format) 
+				*texture = aTexturePools[i].FindTexture();
+		}
+	}
+	if (*texture)
+		return D3D_OK;
+	else
+		return _RwD3DDevice->CreateTexture(width, height, levels, 0, Format, D3DPOOL_MANAGED, texture);
+}
+
+void
+ReleaseTexture(IDirect3DTexture8 *texture)
+{
+	int levels = 1;
+	if (texture->GetLevelCount() > 1)
+		levels = 0;
+
+	D3DSURFACE_DESC SURFACE_DESC;
+
+	texture->GetLevelDesc(0, &SURFACE_DESC);
+
+	if (SURFACE_DESC.Width == SURFACE_DESC.Height) {
+		for (int i = 0; i < numTexturePools; i++) {
+			if (SURFACE_DESC.Width == aTexturePools[i].GetSize() && SURFACE_DESC.Format == aTexturePools[i].Format && levels == aTexturePools[i].levels) {
+				if (!aTexturePools[i].AddTexture(texture)) {
+					if (aTexturePools[i].texturesUsed > 3 * aTexturePools[i].texturesMax / 2) {
+						aTexturePools[i].Resize(2 * aTexturePools[i].texturesMax);
+						aTexturePools[i].texturesUsed--;
+						aTexturePools[i].AddTexture(texture);
+					} else {
+						texture->Release();
+					}
+				}
+				return;
+			}
+		}
+	}
+	if (numTexturePools < 12 && bUsePaletteIndex && levels != 0 && SURFACE_DESC.Width == SURFACE_DESC.Height &&
+	    (SURFACE_DESC.Width == 64 || SURFACE_DESC.Width == 128 || SURFACE_DESC.Width == 256)) {
+		aTexturePools[numTexturePools].Create(SURFACE_DESC.Format, SURFACE_DESC.Width, 1, 16);
+		aTexturePools[numTexturePools].AddTexture(texture);
+		numTexturePools++;
+	} else
+		texture->Release();
+}
+
+int
+FindAvailablePaletteIndex()
+{
+	int index = PaletteList.Find();
+	if (index == -1)
+		index = MaxPaletteIndex++;
+	return index;
+}
+
+void
+AddAvailablePaletteIndex(int index)
+{
+	if (bUsePaletteIndex)
+		PaletteList.Add(index);
+}
+
+void
+_TexturePoolsInitialise()
+{
+	PaletteList.Alloc(100);
+	MaxPaletteIndex = 0;
+}
+
+void
+_TexturePoolsShutdown()
+{
+	for (int i = 0; i < numTexturePools; i++)
+		aTexturePools[i].Release();
+
+	numTexturePools = 0;
+	bUsePaletteIndex = false;
+	PaletteList.Free();
+}
+
+#endif // !LIBRW
\ No newline at end of file
diff --git a/src/rw/TexturePools.h b/src/rw/TexturePools.h
new file mode 100644
index 00000000..75187432
--- /dev/null
+++ b/src/rw/TexturePools.h
@@ -0,0 +1,42 @@
+#pragma once
+
+class CTexturePool
+{
+public:
+	D3DFORMAT Format;
+	int size;
+	uint32 levels;
+	int32 texturesMax;
+	int32 texturesUsed;
+	int32 texturesNum;
+	IDirect3DTexture8 **pTextures;
+
+public:
+	CTexturePool() {}
+	void Create(D3DFORMAT _Format, int size, uint32 mipmapLevels, int32 numTextures);
+	void Release();
+	IDirect3DTexture8 *FindTexture();
+	bool AddTexture(IDirect3DTexture8 *texture);
+	void Resize(int numTextures);
+#ifdef FIX_BUGS
+	int GetSize() { return size; }
+#else
+	float GetSize() { return size; }
+#endif
+};
+
+class CPaletteList
+{
+	int Max;
+	int Num;
+	int *Data;
+public:
+	void Alloc(int max);
+	void Free();
+	int Find();
+	void Add(int item);
+	void Resize(int max);
+};
+
+void _TexturePoolsInitialise();
+void _TexturePoolsShutdown();
\ No newline at end of file
-- 
cgit v1.2.3


From 50bf0f27a00eec43c1b92a9a0ae81b5916442ba2 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Wed, 2 Dec 2020 12:58:29 +0100
Subject: rpDefaultGeometryInstance

---
 src/rw/VisibilityPlugins.cpp | 91 +++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 85 insertions(+), 6 deletions(-)

(limited to 'src/rw')

diff --git a/src/rw/VisibilityPlugins.cpp b/src/rw/VisibilityPlugins.cpp
index 68775c72..019a781e 100644
--- a/src/rw/VisibilityPlugins.cpp
+++ b/src/rw/VisibilityPlugins.cpp
@@ -31,14 +31,93 @@ float CVisibilityPlugins::ms_pedLod0Dist;
 float CVisibilityPlugins::ms_pedLod1Dist;
 float CVisibilityPlugins::ms_pedFadeDist;
 
-#ifdef GTA_PS2
-void
-rpDefaultGeometryInstance(RpGeometry *geo, void *atomic, int unk)
+//#ifdef GTA_PS2
+#if 1
+// if wanted, delete the original geometry data after rendering
+// and only keep the instanced data
+bool
+rpDefaultGeometryInstance(RpGeometry *geo, void *atomic, int del)
 {
-	// TODO
-	// this function seems to delete the original geometry data
-	// and only keep the instanced data
+#if THIS_IS_COMPATIBLE_WITH_GTA3_RW31
+	if(RpGeometryGetNumMorphTargets(geo) != 1)
+		return false;
+
+	// this needs R*'s modification that geometry data is
+	// allocated separately from the geometry itself
+	geo->instanceFlags = rpGEOMETRYINSTANCE;
 	AtomicDefaultRenderCallBack((RpAtomic*)atomic);
+
+	if(!del)
+		return true;
+
+	// New mesh without indices
+	RpMeshHeader *newheader = _rpMeshHeaderCreate(sizeof(RpMesh)*geo->mesh->numMeshes + sizeof(RpMeshHeader));
+	newheader->numMeshes = geo->mesh->numMeshes;
+	newheader->serialNum = 1;
+	newheader->totalIndicesInMesh = 0;
+	newheader->firstMeshOffset = 0;
+	RpMesh *oldmesh = (RpMesh*)(geo->mesh+1);
+	RpMesh *newmesh = (RpMesh*)(newheader+1);
+	for(int i = 0; i < geo->mesh->numMeshes; i++){
+		newmesh[i].indices = nil;
+		newmesh[i].numIndices = 0;
+		newmesh[i].material = oldmesh[i].material;
+	}
+
+	geo->refCount++;
+	RpGeometryLock(geo, rpGEOMETRYLOCKPOLYGONS | rpGEOMETRYLOCKVERTICES |
+		rpGEOMETRYLOCKNORMALS | rpGEOMETRYLOCKPRELIGHT |
+		rpGEOMETRYLOCKTEXCOORDS1 | rpGEOMETRYLOCKTEXCOORDS2);
+
+	// vertices and normals
+	RpMorphTarget *mt = RpGeometryGetMorphTarget(geo, 0);
+	if(mt->verts){
+		RwFree(mt->verts);
+		mt->verts = nil;
+		mt->normals = nil;
+	}
+	geo->numVertices = 0;
+
+	// triangles
+	for(int i = 0; i < RpGeometryGetNumTriangles(geo); i++){
+		if(RpGeometryGetTriangles(geo)->matIndex == -1)
+			continue;
+		RpMaterialDestroy(_rpMaterialListGetMaterial(&geo->matList, RpGeometryGetTriangles(geo)->matIndex));
+	}
+	if(RpGeometryGetTriangles(geo)){
+		RwFree(RpGeometryGetTriangles(geo));
+		geo->triangles = nil;
+		geo->numTriangles = 0;
+	}
+
+	// tex coords
+	if(RpGeometryGetVertexTexCoords(geo, 1)){
+		RwFree(RpGeometryGetVertexTexCoords(geo, 1));
+		geo->texCoords[1] = nil;
+	}
+	if(RpGeometryGetVertexTexCoords(geo, 0)){
+		RwFree(RpGeometryGetVertexTexCoords(geo, 0));
+		geo->texCoords[0] = nil;
+	}
+
+	// vertex colors
+	if(RpGeometryGetPreLightColors(geo)){
+		RwFree(RpGeometryGetPreLightColors(geo));
+		geo->preLitLum = nil;
+	}
+
+	RpGeometryUnlock(geo);
+
+	geo->instanceFlags = rpGEOMETRYPERSISTENT;
+	// BUG? don't we have to free the old mesh?
+	geo->mesh = newheader;
+	geo->refCount--;
+#else
+	// We can do something for librw here actually, maybe later
+	AtomicDefaultRenderCallBack((RpAtomic*)atomic);
+#endif
+
+	return true;
 }
 
 RpAtomic*
-- 
cgit v1.2.3


From 448ba9b7e86e93581df7813bb5250168b5813c72 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Wed, 2 Dec 2020 13:08:30 +0100
Subject: bla

---
 src/rw/VisibilityPlugins.cpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'src/rw')

diff --git a/src/rw/VisibilityPlugins.cpp b/src/rw/VisibilityPlugins.cpp
index 019a781e..f931019c 100644
--- a/src/rw/VisibilityPlugins.cpp
+++ b/src/rw/VisibilityPlugins.cpp
@@ -31,8 +31,7 @@ float CVisibilityPlugins::ms_pedLod0Dist;
 float CVisibilityPlugins::ms_pedLod1Dist;
 float CVisibilityPlugins::ms_pedFadeDist;
 
-//#ifdef GTA_PS2
-#if 1
+#ifdef GTA_PS2	// maybe something else?
 // if wanted, delete the original geometry data after rendering
 // and only keep the instanced data
 bool
-- 
cgit v1.2.3


From 9714a3776996d97e680cea575967a1d6041f5723 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Fri, 4 Dec 2020 01:12:58 +0100
Subject: bit more GTA_VERSION and GTA_PS2

---
 src/rw/VisibilityPlugins.cpp | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'src/rw')

diff --git a/src/rw/VisibilityPlugins.cpp b/src/rw/VisibilityPlugins.cpp
index f931019c..d81c97f2 100644
--- a/src/rw/VisibilityPlugins.cpp
+++ b/src/rw/VisibilityPlugins.cpp
@@ -819,6 +819,11 @@ CVisibilityPlugins::PluginAttach(void)
 	ms_clumpPluginOffset = RpClumpRegisterPlugin(sizeof(ClumpExt),
 		ID_VISIBILITYCLUMP,
 		ClumpConstructor, ClumpDestructor, ClumpCopyConstructor);
+
+#if GTA_VERSION <= GTA3_PS2_16
+	Initialise();
+#endif
+
 	return ms_atomicPluginOffset != -1 && ms_clumpPluginOffset != -1;
 }
 
-- 
cgit v1.2.3


From 466eee84e76214a3300f3183f5025140c036e431 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Fri, 4 Dec 2020 10:23:04 +0100
Subject: typo

---
 src/rw/VisibilityPlugins.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'src/rw')

diff --git a/src/rw/VisibilityPlugins.cpp b/src/rw/VisibilityPlugins.cpp
index d81c97f2..b27d96c8 100644
--- a/src/rw/VisibilityPlugins.cpp
+++ b/src/rw/VisibilityPlugins.cpp
@@ -820,7 +820,7 @@ CVisibilityPlugins::PluginAttach(void)
 		ID_VISIBILITYCLUMP,
 		ClumpConstructor, ClumpDestructor, ClumpCopyConstructor);
 
-#if GTA_VERSION <= GTA3_PS2_16
+#if GTA_VERSION <= GTA3_PS2_160
 	Initialise();
 #endif
 
-- 
cgit v1.2.3


From 28a942735cbcb329b572a20504b05d88e1364db6 Mon Sep 17 00:00:00 2001
From: aap <aap@papnet.eu>
Date: Sat, 5 Dec 2020 14:50:54 +0100
Subject: fix pMemoryTop

---
 src/rw/MemoryMgr.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

(limited to 'src/rw')

diff --git a/src/rw/MemoryMgr.cpp b/src/rw/MemoryMgr.cpp
index ef0ecbdf..e2f6f144 100644
--- a/src/rw/MemoryMgr.cpp
+++ b/src/rw/MemoryMgr.cpp
@@ -3,7 +3,7 @@
 #include "MemoryMgr.h"
 
 
-void *pMemoryTop;
+uint8 *pMemoryTop;
 
 void
 InitMemoryMgr(void)
@@ -42,8 +42,8 @@ MemoryMgrMalloc(size_t size)
 #else
 	void *mem = malloc(size);
 #endif
-	if(mem > pMemoryTop)
-		pMemoryTop = mem;
+	if((uint8*)mem + size > pMemoryTop)
+		pMemoryTop = (uint8*)mem + size ;
 	return mem;
 }
 
@@ -55,8 +55,8 @@ MemoryMgrRealloc(void *ptr, size_t size)
 #else
 	void *mem = realloc(ptr, size);
 #endif
-	if(mem > pMemoryTop)
-		pMemoryTop = mem;
+	if((uint8*)mem + size  > pMemoryTop)
+		pMemoryTop = (uint8*)mem + size ;
 	return mem;
 }
 
@@ -68,8 +68,8 @@ MemoryMgrCalloc(size_t num, size_t size)
 #else
 	void *mem = calloc(num, size);
 #endif
-	if(mem > pMemoryTop)
-		pMemoryTop = mem;
+	if((uint8*)mem + size  > pMemoryTop)
+		pMemoryTop = (uint8*)mem + size ;
 #ifdef FIX_BUGS
 	memset(mem, 0, num*size);
 #endif
-- 
cgit v1.2.3