Merge pull request #14 from ReactiioN1337/develop

Updated legacy branch

Author: ReactiioN1337

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "thirdparty/liblzma"]
+	path = thirdparty/liblzma
+	url = https://github.com/ReactiioN1337/liblzma.git

CMakeLists.txt

@@ -0,0 +1,53 @@
+# CMakeList.txt: projekt CMake dla elementu vpk_kv_generator, dołącz źródło i zdefiniuj
+# tutaj logikę specyficzną dla projektu.
+#
+cmake_minimum_required (VERSION 3.10)
+
+include_guard(GLOBAL)
+
+set (CMAKE_CXX_STANDARD 17) #this does not change __cplusplus var in MSVC for some reason
+
+project ("valve-bsp-parser")
+
+
+#set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wextra -pedantic -Werror -funroll-loops -fvisibility=hidden -O3")
+
+#Template compilation fails at x64 MSVC in parse_map template function
+# beacuse of _NODISCARD macro
+#Since in c++17 keyword [[nodiscard]] is already defined we use it instead of a macro
+#TODO: Can we use x64 version of the lib?
+
+#TODO: LZMA compression of lumps
+#TODO: entity lump
+#TODO: Overwrite in-mem bsp file with standalone lump files present in same directory as map
+#Research from leak: This functionality is "temporarily" disabled from the multiplayer games, due to possibility of exploits. sv_pure cannot detect such patches. The comment cites a wallhack as an example.
+# Dodaj źródło do pliku wykonywalnego tego projektu.
+set (PRIVATE_INCLUDES
+    "include/valve-bsp-parser/bsp_parser.hpp"
+    "include/valve-bsp-parser/core/matrix.hpp"
+    "include/valve-bsp-parser/core/requirements.hpp"
+    "include/valve-bsp-parser/core/valve_structs.hpp")
+
+set (SOURCES 
+"src/bsp_parser.cpp")
+
+add_library(valve-bsp-parser STATIC  ${PRIVATE_INCLUDES} ${SOURCES})
+
+
+
+
+    add_subdirectory(thirdparty/liblzma)
+
+add_dependencies(valve-bsp-parser lzma)
+target_include_directories(valve-bsp-parser PUBLIC
+    ${Boost_INCLUDE_DIR}
+    "${PROJECT_SOURCE_DIR}/include/"
+    "${PROJECT_SOURCE_DIR}/thirdparty/liblzma/include"
+    )
+
+
+target_link_libraries(valve-bsp-parser PRIVATE lzma)
+    
+
+
+# TODO: Dodaj testy i zainstaluj elementy docelowe w razie potrzeby.

include/valve-bsp-parser/bsp_parser.hpp

@@ -1,4 +1,4 @@
-///--------------------------------------------------------------------------------
+///--------------------------------------------------------------------------------
 ///-- Author        ReactiioN
 ///-- Copyright     2016-2020, ReactiioN
 ///-- License       MIT
@@ -7,6 +7,11 @@
 
 #include <valve-bsp-parser/core/valve_structs.hpp>
 #include <shared_mutex>
+#include <LzmaLib.h>
+#include <cstring>
+#include <cassert>
+#include <mutex>
+#include <optional>
 
 namespace rn {
 class bsp_parser final
@@ -39,21 +44,34 @@ class bsp_parser final
         std::string&       file_path
     );
 
+
     bool parse_planes(
-        std::ifstream& file
+        std::ifstream& file,
+        std::optional<valve::lumpfileheader_t> lumpFileHeader
+    );
+    bool parse_entities(
+        std::ifstream& file,
+        std::optional<valve::lumpfileheader_t> lumpFileHeader
     );
 
     bool parse_nodes(
-        std::ifstream& file
+        std::ifstream& file,
+        std::optional<valve::lumpfileheader_t> lumpFileHeader
     );
 
     bool parse_leaffaces(
-        std::ifstream& file
+        std::ifstream& file,
+        std::optional<valve::lumpfileheader_t> lumpFileHeader
     );
 
     bool parse_leafbrushes(
-        std::ifstream& file
-    );
+        std::ifstream& file,
+        std::optional<valve::lumpfileheader_t> lumpFileHeader
+    ); 
+    
+    //bool parse_entities(
+    //    std::ifstream& file
+    //);
 
     bool parse_polygons();
 
@@ -81,26 +99,104 @@ class bsp_parser final
     )const;
 
     template<typename type>
