Initial commit

.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = tab
+insert_final_newline = true
+trim_trailing_whitespace = true

.gitignore

@@ -0,0 +1,7 @@
+.idea/
+.vs/
+build/
+cmake-build-debug/
+cmake-build-release/
+CMakeSettings.json
+out/

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "vendor/nlohmann_json"]
+	path = vendor/nlohmann_json
+	url = https://github.com/nlohmann/json
+[submodule "vendor/spdlog"]
+	path = vendor/spdlog
+	url = https://github.com/gabime/spdlog

CMakeLists.txt

@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 3.26)
+
+project(cs2-schema-dumper)
+
+set(CMAKE_CXX_STANDARD 20)
+
+add_compile_definitions(WIN32_LEAN_AND_MEAN)
+
+add_subdirectory(vendor)
+
+add_executable(${PROJECT_NAME}
+    src/main.cpp
+    src/process.cpp
+    src/sdk/c_schema_class_field_data.cpp
+    src/sdk/c_schema_class_info.cpp
+    src/sdk/c_schema_system.cpp
+    src/sdk/c_schema_system_type_scope.cpp
+    src/sdk/c_schema_type_declared_class.cpp
+    src/utility/murmur_hash.cpp
+)
+
+target_link_libraries(${PROJECT_NAME} nlohmann_json::nlohmann_json spdlog::spdlog)
+
+target_include_directories(${PROJECT_NAME} PRIVATE include vendor/nlohmann_json/single_include vendor/spdlog/include)

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 a2x
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,13 @@
+# CS2 Schema Dumper
+
+Automated schema class file generator for Counter-Strike: 2. Generates JSON and C++ header files.
+
+# Generated Files
+
+Generated files are stored in the `generated` directory.
+
+📂 [Pre-generated Files](./generated)
+
+# License
+
+Please refer to the [LICENSE](./LICENSE) file for more details.

generated/engine2.dll.hpp

@@ -0,0 +1,243 @@
+#pragma once
+
+#include <cstddef>
+
+namespace EngineLoopState_t {
+    constexpr std::ptrdiff_t m_nPlatWindowWidth = 0x18;
+    constexpr std::ptrdiff_t m_nPlatWindowHeight = 0x1c;
+    constexpr std::ptrdiff_t m_nRenderWidth = 0x20;
+    constexpr std::ptrdiff_t m_nRenderHeight = 0x24;
+}
+
+namespace EventModInitialized_t {
+}
+
+namespace EventFrameBoundary_t {
+    constexpr std::ptrdiff_t m_flFrameTime = 0x0;
+}
+
+namespace EventProfileStorageAvailable_t {
+    constexpr std::ptrdiff_t m_nSplitScreenSlot = 0x0;
+}
+
+namespace EventSplitScreenStateChanged_t {
+}
+
+namespace EventSetTime_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_nClientOutputFrames = 0x28;
+    constexpr std::ptrdiff_t m_flRealTime = 0x30;
+    constexpr std::ptrdiff_t m_flRenderTime = 0x38;
+    constexpr std::ptrdiff_t m_flRenderFrameTime = 0x40;
+    constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x48;
+    constexpr std::ptrdiff_t m_flRenderFrameTimeUnscaled = 0x50;
+    constexpr std::ptrdiff_t m_flTickRemainder = 0x58;
+}
+
+namespace EventClientPollInput_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_flRealTime = 0x28;
+}
+
+namespace EventClientProcessInput_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_flRealTime = 0x28;
+}
+
+namespace EventClientProcessGameInput_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_flRealTime = 0x28;
+    constexpr std::ptrdiff_t m_flFrameTime = 0x2c;
+}
+
+namespace EventClientPreOutput_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_flRenderTime = 0x28;
+    constexpr std::ptrdiff_t m_flRenderFrameTime = 0x30;
+    constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x38;
+    constexpr std::ptrdiff_t m_flRealTime = 0x40;
+    constexpr std::ptrdiff_t m_bRenderOnly = 0x44;
+}
+
+namespace EventClientSceneSystemThreadStateChange_t {
+    constexpr std::ptrdiff_t m_bThreadsActive = 0x0;
+}
+
+namespace EventClientOutput_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_flRenderTime = 0x28;
+    constexpr std::ptrdiff_t m_flRealTime = 0x2c;
+    constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x30;
+    constexpr std::ptrdiff_t m_bRenderOnly = 0x34;
+}
+
+namespace EventClientPostOutput_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_flRenderTime = 0x28;
+    constexpr std::ptrdiff_t m_flRenderFrameTime = 0x30;
+    constexpr std::ptrdiff_t m_flRenderFrameTimeUnbounded = 0x34;
+    constexpr std::ptrdiff_t m_bRenderOnly = 0x38;
+}
+
+namespace EventClientFrameSimulate_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_flRealTime = 0x28;
+    constexpr std::ptrdiff_t m_flFrameTime = 0x2c;
+}
+
+namespace EventSimpleLoopFrameUpdate_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_flRealTime = 0x28;
+    constexpr std::ptrdiff_t m_flFrameTime = 0x2c;
+}
+
+namespace EventSimulate_t {
+    constexpr std::ptrdiff_t m_LoopState = 0x0;
+    constexpr std::ptrdiff_t m_bFirstTick = 0x28;
+    constexpr std::ptrdiff_t m_bLastTick = 0x29;
+}
+
+namespace EventAdvanceTick_t {
+    constexpr std::ptrdiff_t m_nCurrentTick = 0x30;
+    constexpr std::ptrdiff_t m_nCurrentTickThisFrame = 0x34;
+    constexpr std::ptrdiff_t m_nTotalTicksThisFrame = 0x38;
+    constexpr std::ptrdiff_t m_nTotalTicks = 0x3c;
+}
+
+namespace EventPostAdvanceTick_t {
+    constexpr std::ptrdiff_t m_nCurrentTick = 0x30;
+    constexpr std::ptrdiff_t m_nCurrentTickThisFrame = 0x34;
+    constexpr std::ptrdiff_t m_nTotalTicksThisFrame = 0x38;
+    constexpr std::ptrdiff_t m_nTotalTicks = 0x3c;
+}
+
+namespace EventServerAdvanceTick_t {
+}
+
+namespace EventServerPostAdvanceTick_t {
+}
+
+namespace EventClientAdvanceTick_t {
+}
+
+namespace EventClientPostAdvanceTick_t {
+}
+
+namespace EventClientSendInput_t {
+    constexpr std::ptrdiff_t m_bFinalClientCommandTick = 0x0;
+    constexpr std::ptrdiff_t m_nAdditionalClientCommandsToCreate = 0x4;
+}
+
+namespace EventClientPredictionPostNetupdate_t {
+}
+
+namespace EventClientPollNetworking_t {
+    constexpr std::ptrdiff_t m_nTickCount = 0x0;
+}
+
+namespace EventClientProcessNetworking_t {
+}
+
+namespace EventClientPreSimulate_t {
+}
+
+namespace EventClientSimulate_t {
+}
+
+namespace EventServerPollNetworking_t {
+}
+
+namespace EventServerProcessNetworking_t {
+}
+
+namespace EventServerSimulate_t {
+}
+
+namespace EventServerPostSimulate_t {
+}
+
+namespace EventClientPostSimulate_t {
+}
+
+namespace EventClientPauseSimulate_t {
+}
+
+namespace EventPostDataUpdate_t {
+    constexpr std::ptrdiff_t m_nCount = 0x0;
+}
+
+namespace EventPreDataUpdate_t {
+    constexpr std::ptrdiff_t m_nCount = 0x0;
+}
+
+namespace EventAppShutdown_t {
+    constexpr std::ptrdiff_t m_nDummy0 = 0x0;
+}
+
+namespace IHandleEntity {
+}
+
+namespace CNetworkVarChainer {
+    constexpr std::ptrdiff_t m_PathIndex = 0x20;
+}
+
+namespace CVariantDefaultAllocator {
+}
+
+namespace EntOutput_t {
+}
+
+namespace EntComponentInfo_t {
+    constexpr std::ptrdiff_t m_pName = 0x0;
+    constexpr std::ptrdiff_t m_pCPPClassname = 0x8;
+    constexpr std::ptrdiff_t m_pNetworkDataReferencedDescription = 0x10;
+    constexpr std::ptrdiff_t m_pNetworkDataReferencedPtrPropDescription = 0x18;
+    constexpr std::ptrdiff_t m_nRuntimeIndex = 0x20;
+    constexpr std::ptrdiff_t m_nFlags = 0x24;
+    constexpr std::ptrdiff_t m_pBaseClassComponentHelper = 0x60;
+}
+
+namespace CEntityComponent {
+}
+
+namespace EntInput_t {
+}
+
+namespace CEntityComponentHelper {
+    constexpr std::ptrdiff_t m_flags = 0x8;
+    constexpr std::ptrdiff_t m_pInfo = 0x10;
+    constexpr std::ptrdiff_t m_nPriority = 0x18;
+    constexpr std::ptrdiff_t m_pNext = 0x20;
+}
+
+namespace CEntityIdentity {
+    constexpr std::ptrdiff_t m_nameStringableIndex = 0x14;
+    constexpr std::ptrdiff_t m_name = 0x18;
+    constexpr std::ptrdiff_t m_designerName = 0x20;
+    constexpr std::ptrdiff_t m_flags = 0x30;
+    constexpr std::ptrdiff_t m_worldGroupId = 0x38;
+    constexpr std::ptrdiff_t m_fDataObjectTypes = 0x3c;
+    constexpr std::ptrdiff_t m_PathIndex = 0x40;
+    constexpr std::ptrdiff_t m_pPrev = 0x58;
+    constexpr std::ptrdiff_t m_pNext = 0x60;
+    constexpr std::ptrdiff_t m_pPrevByClass = 0x68;
+    constexpr std::ptrdiff_t m_pNextByClass = 0x70;
+}
+
+namespace CEmptyEntityInstance {
+}
+
+namespace CEntityInstance {
+    constexpr std::ptrdiff_t m_iszPrivateVScripts = 0x8;
+    constexpr std::ptrdiff_t m_pEntity = 0x10;
+    constexpr std::ptrdiff_t m_CScriptComponent = 0x28;
+}
+
+namespace CEntityIOOutput {
+    constexpr std::ptrdiff_t m_Value = 0x18;
+}
+
+namespace CScriptComponent {
+    constexpr std::ptrdiff_t m_scriptClassName = 0x30;
+}
+

generated/engine2.dll.json

@@ -0,0 +1,147 @@
+{
+    "CEntityComponentHelper": {
+        "m_flags": 8,
+        "m_nPriority": 24,
+        "m_pInfo": 16,
+        "m_pNext": 32
+    },
+    "CEntityIOOutput": {
+        "m_Value": 24
+    },
+    "CEntityIdentity": {
+        "m_PathIndex": 64,
+        "m_designerName": 32,
+        "m_fDataObjectTypes": 60,
+        "m_flags": 48,
+        "m_name": 24,
+        "m_nameStringableIndex": 20,
+        "m_pNext": 96,
+        "m_pNextByClass": 112,
+        "m_pPrev": 88,
+        "m_pPrevByClass": 104,
+        "m_worldGroupId": 56
+    },
+    "CEntityInstance": {
+        "m_CScriptComponent": 40,
+        "m_iszPrivateVScripts": 8,
+        "m_pEntity": 16
+    },
+    "CNetworkVarChainer": {
+        "m_PathIndex": 32
+    },
+    "CScriptComponent": {
+        "m_scriptClassName": 48
+    },
+    "EngineLoopState_t": {
+        "m_nPlatWindowHeight": 28,
+        "m_nPlatWindowWidth": 24,
+        "m_nRenderHeight": 36,
+        "m_nRenderWidth": 32
+    },
+    "EntComponentInfo_t": {
+        "m_nFlags": 36,
+        "m_nRuntimeIndex": 32,
+        "m_pBaseClassComponentHelper": 96,
+        "m_pCPPClassname": 8,
+        "m_pName": 0,
+        "m_pNetworkDataReferencedDescription": 16,
+        "m_pNetworkDataReferencedPtrPropDescription": 24
+    },
+    "EventAdvanceTick_t": {
+        "m_nCurrentTick": 48,
+        "m_nCurrentTickThisFrame": 52,
+        "m_nTotalTicks": 60,
+        "m_nTotalTicksThisFrame": 56
+    },
+    "EventAppShutdown_t": {
+        "m_nDummy0": 0
+    },
+    "EventClientFrameSimulate_t": {
+        "m_LoopState": 0,
+        "m_flFrameTime": 44,
+        "m_flRealTime": 40
+    },
+    "EventClientOutput_t": {
+        "m_LoopState": 0,
+        "m_bRenderOnly": 52,
+        "m_flRealTime": 44,
+        "m_flRenderFrameTimeUnbounded": 48,
+        "m_flRenderTime": 40
+    },
+    "EventClientPollInput_t": {
+        "m_LoopState": 0,
+        "m_flRealTime": 40
+    },
+    "EventClientPollNetworking_t": {
+        "m_nTickCount": 0
+    },
+    "EventClientPostOutput_t": {
+        "m_LoopState": 0,
+        "m_bRenderOnly": 56,
+        "m_flRenderFrameTime": 48,
+        "m_flRenderFrameTimeUnbounded": 52,
+        "m_flRenderTime": 40
+    },
+    "EventClientPreOutput_t": {
+        "m_LoopState": 0,
+        "m_bRenderOnly": 68,
+        "m_flRealTime": 64,
+        "m_flRenderFrameTime": 48,
+        "m_flRenderFrameTimeUnbounded": 56,
+        "m_flRenderTime": 40
+    },
+    "EventClientProcessGameInput_t": {
+        "m_LoopState": 0,
+        "m_flFrameTime": 44,
+        "m_flRealTime": 40
+    },
+    "EventClientProcessInput_t": {
+        "m_LoopState": 0,
+        "m_flRealTime": 40
+    },
+    "EventClientSceneSystemThreadStateChange_t": {
+        "m_bThreadsActive": 0
+    },
+    "EventClientSendInput_t": {
+        "m_bFinalClientCommandTick": 0,
+        "m_nAdditionalClientCommandsToCreate": 4
+    },
+    "EventFrameBoundary_t": {
+        "m_flFrameTime": 0
+    },
+    "EventPostAdvanceTick_t": {
+        "m_nCurrentTick": 48,
+        "m_nCurrentTickThisFrame": 52,
+        "m_nTotalTicks": 60,
+        "m_nTotalTicksThisFrame": 56
+    },
+    "EventPostDataUpdate_t": {
+        "m_nCount": 0
+    },
+    "EventPreDataUpdate_t": {
+        "m_nCount": 0
+    },
+    "EventProfileStorageAvailable_t": {
+        "m_nSplitScreenSlot": 0
+    },
+    "EventSetTime_t": {
+        "m_LoopState": 0,
+        "m_flRealTime": 48,
+        "m_flRenderFrameTime": 64,
+        "m_flRenderFrameTimeUnbounded": 72,
+        "m_flRenderFrameTimeUnscaled": 80,
+        "m_flRenderTime": 56,
+        "m_flTickRemainder": 88,
+        "m_nClientOutputFrames": 40
+    },
+    "EventSimpleLoopFrameUpdate_t": {
+        "m_LoopState": 0,
+        "m_flFrameTime": 44,
+        "m_flRealTime": 40
+    },
+    "EventSimulate_t": {
+        "m_LoopState": 0,
+        "m_bFirstTick": 40,
+        "m_bLastTick": 41
+    }
+}

generated/host.dll.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <cstddef>
+
+namespace CAnimScriptBase {
+    constexpr std::ptrdiff_t m_bIsValid = 0x8;
+}
+
+namespace EmptyTestScript {
+    constexpr std::ptrdiff_t m_hTest = 0x10;
+}
+

generated/host.dll.json

@@ -0,0 +1,8 @@
+{
+    "CAnimScriptBase": {
+        "m_bIsValid": 8
+    },
+    "EmptyTestScript": {
+        "m_hTest": 16
+    }
+}

generated/materialsystem2.dll.hpp

@@ -0,0 +1,111 @@
+#pragma once
+
+#include <cstddef>
+
+namespace MaterialParam_t {
+    constexpr std::ptrdiff_t m_name = 0x0;
+}
+
+namespace MaterialParamInt_t {
+    constexpr std::ptrdiff_t m_nValue = 0x8;
+}
+
+namespace MaterialParamFloat_t {
+    constexpr std::ptrdiff_t m_flValue = 0x8;
+}
+
+namespace MaterialParamVector_t {
+    constexpr std::ptrdiff_t m_value = 0x8;
+}
+
+namespace MaterialParamTexture_t {
+    constexpr std::ptrdiff_t m_pValue = 0x8;
+}
+
+namespace MaterialParamString_t {
+    constexpr std::ptrdiff_t m_value = 0x8;
+}
+
+namespace MaterialParamBuffer_t {
+    constexpr std::ptrdiff_t m_value = 0x8;
+}
+
+namespace MaterialResourceData_t {
+    constexpr std::ptrdiff_t m_materialName = 0x0;
+    constexpr std::ptrdiff_t m_shaderName = 0x8;
+    constexpr std::ptrdiff_t m_intParams = 0x10;
+    constexpr std::ptrdiff_t m_floatParams = 0x28;
+    constexpr std::ptrdiff_t m_vectorParams = 0x40;
+    constexpr std::ptrdiff_t m_textureParams = 0x58;
+    constexpr std::ptrdiff_t m_dynamicParams = 0x70;
+    constexpr std::ptrdiff_t m_dynamicTextureParams = 0x88;
+    constexpr std::ptrdiff_t m_intAttributes = 0xa0;
+    constexpr std::ptrdiff_t m_floatAttributes = 0xb8;
+    constexpr std::ptrdiff_t m_vectorAttributes = 0xd0;
+    constexpr std::ptrdiff_t m_textureAttributes = 0xe8;
+    constexpr std::ptrdiff_t m_stringAttributes = 0x100;
+    constexpr std::ptrdiff_t m_renderAttributesUsed = 0x118;
+}
+
+namespace PostProcessingTonemapParameters_t {
+    constexpr std::ptrdiff_t m_flExposureBias = 0x0;
+    constexpr std::ptrdiff_t m_flShoulderStrength = 0x4;
+    constexpr std::ptrdiff_t m_flLinearStrength = 0x8;
+    constexpr std::ptrdiff_t m_flLinearAngle = 0xc;
+    constexpr std::ptrdiff_t m_flToeStrength = 0x10;
+    constexpr std::ptrdiff_t m_flToeNum = 0x14;
+    constexpr std::ptrdiff_t m_flToeDenom = 0x18;
+    constexpr std::ptrdiff_t m_flWhitePoint = 0x1c;
+    constexpr std::ptrdiff_t m_flLuminanceSource = 0x20;
+    constexpr std::ptrdiff_t m_flExposureBiasShadows = 0x24;
+    constexpr std::ptrdiff_t m_flExposureBiasHighlights = 0x28;
+    constexpr std::ptrdiff_t m_flMinShadowLum = 0x2c;
+    constexpr std::ptrdiff_t m_flMaxShadowLum = 0x30;
+    constexpr std::ptrdiff_t m_flMinHighlightLum = 0x34;
+    constexpr std::ptrdiff_t m_flMaxHighlightLum = 0x38;
+}
+
+namespace PostProcessingBloomParameters_t {
+    constexpr std::ptrdiff_t m_blendMode = 0x0;
+    constexpr std::ptrdiff_t m_flBloomStrength = 0x4;
+    constexpr std::ptrdiff_t m_flScreenBloomStrength = 0x8;
+    constexpr std::ptrdiff_t m_flBlurBloomStrength = 0xc;
+    constexpr std::ptrdiff_t m_flBloomThreshold = 0x10;
+    constexpr std::ptrdiff_t m_flBloomThresholdWidth = 0x14;
+    constexpr std::ptrdiff_t m_flSkyboxBloomStrength = 0x18;
+    constexpr std::ptrdiff_t m_flBloomStartValue = 0x1c;
+    constexpr std::ptrdiff_t m_flBlurWeight = 0x20;
+    constexpr std::ptrdiff_t m_vBlurTint = 0x34;
+}
+
+namespace PostProcessingVignetteParameters_t {
+    constexpr std::ptrdiff_t m_flVignetteStrength = 0x0;
+    constexpr std::ptrdiff_t m_vCenter = 0x4;
+    constexpr std::ptrdiff_t m_flRadius = 0xc;
+    constexpr std::ptrdiff_t m_flRoundness = 0x10;
+    constexpr std::ptrdiff_t m_flFeather = 0x14;
+    constexpr std::ptrdiff_t m_vColorTint = 0x18;
+}
+
+namespace PostProcessingLocalContrastParameters_t {
+    constexpr std::ptrdiff_t m_flLocalContrastStrength = 0x0;
+    constexpr std::ptrdiff_t m_flLocalContrastEdgeStrength = 0x4;
+    constexpr std::ptrdiff_t m_flLocalContrastVignetteStart = 0x8;
+    constexpr std::ptrdiff_t m_flLocalContrastVignetteEnd = 0xc;
+    constexpr std::ptrdiff_t m_flLocalContrastVignetteBlur = 0x10;
+}
+
+namespace PostProcessingResource_t {
+    constexpr std::ptrdiff_t m_bHasTonemapParams = 0x0;
+    constexpr std::ptrdiff_t m_toneMapParams = 0x4;
+    constexpr std::ptrdiff_t m_bHasBloomParams = 0x40;
+    constexpr std::ptrdiff_t m_bloomParams = 0x44;
+    constexpr std::ptrdiff_t m_bHasVignetteParams = 0xb4;
+    constexpr std::ptrdiff_t m_vignetteParams = 0xb8;
+    constexpr std::ptrdiff_t m_bHasLocalContrastParams = 0xdc;
+    constexpr std::ptrdiff_t m_localConstrastParams = 0xe0;
+    constexpr std::ptrdiff_t m_nColorCorrectionVolumeDim = 0xf4;
+    constexpr std::ptrdiff_t m_colorCorrectionVolumeData = 0xf8;
+    constexpr std::ptrdiff_t m_bHasColorCorrection = 0x110;
+}
+

generated/materialsystem2.dll.json

@@ -0,0 +1,96 @@
+{
+    "MaterialParamBuffer_t": {
+        "m_value": 8
+    },
+    "MaterialParamFloat_t": {
+        "m_flValue": 8
+    },
+    "MaterialParamInt_t": {
+        "m_nValue": 8
+    },
+    "MaterialParamString_t": {
+        "m_value": 8
+    },
+    "MaterialParamTexture_t": {
+        "m_pValue": 8
+    },
+    "MaterialParamVector_t": {
+        "m_value": 8
+    },
+    "MaterialParam_t": {
+        "m_name": 0
+    },
+    "MaterialResourceData_t": {
+        "m_dynamicParams": 112,
+        "m_dynamicTextureParams": 136,
+        "m_floatAttributes": 184,
+        "m_floatParams": 40,
+        "m_intAttributes": 160,
+        "m_intParams": 16,
+        "m_materialName": 0,
+        "m_renderAttributesUsed": 280,
+        "m_shaderName": 8,
+        "m_stringAttributes": 256,
+        "m_textureAttributes": 232,
+        "m_textureParams": 88,
+        "m_vectorAttributes": 208,
+        "m_vectorParams": 64
+    },
+    "PostProcessingBloomParameters_t": {
+        "m_blendMode": 0,
+        "m_flBloomStartValue": 28,
+        "m_flBloomStrength": 4,
+        "m_flBloomThreshold": 16,
+        "m_flBloomThresholdWidth": 20,
+        "m_flBlurBloomStrength": 12,
+        "m_flBlurWeight": 32,
+        "m_flScreenBloomStrength": 8,
+        "m_flSkyboxBloomStrength": 24,
+        "m_vBlurTint": 52
+    },
+    "PostProcessingLocalContrastParameters_t": {
+        "m_flLocalContrastEdgeStrength": 4,
+        "m_flLocalContrastStrength": 0,
+        "m_flLocalContrastVignetteBlur": 16,
+        "m_flLocalContrastVignetteEnd": 12,
+        "m_flLocalContrastVignetteStart": 8
+    },
+    "PostProcessingResource_t": {
+        "m_bHasBloomParams": 64,
+        "m_bHasColorCorrection": 272,
+        "m_bHasLocalContrastParams": 220,
+        "m_bHasTonemapParams": 0,
+        "m_bHasVignetteParams": 180,
+        "m_bloomParams": 68,
+        "m_colorCorrectionVolumeData": 248,
+        "m_localConstrastParams": 224,
+        "m_nColorCorrectionVolumeDim": 244,
+        "m_toneMapParams": 4,
+        "m_vignetteParams": 184
+    },
+    "PostProcessingTonemapParameters_t": {
+        "m_flExposureBias": 0,
+        "m_flExposureBiasHighlights": 40,
+        "m_flExposureBiasShadows": 36,
+        "m_flLinearAngle": 12,
+        "m_flLinearStrength": 8,
+        "m_flLuminanceSource": 32,
+        "m_flMaxHighlightLum": 56,
+        "m_flMaxShadowLum": 48,
+        "m_flMinHighlightLum": 52,
+        "m_flMinShadowLum": 44,
+        "m_flShoulderStrength": 4,
+        "m_flToeDenom": 24,
+        "m_flToeNum": 20,
+        "m_flToeStrength": 16,
+        "m_flWhitePoint": 28
+    },
+    "PostProcessingVignetteParameters_t": {
+        "m_flFeather": 20,
+        "m_flRadius": 12,
+        "m_flRoundness": 16,
+        "m_flVignetteStrength": 0,
+        "m_vCenter": 4,
+        "m_vColorTint": 24
+    }
+}

