bsppp: add support for console BSPs

Author: craftablescience

ext/bufferstream

@@ -18,6 +18,7 @@
 namespace bsppp {
 
 constexpr auto BSP_SIGNATURE = sourcepp::parser::binary::makeFourCC("VBSP");
+constexpr auto BSP_CONSOLE_SIGNATURE = sourcepp::parser::binary::makeFourCC("PSBV");
 
 enum class BSPLump : int32_t {
 	UNKNOWN = -1,
@@ -156,6 +157,14 @@ class BSP {
 
 	void setMapRevision(uint32_t mapRevision);
 
+	[[nodiscard]] bool isL4D2() const;
+
+	void setL4D2(bool isL4D2);
+
+	[[nodiscard]] bool isConsole() const;
+
+	void setConsole(bool isConsole);
+
 	[[nodiscard]] bool hasLump(BSPLump lumpIndex) const;
 
 	[[nodiscard]] bool isLumpCompressed(BSPLump lumpIndex) const;
@@ -258,7 +267,9 @@ class BSP {
 	uint32_t stagedMapRevision{};
 
 	// Slightly different header despite using the same version just to be quirky
-	bool isL4D2 = false;
+	bool l4d2 = false;
+	// BSP is mostly big-endian
+	bool console = false;
 };
 
 } // namespace bsppp

include/bsppp/BSP.h

@@ -1,5 +1,5 @@
-from ._sourcepp_impl import __doc__, gamepp, sourcepp, steampp, toolpp, vcryptpp, vtfpp
+from ._sourcepp_impl import __doc__, bsppp, gamepp, sourcepp, steampp, toolpp, vcryptpp, vtfpp
 
 __author__ = "craftablescience"
 __version__ = "${SOURCEPP_PYTHON_VERSION}"
-__all__ = ['__author__', '__doc__', '__version__', 'gamepp', 'sourcepp', 'steampp', 'toolpp', 'vcryptpp', 'vtfpp']
+__all__ = ['__author__', '__doc__', '__version__', 'bsppp', 'gamepp', 'sourcepp', 'steampp', 'toolpp', 'vcryptpp', 'vtfpp']

lang/python/cfg/__init__.py

@@ -270,6 +270,8 @@ inline void register_python(py::module_& m) {
 		.def_static("create", &BSP::create, py::arg("path"), py::arg("version") = 21, py::arg("map_revision") = 0)
 		.def_prop_rw("version", &BSP::getVersion, &BSP::setVersion)
 		.def_prop_rw("map_revision", &BSP::getMapRevision, &BSP::setMapRevision)
+		.def_prop_rw("l4d2", &BSP::isL4D2, &BSP::setL4D2)
+		.def_prop_rw("console", &BSP::isConsole, &BSP::setConsole)
 		.def("has_lump", &BSP::hasLump, py::arg("lump_index"))
 		.def("is_lump_compressed", &BSP::isLumpCompressed, py::arg("lump_index"))
 		.def("get_lump_version", &BSP::getLumpVersion, py::arg("lump_index"))

lang/python/src/bsppp.h

@@ -23,6 +23,7 @@ template<BufferStreamPODType T>
 	}
 
 	BufferStreamReadOnly stream{*data};
+	stream.set_big_endian(bsp.isConsole());
 	std::vector<T> out;
 	callback(bsp, stream, out);
 	return out;
@@ -104,6 +105,22 @@ void BSP::setMapRevision(uint32_t mapRevision) {
 	this->stagedMapRevision = mapRevision;
 }
 
+bool BSP::isL4D2() const {
+	return this->l4d2;
+}
+
+void BSP::setL4D2(bool isL4D2) {
+	this->l4d2 = isL4D2;
+}
+
+bool BSP::isConsole() const {
+	return this->console;
+}
+
+void BSP::setConsole(bool isConsole) {
+	this->console = isConsole;
+}
+
 bool BSP::hasLump(BSPLump lumpIndex) const {
 	if (this->path.empty()) {
 		return false;
@@ -351,6 +368,7 @@ bool BSP::bake(std::string_view outputPath) {
 
 	std::vector<std::byte> out;
 	BufferStream stream{out};
+	stream.set_big_endian(this->console);
 
 	stream << BSP_SIGNATURE << this->stagedVersion;
 	if (this->stagedVersion == 27) {
@@ -421,7 +439,7 @@ bool BSP::bake(std::string_view outputPath) {
 
 			const auto curPos = stream.tell();
 			stream.seek_u(lumpsHeaderOffset + (i * sizeof(Lump)));
-			if (!this->isL4D2) {
+			if (!this->l4d2) {
 				stream
 					.write<uint32_t>(gameLumpOffset)
 					.write<uint32_t>(curPos - gameLumpOffset)
@@ -442,7 +460,7 @@ bool BSP::bake(std::string_view outputPath) {
 			const auto& lumpPair = this->stagedLumps.at(i);
 			const auto curPos = stream.tell();
 			stream.seek_u(lumpsHeaderOffset + (i * sizeof(Lump)));
-			if (!this->isL4D2) {
+			if (!this->l4d2) {
 				stream
 					.write<uint32_t>(curPos)
 					.write<uint32_t>(lumpPair.second.size())
@@ -466,7 +484,7 @@ bool BSP::bake(std::string_view outputPath) {
 			stream.seek_u(lumpsHeaderOffset + (i * sizeof(Lump)));
 
 			auto& lump = this->header.lumps[i];
-			if (!this->isL4D2) {
+			if (!this->l4d2) {
 				stream
 					.write<uint32_t>(curPos)
 					.write<uint32_t>(lump.length)
@@ -494,7 +512,7 @@ bool BSP::bake(std::string_view outputPath) {
 		}
 	}
 
-	out.resize(stream.tell());
+	out.resize(stream.size());
 	if (!fs::writeFileBuffer(outputPath.empty() ? this->path : std::string{outputPath}, out)) {
 		return false;
 	}
@@ -511,9 +529,12 @@ bool BSP::readHeader() {
 	}
 	reader.seek_in(0);
 
-	if (reader.read<uint32_t>() != BSP_SIGNATURE) {
+	if (auto signature = reader.read<uint32_t>(); signature != BSP_SIGNATURE && signature != BSP_CONSOLE_SIGNATURE) {
 		// File is not a BSP
 		return false;
+	} else if (signature == BSP_CONSOLE_SIGNATURE) {
+		this->console = true;
+		reader.set_big_endian(true);
 	}
 	this->header.version = reader.read<uint32_t>();
 
@@ -539,8 +560,8 @@ bool BSP::readHeader() {
 				break;
 			}
 		}
-		this->isL4D2 = i == BSP_LUMP_COUNT;
-		if (this->isL4D2) {
+		this->l4d2 = i == BSP_LUMP_COUNT;
+		if (this->l4d2) {
 			// Swap fields around
 			for (i = 0; i < BSP_LUMP_COUNT; i++) {
 				std::swap(this->header.lumps[i].offset, this->header.lumps[i].version);
@@ -693,6 +714,7 @@ std::vector<BSPGameLump> BSP::parseGameLumps(bool decompress) const {
 		return lumps;
 	}
 	BufferStreamReadOnly stream{*gameLumpData};
+	stream.set_big_endian(this->console);
 
 	lumps.resize(stream.read<uint32_t>());
 	for (auto& lump : lumps) {