- D1 Roads support

Author: SoapyMan

routines/d2_types.h

@@ -382,7 +382,7 @@ struct DRIVER2_JUNCTION
 };
 
 //------------------------------------------------------------------------------------------------------------
-// Driver 1 PSX is so wasteful
+// Driver 1 PSX
 
 struct ROAD_MAP_LUMP_DATA
 {
@@ -420,12 +420,57 @@ struct ROUTE_DATA
 	int type;
 	int height;
 	int objectAngle;
+	int roadIndex;
 	uint value;
 };
 
+enum DRIVER1_ROAD_FLAGS
+{
+	ROAD_FLAG_PARKING = (1 << 0)
+};
+
+struct DRIVER1_ROAD
+{
+	short	id;
+	short	ConnectIdx[2];
+	char	NumLanes, LaneDirs;			// looks like the same as in D2
+	short	length;
+	char	flags;
+	char	pad;
+	short	x, z;
+};
+
+struct DRIVER1_JUNC_ETRY
+{
+	short	fromJunc;
+	short	road;
+	short	flags;
+	short	extraFlags;
+};
+
+struct DRIVER1_JUNCTION
+{
+	short	id;
+	char	type;
+	char	pad;
+	short	lightsTimer;
+	char	lightsNS, lightsWE;
+	DRIVER1_JUNC_ETRY entries[4];
+	short	x, z;
+};
+
+struct DRIVER1_ROADBOUNDS
+{
+	int		x1, y1;
+	int		x2, y2;
+	uint8	dir;
+	uint8	_pad[3];
+};
+
 //------------------------------------------------------------------------------------------------------------
 
-struct AreaDataStr {
+struct AreaDataStr 
+{
 	uint16	gfx_offset;
 	uint16	model_offset;
 	uint16	music_offset;

routines/level.cpp

@@ -232,9 +232,13 @@ void CDriverLevelLoader::ProcessLumps(IVirtualStream* pFile)
 				break;
 			case LUMP_ROADS:
 				DevMsg(SPEW_WARNING, "LUMP_ROADS ofs=%d size=%d\n", pFile->Tell(), lump.size);
+				if (m_map)
+					((CDriver1LevelMap*)m_map)->LoadRoadsLump(pFile);
 				break;
 			case LUMP_JUNCTIONS:
 				DevMsg(SPEW_WARNING, "LUMP_JUNCTIONS ofs=%d size=%d\n", pFile->Tell(), lump.size);
+				if (m_map)
+					((CDriver1LevelMap*)m_map)->LoadJunctionsLump(pFile);
 				break;
 			case LUMP_ROADSURF:
 				DevMsg(SPEW_WARNING, "LUMP_ROADSURF ofs=%d size=%d\n", pFile->Tell(), lump.size);
@@ -243,9 +247,13 @@ void CDriverLevelLoader::ProcessLumps(IVirtualStream* pFile)
 				break;
 			case LUMP_ROADBOUNDS:
 				DevMsg(SPEW_WARNING, "LUMP_ROADBOUNDS ofs=%d size=%d\n", pFile->Tell(), lump.size);
+				if (m_map)
+					((CDriver1LevelMap*)m_map)->LoadRoadBoundsLump(pFile);
 				break;
 			case LUMP_JUNCBOUNDS:
 				DevMsg(SPEW_WARNING, "LUMP_JUNCBOUNDS ofs=%d size=%d\n", pFile->Tell(), lump.size);
+				if (m_map)
+					((CDriver1LevelMap*)m_map)->LoadJuncBoundsLump(pFile);
 				break;
 			case LUMP_SUBDIVISION:
 				DevMsg(SPEW_WARNING, "LUMP_SUBDIVISION ofs=%d size=%d\n", pFile->Tell(), lump.size);

routines/regions_d1.cpp

@@ -22,6 +22,9 @@ void CDriver1LevelRegion::FreeAll()
 
 	delete[] m_roadMap;
 	m_roadMap = nullptr;
+
+	delete[] m_surfaceRoads;
+	m_surfaceRoads = nullptr;
 }
 
 void CDriver1LevelRegion::LoadRegionData(const SPOOL_CONTEXT& ctx)
@@ -58,8 +61,8 @@ void CDriver1LevelRegion::LoadRegionData(const SPOOL_CONTEXT& ctx)
 	const int pvsDataOffset = cellObjectsOffset + m_spoolInfo->cell_data_size[2]; // FIXME: is it even there in Driver 1?
 
 	// read roadm (map?)
-	//pFile->Seek(ctx.lumpInfo->spooled_offset + roadMOffset * SPOOL_CD_BLOCK_SIZE, VS_SEEK_SET);
-	//pFile->Read(roadMapData, m_spoolInfo->roadm_size * SPOOL_CD_BLOCK_SIZE, sizeof(char));
+	pFile->Seek(ctx.lumpInfo->spooled_offset + roadMOffset * SPOOL_CD_BLOCK_SIZE, VS_SEEK_SET);
+	LoadRoadCellsData(pFile);
 
 	// read roadh (heights?)
 	pFile->Seek(ctx.lumpInfo->spooled_offset + roadHOffset * SPOOL_CD_BLOCK_SIZE, VS_SEEK_SET);
@@ -137,6 +140,30 @@ void CDriver1LevelRegion::LoadRoadHeightMapData(IVirtualStream* pFile)
 	delete[] roadMapData;
 }
 