generated/meshsystem.dll.hpp

@@ -0,0 +1,4 @@
+#pragma once
+
+#include <cstddef>
+

generated/meshsystem.dll.json

@@ -0,0 +1 @@
+null

generated/networksystem.dll.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <cstddef>
+
+namespace ChangeAccessorFieldPathIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+

generated/networksystem.dll.json

@@ -0,0 +1,5 @@
+{
+    "ChangeAccessorFieldPathIndex_t": {
+        "m_Value": 0
+    }
+}

generated/panorama.dll.hpp

@@ -0,0 +1,4 @@
+#pragma once
+
+#include <cstddef>
+

generated/panorama.dll.json

@@ -0,0 +1 @@
+null

generated/pulse_system.dll.hpp

@@ -0,0 +1,348 @@
+#pragma once
+
+#include <cstddef>
+
+namespace CPulseTestFuncs_LibraryA {
+}
+
+namespace CPulseExecCursor {
+}
+
+namespace CPulse_RegisterInfo {
+    constexpr std::ptrdiff_t m_nReg = 0x0;
+    constexpr std::ptrdiff_t m_Type = 0x8;
+    constexpr std::ptrdiff_t m_OriginName = 0x18;
+    constexpr std::ptrdiff_t m_nWrittenByInstruction = 0x50;
+    constexpr std::ptrdiff_t m_nLastReadByInstruction = 0x54;
+}
+
+namespace CPulse_Chunk {
+    constexpr std::ptrdiff_t m_Instructions = 0x0;
+    constexpr std::ptrdiff_t m_Registers = 0x10;
+    constexpr std::ptrdiff_t m_InstructionEditorIDs = 0x20;
+}
+
+namespace CPulse_Variable {
+    constexpr std::ptrdiff_t m_Name = 0x0;
+    constexpr std::ptrdiff_t m_Description = 0x8;
+    constexpr std::ptrdiff_t m_Type = 0x10;
+    constexpr std::ptrdiff_t m_DefaultValue = 0x20;
+    constexpr std::ptrdiff_t m_bIsPublic = 0x32;
+}
+
+namespace CPulse_PublicOutput {
+    constexpr std::ptrdiff_t m_Name = 0x0;
+    constexpr std::ptrdiff_t m_Description = 0x8;
+    constexpr std::ptrdiff_t m_ParamType = 0x10;
+}
+
+namespace CPulse_OutputConnection {
+    constexpr std::ptrdiff_t m_SourceOutput = 0x0;
+    constexpr std::ptrdiff_t m_TargetEntity = 0x8;
+    constexpr std::ptrdiff_t m_TargetInput = 0x10;
+    constexpr std::ptrdiff_t m_Param = 0x18;
+}
+
+namespace CPulse_InvokeBinding {
+    constexpr std::ptrdiff_t m_RegisterMap = 0x0;
+    constexpr std::ptrdiff_t m_FuncName = 0x20;
+    constexpr std::ptrdiff_t m_nCellIndex = 0x28;
+    constexpr std::ptrdiff_t m_InstanceType = 0x30;
+    constexpr std::ptrdiff_t m_nSrcChunk = 0x40;
+    constexpr std::ptrdiff_t m_nSrcInstruction = 0x44;
+}
+
+namespace CPulse_CallInfo {
+    constexpr std::ptrdiff_t m_PortName = 0x0;
+    constexpr std::ptrdiff_t m_nEditorNodeID = 0x8;
+    constexpr std::ptrdiff_t m_RegisterMap = 0x10;
+    constexpr std::ptrdiff_t m_CallMethodID = 0x30;
+    constexpr std::ptrdiff_t m_nSrcChunk = 0x34;
+    constexpr std::ptrdiff_t m_nSrcInstruction = 0x38;
+}
+
+namespace CPulseGraphDef {
+    constexpr std::ptrdiff_t m_DomainIdentifier = 0x8;
+    constexpr std::ptrdiff_t m_ParentMapName = 0x10;
+    constexpr std::ptrdiff_t m_Chunks = 0x18;
+    constexpr std::ptrdiff_t m_Cells = 0x30;
+    constexpr std::ptrdiff_t m_Vars = 0x48;
+    constexpr std::ptrdiff_t m_PublicOutputs = 0x60;
+    constexpr std::ptrdiff_t m_InvokeBindings = 0x78;
+    constexpr std::ptrdiff_t m_CallInfos = 0x90;
+    constexpr std::ptrdiff_t m_OutputConnections = 0xa8;
+}
+
+namespace CBasePulseGraphInstance {
+}
+
+namespace CPulseMathlib {
+}
+
+namespace CPulseTestScriptLib {
+}
+
+namespace PulseRuntimeChunkIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseRuntimeCallInfoIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseRuntimeVarIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseRuntimeOutputIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseRuntimeStateOffset_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseRuntimeRegisterIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseRuntimeCellIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseRuntimeInvokeIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseDocNodeID_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseRuntimeEntrypointIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace PulseRegisterMap_t {
+    constexpr std::ptrdiff_t m_Inparams = 0x0;
+    constexpr std::ptrdiff_t m_Outparams = 0x10;
+}
+
+namespace PGDInstruction_t {
+    constexpr std::ptrdiff_t m_nCode = 0x0;
+    constexpr std::ptrdiff_t m_nVar = 0x4;
+    constexpr std::ptrdiff_t m_nReg0 = 0x8;
+    constexpr std::ptrdiff_t m_nReg1 = 0xa;
+    constexpr std::ptrdiff_t m_nReg2 = 0xc;
+    constexpr std::ptrdiff_t m_nInvokeBindingIndex = 0x10;
+    constexpr std::ptrdiff_t m_nChunk = 0x14;
+    constexpr std::ptrdiff_t m_nDestInstruction = 0x18;
+    constexpr std::ptrdiff_t m_nCallInfoIndex = 0x1c;
+    constexpr std::ptrdiff_t m_Arg0Name = 0x20;
+    constexpr std::ptrdiff_t m_Arg1Name = 0x28;
+    constexpr std::ptrdiff_t m_bLiteralBool = 0x30;
+    constexpr std::ptrdiff_t m_nLiteralInt = 0x34;
+    constexpr std::ptrdiff_t m_flLiteralFloat = 0x38;
+    constexpr std::ptrdiff_t m_LiteralString = 0x40;
+    constexpr std::ptrdiff_t m_vLiteralVec3 = 0x50;
+}
+
+namespace CPulse_OutflowConnection {
+    constexpr std::ptrdiff_t m_SourceOutflowName = 0x0;
+    constexpr std::ptrdiff_t m_nDestChunk = 0x8;
+    constexpr std::ptrdiff_t m_nInstruction = 0xc;
+}
+
+namespace CPulse_ResumePoint {
+}
+
+namespace CPulseCell_Base {
+    constexpr std::ptrdiff_t m_nEditorNodeID = 0x8;
+}
+
+namespace CPulseCell_BaseFlow {
+}
+
+namespace CPulseCell_Inflow_BaseEntrypoint {
+    constexpr std::ptrdiff_t m_EntryChunk = 0x48;
+    constexpr std::ptrdiff_t m_RegisterMap = 0x50;
+}
+
+namespace CPulseRuntimeMethodArg {
+    constexpr std::ptrdiff_t m_Name = 0x0;
+    constexpr std::ptrdiff_t m_Description = 0x38;
+    constexpr std::ptrdiff_t m_Type = 0x40;
+}
+
+namespace CPulseCell_Inflow_Method {
+    constexpr std::ptrdiff_t m_MethodName = 0x70;
+    constexpr std::ptrdiff_t m_Description = 0x78;
+    constexpr std::ptrdiff_t m_bIsPublic = 0x80;
+    constexpr std::ptrdiff_t m_ReturnType = 0x88;
+    constexpr std::ptrdiff_t m_Args = 0x98;
+}
+
+namespace CPulseCell_Inflow_EventHandler {
+    constexpr std::ptrdiff_t m_EventName = 0x70;
+}
+
+namespace CPulseCell_Inflow_GraphHook {
+    constexpr std::ptrdiff_t m_HookName = 0x70;
+}
+
+namespace CPulseCell_Inflow_EntOutputHandler {
+    constexpr std::ptrdiff_t m_SourceEntity = 0x70;
+    constexpr std::ptrdiff_t m_SourceOutput = 0x78;
+    constexpr std::ptrdiff_t m_TargetInput = 0x80;
+    constexpr std::ptrdiff_t m_ExpectedParamType = 0x88;
+}
+
+namespace CPulseCell_BaseYieldingInflow {
+}
+
+namespace CPulseCell_BaseValue {
+}
+
+namespace CPulseCell_Step_PublicOutput {
+    constexpr std::ptrdiff_t m_OutputIndex = 0x48;
+}
+
+namespace CPulseCell_Inflow_Yield {
+    constexpr std::ptrdiff_t m_UnyieldResume = 0x48;
+}
+
+namespace CPulseCell_Inflow_Wait {
+    constexpr std::ptrdiff_t m_WakeResume = 0x48;
+}
+
+namespace CPulseCell_Outflow_StringSwitch {
+    constexpr std::ptrdiff_t m_DefaultCaseOutflow = 0x48;
+    constexpr std::ptrdiff_t m_CaseOutflows = 0x58;
+}
+
+namespace CPulseCell_Outflow_IntSwitch {
+    constexpr std::ptrdiff_t m_DefaultCaseOutflow = 0x48;
+    constexpr std::ptrdiff_t m_CaseOutflows = 0x58;
+}
+
+namespace CPulseCell_Outflow_CycleOrdered {
+    constexpr std::ptrdiff_t m_Outputs = 0x48;
+}
+
+namespace CPulseCell_Outflow_CycleOrdered::InstanceState_t {
+    constexpr std::ptrdiff_t m_nNextIndex = 0x0;
+}
+
+namespace CPulseCell_Outflow_CycleRandom {
+    constexpr std::ptrdiff_t m_Outputs = 0x48;
+}
+
+namespace CPulseCell_Outflow_CycleShuffled {
+    constexpr std::ptrdiff_t m_Outputs = 0x48;
+}
+
+namespace CPulseCell_Outflow_CycleShuffled::InstanceState_t {
+    constexpr std::ptrdiff_t m_Shuffle = 0x0;
+    constexpr std::ptrdiff_t m_nNextShuffle = 0x20;
+}
+
+namespace CPulseCell_Outflow_SimultaneousParallel {
+    constexpr std::ptrdiff_t m_Outputs = 0x48;
+}
+
+namespace CPulseCell_Outflow_TestRandomYesNo {
+    constexpr std::ptrdiff_t m_Yes = 0x48;
+    constexpr std::ptrdiff_t m_No = 0x58;
+}
+
+namespace CPulseCell_Outflow_TestExplicitYesNo {
+    constexpr std::ptrdiff_t m_Yes = 0x48;
+    constexpr std::ptrdiff_t m_No = 0x58;
+}
+
+namespace CPulseCell_Value_TestValue50 {
+}
+
+namespace CPulseCell_Value_RandomInt {
+}
+
+namespace CPulseCell_Step_DebugLog {
+}
+
+namespace CPulseCell_Step_CallExternalMethod {
+    constexpr std::ptrdiff_t m_MethodName = 0x48;
+    constexpr std::ptrdiff_t m_ExpectedArgs = 0x50;
+}
+
+namespace PulseTestEHandle_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace FakeEntity_t {
+    constexpr std::ptrdiff_t m_nHandle = 0x0;
+    constexpr std::ptrdiff_t m_Name = 0x8;
+    constexpr std::ptrdiff_t m_Class = 0x10;
+    constexpr std::ptrdiff_t m_bDestroyed = 0x18;
+    constexpr std::ptrdiff_t m_pAssociatedGraphInstance = 0x20;
+    constexpr std::ptrdiff_t m_bFuncWasCalled = 0x28;
+    constexpr std::ptrdiff_t m_fValue = 0x2c;
+}
+
+namespace CPulseGraphInstance_TestDomain {
+    constexpr std::ptrdiff_t m_bIsRunningUnitTests = 0xd0;
+    constexpr std::ptrdiff_t m_bExplicitTimeStepping = 0xd1;
+    constexpr std::ptrdiff_t m_bExpectingToDestroyWithYieldedCursors = 0xd2;
+    constexpr std::ptrdiff_t m_nNextValidateIndex = 0xd4;
+    constexpr std::ptrdiff_t m_Tracepoints = 0xd8;
+    constexpr std::ptrdiff_t m_bTestYesOrNoPath = 0xf0;
+}
+
+namespace CPulseCell_Step_TestDomainTracepoint {
+}
+
+namespace CPulseCell_Step_TestDomainCreateFakeEntity {
+}
+
+namespace CPulseCell_Step_TestDomainDestroyFakeEntity {
+}
+
+namespace CPulseCell_Step_TestDomainEntFire {
+    constexpr std::ptrdiff_t m_Input = 0x48;
+}
+
+namespace CPulseCell_Val_TestDomainGetEntityName {
+}
+
+namespace CPulseCell_Val_TestDomainFindEntityByName {
+}
+
+namespace CTestDomainDerived_Cursor {
+    constexpr std::ptrdiff_t m_nCursorValueA = 0x188;
+    constexpr std::ptrdiff_t m_nCursorValueB = 0x18c;
+}
+
+namespace CPulseGraphInstance_TestDomain_Derived {
+    constexpr std::ptrdiff_t m_nInstanceValueX = 0xf8;
+}
+
+namespace CPulseTestFuncs_DerivedDomain {
+}
+
+namespace CPulseCell_Test_NoInflow {
+}
+
+namespace CPulseCell_Test_MultiInflow_WithDefault {
+}
+
+namespace CPulseCell_Test_MultiInflow_NoDefault {
+}
+
+namespace CPulseTurtleGraphicsCursor {
+    constexpr std::ptrdiff_t m_Color = 0x188;
+    constexpr std::ptrdiff_t m_vPos = 0x18c;
+    constexpr std::ptrdiff_t m_flHeadingDeg = 0x194;
+    constexpr std::ptrdiff_t m_bPenUp = 0x198;
+}
+
+namespace CPulseGraphInstance_TurtleGraphics {
+}
+

generated/pulse_system.dll.json

@@ -0,0 +1,231 @@
+{
+    "CPulseCell_Base": {
+        "m_nEditorNodeID": 8
+    },
+    "CPulseCell_Inflow_BaseEntrypoint": {
+        "m_EntryChunk": 72,
+        "m_RegisterMap": 80
+    },
+    "CPulseCell_Inflow_EntOutputHandler": {
+        "m_ExpectedParamType": 136,
+        "m_SourceEntity": 112,
+        "m_SourceOutput": 120,
+        "m_TargetInput": 128
+    },
+    "CPulseCell_Inflow_EventHandler": {
+        "m_EventName": 112
+    },
+    "CPulseCell_Inflow_GraphHook": {
+        "m_HookName": 112
+    },
+    "CPulseCell_Inflow_Method": {
+        "m_Args": 152,
+        "m_Description": 120,
+        "m_MethodName": 112,
+        "m_ReturnType": 136,
+        "m_bIsPublic": 128
+    },
+    "CPulseCell_Inflow_Wait": {
+        "m_WakeResume": 72
+    },
+    "CPulseCell_Inflow_Yield": {
+        "m_UnyieldResume": 72
+    },
+    "CPulseCell_Outflow_CycleOrdered": {
+        "m_Outputs": 72
+    },
+    "CPulseCell_Outflow_CycleOrdered::InstanceState_t": {
+        "m_nNextIndex": 0
+    },
+    "CPulseCell_Outflow_CycleRandom": {
+        "m_Outputs": 72
+    },
+    "CPulseCell_Outflow_CycleShuffled": {
+        "m_Outputs": 72
+    },
+    "CPulseCell_Outflow_CycleShuffled::InstanceState_t": {
+        "m_Shuffle": 0,
+        "m_nNextShuffle": 32
+    },
+    "CPulseCell_Outflow_IntSwitch": {
+        "m_CaseOutflows": 88,
+        "m_DefaultCaseOutflow": 72
+    },
+    "CPulseCell_Outflow_SimultaneousParallel": {
+        "m_Outputs": 72
+    },
+    "CPulseCell_Outflow_StringSwitch": {
+        "m_CaseOutflows": 88,
+        "m_DefaultCaseOutflow": 72
+    },
+    "CPulseCell_Outflow_TestExplicitYesNo": {
+        "m_No": 88,
+        "m_Yes": 72
+    },
+    "CPulseCell_Outflow_TestRandomYesNo": {
+        "m_No": 88,
+        "m_Yes": 72
+    },
+    "CPulseCell_Step_CallExternalMethod": {
+        "m_ExpectedArgs": 80,
+        "m_MethodName": 72
+    },
+    "CPulseCell_Step_PublicOutput": {
+        "m_OutputIndex": 72
+    },
+    "CPulseCell_Step_TestDomainEntFire": {
+        "m_Input": 72
+    },
+    "CPulseGraphDef": {
+        "m_CallInfos": 144,
+        "m_Cells": 48,
+        "m_Chunks": 24,
+        "m_DomainIdentifier": 8,
+        "m_InvokeBindings": 120,
+        "m_OutputConnections": 168,
+        "m_ParentMapName": 16,
+        "m_PublicOutputs": 96,
+        "m_Vars": 72
+    },
+    "CPulseGraphInstance_TestDomain": {
+        "m_Tracepoints": 216,
+        "m_bExpectingToDestroyWithYieldedCursors": 210,
+        "m_bExplicitTimeStepping": 209,
+        "m_bIsRunningUnitTests": 208,
+        "m_bTestYesOrNoPath": 240,
+        "m_nNextValidateIndex": 212
+    },
+    "CPulseGraphInstance_TestDomain_Derived": {
+        "m_nInstanceValueX": 248
+    },
+    "CPulseRuntimeMethodArg": {
+        "m_Description": 56,
+        "m_Name": 0,
+        "m_Type": 64
+    },
+    "CPulseTurtleGraphicsCursor": {
+        "m_Color": 392,
+        "m_bPenUp": 408,
+        "m_flHeadingDeg": 404,
+        "m_vPos": 396
+    },
+    "CPulse_CallInfo": {
+        "m_CallMethodID": 48,
+        "m_PortName": 0,
+        "m_RegisterMap": 16,
+        "m_nEditorNodeID": 8,
+        "m_nSrcChunk": 52,
+        "m_nSrcInstruction": 56
+    },
+    "CPulse_Chunk": {
+        "m_InstructionEditorIDs": 32,
+        "m_Instructions": 0,
+        "m_Registers": 16
+    },
+    "CPulse_InvokeBinding": {
+        "m_FuncName": 32,
+        "m_InstanceType": 48,
+        "m_RegisterMap": 0,
+        "m_nCellIndex": 40,
+        "m_nSrcChunk": 64,
+        "m_nSrcInstruction": 68
+    },
+    "CPulse_OutflowConnection": {
+        "m_SourceOutflowName": 0,
+        "m_nDestChunk": 8,
+        "m_nInstruction": 12
+    },
+    "CPulse_OutputConnection": {
+        "m_Param": 24,
+        "m_SourceOutput": 0,
+        "m_TargetEntity": 8,
+        "m_TargetInput": 16
+    },
+    "CPulse_PublicOutput": {
+        "m_Description": 8,
+        "m_Name": 0,
+        "m_ParamType": 16
+    },
+    "CPulse_RegisterInfo": {
+        "m_OriginName": 24,
+        "m_Type": 8,
+        "m_nLastReadByInstruction": 84,
+        "m_nReg": 0,
+        "m_nWrittenByInstruction": 80
+    },
+    "CPulse_Variable": {
+        "m_DefaultValue": 32,
+        "m_Description": 8,
+        "m_Name": 0,
+        "m_Type": 16,
+        "m_bIsPublic": 50
+    },
+    "CTestDomainDerived_Cursor": {
+        "m_nCursorValueA": 392,
+        "m_nCursorValueB": 396
+    },
+    "FakeEntity_t": {
+        "m_Class": 16,
+        "m_Name": 8,
+        "m_bDestroyed": 24,
+        "m_bFuncWasCalled": 40,
+        "m_fValue": 44,
+        "m_nHandle": 0,
+        "m_pAssociatedGraphInstance": 32
+    },
+    "PGDInstruction_t": {
+        "m_Arg0Name": 32,
+        "m_Arg1Name": 40,
+        "m_LiteralString": 64,
+        "m_bLiteralBool": 48,
+        "m_flLiteralFloat": 56,
+        "m_nCallInfoIndex": 28,
+        "m_nChunk": 20,
+        "m_nCode": 0,
+        "m_nDestInstruction": 24,
+        "m_nInvokeBindingIndex": 16,
+        "m_nLiteralInt": 52,
+        "m_nReg0": 8,
+        "m_nReg1": 10,
+        "m_nReg2": 12,
+        "m_nVar": 4,
+        "m_vLiteralVec3": 80
+    },
+    "PulseDocNodeID_t": {
+        "m_Value": 0
+    },
+    "PulseRegisterMap_t": {
+        "m_Inparams": 0,
+        "m_Outparams": 16
+    },
+    "PulseRuntimeCallInfoIndex_t": {
+        "m_Value": 0
+    },
+    "PulseRuntimeCellIndex_t": {
+        "m_Value": 0
+    },
+    "PulseRuntimeChunkIndex_t": {
+        "m_Value": 0
+    },
+    "PulseRuntimeEntrypointIndex_t": {
+        "m_Value": 0
+    },
+    "PulseRuntimeInvokeIndex_t": {
+        "m_Value": 0
+    },
+    "PulseRuntimeOutputIndex_t": {
+        "m_Value": 0
+    },
+    "PulseRuntimeRegisterIndex_t": {
+        "m_Value": 0
+    },
+    "PulseRuntimeStateOffset_t": {
+        "m_Value": 0
+    },
+    "PulseRuntimeVarIndex_t": {
+        "m_Value": 0
+    },
+    "PulseTestEHandle_t": {
+        "m_Value": 0
+    }
+}

generated/rendersystemdx11.dll.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <cstddef>
+
+namespace RenderInputLayoutField_t {
+    constexpr std::ptrdiff_t m_pSemanticName = 0x0;
+    constexpr std::ptrdiff_t m_nSemanticIndex = 0x20;
+    constexpr std::ptrdiff_t m_Format = 0x24;
+    constexpr std::ptrdiff_t m_nOffset = 0x28;
+    constexpr std::ptrdiff_t m_nSlot = 0x2c;
+    constexpr std::ptrdiff_t m_nSlotType = 0x30;
+    constexpr std::ptrdiff_t m_nInstanceStepRate = 0x34;
+}
+
+namespace VsInputSignatureElement_t {
+    constexpr std::ptrdiff_t m_pName = 0x0;
+    constexpr std::ptrdiff_t m_pSemantic = 0x40;
+    constexpr std::ptrdiff_t m_pD3DSemanticName = 0x80;
+    constexpr std::ptrdiff_t m_nD3DSemanticIndex = 0xc0;
+}
+
+namespace VsInputSignature_t {
+    constexpr std::ptrdiff_t m_elems = 0x0;
+}
+

generated/rendersystemdx11.dll.json

@@ -0,0 +1,20 @@
+{
+    "RenderInputLayoutField_t": {
+        "m_Format": 36,
+        "m_nInstanceStepRate": 52,
+        "m_nOffset": 40,
+        "m_nSemanticIndex": 32,
+        "m_nSlot": 44,
+        "m_nSlotType": 48,
+        "m_pSemanticName": 0
+    },
+    "VsInputSignatureElement_t": {
+        "m_nD3DSemanticIndex": 192,
+        "m_pD3DSemanticName": 128,
+        "m_pName": 0,
+        "m_pSemantic": 64
+    },
+    "VsInputSignature_t": {
+        "m_elems": 0
+    }
+}

