- sync driver_routines from OpenDriverEngine

SoapyMan · SoapyMan · commit f4244a5bffe3 · 2021-07-11T17:16:35.000+06:00
diff --git a/DriverLevelTool/driver_level.cpp b/DriverLevelTool/driver_level.cpp
@@ -105,8 +105,6 @@ void ExportLevelFile()
 	CFileStream stream(levTest);
 	ELevelFormat levFormat = CDriverLevelLoader::DetectLevelFormat(&stream);
 
-	fclose(levTest);
-
 	CDriverLevelLoader levLoader;
 
 	// create map accordingly
@@ -117,11 +115,13 @@ void ExportLevelFile()
 
 	levLoader.Initialize(g_levInfo, &g_levTextures, &g_levModels, g_levMap);
 
-	if (levLoader.LoadFromFile(g_levname))
+	if (levLoader.Load(&stream))
 	{
 		ExportLevelData();
 	}
 
+	fclose(levTest);
+
 	MsgWarning("Freeing level data ...\n");
 
 	g_levMap->FreeAll();
diff --git a/DriverLevelTool/driver_routines/d2_types.h b/DriverLevelTool/driver_routines/d2_types.h
@@ -4,7 +4,7 @@
 #include "core/dktypes.h"
 #include "math/psx_math_types.h"
 
-#define TEXPAGE_SIZE_X	(128)
+#define TEXPAGE_SIZE_X	(128)	// don't ask why. It's 4 bit.
 #define TEXPAGE_SIZE_Y	(256)
 
 #define TEXPAGE_4BIT_SIZE	(TEXPAGE_SIZE_X*TEXPAGE_SIZE_Y)
diff --git a/DriverLevelTool/driver_routines/level.cpp b/DriverLevelTool/driver_routines/level.cpp
@@ -299,27 +299,16 @@ void CDriverLevelLoader::Release()
 //-------------------------------------------------------------
 // Loads the LEV file data
 //-------------------------------------------------------------