+void CDriver1LevelRegion::LoadRoadCellsData(IVirtualStream* pFile)
+{
+	m_surfaceRoads = new ushort[ROAD_MAP_REGION_CELLS];
+	ushort* pRoadIds = m_surfaceRoads;
+	int i = ROAD_MAP_REGION_CELLS;
+
+	do {
+		short length;
+		pFile->Read(&length, 1, sizeof(short));
+
+		if (length == -1)
+			break;
+
+		ushort value;
+		pFile->Read(&value, 1, sizeof(short));
+
+		int count = length;
+		for (i = i - count; count > 0; count--)
+		{
+			*pRoadIds++ = value;
+		}
+	} while (i > 0);
+}
+
 //----------------------------------------
 // cell iterator
 CELL_OBJECT* CDriver1LevelRegion::StartIterator(CELL_ITERATOR_D1* iterator, int cellNumber) const
@@ -175,6 +202,18 @@ void CDriver1LevelMap::FreeAll()
 	Memory::free(m_surfaceData);
 	m_surfaceData = nullptr;
 
+	delete[] m_roads;
+	m_roads = nullptr;
+
+	delete[] m_roadBounds;
+	m_roadBounds = nullptr;
+
+	delete[] m_junctions;
+	m_junctions = nullptr;
+
+	delete[] m_junctionBounds;
+	m_junctionBounds = nullptr;
+
 	CBaseLevelMap::FreeAll();
 }
 
@@ -225,6 +264,36 @@ void CDriver1LevelMap::LoadRoadMapLump(IVirtualStream* pFile)
 	//m_roadMapLumpData.unitZMid = 1500 * height / 2;
 }
 
+void CDriver1LevelMap::LoadRoadsLump(IVirtualStream* pFile)
+{
+	pFile->Read(&m_numRoads, 1, sizeof(int));
+	m_roads = new DRIVER1_ROAD[m_numRoads];
+	pFile->Read(m_roads, m_numRoads, sizeof(DRIVER1_ROAD));
+}
+
+void CDriver1LevelMap::LoadJunctionsLump(IVirtualStream* pFile)
+{
+	pFile->Read(&m_numJunctions, 1, sizeof(int));
+	m_junctions = new DRIVER1_JUNCTION[m_numJunctions];
+	pFile->Read(m_junctions, m_numJunctions, sizeof(DRIVER1_JUNCTION));
+}
+
+void CDriver1LevelMap::LoadRoadBoundsLump(IVirtualStream* pFile)
+{
+	int numRoadBounds;
+	pFile->Read(&numRoadBounds, 1, sizeof(int));
+	m_roadBounds = new DRIVER1_ROADBOUNDS[numRoadBounds];
+	pFile->Read(m_roadBounds, numRoadBounds, sizeof(DRIVER1_ROADBOUNDS));
+}
+
+void CDriver1LevelMap::LoadJuncBoundsLump(IVirtualStream* pFile)
+{
+	int numJuncBounds;
+	pFile->Read(&numJuncBounds, 1, sizeof(int));
+	m_junctionBounds = new XYPAIR[numJuncBounds];
+	pFile->Read(m_junctionBounds, numJuncBounds, sizeof(XYPAIR));
+}
+
 void CDriver1LevelMap::LoadRoadSurfaceLump(IVirtualStream* pFile, int size)
 {
 	int numSurfaces;
@@ -252,6 +321,12 @@ 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;
 
+	if (region_x < 0 ||
+		region_z < 0 ||
+		region_x >= m_regions_across ||
+		region_z >= m_regions_down)
+		return nullptr;
+
 	return GetRegion(region_x + region_z * m_regions_across);
 }
 