generated/resourcesystem.dll.hpp

@@ -0,0 +1,203 @@
+#pragma once
+
+#include <cstddef>
+
+namespace TestResource_t {
+    constexpr std::ptrdiff_t m_name = 0x0;
+}
+
+namespace InfoForResourceTypeTestResource_t {
+}
+
+namespace InfoForResourceTypeProceduralTestResource_t {
+}
+
+namespace InfoForResourceTypeManifestTestResource_t {
+}
+
+namespace ManifestTestResource_t {
+    constexpr std::ptrdiff_t m_name = 0x0;
+    constexpr std::ptrdiff_t m_child = 0x8;
+}
+
+namespace InfoForResourceTypeCVDataResource {
+}
+
+namespace InfoForResourceTypeIPulseGraphDef {
+}
+
+namespace InfoForResourceTypeCTypeScriptResource {
+}
+
+namespace InfoForResourceTypeCJavaScriptResource {
+}
+
+namespace InfoForResourceTypeIParticleSystemDefinition {
+}
+
+namespace InfoForResourceTypeIParticleSnapshot {
+}
+
+namespace InfoForResourceTypeCAnimData {
+}
+
+namespace InfoForResourceTypeCAnimationGroup {
+}
+
+namespace InfoForResourceTypeCSequenceGroupData {
+}
+
+namespace InfoForResourceTypeIMaterial2 {
+}
+
+namespace InfoForResourceTypeCMorphSetData {
+}
+
+namespace InfoForResourceTypeCRenderMesh {
+}
+
+namespace InfoForResourceTypeCModel {
+}
+
+namespace InfoForResourceTypeCTextureBase {
+}
+
+namespace InfoForResourceTypeIVectorGraphic {
+}
+
+namespace InfoForResourceTypeCVSoundEventScriptList {
+}
+
+namespace InfoForResourceTypeCVSoundStackScriptList {
+}
+
+namespace InfoForResourceTypeVSound_t {
+}
+
+namespace InfoForResourceTypeCVMixListResource {
+}
+
+namespace InfoForResourceTypeCPhysAggregateData {
+}
+
+namespace InfoForResourceTypeCVPhysXSurfacePropertiesList {
+}
+
+namespace InfoForResourceTypeCEntityLump {
+}
+
+namespace InfoForResourceTypeCWorldNode {
+}
+
+namespace InfoForResourceTypeWorld_t {
+}
+
+namespace InfoForResourceTypeCVoxelVisibility {
+}
+
+namespace InfoForResourceTypeCPostProcessingResource {
+}
+
+namespace InfoForResourceTypeCPanoramaStyle {
+}
+
+namespace InfoForResourceTypeCPanoramaLayout {
+}
+
+namespace InfoForResourceTypeCPanoramaDynamicImages {
+}
+
+namespace InfoForResourceTypeCDotaItemDefinitionResource {
+}
+
+namespace InfoForResourceTypeCDOTAPatchNotesList {
+}
+
+namespace InfoForResourceTypeCDOTANovelsList {
+}
+
+namespace InfoForResourceTypeIAnimGraphModelBinding {
+}
+
+namespace InfoForResourceTypeCChoreoSceneFileData {
+}
+
+namespace InfoForResourceTypeCDACGameDefsData {
+}
+
+namespace InfoForResourceTypeCCompositeMaterialKit {
+}
+
+namespace InfoForResourceTypeCSmartProp {
+}
+
+namespace InfoForResourceTypeCCSGOEconItem {
+}
+
+namespace InfoForResourceTypeCResponseRulesList {
+}
+
+namespace FuseVariableIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace FuseFunctionIndex_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace ConstantInfo_t {
+    constexpr std::ptrdiff_t m_name = 0x0;
+    constexpr std::ptrdiff_t m_nameToken = 0x8;
+    constexpr std::ptrdiff_t m_flValue = 0xc;
+}
+
+namespace VariableInfo_t {
+    constexpr std::ptrdiff_t m_name = 0x0;
+    constexpr std::ptrdiff_t m_nameToken = 0x8;
+    constexpr std::ptrdiff_t m_nIndex = 0xc;
+    constexpr std::ptrdiff_t m_nNumComponents = 0xe;
+    constexpr std::ptrdiff_t m_eVarType = 0xf;
+    constexpr std::ptrdiff_t m_eAccess = 0x10;
+}
+
+namespace FunctionInfo_t {
+    constexpr std::ptrdiff_t m_name = 0x8;
+    constexpr std::ptrdiff_t m_nameToken = 0x10;
+    constexpr std::ptrdiff_t m_nParamCount = 0x14;
+    constexpr std::ptrdiff_t m_nIndex = 0x18;
+    constexpr std::ptrdiff_t m_bIsPure = 0x1a;
+}
+
+namespace CFuseProgram {
+    constexpr std::ptrdiff_t m_programBuffer = 0x0;
+    constexpr std::ptrdiff_t m_variablesRead = 0x18;
+    constexpr std::ptrdiff_t m_variablesWritten = 0x30;
+    constexpr std::ptrdiff_t m_nMaxTempVarsUsed = 0x48;
+}
+
+namespace CFuseSymbolTable {
+    constexpr std::ptrdiff_t m_constants = 0x0;
+    constexpr std::ptrdiff_t m_variables = 0x18;
+    constexpr std::ptrdiff_t m_functions = 0x30;
+    constexpr std::ptrdiff_t m_constantMap = 0x48;
+    constexpr std::ptrdiff_t m_variableMap = 0x68;
+    constexpr std::ptrdiff_t m_functionMap = 0x88;
+}
+
+namespace AABB_t {
+    constexpr std::ptrdiff_t m_vMinBounds = 0x0;
+    constexpr std::ptrdiff_t m_vMaxBounds = 0xc;
+}
+
+namespace PackedAABB_t {
+    constexpr std::ptrdiff_t m_nPackedMin = 0x0;
+    constexpr std::ptrdiff_t m_nPackedMax = 0x4;
+}
+
+namespace FourQuaternions {
+    constexpr std::ptrdiff_t x = 0x0;
+    constexpr std::ptrdiff_t y = 0x10;
+    constexpr std::ptrdiff_t z = 0x20;
+    constexpr std::ptrdiff_t w = 0x30;
+}
+

generated/resourcesystem.dll.json

@@ -0,0 +1,63 @@
+{
+    "AABB_t": {
+        "m_vMaxBounds": 12,
+        "m_vMinBounds": 0
+    },
+    "CFuseProgram": {
+        "m_nMaxTempVarsUsed": 72,
+        "m_programBuffer": 0,
+        "m_variablesRead": 24,
+        "m_variablesWritten": 48
+    },
+    "CFuseSymbolTable": {
+        "m_constantMap": 72,
+        "m_constants": 0,
+        "m_functionMap": 136,
+        "m_functions": 48,
+        "m_variableMap": 104,
+        "m_variables": 24
+    },
+    "ConstantInfo_t": {
+        "m_flValue": 12,
+        "m_name": 0,
+        "m_nameToken": 8
+    },
+    "FourQuaternions": {
+        "w": 48,
+        "x": 0,
+        "y": 16,
+        "z": 32
+    },
+    "FunctionInfo_t": {
+        "m_bIsPure": 26,
+        "m_nIndex": 24,
+        "m_nParamCount": 20,
+        "m_name": 8,
+        "m_nameToken": 16
+    },
+    "FuseFunctionIndex_t": {
+        "m_Value": 0
+    },
+    "FuseVariableIndex_t": {
+        "m_Value": 0
+    },
+    "ManifestTestResource_t": {
+        "m_child": 8,
+        "m_name": 0
+    },
+    "PackedAABB_t": {
+        "m_nPackedMax": 4,
+        "m_nPackedMin": 0
+    },
+    "TestResource_t": {
+        "m_name": 0
+    },
+    "VariableInfo_t": {
+        "m_eAccess": 16,
+        "m_eVarType": 15,
+        "m_nIndex": 12,
+        "m_nNumComponents": 14,
+        "m_name": 0,
+        "m_nameToken": 8
+    }
+}

generated/scenefilecache.dll.hpp

@@ -0,0 +1,4 @@
+#pragma once
+
+#include <cstddef>
+

generated/scenefilecache.dll.json

@@ -0,0 +1 @@
+null

generated/scenesystem.dll.hpp

@@ -0,0 +1,57 @@
+#pragma once
+
+#include <cstddef>
+
+namespace CSSDSEndFrameViewInfo {
+    constexpr std::ptrdiff_t m_nViewId = 0x0;
+    constexpr std::ptrdiff_t m_ViewName = 0x8;
+}
+
+namespace CSSDSMsg_EndFrame {
+    constexpr std::ptrdiff_t m_Views = 0x0;
+}
+
+namespace SceneViewId_t {
+    constexpr std::ptrdiff_t m_nViewId = 0x0;
+    constexpr std::ptrdiff_t m_nFrameCount = 0x8;
+}
+
+namespace CSSDSMsg_ViewRender {
+    constexpr std::ptrdiff_t m_viewId = 0x0;
+    constexpr std::ptrdiff_t m_ViewName = 0x10;
+}
+
+namespace CSSDSMsg_LayerBase {
+    constexpr std::ptrdiff_t m_viewId = 0x0;
+    constexpr std::ptrdiff_t m_ViewName = 0x10;
+    constexpr std::ptrdiff_t m_nLayerIndex = 0x18;
+    constexpr std::ptrdiff_t m_nLayerId = 0x20;
+    constexpr std::ptrdiff_t m_LayerName = 0x28;
+    constexpr std::ptrdiff_t m_displayText = 0x30;
+}
+
+namespace CSSDSMsg_ViewTarget {
+    constexpr std::ptrdiff_t m_Name = 0x0;
+    constexpr std::ptrdiff_t m_TextureId = 0x8;
+    constexpr std::ptrdiff_t m_nWidth = 0x10;
+    constexpr std::ptrdiff_t m_nHeight = 0x14;
+    constexpr std::ptrdiff_t m_nRequestedWidth = 0x18;
+    constexpr std::ptrdiff_t m_nRequestedHeight = 0x1c;
+    constexpr std::ptrdiff_t m_nNumMipLevels = 0x20;
+    constexpr std::ptrdiff_t m_nDepth = 0x24;
+    constexpr std::ptrdiff_t m_nMultisampleNumSamples = 0x28;
+    constexpr std::ptrdiff_t m_nFormat = 0x2c;
+}
+
+namespace CSSDSMsg_ViewTargetList {
+    constexpr std::ptrdiff_t m_viewId = 0x0;
+    constexpr std::ptrdiff_t m_ViewName = 0x10;
+    constexpr std::ptrdiff_t m_Targets = 0x18;
+}
+
+namespace CSSDSMsg_PreLayer {
+}
+
+namespace CSSDSMsg_PostLayer {
+}
+

generated/scenesystem.dll.json

@@ -0,0 +1,42 @@
+{
+    "CSSDSEndFrameViewInfo": {
+        "m_ViewName": 8,
+        "m_nViewId": 0
+    },
+    "CSSDSMsg_EndFrame": {
+        "m_Views": 0
+    },
+    "CSSDSMsg_LayerBase": {
+        "m_LayerName": 40,
+        "m_ViewName": 16,
+        "m_displayText": 48,
+        "m_nLayerId": 32,
+        "m_nLayerIndex": 24,
+        "m_viewId": 0
+    },
+    "CSSDSMsg_ViewRender": {
+        "m_ViewName": 16,
+        "m_viewId": 0
+    },
+    "CSSDSMsg_ViewTarget": {
+        "m_Name": 0,
+        "m_TextureId": 8,
+        "m_nDepth": 36,
+        "m_nFormat": 44,
+        "m_nHeight": 20,
+        "m_nMultisampleNumSamples": 40,
+        "m_nNumMipLevels": 32,
+        "m_nRequestedHeight": 28,
+        "m_nRequestedWidth": 24,
+        "m_nWidth": 16
+    },
+    "CSSDSMsg_ViewTargetList": {
+        "m_Targets": 24,
+        "m_ViewName": 16,
+        "m_viewId": 0
+    },
+    "SceneViewId_t": {
+        "m_nFrameCount": 8,
+        "m_nViewId": 0
+    }
+}

generated/schemasystem.dll.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <cstddef>
+
+namespace CSchemaSystemInternalRegistration {
+    constexpr std::ptrdiff_t m_Vector2D = 0x0;
+    constexpr std::ptrdiff_t m_Vector = 0x8;
+    constexpr std::ptrdiff_t m_VectorAligned = 0x20;
+    constexpr std::ptrdiff_t m_Quaternion = 0x30;
+    constexpr std::ptrdiff_t m_QAngle = 0x40;
+    constexpr std::ptrdiff_t m_RotationVector = 0x4c;
+    constexpr std::ptrdiff_t m_RadianEuler = 0x58;
+    constexpr std::ptrdiff_t m_DegreeEuler = 0x64;
+    constexpr std::ptrdiff_t m_QuaternionStorage = 0x70;
+    constexpr std::ptrdiff_t m_matrix3x4_t = 0x80;
+    constexpr std::ptrdiff_t m_matrix3x4a_t = 0xb0;
+    constexpr std::ptrdiff_t m_Color = 0xe0;
+    constexpr std::ptrdiff_t m_Vector4D = 0xe4;
+    constexpr std::ptrdiff_t m_CTransform = 0x100;
+    constexpr std::ptrdiff_t m_pKeyValues = 0x120;
+    constexpr std::ptrdiff_t m_CUtlBinaryBlock = 0x128;
+    constexpr std::ptrdiff_t m_CUtlString = 0x140;
+    constexpr std::ptrdiff_t m_CUtlSymbol = 0x148;
+    constexpr std::ptrdiff_t m_stringToken = 0x14c;
+    constexpr std::ptrdiff_t m_stringTokenWithStorage = 0x150;
+    constexpr std::ptrdiff_t m_ResourceTypes = 0x168;
+    constexpr std::ptrdiff_t m_KV3 = 0x170;
+}
+
+namespace InfoForResourceTypeCResourceManifestInternal {
+}
+
+namespace ResourceId_t {
+    constexpr std::ptrdiff_t m_Value = 0x0;
+}
+
+namespace CExampleSchemaVData_Monomorphic {
+    constexpr std::ptrdiff_t m_nExample1 = 0x0;
+    constexpr std::ptrdiff_t m_nExample2 = 0x4;
+}
+
+namespace CExampleSchemaVData_PolymorphicBase {
+    constexpr std::ptrdiff_t m_nBase = 0x8;
+}
+
+namespace CExampleSchemaVData_PolymorphicDerivedA {
+    constexpr std::ptrdiff_t m_nDerivedA = 0x10;
+}
+
+namespace CExampleSchemaVData_PolymorphicDerivedB {
+    constexpr std::ptrdiff_t m_nDerivedB = 0x10;
+}
+

generated/schemasystem.dll.json

@@ -0,0 +1,42 @@
+{
+    "CExampleSchemaVData_Monomorphic": {
+        "m_nExample1": 0,
+        "m_nExample2": 4
+    },
+    "CExampleSchemaVData_PolymorphicBase": {
+        "m_nBase": 8
+    },
+    "CExampleSchemaVData_PolymorphicDerivedA": {
+        "m_nDerivedA": 16
+    },
+    "CExampleSchemaVData_PolymorphicDerivedB": {
+        "m_nDerivedB": 16
+    },
+    "CSchemaSystemInternalRegistration": {
+        "m_CTransform": 256,
+        "m_CUtlBinaryBlock": 296,
+        "m_CUtlString": 320,
+        "m_CUtlSymbol": 328,
+        "m_Color": 224,
+        "m_DegreeEuler": 100,
+        "m_KV3": 368,
+        "m_QAngle": 64,
+        "m_Quaternion": 48,
+        "m_QuaternionStorage": 112,
+        "m_RadianEuler": 88,
+        "m_ResourceTypes": 360,
+        "m_RotationVector": 76,
+        "m_Vector": 8,
+        "m_Vector2D": 0,
+        "m_Vector4D": 228,
+        "m_VectorAligned": 32,
+        "m_matrix3x4_t": 128,
+        "m_matrix3x4a_t": 176,
+        "m_pKeyValues": 288,
+        "m_stringToken": 332,
+        "m_stringTokenWithStorage": 336
+    },
+    "ResourceId_t": {
+        "m_Value": 0
+    }
+}

generated/soundsystem.dll.hpp