-    _NODISCARD
+    NODISCARD
     bool parse_lump(
         std::ifstream&          file,
         const valve::lump_index lump_index,
-        std::vector<type>&      out
+        std::vector<type>&      out,
+        std::optional<valve::lumpfileheader_t> fileLump = std::nullopt
     ) const
     {
+        using rn::valve::lzma_header_t;
+        using rn::valve::has_valid_lzma_ident;
         const auto index = static_cast<std::underlying_type_t<valve::lump_index>>( lump_index );
-        if( index >= _bsp_header.lumps.size() ) {
+
+
+
+        if( index >= bsp_header.lumps.size() ) {
             return false;
         }
+        //TODO: decompress lump here if compressed
+        //Default behavior is casting data to underlying types.
+        //It doesn't handle compression
+
+
+        //There are two exceptions though: Game lumps (35) (yes, multiple; compressed individually), and PAK Lump (40) (basically a zip file)
+
+
+        const auto& lump = bsp_header.lumps.at( index );
+
+        std::size_t lumpOffset,lumpSize;
+
+        valve::lumpfileheader_t lumpPatch;
+        if (fileLump.has_value()) {
+               lumpPatch = fileLump.value();
+               lumpOffset = lumpPatch.file_offset;
+               lumpSize = lumpPatch.file_size;
+        } else {
+
+            lumpOffset = lump.file_offset;
+            lumpSize = lump.file_size;
+        }
+
+        auto size  = static_cast<std::size_t>( lumpSize ) / sizeof( type );
+        //out.resize( size );
+
+
+        char* tmpData = new char[lumpSize + sizeof(lzma_header_t) + 1]; //lump.file_size doesn't count size of the header
+        file.seekg( lumpOffset );
+        //Temporarily make this array. This data may be compressed.
+        
+        memset(tmpData, 0, lumpSize + sizeof(lzma_header_t) + 1);
+
+        file.read(tmpData, lumpSize);
 
-        const auto& lump = _bsp_header.lumps.at( index );
-        const auto size  = static_cast<std::size_t>( lump.file_size ) / sizeof( type );
+        lzma_header_t lzma_header;
+        memcpy(&lzma_header, tmpData, sizeof(lzma_header));
 
-        out.resize( size );
 
-        file.seekg( lump.file_offset );
-        file.read( reinterpret_cast<char*>( out.data() ), size * static_cast<std::size_t>( sizeof( type ) ) );
+        if (has_valid_lzma_ident(lzma_header.id))
+        {
+            assert(lump_index != valve::lump_index::game_lump || lump_index != valve::lump_index::pak_file); //Those have special rules regarding compression.
 
+
+
+            //This section below was BEFORE if check. This resulted on malloc pulling array size from garbage data
+            //without checking if data were actually compressed.
+
+
+            char* tmpUncompressedData;
+            //bool isCompressed = false;
+
+           
+            tmpUncompressedData = new char[lzma_header.actualSize + 1];
+
+
+            size_t lzmaSize = lzma_header.lzmaSize,realSize = lzma_header.actualSize;
+
+
+            LzmaUncompress(reinterpret_cast<unsigned char*>(tmpUncompressedData),
+                           &realSize,
+                           reinterpret_cast<unsigned char*>(tmpData+sizeof(lzma_header_t)), //point to actual data, not the header
+                           &lzmaSize,
+                           reinterpret_cast<unsigned char*>(lzma_header.properties.data()),
+                           LZMA_PROPS_SIZE);
+            out.resize(static_cast<std::size_t>(lzma_header.actualSize) / sizeof(type));
+            out.assign(reinterpret_cast<type*>(tmpUncompressedData),reinterpret_cast<type*>(tmpUncompressedData+realSize));
+            delete[] tmpUncompressedData;
+
+        }
+        else
+        {
+            out.resize(size/sizeof(type));
+            out.assign(reinterpret_cast<type*>(tmpData),reinterpret_cast<type*>(tmpData+lumpSize));
+        }
+
+        
+
+
+        //file.read( reinterpret_cast<char*>( out.data() ), size * static_cast<std::size_t>( sizeof( type ) ) );
+        delete[] tmpData;
         return true;
     }
 
@@ -120,23 +216,31 @@ class bsp_parser final
         const vector3&  final,
         valve::trace_t* out
     );
+    void unload_map();
 