-bool CDriverLevelLoader::LoadFromFile(const char* fileName)
+bool CDriverLevelLoader::Load(IVirtualStream* pStream)
 {
-	// try load driver2 lev file
-	FILE* pReadFile = fopen(fileName, "rb");
-
-	if (!pReadFile)
-	{
-		MsgError("Failed to open LEV file!\n");
+	if (!pStream)
 		return false;
-	}
-
-	CFileStream stream(pReadFile);
-
-	// seek to begin
-	MsgWarning("-----------\nLoading LEV file '%s'\n", fileName);
 
 	//-------------------------------------------------------------------
 
 	// perform auto-detection if format is not specified
 	if (m_format == LEV_FORMAT_AUTODETECT)
-		m_format = DetectLevelFormat(&stream);
+		m_format = DetectLevelFormat(pStream);
 
 	if (m_map)
 		m_map->SetFormat(m_format);
@@ -328,17 +317,16 @@ bool CDriverLevelLoader::LoadFromFile(const char* fileName)
 		m_textures->SetFormat(m_format);
 
 	LUMP curLump;
-	stream.Read(&curLump, sizeof(curLump), 1);
+	pStream->Read(&curLump, sizeof(curLump), 1);
 
 	if (curLump.type != LUMP_LUMPDESC)
 	{
 		MsgError("Not a LEV file!\n");
-		fclose(pReadFile);
 		return false;
 	}
 
 	// read chunk offsets
-	stream.Read(m_lumpInfo, sizeof(OUT_CITYLUMP_INFO), 1);
+	pStream->Read(m_lumpInfo, sizeof(OUT_CITYLUMP_INFO), 1);
 
 	DevMsg(SPEW_NORM, "data1_offset = %d\n", m_lumpInfo->loadtime_offset);
 	DevMsg(SPEW_NORM, "data1_size = %d\n", m_lumpInfo->loadtime_size);
@@ -356,53 +344,48 @@ bool CDriverLevelLoader::LoadFromFile(const char* fileName)
 
 	//-----------------------------------------------------
 	// seek to section 1 - lump data 1
-	stream.Seek(m_lumpInfo->loadtime_offset, VS_SEEK_SET);
+	pStream->Seek(m_lumpInfo->loadtime_offset, VS_SEEK_SET);
 
 	// read lump
-	stream.Read(&curLump, sizeof(curLump), 1);
+	pStream->Read(&curLump, sizeof(curLump), 1);
 
 	if (curLump.type != LUMP_LOADTIME_DATA)
 	{
 		MsgError("Not a LUMP_LOADTIME_DATA!\n");
-		fclose(pReadFile);
 		return false;
 	}
 
 	DevMsg(SPEW_INFO, "entering LUMP_LOADTIME_DATA size = %d\n--------------\n", curLump.size);
 
 	// read sublumps
-	ProcessLumps(&stream);
+	ProcessLumps(pStream);
 
 	//-----------------------------------------------------
 	// read global textures
 
 	if (m_textures)
 	{
-		stream.Seek(m_lumpInfo->tpage_offset, VS_SEEK_SET);
-		m_textures->LoadPermanentTPages(&stream);
+		pStream->Seek(m_lumpInfo->tpage_offset, VS_SEEK_SET);
+		m_textures->LoadPermanentTPages(pStream);
 	}
 
 	//-----------------------------------------------------
 	// seek to section 3 - lump data 2
-	stream.Seek(m_lumpInfo->inmem_offset, VS_SEEK_SET);
+	pStream->Seek(m_lumpInfo->inmem_offset, VS_SEEK_SET);
 
 	// read lump
-	stream.Read(&curLump, sizeof(curLump), 1);
+	pStream->Read(&curLump, sizeof(curLump), 1);
 
 	if (curLump.type != LUMP_INMEMORY_DATA)
 	{
 		MsgError("Not a lump LUMP_INMEMORY_DATA!\n");
-		fclose(pReadFile);
 		return false;
 	}
 
 	DevMsg(SPEW_INFO, "entering LUMP_INMEMORY_DATA size = %d\n--------------\n", curLump.size);
 
 	// read sublumps
-	ProcessLumps(&stream);
-
-	// completed!
-	fclose(pReadFile);
+	ProcessLumps(pStream);
 
 	return true;
 }
diff --git a/DriverLevelTool/driver_routines/level.h b/DriverLevelTool/driver_routines/level.h
@@ -83,7 +83,7 @@ class CDriverLevelLoader
 
 	ELevelFormat			GetFormat() const;
 
-	bool					LoadFromFile(const char* fileName);
+	bool					Load(IVirtualStream* pStream);
 
 protected:
 	void					ProcessLumps(IVirtualStream* pFile);
diff --git a/DriverLevelTool/driver_routines/models.cpp b/DriverLevelTool/driver_routines/models.cpp
@@ -3,7 +3,7 @@
 
 #include <malloc.h>
 #include <nstd/HashSet.hpp>
-#include "util/util.h"
+
 #include "models.h"
 
 #include <string.h>
@@ -348,9 +348,9 @@ void SwapValues(T& a, T& b)
 
 // returns size of face and fills dface_t struct
 // TODO: rework, few variants of faces still looks bad
-int decode_poly(const char* polyList, dpoly_t* out)
+int decode_poly(const char* polyList, dpoly_t* out, int forceType /*= -1*/)
 {
-	int ptype = *polyList & 0x1f;
+	int ptype = forceType == -1 ? (*polyList & 0x1f) : forceType;
 
 	out->page = 0xFF;
 	out->detail = 0xFF;
@@ -361,7 +361,7 @@ int decode_poly(const char* polyList, dpoly_t* out)
 	switch (ptype)
 	{
 		case 1:
-			// what a strange face type
+			// what a strange face type. Hardcoded?
 			*(uint*)out->vindices = *(uint*)&polyList[3];
 			break;
 		case 0:
@@ -479,5 +479,5 @@ int decode_poly(const char* polyList, dpoly_t* out)
 		}
 	}
 	