@@ -0,0 +1,309 @@
+#pragma once
+
+#include <cstddef>
+
+namespace CSosGroupActionSchema {
+    constexpr std::ptrdiff_t m_name = 0x8;
+    constexpr std::ptrdiff_t m_actionType = 0x10;
+    constexpr std::ptrdiff_t m_actionInstanceType = 0x14;
+}
+
+namespace CSosGroupActionLimitSchema {
+    constexpr std::ptrdiff_t m_nMaxCount = 0x18;
+    constexpr std::ptrdiff_t m_nStopType = 0x1c;
+    constexpr std::ptrdiff_t m_nSortType = 0x20;
+}
+
+namespace CSosGroupActionTimeLimitSchema {
+    constexpr std::ptrdiff_t m_flMaxDuration = 0x18;
+}
+
+namespace CSosGroupActionSetSoundeventParameterSchema {
+    constexpr std::ptrdiff_t m_nMaxCount = 0x18;
+    constexpr std::ptrdiff_t m_flMinValue = 0x1c;
+    constexpr std::ptrdiff_t m_flMaxValue = 0x20;
+    constexpr std::ptrdiff_t m_opvarName = 0x28;
+    constexpr std::ptrdiff_t m_nSortType = 0x30;
+}
+
+namespace CSosGroupBranchPattern {
+    constexpr std::ptrdiff_t m_bMatchEventName = 0x8;
+    constexpr std::ptrdiff_t m_bMatchEventSubString = 0x9;
+    constexpr std::ptrdiff_t m_bMatchEntIndex = 0xa;
+    constexpr std::ptrdiff_t m_bMatchOpvar = 0xb;
+}
+
+namespace CSosGroupMatchPattern {
+    constexpr std::ptrdiff_t m_matchSoundEventName = 0x10;
+    constexpr std::ptrdiff_t m_matchSoundEventSubString = 0x18;
+    constexpr std::ptrdiff_t m_flEntIndex = 0x20;
+    constexpr std::ptrdiff_t m_flOpvar = 0x24;
+}
+
+namespace CSosSoundEventGroupSchema {
+    constexpr std::ptrdiff_t m_name = 0x0;
+    constexpr std::ptrdiff_t m_nType = 0x8;
+    constexpr std::ptrdiff_t m_bIsBlocking = 0xc;
+    constexpr std::ptrdiff_t m_nBlockMaxCount = 0x10;
+    constexpr std::ptrdiff_t m_bInvertMatch = 0x14;
+    constexpr std::ptrdiff_t m_matchPattern = 0x18;
+    constexpr std::ptrdiff_t m_branchPattern = 0x40;
+    constexpr std::ptrdiff_t m_vActions = 0xb0;
+}
+
+namespace CSosSoundEventGroupListSchema {
+    constexpr std::ptrdiff_t m_groupList = 0x0;
+}
+
+namespace SosEditItemInfo_t {
+    constexpr std::ptrdiff_t itemType = 0x0;
+    constexpr std::ptrdiff_t itemName = 0x8;
+    constexpr std::ptrdiff_t itemTypeName = 0x10;
+    constexpr std::ptrdiff_t itemKVString = 0x20;
+    constexpr std::ptrdiff_t itemPos = 0x28;
+}
+
+namespace SelectedEditItemInfo_t {
+    constexpr std::ptrdiff_t m_EditItems = 0x0;
+}
+
+namespace CSoundEventMetaData {
+    constexpr std::ptrdiff_t m_soundEventVMix = 0x0;
+}
+
+namespace CDSPMixgroupModifier {
+    constexpr std::ptrdiff_t m_mixgroup = 0x0;
+    constexpr std::ptrdiff_t m_flModifier = 0x8;
+    constexpr std::ptrdiff_t m_flModifierMin = 0xc;
+    constexpr std::ptrdiff_t m_flSourceModifier = 0x10;
+    constexpr std::ptrdiff_t m_flSourceModifierMin = 0x14;
+    constexpr std::ptrdiff_t m_flListenerReverbModifierWhenSourceReverbIsActive = 0x18;
+}
+
+namespace CDspPresetModifierList {
+    constexpr std::ptrdiff_t m_dspName = 0x0;
+    constexpr std::ptrdiff_t m_modifiers = 0x8;
+}
+
+namespace CDSPPresetMixgroupModifierTable {
+    constexpr std::ptrdiff_t m_table = 0x0;
+}
+
+namespace VMixFilterDesc_t {
+    constexpr std::ptrdiff_t m_nFilterType = 0x0;
+    constexpr std::ptrdiff_t m_nFilterSlope = 0x2;
+    constexpr std::ptrdiff_t m_bEnabled = 0x3;
+    constexpr std::ptrdiff_t m_fldbGain = 0x4;
+    constexpr std::ptrdiff_t m_flCutoffFreq = 0x8;
+    constexpr std::ptrdiff_t m_flQ = 0xc;
+}
+
+namespace VMixEQ8Desc_t {
+    constexpr std::ptrdiff_t m_stages = 0x0;
+}
+
+namespace VMixDelayDesc_t {
+    constexpr std::ptrdiff_t m_feedbackFilter = 0x0;
+    constexpr std::ptrdiff_t m_bEnableFilter = 0x10;
+    constexpr std::ptrdiff_t m_flDelay = 0x14;
+    constexpr std::ptrdiff_t m_flDirectGain = 0x18;
+    constexpr std::ptrdiff_t m_flDelayGain = 0x1c;
+    constexpr std::ptrdiff_t m_flFeedbackGain = 0x20;
+    constexpr std::ptrdiff_t m_flWidth = 0x24;
+}
+
+namespace VMixPannerDesc_t {
+    constexpr std::ptrdiff_t m_type = 0x0;
+    constexpr std::ptrdiff_t m_flStrength = 0x4;
+}
+
+namespace VMixModDelayDesc_t {
+    constexpr std::ptrdiff_t m_feedbackFilter = 0x0;
+    constexpr std::ptrdiff_t m_bPhaseInvert = 0x10;
+    constexpr std::ptrdiff_t m_flGlideTime = 0x14;
+    constexpr std::ptrdiff_t m_flDelay = 0x18;
+    constexpr std::ptrdiff_t m_flOutputGain = 0x1c;
+    constexpr std::ptrdiff_t m_flFeedbackGain = 0x20;
+    constexpr std::ptrdiff_t m_flModRate = 0x24;
+    constexpr std::ptrdiff_t m_flModDepth = 0x28;
+    constexpr std::ptrdiff_t m_bApplyAntialiasing = 0x2c;
+}
+
+namespace VMixDiffusorDesc_t {
+    constexpr std::ptrdiff_t m_flSize = 0x0;
+    constexpr std::ptrdiff_t m_flComplexity = 0x4;
+    constexpr std::ptrdiff_t m_flFeedback = 0x8;
+    constexpr std::ptrdiff_t m_flOutputGain = 0xc;
+}
+
+namespace VMixBoxverbDesc_t {
+    constexpr std::ptrdiff_t m_flSizeMax = 0x0;
+    constexpr std::ptrdiff_t m_flSizeMin = 0x4;
+    constexpr std::ptrdiff_t m_flComplexity = 0x8;
+    constexpr std::ptrdiff_t m_flDiffusion = 0xc;
+    constexpr std::ptrdiff_t m_flModDepth = 0x10;
+    constexpr std::ptrdiff_t m_flModRate = 0x14;
+    constexpr std::ptrdiff_t m_bParallel = 0x18;
+    constexpr std::ptrdiff_t m_filterType = 0x1c;
+    constexpr std::ptrdiff_t m_flWidth = 0x2c;
+    constexpr std::ptrdiff_t m_flHeight = 0x30;
+    constexpr std::ptrdiff_t m_flDepth = 0x34;
+    constexpr std::ptrdiff_t m_flFeedbackScale = 0x38;
+    constexpr std::ptrdiff_t m_flFeedbackWidth = 0x3c;
+    constexpr std::ptrdiff_t m_flFeedbackHeight = 0x40;
+    constexpr std::ptrdiff_t m_flFeedbackDepth = 0x44;
+    constexpr std::ptrdiff_t m_flOutputGain = 0x48;
+    constexpr std::ptrdiff_t m_flTaps = 0x4c;
+}
+
+namespace VMixFreeverbDesc_t {
+    constexpr std::ptrdiff_t m_flRoomSize = 0x0;
+    constexpr std::ptrdiff_t m_flDamp = 0x4;
+    constexpr std::ptrdiff_t m_flWidth = 0x8;
+    constexpr std::ptrdiff_t m_flLateReflections = 0xc;
+}
+
+namespace VMixPlateverbDesc_t {
+    constexpr std::ptrdiff_t m_flPrefilter = 0x0;
+    constexpr std::ptrdiff_t m_flInputDiffusion1 = 0x4;
+    constexpr std::ptrdiff_t m_flInputDiffusion2 = 0x8;
+    constexpr std::ptrdiff_t m_flDecay = 0xc;
+    constexpr std::ptrdiff_t m_flDamp = 0x10;
+    constexpr std::ptrdiff_t m_flFeedbackDiffusion1 = 0x14;
+    constexpr std::ptrdiff_t m_flFeedbackDiffusion2 = 0x18;
+}
+
+namespace VMixDynamicsDesc_t {
+    constexpr std::ptrdiff_t m_fldbGain = 0x0;
+    constexpr std::ptrdiff_t m_fldbNoiseGateThreshold = 0x4;
+    constexpr std::ptrdiff_t m_fldbCompressionThreshold = 0x8;
+    constexpr std::ptrdiff_t m_fldbLimiterThreshold = 0xc;
+    constexpr std::ptrdiff_t m_fldbKneeWidth = 0x10;
+    constexpr std::ptrdiff_t m_flRatio = 0x14;
+    constexpr std::ptrdiff_t m_flLimiterRatio = 0x18;
+    constexpr std::ptrdiff_t m_flAttackTimeMS = 0x1c;
+    constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x20;
+    constexpr std::ptrdiff_t m_flRMSTimeMS = 0x24;
+    constexpr std::ptrdiff_t m_flWetMix = 0x28;
+    constexpr std::ptrdiff_t m_bPeakMode = 0x2c;
+}
+
+namespace VMixDynamicsCompressorDesc_t {
+    constexpr std::ptrdiff_t m_fldbOutputGain = 0x0;
+    constexpr std::ptrdiff_t m_fldbCompressionThreshold = 0x4;
+    constexpr std::ptrdiff_t m_fldbKneeWidth = 0x8;
+    constexpr std::ptrdiff_t m_flCompressionRatio = 0xc;
+    constexpr std::ptrdiff_t m_flAttackTimeMS = 0x10;
+    constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x14;
+    constexpr std::ptrdiff_t m_flRMSTimeMS = 0x18;
+    constexpr std::ptrdiff_t m_flWetMix = 0x1c;
+    constexpr std::ptrdiff_t m_bPeakMode = 0x20;
+}
+
+namespace VMixDynamicsBand_t {
+    constexpr std::ptrdiff_t m_fldbGainInput = 0x0;
+    constexpr std::ptrdiff_t m_fldbGainOutput = 0x4;
+    constexpr std::ptrdiff_t m_fldbThresholdBelow = 0x8;
+    constexpr std::ptrdiff_t m_fldbThresholdAbove = 0xc;
+    constexpr std::ptrdiff_t m_flRatioBelow = 0x10;
+    constexpr std::ptrdiff_t m_flRatioAbove = 0x14;
+    constexpr std::ptrdiff_t m_flAttackTimeMS = 0x18;
+    constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x1c;
+    constexpr std::ptrdiff_t m_bEnable = 0x20;
+    constexpr std::ptrdiff_t m_bSolo = 0x21;
+}
+
+namespace VMixDynamics3BandDesc_t {
+    constexpr std::ptrdiff_t m_fldbGainOutput = 0x0;
+    constexpr std::ptrdiff_t m_flRMSTimeMS = 0x4;
+    constexpr std::ptrdiff_t m_fldbKneeWidth = 0x8;
+    constexpr std::ptrdiff_t m_flDepth = 0xc;
+    constexpr std::ptrdiff_t m_flWetMix = 0x10;
+    constexpr std::ptrdiff_t m_flTimeScale = 0x14;
+    constexpr std::ptrdiff_t m_flLowCutoffFreq = 0x18;
+    constexpr std::ptrdiff_t m_flHighCutoffFreq = 0x1c;
+    constexpr std::ptrdiff_t m_bPeakMode = 0x20;
+    constexpr std::ptrdiff_t m_bandDesc = 0x24;
+}
+
+namespace VMixEnvelopeDesc_t {
+    constexpr std::ptrdiff_t m_flAttackTimeMS = 0x0;
+    constexpr std::ptrdiff_t m_flHoldTimeMS = 0x4;
+    constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x8;
+}
+
+namespace VMixPitchShiftDesc_t {
+    constexpr std::ptrdiff_t m_nGrainSampleCount = 0x0;
+    constexpr std::ptrdiff_t m_flPitchShift = 0x4;
+    constexpr std::ptrdiff_t m_nQuality = 0x8;
+    constexpr std::ptrdiff_t m_nProcType = 0xc;
+}
+
+namespace VMixConvolutionDesc_t {
+    constexpr std::ptrdiff_t m_fldbGain = 0x0;
+    constexpr std::ptrdiff_t m_flPreDelayMS = 0x4;
+    constexpr std::ptrdiff_t m_flWetMix = 0x8;
+    constexpr std::ptrdiff_t m_fldbLow = 0xc;
+    constexpr std::ptrdiff_t m_fldbMid = 0x10;
+    constexpr std::ptrdiff_t m_fldbHigh = 0x14;
+    constexpr std::ptrdiff_t m_flLowCutoffFreq = 0x18;
+    constexpr std::ptrdiff_t m_flHighCutoffFreq = 0x1c;
+}
+
+namespace VMixVocoderDesc_t {
+    constexpr std::ptrdiff_t m_nBandCount = 0x0;
+    constexpr std::ptrdiff_t m_flBandwidth = 0x4;
+    constexpr std::ptrdiff_t m_fldBModGain = 0x8;
+    constexpr std::ptrdiff_t m_flFreqRangeStart = 0xc;
+    constexpr std::ptrdiff_t m_flFreqRangeEnd = 0x10;
+    constexpr std::ptrdiff_t m_fldBUnvoicedGain = 0x14;
+    constexpr std::ptrdiff_t m_flAttackTimeMS = 0x18;
+    constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x1c;
+    constexpr std::ptrdiff_t m_nDebugBand = 0x20;
+    constexpr std::ptrdiff_t m_bPeakMode = 0x24;
+}
+
+namespace VMixShaperDesc_t {
+    constexpr std::ptrdiff_t m_nShape = 0x0;
+    constexpr std::ptrdiff_t m_fldbDrive = 0x4;
+    constexpr std::ptrdiff_t m_fldbOutputGain = 0x8;
+    constexpr std::ptrdiff_t m_flWetMix = 0xc;
+    constexpr std::ptrdiff_t m_nOversampleFactor = 0x10;
+}
+
+namespace VMixUtilityDesc_t {
+    constexpr std::ptrdiff_t m_nOp = 0x0;
+    constexpr std::ptrdiff_t m_flInputPan = 0x4;
+    constexpr std::ptrdiff_t m_flOutputBalance = 0x8;
+    constexpr std::ptrdiff_t m_fldbOutputGain = 0xc;
+    constexpr std::ptrdiff_t m_bBassMono = 0x10;
+    constexpr std::ptrdiff_t m_flBassFreq = 0x14;
+}
+
+namespace VMixAutoFilterDesc_t {
+    constexpr std::ptrdiff_t m_flEnvelopeAmount = 0x0;
+    constexpr std::ptrdiff_t m_flAttackTimeMS = 0x4;
+    constexpr std::ptrdiff_t m_flReleaseTimeMS = 0x8;
+    constexpr std::ptrdiff_t m_filter = 0xc;
+    constexpr std::ptrdiff_t m_flLFOAmount = 0x1c;
+    constexpr std::ptrdiff_t m_flLFORate = 0x20;
+    constexpr std::ptrdiff_t m_flPhase = 0x24;
+    constexpr std::ptrdiff_t m_nLFOShape = 0x28;
+}
+
+namespace VMixOscDesc_t {
+    constexpr std::ptrdiff_t oscType = 0x0;
+    constexpr std::ptrdiff_t m_freq = 0x4;
+    constexpr std::ptrdiff_t m_flPhase = 0x8;
+}
+
+namespace VMixEffectChainDesc_t {
+    constexpr std::ptrdiff_t m_flCrossfadeTime = 0x0;
+}
+
+namespace VMixSubgraphSwitchDesc_t {
+    constexpr std::ptrdiff_t m_interpolationMode = 0x0;
+    constexpr std::ptrdiff_t m_bOnlyTailsOnFadeOut = 0x4;
+    constexpr std::ptrdiff_t m_flInterpolationTime = 0x8;
+}
+

generated/soundsystem.dll.json

@@ -0,0 +1,270 @@
+{
+    "CDSPMixgroupModifier": {
+        "m_flListenerReverbModifierWhenSourceReverbIsActive": 24,
+        "m_flModifier": 8,
+        "m_flModifierMin": 12,
+        "m_flSourceModifier": 16,
+        "m_flSourceModifierMin": 20,
+        "m_mixgroup": 0
+    },
+    "CDSPPresetMixgroupModifierTable": {
+        "m_table": 0
+    },
+    "CDspPresetModifierList": {
+        "m_dspName": 0,
+        "m_modifiers": 8
+    },
+    "CSosGroupActionLimitSchema": {
+        "m_nMaxCount": 24,
+        "m_nSortType": 32,
+        "m_nStopType": 28
+    },
+    "CSosGroupActionSchema": {
+        "m_actionInstanceType": 20,
+        "m_actionType": 16,
+        "m_name": 8
+    },
+    "CSosGroupActionSetSoundeventParameterSchema": {
+        "m_flMaxValue": 32,
+        "m_flMinValue": 28,
+        "m_nMaxCount": 24,
+        "m_nSortType": 48,
+        "m_opvarName": 40
+    },
+    "CSosGroupActionTimeLimitSchema": {
+        "m_flMaxDuration": 24
+    },
+    "CSosGroupBranchPattern": {
+        "m_bMatchEntIndex": 10,
+        "m_bMatchEventName": 8,
+        "m_bMatchEventSubString": 9,
+        "m_bMatchOpvar": 11
+    },
+    "CSosGroupMatchPattern": {
+        "m_flEntIndex": 32,
+        "m_flOpvar": 36,
+        "m_matchSoundEventName": 16,
+        "m_matchSoundEventSubString": 24
+    },
+    "CSosSoundEventGroupListSchema": {
+        "m_groupList": 0
+    },
+    "CSosSoundEventGroupSchema": {
+        "m_bInvertMatch": 20,
+        "m_bIsBlocking": 12,
+        "m_branchPattern": 64,
+        "m_matchPattern": 24,
+        "m_nBlockMaxCount": 16,
+        "m_nType": 8,
+        "m_name": 0,
+        "m_vActions": 176
+    },
+    "CSoundEventMetaData": {
+        "m_soundEventVMix": 0
+    },
+    "SelectedEditItemInfo_t": {
+        "m_EditItems": 0
+    },
+    "SosEditItemInfo_t": {
+        "itemKVString": 32,
+        "itemName": 8,
+        "itemPos": 40,
+        "itemType": 0,
+        "itemTypeName": 16
+    },
+    "VMixAutoFilterDesc_t": {
+        "m_filter": 12,
+        "m_flAttackTimeMS": 4,
+        "m_flEnvelopeAmount": 0,
+        "m_flLFOAmount": 28,
+        "m_flLFORate": 32,
+        "m_flPhase": 36,
+        "m_flReleaseTimeMS": 8,
+        "m_nLFOShape": 40
+    },
+    "VMixBoxverbDesc_t": {
+        "m_bParallel": 24,
+        "m_filterType": 28,
+        "m_flComplexity": 8,
+        "m_flDepth": 52,
+        "m_flDiffusion": 12,
+        "m_flFeedbackDepth": 68,
+        "m_flFeedbackHeight": 64,
+        "m_flFeedbackScale": 56,
+        "m_flFeedbackWidth": 60,
+        "m_flHeight": 48,
+        "m_flModDepth": 16,
+        "m_flModRate": 20,
+        "m_flOutputGain": 72,
+        "m_flSizeMax": 0,
+        "m_flSizeMin": 4,
+        "m_flTaps": 76,
+        "m_flWidth": 44
+    },
+    "VMixConvolutionDesc_t": {
+        "m_flHighCutoffFreq": 28,
+        "m_flLowCutoffFreq": 24,
+        "m_flPreDelayMS": 4,
+        "m_flWetMix": 8,
+        "m_fldbGain": 0,
+        "m_fldbHigh": 20,
+        "m_fldbLow": 12,
+        "m_fldbMid": 16
+    },
+    "VMixDelayDesc_t": {
+        "m_bEnableFilter": 16,
+        "m_feedbackFilter": 0,
+        "m_flDelay": 20,
+        "m_flDelayGain": 28,
+        "m_flDirectGain": 24,
+        "m_flFeedbackGain": 32,
+        "m_flWidth": 36
+    },
+    "VMixDiffusorDesc_t": {
+        "m_flComplexity": 4,
+        "m_flFeedback": 8,
+        "m_flOutputGain": 12,
+        "m_flSize": 0
+    },
+    "VMixDynamics3BandDesc_t": {
+        "m_bPeakMode": 32,
+        "m_bandDesc": 36,
+        "m_flDepth": 12,
+        "m_flHighCutoffFreq": 28,
+        "m_flLowCutoffFreq": 24,
+        "m_flRMSTimeMS": 4,
+        "m_flTimeScale": 20,
+        "m_flWetMix": 16,
+        "m_fldbGainOutput": 0,
+        "m_fldbKneeWidth": 8
+    },
+    "VMixDynamicsBand_t": {
+        "m_bEnable": 32,
+        "m_bSolo": 33,
+        "m_flAttackTimeMS": 24,
+        "m_flRatioAbove": 20,
+        "m_flRatioBelow": 16,
+        "m_flReleaseTimeMS": 28,
+        "m_fldbGainInput": 0,
+        "m_fldbGainOutput": 4,
+        "m_fldbThresholdAbove": 12,
+        "m_fldbThresholdBelow": 8
+    },
+    "VMixDynamicsCompressorDesc_t": {
+        "m_bPeakMode": 32,
+        "m_flAttackTimeMS": 16,
+        "m_flCompressionRatio": 12,
+        "m_flRMSTimeMS": 24,
+        "m_flReleaseTimeMS": 20,
+        "m_flWetMix": 28,
+        "m_fldbCompressionThreshold": 4,
+        "m_fldbKneeWidth": 8,
+        "m_fldbOutputGain": 0
+    },
+    "VMixDynamicsDesc_t": {
+        "m_bPeakMode": 44,
+        "m_flAttackTimeMS": 28,
+        "m_flLimiterRatio": 24,
+        "m_flRMSTimeMS": 36,
+        "m_flRatio": 20,
+        "m_flReleaseTimeMS": 32,
+        "m_flWetMix": 40,
+        "m_fldbCompressionThreshold": 8,
+        "m_fldbGain": 0,
+        "m_fldbKneeWidth": 16,
+        "m_fldbLimiterThreshold": 12,
+        "m_fldbNoiseGateThreshold": 4
+    },
+    "VMixEQ8Desc_t": {
+        "m_stages": 0
+    },
+    "VMixEffectChainDesc_t": {
+        "m_flCrossfadeTime": 0
+    },
+    "VMixEnvelopeDesc_t": {
+        "m_flAttackTimeMS": 0,
+        "m_flHoldTimeMS": 4,
+        "m_flReleaseTimeMS": 8
+    },
+    "VMixFilterDesc_t": {
+        "m_bEnabled": 3,
+        "m_flCutoffFreq": 8,
+        "m_flQ": 12,
+        "m_fldbGain": 4,
+        "m_nFilterSlope": 2,
+        "m_nFilterType": 0
+    },
+    "VMixFreeverbDesc_t": {
+        "m_flDamp": 4,
+        "m_flLateReflections": 12,
+        "m_flRoomSize": 0,
+        "m_flWidth": 8
+    },
+    "VMixModDelayDesc_t": {
+        "m_bApplyAntialiasing": 44,
+        "m_bPhaseInvert": 16,
+        "m_feedbackFilter": 0,
+        "m_flDelay": 24,
+        "m_flFeedbackGain": 32,
+        "m_flGlideTime": 20,
+        "m_flModDepth": 40,
+        "m_flModRate": 36,
+        "m_flOutputGain": 28
+    },
+    "VMixOscDesc_t": {
+        "m_flPhase": 8,
+        "m_freq": 4,
+        "oscType": 0
+    },
+    "VMixPannerDesc_t": {
+        "m_flStrength": 4,
+        "m_type": 0
+    },
+    "VMixPitchShiftDesc_t": {
+        "m_flPitchShift": 4,
+        "m_nGrainSampleCount": 0,
+        "m_nProcType": 12,
+        "m_nQuality": 8
+    },
+    "VMixPlateverbDesc_t": {
+        "m_flDamp": 16,
+        "m_flDecay": 12,
+        "m_flFeedbackDiffusion1": 20,
+        "m_flFeedbackDiffusion2": 24,
+        "m_flInputDiffusion1": 4,
+        "m_flInputDiffusion2": 8,
+        "m_flPrefilter": 0
+    },
+    "VMixShaperDesc_t": {
+        "m_flWetMix": 12,
+        "m_fldbDrive": 4,
+        "m_fldbOutputGain": 8,
+        "m_nOversampleFactor": 16,
+        "m_nShape": 0
+    },
+    "VMixSubgraphSwitchDesc_t": {
+        "m_bOnlyTailsOnFadeOut": 4,
+        "m_flInterpolationTime": 8,
+        "m_interpolationMode": 0
+    },
+    "VMixUtilityDesc_t": {
+        "m_bBassMono": 16,
+        "m_flBassFreq": 20,
+        "m_flInputPan": 4,
+        "m_flOutputBalance": 8,
+        "m_fldbOutputGain": 12,
+        "m_nOp": 0
+    },
+    "VMixVocoderDesc_t": {
+        "m_bPeakMode": 36,
+        "m_flAttackTimeMS": 24,
+        "m_flBandwidth": 4,
+        "m_flFreqRangeEnd": 16,
+        "m_flFreqRangeStart": 12,
+        "m_flReleaseTimeMS": 28,
+        "m_fldBModGain": 8,
+        "m_fldBUnvoicedGain": 20,
+        "m_nBandCount": 0,
+        "m_nDebugBand": 32
+    }
+}

generated/vphysics2.dll.hpp