+
+
+
+    //TODO: Cannot remove leading underscores as some code relies on it.
+public:
+    std::string                      map_name;
+    valve::dheader_t                 bsp_header;
+    //entities go here
+    std::vector<valve::mvertex_t>    vertices;
+    std::vector<valve::cplane_t>     planes;
+    std::vector<valve::dedge_t>      edges;
+    std::vector<std::int32_t>        surf_edges;
+    std::vector<valve::dleaf_t>      leaves;
+    std::vector<valve::snode_t>      nodes;
+    std::vector<valve::dface_t>      surfaces;
+    std::vector<valve::texinfo_t>    tex_infos;
+    std::vector<valve::dbrush_t>     brushes;
+    std::vector<valve::dbrushside_t> brush_sides;
+    std::vector<std::uint16_t>       leaf_faces;
+    std::vector<std::uint16_t>       leaf_brushes;
+    std::vector<valve::polygon>      polygons;
+    std::vector<valve::entity_t>     entities;
 private:
-    std::string                      _map_name;
-    valve::dheader_t                 _bsp_header;
-    std::vector<valve::mvertex_t>    _vertices;
-    std::vector<valve::cplane_t>     _planes;
-    std::vector<valve::dedge_t>      _edges;
-    std::vector<std::int32_t>        _surf_edges;
-    std::vector<valve::dleaf_t>      _leaves;
-    std::vector<valve::snode_t>      _nodes;
-    std::vector<valve::dface_t>      _surfaces;
-    std::vector<valve::texinfo_t>    _tex_infos;
-    std::vector<valve::dbrush_t>     _brushes;
-    std::vector<valve::dbrushside_t> _brush_sides;
-    std::vector<std::uint16_t>       _leaf_faces;
-    std::vector<std::uint16_t>       _leaf_brushes;
-    std::vector<valve::polygon>      _polygons;
     mutable std::shared_timed_mutex  _mutex;
 };
 }

include/valve-bsp-parser/core/matrix.hpp

@@ -295,15 +295,15 @@ class matrix_t
         return at( row_index * num_cols + col_index );
     }
 
-    _NODISCARD
+    NODISCARD
     const float& at(
         const std::size_t index
     ) const
     {
         return _data.at( clamp_index( index ) );
     }
 
-    _NODISCARD
+    NODISCARD
     const float& at(
         const std::size_t row_index,
         const std::size_t col_index
@@ -312,13 +312,13 @@ class matrix_t
         return at( row_index * num_cols + col_index );
     }
 
-    _NODISCARD
+    NODISCARD
     bool is_zero() const
     {
         return all_of( 0.f );
     }
 
-    _NODISCARD
+    NODISCARD
     bool all_of(
         const float value
     ) const
@@ -329,7 +329,7 @@ class matrix_t
         } );
     }
 
-    _NODISCARD
+    NODISCARD
     float normsqr() const
     {
         static_assert( is_vector(), "norm() can only be used on vectors" );
@@ -343,10 +343,10 @@ class matrix_t
         return value;
     }
 
-    _NODISCARD
+    NODISCARD
     float norm() const
     {
-        return std::sqrtf( normsqr() );
+        return std::sqrt( normsqr() );
     }
 
     matrix_t<1, num_cols> row(
@@ -421,7 +421,7 @@ class matrix_t
         ( *this ) /= norm();
     }
 
-    _NODISCARD
+    NODISCARD
     matrix_t normalized() const
     {
         auto lhs = *this;
@@ -430,7 +430,7 @@ class matrix_t
     }
 
     template<std::size_t rhs_num_rows, std::size_t rhs_num_cols>
-    _NODISCARD
+    NODISCARD
     float dot(
         const matrix_t<rhs_num_rows, rhs_num_cols>& rhs
     ) const
@@ -447,7 +447,7 @@ class matrix_t
         return value;
     }
 
-    _NODISCARD
+    NODISCARD
     matrix_t cross(
         const matrix_t& rhs
     ) const
@@ -461,7 +461,7 @@ class matrix_t
         };
     }
 
-    _NODISCARD
+    NODISCARD
     matrix_t ncross(
         const matrix_t& rhs
     ) const

include/valve-bsp-parser/core/requirements.hpp

@@ -17,3 +17,16 @@
 #include <fstream>
 #include <string>
 #include <vector>
+#include <unordered_map>
+#include <sstream>
+
+
+// check for nodiscard
+
+#if __cplusplus >= 201703L // in MSVC this variable is bogus and refers to C++98 version.
+    #define NODISCARD [[nodiscard]]
+#elif defined(_MSC_VER)
+    #define NODISCARD _NODISCARD
+#else
+    #define NODISCARD [[nodiscard]]
+#endif