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,5 @@
+.idea/
+.vs/
+build/
+CMakeSettings.json
+out/

CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.26)
+
+project(cs2-offset-dumper)
+
+set(CMAKE_CXX_STANDARD 20)
+
+add_compile_definitions(WIN32_LEAN_AND_MEAN)
+
+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_include_directories(${PROJECT_NAME} PRIVATE include)

README.md

@@ -0,0 +1 @@
+# cs2-offset-dumper

classes/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;
+}
+

classes/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;
+}
+

classes/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;
+}
+

classes/meshsystem.dll.hpp

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

classes/networksystem.dll.hpp

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

classes/panorama.dll.hpp

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

classes/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 {
+}
+

classes/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;
+}
+

classes/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;
+}
+

classes/scenefilecache.dll.hpp

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

classes/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 {
+}
+

classes/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;
+}
+

classes/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;
+}
+

classes/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;
+}
+

classes/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;
+}
+

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,34 @@
+#pragma once
+
+#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,71 @@
+#include "sdk/sdk.hpp"
+
+#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("classes/{}.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";
+
+        printf_s("    -> generated header for %s!\n", declared_class->get_class_name().c_str());
+    }
+}
+
+int main() {
+    if (!std::filesystem::exists("classes"))
+        std::filesystem::create_directory("classes");
+
+    if (!process::attach("cs2.exe")) {
+        printf_s("[-] failed to attach to process.\n");
+
+        return 1;
+    }
+
+    printf_s("[+] attached to process!\n");
+
+    const auto schema_system = sdk::CSchemaSystem::get();
+
+    if (schema_system == nullptr) {
+        printf_s("[-] failed to get schema system.\n");
+
+        return 1;
+    }
+
+    printf_s("[+] schema system: 0x%llX\n", reinterpret_cast<std::uint64_t>(schema_system));
+
+    for (const sdk::CSchemaSystemTypeScope* type_scope : schema_system->get_type_scopes()) {
+        printf_s("[+] generating headers for %s...\n", type_scope->get_module_name().c_str());
+
+        generate_header_for_type_scope(type_scope);
+    }
+
+    printf_s("[+] done!\n");
+
+    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 0;
+        }
+    }
+
+    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;
+    }
+}