- move overlay map handling to CDriverLevelTextures, fix export bug

Author: SoapyMan

DriverLevelTool/driver_routines/d2_types.h

@@ -309,6 +309,14 @@ struct CELL_OBJECT {
 
 //------------------------------------------------------------------------------------------------------------
 
+enum SurfaceType
+{
+	SurfType_Asphalt = 0,
+	SurfType_Grass = 4,
+	SurfType_Water = 6,
+	SurfType_DeepWater = 9,		// the default surface
+};
+
 struct sdPlane
 {
 	short surfaceType;
@@ -371,6 +379,14 @@ struct DRIVER2_JUNCTION
 
 //------------------------------------------------------------------------------------------------------------
 
+struct ROAD_MAP_LUMP_DATA
+{
+	int width, height;
+	int unitXMid, unitZMid;
+};
+
+//------------------------------------------------------------------------------------------------------------
+
 struct AreaDataStr {
 	uint16	gfx_offset;
 	uint16	model_offset;

DriverLevelTool/driver_routines/level.cpp

@@ -11,20 +11,6 @@
 
 #include "level.h"
 
-
-//--------------------------------------------------------------------------------------------------------------------------
-
-char*						g_overlayMapData = nullptr;
-
-//-------------------------------------------------------------
-// Loads overhead map lump
-//-------------------------------------------------------------
-void LoadOverlayMapLump(IVirtualStream* pFile, int lumpSize)
-{
-	g_overlayMapData = new char[lumpSize];
-	pFile->Read(g_overlayMapData, 1, lumpSize);
-}
-
 //-------------------------------------------------------------
 // Auto-detects level format
 //-------------------------------------------------------------
@@ -182,12 +168,13 @@ void CDriverLevelLoader::ProcessLumps(IVirtualStream* pFile)
 				break;
 			case LUMP_OVERLAYMAP:
 				DevMsg(SPEW_WARNING, "LUMP_OVERLAYMAP ofs=%d size=%d\n", pFile->Tell(), lump.size);
-				LoadOverlayMapLump(pFile, lump.size);
+				if(m_textures)
+					m_textures->LoadOverlayMapLump(pFile, lump.size);
 				break;
 			case LUMP_PALLET:
 				DevMsg(SPEW_WARNING, "LUMP_PALLET ofs=%d size=%d\n", pFile->Tell(), lump.size);
 				if(m_textures)
-					m_textures->ProcessPalletLump(pFile);
+					m_textures->LoadPalletLump(pFile);
 				break;
 			case LUMP_SPOOLINFO:
 				DevMsg(SPEW_WARNING, "LUMP_SPOOLINFO ofs=%d size=%d\n", pFile->Tell(), lump.size);
@@ -293,7 +280,6 @@ void CDriverLevelLoader::Initialize(OUT_CITYLUMP_INFO& lumpInfo, CDriverLevelTex
 
 void CDriverLevelLoader::Release()
 {
-	delete[] g_overlayMapData;
 }
 
 //-------------------------------------------------------------

DriverLevelTool/driver_routines/models.cpp

@@ -58,7 +58,7 @@ ModelRef_t* CDriverLevelModels::GetModelByIndex(int nIndex) const
 
 int CDriverLevelModels::FindModelIndexByName(const char* name) const
 {
-	for (int i = 0; i < MAX_MODELS && i < m_model_names.size(); i++)
+	for (usize i = 0; i < MAX_MODELS && i < m_model_names.size(); i++)
 	{
 		if (!stricmp(m_model_names[i], name))
 			return i;

DriverLevelTool/driver_routines/models.h

@@ -48,39 +48,31 @@ enum EFaceFlags_e
 
 struct ModelRef_t
 {
-	ModelRef_t()
-	{
-		model = nullptr;
-		userData = nullptr;
-		baseInstance = nullptr;
-		name = nullptr;
-	}
+	ModelRef_t* baseInstance{ nullptr };
 
-	ModelRef_t* baseInstance;
+	const char* name{ nullptr };
+	MODEL*		model{ nullptr };
 
-	const char*	name;
-	MODEL*		model;
+	int			index{ -1 };
+	int			size{ 0 };
 
-	int			index;
-	int			size;
-
-	ushort		highDetailId;
-	ushort		lowDetailId;
+	ushort		highDetailId{ 0xffff };
+	ushort		lowDetailId{ 0xffff };
 
-	void*		userData; // might contain a hardware model pointer
+	void*		userData{ nullptr }; // might contain a hardware model pointer
 };
 
 //------------------------------------------------------------------------------------------------------------
 
 struct CarModelData_t
 {
-	MODEL* cleanmodel;
-	MODEL* dammodel;
-	MODEL* lowmodel;
+	MODEL* cleanmodel{ nullptr };
+	MODEL* dammodel{ nullptr };
+	MODEL* lowmodel{ nullptr };
 
-	int cleanSize;
-	int damSize;
-	int lowSize;
+	int cleanSize{ 0 };
+	int damSize{ 0 };
+	int lowSize{ 0 };
 };
 
 class CDriverLevelModels

DriverLevelTool/driver_routines/regions.h

@@ -106,6 +106,7 @@ class CBaseLevelMap
 	virtual CBaseLevelRegion*	GetRegion(int regionIdx) const = 0;
 
 	virtual int					MapHeight(const VECTOR_NOPAD& position) const = 0;
+	virtual int					FindSurface(const VECTOR_NOPAD& position, VECTOR_NOPAD& outNormal, VECTOR_NOPAD& outPoint, sdPlane** outPlane) const = 0;
 
 	// converters
 	void						WorldPositionToCellXZ(XZPAIR& cell, const VECTOR_NOPAD& position) const;

DriverLevelTool/driver_routines/regions_d1.cpp

@@ -144,7 +144,7 @@ void CDriver1LevelMap::LoadSpoolInfoLump(IVirtualStream* pFile)
 	CBaseLevelMap::LoadSpoolInfoLump(pFile);
 
 	// Init regions
-	int total_regions = m_regions_across * m_regions_down;
+	const int total_regions = m_regions_across * m_regions_down;
 
 	m_regions = new CDriver1LevelRegion[total_regions];
 
@@ -158,11 +158,17 @@ CBaseLevelRegion* CDriver1LevelMap::GetRegion(const XZPAIR& cell) const
 	const int region_x = cell.x / m_mapInfo.region_size;
 	const int region_z = cell.z / m_mapInfo.region_size;
 
-	return &m_regions[region_x + region_z * m_regions_across];
+	return GetRegion(region_x + region_z * m_regions_across);;
 }
 
 CBaseLevelRegion* CDriver1LevelMap::GetRegion(int regionIdx) const
 {
+#if 0
+	const int total_regions = m_regions_across * m_regions_down;
+
+	if (regionIdx < 0 && regionIdx >= total_regions)
+		return nullptr;
+#endif
 	return &m_regions[regionIdx];
 }
 
@@ -186,7 +192,7 @@ void CDriver1LevelMap::SpoolRegion(const SPOOL_CONTEXT& ctx, int regionIdx)
 {
 	CDriver1LevelRegion* region = (CDriver1LevelRegion*)GetRegion(regionIdx);
 
-	if (!region->m_loaded)
+	if (region && !region->m_loaded)
 	{
 		if (m_regionSpoolInfoOffsets[region->m_regionNumber] != REGION_EMPTY)
 		{
@@ -198,20 +204,47 @@ void CDriver1LevelMap::SpoolRegion(const SPOOL_CONTEXT& ctx, int regionIdx)
 	}
 }
 
+extern sdPlane g_defaultPlane;
+
 int	CDriver1LevelMap::MapHeight(const VECTOR_NOPAD& position) const
 {
 	MsgWarning("UNIMPLEMENTED MapHeight for D1\n");
 	return 0;
 }
 
+int CDriver1LevelMap::FindSurface(const VECTOR_NOPAD& position, VECTOR_NOPAD& outNormal, VECTOR_NOPAD& outPoint, sdPlane** outPlane) const
+{
+	{
+		*outPlane = &g_defaultPlane;
+
+		outPoint.vx = position.vx;
+		outPoint.vz = position.vz;
+		outPoint.vy = 0;
+
+		if (*outPlane == NULL || (*outPlane)->b == 0)
+		{
+			outNormal.vx = 0;
+			outNormal.vy = 4096;
+			outNormal.vz = 0;
+		}
+		else
+		{
+			outNormal.vx = (int)(*outPlane)->a >> 2;
+			outNormal.vy = (int)(*outPlane)->b >> 2;
+			outNormal.vz = (int)(*outPlane)->c >> 2;
+		}
+	}
+	return 4096;
+}
+
 //-------------------------------------------------------------
 // returns first cell object of cell
 //-------------------------------------------------------------
-CELL_OBJECT* CDriver1LevelMap::GetFirstCop(CELL_ITERATOR_D1* iterator, int cellx, int cellz) const
+CELL_OBJECT* CDriver1LevelMap::GetFirstCop(CELL_ITERATOR_D1* iterator, const XZPAIR& cell) const
 {
 	// lookup region
-	const int region_x = cellx / m_mapInfo.region_size;
-	const int region_z = cellz / m_mapInfo.region_size;
+	const int region_x = cell.x / m_mapInfo.region_size;
+	const int region_z = cell.z / m_mapInfo.region_size;
 
 	int regionIdx = region_x + region_z * m_regions_across;
 
@@ -224,8 +257,8 @@ CELL_OBJECT* CDriver1LevelMap::GetFirstCop(CELL_ITERATOR_D1* iterator, int cellx
 		return nullptr;
 
 	// get cell index on the region
-	const int region_cell_x = cellx % m_mapInfo.region_size;
-	const int region_cell_z = cellz % m_mapInfo.region_size;
+	const int region_cell_x = cell.x % m_mapInfo.region_size;
+	const int region_cell_z = cell.z % m_mapInfo.region_size;
 
 	// FIXME: might be incorrect
 	int cell_index = region_cell_x + region_cell_z * m_mapInfo.region_size;
@@ -236,11 +269,11 @@ CELL_OBJECT* CDriver1LevelMap::GetFirstCop(CELL_ITERATOR_D1* iterator, int cellx
 		return nullptr;
 
 	// get the packed cell data start and near cell
-	CELL_DATA_D1& cell = region.m_cells[cell_ptr];
+	CELL_DATA_D1& pcd = region.m_cells[cell_ptr];
 
-	CELL_OBJECT* pco = region.GetCellObject(cell.num & 0x3fff);
+	CELL_OBJECT* pco = region.GetCellObject(pcd.num & 0x3fff);
 
-	iterator->pcd = &cell;
+	iterator->pcd = &pcd;
 	iterator->pco = pco;
 
 	return pco;

DriverLevelTool/driver_routines/regions_d1.h

@@ -53,10 +53,11 @@ class CDriver1LevelMap : public CBaseLevelMap
 	CBaseLevelRegion*		GetRegion(int regionIdx) const override;
 
 	int						MapHeight(const VECTOR_NOPAD& position) const override;
+	int						FindSurface(const VECTOR_NOPAD& position, VECTOR_NOPAD& outNormal, VECTOR_NOPAD& outPoint, sdPlane** outPlane) const override;
 
 	//----------------------------------------
 	// cell iterator
-	CELL_OBJECT*			GetFirstCop(CELL_ITERATOR_D1* iterator, int cellx, int cellz) const;
+	CELL_OBJECT*			GetFirstCop(CELL_ITERATOR_D1* iterator, const XZPAIR& cell) const;
 	CELL_OBJECT*			GetNextCop(CELL_ITERATOR_D1* iterator) const;
 
 protected:

DriverLevelTool/driver_routines/regions_d2.cpp

@@ -15,8 +15,8 @@
 #define IS_CURVED_SURFACE(surfid)			(((surfid) > -1) && ((surfid) & 0xFFFFE000) == 0x4000 && ((surfid) & 0x1FFF) < m_numCurves)
 #define IS_JUNCTION_SURFACE(surfid)			(((surfid) > -1) && ((surfid) & 0xFFFFE000) == 0x2000 && ((surfid) & 0x1FFF) < m_numJunctions)
 
-sdPlane g_defaultPlane	= { 0, 0, 0, 0, 2048 };
-sdPlane g_seaPlane		= { 9, 0, 16384, 0, 2048 };
+sdPlane g_defaultPlane	= { SurfType_Asphalt, 0, 0, 0, 2048 };
+sdPlane g_seaPlane		= { SurfType_DeepWater, 0, 16384, 0, 2048 };
 
 int SdHeightOnPlane(const VECTOR_NOPAD& position, sdPlane* plane, DRIVER2_CURVE* curves)
 {
@@ -683,19 +683,26 @@ CBaseLevelRegion* CDriver2LevelMap::GetRegion(const XZPAIR& cell) const
 	const int region_x = cell.x / m_mapInfo.region_size;
 	const int region_z = cell.z / m_mapInfo.region_size;
 
-	return &m_regions[region_x + region_z * m_regions_across];
+	return GetRegion(region_x + region_z * m_regions_across);
 }
 
 CBaseLevelRegion* CDriver2LevelMap::GetRegion(int regionIdx) const
 {
+#if 0
+	const int total_regions = m_regions_across * m_regions_down;
+
+	if (regionIdx < 0 && regionIdx >= total_regions)
+		return nullptr;
+#endif
+
 	return &m_regions[regionIdx];
 }
 
 void CDriver2LevelMap::SpoolRegion(const SPOOL_CONTEXT& ctx, const XZPAIR& cell)
 {
 	CDriver2LevelRegion* region = (CDriver2LevelRegion*)GetRegion(cell);
 
-	if (!region->m_loaded)
+	if (region && !region->m_loaded)
 	{
 		if (m_regionSpoolInfoOffsets[region->m_regionNumber] != REGION_EMPTY)
 		{
@@ -711,7 +718,7 @@ void CDriver2LevelMap::SpoolRegion(const SPOOL_CONTEXT& ctx, int regionIdx)
 {
 	CDriver2LevelRegion* region = (CDriver2LevelRegion*)GetRegion(regionIdx);
 
-	if (!region->m_loaded)
+	if (region && !region->m_loaded)
 	{
 		if (m_regionSpoolInfoOffsets[region->m_regionNumber] != REGION_EMPTY)
 		{
@@ -736,14 +743,54 @@ int CDriver2LevelMap::MapHeight(const VECTOR_NOPAD& position) const
 	WorldPositionToCellXZ(cell, cellPos);
 	CDriver2LevelRegion* region = (CDriver2LevelRegion*)GetRegion(cell);
 
-	sdPlane* plane = region->SdGetCell(cellPos, level, SdGetBSP);
+	sdPlane* plane = &g_seaPlane;
+	if (region)
+		plane = region->SdGetCell(cellPos, level, SdGetBSP);
 
 	if (plane)
 		return SdHeightOnPlane(position, plane, m_curves);
 
 	return 0;
 }
 
+int CDriver2LevelMap::FindSurface(const VECTOR_NOPAD& position, VECTOR_NOPAD& outNormal, VECTOR_NOPAD& outPoint, sdPlane** outPlane) const
+{
+	VECTOR_NOPAD cellPos;
+	XZPAIR cell;
+	int level = 0;
+
+	cellPos.vx = position.vx - 512;	// FIXME: is that a quarter of a cell?
+	cellPos.vy = position.vy;
+	cellPos.vz = position.vz - 512;
+
+	WorldPositionToCellXZ(cell, cellPos);
+	CDriver2LevelRegion* region = (CDriver2LevelRegion*)GetRegion(cell);
+
+	if (region)
+	{
+		*outPlane = region->SdGetCell(cellPos, level, SdGetBSP);
+
+		outPoint.vx = position.vx;
+		outPoint.vz = position.vz;
+		outPoint.vy = SdHeightOnPlane(position, *outPlane, m_curves);
+
+		if (*outPlane == NULL || (*outPlane)->b == 0)
+		{
+			outNormal.vx = 0;
+			outNormal.vy = 4096;
+			outNormal.vz = 0;
+		}
+		else
+		{
+			outNormal.vx = (int)(*outPlane)->a >> 2;
+			outNormal.vy = (int)(*outPlane)->b >> 2;
+			outNormal.vz = (int)(*outPlane)->c >> 2;
+		}
+	}
+
+	return 4096;
+}
+
 int	CDriver2LevelMap::GetRoadIndex(VECTOR_NOPAD& position) const
 {
 	VECTOR_NOPAD cellPos;
@@ -915,6 +962,7 @@ PACKED_CELL_OBJECT* CDriver2LevelMap::GetNextPackedCop(CELL_ITERATOR_D2* iterato
 	ushort num;
 	PACKED_CELL_OBJECT* ppco;
 	CELL_OBJECT* co;
+	CDriver2LevelRegion* reg = iterator->region;
 
 	do {
 		CELL_DATA* celld = iterator->pcd;
@@ -932,8 +980,8 @@ PACKED_CELL_OBJECT* CDriver2LevelMap::GetNextPackedCop(CELL_ITERATOR_D2* iterato
 
 		iterator->pcd = celld;
 
-		ppco = iterator->region->GetPackedCellObject(celld->num & 0x3fff);
-		co = iterator->region->GetCellObject(celld->num & 0x3fff);
+		ppco = reg->GetPackedCellObject(celld->num & 0x3fff);
+		co = reg->GetCellObject(celld->num & 0x3fff);
 
 	} while (ppco->value == 0xffff && (ppco->pos.vy & 1));