@@ -0,0 +1,743 @@
+#pragma once
+
+#include <cstddef>
+
+namespace constraint_breakableparams_t {
+    constexpr std::ptrdiff_t strength = 0x0;
+    constexpr std::ptrdiff_t forceLimit = 0x4;
+    constexpr std::ptrdiff_t torqueLimit = 0x8;
+    constexpr std::ptrdiff_t bodyMassScale = 0xc;
+    constexpr std::ptrdiff_t isActive = 0x14;
+}
+
+namespace constraint_axislimit_t {
+    constexpr std::ptrdiff_t flMinRotation = 0x0;
+    constexpr std::ptrdiff_t flMaxRotation = 0x4;
+    constexpr std::ptrdiff_t flMotorTargetAngSpeed = 0x8;
+    constexpr std::ptrdiff_t flMotorMaxTorque = 0xc;
+}
+
+namespace constraint_hingeparams_t {
+    constexpr std::ptrdiff_t worldPosition = 0x0;
+    constexpr std::ptrdiff_t worldAxisDirection = 0xc;
+    constexpr std::ptrdiff_t hingeAxis = 0x18;
+    constexpr std::ptrdiff_t constraint = 0x28;
+}
+
+namespace IPhysicsPlayerController {
+}
+
+namespace CFeJiggleBone {
+    constexpr std::ptrdiff_t m_nFlags = 0x0;
+    constexpr std::ptrdiff_t m_flLength = 0x4;
+    constexpr std::ptrdiff_t m_flTipMass = 0x8;
+    constexpr std::ptrdiff_t m_flYawStiffness = 0xc;
+    constexpr std::ptrdiff_t m_flYawDamping = 0x10;
+    constexpr std::ptrdiff_t m_flPitchStiffness = 0x14;
+    constexpr std::ptrdiff_t m_flPitchDamping = 0x18;
+    constexpr std::ptrdiff_t m_flAlongStiffness = 0x1c;
+    constexpr std::ptrdiff_t m_flAlongDamping = 0x20;
+    constexpr std::ptrdiff_t m_flAngleLimit = 0x24;
+    constexpr std::ptrdiff_t m_flMinYaw = 0x28;
+    constexpr std::ptrdiff_t m_flMaxYaw = 0x2c;
+    constexpr std::ptrdiff_t m_flYawFriction = 0x30;
+    constexpr std::ptrdiff_t m_flYawBounce = 0x34;
+    constexpr std::ptrdiff_t m_flMinPitch = 0x38;
+    constexpr std::ptrdiff_t m_flMaxPitch = 0x3c;
+    constexpr std::ptrdiff_t m_flPitchFriction = 0x40;
+    constexpr std::ptrdiff_t m_flPitchBounce = 0x44;
+    constexpr std::ptrdiff_t m_flBaseMass = 0x48;
+    constexpr std::ptrdiff_t m_flBaseStiffness = 0x4c;
+    constexpr std::ptrdiff_t m_flBaseDamping = 0x50;
+    constexpr std::ptrdiff_t m_flBaseMinLeft = 0x54;
+    constexpr std::ptrdiff_t m_flBaseMaxLeft = 0x58;
+    constexpr std::ptrdiff_t m_flBaseLeftFriction = 0x5c;
+    constexpr std::ptrdiff_t m_flBaseMinUp = 0x60;
+    constexpr std::ptrdiff_t m_flBaseMaxUp = 0x64;
+    constexpr std::ptrdiff_t m_flBaseUpFriction = 0x68;
+    constexpr std::ptrdiff_t m_flBaseMinForward = 0x6c;
+    constexpr std::ptrdiff_t m_flBaseMaxForward = 0x70;
+    constexpr std::ptrdiff_t m_flBaseForwardFriction = 0x74;
+    constexpr std::ptrdiff_t m_flRadius0 = 0x78;
+    constexpr std::ptrdiff_t m_flRadius1 = 0x7c;
+    constexpr std::ptrdiff_t m_vPoint0 = 0x80;
+    constexpr std::ptrdiff_t m_vPoint1 = 0x8c;
+    constexpr std::ptrdiff_t m_nCollisionMask = 0x98;
+}
+
+namespace CFeNamedJiggleBone {
+    constexpr std::ptrdiff_t m_strParentBone = 0x0;
+    constexpr std::ptrdiff_t m_transform = 0x10;
+    constexpr std::ptrdiff_t m_nJiggleParent = 0x30;
+    constexpr std::ptrdiff_t m_jiggleBone = 0x34;
+}
+
+namespace CFeIndexedJiggleBone {
+    constexpr std::ptrdiff_t m_nNode = 0x0;
+    constexpr std::ptrdiff_t m_nJiggleParent = 0x4;
+    constexpr std::ptrdiff_t m_jiggleBone = 0x8;
+}
+
+namespace PhysFeModelDesc_t {
+    constexpr std::ptrdiff_t m_CtrlHash = 0x0;
+    constexpr std::ptrdiff_t m_CtrlName = 0x18;
+    constexpr std::ptrdiff_t m_nStaticNodeFlags = 0x30;
+    constexpr std::ptrdiff_t m_nDynamicNodeFlags = 0x34;
+    constexpr std::ptrdiff_t m_flLocalForce = 0x38;
+    constexpr std::ptrdiff_t m_flLocalRotation = 0x3c;
+    constexpr std::ptrdiff_t m_nNodeCount = 0x40;
+    constexpr std::ptrdiff_t m_nStaticNodes = 0x42;
+    constexpr std::ptrdiff_t m_nRotLockStaticNodes = 0x44;
+    constexpr std::ptrdiff_t m_nFirstPositionDrivenNode = 0x46;
+    constexpr std::ptrdiff_t m_nSimdTriCount1 = 0x48;
+    constexpr std::ptrdiff_t m_nSimdTriCount2 = 0x4a;
+    constexpr std::ptrdiff_t m_nSimdQuadCount1 = 0x4c;
+    constexpr std::ptrdiff_t m_nSimdQuadCount2 = 0x4e;
+    constexpr std::ptrdiff_t m_nQuadCount1 = 0x50;
+    constexpr std::ptrdiff_t m_nQuadCount2 = 0x52;
+    constexpr std::ptrdiff_t m_nTreeDepth = 0x54;
+    constexpr std::ptrdiff_t m_nNodeBaseJiggleboneDependsCount = 0x56;
+    constexpr std::ptrdiff_t m_nRopeCount = 0x58;
+    constexpr std::ptrdiff_t m_Ropes = 0x60;
+    constexpr std::ptrdiff_t m_NodeBases = 0x78;
+    constexpr std::ptrdiff_t m_SimdNodeBases = 0x90;
+    constexpr std::ptrdiff_t m_Quads = 0xa8;
+    constexpr std::ptrdiff_t m_SimdQuads = 0xc0;
+    constexpr std::ptrdiff_t m_SimdTris = 0xd8;
+    constexpr std::ptrdiff_t m_SimdRods = 0xf0;
+    constexpr std::ptrdiff_t m_InitPose = 0x108;
+    constexpr std::ptrdiff_t m_Rods = 0x120;
+    constexpr std::ptrdiff_t m_Twists = 0x138;
+    constexpr std::ptrdiff_t m_AxialEdges = 0x150;
+    constexpr std::ptrdiff_t m_NodeInvMasses = 0x168;
+    constexpr std::ptrdiff_t m_CtrlOffsets = 0x180;
+    constexpr std::ptrdiff_t m_CtrlOsOffsets = 0x198;
+    constexpr std::ptrdiff_t m_FollowNodes = 0x1b0;
+    constexpr std::ptrdiff_t m_CollisionPlanes = 0x1c8;
+    constexpr std::ptrdiff_t m_NodeIntegrator = 0x1e0;
+    constexpr std::ptrdiff_t m_SpringIntegrator = 0x1f8;
+    constexpr std::ptrdiff_t m_SimdSpringIntegrator = 0x210;
+    constexpr std::ptrdiff_t m_WorldCollisionParams = 0x228;
+    constexpr std::ptrdiff_t m_LegacyStretchForce = 0x240;
+    constexpr std::ptrdiff_t m_NodeCollisionRadii = 0x258;
+    constexpr std::ptrdiff_t m_DynNodeFriction = 0x270;
+    constexpr std::ptrdiff_t m_LocalRotation = 0x288;
+    constexpr std::ptrdiff_t m_LocalForce = 0x2a0;
+    constexpr std::ptrdiff_t m_TaperedCapsuleStretches = 0x2b8;
+    constexpr std::ptrdiff_t m_TaperedCapsuleRigids = 0x2d0;
+    constexpr std::ptrdiff_t m_SphereRigids = 0x2e8;
+    constexpr std::ptrdiff_t m_WorldCollisionNodes = 0x300;
+    constexpr std::ptrdiff_t m_TreeParents = 0x318;
+    constexpr std::ptrdiff_t m_TreeCollisionMasks = 0x330;
+    constexpr std::ptrdiff_t m_TreeChildren = 0x348;
+    constexpr std::ptrdiff_t m_FreeNodes = 0x360;
+    constexpr std::ptrdiff_t m_FitMatrices = 0x378;
+    constexpr std::ptrdiff_t m_FitWeights = 0x390;
+    constexpr std::ptrdiff_t m_ReverseOffsets = 0x3a8;
+    constexpr std::ptrdiff_t m_AnimStrayRadii = 0x3c0;
+    constexpr std::ptrdiff_t m_SimdAnimStrayRadii = 0x3d8;
+    constexpr std::ptrdiff_t m_KelagerBends = 0x3f0;
+    constexpr std::ptrdiff_t m_CtrlSoftOffsets = 0x408;
+    constexpr std::ptrdiff_t m_JiggleBones = 0x420;
+    constexpr std::ptrdiff_t m_SourceElems = 0x438;
+    constexpr std::ptrdiff_t m_GoalDampedSpringIntegrators = 0x450;
+    constexpr std::ptrdiff_t m_Tris = 0x468;
+    constexpr std::ptrdiff_t m_nTriCount1 = 0x480;
+    constexpr std::ptrdiff_t m_nTriCount2 = 0x482;
+    constexpr std::ptrdiff_t m_nReservedUint8 = 0x484;
+    constexpr std::ptrdiff_t m_nExtraPressureIterations = 0x485;
+    constexpr std::ptrdiff_t m_nExtraGoalIterations = 0x486;
+    constexpr std::ptrdiff_t m_nExtraIterations = 0x487;
+    constexpr std::ptrdiff_t m_BoxRigids = 0x488;
+    constexpr std::ptrdiff_t m_DynNodeVertexSet = 0x4a0;
+    constexpr std::ptrdiff_t m_VertexSetNames = 0x4b8;
+    constexpr std::ptrdiff_t m_RigidColliderPriorities = 0x4d0;
+    constexpr std::ptrdiff_t m_MorphLayers = 0x4e8;
+    constexpr std::ptrdiff_t m_MorphSetData = 0x500;
+    constexpr std::ptrdiff_t m_VertexMaps = 0x518;
+    constexpr std::ptrdiff_t m_VertexMapValues = 0x530;
+    constexpr std::ptrdiff_t m_Effects = 0x548;
+    constexpr std::ptrdiff_t m_LockToParent = 0x560;
+    constexpr std::ptrdiff_t m_LockToGoal = 0x578;
+    constexpr std::ptrdiff_t m_DynNodeWindBases = 0x590;
+    constexpr std::ptrdiff_t m_flInternalPressure = 0x5a8;
+    constexpr std::ptrdiff_t m_flDefaultTimeDilation = 0x5ac;
+    constexpr std::ptrdiff_t m_flWindage = 0x5b0;
+    constexpr std::ptrdiff_t m_flWindDrag = 0x5b4;
+    constexpr std::ptrdiff_t m_flDefaultSurfaceStretch = 0x5b8;
+    constexpr std::ptrdiff_t m_flDefaultThreadStretch = 0x5bc;
+    constexpr std::ptrdiff_t m_flDefaultGravityScale = 0x5c0;
+    constexpr std::ptrdiff_t m_flDefaultVelAirDrag = 0x5c4;
+    constexpr std::ptrdiff_t m_flDefaultExpAirDrag = 0x5c8;
+    constexpr std::ptrdiff_t m_flDefaultVelQuadAirDrag = 0x5cc;
+    constexpr std::ptrdiff_t m_flDefaultExpQuadAirDrag = 0x5d0;
+    constexpr std::ptrdiff_t m_flRodVelocitySmoothRate = 0x5d4;
+    constexpr std::ptrdiff_t m_flQuadVelocitySmoothRate = 0x5d8;
+    constexpr std::ptrdiff_t m_flAddWorldCollisionRadius = 0x5dc;
+    constexpr std::ptrdiff_t m_flDefaultVolumetricSolveAmount = 0x5e0;
+    constexpr std::ptrdiff_t m_nRodVelocitySmoothIterations = 0x5e4;
+    constexpr std::ptrdiff_t m_nQuadVelocitySmoothIterations = 0x5e6;
+}
+
+namespace FourVectors2D {
+    constexpr std::ptrdiff_t x = 0x0;
+    constexpr std::ptrdiff_t y = 0x10;
+}
+
+namespace FeEdgeDesc_t {
+    constexpr std::ptrdiff_t nEdge = 0x0;
+    constexpr std::ptrdiff_t nSide = 0x4;
+    constexpr std::ptrdiff_t nVirtElem = 0xc;
+}
+
+namespace OldFeEdge_t {
+    constexpr std::ptrdiff_t m_flK = 0x0;
+    constexpr std::ptrdiff_t invA = 0xc;
+    constexpr std::ptrdiff_t t = 0x10;
+    constexpr std::ptrdiff_t flThetaRelaxed = 0x14;
+    constexpr std::ptrdiff_t flThetaFactor = 0x18;
+    constexpr std::ptrdiff_t c01 = 0x1c;
+    constexpr std::ptrdiff_t c02 = 0x20;
+    constexpr std::ptrdiff_t c03 = 0x24;
+    constexpr std::ptrdiff_t c04 = 0x28;
+    constexpr std::ptrdiff_t flAxialModelDist = 0x2c;
+    constexpr std::ptrdiff_t flAxialModelWeights = 0x30;
+    constexpr std::ptrdiff_t m_nNode = 0x40;
+}
+
+namespace FeWeightedNode_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t nWeight = 0x2;
+}
+
+namespace FeKelagerBend2_t {
+    constexpr std::ptrdiff_t flWeight = 0x0;
+    constexpr std::ptrdiff_t flHeight0 = 0xc;
+    constexpr std::ptrdiff_t nNode = 0x10;
+    constexpr std::ptrdiff_t nReserved = 0x16;
+}
+
+namespace FeStiffHingeBuild_t {
+    constexpr std::ptrdiff_t flMaxAngle = 0x0;
+    constexpr std::ptrdiff_t flStrength = 0x4;
+    constexpr std::ptrdiff_t flMotionBias = 0x8;
+    constexpr std::ptrdiff_t nNode = 0x14;
+}
+
+namespace FeTri_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t w1 = 0x8;
+    constexpr std::ptrdiff_t w2 = 0xc;
+    constexpr std::ptrdiff_t v1x = 0x10;
+    constexpr std::ptrdiff_t v2 = 0x14;
+}
+
+namespace FeSimdTri_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t w1 = 0x30;
+    constexpr std::ptrdiff_t w2 = 0x40;
+    constexpr std::ptrdiff_t v1x = 0x50;
+    constexpr std::ptrdiff_t v2 = 0x60;
+}
+
+namespace FeQuad_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t flSlack = 0x8;
+    constexpr std::ptrdiff_t vShape = 0xc;
+}
+
+namespace FeNodeBase_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t nDummy = 0x2;
+    constexpr std::ptrdiff_t nNodeX0 = 0x8;
+    constexpr std::ptrdiff_t nNodeX1 = 0xa;
+    constexpr std::ptrdiff_t nNodeY0 = 0xc;
+    constexpr std::ptrdiff_t nNodeY1 = 0xe;
+    constexpr std::ptrdiff_t qAdjust = 0x10;
+}
+
+namespace FeNodeWindBase_t {
+    constexpr std::ptrdiff_t nNodeX0 = 0x0;
+    constexpr std::ptrdiff_t nNodeX1 = 0x2;
+    constexpr std::ptrdiff_t nNodeY0 = 0x4;
+    constexpr std::ptrdiff_t nNodeY1 = 0x6;
+}
+
+namespace FeNodeReverseOffset_t {
+    constexpr std::ptrdiff_t vOffset = 0x0;
+    constexpr std::ptrdiff_t nBoneCtrl = 0xc;
+    constexpr std::ptrdiff_t nTargetNode = 0xe;
+}
+
+namespace FeSimdQuad_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t f4Slack = 0x20;
+    constexpr std::ptrdiff_t vShape = 0x30;
+    constexpr std::ptrdiff_t f4Weights = 0xf0;
+}
+
+namespace FeAxialEdgeBend_t {
+    constexpr std::ptrdiff_t te = 0x0;
+    constexpr std::ptrdiff_t tv = 0x4;
+    constexpr std::ptrdiff_t flDist = 0x8;
+    constexpr std::ptrdiff_t flWeight = 0xc;
+    constexpr std::ptrdiff_t nNode = 0x1c;
+}
+
+namespace FeBandBendLimit_t {
+    constexpr std::ptrdiff_t flDistMin = 0x0;
+    constexpr std::ptrdiff_t flDistMax = 0x4;
+    constexpr std::ptrdiff_t nNode = 0x8;
+}
+
+namespace FeRodConstraint_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t flMaxDist = 0x4;
+    constexpr std::ptrdiff_t flMinDist = 0x8;
+    constexpr std::ptrdiff_t flWeight0 = 0xc;
+    constexpr std::ptrdiff_t flRelaxationFactor = 0x10;
+}
+
+namespace FeTwistConstraint_t {
+    constexpr std::ptrdiff_t nNodeOrient = 0x0;
+    constexpr std::ptrdiff_t nNodeEnd = 0x2;
+    constexpr std::ptrdiff_t flTwistRelax = 0x4;
+    constexpr std::ptrdiff_t flSwingRelax = 0x8;
+}
+
+namespace FeSimdRodConstraint_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t f4MaxDist = 0x10;
+    constexpr std::ptrdiff_t f4MinDist = 0x20;
+    constexpr std::ptrdiff_t f4Weight0 = 0x30;
+    constexpr std::ptrdiff_t f4RelaxationFactor = 0x40;
+}
+
+namespace FeAnimStrayRadius_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t flMaxDist = 0x4;
+    constexpr std::ptrdiff_t flRelaxationFactor = 0x8;
+}
+
+namespace FeSimdAnimStrayRadius_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t flMaxDist = 0x10;
+    constexpr std::ptrdiff_t flRelaxationFactor = 0x20;
+}
+
+namespace FeSimdNodeBase_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t nNodeX0 = 0x8;
+    constexpr std::ptrdiff_t nNodeX1 = 0x10;
+    constexpr std::ptrdiff_t nNodeY0 = 0x18;
+    constexpr std::ptrdiff_t nNodeY1 = 0x20;
+    constexpr std::ptrdiff_t nDummy = 0x28;
+    constexpr std::ptrdiff_t qAdjust = 0x30;
+}
+
+namespace FeNodeIntegrator_t {
+    constexpr std::ptrdiff_t flPointDamping = 0x0;
+    constexpr std::ptrdiff_t flAnimationForceAttraction = 0x4;
+    constexpr std::ptrdiff_t flAnimationVertexAttraction = 0x8;
+    constexpr std::ptrdiff_t flGravity = 0xc;
+}
+
+namespace FeSpringIntegrator_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t flSpringRestLength = 0x4;
+    constexpr std::ptrdiff_t flSpringConstant = 0x8;
+    constexpr std::ptrdiff_t flSpringDamping = 0xc;
+    constexpr std::ptrdiff_t flNodeWeight0 = 0x10;
+}
+
+namespace FeSimdSpringIntegrator_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+    constexpr std::ptrdiff_t flSpringRestLength = 0x10;
+    constexpr std::ptrdiff_t flSpringConstant = 0x20;
+    constexpr std::ptrdiff_t flSpringDamping = 0x30;
+    constexpr std::ptrdiff_t flNodeWeight0 = 0x40;
+}
+
+namespace FeCtrlOffset_t {
+    constexpr std::ptrdiff_t vOffset = 0x0;
+    constexpr std::ptrdiff_t nCtrlParent = 0xc;
+    constexpr std::ptrdiff_t nCtrlChild = 0xe;
+}
+
+namespace FeSoftParent_t {
+    constexpr std::ptrdiff_t nParent = 0x0;
+    constexpr std::ptrdiff_t flAlpha = 0x4;
+}
+
+namespace FeCtrlSoftOffset_t {
+    constexpr std::ptrdiff_t nCtrlParent = 0x0;
+    constexpr std::ptrdiff_t nCtrlChild = 0x2;
+    constexpr std::ptrdiff_t vOffset = 0x4;
+    constexpr std::ptrdiff_t flAlpha = 0x10;
+}
+
+namespace FeCtrlOsOffset_t {
+    constexpr std::ptrdiff_t nCtrlParent = 0x0;
+    constexpr std::ptrdiff_t nCtrlChild = 0x2;
+}
+
+namespace FeFollowNode_t {
+    constexpr std::ptrdiff_t nParentNode = 0x0;
+    constexpr std::ptrdiff_t nChildNode = 0x2;
+    constexpr std::ptrdiff_t flWeight = 0x4;
+}
+
+namespace FeCollisionPlane_t {
+    constexpr std::ptrdiff_t nCtrlParent = 0x0;
+    constexpr std::ptrdiff_t nChildNode = 0x2;
+    constexpr std::ptrdiff_t m_Plane = 0x4;
+    constexpr std::ptrdiff_t flStickiness = 0x14;
+    constexpr std::ptrdiff_t flStrength = 0x18;
+}
+
+namespace FeWorldCollisionParams_t {
+    constexpr std::ptrdiff_t flWorldFriction = 0x0;
+    constexpr std::ptrdiff_t flGroundFriction = 0x4;
+    constexpr std::ptrdiff_t nListBegin = 0x8;
+    constexpr std::ptrdiff_t nListEnd = 0xa;
+}
+
+namespace FeTreeChildren_t {
+    constexpr std::ptrdiff_t nChild = 0x0;
+}
+
+namespace FeTaperedCapsuleRigid_t {
+    constexpr std::ptrdiff_t vSphere = 0x0;
+    constexpr std::ptrdiff_t flStickiness = 0x20;
+    constexpr std::ptrdiff_t nNode = 0x24;
+    constexpr std::ptrdiff_t nCollisionMask = 0x26;
+    constexpr std::ptrdiff_t nVertexMapIndex = 0x28;
+    constexpr std::ptrdiff_t nFlags = 0x2a;
+}
+
+namespace FeSphereRigid_t {
+    constexpr std::ptrdiff_t vSphere = 0x0;
+    constexpr std::ptrdiff_t flStickiness = 0x10;
+    constexpr std::ptrdiff_t nNode = 0x14;
+    constexpr std::ptrdiff_t nCollisionMask = 0x16;
+    constexpr std::ptrdiff_t nVertexMapIndex = 0x18;
+    constexpr std::ptrdiff_t nFlags = 0x1a;
+}
+
+namespace FeBoxRigid_t {
+    constexpr std::ptrdiff_t tmFrame2 = 0x0;
+    constexpr std::ptrdiff_t nNode = 0x20;
+    constexpr std::ptrdiff_t nCollisionMask = 0x22;
+    constexpr std::ptrdiff_t vSize = 0x24;
+    constexpr std::ptrdiff_t flStickiness = 0x30;
+    constexpr std::ptrdiff_t nVertexMapIndex = 0x34;
+    constexpr std::ptrdiff_t nFlags = 0x36;
+    constexpr std::ptrdiff_t flReserved = 0x38;
+}
+
+namespace CovMatrix3 {
+    constexpr std::ptrdiff_t m_vDiag = 0x0;
+    constexpr std::ptrdiff_t m_flXY = 0xc;
+    constexpr std::ptrdiff_t m_flXZ = 0x10;
+    constexpr std::ptrdiff_t m_flYZ = 0x14;
+}
+
+namespace FourCovMatrices3 {
+    constexpr std::ptrdiff_t m_vDiag = 0x0;
+    constexpr std::ptrdiff_t m_flXY = 0x30;
+    constexpr std::ptrdiff_t m_flXZ = 0x40;
+    constexpr std::ptrdiff_t m_flYZ = 0x50;
+}
+
+namespace FeFitWeight_t {
+    constexpr std::ptrdiff_t flWeight = 0x0;
+    constexpr std::ptrdiff_t nNode = 0x4;
+    constexpr std::ptrdiff_t nDummy = 0x6;
+}
+
+namespace FeFitInfluence_t {
+    constexpr std::ptrdiff_t nVertexNode = 0x0;
+    constexpr std::ptrdiff_t flWeight = 0x4;
+    constexpr std::ptrdiff_t nMatrixNode = 0x8;
+}
+
+namespace FeFitMatrix_t {
+    constexpr std::ptrdiff_t bone = 0x0;
+    constexpr std::ptrdiff_t vCenter = 0x20;
+    constexpr std::ptrdiff_t nEnd = 0x2c;
+    constexpr std::ptrdiff_t nNode = 0x2e;
+    constexpr std::ptrdiff_t nBeginDynamic = 0x30;
+}
+
+namespace FeRigidColliderIndices_t {
+    constexpr std::ptrdiff_t m_nTaperedCapsuleRigidIndex = 0x0;
+    constexpr std::ptrdiff_t m_nSphereRigidIndex = 0x2;
+    constexpr std::ptrdiff_t m_nBoxRigidIndex = 0x4;
+    constexpr std::ptrdiff_t m_nCollisionPlaneIndex = 0x6;
+}
+
+namespace FeBuildTaperedCapsuleRigid_t {
+    constexpr std::ptrdiff_t m_nPriority = 0x30;
+    constexpr std::ptrdiff_t m_nVertexMapHash = 0x34;
+}
+
+namespace FeBuildBoxRigid_t {
+    constexpr std::ptrdiff_t m_nPriority = 0x40;
+    constexpr std::ptrdiff_t m_nVertexMapHash = 0x44;
+}
+
+namespace FeBuildSphereRigid_t {
+    constexpr std::ptrdiff_t m_nPriority = 0x20;
+    constexpr std::ptrdiff_t m_nVertexMapHash = 0x24;
+}
+
+namespace FeSourceEdge_t {
+    constexpr std::ptrdiff_t nNode = 0x0;
+}
+
+namespace FeEffectDesc_t {
+    constexpr std::ptrdiff_t sName = 0x0;
+    constexpr std::ptrdiff_t nNameHash = 0x8;
+    constexpr std::ptrdiff_t nType = 0xc;
+    constexpr std::ptrdiff_t m_Params = 0x10;
+}
+
+namespace FeVertexMapBuild_t {
+    constexpr std::ptrdiff_t m_VertexMapName = 0x0;
+    constexpr std::ptrdiff_t m_nNameHash = 0x8;
+    constexpr std::ptrdiff_t m_Color = 0xc;
+    constexpr std::ptrdiff_t m_flVolumetricSolveStrength = 0x10;
+    constexpr std::ptrdiff_t m_nScaleSourceNode = 0x14;
+    constexpr std::ptrdiff_t m_Weights = 0x18;
+}
+
+namespace CFeVertexMapBuildArray {
+    constexpr std::ptrdiff_t m_Array = 0x0;
+}
+
+namespace FeProxyVertexMap_t {
+    constexpr std::ptrdiff_t m_Name = 0x0;
+    constexpr std::ptrdiff_t m_flWeight = 0x8;
+}
+
+namespace FeVertexMapDesc_t {
+    constexpr std::ptrdiff_t sName = 0x0;
+    constexpr std::ptrdiff_t nNameHash = 0x8;
+    constexpr std::ptrdiff_t nColor = 0xc;
+    constexpr std::ptrdiff_t nFlags = 0x10;
+    constexpr std::ptrdiff_t nVertexBase = 0x14;
+    constexpr std::ptrdiff_t nVertexCount = 0x16;
+    constexpr std::ptrdiff_t nMapOffset = 0x18;
+    constexpr std::ptrdiff_t nNodeListOffset = 0x1c;
+    constexpr std::ptrdiff_t vCenterOfMass = 0x20;
+    constexpr std::ptrdiff_t flVolumetricSolveStrength = 0x2c;
+    constexpr std::ptrdiff_t nScaleSourceNode = 0x30;
+    constexpr std::ptrdiff_t nNodeListCount = 0x32;
+}
+
+namespace FeMorphLayerDepr_t {
+    constexpr std::ptrdiff_t m_Name = 0x0;
+    constexpr std::ptrdiff_t m_nNameHash = 0x8;
+    constexpr std::ptrdiff_t m_Nodes = 0x10;
+    constexpr std::ptrdiff_t m_InitPos = 0x28;
+    constexpr std::ptrdiff_t m_Gravity = 0x40;
+    constexpr std::ptrdiff_t m_GoalStrength = 0x58;
+    constexpr std::ptrdiff_t m_GoalDamping = 0x70;
+    constexpr std::ptrdiff_t m_nFlags = 0x88;
+}
+
+namespace CFeMorphLayer {
+    constexpr std::ptrdiff_t m_Name = 0x0;
+    constexpr std::ptrdiff_t m_nNameHash = 0x8;
+    constexpr std::ptrdiff_t m_Nodes = 0x10;
+    constexpr std::ptrdiff_t m_InitPos = 0x28;
+    constexpr std::ptrdiff_t m_Gravity = 0x40;
+    constexpr std::ptrdiff_t m_GoalStrength = 0x58;
+    constexpr std::ptrdiff_t m_GoalDamping = 0x70;
+}
+
+namespace Dop26_t {
+    constexpr std::ptrdiff_t m_flSupport = 0x0;
+}
+
+namespace RnSphere_t {
+    constexpr std::ptrdiff_t m_vCenter = 0x0;
+    constexpr std::ptrdiff_t m_flRadius = 0xc;
+}
+
+namespace RnCapsule_t {
+    constexpr std::ptrdiff_t m_vCenter = 0x0;
+    constexpr std::ptrdiff_t m_flRadius = 0x18;
+}
+
+namespace RnPlane_t {
+    constexpr std::ptrdiff_t m_vNormal = 0x0;
+    constexpr std::ptrdiff_t m_flOffset = 0xc;
+}
+
+namespace RnHalfEdge_t {
+    constexpr std::ptrdiff_t m_nNext = 0x0;
+    constexpr std::ptrdiff_t m_nTwin = 0x1;
+    constexpr std::ptrdiff_t m_nOrigin = 0x2;
+    constexpr std::ptrdiff_t m_nFace = 0x3;
+}
+
+namespace RnFace_t {
+    constexpr std::ptrdiff_t m_nEdge = 0x0;
+}
+
+namespace CRegionSVM {
+    constexpr std::ptrdiff_t m_Planes = 0x0;
+    constexpr std::ptrdiff_t m_Nodes = 0x18;
+}
+
+namespace RnHull_t {
+    constexpr std::ptrdiff_t m_vCentroid = 0x0;
+    constexpr std::ptrdiff_t m_flMaxAngularRadius = 0xc;
+    constexpr std::ptrdiff_t m_Bounds = 0x10;
+    constexpr std::ptrdiff_t m_vOrthographicAreas = 0x28;
+    constexpr std::ptrdiff_t m_MassProperties = 0x34;
+    constexpr std::ptrdiff_t m_flVolume = 0x64;
+    constexpr std::ptrdiff_t m_Vertices = 0x68;
+    constexpr std::ptrdiff_t m_Edges = 0x80;
+    constexpr std::ptrdiff_t m_Faces = 0x98;
+    constexpr std::ptrdiff_t m_Planes = 0xb0;
+    constexpr std::ptrdiff_t m_nFlags = 0xc8;
+    constexpr std::ptrdiff_t m_pRegionSVM = 0xd0;
+}
+
+namespace RnTriangle_t {
+    constexpr std::ptrdiff_t m_nIndex = 0x0;
+}
+
+namespace RnWing_t {
+    constexpr std::ptrdiff_t m_nIndex = 0x0;
+}
+
+namespace RnNode_t {
+    constexpr std::ptrdiff_t m_vMin = 0x0;
+    constexpr std::ptrdiff_t m_nChildren = 0xc;
+    constexpr std::ptrdiff_t m_vMax = 0x10;
+    constexpr std::ptrdiff_t m_nTriangleOffset = 0x1c;
+}
+
+namespace RnMesh_t {
+    constexpr std::ptrdiff_t m_vMin = 0x0;
+    constexpr std::ptrdiff_t m_vMax = 0xc;
+    constexpr std::ptrdiff_t m_Nodes = 0x18;
+    constexpr std::ptrdiff_t m_Vertices = 0x30;
+    constexpr std::ptrdiff_t m_Triangles = 0x48;
+    constexpr std::ptrdiff_t m_Wings = 0x60;
+    constexpr std::ptrdiff_t m_Materials = 0x78;
+    constexpr std::ptrdiff_t m_vOrthographicAreas = 0x90;
+    constexpr std::ptrdiff_t m_bHasOpenEdges = 0x9c;
+}
+
+namespace RnShapeDesc_t {
+    constexpr std::ptrdiff_t m_nCollisionAttributeIndex = 0x0;
+    constexpr std::ptrdiff_t m_nSurfacePropertyIndex = 0x4;
+    constexpr std::ptrdiff_t m_UserFriendlyName = 0x8;
+}
+
+namespace RnSphereDesc_t {
+    constexpr std::ptrdiff_t m_Sphere = 0x10;
+}
+
+namespace RnCapsuleDesc_t {
+    constexpr std::ptrdiff_t m_Capsule = 0x10;
+}
+
+namespace RnHullDesc_t {
+    constexpr std::ptrdiff_t m_Hull = 0x10;
+}
+
+namespace RnMeshDesc_t {
+    constexpr std::ptrdiff_t m_Mesh = 0x10;
+}
+
+namespace RnSoftbodyParticle_t {
+    constexpr std::ptrdiff_t m_flMassInv = 0x0;
+}
+
+namespace RnSoftbodySpring_t {
+    constexpr std::ptrdiff_t m_nParticle = 0x0;
+    constexpr std::ptrdiff_t m_flLength = 0x4;
+}
+
+namespace RnSoftbodyCapsule_t {
+    constexpr std::ptrdiff_t m_vCenter = 0x0;
+    constexpr std::ptrdiff_t m_flRadius = 0x18;
+    constexpr std::ptrdiff_t m_nParticle = 0x1c;
+}
+
+namespace RnBlendVertex_t {
+    constexpr std::ptrdiff_t m_nWeight0 = 0x0;
+    constexpr std::ptrdiff_t m_nIndex0 = 0x2;
+    constexpr std::ptrdiff_t m_nWeight1 = 0x4;
+    constexpr std::ptrdiff_t m_nIndex1 = 0x6;
+    constexpr std::ptrdiff_t m_nWeight2 = 0x8;
+    constexpr std::ptrdiff_t m_nIndex2 = 0xa;
+    constexpr std::ptrdiff_t m_nFlags = 0xc;
+    constexpr std::ptrdiff_t m_nTargetIndex = 0xe;
+}
+
+namespace CastSphereSATParams_t {
+    constexpr std::ptrdiff_t m_vRayStart = 0x0;
+    constexpr std::ptrdiff_t m_vRayDelta = 0xc;
+    constexpr std::ptrdiff_t m_flRadius = 0x18;
+    constexpr std::ptrdiff_t m_flMaxFraction = 0x1c;
+    constexpr std::ptrdiff_t m_flScale = 0x20;
+    constexpr std::ptrdiff_t m_pHull = 0x28;
+}
+
+namespace RnBodyDesc_t {
+    constexpr std::ptrdiff_t m_sDebugName = 0x0;
+    constexpr std::ptrdiff_t m_vPosition = 0x8;
+    constexpr std::ptrdiff_t m_qOrientation = 0x14;
+    constexpr std::ptrdiff_t m_vLinearVelocity = 0x24;
+    constexpr std::ptrdiff_t m_vAngularVelocity = 0x30;
+    constexpr std::ptrdiff_t m_vLocalMassCenter = 0x3c;
+    constexpr std::ptrdiff_t m_LocalInertiaInv = 0x48;
+    constexpr std::ptrdiff_t m_flMassInv = 0x6c;
+    constexpr std::ptrdiff_t m_flGameMass = 0x70;
+    constexpr std::ptrdiff_t m_flInertiaScaleInv = 0x74;
+    constexpr std::ptrdiff_t m_flLinearDamping = 0x78;
+    constexpr std::ptrdiff_t m_flAngularDamping = 0x7c;
+    constexpr std::ptrdiff_t m_flLinearDrag = 0x80;
+    constexpr std::ptrdiff_t m_flAngularDrag = 0x84;
+    constexpr std::ptrdiff_t m_flLinearBuoyancyDrag = 0x88;
+    constexpr std::ptrdiff_t m_flAngularBuoyancyDrag = 0x8c;
+    constexpr std::ptrdiff_t m_vLastAwakeForceAccum = 0x90;
+    constexpr std::ptrdiff_t m_vLastAwakeTorqueAccum = 0x9c;
+    constexpr std::ptrdiff_t m_flBuoyancyFactor = 0xa8;
+    constexpr std::ptrdiff_t m_flGravityScale = 0xac;
+    constexpr std::ptrdiff_t m_flTimeScale = 0xb0;
+    constexpr std::ptrdiff_t m_nBodyType = 0xb4;
+    constexpr std::ptrdiff_t m_nGameIndex = 0xb8;
+    constexpr std::ptrdiff_t m_nGameFlags = 0xbc;
+    constexpr std::ptrdiff_t m_nMinVelocityIterations = 0xc0;
+    constexpr std::ptrdiff_t m_nMinPositionIterations = 0xc1;
+    constexpr std::ptrdiff_t m_nMassPriority = 0xc2;
+    constexpr std::ptrdiff_t m_bEnabled = 0xc3;
+    constexpr std::ptrdiff_t m_bSleeping = 0xc4;
+    constexpr std::ptrdiff_t m_bIsContinuousEnabled = 0xc5;
+    constexpr std::ptrdiff_t m_bDragEnabled = 0xc6;
+    constexpr std::ptrdiff_t m_bBuoyancyDragEnabled = 0xc7;
+    constexpr std::ptrdiff_t m_bGravityDisabled = 0xc8;
+    constexpr std::ptrdiff_t m_bSpeculativeEnabled = 0xc9;
+    constexpr std::ptrdiff_t m_bHasShadowController = 0xca;
+}
+
+namespace VertexPositionNormal_t {
+    constexpr std::ptrdiff_t m_vPosition = 0x0;
+    constexpr std::ptrdiff_t m_vNormal = 0xc;
+}
+
+namespace VertexPositionColor_t {
+    constexpr std::ptrdiff_t m_vPosition = 0x0;
+}
+
+namespace vphysics_save_cphysicsbody_t {
+    constexpr std::ptrdiff_t m_nOldPointer = 0xd0;
+}
+