-	return PolySizes[ptype];
+	return PolySizes[*polyList & 0x1f];
 }
diff --git a/DriverLevelTool/driver_routines/models.h b/DriverLevelTool/driver_routines/models.h
@@ -123,18 +123,18 @@ class CDriverLevelModels
 
 	Array<String>		m_model_names;
 
-	OnModelLoaded_t		m_onModelLoaded;
-	OnModelFreed_t		m_onModelFreed;
-	OnCarModelLoaded_t	m_onCarModelLoaded;
-	OnCarModelFreed_t	m_onCarModelFreed;
+	OnModelLoaded_t		m_onModelLoaded{ nullptr };
+	OnModelFreed_t		m_onModelFreed{ nullptr };
+	OnCarModelLoaded_t	m_onCarModelLoaded{ nullptr };
+	OnCarModelFreed_t	m_onCarModelFreed{ nullptr };
 
 	int					m_numModelsInPack{0};
 };
 
 //------------------------------------------------------------------------------------------------------------
 
 void			PrintUnknownPolys();
-int				decode_poly(const char* face, dpoly_t* out);
+int				decode_poly(const char* face, dpoly_t* out, int forceType = -1);
 
 //-------------------------------------------------------------------------------
 
diff --git a/DriverLevelTool/driver_routines/regions.cpp b/DriverLevelTool/driver_routines/regions.cpp
@@ -446,6 +446,27 @@ void CBaseLevelMap::LoadInAreaModels(const SPOOL_CONTEXT& ctx, int areaDataNum)
 	delete[] new_model_numbers;
 }
 