@@ -370,13 +445,15 @@ bool CDriver1LevelMap::GetRoadInfo(ROUTE_DATA& outData, const VECTOR_NOPAD& posi
 		return false;
 	}
 
-	const uint value = region->m_roadMap[(cpos.x % road_region_size) + 
-										 (cpos.z % road_region_size) * road_region_size];
+	const int cellIdx = (cpos.x % road_region_size) + (cpos.z % road_region_size) * road_region_size;
+
+	const uint value = region->m_roadMap[cellIdx];
 
 	outData.height = *(short*)&value;
-	outData.type = value >> 16 & 0x3ff;
+	outData.type = value >> 16 & 1023;
 	outData.objectAngle = (value >> 30) * 1024;
 	outData.value = value;
+	outData.roadIndex = region->m_surfaceRoads[cellIdx];
 
 	return true;
 }

routines/regions_d1.h

@@ -6,6 +6,8 @@
 // DRIVER 1
 //----------------------------------------------------------------------------------
 
+#define ROAD_MAP_REGION_CELLS	3600
+
 class CDriver1LevelRegion;
 class CDriver1LevelMap;
 
@@ -32,9 +34,11 @@ class CDriver1LevelRegion : public CBaseLevelRegion
 
 protected:
 	void					LoadRoadHeightMapData(IVirtualStream* pFile);
+	void					LoadRoadCellsData(IVirtualStream* pFile);
 
 	CELL_DATA_D1*			m_cells{ nullptr };				// cell data that holding information about cell pointers. 3D world seeks cells first here
 	uint*					m_roadMap{ nullptr };
+	ushort*					m_surfaceRoads{ nullptr };
 };
 
 
@@ -50,6 +54,11 @@ class CDriver1LevelMap : public CBaseLevelMap
 	void 					LoadMapLump(IVirtualStream* pFile) override;
 	void					LoadSpoolInfoLump(IVirtualStream* pFile) override;
 
+	void					LoadRoadsLump(IVirtualStream* pFile);
+	void					LoadJunctionsLump(IVirtualStream* pFile);
+	void					LoadRoadBoundsLump(IVirtualStream* pFile);
+	void					LoadJuncBoundsLump(IVirtualStream* pFile);
+
 	void					LoadRoadMapLump(IVirtualStream* pFile); // or NewProcessRoadMapLump in D1 & D2
 	void					LoadRoadSurfaceLump(IVirtualStream* pFile, int size);
 
@@ -68,7 +77,17 @@ class CDriver1LevelMap : public CBaseLevelMap
 
 	//----------------------------------------
 	// road map stuff
-	bool					GetRoadInfo(ROUTE_DATA& outData, const VECTOR_NOPAD& position) const;
+	bool						GetRoadInfo(ROUTE_DATA& outData, const VECTOR_NOPAD& position) const;
+
+	int							GetNumRoads() const { return m_numRoads; }
+	int							GetNumJunctions() const { return m_numJunctions; }
+
+	const ROAD_MAP_LUMP_DATA&	GetRoadMapLumpData() const { return m_roadMapLumpData; }
+
+	DRIVER1_ROAD*				GetRoad(int idx) const { return &m_roads[idx]; }
+	DRIVER1_ROADBOUNDS*			GetRoadBounds(int idx) const { return &m_roadBounds[idx]; }
+	DRIVER1_JUNCTION*			GetJunction(int idx) const { return &m_junctions[idx]; }
+	XYPAIR*						GetJunctionBounds(int idx) const { return &m_junctionBounds[idx]; }
 
 protected:
 
@@ -79,6 +98,14 @@ class CDriver1LevelMap : public CBaseLevelMap
 	CDriver1LevelRegion*	m_regions{ nullptr };					// map of regions
 	SURFACEINFO*			m_surfacePtrs[900];
 	char*					m_surfaceData{ nullptr };
+
+	DRIVER1_ROAD*			m_roads{ nullptr };
+	DRIVER1_ROADBOUNDS*		m_roadBounds{ nullptr };
+	DRIVER1_JUNCTION*		m_junctions{ nullptr };
+	XYPAIR*					m_junctionBounds{ nullptr };
+
+	int						m_numRoads{ 0 };
+	int						m_numJunctions{ 0 };
 };