generated/vphysics2.dll.json

@@ -0,0 +1,653 @@
+{
+    "CFeIndexedJiggleBone": {
+        "m_jiggleBone": 8,
+        "m_nJiggleParent": 4,
+        "m_nNode": 0
+    },
+    "CFeJiggleBone": {
+        "m_flAlongDamping": 32,
+        "m_flAlongStiffness": 28,
+        "m_flAngleLimit": 36,
+        "m_flBaseDamping": 80,
+        "m_flBaseForwardFriction": 116,
+        "m_flBaseLeftFriction": 92,
+        "m_flBaseMass": 72,
+        "m_flBaseMaxForward": 112,
+        "m_flBaseMaxLeft": 88,
+        "m_flBaseMaxUp": 100,
+        "m_flBaseMinForward": 108,
+        "m_flBaseMinLeft": 84,
+        "m_flBaseMinUp": 96,
+        "m_flBaseStiffness": 76,
+        "m_flBaseUpFriction": 104,
+        "m_flLength": 4,
+        "m_flMaxPitch": 60,
+        "m_flMaxYaw": 44,
+        "m_flMinPitch": 56,
+        "m_flMinYaw": 40,
+        "m_flPitchBounce": 68,
+        "m_flPitchDamping": 24,
+        "m_flPitchFriction": 64,
+        "m_flPitchStiffness": 20,
+        "m_flRadius0": 120,
+        "m_flRadius1": 124,
+        "m_flTipMass": 8,
+        "m_flYawBounce": 52,
+        "m_flYawDamping": 16,
+        "m_flYawFriction": 48,
+        "m_flYawStiffness": 12,
+        "m_nCollisionMask": 152,
+        "m_nFlags": 0,
+        "m_vPoint0": 128,
+        "m_vPoint1": 140
+    },
+    "CFeMorphLayer": {
+        "m_GoalDamping": 112,
+        "m_GoalStrength": 88,
+        "m_Gravity": 64,
+        "m_InitPos": 40,
+        "m_Name": 0,
+        "m_Nodes": 16,
+        "m_nNameHash": 8
+    },
+    "CFeNamedJiggleBone": {
+        "m_jiggleBone": 52,
+        "m_nJiggleParent": 48,
+        "m_strParentBone": 0,
+        "m_transform": 16
+    },
+    "CFeVertexMapBuildArray": {
+        "m_Array": 0
+    },
+    "CRegionSVM": {
+        "m_Nodes": 24,
+        "m_Planes": 0
+    },
+    "CastSphereSATParams_t": {
+        "m_flMaxFraction": 28,
+        "m_flRadius": 24,
+        "m_flScale": 32,
+        "m_pHull": 40,
+        "m_vRayDelta": 12,
+        "m_vRayStart": 0
+    },
+    "CovMatrix3": {
+        "m_flXY": 12,
+        "m_flXZ": 16,
+        "m_flYZ": 20,
+        "m_vDiag": 0
+    },
+    "Dop26_t": {
+        "m_flSupport": 0
+    },
+    "FeAnimStrayRadius_t": {
+        "flMaxDist": 4,
+        "flRelaxationFactor": 8,
+        "nNode": 0
+    },
+    "FeAxialEdgeBend_t": {
+        "flDist": 8,
+        "flWeight": 12,
+        "nNode": 28,
+        "te": 0,
+        "tv": 4
+    },
+    "FeBandBendLimit_t": {
+        "flDistMax": 4,
+        "flDistMin": 0,
+        "nNode": 8
+    },
+    "FeBoxRigid_t": {
+        "flReserved": 56,
+        "flStickiness": 48,
+        "nCollisionMask": 34,
+        "nFlags": 54,
+        "nNode": 32,
+        "nVertexMapIndex": 52,
+        "tmFrame2": 0,
+        "vSize": 36
+    },
+    "FeBuildBoxRigid_t": {
+        "m_nPriority": 64,
+        "m_nVertexMapHash": 68
+    },
+    "FeBuildSphereRigid_t": {
+        "m_nPriority": 32,
+        "m_nVertexMapHash": 36
+    },
+    "FeBuildTaperedCapsuleRigid_t": {
+        "m_nPriority": 48,
+        "m_nVertexMapHash": 52
+    },
+    "FeCollisionPlane_t": {
+        "flStickiness": 20,
+        "flStrength": 24,
+        "m_Plane": 4,
+        "nChildNode": 2,
+        "nCtrlParent": 0
+    },
+    "FeCtrlOffset_t": {
+        "nCtrlChild": 14,
+        "nCtrlParent": 12,
+        "vOffset": 0
+    },
+    "FeCtrlOsOffset_t": {
+        "nCtrlChild": 2,
+        "nCtrlParent": 0
+    },
+    "FeCtrlSoftOffset_t": {
+        "flAlpha": 16,
+        "nCtrlChild": 2,
+        "nCtrlParent": 0,
+        "vOffset": 4
+    },
+    "FeEdgeDesc_t": {
+        "nEdge": 0,
+        "nSide": 4,
+        "nVirtElem": 12
+    },
+    "FeEffectDesc_t": {
+        "m_Params": 16,
+        "nNameHash": 8,
+        "nType": 12,
+        "sName": 0
+    },
+    "FeFitInfluence_t": {
+        "flWeight": 4,
+        "nMatrixNode": 8,
+        "nVertexNode": 0
+    },
+    "FeFitMatrix_t": {
+        "bone": 0,
+        "nBeginDynamic": 48,
+        "nEnd": 44,
+        "nNode": 46,
+        "vCenter": 32
+    },
+    "FeFitWeight_t": {
+        "flWeight": 0,
+        "nDummy": 6,
+        "nNode": 4
+    },
+    "FeFollowNode_t": {
+        "flWeight": 4,
+        "nChildNode": 2,
+        "nParentNode": 0
+    },
+    "FeKelagerBend2_t": {
+        "flHeight0": 12,
+        "flWeight": 0,
+        "nNode": 16,
+        "nReserved": 22
+    },
+    "FeMorphLayerDepr_t": {
+        "m_GoalDamping": 112,
+        "m_GoalStrength": 88,
+        "m_Gravity": 64,
+        "m_InitPos": 40,
+        "m_Name": 0,
+        "m_Nodes": 16,
+        "m_nFlags": 136,
+        "m_nNameHash": 8
+    },
+    "FeNodeBase_t": {
+        "nDummy": 2,
+        "nNode": 0,
+        "nNodeX0": 8,
+        "nNodeX1": 10,
+        "nNodeY0": 12,
+        "nNodeY1": 14,
+        "qAdjust": 16
+    },
+    "FeNodeIntegrator_t": {
+        "flAnimationForceAttraction": 4,
+        "flAnimationVertexAttraction": 8,
+        "flGravity": 12,
+        "flPointDamping": 0
+    },
+    "FeNodeReverseOffset_t": {
+        "nBoneCtrl": 12,
+        "nTargetNode": 14,
+        "vOffset": 0
+    },
+    "FeNodeWindBase_t": {
+        "nNodeX0": 0,
+        "nNodeX1": 2,
+        "nNodeY0": 4,
+        "nNodeY1": 6
+    },
+    "FeProxyVertexMap_t": {
+        "m_Name": 0,
+        "m_flWeight": 8
+    },
+    "FeQuad_t": {
+        "flSlack": 8,
+        "nNode": 0,
+        "vShape": 12
+    },
+    "FeRigidColliderIndices_t": {
+        "m_nBoxRigidIndex": 4,
+        "m_nCollisionPlaneIndex": 6,
+        "m_nSphereRigidIndex": 2,
+        "m_nTaperedCapsuleRigidIndex": 0
+    },
+    "FeRodConstraint_t": {
+        "flMaxDist": 4,
+        "flMinDist": 8,
+        "flRelaxationFactor": 16,
+        "flWeight0": 12,
+        "nNode": 0
+    },
+    "FeSimdAnimStrayRadius_t": {
+        "flMaxDist": 16,
+        "flRelaxationFactor": 32,
+        "nNode": 0
+    },
+    "FeSimdNodeBase_t": {
+        "nDummy": 40,
+        "nNode": 0,
+        "nNodeX0": 8,
+        "nNodeX1": 16,
+        "nNodeY0": 24,
+        "nNodeY1": 32,
+        "qAdjust": 48
+    },
+    "FeSimdQuad_t": {
+        "f4Slack": 32,
+        "f4Weights": 240,
+        "nNode": 0,
+        "vShape": 48
+    },
+    "FeSimdRodConstraint_t": {
+        "f4MaxDist": 16,
+        "f4MinDist": 32,
+        "f4RelaxationFactor": 64,
+        "f4Weight0": 48,
+        "nNode": 0
+    },
+    "FeSimdSpringIntegrator_t": {
+        "flNodeWeight0": 64,
+        "flSpringConstant": 32,
+        "flSpringDamping": 48,
+        "flSpringRestLength": 16,
+        "nNode": 0
+    },
+    "FeSimdTri_t": {
+        "nNode": 0,
+        "v1x": 80,
+        "v2": 96,
+        "w1": 48,
+        "w2": 64
+    },
+    "FeSoftParent_t": {
+        "flAlpha": 4,
+        "nParent": 0
+    },
+    "FeSourceEdge_t": {
+        "nNode": 0
+    },
+    "FeSphereRigid_t": {
+        "flStickiness": 16,
+        "nCollisionMask": 22,
+        "nFlags": 26,
+        "nNode": 20,
+        "nVertexMapIndex": 24,
+        "vSphere": 0
+    },
+    "FeSpringIntegrator_t": {
+        "flNodeWeight0": 16,
+        "flSpringConstant": 8,
+        "flSpringDamping": 12,
+        "flSpringRestLength": 4,
+        "nNode": 0
+    },
+    "FeStiffHingeBuild_t": {
+        "flMaxAngle": 0,
+        "flMotionBias": 8,
+        "flStrength": 4,
+        "nNode": 20
+    },
+    "FeTaperedCapsuleRigid_t": {
+        "flStickiness": 32,
+        "nCollisionMask": 38,
+        "nFlags": 42,
+        "nNode": 36,
+        "nVertexMapIndex": 40,
+        "vSphere": 0
+    },
+    "FeTreeChildren_t": {
+        "nChild": 0
+    },
+    "FeTri_t": {
+        "nNode": 0,
+        "v1x": 16,
+        "v2": 20,
+        "w1": 8,
+        "w2": 12
+    },
+    "FeTwistConstraint_t": {
+        "flSwingRelax": 8,
+        "flTwistRelax": 4,
+        "nNodeEnd": 2,
+        "nNodeOrient": 0
+    },
+    "FeVertexMapBuild_t": {
+        "m_Color": 12,
+        "m_VertexMapName": 0,
+        "m_Weights": 24,
+        "m_flVolumetricSolveStrength": 16,
+        "m_nNameHash": 8,
+        "m_nScaleSourceNode": 20
+    },
+    "FeVertexMapDesc_t": {
+        "flVolumetricSolveStrength": 44,
+        "nColor": 12,
+        "nFlags": 16,
+        "nMapOffset": 24,
+        "nNameHash": 8,
+        "nNodeListCount": 50,
+        "nNodeListOffset": 28,
+        "nScaleSourceNode": 48,
+        "nVertexBase": 20,
+        "nVertexCount": 22,
+        "sName": 0,
+        "vCenterOfMass": 32
+    },
+    "FeWeightedNode_t": {
+        "nNode": 0,
+        "nWeight": 2
+    },
+    "FeWorldCollisionParams_t": {
+        "flGroundFriction": 4,
+        "flWorldFriction": 0,
+        "nListBegin": 8,
+        "nListEnd": 10
+    },
+    "FourCovMatrices3": {
+        "m_flXY": 48,
+        "m_flXZ": 64,
+        "m_flYZ": 80,
+        "m_vDiag": 0
+    },
+    "FourVectors2D": {
+        "x": 0,
+        "y": 16
+    },
+    "OldFeEdge_t": {
+        "c01": 28,
+        "c02": 32,
+        "c03": 36,
+        "c04": 40,
+        "flAxialModelDist": 44,
+        "flAxialModelWeights": 48,
+        "flThetaFactor": 24,
+        "flThetaRelaxed": 20,
+        "invA": 12,
+        "m_flK": 0,
+        "m_nNode": 64,
+        "t": 16
+    },
+    "PhysFeModelDesc_t": {
+        "m_AnimStrayRadii": 960,
+        "m_AxialEdges": 336,
+        "m_BoxRigids": 1160,
+        "m_CollisionPlanes": 456,
+        "m_CtrlHash": 0,
+        "m_CtrlName": 24,
+        "m_CtrlOffsets": 384,
+        "m_CtrlOsOffsets": 408,
+        "m_CtrlSoftOffsets": 1032,
+        "m_DynNodeFriction": 624,
+        "m_DynNodeVertexSet": 1184,
+        "m_DynNodeWindBases": 1424,
+        "m_Effects": 1352,
+        "m_FitMatrices": 888,
+        "m_FitWeights": 912,
+        "m_FollowNodes": 432,
+        "m_FreeNodes": 864,
+        "m_GoalDampedSpringIntegrators": 1104,
+        "m_InitPose": 264,
+        "m_JiggleBones": 1056,
+        "m_KelagerBends": 1008,
+        "m_LegacyStretchForce": 576,
+        "m_LocalForce": 672,
+        "m_LocalRotation": 648,
+        "m_LockToGoal": 1400,
+        "m_LockToParent": 1376,
+        "m_MorphLayers": 1256,
+        "m_MorphSetData": 1280,
+        "m_NodeBases": 120,
+        "m_NodeCollisionRadii": 600,
+        "m_NodeIntegrator": 480,
+        "m_NodeInvMasses": 360,
+        "m_Quads": 168,
+        "m_ReverseOffsets": 936,
+        "m_RigidColliderPriorities": 1232,
+        "m_Rods": 288,
+        "m_Ropes": 96,
+        "m_SimdAnimStrayRadii": 984,
+        "m_SimdNodeBases": 144,
+        "m_SimdQuads": 192,
+        "m_SimdRods": 240,
+        "m_SimdSpringIntegrator": 528,
+        "m_SimdTris": 216,
+        "m_SourceElems": 1080,
+        "m_SphereRigids": 744,
+        "m_SpringIntegrator": 504,
+        "m_TaperedCapsuleRigids": 720,
+        "m_TaperedCapsuleStretches": 696,
+        "m_TreeChildren": 840,
+        "m_TreeCollisionMasks": 816,
+        "m_TreeParents": 792,
+        "m_Tris": 1128,
+        "m_Twists": 312,
+        "m_VertexMapValues": 1328,
+        "m_VertexMaps": 1304,
+        "m_VertexSetNames": 1208,
+        "m_WorldCollisionNodes": 768,
+        "m_WorldCollisionParams": 552,
+        "m_flAddWorldCollisionRadius": 1500,
+        "m_flDefaultExpAirDrag": 1480,
+        "m_flDefaultExpQuadAirDrag": 1488,
+        "m_flDefaultGravityScale": 1472,
+        "m_flDefaultSurfaceStretch": 1464,
+        "m_flDefaultThreadStretch": 1468,
+        "m_flDefaultTimeDilation": 1452,
+        "m_flDefaultVelAirDrag": 1476,
+        "m_flDefaultVelQuadAirDrag": 1484,
+        "m_flDefaultVolumetricSolveAmount": 1504,
+        "m_flInternalPressure": 1448,
+        "m_flLocalForce": 56,
+        "m_flLocalRotation": 60,
+        "m_flQuadVelocitySmoothRate": 1496,
+        "m_flRodVelocitySmoothRate": 1492,
+        "m_flWindDrag": 1460,
+        "m_flWindage": 1456,
+        "m_nDynamicNodeFlags": 52,
+        "m_nExtraGoalIterations": 1158,
+        "m_nExtraIterations": 1159,
+        "m_nExtraPressureIterations": 1157,
+        "m_nFirstPositionDrivenNode": 70,
+        "m_nNodeBaseJiggleboneDependsCount": 86,
+        "m_nNodeCount": 64,
+        "m_nQuadCount1": 80,
+        "m_nQuadCount2": 82,
+        "m_nQuadVelocitySmoothIterations": 1510,
+        "m_nReservedUint8": 1156,
+        "m_nRodVelocitySmoothIterations": 1508,
+        "m_nRopeCount": 88,
+        "m_nRotLockStaticNodes": 68,
+        "m_nSimdQuadCount1": 76,
+        "m_nSimdQuadCount2": 78,
+        "m_nSimdTriCount1": 72,
+        "m_nSimdTriCount2": 74,
+        "m_nStaticNodeFlags": 48,
+        "m_nStaticNodes": 66,
+        "m_nTreeDepth": 84,
+        "m_nTriCount1": 1152,
+        "m_nTriCount2": 1154
+    },
+    "RnBlendVertex_t": {
+        "m_nFlags": 12,
+        "m_nIndex0": 2,
+        "m_nIndex1": 6,
+        "m_nIndex2": 10,
+        "m_nTargetIndex": 14,
+        "m_nWeight0": 0,
+        "m_nWeight1": 4,
+        "m_nWeight2": 8
+    },
+    "RnBodyDesc_t": {
+        "m_LocalInertiaInv": 72,
+        "m_bBuoyancyDragEnabled": 199,
+        "m_bDragEnabled": 198,
+        "m_bEnabled": 195,
+        "m_bGravityDisabled": 200,
+        "m_bHasShadowController": 202,
+        "m_bIsContinuousEnabled": 197,
+        "m_bSleeping": 196,
+        "m_bSpeculativeEnabled": 201,
+        "m_flAngularBuoyancyDrag": 140,
+        "m_flAngularDamping": 124,
+        "m_flAngularDrag": 132,
+        "m_flBuoyancyFactor": 168,
+        "m_flGameMass": 112,
+        "m_flGravityScale": 172,
+        "m_flInertiaScaleInv": 116,
+        "m_flLinearBuoyancyDrag": 136,
+        "m_flLinearDamping": 120,
+        "m_flLinearDrag": 128,
+        "m_flMassInv": 108,
+        "m_flTimeScale": 176,
+        "m_nBodyType": 180,
+        "m_nGameFlags": 188,
+        "m_nGameIndex": 184,
+        "m_nMassPriority": 194,
+        "m_nMinPositionIterations": 193,
+        "m_nMinVelocityIterations": 192,
+        "m_qOrientation": 20,
+        "m_sDebugName": 0,
+        "m_vAngularVelocity": 48,
+        "m_vLastAwakeForceAccum": 144,
+        "m_vLastAwakeTorqueAccum": 156,
+        "m_vLinearVelocity": 36,
+        "m_vLocalMassCenter": 60,
+        "m_vPosition": 8
+    },
+    "RnCapsuleDesc_t": {
+        "m_Capsule": 16
+    },
+    "RnCapsule_t": {
+        "m_flRadius": 24,
+        "m_vCenter": 0
+    },
+    "RnFace_t": {
+        "m_nEdge": 0
+    },
+    "RnHalfEdge_t": {
+        "m_nFace": 3,
+        "m_nNext": 0,
+        "m_nOrigin": 2,
+        "m_nTwin": 1
+    },
+    "RnHullDesc_t": {
+        "m_Hull": 16
+    },
+    "RnHull_t": {
+        "m_Bounds": 16,
+        "m_Edges": 128,
+        "m_Faces": 152,
+        "m_MassProperties": 52,
+        "m_Planes": 176,
+        "m_Vertices": 104,
+        "m_flMaxAngularRadius": 12,
+        "m_flVolume": 100,
+        "m_nFlags": 200,
+        "m_pRegionSVM": 208,
+        "m_vCentroid": 0,
+        "m_vOrthographicAreas": 40
+    },
+    "RnMeshDesc_t": {
+        "m_Mesh": 16
+    },
+    "RnMesh_t": {
+        "m_Materials": 120,
+        "m_Nodes": 24,
+        "m_Triangles": 72,
+        "m_Vertices": 48,
+        "m_Wings": 96,
+        "m_bHasOpenEdges": 156,
+        "m_vMax": 12,
+        "m_vMin": 0,
+        "m_vOrthographicAreas": 144
+    },
+    "RnNode_t": {
+        "m_nChildren": 12,
+        "m_nTriangleOffset": 28,
+        "m_vMax": 16,
+        "m_vMin": 0
+    },
+    "RnPlane_t": {
+        "m_flOffset": 12,
+        "m_vNormal": 0
+    },
+    "RnShapeDesc_t": {
+        "m_UserFriendlyName": 8,
+        "m_nCollisionAttributeIndex": 0,
+        "m_nSurfacePropertyIndex": 4
+    },
+    "RnSoftbodyCapsule_t": {
+        "m_flRadius": 24,
+        "m_nParticle": 28,
+        "m_vCenter": 0
+    },
+    "RnSoftbodyParticle_t": {
+        "m_flMassInv": 0
+    },
+    "RnSoftbodySpring_t": {
+        "m_flLength": 4,
+        "m_nParticle": 0
+    },
+    "RnSphereDesc_t": {
+        "m_Sphere": 16
+    },
+    "RnSphere_t": {
+        "m_flRadius": 12,
+        "m_vCenter": 0
+    },
+    "RnTriangle_t": {
+        "m_nIndex": 0
+    },
+    "RnWing_t": {
+        "m_nIndex": 0
+    },
+    "VertexPositionColor_t": {
+        "m_vPosition": 0
+    },
+    "VertexPositionNormal_t": {
+        "m_vNormal": 12,
+        "m_vPosition": 0
+    },
+    "constraint_axislimit_t": {
+        "flMaxRotation": 4,
+        "flMinRotation": 0,
+        "flMotorMaxTorque": 12,
+        "flMotorTargetAngSpeed": 8
+    },
+    "constraint_breakableparams_t": {
+        "bodyMassScale": 12,
+        "forceLimit": 4,
+        "isActive": 20,
+        "strength": 0,
+        "torqueLimit": 8
+    },
+    "constraint_hingeparams_t": {
+        "constraint": 40,
+        "hingeAxis": 24,
+        "worldAxisDirection": 12,
+        "worldPosition": 0
+    },
+    "vphysics_save_cphysicsbody_t": {
+        "m_nOldPointer": 208
+    }
+}