+bool CBaseLevelMap::IsRegionSpooled(const XZPAIR& cell) const
+{
+	CBaseLevelRegion* reg = GetRegion(cell);
+	return reg ? reg->m_loaded : false;
+}
+
+bool CBaseLevelMap::IsRegionSpooled(int index) const
+{
+	CBaseLevelRegion* reg = GetRegion(index);
+	return reg ? reg->m_loaded : false;
+}
+
+int CBaseLevelMap::GetRegionIndex(const XZPAIR& cell) const
+{
+	// lookup region
+	const int region_x = cell.x / m_mapInfo.region_size;
+	const int region_z = cell.z / m_mapInfo.region_size;
+
+	return region_x + region_z * m_regions_across;
+}
+
 void CBaseLevelMap::InitRegion(CBaseLevelRegion* region, int index) const
 {
 	ushort spoolOffset = m_regionSpoolInfoOffsets[index];
diff --git a/DriverLevelTool/driver_routines/regions.h b/DriverLevelTool/driver_routines/regions.h
@@ -94,6 +94,11 @@ class CBaseLevelMap
 	virtual void				SpoolRegion(const SPOOL_CONTEXT& ctx, const XZPAIR& cell) = 0;
 	virtual void				SpoolRegion(const SPOOL_CONTEXT& ctx, int regionIdx) = 0;
 
+	int							GetRegionIndex(const XZPAIR& cell) const;
+
+	bool						IsRegionSpooled(const XZPAIR& cell) const;
+	bool						IsRegionSpooled(int index) const;
+
 	virtual CBaseLevelRegion*	GetRegion(const XZPAIR& cell) const = 0;
 	virtual CBaseLevelRegion*	GetRegion(int regionIdx) const = 0;
 
diff --git a/DriverLevelTool/driver_routines/regions_d2.cpp b/DriverLevelTool/driver_routines/regions_d2.cpp
@@ -651,11 +651,11 @@ bool CDriver2LevelMap::UnpackCellObject(CELL_OBJECT& co, PACKED_CELL_OBJECT* pco
 	if (!pco)
 		return false;
 
-	co.pos.vx = nearCell.x + (((pco->pos.vx - nearCell.x) << 0x10) >> 0x10);
-	co.pos.vz = nearCell.z + (((pco->pos.vz - nearCell.z) << 0x10) >> 0x10);
+	co.pos.vx = nearCell.x + (short)(pco->pos.vx - nearCell.x);
+	co.pos.vz = nearCell.z + (short)(pco->pos.vz - nearCell.z);
 
 	// cell height should be negated
-	co.pos.vy = ((pco->pos.vy << 0x10) >> 0x11);
+	co.pos.vy = (short)pco->pos.vy >> 1;
 
 	co.yang = pco->value & 0x3f;
 	co.type = (pco->value >> 6) | ((pco->pos.vy & 1) << 10);
diff --git a/DriverLevelTool/driver_routines/textures.cpp b/DriverLevelTool/driver_routines/textures.cpp
@@ -98,13 +98,10 @@ void CTexturePage::ConvertIndexedTextureToRGBA(uint* dest_color_data, int detail
 	int h = texInfo.height;
 
 	if (w == 0)
-		w = 256;
+		w = TEXPAGE_SIZE_Y;
 
 	if (h == 0)
-		h = 256;
-
-	//char* textureName = g_textureNamesData + m_details[detail].nameoffset;
-	//MsgWarning("Applying detail %d '%s' (xywh: %d %d %d %d)\n", detail, textureName, ox, oy, w, h);
+		h = TEXPAGE_SIZE_Y;
 
 	int tp_wx = ox + w;
 	int tp_hy = oy + h;
@@ -113,7 +110,7 @@ void CTexturePage::ConvertIndexedTextureToRGBA(uint* dest_color_data, int detail
 	{
 		for (int x = ox; x < tp_wx; x++)
 		{
-			ubyte clindex = bitmap.data[y * 128 + x / 2];
+			ubyte clindex = bitmap.data[y * TEXPAGE_SIZE_X + x / 2];
 
 			if (0 != (x & 1))
 				clindex >>= 4;
diff --git a/DriverLevelTool/viewer/viewer.cpp b/DriverLevelTool/viewer/viewer.cpp
@@ -197,7 +197,7 @@ bool LoadLevelFile()
 	CDriverLevelLoader loader;
 	loader.Initialize(g_levInfo, &g_levTextures, &g_levModels, g_levMap);
 
-	return loader.LoadFromFile(g_levname);
+	return loader.Load(&stream);
 }
 
 //-------------------------------------------------------

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`
`4`	`4`	`#include <malloc.h>`
`5`	`5`	`#include <nstd/HashSet.hpp>`
`6`		`-#include "util/util.h"`
	`6`	`+`
`7`	`7`	`#include "models.h"`
`8`	`8`
`9`	`9`	`#include <string.h>`
`@@ -348,9 +348,9 @@ void SwapValues(T& a, T& b)`
`348`	`348`
`349`	`349`	`// returns size of face and fills dface_t struct`
`350`	`350`	`// TODO: rework, few variants of faces still looks bad`
`351`		`-int decode_poly(const char* polyList, dpoly_t* out)`
	`351`	`+int decode_poly(const char* polyList, dpoly_t* out, int forceType /= -1/)`
`352`	`352`	`{`
`353`		`- int ptype = *polyList & 0x1f;`
	`353`	`+ int ptype = forceType == -1 ? (*polyList & 0x1f) : forceType;`
`354`	`354`
`355`	`355`	`out->page = 0xFF;`
`356`	`356`	`out->detail = 0xFF;`
`@@ -361,7 +361,7 @@ int decode_poly(const char* polyList, dpoly_t* out)`
`361`	`361`	`switch (ptype)`
`362`	`362`	`{`
`363`	`363`	`case 1:`
`364`		`- // what a strange face type`
	`364`	`+ // what a strange face type. Hardcoded?`
`365`	`365`	`(uint)out->vindices = (uint)&polyList[3];`
`366`	`366`	`break;`
`367`	`367`	`case 0:`
`@@ -479,5 +479,5 @@ int decode_poly(const char* polyList, dpoly_t* out)`
`479`	`479`	`}`
`480`	`480`	`}`
`481`	`481`
`482`		`- return PolySizes[ptype];`
	`482`	`+ return PolySizes[*polyList & 0x1f];`
`483`	`483`	`}`