generated/worldrenderer.dll.hpp

@@ -0,0 +1,228 @@
+#pragma once
+
+#include <cstddef>
+
+namespace EntityIOConnectionData_t {
+    constexpr std::ptrdiff_t m_outputName = 0x0;
+    constexpr std::ptrdiff_t m_targetType = 0x8;
+    constexpr std::ptrdiff_t m_targetName = 0x10;
+    constexpr std::ptrdiff_t m_inputName = 0x18;
+    constexpr std::ptrdiff_t m_overrideParam = 0x20;
+    constexpr std::ptrdiff_t m_flDelay = 0x28;
+    constexpr std::ptrdiff_t m_nTimesToFire = 0x2c;
+}
+
+namespace EntityKeyValueData_t {
+    constexpr std::ptrdiff_t m_connections = 0x8;
+    constexpr std::ptrdiff_t m_keyValuesData = 0x20;
+}
+
+namespace PermEntityLumpData_t {
+    constexpr std::ptrdiff_t m_name = 0x8;
+    constexpr std::ptrdiff_t m_hammerUniqueId = 0x10;
+    constexpr std::ptrdiff_t m_childLumps = 0x18;
+    constexpr std::ptrdiff_t m_entityKeyValues = 0x30;
+}
+
+namespace SceneObject_t {
+    constexpr std::ptrdiff_t m_nObjectID = 0x0;
+    constexpr std::ptrdiff_t m_vTransform = 0x4;
+    constexpr std::ptrdiff_t m_flFadeStartDistance = 0x34;
+    constexpr std::ptrdiff_t m_flFadeEndDistance = 0x38;
+    constexpr std::ptrdiff_t m_vTintColor = 0x3c;
+    constexpr std::ptrdiff_t m_skin = 0x50;
+    constexpr std::ptrdiff_t m_nObjectTypeFlags = 0x58;
+    constexpr std::ptrdiff_t m_vLightingOrigin = 0x5c;
+    constexpr std::ptrdiff_t m_nLightGroup = 0x68;
+    constexpr std::ptrdiff_t m_nOverlayRenderOrder = 0x6c;
+    constexpr std::ptrdiff_t m_nLODOverride = 0x6e;
+    constexpr std::ptrdiff_t m_nCubeMapPrecomputedHandshake = 0x70;
+    constexpr std::ptrdiff_t m_nLightProbeVolumePrecomputedHandshake = 0x74;
+    constexpr std::ptrdiff_t m_renderableModel = 0x80;
+    constexpr std::ptrdiff_t m_renderable = 0x88;
+}
+
+namespace BaseSceneObjectOverride_t {
+    constexpr std::ptrdiff_t m_nSceneObjectIndex = 0x0;
+}
+
+namespace ExtraVertexStreamOverride_t {
+    constexpr std::ptrdiff_t m_nSubSceneObject = 0x4;
+    constexpr std::ptrdiff_t m_nDrawCallIndex = 0x8;
+    constexpr std::ptrdiff_t m_nAdditionalMeshDrawPrimitiveFlags = 0xc;
+    constexpr std::ptrdiff_t m_extraBufferBinding = 0x10;
+}
+
+namespace MaterialOverride_t {
+    constexpr std::ptrdiff_t m_nSubSceneObject = 0x4;
+    constexpr std::ptrdiff_t m_nDrawCallIndex = 0x8;
+    constexpr std::ptrdiff_t m_pMaterial = 0x10;
+}
+
+namespace InfoOverlayData_t {
+    constexpr std::ptrdiff_t m_transform = 0x0;
+    constexpr std::ptrdiff_t m_flWidth = 0x30;
+    constexpr std::ptrdiff_t m_flHeight = 0x34;
+    constexpr std::ptrdiff_t m_flDepth = 0x38;
+    constexpr std::ptrdiff_t m_vUVStart = 0x3c;
+    constexpr std::ptrdiff_t m_vUVEnd = 0x44;
+    constexpr std::ptrdiff_t m_pMaterial = 0x50;
+    constexpr std::ptrdiff_t m_nRenderOrder = 0x58;
+    constexpr std::ptrdiff_t m_vTintColor = 0x5c;
+    constexpr std::ptrdiff_t m_nSequenceOverride = 0x6c;
+}
+
+namespace BakedLightingInfo_t {
+    constexpr std::ptrdiff_t m_nLightmapVersionNumber = 0x0;
+    constexpr std::ptrdiff_t m_nLightmapGameVersionNumber = 0x4;
+    constexpr std::ptrdiff_t m_vLightmapUvScale = 0x8;
+    constexpr std::ptrdiff_t m_bHasLightmaps = 0x10;
+    constexpr std::ptrdiff_t m_lightMaps = 0x18;
+}
+
+namespace WorldNodeOnDiskBufferData_t {
+    constexpr std::ptrdiff_t m_nElementCount = 0x0;
+    constexpr std::ptrdiff_t m_nElementSizeInBytes = 0x4;
+    constexpr std::ptrdiff_t m_inputLayoutFields = 0x8;
+    constexpr std::ptrdiff_t m_pData = 0x20;
+}
+
+namespace AggregateMeshInfo_t {
+    constexpr std::ptrdiff_t m_nVisClusterMemberOffset = 0x0;
+    constexpr std::ptrdiff_t m_nVisClusterMemberCount = 0x4;
+    constexpr std::ptrdiff_t m_bHasTransform = 0x5;
+    constexpr std::ptrdiff_t m_nDrawCallIndex = 0x6;
+    constexpr std::ptrdiff_t m_nLODSetupIndex = 0x8;
+    constexpr std::ptrdiff_t m_nLODGroupMask = 0xa;
+    constexpr std::ptrdiff_t m_vTintColor = 0xb;
+    constexpr std::ptrdiff_t m_objectFlags = 0x10;
+    constexpr std::ptrdiff_t m_nLightProbeVolumePrecomputedHandshake = 0x14;
+}
+
+namespace AggregateLODSetup_t {
+    constexpr std::ptrdiff_t m_vLODOrigin = 0x0;
+    constexpr std::ptrdiff_t m_fMaxObjectScale = 0xc;
+    constexpr std::ptrdiff_t m_nLODMask = 0x10;
+    constexpr std::ptrdiff_t m_fSwitchDistances = 0x18;
+}
+
+namespace AggregateSceneObject_t {
+    constexpr std::ptrdiff_t m_allFlags = 0x0;
+    constexpr std::ptrdiff_t m_anyFlags = 0x4;
+    constexpr std::ptrdiff_t m_nLayer = 0x8;
+    constexpr std::ptrdiff_t m_aggregateMeshes = 0x10;
+    constexpr std::ptrdiff_t m_lodSetups = 0x28;
+    constexpr std::ptrdiff_t m_visClusterMembership = 0x40;
+    constexpr std::ptrdiff_t m_fragmentTransforms = 0x58;
+    constexpr std::ptrdiff_t m_renderableModel = 0x70;
+}
+
+namespace ClutterTile_t {
+    constexpr std::ptrdiff_t m_nFirstInstance = 0x0;
+    constexpr std::ptrdiff_t m_nLastInstance = 0x4;
+    constexpr std::ptrdiff_t m_BoundsWs = 0x8;
+}
+
+namespace ClutterSceneObject_t {
+    constexpr std::ptrdiff_t m_Bounds = 0x0;
+    constexpr std::ptrdiff_t m_flags = 0x18;
+    constexpr std::ptrdiff_t m_nLayer = 0x1c;
+    constexpr std::ptrdiff_t m_instancePositions = 0x20;
+    constexpr std::ptrdiff_t m_instanceScales = 0x50;
+    constexpr std::ptrdiff_t m_instanceTintSrgb = 0x68;
+    constexpr std::ptrdiff_t m_tiles = 0x80;
+    constexpr std::ptrdiff_t m_renderableModel = 0x98;
+}
+
+namespace WorldNode_t {
+    constexpr std::ptrdiff_t m_sceneObjects = 0x0;
+    constexpr std::ptrdiff_t m_infoOverlays = 0x18;
+    constexpr std::ptrdiff_t m_visClusterMembership = 0x30;
+    constexpr std::ptrdiff_t m_aggregateSceneObjects = 0x48;
+    constexpr std::ptrdiff_t m_clutterSceneObjects = 0x60;
+    constexpr std::ptrdiff_t m_extraVertexStreamOverrides = 0x78;
+    constexpr std::ptrdiff_t m_materialOverrides = 0x90;
+    constexpr std::ptrdiff_t m_extraVertexStreams = 0xa8;
+    constexpr std::ptrdiff_t m_layerNames = 0xc0;
+    constexpr std::ptrdiff_t m_sceneObjectLayerIndices = 0xd8;
+    constexpr std::ptrdiff_t m_overlayLayerIndices = 0xf0;
+    constexpr std::ptrdiff_t m_grassFileName = 0x108;
+    constexpr std::ptrdiff_t m_nodeLightingInfo = 0x110;
+}
+
+namespace WorldBuilderParams_t {
+    constexpr std::ptrdiff_t m_flMinDrawVolumeSize = 0x0;
+    constexpr std::ptrdiff_t m_bBuildBakedLighting = 0x4;
+    constexpr std::ptrdiff_t m_vLightmapUvScale = 0x8;
+    constexpr std::ptrdiff_t m_nCompileTimestamp = 0x10;
+    constexpr std::ptrdiff_t m_nCompileFingerprint = 0x18;
+}
+
+namespace NodeData_t {
+    constexpr std::ptrdiff_t m_nParent = 0x0;
+    constexpr std::ptrdiff_t m_vOrigin = 0x4;
+    constexpr std::ptrdiff_t m_vMinBounds = 0x10;
+    constexpr std::ptrdiff_t m_vMaxBounds = 0x1c;
+    constexpr std::ptrdiff_t m_flMinimumDistance = 0x28;
+    constexpr std::ptrdiff_t m_ChildNodeIndices = 0x30;
+    constexpr std::ptrdiff_t m_worldNodePrefix = 0x48;
+}
+
+namespace World_t {
+    constexpr std::ptrdiff_t m_builderParams = 0x0;
+    constexpr std::ptrdiff_t m_worldNodes = 0x20;
+    constexpr std::ptrdiff_t m_worldLightingInfo = 0x38;
+    constexpr std::ptrdiff_t m_entityLumps = 0x68;
+}
+
+namespace VoxelVisBlockOffset_t {
+    constexpr std::ptrdiff_t m_nOffset = 0x0;
+    constexpr std::ptrdiff_t m_nElementCount = 0x4;
+}
+
+namespace CVoxelVisibility {
+    constexpr std::ptrdiff_t m_nBaseClusterCount = 0x40;
+    constexpr std::ptrdiff_t m_nPVSBytesPerCluster = 0x44;
+    constexpr std::ptrdiff_t m_vMinBounds = 0x48;
+    constexpr std::ptrdiff_t m_vMaxBounds = 0x54;
+    constexpr std::ptrdiff_t m_flGridSize = 0x60;
+    constexpr std::ptrdiff_t m_nSkyVisibilityCluster = 0x64;
+    constexpr std::ptrdiff_t m_nSunVisibilityCluster = 0x68;
+    constexpr std::ptrdiff_t m_NodeBlock = 0x6c;
+    constexpr std::ptrdiff_t m_RegionBlock = 0x74;
+    constexpr std::ptrdiff_t m_EnclosedClusterListBlock = 0x7c;
+    constexpr std::ptrdiff_t m_EnclosedClustersBlock = 0x84;
+    constexpr std::ptrdiff_t m_MasksBlock = 0x8c;
+    constexpr std::ptrdiff_t m_nVisBlocks = 0x94;
+}
+
+namespace VMapResourceData_t {
+}
+
+namespace InfoForResourceTypeVMapResourceData_t {
+}
+
+namespace CEntityIdentity {
+    constexpr std::ptrdiff_t m_nameStringableIndex = 0x14;
+    constexpr std::ptrdiff_t m_name = 0x18;
+    constexpr std::ptrdiff_t m_designerName = 0x20;
+    constexpr std::ptrdiff_t m_flags = 0x30;
+    constexpr std::ptrdiff_t m_worldGroupId = 0x38;
+    constexpr std::ptrdiff_t m_fDataObjectTypes = 0x3c;
+    constexpr std::ptrdiff_t m_PathIndex = 0x40;
+    constexpr std::ptrdiff_t m_pPrev = 0x58;
+    constexpr std::ptrdiff_t m_pNext = 0x60;
+    constexpr std::ptrdiff_t m_pPrevByClass = 0x68;
+    constexpr std::ptrdiff_t m_pNextByClass = 0x70;
+}
+
+namespace CEntityInstance {
+    constexpr std::ptrdiff_t m_iszPrivateVScripts = 0x8;
+    constexpr std::ptrdiff_t m_pEntity = 0x10;
+    constexpr std::ptrdiff_t m_CScriptComponent = 0x28;
+}
+
+namespace CScriptComponent {
+    constexpr std::ptrdiff_t m_scriptClassName = 0x30;
+}
+

generated/worldrenderer.dll.json

@@ -0,0 +1,196 @@
+{
+    "AggregateLODSetup_t": {
+        "m_fMaxObjectScale": 12,
+        "m_fSwitchDistances": 24,
+        "m_nLODMask": 16,
+        "m_vLODOrigin": 0
+    },
+    "AggregateMeshInfo_t": {
+        "m_bHasTransform": 5,
+        "m_nDrawCallIndex": 6,
+        "m_nLODGroupMask": 10,
+        "m_nLODSetupIndex": 8,
+        "m_nLightProbeVolumePrecomputedHandshake": 20,
+        "m_nVisClusterMemberCount": 4,
+        "m_nVisClusterMemberOffset": 0,
+        "m_objectFlags": 16,
+        "m_vTintColor": 11
+    },
+    "AggregateSceneObject_t": {
+        "m_aggregateMeshes": 16,
+        "m_allFlags": 0,
+        "m_anyFlags": 4,
+        "m_fragmentTransforms": 88,
+        "m_lodSetups": 40,
+        "m_nLayer": 8,
+        "m_renderableModel": 112,
+        "m_visClusterMembership": 64
+    },
+    "BakedLightingInfo_t": {
+        "m_bHasLightmaps": 16,
+        "m_lightMaps": 24,
+        "m_nLightmapGameVersionNumber": 4,
+        "m_nLightmapVersionNumber": 0,
+        "m_vLightmapUvScale": 8
+    },
+    "BaseSceneObjectOverride_t": {
+        "m_nSceneObjectIndex": 0
+    },
+    "CEntityIdentity": {
+        "m_PathIndex": 64,
+        "m_designerName": 32,
+        "m_fDataObjectTypes": 60,
+        "m_flags": 48,
+        "m_name": 24,
+        "m_nameStringableIndex": 20,
+        "m_pNext": 96,
+        "m_pNextByClass": 112,
+        "m_pPrev": 88,
+        "m_pPrevByClass": 104,
+        "m_worldGroupId": 56
+    },
+    "CEntityInstance": {
+        "m_CScriptComponent": 40,
+        "m_iszPrivateVScripts": 8,
+        "m_pEntity": 16
+    },
+    "CScriptComponent": {
+        "m_scriptClassName": 48
+    },
+    "CVoxelVisibility": {
+        "m_EnclosedClusterListBlock": 124,
+        "m_EnclosedClustersBlock": 132,
+        "m_MasksBlock": 140,
+        "m_NodeBlock": 108,
+        "m_RegionBlock": 116,
+        "m_flGridSize": 96,
+        "m_nBaseClusterCount": 64,
+        "m_nPVSBytesPerCluster": 68,
+        "m_nSkyVisibilityCluster": 100,
+        "m_nSunVisibilityCluster": 104,
+        "m_nVisBlocks": 148,
+        "m_vMaxBounds": 84,
+        "m_vMinBounds": 72
+    },
+    "ClutterSceneObject_t": {
+        "m_Bounds": 0,
+        "m_flags": 24,
+        "m_instancePositions": 32,
+        "m_instanceScales": 80,
+        "m_instanceTintSrgb": 104,
+        "m_nLayer": 28,
+        "m_renderableModel": 152,
+        "m_tiles": 128
+    },
+    "ClutterTile_t": {
+        "m_BoundsWs": 8,
+        "m_nFirstInstance": 0,
+        "m_nLastInstance": 4
+    },
+    "EntityIOConnectionData_t": {
+        "m_flDelay": 40,
+        "m_inputName": 24,
+        "m_nTimesToFire": 44,
+        "m_outputName": 0,
+        "m_overrideParam": 32,
+        "m_targetName": 16,
+        "m_targetType": 8
+    },
+    "EntityKeyValueData_t": {
+        "m_connections": 8,
+        "m_keyValuesData": 32
+    },
+    "ExtraVertexStreamOverride_t": {
+        "m_extraBufferBinding": 16,
+        "m_nAdditionalMeshDrawPrimitiveFlags": 12,
+        "m_nDrawCallIndex": 8,
+        "m_nSubSceneObject": 4
+    },
+    "InfoOverlayData_t": {
+        "m_flDepth": 56,
+        "m_flHeight": 52,
+        "m_flWidth": 48,
+        "m_nRenderOrder": 88,
+        "m_nSequenceOverride": 108,
+        "m_pMaterial": 80,
+        "m_transform": 0,
+        "m_vTintColor": 92,
+        "m_vUVEnd": 68,
+        "m_vUVStart": 60
+    },
+    "MaterialOverride_t": {
+        "m_nDrawCallIndex": 8,
+        "m_nSubSceneObject": 4,
+        "m_pMaterial": 16
+    },
+    "NodeData_t": {
+        "m_ChildNodeIndices": 48,
+        "m_flMinimumDistance": 40,
+        "m_nParent": 0,
+        "m_vMaxBounds": 28,
+        "m_vMinBounds": 16,
+        "m_vOrigin": 4,
+        "m_worldNodePrefix": 72
+    },
+    "PermEntityLumpData_t": {
+        "m_childLumps": 24,
+        "m_entityKeyValues": 48,
+        "m_hammerUniqueId": 16,
+        "m_name": 8
+    },
+    "SceneObject_t": {
+        "m_flFadeEndDistance": 56,
+        "m_flFadeStartDistance": 52,
+        "m_nCubeMapPrecomputedHandshake": 112,
+        "m_nLODOverride": 110,
+        "m_nLightGroup": 104,
+        "m_nLightProbeVolumePrecomputedHandshake": 116,
+        "m_nObjectID": 0,
+        "m_nObjectTypeFlags": 88,
+        "m_nOverlayRenderOrder": 108,
+        "m_renderable": 136,
+        "m_renderableModel": 128,
+        "m_skin": 80,
+        "m_vLightingOrigin": 92,
+        "m_vTintColor": 60,
+        "m_vTransform": 4
+    },
+    "VoxelVisBlockOffset_t": {
+        "m_nElementCount": 4,
+        "m_nOffset": 0
+    },
+    "WorldBuilderParams_t": {
+        "m_bBuildBakedLighting": 4,
+        "m_flMinDrawVolumeSize": 0,
+        "m_nCompileFingerprint": 24,
+        "m_nCompileTimestamp": 16,
+        "m_vLightmapUvScale": 8
+    },
+    "WorldNodeOnDiskBufferData_t": {
+        "m_inputLayoutFields": 8,
+        "m_nElementCount": 0,
+        "m_nElementSizeInBytes": 4,
+        "m_pData": 32
+    },
+    "WorldNode_t": {
+        "m_aggregateSceneObjects": 72,
+        "m_clutterSceneObjects": 96,
+        "m_extraVertexStreamOverrides": 120,
+        "m_extraVertexStreams": 168,
+        "m_grassFileName": 264,
+        "m_infoOverlays": 24,
+        "m_layerNames": 192,
+        "m_materialOverrides": 144,
+        "m_nodeLightingInfo": 272,
+        "m_overlayLayerIndices": 240,
+        "m_sceneObjectLayerIndices": 216,
+        "m_sceneObjects": 0,
+        "m_visClusterMembership": 48
+    },
+    "World_t": {
+        "m_builderParams": 0,
+        "m_entityLumps": 104,
+        "m_worldLightingInfo": 56,
+        "m_worldNodes": 32
+    }
+}

include/base/safe_handle.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#define _AMD64_
+
+#include <memory>
+
+#include <handleapi.h>
+
+namespace base {
+    namespace detail {
+        struct HandleDisposer {
+            using pointer = HANDLE;
+
+            void operator()(const HANDLE handle) const noexcept {
+                if (handle != nullptr && handle != INVALID_HANDLE_VALUE)
+                    CloseHandle(handle);
+            }
+        };
+    }
+
+    using SafeHandle = std::unique_ptr<HANDLE, detail::HandleDisposer>;
+}

include/process.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <cstdint>
+#include <optional>
+#include <string_view>
+
+namespace process {
+    bool attach(std::string_view process_name);
+
+    [[nodiscard]] std::optional<std::uintptr_t> find_pattern(std::string_view module_name, std::string_view pattern) noexcept;
+
+    [[nodiscard]] std::optional<std::uintptr_t> get_module_base(std::string_view module_name) noexcept;
+
+    [[nodiscard]] std::optional<std::uintptr_t> resolve_rip_relative_address(std::uintptr_t address) noexcept;
+
+    bool read_memory(std::uintptr_t address, void* buffer, std::size_t size) noexcept;
+
+    bool write_memory(std::uintptr_t address, const void* buffer, std::size_t size) noexcept;
+
+    std::string read_string(std::uintptr_t address, std::size_t length) noexcept;
+
+    template <typename T>
+    T read_memory(const std::uintptr_t address) noexcept {
+        T buffer = {};
+
+        read_memory(address, &buffer, sizeof(T));
+
+        return buffer;
+    }
+
+    template <typename T>
+    bool write_memory(const std::uintptr_t address, const T& buffer) noexcept {
+        return write_memory(address, &buffer, sizeof(T));
+    }
+}

include/sdk/c_schema_class_field_data.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+namespace sdk {
+    class SchemaClassFieldData_t {
+    public:
+        [[nodiscard]] std::string get_name() const noexcept;
+
+        [[nodiscard]] std::uint16_t get_offset() const noexcept;
+    };
+}

include/sdk/c_schema_class_info.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace sdk {
+    class SchemaClassFieldData_t;
+
+    class CSchemaClassInfo {
+    public:
+        [[nodiscard]] std::uint16_t get_fields_count() const noexcept;
+
+        [[nodiscard]] std::vector<SchemaClassFieldData_t*> get_fields() const noexcept;
+    };
+}

include/sdk/c_schema_system.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <vector>
+
+namespace sdk {
+    class CSchemaSystemTypeScope;
+
+    class CSchemaSystem {
+    public:
+        static CSchemaSystem* get() noexcept;
+
+        [[nodiscard]] std::vector<CSchemaSystemTypeScope*> get_type_scopes() const noexcept;
+    };
+}

include/sdk/c_schema_system_type_scope.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace sdk {
+    class CSchemaClassInfo;
+    class CSchemaType_DeclaredClass;
+
+    class CSchemaSystemTypeScope {
+    public:
+        [[nodiscard]] CSchemaClassInfo* find_declared_class(std::string_view class_name) const noexcept;
+
+        [[nodiscard]] std::vector<CSchemaType_DeclaredClass*> get_declared_classes() const noexcept;
+
+        [[nodiscard]] std::string get_module_name() const noexcept;
+    };
+}

include/sdk/c_schema_type_declared_class.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+namespace sdk {
+    class CSchemaType_DeclaredClass {
+    public:
+        [[nodiscard]] std::string get_class_name() const noexcept;
+    };
+}

include/sdk/sdk.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "process.hpp"
+
+#include "c_schema_class_field_data.hpp"
+#include "c_schema_class_info.hpp"
+#include "c_schema_system.hpp"
+#include "c_schema_system_type_scope.hpp"
+#include "c_schema_type_declared_class.hpp"

include/utility/murmur_hash.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <cstdint>
+
+namespace utility {
+    std::uint32_t murmur_hash2(const void* key, std::uint32_t length, std::uint32_t seed);
+}

src/main.cpp

@@ -0,0 +1,108 @@
+#include "sdk/sdk.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <spdlog/spdlog.h>
+
+#include <filesystem>
+#include <fstream>
+
+void generate_header_for_type_scope(const sdk::CSchemaSystemTypeScope* type_scope) {
+    if (type_scope == nullptr)
+        return;
+
+    const std::string output_file_name = std::format("generated/{}.hpp", type_scope->get_module_name());
+
+    std::fstream output(output_file_name, std::ios::out);
+
+    output << "#pragma once\n\n#include <cstddef>\n\n";
+
+    for (const sdk::CSchemaType_DeclaredClass* declared_class : type_scope->get_declared_classes()) {
+        if (declared_class == nullptr)
+            continue;
+
+        const sdk::CSchemaClassInfo* class_info = type_scope->find_declared_class(declared_class->get_class_name());
+
+        if (class_info == nullptr)
+            continue;
+
+        output << "namespace " << declared_class->get_class_name() << " {\n";
+
+        for (const sdk::SchemaClassFieldData_t* field : class_info->get_fields()) {
+            if (field == nullptr)
+                continue;
+
+            output << "    constexpr std::ptrdiff_t " << field->get_name() << " = 0x" << std::hex << field->get_offset() << ";\n";
+        }
+
+        output << "}\n\n";
+
+        spdlog::info("    > generated header file for {}", declared_class->get_class_name().c_str());
+    }
+}
+
+void generate_json_for_type_scope(const sdk::CSchemaSystemTypeScope* type_scope) {
+    if (type_scope == nullptr)
+        return;
+
+    const std::string output_file_name = std::format("generated/{}.json", type_scope->get_module_name());
+
+    std::fstream output(output_file_name, std::ios::out);
+
+    nlohmann::json json;
+
+    for (const sdk::CSchemaType_DeclaredClass* declared_class : type_scope->get_declared_classes()) {
+        if (declared_class == nullptr)
+            continue;
+
+        const sdk::CSchemaClassInfo* class_info = type_scope->find_declared_class(declared_class->get_class_name());
+
+        if (class_info == nullptr)
+            continue;
+
+        for (const sdk::SchemaClassFieldData_t* field : class_info->get_fields()) {
+            if (field == nullptr)
+                continue;
+
+            json[declared_class->get_class_name()][field->get_name()] = field->get_offset();
+        }
+
+        spdlog::info("    > generated json file for {}", declared_class->get_class_name().c_str());
+    }
+
+    output << json.dump(4);
+}
+
+int main() {
+    if (!std::filesystem::exists("generated"))
+        std::filesystem::create_directory("generated");
+
+    if (!process::attach("cs2.exe")) {
+        spdlog::error("failed to attach to process.");
+
+        return 1;
+    }
+
+    spdlog::info("attached to process!");
+
+    const auto schema_system = sdk::CSchemaSystem::get();
+
+    if (schema_system == nullptr) {
+        spdlog::error("failed to get schema system.");
+
+        return 1;
+    }
+
+    spdlog::info("schema system: {:#x}", reinterpret_cast<std::uint64_t>(schema_system));
+
+    for (const sdk::CSchemaSystemTypeScope* type_scope : schema_system->get_type_scopes()) {
+        spdlog::info("generating files for {}...", type_scope->get_module_name().c_str());
+
+        generate_header_for_type_scope(type_scope);
+        generate_json_for_type_scope(type_scope);
+    }
+
+    spdlog::info("done!");
+
+    return 0;
+}

src/process.cpp

@@ -0,0 +1,164 @@
+#include "process.hpp"
+#include "base/safe_handle.hpp"
+
+#include <charconv>
+#include <stdexcept>
+#include <vector>
+
+#include <Windows.h>
+#include <TlHelp32.h>
+
+namespace process {
+    std::uint32_t process_id = 0;
+
+    base::SafeHandle process_handle;
+
+    namespace detail {
+        std::optional<std::uint32_t> get_process_id_by_name(const std::string_view process_name) noexcept {
+            const base::SafeHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0));
+
+            if (snapshot.get() == INVALID_HANDLE_VALUE)
+                return std::nullopt;
+
+            PROCESSENTRY32 process_entry = {};
+
+            process_entry.dwSize = sizeof(PROCESSENTRY32);
+
+            for (Process32First(snapshot.get(), &process_entry); Process32Next(snapshot.get(), &process_entry);) {
+                if (std::string_view(process_entry.szExeFile) == process_name)
+                    return process_entry.th32ProcessID;
+            }
+
+            return std::nullopt;
+        }
+    }
+
+    bool attach(const std::string_view process_name) {
+        process_id = detail::get_process_id_by_name(process_name).value_or(0);
+
+        if (process_id == 0)
+            return false;
+
+        process_handle = base::SafeHandle(OpenProcess(PROCESS_ALL_ACCESS, 0, process_id));
+
+        return process_handle.get() != nullptr;
+    }
+
+    std::optional<std::uintptr_t> find_pattern(const std::string_view module_name, const std::string_view pattern) noexcept {
+        constexpr auto pattern_to_bytes = [](const std::string_view pattern) -> std::vector<std::int32_t> {
+            std::vector<std::int32_t> bytes;
+
+            for (std::size_t i = 0; i < pattern.size(); ++i) {
+                if (pattern[i] == ' ')
+                    continue;
+
+                if (pattern[i] == '?') {
+                    bytes.push_back(-1);
+
+                    continue;
+                }
+
+                if (i + 1 < pattern.size()) {
+                    std::int32_t value = 0;
+
+                    if (const auto [ptr, ec] = std::from_chars(pattern.data() + i, pattern.data() + i + 2, value, 16); ec == std::errc())
+                        bytes.push_back(value);
+
+                    ++i;
+                }
+            }
+
+            return bytes;
+        };
+
+        const std::optional<std::uintptr_t> module_base = get_module_base(module_name);
+
+        if (!module_base.has_value())
+            return std::nullopt;
+
+        const auto headers = std::make_unique<std::uint8_t[]>(0x1000);
+
+        if (!read_memory(module_base.value(), headers.get(), 0x1000))
+            return std::nullopt;
+
+        const auto dos_header = reinterpret_cast<PIMAGE_DOS_HEADER>(headers.get());
+
+        if (dos_header->e_magic != IMAGE_DOS_SIGNATURE)
+            return std::nullopt;
+
+        const auto nt_headers = reinterpret_cast<PIMAGE_NT_HEADERS>(headers.get() + dos_header->e_lfanew);
+
+        if (nt_headers->Signature != IMAGE_NT_SIGNATURE)
+            return std::nullopt;
+
+        const std::uint32_t module_size = nt_headers->OptionalHeader.SizeOfImage;
+
+        const auto module_data = std::make_unique<std::uint8_t[]>(module_size);
+
+        if (!read_memory(module_base.value(), module_data.get(), module_size))
+            return std::nullopt;
+
+        const std::vector<std::int32_t> pattern_bytes = pattern_to_bytes(pattern);
+
+        for (std::size_t i = 0; i < module_size - pattern.size(); ++i) {
+            bool found = true;
+
+            for (std::size_t j = 0; j < pattern_bytes.size(); ++j) {
+                if (module_data[i + j] != pattern_bytes[j] && pattern_bytes[j] != -1) {
+                    found = false;
+
+                    break;
+                }
+            }
+
+            if (found)
+                return module_base.value() + i;
+        }
+
+        return std::nullopt;
+    }
+
+    std::optional<std::uintptr_t> get_module_base(const std::string_view module_name) noexcept {
+        const base::SafeHandle snapshot(CreateToolhelp32Snapshot(TH32CS_SNAPMODULE | TH32CS_SNAPMODULE32, process_id));
+
+        if (snapshot.get() == INVALID_HANDLE_VALUE)
+            return std::nullopt;
+
+        MODULEENTRY32 module_entry = {};
+
+        module_entry.dwSize = sizeof(MODULEENTRY32);
+
+        for (Module32First(snapshot.get(), &module_entry); Module32Next(snapshot.get(), &module_entry);) {
+            if (_stricmp(module_entry.szModule, module_name.data()) == 0)
+                return reinterpret_cast<std::uintptr_t>(module_entry.modBaseAddr);
+        }
+
+        return std::nullopt;
+    }
+
+    std::optional<std::uintptr_t> resolve_rip_relative_address(const std::uintptr_t address) noexcept {
+        const auto displacement = read_memory<std::int32_t>(address + 0x3);
+
+        return address + displacement + 0x7;
+    }
+
+    bool read_memory(const std::uintptr_t address, void* buffer, const std::size_t size) noexcept {
+        return ReadProcessMemory(process_handle.get(), reinterpret_cast<LPCVOID>(address), buffer, size, nullptr);
+    }
+
+    bool write_memory(const std::uintptr_t address, const void* buffer, const std::size_t size) noexcept {
+        return WriteProcessMemory(process_handle.get(), reinterpret_cast<LPVOID>(address), buffer, size, nullptr);
+    }
+
+    std::string read_string(const std::uintptr_t address, const std::size_t length) noexcept {
+        std::vector<char> buffer(length);
+
+        if (!read_memory(address, buffer.data(), length))
+            return {};
+
+        if (const auto it = std::ranges::find(buffer, '\0'); it != buffer.end())
+            buffer.resize(std::distance(buffer.begin(), it));
+
+        return { buffer.begin(), buffer.end() };
+    }
+}

src/sdk/c_schema_class_field_data.cpp

@@ -0,0 +1,11 @@
+#include "sdk/sdk.hpp"
+
+namespace sdk {
+    std::string SchemaClassFieldData_t::get_name() const noexcept {
+        return process::read_string(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this)), 64);
+    }
+
+    std::uint16_t SchemaClassFieldData_t::get_offset() const noexcept {
+        return process::read_memory<std::uint16_t>(reinterpret_cast<std::uint64_t>(this) + 0x10);
+    }
+}

src/sdk/c_schema_class_info.cpp

@@ -0,0 +1,22 @@
+#include "sdk/sdk.hpp"
+
+namespace sdk {
+    std::uint16_t CSchemaClassInfo::get_fields_count() const noexcept {
+        return process::read_memory<std::uint16_t>(reinterpret_cast<std::uint64_t>(this) + 0x1C);
+    }
+
+    std::vector<SchemaClassFieldData_t*> CSchemaClassInfo::get_fields() const noexcept {
+        std::vector<SchemaClassFieldData_t*> fields;
+
+        for (std::size_t i = 0; i < get_fields_count(); ++i) {
+            const auto field = reinterpret_cast<SchemaClassFieldData_t*>(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x28) + (i * 0x20));
+
+            if (field == nullptr)
+                continue;
+
+            fields.push_back(field);
+        }
+
+        return fields;
+    }
+}

src/sdk/c_schema_system.cpp

@@ -0,0 +1,28 @@
+#include "sdk/c_schema_system.hpp"
+#include "process.hpp"
+
+namespace sdk {
+    CSchemaSystem* CSchemaSystem::get() noexcept {
+        std::optional<std::uintptr_t> address = process::find_pattern("schemasystem.dll", "48 8D 0D ? ? ? ? E9 ? ? ? ? CC CC CC CC 48 8D 0D ? ? ? ? E9 ? ? ? ? CC CC CC CC 48 83 EC 28");
+
+        if (!address.has_value())
+            return nullptr;
+
+        address = process::resolve_rip_relative_address(address.value());
+
+        if (!address.has_value())
+            return nullptr;
+
+        return reinterpret_cast<CSchemaSystem*>(address.value());
+    }
+
+    std::vector<CSchemaSystemTypeScope*> CSchemaSystem::get_type_scopes() const noexcept {
+        std::vector<CSchemaSystemTypeScope*> type_scopes;
+
+        type_scopes.resize(process::read_memory<std::uint32_t>(reinterpret_cast<std::uint64_t>(this) + 0x190));
+
+        process::read_memory(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x198), type_scopes.data(), type_scopes.size() * sizeof(std::uint64_t));
+
+        return type_scopes;
+    }
+}

src/sdk/c_schema_system_type_scope.cpp

@@ -0,0 +1,97 @@
+#include "sdk/sdk.hpp"
+#include "utility/murmur_hash.hpp"
+
+namespace sdk {
+    CSchemaClassInfo* CSchemaSystemTypeScope::find_declared_class(const std::string_view class_name) const noexcept {
+        const std::uint32_t hash = utility::murmur_hash2(class_name.data(), class_name.length(), 0xBAADFEED);
+
+        const std::int32_t hash_transform1 = static_cast<std::uint8_t>(hash >> 0x10) - 0x2D6 + 0x21 * (0x21 * static_cast<std::uint8_t>(hash) + static_cast<std::uint8_t>(hash >> 0x8));
+        const std::int32_t hash_transform2 = 0x21 * hash_transform1 + static_cast<std::uint8_t>(hash >> 0x18);
+
+        const auto hash_part = static_cast<std::uint32_t>(static_cast<std::uint8_t>(hash >> 0x18));
+
+        const std::int32_t hash_transform4 = (hash_transform2 ^ (hash_transform2 >> 0x10)) ^ (static_cast<std::uint16_t>(hash_transform2 ^ (hash_part >> 0x10)) >> 0x8);
+
+        const auto get_class_info = [&](const std::uint64_t address) -> CSchemaClassInfo* {
+            const std::uint64_t class_info_address = address + 0x558 + static_cast<std::uint64_t>(0x28) * static_cast<std::uint8_t>(hash_transform4);
+
+            const auto initial_address = process::read_memory<std::uint64_t>(class_info_address + 0x58);
+
+            std::uint64_t class_address = initial_address;
+
+            if (initial_address != 0) {
+                while (process::read_memory<std::uint32_t>(class_address) != hash) {
+                    class_address = process::read_memory<std::uint64_t>(class_address + 0x8);
+
+                    if (class_address == 0)
+                        break;
+                }
+            }
+
+            if (class_address == 0) {
+                const auto secondary_address = process::read_memory<std::uint64_t>(class_info_address + 0x60);
+
+                std::uint64_t final_address = 0;
+
+                if (secondary_address != 0 && secondary_address != initial_address) {
+                    auto current_address = process::read_memory<std::uint64_t>(class_info_address + 0x60);
+
+                    const auto starting_address = process::read_memory<std::uint64_t>(class_info_address + 0x58);
+
+                    if (current_address != starting_address) {
+                        while (process::read_memory<std::uint32_t>(current_address) != hash) {
+                            current_address = process::read_memory<std::uint64_t>(current_address + 0x8);
+
+                            if (current_address == starting_address)
+                                break;
+                        }
+
+                        final_address = current_address;
+                    }
+                }
+
+                class_address = final_address;
+            }
+
+            return reinterpret_cast<CSchemaClassInfo*>(class_address);
+        };
+
+        const CSchemaClassInfo* class_info = get_class_info(reinterpret_cast<std::uint64_t>(this));
+
+        if (class_info != nullptr)
+            return reinterpret_cast<CSchemaClassInfo*>(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(class_info) + 0x10));
+
+        const auto secondary_class_info = process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x108);
+
+        return secondary_class_info != 0 ? reinterpret_cast<CSchemaClassInfo*>(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(get_class_info(secondary_class_info)) + 0x10)) : nullptr;
+    }
+
+    std::vector<CSchemaType_DeclaredClass*> CSchemaSystemTypeScope::get_declared_classes() const noexcept {
+        std::vector<CSchemaType_DeclaredClass*> classes;
+
+        const std::uint64_t base = reinterpret_cast<std::uint64_t>(this) + 0x558;
+
+        const auto block_size = process::read_memory<std::uint32_t>(base + 0x4);
+        const auto count = process::read_memory<std::uint32_t>(base + 0x10);
+        const auto unallocated_data = process::read_memory<std::uint64_t>(base + 0x18 + 0x18);
+
+        std::int32_t index = 0;
+
+        for (std::uint64_t element = unallocated_data; element; element = process::read_memory<std::uint64_t>(element)) {
+            for (std::int32_t i = 0; i < block_size && i != count; ++i) {
+                classes.push_back(reinterpret_cast<CSchemaType_DeclaredClass*>(process::read_memory<std::uint64_t>(element + 0x20 + (i * 0x18))));
+
+                ++index;
+
+                if (index >= count)
+                    break;
+            }
+        }
+
+        return classes;
+    }
+
+    std::string CSchemaSystemTypeScope::get_module_name() const noexcept {
+        return process::read_string(reinterpret_cast<std::uint64_t>(this) + 0x8, 256);
+    }
+}

src/sdk/c_schema_type_declared_class.cpp

@@ -0,0 +1,7 @@
+#include "sdk/sdk.hpp"
+
+namespace sdk {
+    std::string CSchemaType_DeclaredClass::get_class_name() const noexcept {
+        return process::read_string(process::read_memory<std::uint64_t>(reinterpret_cast<std::uint64_t>(this) + 0x8), 64);
+    }
+}

src/utility/murmur_hash.cpp

@@ -0,0 +1,53 @@
+#include "utility/murmur_hash.hpp"
+
+namespace utility {
+    std::uint32_t murmur_hash2(const void* key, std::uint32_t length, const std::uint32_t seed) {
+        constexpr auto get_block = [](const std::uint32_t* ptr) -> std::uint32_t {
+            const auto bytes = reinterpret_cast<const std::uint8_t*>(ptr);
+
+            return static_cast<std::uint32_t>(bytes[0]) | static_cast<std::uint32_t>(bytes[1]) << 0x8 | static_cast<std::uint32_t>(bytes[2]) << 0x10 | static_cast<std::uint32_t>(bytes[3]) << 0x18;
+        };
+
+        constexpr std::uint32_t HASH_CONSTANT = 0x5BD1E995;
+
+        std::uint32_t hash = seed ^ length;
+
+        auto data = static_cast<const std::uint8_t*>(key);
+
+        while (length >= 4) {
+            std::uint32_t block = get_block(reinterpret_cast<const std::uint32_t*>(data));
+
+            block *= HASH_CONSTANT;
+            block ^= block >> 0x18;
+            block *= HASH_CONSTANT;
+
+            hash *= HASH_CONSTANT;
+            hash ^= block;
+
+            data += 0x4;
+            length -= 0x4;
+        }
+
+        switch (length) {
+            case 3:
+                hash ^= data[2] << 0x10;
+
+            case 2:
+                hash ^= data[1] << 0x8;
+
+            case 1: {
+                hash ^= data[0];
+                hash *= HASH_CONSTANT;
+            }
+
+            default:
+                break;
+        }
+
+        hash ^= hash >> 0xD;
+        hash *= HASH_CONSTANT;
+        hash ^= hash >> 0xF;
+
+        return hash;
+    }
+}

vendor/CMakeLists.txt

@@ -0,0 +1,4 @@
+cmake_minimum_required(VERSION 3.26)
+
+add_subdirectory(nlohmann_json)
+add_subdirectory(spdlog)

vendor/nlohmann_json

@@ -0,0 +1 @@
+Subproject commit 836b7beca4b62e2a99465edef44066b7401fd704

vendor/spdlog

@@ -0,0 +1 @@
+Subproject commit 3aceda041b2bfbccaf14d5c83eda16fc67bea364