hxuanyu
/
cs2-dumper
mirror of https://github.com/a2x/cs2-dumper.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add python file builder

This commit is contained in:
a2x 2023-10-17 12:06:23 +10:00
parent c55bdf15a2
commit 0a86db6b40
86 changed files with 17670 additions and 436 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Cargo.toml
View File

@ -1,6 +1,6 @@
[package]
name = "cs2-dumper"
version = "1.1.1"
version = "1.1.2"
authors = ["a2x"]
edition = "2021"
readme = "README.md"
@ -10,6 +10,7 @@ license = "MIT"
[dependencies]
chrono = "0.4"
clap = { version = "4.4", features = ["derive"] }
convert_case = "0.6"
lazy_static = "1.4"
log = "0.4"
regex = "1.9"

2
generated/animationsystem.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.539445700 UTC
* 2023-10-17 02:04:49.867815600 UTC
*/
public static class AimMatrixOpFixedSettings_t {

10
generated/animationsystem.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:49.844204800 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.515770200 UTC
*/
namespace AimMatrixOpFixedSettings_t {
constexpr std::ptrdiff_t m_attachment = 0x0; // CAnimAttachment
constexpr std::ptrdiff_t m_damping = 0x80; // CAnimInputDamping

2189
generated/animationsystem.dll.py Normal file
View File

File diff suppressed because it is too large Load Diff

6
generated/animationsystem.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.563817600 UTC
* 2023-10-17 02:04:49.915588500 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod AimMatrixOpFixedSettings_t {
pub const m_attachment: usize = 0x0; // CAnimAttachment
pub const m_damping: usize = 0x80; // CAnimInputDamping

2
generated/client.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.884630900 UTC
* 2023-10-17 02:04:51.383225900 UTC
*/
public static class ActiveModelConfig_t {

10
generated/client.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:51.341476500 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.843400800 UTC
*/
namespace ActiveModelConfig_t {
constexpr std::ptrdiff_t m_Handle = 0x28; // ModelConfigHandle_t
constexpr std::ptrdiff_t m_Name = 0x30; // CUtlSymbolLarge

3439
generated/client.dll.py Normal file
View File

File diff suppressed because it is too large Load Diff

6
generated/client.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.927109500 UTC
* 2023-10-17 02:04:51.467219600 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod ActiveModelConfig_t {
pub const m_Handle: usize = 0x28; // ModelConfigHandle_t
pub const m_Name: usize = 0x30; // CUtlSymbolLarge

2
generated/engine2.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.375847600 UTC
* 2023-10-17 02:04:49.696799500 UTC
*/
public static class CEntityComponentHelper {

10
generated/engine2.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:49.694823800 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.373798700 UTC
*/
namespace CEntityComponentHelper {
constexpr std::ptrdiff_t m_flags = 0x8; // uint32_t
constexpr std::ptrdiff_t m_pInfo = 0x10; // EntComponentInfo_t*

149
generated/engine2.dll.py Normal file
View File

@ -0,0 +1,149 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:49.699141900 UTC
'''
class CEntityComponentHelper:
m_flags = 0x8 # uint32_t
m_pInfo = 0x10 # EntComponentInfo_t*
m_nPriority = 0x18 # int32_t
m_pNext = 0x20 # CEntityComponentHelper*
class CEntityIOOutput:
m_Value = 0x18 # CVariantBase<CVariantDefaultAllocator>
class CEntityIdentity:
m_nameStringableIndex = 0x14 # int32_t
m_name = 0x18 # CUtlSymbolLarge
m_designerName = 0x20 # CUtlSymbolLarge
m_flags = 0x30 # uint32_t
m_worldGroupId = 0x38 # WorldGroupId_t
m_fDataObjectTypes = 0x3C # uint32_t
m_PathIndex = 0x40 # ChangeAccessorFieldPathIndex_t
m_pPrev = 0x58 # CEntityIdentity*
m_pNext = 0x60 # CEntityIdentity*
m_pPrevByClass = 0x68 # CEntityIdentity*
m_pNextByClass = 0x70 # CEntityIdentity*
class CEntityInstance:
m_iszPrivateVScripts = 0x8 # CUtlSymbolLarge
m_pEntity = 0x10 # CEntityIdentity*
m_CScriptComponent = 0x28 # CScriptComponent*
class CNetworkVarChainer:
m_PathIndex = 0x20 # ChangeAccessorFieldPathIndex_t
class CScriptComponent:
m_scriptClassName = 0x30 # CUtlSymbolLarge
class EngineLoopState_t:
m_nPlatWindowWidth = 0x18 # int32_t
m_nPlatWindowHeight = 0x1C # int32_t
m_nRenderWidth = 0x20 # int32_t
m_nRenderHeight = 0x24 # int32_t
class EntComponentInfo_t:
m_pName = 0x0 # char*
m_pCPPClassname = 0x8 # char*
m_pNetworkDataReferencedDescription = 0x10 # char*
m_pNetworkDataReferencedPtrPropDescription = 0x18 # char*
m_nRuntimeIndex = 0x20 # int32_t
m_nFlags = 0x24 # uint32_t
m_pBaseClassComponentHelper = 0x60 # CEntityComponentHelper*
class EventAdvanceTick_t:
m_nCurrentTick = 0x30 # int32_t
m_nCurrentTickThisFrame = 0x34 # int32_t
m_nTotalTicksThisFrame = 0x38 # int32_t
m_nTotalTicks = 0x3C # int32_t
class EventAppShutdown_t:
m_nDummy0 = 0x0 # int32_t
class EventClientFrameSimulate_t:
m_LoopState = 0x0 # EngineLoopState_t
m_flRealTime = 0x28 # float
m_flFrameTime = 0x2C # float
class EventClientOutput_t:
m_LoopState = 0x0 # EngineLoopState_t
m_flRenderTime = 0x28 # float
m_flRealTime = 0x2C # float
m_flRenderFrameTimeUnbounded = 0x30 # float
m_bRenderOnly = 0x34 # bool
class EventClientPollInput_t:
m_LoopState = 0x0 # EngineLoopState_t
m_flRealTime = 0x28 # float
class EventClientPollNetworking_t:
m_nTickCount = 0x0 # int32_t
class EventClientPostOutput_t:
m_LoopState = 0x0 # EngineLoopState_t
m_flRenderTime = 0x28 # double
m_flRenderFrameTime = 0x30 # float
m_flRenderFrameTimeUnbounded = 0x34 # float
m_bRenderOnly = 0x38 # bool
class EventClientPreOutput_t:
m_LoopState = 0x0 # EngineLoopState_t
m_flRenderTime = 0x28 # double
m_flRenderFrameTime = 0x30 # double
m_flRenderFrameTimeUnbounded = 0x38 # double
m_flRealTime = 0x40 # float
m_bRenderOnly = 0x44 # bool
class EventClientProcessGameInput_t:
m_LoopState = 0x0 # EngineLoopState_t
m_flRealTime = 0x28 # float
m_flFrameTime = 0x2C # float
class EventClientProcessInput_t:
m_LoopState = 0x0 # EngineLoopState_t
m_flRealTime = 0x28 # float
class EventClientSceneSystemThreadStateChange_t:
m_bThreadsActive = 0x0 # bool
class EventClientSendInput_t:
m_bFinalClientCommandTick = 0x0 # bool
m_nAdditionalClientCommandsToCreate = 0x4 # int32_t
class EventFrameBoundary_t:
m_flFrameTime = 0x0 # float
class EventPostAdvanceTick_t:
m_nCurrentTick = 0x30 # int32_t
m_nCurrentTickThisFrame = 0x34 # int32_t
m_nTotalTicksThisFrame = 0x38 # int32_t
m_nTotalTicks = 0x3C # int32_t
class EventPostDataUpdate_t:
m_nCount = 0x0 # int32_t
class EventPreDataUpdate_t:
m_nCount = 0x0 # int32_t
class EventProfileStorageAvailable_t:
m_nSplitScreenSlot = 0x0 # CSplitScreenSlot
class EventSetTime_t:
m_LoopState = 0x0 # EngineLoopState_t
m_nClientOutputFrames = 0x28 # int32_t
m_flRealTime = 0x30 # double
m_flRenderTime = 0x38 # double
m_flRenderFrameTime = 0x40 # double
m_flRenderFrameTimeUnbounded = 0x48 # double
m_flRenderFrameTimeUnscaled = 0x50 # double
m_flTickRemainder = 0x58 # double
class EventSimpleLoopFrameUpdate_t:
m_LoopState = 0x0 # EngineLoopState_t
m_flRealTime = 0x28 # float
m_flFrameTime = 0x2C # float
class EventSimulate_t:
m_LoopState = 0x0 # EngineLoopState_t
m_bFirstTick = 0x28 # bool
m_bLastTick = 0x29 # bool

6
generated/engine2.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.378512600 UTC
* 2023-10-17 02:04:49.701434300 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod CEntityComponentHelper {
pub const m_flags: usize = 0x8; // uint32_t
pub const m_pInfo: usize = 0x10; // EntComponentInfo_t*

2
generated/host.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.969358100 UTC
* 2023-10-17 02:04:51.510044200 UTC
*/
public static class CAnimScriptBase {

10
generated/host.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:51.509650200 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.968868800 UTC
*/
namespace CAnimScriptBase {
constexpr std::ptrdiff_t m_bIsValid = 0x8; // bool
}

10
generated/host.dll.py Normal file
View File

@ -0,0 +1,10 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:51.510616600 UTC
'''
class CAnimScriptBase:
m_bIsValid = 0x8 # bool
class EmptyTestScript:
m_hTest = 0x10 # CAnimScriptParam<float>

6
generated/host.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.970197200 UTC
* 2023-10-17 02:04:51.511077100 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod CAnimScriptBase {
pub const m_bIsValid: usize = 0x8; // bool
}

72
generated/interfaces.cs
View File

@ -1,14 +1,14 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:33.222923700 UTC
* 2023-10-17 02:04:51.720428600 UTC
*/
public static class animationsystem_dll {
public static class AnimationsystemDll {
public const nint AnimationSystemUtils_001 = 0x64670;
public const nint AnimationSystem_001 = 0x5F1D0;
}
public static class client_dll {
public static class ClientDll {
public const nint LegacyGameUI001 = 0x88F360;
public const nint Source2ClientUI001 = 0x87DE00;
public const nint Source2ClientPrediction001 = 0x79B660;
@ -19,7 +19,7 @@ public static class client_dll {
public const nint Source2ClientConfig001 = 0x4721F0;
}
public static class engine2_dll {
public static class Engine2Dll {
public const nint SimpleEngineLoopService_001 = 0x1E1C70;
public const nint ClientServerEngineLoopService_001 = 0x1D7940;
public const nint KeyValueCache001 = 0x1D3F80;
@ -54,12 +54,12 @@ public static class engine2_dll {
public const nint Source2EngineToClient001 = 0x5A1B0;
}
public static class filesystem_stdio_dll {
public static class FilesystemStdioDll {
public const nint VAsyncFileSystem2_001 = 0x66D30;
public const nint VFileSystem017 = 0x66D20;
}
public static class host_dll {
public static class HostDll {
public const nint Source2Host001 = 0x18E10;
public const nint SinglePlayerSharedMemory001 = 0x18A90;
public const nint SaveRestoreDataVersion001 = 0x18A80;
@ -70,25 +70,25 @@ public static class host_dll {
public const nint DebugDrawQueueManager001 = 0x11710;
}
public static class imemanager_dll {
public static class ImemanagerDll {
public const nint IMEManager001 = 0xC470;
}
public static class inputsystem_dll {
public static class InputsystemDll {
public const nint InputSystemVersion001 = 0x28D0;
public const nint InputStackSystemVersion001 = 0x16F0;
}
public static class localize_dll {
public static class LocalizeDll {
public const nint Localize_001 = 0x3830;
}
public static class matchmaking_dll {
public static class MatchmakingDll {
public const nint GameTypes001 = 0x50270;
public const nint MATCHFRAMEWORK_001 = 0x101030;
}
public static class materialsystem2_dll {
public static class Materialsystem2Dll {
public const nint MaterialUtils_001 = 0x4DB80;
public const nint TextLayout_001 = 0x4A2D0;
public const nint PostProcessingSystem_001 = 0x42A50;
@ -96,67 +96,67 @@ public static class materialsystem2_dll {
public const nint VMaterialSystem2_001 = 0x25EB0;
}
public static class meshsystem_dll {
public static class MeshsystemDll {
public const nint MeshSystem001 = 0x7270;
}
public static class navsystem_dll {
public static class NavsystemDll {
public const nint NavSystem001 = 0x76F0;
}
public static class networksystem_dll {
public static class NetworksystemDll {
public const nint SerializedEntitiesVersion001 = 0xD1A60;
public const nint NetworkSystemVersion001 = 0xBBF70;
public const nint NetworkMessagesVersion001 = 0x9C010;
public const nint FlattenedSerializersVersion001 = 0x7B890;
}
public static class panorama_dll {
public static class PanoramaDll {
public const nint PanoramaUIEngine001 = 0x57EE0;
}
public static class panorama_text_pango_dll {
public static class PanoramaTextPangoDll {
public const nint PanoramaTextServices001 = 0x4CBD0;
}
public static class panoramauiclient_dll {
public static class PanoramauiclientDll {
public const nint PanoramaUIClient001 = 0x12780;
}
public static class particles_dll {
public static class ParticlesDll {
public const nint ParticleSystemMgr003 = 0x52D20;
}
public static class pulse_system_dll {
public static class PulseSystemDll {
public const nint IPulseSystem_001 = 0x5B80;
}
public static class rendersystemdx11_dll {
public static class Rendersystemdx11Dll {
public const nint RenderUtils_001 = 0x52C90;
public const nint VRenderDeviceMgrBackdoor001 = 0x4A3A0;
public const nint RenderDeviceMgr001 = 0x4A390;
}
public static class resourcesystem_dll {
public static class ResourcesystemDll {
public const nint ResourceSystem013 = 0x10650;
}
public static class scenefilecache_dll {
public static class ScenefilecacheDll {
public const nint SceneFileCache002 = 0x68E0;
public const nint ResponseRulesCache001 = 0x3190;
}
public static class scenesystem_dll {
public static class ScenesystemDll {
public const nint SceneUtils_001 = 0x13D030;
public const nint SceneSystem_002 = 0xCAE10;
public const nint RenderingPipelines_001 = 0x8EED0;
}
public static class schemasystem_dll {
public static class SchemasystemDll {
public const nint SchemaSystem_001 = 0xA930;
}
public static class server_dll {
public static class ServerDll {
public const nint NavGameTest001 = 0xA2C470;
public const nint ServerToolsInfo_001 = 0x830DE0;
public const nint Source2GameClients001 = 0x830DF0;
@ -169,18 +169,18 @@ public static class server_dll {
public const nint Source2GameDirector001 = 0x13EAB0;
}
public static class soundsystem_dll {
public static class SoundsystemDll {
public const nint SoundOpSystem001 = 0x156160;
public const nint SoundOpSystemEdit001 = 0x8B540;
public const nint VMixEditTool001 = 0x71740;
public const nint SoundSystem001 = 0x46540;
}
public static class steamaudio_dll {
public static class SteamaudioDll {
public const nint SteamAudio001 = 0x12EE0;
}
public static class steamclient64_dll {
public static class Steamclient64Dll {
public const nint IVALIDATE001 = 0x833640;
public const nint CLIENTENGINE_INTERFACE_VERSION005 = 0x82F4C0;
public const nint SteamClient020 = 0x62CAF0;
@ -202,39 +202,39 @@ public static class steamclient64_dll {
public const nint p2pvoicesingleton002 = 0xD5840;
}
public static class tier0_dll {
public static class Tier0Dll {
public const nint VStringTokenSystem001 = 0x18C390;
public const nint TestScriptMgr001 = 0x13F6F0;
public const nint VProcessUtils002 = 0x12F870;
public const nint VEngineCvar007 = 0x61C50;
}
public static class v8system_dll {
public static class V8SystemDll {
public const nint Source2V8System001 = 0x1670;
}
public static class valve_avi_dll {
public static class ValveAviDll {
public const nint VAvi001 = 0x2F90;
}
public static class valve_wmf_dll {
public static class ValveWmfDll {
public const nint VMediaFoundation001 = 0x12D0;
}
public static class vphysics2_dll {
public static class Vphysics2Dll {
public const nint VPhysics2_Handle_Interface_001 = 0x5FA50;
public const nint VPhysics2_Interface_001 = 0x5B7F0;
}
public static class vscript_dll {
public static class VscriptDll {
public const nint VScriptManager010 = 0x31DA0;
}
public static class vstdlib_s64_dll {
public static class VstdlibS64Dll {
public const nint IVALIDATE001 = 0x24FF0;
public const nint VEngineCvar002 = 0x5750;
}
public static class worldrenderer_dll {
public static class WorldrendererDll {
public const nint WorldRendererMgr001 = 0x21530;
}

80
generated/interfaces.hpp
View File

@ -1,18 +1,18 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:51.718050700 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:33.220433600 UTC
*/
namespace animationsystem_dll {
namespace AnimationsystemDll {
constexpr std::ptrdiff_t AnimationSystemUtils_001 = 0x64670;
constexpr std::ptrdiff_t AnimationSystem_001 = 0x5F1D0;
}
namespace client_dll {
namespace ClientDll {
constexpr std::ptrdiff_t LegacyGameUI001 = 0x88F360;
constexpr std::ptrdiff_t Source2ClientUI001 = 0x87DE00;
constexpr std::ptrdiff_t Source2ClientPrediction001 = 0x79B660;
@ -23,7 +23,7 @@ namespace client_dll {
constexpr std::ptrdiff_t Source2ClientConfig001 = 0x4721F0;
}
namespace engine2_dll {
namespace Engine2Dll {
constexpr std::ptrdiff_t SimpleEngineLoopService_001 = 0x1E1C70;
constexpr std::ptrdiff_t ClientServerEngineLoopService_001 = 0x1D7940;
constexpr std::ptrdiff_t KeyValueCache001 = 0x1D3F80;
@ -58,12 +58,12 @@ namespace engine2_dll {
constexpr std::ptrdiff_t Source2EngineToClient001 = 0x5A1B0;
}
namespace filesystem_stdio_dll {
namespace FilesystemStdioDll {
constexpr std::ptrdiff_t VAsyncFileSystem2_001 = 0x66D30;
constexpr std::ptrdiff_t VFileSystem017 = 0x66D20;
}
namespace host_dll {
namespace HostDll {
constexpr std::ptrdiff_t Source2Host001 = 0x18E10;
constexpr std::ptrdiff_t SinglePlayerSharedMemory001 = 0x18A90;
constexpr std::ptrdiff_t SaveRestoreDataVersion001 = 0x18A80;
@ -74,25 +74,25 @@ namespace host_dll {
constexpr std::ptrdiff_t DebugDrawQueueManager001 = 0x11710;
}
namespace imemanager_dll {
namespace ImemanagerDll {
constexpr std::ptrdiff_t IMEManager001 = 0xC470;
}
namespace inputsystem_dll {
namespace InputsystemDll {
constexpr std::ptrdiff_t InputSystemVersion001 = 0x28D0;
constexpr std::ptrdiff_t InputStackSystemVersion001 = 0x16F0;
}
namespace localize_dll {
namespace LocalizeDll {
constexpr std::ptrdiff_t Localize_001 = 0x3830;
}
namespace matchmaking_dll {
namespace MatchmakingDll {
constexpr std::ptrdiff_t GameTypes001 = 0x50270;
constexpr std::ptrdiff_t MATCHFRAMEWORK_001 = 0x101030;
}
namespace materialsystem2_dll {
namespace Materialsystem2Dll {
constexpr std::ptrdiff_t MaterialUtils_001 = 0x4DB80;
constexpr std::ptrdiff_t TextLayout_001 = 0x4A2D0;
constexpr std::ptrdiff_t PostProcessingSystem_001 = 0x42A50;
@ -100,67 +100,67 @@ namespace materialsystem2_dll {
constexpr std::ptrdiff_t VMaterialSystem2_001 = 0x25EB0;
}
namespace meshsystem_dll {
namespace MeshsystemDll {
constexpr std::ptrdiff_t MeshSystem001 = 0x7270;
}
namespace navsystem_dll {
namespace NavsystemDll {
constexpr std::ptrdiff_t NavSystem001 = 0x76F0;
}
namespace networksystem_dll {
namespace NetworksystemDll {
constexpr std::ptrdiff_t SerializedEntitiesVersion001 = 0xD1A60;
constexpr std::ptrdiff_t NetworkSystemVersion001 = 0xBBF70;
constexpr std::ptrdiff_t NetworkMessagesVersion001 = 0x9C010;
constexpr std::ptrdiff_t FlattenedSerializersVersion001 = 0x7B890;
}
namespace panorama_dll {
namespace PanoramaDll {
constexpr std::ptrdiff_t PanoramaUIEngine001 = 0x57EE0;
}
namespace panorama_text_pango_dll {
namespace PanoramaTextPangoDll {
constexpr std::ptrdiff_t PanoramaTextServices001 = 0x4CBD0;
}
namespace panoramauiclient_dll {
namespace PanoramauiclientDll {
constexpr std::ptrdiff_t PanoramaUIClient001 = 0x12780;
}
namespace particles_dll {
namespace ParticlesDll {
constexpr std::ptrdiff_t ParticleSystemMgr003 = 0x52D20;
}
namespace pulse_system_dll {
namespace PulseSystemDll {
constexpr std::ptrdiff_t IPulseSystem_001 = 0x5B80;
}
namespace rendersystemdx11_dll {
namespace Rendersystemdx11Dll {
constexpr std::ptrdiff_t RenderUtils_001 = 0x52C90;
constexpr std::ptrdiff_t VRenderDeviceMgrBackdoor001 = 0x4A3A0;
constexpr std::ptrdiff_t RenderDeviceMgr001 = 0x4A390;
}
namespace resourcesystem_dll {
namespace ResourcesystemDll {
constexpr std::ptrdiff_t ResourceSystem013 = 0x10650;
}
namespace scenefilecache_dll {
namespace ScenefilecacheDll {
constexpr std::ptrdiff_t SceneFileCache002 = 0x68E0;
constexpr std::ptrdiff_t ResponseRulesCache001 = 0x3190;
}
namespace scenesystem_dll {
namespace ScenesystemDll {
constexpr std::ptrdiff_t SceneUtils_001 = 0x13D030;
constexpr std::ptrdiff_t SceneSystem_002 = 0xCAE10;
constexpr std::ptrdiff_t RenderingPipelines_001 = 0x8EED0;
}
namespace schemasystem_dll {
namespace SchemasystemDll {
constexpr std::ptrdiff_t SchemaSystem_001 = 0xA930;
}
namespace server_dll {
namespace ServerDll {
constexpr std::ptrdiff_t NavGameTest001 = 0xA2C470;
constexpr std::ptrdiff_t ServerToolsInfo_001 = 0x830DE0;
constexpr std::ptrdiff_t Source2GameClients001 = 0x830DF0;
@ -173,18 +173,18 @@ namespace server_dll {
constexpr std::ptrdiff_t Source2GameDirector001 = 0x13EAB0;
}
namespace soundsystem_dll {
namespace SoundsystemDll {
constexpr std::ptrdiff_t SoundOpSystem001 = 0x156160;
constexpr std::ptrdiff_t SoundOpSystemEdit001 = 0x8B540;
constexpr std::ptrdiff_t VMixEditTool001 = 0x71740;
constexpr std::ptrdiff_t SoundSystem001 = 0x46540;
}
namespace steamaudio_dll {
namespace SteamaudioDll {
constexpr std::ptrdiff_t SteamAudio001 = 0x12EE0;
}
namespace steamclient64_dll {
namespace Steamclient64Dll {
constexpr std::ptrdiff_t IVALIDATE001 = 0x833640;
constexpr std::ptrdiff_t CLIENTENGINE_INTERFACE_VERSION005 = 0x82F4C0;
constexpr std::ptrdiff_t SteamClient020 = 0x62CAF0;
@ -206,39 +206,39 @@ namespace steamclient64_dll {
constexpr std::ptrdiff_t p2pvoicesingleton002 = 0xD5840;
}
namespace tier0_dll {
namespace Tier0Dll {
constexpr std::ptrdiff_t VStringTokenSystem001 = 0x18C390;
constexpr std::ptrdiff_t TestScriptMgr001 = 0x13F6F0;
constexpr std::ptrdiff_t VProcessUtils002 = 0x12F870;
constexpr std::ptrdiff_t VEngineCvar007 = 0x61C50;
}
namespace v8system_dll {
namespace V8SystemDll {
constexpr std::ptrdiff_t Source2V8System001 = 0x1670;
}
namespace valve_avi_dll {
namespace ValveAviDll {
constexpr std::ptrdiff_t VAvi001 = 0x2F90;
}
namespace valve_wmf_dll {
namespace ValveWmfDll {
constexpr std::ptrdiff_t VMediaFoundation001 = 0x12D0;
}
namespace vphysics2_dll {
namespace Vphysics2Dll {
constexpr std::ptrdiff_t VPhysics2_Handle_Interface_001 = 0x5FA50;
constexpr std::ptrdiff_t VPhysics2_Interface_001 = 0x5B7F0;
}
namespace vscript_dll {
namespace VscriptDll {
constexpr std::ptrdiff_t VScriptManager010 = 0x31DA0;
}
namespace vstdlib_s64_dll {
namespace VstdlibS64Dll {
constexpr std::ptrdiff_t IVALIDATE001 = 0x24FF0;
constexpr std::ptrdiff_t VEngineCvar002 = 0x5750;
}
namespace worldrenderer_dll {
namespace WorldrendererDll {
constexpr std::ptrdiff_t WorldRendererMgr001 = 0x21530;
}

70
generated/interfaces.json
View File

@ -1,9 +1,9 @@
{
"animationsystem_dll": {
"AnimationsystemDll": {
"AnimationSystemUtils_001": 411248,
"AnimationSystem_001": 389584
},
"client_dll": {
"ClientDll": {
"ClientToolsInfo_001": 7501168,
"EmptyWorldService001_Client": 4764128,
"GameClientExports001": 7501184,
@ -13,7 +13,7 @@
"Source2ClientPrediction001": 7976544,
"Source2ClientUI001": 8904192
},
"engine2_dll": {
"Engine2Dll": {
"BenchmarkService001": 1476576,
"BugService001": 1482768,
"ClientServerEngineLoopService_001": 1931584,
@ -47,11 +47,11 @@
"VENGINE_GAMEUIFUNCS_VERSION005": 1139648,
"VProfService_001": 1796112
},
"filesystem_stdio_dll": {
"FilesystemStdioDll": {
"VAsyncFileSystem2_001": 421168,
"VFileSystem017": 421152
},
"host_dll": {
"HostDll": {
"DebugDrawQueueManager001": 71440,
"GameModelInfo001": 72896,
"GameSystem2HostHook": 73120,
@ -61,75 +61,75 @@
"SinglePlayerSharedMemory001": 101008,
"Source2Host001": 101904
},
"imemanager_dll": {
"ImemanagerDll": {
"IMEManager001": 50288
},
"inputsystem_dll": {
"InputsystemDll": {
"InputStackSystemVersion001": 5872,
"InputSystemVersion001": 10448
},
"localize_dll": {
"LocalizeDll": {
"Localize_001": 14384
},
"matchmaking_dll": {
"MatchmakingDll": {
"GameTypes001": 328304,
"MATCHFRAMEWORK_001": 1052720
},
"materialsystem2_dll": {
"Materialsystem2Dll": {
"FontManager_001": 227568,
"MaterialUtils_001": 318336,
"PostProcessingSystem_001": 272976,
"TextLayout_001": 303824,
"VMaterialSystem2_001": 155312
},
"meshsystem_dll": {
"MeshsystemDll": {
"MeshSystem001": 29296
},
"navsystem_dll": {
"NavsystemDll": {
"NavSystem001": 30448
},
"networksystem_dll": {
"NetworksystemDll": {
"FlattenedSerializersVersion001": 506000,
"NetworkMessagesVersion001": 638992,
"NetworkSystemVersion001": 769904,
"SerializedEntitiesVersion001": 858720
},
"panorama_dll": {
"PanoramaDll": {
"PanoramaUIEngine001": 360160
},
"panorama_text_pango_dll": {
"PanoramaTextPangoDll": {
"PanoramaTextServices001": 314320
},
"panoramauiclient_dll": {
"PanoramauiclientDll": {
"PanoramaUIClient001": 75648
},
"particles_dll": {
"ParticlesDll": {
"ParticleSystemMgr003": 339232
},
"pulse_system_dll": {
"PulseSystemDll": {
"IPulseSystem_001": 23424
},
"rendersystemdx11_dll": {
"Rendersystemdx11Dll": {
"RenderDeviceMgr001": 304016,
"RenderUtils_001": 339088,
"VRenderDeviceMgrBackdoor001": 304032
},
"resourcesystem_dll": {
"ResourcesystemDll": {
"ResourceSystem013": 67152
},
"scenefilecache_dll": {
"ScenefilecacheDll": {
"ResponseRulesCache001": 12688,
"SceneFileCache002": 26848
},
"scenesystem_dll": {
"ScenesystemDll": {
"RenderingPipelines_001": 585424,
"SceneSystem_002": 830992,
"SceneUtils_001": 1298480
},
"schemasystem_dll": {
"SchemasystemDll": {
"SchemaSystem_001": 43312
},
"server_dll": {
"ServerDll": {
"EmptyWorldService001_Server": 5798064,
"EntitySubclassUtilsV001": 2916880,
"NavGameTest001": 10667120,
@ -141,16 +141,16 @@
"Source2ServerConfig001": 5666992,
"customnavsystem001": 2379184
},
"soundsystem_dll": {
"SoundsystemDll": {
"SoundOpSystem001": 1401184,
"SoundOpSystemEdit001": 570688,
"SoundSystem001": 288064,
"VMixEditTool001": 464704
},
"steamaudio_dll": {
"SteamaudioDll": {
"SteamAudio001": 77536
},
"steamclient64_dll": {
"Steamclient64Dll": {
"CLIENTENGINE_INTERFACE_VERSION005": 8582336,
"IVALIDATE001": 8599104,
"SteamClient006": 6474256,
@ -171,33 +171,33 @@
"p2pvoice002": 888480,
"p2pvoicesingleton002": 874560
},
"tier0_dll": {
"Tier0Dll": {
"TestScriptMgr001": 1308400,
"VEngineCvar007": 400464,
"VProcessUtils002": 1243248,
"VStringTokenSystem001": 1622928
},
"v8system_dll": {
"V8SystemDll": {
"Source2V8System001": 5744
},
"valve_avi_dll": {
"ValveAviDll": {
"VAvi001": 12176
},
"valve_wmf_dll": {
"ValveWmfDll": {
"VMediaFoundation001": 4816
},
"vphysics2_dll": {
"Vphysics2Dll": {
"VPhysics2_Handle_Interface_001": 391760,
"VPhysics2_Interface_001": 374768
},
"vscript_dll": {
"VscriptDll": {
"VScriptManager010": 204192
},
"vstdlib_s64_dll": {
"VstdlibS64Dll": {
"IVALIDATE001": 151536,
"VEngineCvar002": 22352
},
"worldrenderer_dll": {
"WorldrendererDll": {
"WorldRendererMgr001": 136496
}
}

205
generated/interfaces.py Normal file
View File

@ -0,0 +1,205 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:51.722997500 UTC
'''
class AnimationsystemDll:
AnimationSystemUtils_001 = 0x64670
AnimationSystem_001 = 0x5F1D0
class ClientDll:
LegacyGameUI001 = 0x88F360
Source2ClientUI001 = 0x87DE00
Source2ClientPrediction001 = 0x79B660
ClientToolsInfo_001 = 0x727570
Source2Client002 = 0x727590
GameClientExports001 = 0x727580
EmptyWorldService001_Client = 0x48B1E0
Source2ClientConfig001 = 0x4721F0
class Engine2Dll:
SimpleEngineLoopService_001 = 0x1E1C70
ClientServerEngineLoopService_001 = 0x1D7940
KeyValueCache001 = 0x1D3F80
HostStateMgr001 = 0x1D1990
GameEventSystemServerV001 = 0x1CD050
GameEventSystemClientV001 = 0x1CD040
EngineServiceMgr001 = 0x1C8D30
VProfService_001 = 0x1B6810
ToolService_001 = 0x1B5560
StatsService_001 = 0x1B07E0
SplitScreenService_001 = 0x1ADA50
SoundService_001 = 0x1A85A0
ScreenshotService001 = 0x1A4470
RenderService_001 = 0x1A17D0
NetworkService_001 = 0x1A12E0
NetworkServerService_001 = 0x19C380
NetworkP2PService_001 = 0x197D90
NetworkClientService_001 = 0x1919C0
MapListService_001 = 0x18A990
InputService_001 = 0x1787D0
GameUIService_001 = 0x173290
GameResourceServiceServerV001 = 0x170FF0
GameResourceServiceClientV001 = 0x170FE0
BugService001 = 0x16A010
BenchmarkService001 = 0x1687E0
VENGINE_GAMEUIFUNCS_VERSION005 = 0x1163C0
EngineGameUI001 = 0x115750
INETSUPPORT_001 = 0xE59D0
Source2EngineToServerStringTable001 = 0xA0B50
Source2EngineToServer001 = 0x8AA40
Source2EngineToClientStringTable001 = 0x83760
Source2EngineToClient001 = 0x5A1B0
class FilesystemStdioDll:
VAsyncFileSystem2_001 = 0x66D30
VFileSystem017 = 0x66D20
class HostDll:
Source2Host001 = 0x18E10
SinglePlayerSharedMemory001 = 0x18A90
SaveRestoreDataVersion001 = 0x18A80
PredictionDiffManager001 = 0x16E20
HostUtils001 = 0x12550
GameSystem2HostHook = 0x11DA0
GameModelInfo001 = 0x11CC0
DebugDrawQueueManager001 = 0x11710
class ImemanagerDll:
IMEManager001 = 0xC470
class InputsystemDll:
InputSystemVersion001 = 0x28D0
InputStackSystemVersion001 = 0x16F0
class LocalizeDll:
Localize_001 = 0x3830
class MatchmakingDll:
GameTypes001 = 0x50270
MATCHFRAMEWORK_001 = 0x101030
class Materialsystem2Dll:
MaterialUtils_001 = 0x4DB80
TextLayout_001 = 0x4A2D0
PostProcessingSystem_001 = 0x42A50
FontManager_001 = 0x378F0
VMaterialSystem2_001 = 0x25EB0
class MeshsystemDll:
MeshSystem001 = 0x7270
class NavsystemDll:
NavSystem001 = 0x76F0
class NetworksystemDll:
SerializedEntitiesVersion001 = 0xD1A60
NetworkSystemVersion001 = 0xBBF70
NetworkMessagesVersion001 = 0x9C010
FlattenedSerializersVersion001 = 0x7B890
class PanoramaDll:
PanoramaUIEngine001 = 0x57EE0
class PanoramaTextPangoDll:
PanoramaTextServices001 = 0x4CBD0
class PanoramauiclientDll:
PanoramaUIClient001 = 0x12780
class ParticlesDll:
ParticleSystemMgr003 = 0x52D20
class PulseSystemDll:
IPulseSystem_001 = 0x5B80
class Rendersystemdx11Dll:
RenderUtils_001 = 0x52C90
VRenderDeviceMgrBackdoor001 = 0x4A3A0
RenderDeviceMgr001 = 0x4A390
class ResourcesystemDll:
ResourceSystem013 = 0x10650
class ScenefilecacheDll:
SceneFileCache002 = 0x68E0
ResponseRulesCache001 = 0x3190
class ScenesystemDll:
SceneUtils_001 = 0x13D030
SceneSystem_002 = 0xCAE10
RenderingPipelines_001 = 0x8EED0
class SchemasystemDll:
SchemaSystem_001 = 0xA930
class ServerDll:
NavGameTest001 = 0xA2C470
ServerToolsInfo_001 = 0x830DE0
Source2GameClients001 = 0x830DF0
Source2GameEntities001 = 0x830E00
Source2Server001 = 0x830E10
EmptyWorldService001_Server = 0x5878B0
Source2ServerConfig001 = 0x5678B0
EntitySubclassUtilsV001 = 0x2C8210
customnavsystem001 = 0x244DB0
Source2GameDirector001 = 0x13EAB0
class SoundsystemDll:
SoundOpSystem001 = 0x156160
SoundOpSystemEdit001 = 0x8B540
VMixEditTool001 = 0x71740
SoundSystem001 = 0x46540
class SteamaudioDll:
SteamAudio001 = 0x12EE0
class Steamclient64Dll:
IVALIDATE001 = 0x833640
CLIENTENGINE_INTERFACE_VERSION005 = 0x82F4C0
SteamClient020 = 0x62CAF0
SteamClient019 = 0x62CAE0
SteamClient018 = 0x62CAD0
SteamClient017 = 0x62CAC0
SteamClient016 = 0x62CAB0
SteamClient015 = 0x62CAA0
SteamClient014 = 0x62CA90
SteamClient013 = 0x62CA80
SteamClient012 = 0x62CA70
SteamClient011 = 0x62CA60
SteamClient010 = 0x62CA50
SteamClient009 = 0x62CA40
SteamClient008 = 0x62CA30
SteamClient007 = 0x62CA20
SteamClient006 = 0x62CA10
p2pvoice002 = 0xD8EA0
p2pvoicesingleton002 = 0xD5840
class Tier0Dll:
VStringTokenSystem001 = 0x18C390
TestScriptMgr001 = 0x13F6F0
VProcessUtils002 = 0x12F870
VEngineCvar007 = 0x61C50
class V8SystemDll:
Source2V8System001 = 0x1670
class ValveAviDll:
VAvi001 = 0x2F90
class ValveWmfDll:
VMediaFoundation001 = 0x12D0
class Vphysics2Dll:
VPhysics2_Handle_Interface_001 = 0x5FA50
VPhysics2_Interface_001 = 0x5B7F0
class VscriptDll:
VScriptManager010 = 0x31DA0
class VstdlibS64Dll:
IVALIDATE001 = 0x24FF0
VEngineCvar002 = 0x5750
class WorldrendererDll:
WorldRendererMgr001 = 0x21530

76
generated/interfaces.rs
View File

@ -1,16 +1,16 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:33.225495 UTC
* 2023-10-17 02:04:51.725351400 UTC
*/
pub mod animationsystem_dll {
#![allow(non_snake_case, non_upper_case_globals)]
pub mod AnimationsystemDll {
pub const AnimationSystemUtils_001: usize = 0x64670;
pub const AnimationSystem_001: usize = 0x5F1D0;
}
pub mod client_dll {
pub mod ClientDll {
pub const LegacyGameUI001: usize = 0x88F360;
pub const Source2ClientUI001: usize = 0x87DE00;
pub const Source2ClientPrediction001: usize = 0x79B660;
@ -21,7 +21,7 @@ pub mod client_dll {
pub const Source2ClientConfig001: usize = 0x4721F0;
}
pub mod engine2_dll {
pub mod Engine2Dll {
pub const SimpleEngineLoopService_001: usize = 0x1E1C70;
pub const ClientServerEngineLoopService_001: usize = 0x1D7940;
pub const KeyValueCache001: usize = 0x1D3F80;
@ -56,12 +56,12 @@ pub mod engine2_dll {
pub const Source2EngineToClient001: usize = 0x5A1B0;
}
pub mod filesystem_stdio_dll {
pub mod FilesystemStdioDll {
pub const VAsyncFileSystem2_001: usize = 0x66D30;
pub const VFileSystem017: usize = 0x66D20;
}
pub mod host_dll {
pub mod HostDll {
pub const Source2Host001: usize = 0x18E10;
pub const SinglePlayerSharedMemory001: usize = 0x18A90;
pub const SaveRestoreDataVersion001: usize = 0x18A80;
@ -72,25 +72,25 @@ pub mod host_dll {
pub const DebugDrawQueueManager001: usize = 0x11710;
}
pub mod imemanager_dll {
pub mod ImemanagerDll {
pub const IMEManager001: usize = 0xC470;
}
pub mod inputsystem_dll {
pub mod InputsystemDll {
pub const InputSystemVersion001: usize = 0x28D0;
pub const InputStackSystemVersion001: usize = 0x16F0;
}
pub mod localize_dll {
pub mod LocalizeDll {
pub const Localize_001: usize = 0x3830;
}
pub mod matchmaking_dll {
pub mod MatchmakingDll {
pub const GameTypes001: usize = 0x50270;
pub const MATCHFRAMEWORK_001: usize = 0x101030;
}
pub mod materialsystem2_dll {
pub mod Materialsystem2Dll {
pub const MaterialUtils_001: usize = 0x4DB80;
pub const TextLayout_001: usize = 0x4A2D0;
pub const PostProcessingSystem_001: usize = 0x42A50;
@ -98,67 +98,67 @@ pub mod materialsystem2_dll {
pub const VMaterialSystem2_001: usize = 0x25EB0;
}
pub mod meshsystem_dll {
pub mod MeshsystemDll {
pub const MeshSystem001: usize = 0x7270;
}
pub mod navsystem_dll {
pub mod NavsystemDll {
pub const NavSystem001: usize = 0x76F0;
}
pub mod networksystem_dll {
pub mod NetworksystemDll {
pub const SerializedEntitiesVersion001: usize = 0xD1A60;
pub const NetworkSystemVersion001: usize = 0xBBF70;
pub const NetworkMessagesVersion001: usize = 0x9C010;
pub const FlattenedSerializersVersion001: usize = 0x7B890;
}
pub mod panorama_dll {
pub mod PanoramaDll {
pub const PanoramaUIEngine001: usize = 0x57EE0;
}
pub mod panorama_text_pango_dll {
pub mod PanoramaTextPangoDll {
pub const PanoramaTextServices001: usize = 0x4CBD0;
}
pub mod panoramauiclient_dll {
pub mod PanoramauiclientDll {
pub const PanoramaUIClient001: usize = 0x12780;
}
pub mod particles_dll {
pub mod ParticlesDll {
pub const ParticleSystemMgr003: usize = 0x52D20;
}
pub mod pulse_system_dll {
pub mod PulseSystemDll {
pub const IPulseSystem_001: usize = 0x5B80;
}
pub mod rendersystemdx11_dll {
pub mod Rendersystemdx11Dll {
pub const RenderUtils_001: usize = 0x52C90;
pub const VRenderDeviceMgrBackdoor001: usize = 0x4A3A0;
pub const RenderDeviceMgr001: usize = 0x4A390;
}
pub mod resourcesystem_dll {
pub mod ResourcesystemDll {
pub const ResourceSystem013: usize = 0x10650;
}
pub mod scenefilecache_dll {
pub mod ScenefilecacheDll {
pub const SceneFileCache002: usize = 0x68E0;
pub const ResponseRulesCache001: usize = 0x3190;
}
pub mod scenesystem_dll {
pub mod ScenesystemDll {
pub const SceneUtils_001: usize = 0x13D030;
pub const SceneSystem_002: usize = 0xCAE10;
pub const RenderingPipelines_001: usize = 0x8EED0;
}
pub mod schemasystem_dll {
pub mod SchemasystemDll {
pub const SchemaSystem_001: usize = 0xA930;
}
pub mod server_dll {
pub mod ServerDll {
pub const NavGameTest001: usize = 0xA2C470;
pub const ServerToolsInfo_001: usize = 0x830DE0;
pub const Source2GameClients001: usize = 0x830DF0;
@ -171,18 +171,18 @@ pub mod server_dll {
pub const Source2GameDirector001: usize = 0x13EAB0;
}
pub mod soundsystem_dll {
pub mod SoundsystemDll {
pub const SoundOpSystem001: usize = 0x156160;
pub const SoundOpSystemEdit001: usize = 0x8B540;
pub const VMixEditTool001: usize = 0x71740;
pub const SoundSystem001: usize = 0x46540;
}
pub mod steamaudio_dll {
pub mod SteamaudioDll {
pub const SteamAudio001: usize = 0x12EE0;
}
pub mod steamclient64_dll {
pub mod Steamclient64Dll {
pub const IVALIDATE001: usize = 0x833640;
pub const CLIENTENGINE_INTERFACE_VERSION005: usize = 0x82F4C0;
pub const SteamClient020: usize = 0x62CAF0;
@ -204,39 +204,39 @@ pub mod steamclient64_dll {
pub const p2pvoicesingleton002: usize = 0xD5840;
}
pub mod tier0_dll {
pub mod Tier0Dll {
pub const VStringTokenSystem001: usize = 0x18C390;
pub const TestScriptMgr001: usize = 0x13F6F0;
pub const VProcessUtils002: usize = 0x12F870;
pub const VEngineCvar007: usize = 0x61C50;
}
pub mod v8system_dll {
pub mod V8SystemDll {
pub const Source2V8System001: usize = 0x1670;
}
pub mod valve_avi_dll {
pub mod ValveAviDll {
pub const VAvi001: usize = 0x2F90;
}
pub mod valve_wmf_dll {
pub mod ValveWmfDll {
pub const VMediaFoundation001: usize = 0x12D0;
}
pub mod vphysics2_dll {
pub mod Vphysics2Dll {
pub const VPhysics2_Handle_Interface_001: usize = 0x5FA50;
pub const VPhysics2_Interface_001: usize = 0x5B7F0;
}
pub mod vscript_dll {
pub mod VscriptDll {
pub const VScriptManager010: usize = 0x31DA0;
}
pub mod vstdlib_s64_dll {
pub mod VstdlibS64Dll {
pub const IVALIDATE001: usize = 0x24FF0;
pub const VEngineCvar002: usize = 0x5750;
}
pub mod worldrenderer_dll {
pub mod WorldrendererDll {
pub const WorldRendererMgr001: usize = 0x21530;
}

2
generated/materialsystem2.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.387776500 UTC
* 2023-10-17 02:04:49.710835800 UTC
*/
public static class MaterialParamBuffer_t {

10
generated/materialsystem2.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:49.709221 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.386044300 UTC
*/
namespace MaterialParamBuffer_t {
constexpr std::ptrdiff_t m_value = 0x8; // CUtlBinaryBlock
}

98
generated/materialsystem2.dll.py Normal file
View File

@ -0,0 +1,98 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:49.712772400 UTC
'''
class MaterialParamBuffer_t:
m_value = 0x8 # CUtlBinaryBlock
class MaterialParamFloat_t:
m_flValue = 0x8 # float
class MaterialParamInt_t:
m_nValue = 0x8 # int32_t
class MaterialParamString_t:
m_value = 0x8 # CUtlString
class MaterialParamTexture_t:
m_pValue = 0x8 # CStrongHandle<InfoForResourceTypeCTextureBase>
class MaterialParamVector_t:
m_value = 0x8 # Vector4D
class MaterialParam_t:
m_name = 0x0 # CUtlString
class MaterialResourceData_t:
m_materialName = 0x0 # CUtlString
m_shaderName = 0x8 # CUtlString
m_intParams = 0x10 # CUtlVector<MaterialParamInt_t>
m_floatParams = 0x28 # CUtlVector<MaterialParamFloat_t>
m_vectorParams = 0x40 # CUtlVector<MaterialParamVector_t>
m_textureParams = 0x58 # CUtlVector<MaterialParamTexture_t>
m_dynamicParams = 0x70 # CUtlVector<MaterialParamBuffer_t>
m_dynamicTextureParams = 0x88 # CUtlVector<MaterialParamBuffer_t>
m_intAttributes = 0xA0 # CUtlVector<MaterialParamInt_t>
m_floatAttributes = 0xB8 # CUtlVector<MaterialParamFloat_t>
m_vectorAttributes = 0xD0 # CUtlVector<MaterialParamVector_t>
m_textureAttributes = 0xE8 # CUtlVector<MaterialParamTexture_t>
m_stringAttributes = 0x100 # CUtlVector<MaterialParamString_t>
m_renderAttributesUsed = 0x118 # CUtlVector<CUtlString>
class PostProcessingBloomParameters_t:
m_blendMode = 0x0 # BloomBlendMode_t
m_flBloomStrength = 0x4 # float
m_flScreenBloomStrength = 0x8 # float
m_flBlurBloomStrength = 0xC # float
m_flBloomThreshold = 0x10 # float
m_flBloomThresholdWidth = 0x14 # float
m_flSkyboxBloomStrength = 0x18 # float
m_flBloomStartValue = 0x1C # float
m_flBlurWeight = 0x20 # float[5]
m_vBlurTint = 0x34 # Vector[5]
class PostProcessingLocalContrastParameters_t:
m_flLocalContrastStrength = 0x0 # float
m_flLocalContrastEdgeStrength = 0x4 # float
m_flLocalContrastVignetteStart = 0x8 # float
m_flLocalContrastVignetteEnd = 0xC # float
m_flLocalContrastVignetteBlur = 0x10 # float
class PostProcessingResource_t:
m_bHasTonemapParams = 0x0 # bool
m_toneMapParams = 0x4 # PostProcessingTonemapParameters_t
m_bHasBloomParams = 0x40 # bool
m_bloomParams = 0x44 # PostProcessingBloomParameters_t
m_bHasVignetteParams = 0xB4 # bool
m_vignetteParams = 0xB8 # PostProcessingVignetteParameters_t
m_bHasLocalContrastParams = 0xDC # bool
m_localConstrastParams = 0xE0 # PostProcessingLocalContrastParameters_t
m_nColorCorrectionVolumeDim = 0xF4 # int32_t
m_colorCorrectionVolumeData = 0xF8 # CUtlBinaryBlock
m_bHasColorCorrection = 0x110 # bool
class PostProcessingTonemapParameters_t:
m_flExposureBias = 0x0 # float
m_flShoulderStrength = 0x4 # float
m_flLinearStrength = 0x8 # float
m_flLinearAngle = 0xC # float
m_flToeStrength = 0x10 # float
m_flToeNum = 0x14 # float
m_flToeDenom = 0x18 # float
m_flWhitePoint = 0x1C # float
m_flLuminanceSource = 0x20 # float
m_flExposureBiasShadows = 0x24 # float
m_flExposureBiasHighlights = 0x28 # float
m_flMinShadowLum = 0x2C # float
m_flMaxShadowLum = 0x30 # float
m_flMinHighlightLum = 0x34 # float
m_flMaxHighlightLum = 0x38 # float
class PostProcessingVignetteParameters_t:
m_flVignetteStrength = 0x0 # float
m_vCenter = 0x4 # Vector2D
m_flRadius = 0xC # float
m_flRoundness = 0x10 # float
m_flFeather = 0x14 # float
m_vColorTint = 0x18 # Vector

6
generated/materialsystem2.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.389748900 UTC
* 2023-10-17 02:04:49.714514100 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod MaterialParamBuffer_t {
pub const m_value: usize = 0x8; // CUtlBinaryBlock
}

2
generated/networksystem.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.392118600 UTC
* 2023-10-17 02:04:49.716792200 UTC
*/
public static class ChangeAccessorFieldPathIndex_t {

10
generated/networksystem.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:49.716408300 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.391722300 UTC
*/
namespace ChangeAccessorFieldPathIndex_t {
constexpr std::ptrdiff_t m_Value = 0x0; // int16_t
}

7
generated/networksystem.dll.py Normal file
View File

@ -0,0 +1,7 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:49.717532700 UTC
'''
class ChangeAccessorFieldPathIndex_t:
m_Value = 0x0 # int16_t

6
generated/networksystem.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.392830500 UTC
* 2023-10-17 02:04:49.717926 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod ChangeAccessorFieldPathIndex_t {
pub const m_Value: usize = 0x0; // int16_t
}

6
generated/offsets.cs
View File

@ -1,9 +1,9 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:33.672128500 UTC
* 2023-10-17 02:04:52.170660100 UTC
*/
public static class client_dll {
public static class ClientDll {
public const nint dwEntityList = 0x178FC88;
public const nint dwForceAttack = 0x1696DF0;
public const nint dwForceAttack2 = 0x1696E80;
@ -25,7 +25,7 @@ public static class client_dll {
public const nint dwViewRender = 0x187E4A8;
}
public static class engine2_dll {
public static class Engine2Dll {
public const nint dwBuildNumber = 0x487514;
public const nint dwNetworkGameClient = 0x486AB0;
public const nint dwNetworkGameClient_getLocalPlayer = 0xF0;

14
generated/offsets.hpp
View File

@ -1,13 +1,13 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:52.169744400 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:33.670867800 UTC
*/
namespace client_dll {
namespace ClientDll {
constexpr std::ptrdiff_t dwEntityList = 0x178FC88;
constexpr std::ptrdiff_t dwForceAttack = 0x1696DF0;
constexpr std::ptrdiff_t dwForceAttack2 = 0x1696E80;
@ -29,7 +29,7 @@ namespace client_dll {
constexpr std::ptrdiff_t dwViewRender = 0x187E4A8;
}
namespace engine2_dll {
namespace Engine2Dll {
constexpr std::ptrdiff_t dwBuildNumber = 0x487514;
constexpr std::ptrdiff_t dwNetworkGameClient = 0x486AB0;
constexpr std::ptrdiff_t dwNetworkGameClient_getLocalPlayer = 0xF0;

4
generated/offsets.json
View File

@ -1,5 +1,5 @@
{
"client_dll": {
"ClientDll": {
"dwEntityList": 24706184,
"dwForceAttack": 23686640,
"dwForceAttack2": 23686784,
@ -20,7 +20,7 @@
"dwViewMatrix": 25680560,
"dwViewRender": 25683112
},
"engine2_dll": {
"Engine2Dll": {
"dwBuildNumber": 4748564,
"dwNetworkGameClient": 4745904,
"dwNetworkGameClient_getLocalPlayer": 240,

34
generated/offsets.py Normal file
View File

@ -0,0 +1,34 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:52.171902400 UTC
'''
class ClientDll:
dwEntityList = 0x178FC88
dwForceAttack = 0x1696DF0
dwForceAttack2 = 0x1696E80
dwForceBackward = 0x16970C0
dwForceCrouch = 0x1697390
dwForceForward = 0x1697030
dwForceJump = 0x1697300
dwForceLeft = 0x1697150
dwForceRight = 0x16971E0
dwGameRules = 0x17EB818
dwGlobalVars = 0x1692EE8
dwGlowManager = 0x17EAF98
dwInterfaceLinkList = 0x1976138
dwLocalPlayerController = 0x17DE508
dwLocalPlayerPawn = 0x187CFC8
dwPlantedC4 = 0x18838C0
dwViewAngles = 0x18DCAF0
dwViewMatrix = 0x187DAB0
dwViewRender = 0x187E4A8
class Engine2Dll:
dwBuildNumber = 0x487514
dwNetworkGameClient = 0x486AB0
dwNetworkGameClient_getLocalPlayer = 0xF0
dwNetworkGameClient_maxClients = 0x250
dwNetworkGameClient_signOnState = 0x240
dwWindowHeight = 0x538674
dwWindowWidth = 0x538670

10
generated/offsets.rs
View File

@ -1,11 +1,11 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:33.673543400 UTC
* 2023-10-17 02:04:52.173110500 UTC
*/
pub mod client_dll {
#![allow(non_snake_case, non_upper_case_globals)]
pub mod ClientDll {
pub const dwEntityList: usize = 0x178FC88;
pub const dwForceAttack: usize = 0x1696DF0;
pub const dwForceAttack2: usize = 0x1696E80;
@ -27,7 +27,7 @@ pub mod client_dll {
pub const dwViewRender: usize = 0x187E4A8;
}
pub mod engine2_dll {
pub mod Engine2Dll {
pub const dwBuildNumber: usize = 0x487514;
pub const dwNetworkGameClient: usize = 0x486AB0;
pub const dwNetworkGameClient_getLocalPlayer: usize = 0xF0;

2
generated/particles.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.967344 UTC
* 2023-10-17 02:04:50.348555300 UTC
*/
public static class CBaseRendererSource2 {

10
generated/particles.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:50.309640 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.927930 UTC
*/
namespace CBaseRendererSource2 {
constexpr std::ptrdiff_t m_flRadiusScale = 0x200; // CParticleCollectionRendererFloatInput
constexpr std::ptrdiff_t m_flAlphaScale = 0x358; // CParticleCollectionRendererFloatInput

3506
generated/particles.dll.py Normal file
View File

File diff suppressed because it is too large Load Diff

6
generated/particles.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.008264 UTC
* 2023-10-17 02:04:50.428899600 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod CBaseRendererSource2 {
pub const m_flRadiusScale: usize = 0x200; // CParticleCollectionRendererFloatInput
pub const m_flAlphaScale: usize = 0x358; // CParticleCollectionRendererFloatInput

2
generated/pulse_system.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.713845500 UTC
* 2023-10-17 02:04:50.088126900 UTC
*/
public static class CPulseCell_Base {

10
generated/pulse_system.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:50.085477700 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.711122600 UTC
*/
namespace CPulseCell_Base {
constexpr std::ptrdiff_t m_nEditorNodeID = 0x8; // PulseDocNodeID_t
}

233
generated/pulse_system.dll.py Normal file
View File

@ -0,0 +1,233 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:50.091275300 UTC
'''
class CPulseCell_Base:
m_nEditorNodeID = 0x8 # PulseDocNodeID_t
class CPulseCell_Inflow_BaseEntrypoint:
m_EntryChunk = 0x48 # PulseRuntimeChunkIndex_t
m_RegisterMap = 0x50 # PulseRegisterMap_t
class CPulseCell_Inflow_EntOutputHandler:
m_SourceEntity = 0x70 # CUtlSymbolLarge
m_SourceOutput = 0x78 # CUtlSymbolLarge
m_TargetInput = 0x80 # CUtlSymbolLarge
m_ExpectedParamType = 0x88 # CPulseValueFullType
class CPulseCell_Inflow_EventHandler:
m_EventName = 0x70 # CUtlSymbolLarge
class CPulseCell_Inflow_GraphHook:
m_HookName = 0x70 # CUtlSymbolLarge
class CPulseCell_Inflow_Method:
m_MethodName = 0x70 # CUtlSymbolLarge
m_Description = 0x78 # CUtlString
m_bIsPublic = 0x80 # bool
m_ReturnType = 0x88 # CPulseValueFullType
m_Args = 0x98 # CUtlVector<CPulseRuntimeMethodArg>
class CPulseCell_Inflow_Wait:
m_WakeResume = 0x48 # CPulse_ResumePoint
class CPulseCell_Inflow_Yield:
m_UnyieldResume = 0x48 # CPulse_ResumePoint
class CPulseCell_Outflow_CycleOrdered:
m_Outputs = 0x48 # CUtlVector<CPulse_OutflowConnection>
class CPulseCell_Outflow_CycleOrdered_InstanceState_t:
m_nNextIndex = 0x0 # int32_t
class CPulseCell_Outflow_CycleRandom:
m_Outputs = 0x48 # CUtlVector<CPulse_OutflowConnection>
class CPulseCell_Outflow_CycleShuffled:
m_Outputs = 0x48 # CUtlVector<CPulse_OutflowConnection>
class CPulseCell_Outflow_CycleShuffled_InstanceState_t:
m_Shuffle = 0x0 # CUtlVectorFixedGrowable<uint8_t>
m_nNextShuffle = 0x20 # int32_t
class CPulseCell_Outflow_IntSwitch:
m_DefaultCaseOutflow = 0x48 # CPulse_OutflowConnection
m_CaseOutflows = 0x58 # CUtlVector<CPulse_OutflowConnection>
class CPulseCell_Outflow_SimultaneousParallel:
m_Outputs = 0x48 # CUtlVector<CPulse_OutflowConnection>
class CPulseCell_Outflow_StringSwitch:
m_DefaultCaseOutflow = 0x48 # CPulse_OutflowConnection
m_CaseOutflows = 0x58 # CUtlVector<CPulse_OutflowConnection>
class CPulseCell_Outflow_TestExplicitYesNo:
m_Yes = 0x48 # CPulse_OutflowConnection
m_No = 0x58 # CPulse_OutflowConnection
class CPulseCell_Outflow_TestRandomYesNo:
m_Yes = 0x48 # CPulse_OutflowConnection
m_No = 0x58 # CPulse_OutflowConnection
class CPulseCell_Step_CallExternalMethod:
m_MethodName = 0x48 # CUtlSymbolLarge
m_ExpectedArgs = 0x50 # CUtlVector<CPulseRuntimeMethodArg>
class CPulseCell_Step_PublicOutput:
m_OutputIndex = 0x48 # PulseRuntimeOutputIndex_t
class CPulseCell_Step_TestDomainEntFire:
m_Input = 0x48 # CUtlString
class CPulseGraphDef:
m_DomainIdentifier = 0x8 # CUtlSymbolLarge
m_ParentMapName = 0x10 # CUtlSymbolLarge
m_Chunks = 0x18 # CUtlVector<CPulse_Chunk*>
m_Cells = 0x30 # CUtlVector<CPulseCell_Base*>
m_Vars = 0x48 # CUtlVector<CPulse_Variable>
m_PublicOutputs = 0x60 # CUtlVector<CPulse_PublicOutput>
m_InvokeBindings = 0x78 # CUtlVector<CPulse_InvokeBinding*>
m_CallInfos = 0x90 # CUtlVector<CPulse_CallInfo*>
m_OutputConnections = 0xA8 # CUtlVector<CPulse_OutputConnection*>
class CPulseGraphInstance_TestDomain:
m_bIsRunningUnitTests = 0xD0 # bool
m_bExplicitTimeStepping = 0xD1 # bool
m_bExpectingToDestroyWithYieldedCursors = 0xD2 # bool
m_nNextValidateIndex = 0xD4 # int32_t
m_Tracepoints = 0xD8 # CUtlVector<CUtlString>
m_bTestYesOrNoPath = 0xF0 # bool
class CPulseGraphInstance_TestDomain_Derived:
m_nInstanceValueX = 0xF8 # int32_t
class CPulseRuntimeMethodArg:
m_Name = 0x0 # CKV3MemberNameWithStorage
m_Description = 0x38 # CUtlString
m_Type = 0x40 # CPulseValueFullType
class CPulseTurtleGraphicsCursor:
m_Color = 0x188 # Color
m_vPos = 0x18C # Vector2D
m_flHeadingDeg = 0x194 # float
m_bPenUp = 0x198 # bool
class CPulse_CallInfo:
m_PortName = 0x0 # CUtlSymbolLarge
m_nEditorNodeID = 0x8 # PulseDocNodeID_t
m_RegisterMap = 0x10 # PulseRegisterMap_t
m_CallMethodID = 0x30 # PulseDocNodeID_t
m_nSrcChunk = 0x34 # PulseRuntimeChunkIndex_t
m_nSrcInstruction = 0x38 # int32_t
class CPulse_Chunk:
m_Instructions = 0x0 # CUtlLeanVector<PGDInstruction_t>
m_Registers = 0x10 # CUtlLeanVector<CPulse_RegisterInfo>
m_InstructionEditorIDs = 0x20 # CUtlLeanVector<PulseDocNodeID_t>
class CPulse_InvokeBinding:
m_RegisterMap = 0x0 # PulseRegisterMap_t
m_FuncName = 0x20 # CUtlSymbolLarge
m_nCellIndex = 0x28 # PulseRuntimeCellIndex_t
m_InstanceType = 0x30 # CPulseValueFullType
m_nSrcChunk = 0x40 # PulseRuntimeChunkIndex_t
m_nSrcInstruction = 0x44 # int32_t
class CPulse_OutflowConnection:
m_SourceOutflowName = 0x0 # CUtlSymbolLarge
m_nDestChunk = 0x8 # PulseRuntimeChunkIndex_t
m_nInstruction = 0xC # int32_t
class CPulse_OutputConnection:
m_SourceOutput = 0x0 # CUtlSymbolLarge
m_TargetEntity = 0x8 # CUtlSymbolLarge
m_TargetInput = 0x10 # CUtlSymbolLarge
m_Param = 0x18 # CUtlSymbolLarge
class CPulse_PublicOutput:
m_Name = 0x0 # CUtlSymbolLarge
m_Description = 0x8 # CUtlString
m_ParamType = 0x10 # CPulseValueFullType
class CPulse_RegisterInfo:
m_nReg = 0x0 # PulseRuntimeRegisterIndex_t
m_Type = 0x8 # CPulseValueFullType
m_OriginName = 0x18 # CKV3MemberNameWithStorage
m_nWrittenByInstruction = 0x50 # int32_t
m_nLastReadByInstruction = 0x54 # int32_t
class CPulse_Variable:
m_Name = 0x0 # CUtlSymbolLarge
m_Description = 0x8 # CUtlString
m_Type = 0x10 # CPulseValueFullType
m_DefaultValue = 0x20 # KeyValues3
m_bIsPublic = 0x32 # bool
class CTestDomainDerived_Cursor:
m_nCursorValueA = 0x188 # int32_t
m_nCursorValueB = 0x18C # int32_t
class FakeEntity_t:
m_nHandle = 0x0 # PulseTestEHandle_t
m_Name = 0x8 # CUtlString
m_Class = 0x10 # CUtlString
m_bDestroyed = 0x18 # bool
m_pAssociatedGraphInstance = 0x20 # CPulseGraphInstance_TestDomain*
m_bFuncWasCalled = 0x28 # bool
m_fValue = 0x2C # float
class PGDInstruction_t:
m_nCode = 0x0 # PulseInstructionCode_t
m_nVar = 0x4 # PulseRuntimeVarIndex_t
m_nReg0 = 0x8 # PulseRuntimeRegisterIndex_t
m_nReg1 = 0xA # PulseRuntimeRegisterIndex_t
m_nReg2 = 0xC # PulseRuntimeRegisterIndex_t
m_nInvokeBindingIndex = 0x10 # PulseRuntimeInvokeIndex_t
m_nChunk = 0x14 # PulseRuntimeChunkIndex_t
m_nDestInstruction = 0x18 # int32_t
m_nCallInfoIndex = 0x1C # PulseRuntimeCallInfoIndex_t
m_Arg0Name = 0x20 # CUtlSymbolLarge
m_Arg1Name = 0x28 # CUtlSymbolLarge
m_bLiteralBool = 0x30 # bool
m_nLiteralInt = 0x34 # int32_t
m_flLiteralFloat = 0x38 # float
m_LiteralString = 0x40 # CBufferString
m_vLiteralVec3 = 0x50 # Vector
class PulseDocNodeID_t:
m_Value = 0x0 # int32_t
class PulseRegisterMap_t:
m_Inparams = 0x0 # KeyValues3
m_Outparams = 0x10 # KeyValues3
class PulseRuntimeCallInfoIndex_t:
m_Value = 0x0 # int32_t
class PulseRuntimeCellIndex_t:
m_Value = 0x0 # int32_t
class PulseRuntimeChunkIndex_t:
m_Value = 0x0 # int32_t
class PulseRuntimeEntrypointIndex_t:
m_Value = 0x0 # int32_t
class PulseRuntimeInvokeIndex_t:
m_Value = 0x0 # int32_t
class PulseRuntimeOutputIndex_t:
m_Value = 0x0 # int32_t
class PulseRuntimeRegisterIndex_t:
m_Value = 0x0 # int16_t
class PulseRuntimeStateOffset_t:
m_Value = 0x0 # uint16_t
class PulseRuntimeVarIndex_t:
m_Value = 0x0 # int32_t
class PulseTestEHandle_t:
m_Value = 0x0 # int32_t

6
generated/pulse_system.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.716897500 UTC
* 2023-10-17 02:04:50.094207700 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod CPulseCell_Base {
pub const m_nEditorNodeID: usize = 0x8; // PulseDocNodeID_t
}

2
generated/rendersystemdx11.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.362776200 UTC
* 2023-10-17 02:04:49.682169100 UTC
*/
public static class RenderInputLayoutField_t {

10
generated/rendersystemdx11.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:49.681400300 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.361960700 UTC
*/
namespace RenderInputLayoutField_t {
constexpr std::ptrdiff_t m_pSemanticName = 0x0; // uint8_t[32]
constexpr std::ptrdiff_t m_nSemanticIndex = 0x20; // int32_t

22
generated/rendersystemdx11.dll.py Normal file
View File

@ -0,0 +1,22 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:49.683189900 UTC
'''
class RenderInputLayoutField_t:
m_pSemanticName = 0x0 # uint8_t[32]
m_nSemanticIndex = 0x20 # int32_t
m_Format = 0x24 # uint32_t
m_nOffset = 0x28 # int32_t
m_nSlot = 0x2C # int32_t
m_nSlotType = 0x30 # RenderSlotType_t
m_nInstanceStepRate = 0x34 # int32_t
class VsInputSignatureElement_t:
m_pName = 0x0 # char[64]
m_pSemantic = 0x40 # char[64]
m_pD3DSemanticName = 0x80 # char[64]
m_nD3DSemanticIndex = 0xC0 # int32_t
class VsInputSignature_t:
m_elems = 0x0 # CUtlVector<VsInputSignatureElement_t>

6
generated/rendersystemdx11.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.363913900 UTC
* 2023-10-17 02:04:49.684161100 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod RenderInputLayoutField_t {
pub const m_pSemanticName: usize = 0x0; // uint8_t[32]
pub const m_nSemanticIndex: usize = 0x20; // int32_t

2
generated/resourcesystem.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.358179600 UTC
* 2023-10-17 02:04:49.676506900 UTC
*/
public static class AABB_t {

10
generated/resourcesystem.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:49.675361400 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.356904800 UTC
*/
namespace AABB_t {
constexpr std::ptrdiff_t m_vMinBounds = 0x0; // Vector
constexpr std::ptrdiff_t m_vMaxBounds = 0xC; // Vector

65
generated/resourcesystem.dll.py Normal file
View File

@ -0,0 +1,65 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:49.677881900 UTC
'''
class AABB_t:
m_vMinBounds = 0x0 # Vector
m_vMaxBounds = 0xC # Vector
class CFuseProgram:
m_programBuffer = 0x0 # CUtlVector<uint8_t>
m_variablesRead = 0x18 # CUtlVector<FuseVariableIndex_t>
m_variablesWritten = 0x30 # CUtlVector<FuseVariableIndex_t>
m_nMaxTempVarsUsed = 0x48 # int32_t
class CFuseSymbolTable:
m_constants = 0x0 # CUtlVector<ConstantInfo_t>
m_variables = 0x18 # CUtlVector<VariableInfo_t>
m_functions = 0x30 # CUtlVector<FunctionInfo_t>
m_constantMap = 0x48 # CUtlHashtable<CUtlStringToken,int32_t>
m_variableMap = 0x68 # CUtlHashtable<CUtlStringToken,int32_t>
m_functionMap = 0x88 # CUtlHashtable<CUtlStringToken,int32_t>
class ConstantInfo_t:
m_name = 0x0 # CUtlString
m_nameToken = 0x8 # CUtlStringToken
m_flValue = 0xC # float
class FourQuaternions:
x = 0x0 # fltx4
y = 0x10 # fltx4
z = 0x20 # fltx4
w = 0x30 # fltx4
class FunctionInfo_t:
m_name = 0x8 # CUtlString
m_nameToken = 0x10 # CUtlStringToken
m_nParamCount = 0x14 # int32_t
m_nIndex = 0x18 # FuseFunctionIndex_t
m_bIsPure = 0x1A # bool
class FuseFunctionIndex_t:
m_Value = 0x0 # uint16_t
class FuseVariableIndex_t:
m_Value = 0x0 # uint16_t
class ManifestTestResource_t:
m_name = 0x0 # CUtlString
m_child = 0x8 # CStrongHandle<InfoForResourceTypeManifestTestResource_t>
class PackedAABB_t:
m_nPackedMin = 0x0 # uint32_t
m_nPackedMax = 0x4 # uint32_t
class TestResource_t:
m_name = 0x0 # CUtlString
class VariableInfo_t:
m_name = 0x0 # CUtlString
m_nameToken = 0x8 # CUtlStringToken
m_nIndex = 0xC # FuseVariableIndex_t
m_nNumComponents = 0xE # uint8_t
m_eVarType = 0xF # FuseVariableType_t
m_eAccess = 0x10 # FuseVariableAccess_t

6
generated/resourcesystem.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.359706 UTC
* 2023-10-17 02:04:49.679145400 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod AABB_t {
pub const m_vMinBounds: usize = 0x0; // Vector
pub const m_vMaxBounds: usize = 0xC; // Vector

2
generated/scenesystem.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.675288600 UTC
* 2023-10-17 02:04:50.044809800 UTC
*/
public static class CSSDSEndFrameViewInfo {

10
generated/scenesystem.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:50.043752900 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.674184500 UTC
*/
namespace CSSDSEndFrameViewInfo {
constexpr std::ptrdiff_t m_nViewId = 0x0; // uint64_t
constexpr std::ptrdiff_t m_ViewName = 0x8; // CUtlString

44
generated/scenesystem.dll.py Normal file
View File

@ -0,0 +1,44 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:50.046158400 UTC
'''
class CSSDSEndFrameViewInfo:
m_nViewId = 0x0 # uint64_t
m_ViewName = 0x8 # CUtlString
class CSSDSMsg_EndFrame:
m_Views = 0x0 # CUtlVector<CSSDSEndFrameViewInfo>
class CSSDSMsg_LayerBase:
m_viewId = 0x0 # SceneViewId_t
m_ViewName = 0x10 # CUtlString
m_nLayerIndex = 0x18 # int32_t
m_nLayerId = 0x20 # uint64_t
m_LayerName = 0x28 # CUtlString
m_displayText = 0x30 # CUtlString
class CSSDSMsg_ViewRender:
m_viewId = 0x0 # SceneViewId_t
m_ViewName = 0x10 # CUtlString
class CSSDSMsg_ViewTarget:
m_Name = 0x0 # CUtlString
m_TextureId = 0x8 # uint64_t
m_nWidth = 0x10 # int32_t
m_nHeight = 0x14 # int32_t
m_nRequestedWidth = 0x18 # int32_t
m_nRequestedHeight = 0x1C # int32_t
m_nNumMipLevels = 0x20 # int32_t
m_nDepth = 0x24 # int32_t
m_nMultisampleNumSamples = 0x28 # int32_t
m_nFormat = 0x2C # int32_t
class CSSDSMsg_ViewTargetList:
m_viewId = 0x0 # SceneViewId_t
m_ViewName = 0x10 # CUtlString
m_Targets = 0x18 # CUtlVector<CSSDSMsg_ViewTarget>
class SceneViewId_t:
m_nViewId = 0x0 # uint64_t
m_nFrameCount = 0x8 # uint64_t

6
generated/scenesystem.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.676655900 UTC
* 2023-10-17 02:04:50.047339600 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod CSSDSEndFrameViewInfo {
pub const m_nViewId: usize = 0x0; // uint64_t
pub const m_ViewName: usize = 0x8; // CUtlString

2
generated/schemasystem.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.348418900 UTC
* 2023-10-17 02:04:49.665634700 UTC
*/
public static class CExampleSchemaVData_Monomorphic {

10
generated/schemasystem.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:49.664660100 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.347354400 UTC
*/
namespace CExampleSchemaVData_Monomorphic {
constexpr std::ptrdiff_t m_nExample1 = 0x0; // int32_t
constexpr std::ptrdiff_t m_nExample2 = 0x4; // int32_t

44
generated/schemasystem.dll.py Normal file
View File

@ -0,0 +1,44 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:49.666916200 UTC
'''
class CExampleSchemaVData_Monomorphic:
m_nExample1 = 0x0 # int32_t
m_nExample2 = 0x4 # int32_t
class CExampleSchemaVData_PolymorphicBase:
m_nBase = 0x8 # int32_t
class CExampleSchemaVData_PolymorphicDerivedA:
m_nDerivedA = 0x10 # int32_t
class CExampleSchemaVData_PolymorphicDerivedB:
m_nDerivedB = 0x10 # int32_t
class CSchemaSystemInternalRegistration:
m_Vector2D = 0x0 # Vector2D
m_Vector = 0x8 # Vector
m_VectorAligned = 0x20 # VectorAligned
m_Quaternion = 0x30 # Quaternion
m_QAngle = 0x40 # QAngle
m_RotationVector = 0x4C # RotationVector
m_RadianEuler = 0x58 # RadianEuler
m_DegreeEuler = 0x64 # DegreeEuler
m_QuaternionStorage = 0x70 # QuaternionStorage
m_matrix3x4_t = 0x80 # matrix3x4_t
m_matrix3x4a_t = 0xB0 # matrix3x4a_t
m_Color = 0xE0 # Color
m_Vector4D = 0xE4 # Vector4D
m_CTransform = 0x100 # CTransform
m_pKeyValues = 0x120 # KeyValues*
m_CUtlBinaryBlock = 0x128 # CUtlBinaryBlock
m_CUtlString = 0x140 # CUtlString
m_CUtlSymbol = 0x148 # CUtlSymbol
m_stringToken = 0x14C # CUtlStringToken
m_stringTokenWithStorage = 0x150 # CUtlStringTokenWithStorage
m_ResourceTypes = 0x168 # CResourceArray<CResourcePointer<CResourceString>>
m_KV3 = 0x170 # KeyValues3
class ResourceId_t:
m_Value = 0x0 # uint64_t

6
generated/schemasystem.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.349825800 UTC
* 2023-10-17 02:04:49.668056600 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod CExampleSchemaVData_Monomorphic {
pub const m_nExample1: usize = 0x0; // int32_t
pub const m_nExample2: usize = 0x4; // int32_t

2
generated/server.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.484000900 UTC
* 2023-10-17 02:04:50.910543800 UTC
*/
public static class ActiveModelConfig_t {

10
generated/server.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:50.840707300 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.413845700 UTC
*/
namespace ActiveModelConfig_t {
constexpr std::ptrdiff_t m_Handle = 0x28; // ModelConfigHandle_t
constexpr std::ptrdiff_t m_Name = 0x30; // CUtlSymbolLarge

5979
generated/server.dll.py Normal file
View File

File diff suppressed because it is too large Load Diff

6
generated/server.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:32.557311800 UTC
* 2023-10-17 02:04:51.051900700 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod ActiveModelConfig_t {
pub const m_Handle: usize = 0x28; // ModelConfigHandle_t
pub const m_Name: usize = 0x30; // CUtlSymbolLarge

2
generated/soundsystem.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.664413500 UTC
* 2023-10-17 02:04:50.029858700 UTC
*/
public static class CDSPMixgroupModifier {

10
generated/soundsystem.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:50.026242900 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.660932900 UTC
*/
namespace CDSPMixgroupModifier {
constexpr std::ptrdiff_t m_mixgroup = 0x0; // CUtlString
constexpr std::ptrdiff_t m_flModifier = 0x8; // float

272
generated/soundsystem.dll.py Normal file
View File

@ -0,0 +1,272 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:50.033735200 UTC
'''
class CDSPMixgroupModifier:
m_mixgroup = 0x0 # CUtlString
m_flModifier = 0x8 # float
m_flModifierMin = 0xC # float
m_flSourceModifier = 0x10 # float
m_flSourceModifierMin = 0x14 # float
m_flListenerReverbModifierWhenSourceReverbIsActive = 0x18 # float
class CDSPPresetMixgroupModifierTable:
m_table = 0x0 # CUtlVector<CDspPresetModifierList>
class CDspPresetModifierList:
m_dspName = 0x0 # CUtlString
m_modifiers = 0x8 # CUtlVector<CDSPMixgroupModifier>
class CSosGroupActionLimitSchema:
m_nMaxCount = 0x18 # int32_t
m_nStopType = 0x1C # SosActionStopType_t
m_nSortType = 0x20 # SosActionSortType_t
class CSosGroupActionSchema:
m_name = 0x8 # CUtlString
m_actionType = 0x10 # ActionType_t
m_actionInstanceType = 0x14 # ActionType_t
class CSosGroupActionSetSoundeventParameterSchema:
m_nMaxCount = 0x18 # int32_t
m_flMinValue = 0x1C # float
m_flMaxValue = 0x20 # float
m_opvarName = 0x28 # CUtlString
m_nSortType = 0x30 # SosActionSortType_t
class CSosGroupActionTimeLimitSchema:
m_flMaxDuration = 0x18 # float
class CSosGroupBranchPattern:
m_bMatchEventName = 0x8 # bool
m_bMatchEventSubString = 0x9 # bool
m_bMatchEntIndex = 0xA # bool
m_bMatchOpvar = 0xB # bool
class CSosGroupMatchPattern:
m_matchSoundEventName = 0x10 # CUtlString
m_matchSoundEventSubString = 0x18 # CUtlString
m_flEntIndex = 0x20 # float
m_flOpvar = 0x24 # float
class CSosSoundEventGroupListSchema:
m_groupList = 0x0 # CUtlVector<CSosSoundEventGroupSchema>
class CSosSoundEventGroupSchema:
m_name = 0x0 # CUtlString
m_nType = 0x8 # SosGroupType_t
m_bIsBlocking = 0xC # bool
m_nBlockMaxCount = 0x10 # int32_t
m_bInvertMatch = 0x14 # bool
m_matchPattern = 0x18 # CSosGroupMatchPattern
m_branchPattern = 0x40 # CSosGroupBranchPattern
m_vActions = 0xB0 # CSosGroupActionSchema*[4]
class CSoundEventMetaData:
m_soundEventVMix = 0x0 # CStrongHandle<InfoForResourceTypeCVMixListResource>
class SelectedEditItemInfo_t:
m_EditItems = 0x0 # CUtlVector<SosEditItemInfo_t>
class SosEditItemInfo_t:
itemType = 0x0 # SosEditItemType_t
itemName = 0x8 # CUtlString
itemTypeName = 0x10 # CUtlString
itemKVString = 0x20 # CUtlString
itemPos = 0x28 # Vector2D
class VMixAutoFilterDesc_t:
m_flEnvelopeAmount = 0x0 # float
m_flAttackTimeMS = 0x4 # float
m_flReleaseTimeMS = 0x8 # float
m_filter = 0xC # VMixFilterDesc_t
m_flLFOAmount = 0x1C # float
m_flLFORate = 0x20 # float
m_flPhase = 0x24 # float
m_nLFOShape = 0x28 # VMixLFOShape_t
class VMixBoxverbDesc_t:
m_flSizeMax = 0x0 # float
m_flSizeMin = 0x4 # float
m_flComplexity = 0x8 # float
m_flDiffusion = 0xC # float
m_flModDepth = 0x10 # float
m_flModRate = 0x14 # float
m_bParallel = 0x18 # bool
m_filterType = 0x1C # VMixFilterDesc_t
m_flWidth = 0x2C # float
m_flHeight = 0x30 # float
m_flDepth = 0x34 # float
m_flFeedbackScale = 0x38 # float
m_flFeedbackWidth = 0x3C # float
m_flFeedbackHeight = 0x40 # float
m_flFeedbackDepth = 0x44 # float
m_flOutputGain = 0x48 # float
m_flTaps = 0x4C # float
class VMixConvolutionDesc_t:
m_fldbGain = 0x0 # float
m_flPreDelayMS = 0x4 # float
m_flWetMix = 0x8 # float
m_fldbLow = 0xC # float
m_fldbMid = 0x10 # float
m_fldbHigh = 0x14 # float
m_flLowCutoffFreq = 0x18 # float
m_flHighCutoffFreq = 0x1C # float
class VMixDelayDesc_t:
m_feedbackFilter = 0x0 # VMixFilterDesc_t
m_bEnableFilter = 0x10 # bool
m_flDelay = 0x14 # float
m_flDirectGain = 0x18 # float
m_flDelayGain = 0x1C # float
m_flFeedbackGain = 0x20 # float
m_flWidth = 0x24 # float
class VMixDiffusorDesc_t:
m_flSize = 0x0 # float
m_flComplexity = 0x4 # float
m_flFeedback = 0x8 # float
m_flOutputGain = 0xC # float
class VMixDynamics3BandDesc_t:
m_fldbGainOutput = 0x0 # float
m_flRMSTimeMS = 0x4 # float
m_fldbKneeWidth = 0x8 # float
m_flDepth = 0xC # float
m_flWetMix = 0x10 # float
m_flTimeScale = 0x14 # float
m_flLowCutoffFreq = 0x18 # float
m_flHighCutoffFreq = 0x1C # float
m_bPeakMode = 0x20 # bool
m_bandDesc = 0x24 # VMixDynamicsBand_t[3]
class VMixDynamicsBand_t:
m_fldbGainInput = 0x0 # float
m_fldbGainOutput = 0x4 # float
m_fldbThresholdBelow = 0x8 # float
m_fldbThresholdAbove = 0xC # float
m_flRatioBelow = 0x10 # float
m_flRatioAbove = 0x14 # float
m_flAttackTimeMS = 0x18 # float
m_flReleaseTimeMS = 0x1C # float
m_bEnable = 0x20 # bool
m_bSolo = 0x21 # bool
class VMixDynamicsCompressorDesc_t:
m_fldbOutputGain = 0x0 # float
m_fldbCompressionThreshold = 0x4 # float
m_fldbKneeWidth = 0x8 # float
m_flCompressionRatio = 0xC # float
m_flAttackTimeMS = 0x10 # float
m_flReleaseTimeMS = 0x14 # float
m_flRMSTimeMS = 0x18 # float
m_flWetMix = 0x1C # float
m_bPeakMode = 0x20 # bool
class VMixDynamicsDesc_t:
m_fldbGain = 0x0 # float
m_fldbNoiseGateThreshold = 0x4 # float
m_fldbCompressionThreshold = 0x8 # float
m_fldbLimiterThreshold = 0xC # float
m_fldbKneeWidth = 0x10 # float
m_flRatio = 0x14 # float
m_flLimiterRatio = 0x18 # float
m_flAttackTimeMS = 0x1C # float
m_flReleaseTimeMS = 0x20 # float
m_flRMSTimeMS = 0x24 # float
m_flWetMix = 0x28 # float
m_bPeakMode = 0x2C # bool
class VMixEQ8Desc_t:
m_stages = 0x0 # VMixFilterDesc_t[8]
class VMixEffectChainDesc_t:
m_flCrossfadeTime = 0x0 # float
class VMixEnvelopeDesc_t:
m_flAttackTimeMS = 0x0 # float
m_flHoldTimeMS = 0x4 # float
m_flReleaseTimeMS = 0x8 # float
class VMixFilterDesc_t:
m_nFilterType = 0x0 # VMixFilterType_t
m_nFilterSlope = 0x2 # VMixFilterSlope_t
m_bEnabled = 0x3 # bool
m_fldbGain = 0x4 # float
m_flCutoffFreq = 0x8 # float
m_flQ = 0xC # float
class VMixFreeverbDesc_t:
m_flRoomSize = 0x0 # float
m_flDamp = 0x4 # float
m_flWidth = 0x8 # float
m_flLateReflections = 0xC # float
class VMixModDelayDesc_t:
m_feedbackFilter = 0x0 # VMixFilterDesc_t
m_bPhaseInvert = 0x10 # bool
m_flGlideTime = 0x14 # float
m_flDelay = 0x18 # float
m_flOutputGain = 0x1C # float
m_flFeedbackGain = 0x20 # float
m_flModRate = 0x24 # float
m_flModDepth = 0x28 # float
m_bApplyAntialiasing = 0x2C # bool
class VMixOscDesc_t:
oscType = 0x0 # VMixLFOShape_t
m_freq = 0x4 # float
m_flPhase = 0x8 # float
class VMixPannerDesc_t:
m_type = 0x0 # VMixPannerType_t
m_flStrength = 0x4 # float
class VMixPitchShiftDesc_t:
m_nGrainSampleCount = 0x0 # int32_t
m_flPitchShift = 0x4 # float
m_nQuality = 0x8 # int32_t
m_nProcType = 0xC # int32_t
class VMixPlateverbDesc_t:
m_flPrefilter = 0x0 # float
m_flInputDiffusion1 = 0x4 # float
m_flInputDiffusion2 = 0x8 # float
m_flDecay = 0xC # float
m_flDamp = 0x10 # float
m_flFeedbackDiffusion1 = 0x14 # float
m_flFeedbackDiffusion2 = 0x18 # float
class VMixShaperDesc_t:
m_nShape = 0x0 # int32_t
m_fldbDrive = 0x4 # float
m_fldbOutputGain = 0x8 # float
m_flWetMix = 0xC # float
m_nOversampleFactor = 0x10 # int32_t
class VMixSubgraphSwitchDesc_t:
m_interpolationMode = 0x0 # VMixSubgraphSwitchInterpolationType_t
m_bOnlyTailsOnFadeOut = 0x4 # bool
m_flInterpolationTime = 0x8 # float
class VMixUtilityDesc_t:
m_nOp = 0x0 # VMixChannelOperation_t
m_flInputPan = 0x4 # float
m_flOutputBalance = 0x8 # float
m_fldbOutputGain = 0xC # float
m_bBassMono = 0x10 # bool
m_flBassFreq = 0x14 # float
class VMixVocoderDesc_t:
m_nBandCount = 0x0 # int32_t
m_flBandwidth = 0x4 # float
m_fldBModGain = 0x8 # float
m_flFreqRangeStart = 0xC # float
m_flFreqRangeEnd = 0x10 # float
m_fldBUnvoicedGain = 0x14 # float
m_flAttackTimeMS = 0x18 # float
m_flReleaseTimeMS = 0x1C # float
m_nDebugBand = 0x20 # int32_t
m_bPeakMode = 0x24 # bool

6
generated/soundsystem.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.668319800 UTC
* 2023-10-17 02:04:50.037373800 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod CDSPMixgroupModifier {
pub const m_mixgroup: usize = 0x0; // CUtlString
pub const m_flModifier: usize = 0x8; // float

2
generated/vphysics2.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.630609100 UTC
* 2023-10-17 02:04:49.986319 UTC
*/
public static class CFeIndexedJiggleBone {

10
generated/vphysics2.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:49.978664900 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.622787900 UTC
*/
namespace CFeIndexedJiggleBone {
constexpr std::ptrdiff_t m_nNode = 0x0; // uint32_t
constexpr std::ptrdiff_t m_nJiggleParent = 0x4; // uint32_t

657
generated/vphysics2.dll.py Normal file
View File

@ -0,0 +1,657 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:49.994354200 UTC
'''
class CFeIndexedJiggleBone:
m_nNode = 0x0 # uint32_t
m_nJiggleParent = 0x4 # uint32_t
m_jiggleBone = 0x8 # CFeJiggleBone
class CFeJiggleBone:
m_nFlags = 0x0 # uint32_t
m_flLength = 0x4 # float
m_flTipMass = 0x8 # float
m_flYawStiffness = 0xC # float
m_flYawDamping = 0x10 # float
m_flPitchStiffness = 0x14 # float
m_flPitchDamping = 0x18 # float
m_flAlongStiffness = 0x1C # float
m_flAlongDamping = 0x20 # float
m_flAngleLimit = 0x24 # float
m_flMinYaw = 0x28 # float
m_flMaxYaw = 0x2C # float
m_flYawFriction = 0x30 # float
m_flYawBounce = 0x34 # float
m_flMinPitch = 0x38 # float
m_flMaxPitch = 0x3C # float
m_flPitchFriction = 0x40 # float
m_flPitchBounce = 0x44 # float
m_flBaseMass = 0x48 # float
m_flBaseStiffness = 0x4C # float
m_flBaseDamping = 0x50 # float
m_flBaseMinLeft = 0x54 # float
m_flBaseMaxLeft = 0x58 # float
m_flBaseLeftFriction = 0x5C # float
m_flBaseMinUp = 0x60 # float
m_flBaseMaxUp = 0x64 # float
m_flBaseUpFriction = 0x68 # float
m_flBaseMinForward = 0x6C # float
m_flBaseMaxForward = 0x70 # float
m_flBaseForwardFriction = 0x74 # float
m_flRadius0 = 0x78 # float
m_flRadius1 = 0x7C # float
m_vPoint0 = 0x80 # Vector
m_vPoint1 = 0x8C # Vector
m_nCollisionMask = 0x98 # uint16_t
class CFeMorphLayer:
m_Name = 0x0 # CUtlString
m_nNameHash = 0x8 # uint32_t
m_Nodes = 0x10 # CUtlVector<uint16_t>
m_InitPos = 0x28 # CUtlVector<Vector>
m_Gravity = 0x40 # CUtlVector<float>
m_GoalStrength = 0x58 # CUtlVector<float>
m_GoalDamping = 0x70 # CUtlVector<float>
class CFeNamedJiggleBone:
m_strParentBone = 0x0 # CUtlString
m_transform = 0x10 # CTransform
m_nJiggleParent = 0x30 # uint32_t
m_jiggleBone = 0x34 # CFeJiggleBone
class CFeVertexMapBuildArray:
m_Array = 0x0 # CUtlVector<FeVertexMapBuild_t*>
class CRegionSVM:
m_Planes = 0x0 # CUtlVector<RnPlane_t>
m_Nodes = 0x18 # CUtlVector<uint32_t>
class CastSphereSATParams_t:
m_vRayStart = 0x0 # Vector
m_vRayDelta = 0xC # Vector
m_flRadius = 0x18 # float
m_flMaxFraction = 0x1C # float
m_flScale = 0x20 # float
m_pHull = 0x28 # RnHull_t*
class CovMatrix3:
m_vDiag = 0x0 # Vector
m_flXY = 0xC # float
m_flXZ = 0x10 # float
m_flYZ = 0x14 # float
class Dop26_t:
m_flSupport = 0x0 # float[26]
class FeAnimStrayRadius_t:
nNode = 0x0 # uint16_t[2]
flMaxDist = 0x4 # float
flRelaxationFactor = 0x8 # float
class FeAxialEdgeBend_t:
te = 0x0 # float
tv = 0x4 # float
flDist = 0x8 # float
flWeight = 0xC # float[4]
nNode = 0x1C # uint16_t[6]
class FeBandBendLimit_t:
flDistMin = 0x0 # float
flDistMax = 0x4 # float
nNode = 0x8 # uint16_t[6]
class FeBoxRigid_t:
tmFrame2 = 0x0 # CTransform
nNode = 0x20 # uint16_t
nCollisionMask = 0x22 # uint16_t
vSize = 0x24 # Vector
nVertexMapIndex = 0x30 # uint16_t
nFlags = 0x32 # uint16_t
class FeBuildBoxRigid_t:
m_nPriority = 0x40 # int32_t
m_nVertexMapHash = 0x44 # uint32_t
class FeBuildSphereRigid_t:
m_nPriority = 0x20 # int32_t
m_nVertexMapHash = 0x24 # uint32_t
class FeBuildTaperedCapsuleRigid_t:
m_nPriority = 0x30 # int32_t
m_nVertexMapHash = 0x34 # uint32_t
class FeCollisionPlane_t:
nCtrlParent = 0x0 # uint16_t
nChildNode = 0x2 # uint16_t
m_Plane = 0x4 # RnPlane_t
flStrength = 0x14 # float
class FeCtrlOffset_t:
vOffset = 0x0 # Vector
nCtrlParent = 0xC # uint16_t
nCtrlChild = 0xE # uint16_t
class FeCtrlOsOffset_t:
nCtrlParent = 0x0 # uint16_t
nCtrlChild = 0x2 # uint16_t
class FeCtrlSoftOffset_t:
nCtrlParent = 0x0 # uint16_t
nCtrlChild = 0x2 # uint16_t
vOffset = 0x4 # Vector
flAlpha = 0x10 # float
class FeEdgeDesc_t:
nEdge = 0x0 # uint16_t[2]
nSide = 0x4 # uint16_t[2][2]
nVirtElem = 0xC # uint16_t[2]
class FeEffectDesc_t:
sName = 0x0 # CUtlString
nNameHash = 0x8 # uint32_t
nType = 0xC # int32_t
m_Params = 0x10 # KeyValues3
class FeFitInfluence_t:
nVertexNode = 0x0 # uint32_t
flWeight = 0x4 # float
nMatrixNode = 0x8 # uint32_t
class FeFitMatrix_t:
bone = 0x0 # CTransform
vCenter = 0x20 # Vector
nEnd = 0x2C # uint16_t
nNode = 0x2E # uint16_t
nBeginDynamic = 0x30 # uint16_t
class FeFitWeight_t:
flWeight = 0x0 # float
nNode = 0x4 # uint16_t
nDummy = 0x6 # uint16_t
class FeFollowNode_t:
nParentNode = 0x0 # uint16_t
nChildNode = 0x2 # uint16_t
flWeight = 0x4 # float
class FeKelagerBend2_t:
flWeight = 0x0 # float[3]
flHeight0 = 0xC # float
nNode = 0x10 # uint16_t[3]
nReserved = 0x16 # uint16_t
class FeMorphLayerDepr_t:
m_Name = 0x0 # CUtlString
m_nNameHash = 0x8 # uint32_t
m_Nodes = 0x10 # CUtlVector<uint16_t>
m_InitPos = 0x28 # CUtlVector<Vector>
m_Gravity = 0x40 # CUtlVector<float>
m_GoalStrength = 0x58 # CUtlVector<float>
m_GoalDamping = 0x70 # CUtlVector<float>
m_nFlags = 0x88 # uint32_t
class FeNodeBase_t:
nNode = 0x0 # uint16_t
nDummy = 0x2 # uint16_t[3]
nNodeX0 = 0x8 # uint16_t
nNodeX1 = 0xA # uint16_t
nNodeY0 = 0xC # uint16_t
nNodeY1 = 0xE # uint16_t
qAdjust = 0x10 # QuaternionStorage
class FeNodeIntegrator_t:
flPointDamping = 0x0 # float
flAnimationForceAttraction = 0x4 # float
flAnimationVertexAttraction = 0x8 # float
flGravity = 0xC # float
class FeNodeReverseOffset_t:
vOffset = 0x0 # Vector
nBoneCtrl = 0xC # uint16_t
nTargetNode = 0xE # uint16_t
class FeNodeWindBase_t:
nNodeX0 = 0x0 # uint16_t
nNodeX1 = 0x2 # uint16_t
nNodeY0 = 0x4 # uint16_t
nNodeY1 = 0x6 # uint16_t
class FeProxyVertexMap_t:
m_Name = 0x0 # CUtlString
m_flWeight = 0x8 # float
class FeQuad_t:
nNode = 0x0 # uint16_t[4]
flSlack = 0x8 # float
vShape = 0xC # Vector4D[4]
class FeRigidColliderIndices_t:
m_nTaperedCapsuleRigidIndex = 0x0 # uint16_t
m_nSphereRigidIndex = 0x2 # uint16_t
m_nBoxRigidIndex = 0x4 # uint16_t
m_nCollisionPlaneIndex = 0x6 # uint16_t
class FeRodConstraint_t:
nNode = 0x0 # uint16_t[2]
flMaxDist = 0x4 # float
flMinDist = 0x8 # float
flWeight0 = 0xC # float
flRelaxationFactor = 0x10 # float
class FeSimdAnimStrayRadius_t:
nNode = 0x0 # uint16_t[4][2]
flMaxDist = 0x10 # fltx4
flRelaxationFactor = 0x20 # fltx4
class FeSimdNodeBase_t:
nNode = 0x0 # uint16_t[4]
nNodeX0 = 0x8 # uint16_t[4]
nNodeX1 = 0x10 # uint16_t[4]
nNodeY0 = 0x18 # uint16_t[4]
nNodeY1 = 0x20 # uint16_t[4]
nDummy = 0x28 # uint16_t[4]
qAdjust = 0x30 # FourQuaternions
class FeSimdQuad_t:
nNode = 0x0 # uint16_t[4][4]
f4Slack = 0x20 # fltx4
vShape = 0x30 # FourVectors[4]
f4Weights = 0xF0 # fltx4[4]
class FeSimdRodConstraint_t:
nNode = 0x0 # uint16_t[4][2]
f4MaxDist = 0x10 # fltx4
f4MinDist = 0x20 # fltx4
f4Weight0 = 0x30 # fltx4
f4RelaxationFactor = 0x40 # fltx4
class FeSimdSpringIntegrator_t:
nNode = 0x0 # uint16_t[4][2]
flSpringRestLength = 0x10 # fltx4
flSpringConstant = 0x20 # fltx4
flSpringDamping = 0x30 # fltx4
flNodeWeight0 = 0x40 # fltx4
class FeSimdTri_t:
nNode = 0x0 # uint32_t[4][3]
w1 = 0x30 # fltx4
w2 = 0x40 # fltx4
v1x = 0x50 # fltx4
v2 = 0x60 # FourVectors2D
class FeSoftParent_t:
nParent = 0x0 # int32_t
flAlpha = 0x4 # float
class FeSourceEdge_t:
nNode = 0x0 # uint16_t[2]
class FeSphereRigid_t:
vSphere = 0x0 # fltx4
nNode = 0x10 # uint16_t
nCollisionMask = 0x12 # uint16_t
nVertexMapIndex = 0x14 # uint16_t
nFlags = 0x16 # uint16_t
class FeSpringIntegrator_t:
nNode = 0x0 # uint16_t[2]
flSpringRestLength = 0x4 # float
flSpringConstant = 0x8 # float
flSpringDamping = 0xC # float
flNodeWeight0 = 0x10 # float
class FeStiffHingeBuild_t:
flMaxAngle = 0x0 # float
flStrength = 0x4 # float
flMotionBias = 0x8 # float[3]
nNode = 0x14 # uint16_t[3]
class FeTaperedCapsuleRigid_t:
vSphere = 0x0 # fltx4[2]
nNode = 0x20 # uint16_t
nCollisionMask = 0x22 # uint16_t
nVertexMapIndex = 0x24 # uint16_t
nFlags = 0x26 # uint16_t
class FeTaperedCapsuleStretch_t:
nNode = 0x0 # uint16_t[2]
nCollisionMask = 0x4 # uint16_t
nDummy = 0x6 # uint16_t
flRadius = 0x8 # float[2]
class FeTreeChildren_t:
nChild = 0x0 # uint16_t[2]
class FeTri_t:
nNode = 0x0 # uint16_t[3]
w1 = 0x8 # float
w2 = 0xC # float
v1x = 0x10 # float
v2 = 0x14 # Vector2D
class FeTwistConstraint_t:
nNodeOrient = 0x0 # uint16_t
nNodeEnd = 0x2 # uint16_t
flTwistRelax = 0x4 # float
flSwingRelax = 0x8 # float
class FeVertexMapBuild_t:
m_VertexMapName = 0x0 # CUtlString
m_nNameHash = 0x8 # uint32_t
m_Color = 0xC # Color
m_flVolumetricSolveStrength = 0x10 # float
m_nScaleSourceNode = 0x14 # int32_t
m_Weights = 0x18 # CUtlVector<float>
class FeVertexMapDesc_t:
sName = 0x0 # CUtlString
nNameHash = 0x8 # uint32_t
nColor = 0xC # uint32_t
nFlags = 0x10 # uint32_t
nVertexBase = 0x14 # uint16_t
nVertexCount = 0x16 # uint16_t
nMapOffset = 0x18 # uint32_t
nNodeListOffset = 0x1C # uint32_t
vCenterOfMass = 0x20 # Vector
flVolumetricSolveStrength = 0x2C # float
nScaleSourceNode = 0x30 # int16_t
nNodeListCount = 0x32 # uint16_t
class FeWeightedNode_t:
nNode = 0x0 # uint16_t
nWeight = 0x2 # uint16_t
class FeWorldCollisionParams_t:
flWorldFriction = 0x0 # float
flGroundFriction = 0x4 # float
nListBegin = 0x8 # uint16_t
nListEnd = 0xA # uint16_t
class FourCovMatrices3:
m_vDiag = 0x0 # FourVectors
m_flXY = 0x30 # fltx4
m_flXZ = 0x40 # fltx4
m_flYZ = 0x50 # fltx4
class FourVectors2D:
x = 0x0 # fltx4
y = 0x10 # fltx4
class OldFeEdge_t:
m_flK = 0x0 # float[3]
invA = 0xC # float
t = 0x10 # float
flThetaRelaxed = 0x14 # float
flThetaFactor = 0x18 # float
c01 = 0x1C # float
c02 = 0x20 # float
c03 = 0x24 # float
c04 = 0x28 # float
flAxialModelDist = 0x2C # float
flAxialModelWeights = 0x30 # float[4]
m_nNode = 0x40 # uint16_t[4]
class PhysFeModelDesc_t:
m_CtrlHash = 0x0 # CUtlVector<uint32_t>
m_CtrlName = 0x18 # CUtlVector<CUtlString>
m_nStaticNodeFlags = 0x30 # uint32_t
m_nDynamicNodeFlags = 0x34 # uint32_t
m_flLocalForce = 0x38 # float
m_flLocalRotation = 0x3C # float
m_nNodeCount = 0x40 # uint16_t
m_nStaticNodes = 0x42 # uint16_t
m_nRotLockStaticNodes = 0x44 # uint16_t
m_nFirstPositionDrivenNode = 0x46 # uint16_t
m_nSimdTriCount1 = 0x48 # uint16_t
m_nSimdTriCount2 = 0x4A # uint16_t
m_nSimdQuadCount1 = 0x4C # uint16_t
m_nSimdQuadCount2 = 0x4E # uint16_t
m_nQuadCount1 = 0x50 # uint16_t
m_nQuadCount2 = 0x52 # uint16_t
m_nTreeDepth = 0x54 # uint16_t
m_nNodeBaseJiggleboneDependsCount = 0x56 # uint16_t
m_nRopeCount = 0x58 # uint16_t
m_Ropes = 0x60 # CUtlVector<uint16_t>
m_NodeBases = 0x78 # CUtlVector<FeNodeBase_t>
m_SimdNodeBases = 0x90 # CUtlVector<FeSimdNodeBase_t>
m_Quads = 0xA8 # CUtlVector<FeQuad_t>
m_SimdQuads = 0xC0 # CUtlVector<FeSimdQuad_t>
m_SimdTris = 0xD8 # CUtlVector<FeSimdTri_t>
m_SimdRods = 0xF0 # CUtlVector<FeSimdRodConstraint_t>
m_InitPose = 0x108 # CUtlVector<CTransform>
m_Rods = 0x120 # CUtlVector<FeRodConstraint_t>
m_Twists = 0x138 # CUtlVector<FeTwistConstraint_t>
m_AxialEdges = 0x150 # CUtlVector<FeAxialEdgeBend_t>
m_NodeInvMasses = 0x168 # CUtlVector<float>
m_CtrlOffsets = 0x180 # CUtlVector<FeCtrlOffset_t>
m_CtrlOsOffsets = 0x198 # CUtlVector<FeCtrlOsOffset_t>
m_FollowNodes = 0x1B0 # CUtlVector<FeFollowNode_t>
m_CollisionPlanes = 0x1C8 # CUtlVector<FeCollisionPlane_t>
m_NodeIntegrator = 0x1E0 # CUtlVector<FeNodeIntegrator_t>
m_SpringIntegrator = 0x1F8 # CUtlVector<FeSpringIntegrator_t>
m_SimdSpringIntegrator = 0x210 # CUtlVector<FeSimdSpringIntegrator_t>
m_WorldCollisionParams = 0x228 # CUtlVector<FeWorldCollisionParams_t>
m_LegacyStretchForce = 0x240 # CUtlVector<float>
m_NodeCollisionRadii = 0x258 # CUtlVector<float>
m_DynNodeFriction = 0x270 # CUtlVector<float>
m_LocalRotation = 0x288 # CUtlVector<float>
m_LocalForce = 0x2A0 # CUtlVector<float>
m_TaperedCapsuleStretches = 0x2B8 # CUtlVector<FeTaperedCapsuleStretch_t>
m_TaperedCapsuleRigids = 0x2D0 # CUtlVector<FeTaperedCapsuleRigid_t>
m_SphereRigids = 0x2E8 # CUtlVector<FeSphereRigid_t>
m_WorldCollisionNodes = 0x300 # CUtlVector<uint16_t>
m_TreeParents = 0x318 # CUtlVector<uint16_t>
m_TreeCollisionMasks = 0x330 # CUtlVector<uint16_t>
m_TreeChildren = 0x348 # CUtlVector<FeTreeChildren_t>
m_FreeNodes = 0x360 # CUtlVector<uint16_t>
m_FitMatrices = 0x378 # CUtlVector<FeFitMatrix_t>
m_FitWeights = 0x390 # CUtlVector<FeFitWeight_t>
m_ReverseOffsets = 0x3A8 # CUtlVector<FeNodeReverseOffset_t>
m_AnimStrayRadii = 0x3C0 # CUtlVector<FeAnimStrayRadius_t>
m_SimdAnimStrayRadii = 0x3D8 # CUtlVector<FeSimdAnimStrayRadius_t>
m_KelagerBends = 0x3F0 # CUtlVector<FeKelagerBend2_t>
m_CtrlSoftOffsets = 0x408 # CUtlVector<FeCtrlSoftOffset_t>
m_JiggleBones = 0x420 # CUtlVector<CFeIndexedJiggleBone>
m_SourceElems = 0x438 # CUtlVector<uint16_t>
m_GoalDampedSpringIntegrators = 0x450 # CUtlVector<uint32_t>
m_Tris = 0x468 # CUtlVector<FeTri_t>
m_nTriCount1 = 0x480 # uint16_t
m_nTriCount2 = 0x482 # uint16_t
m_nReservedUint8 = 0x484 # uint8_t
m_nExtraPressureIterations = 0x485 # uint8_t
m_nExtraGoalIterations = 0x486 # uint8_t
m_nExtraIterations = 0x487 # uint8_t
m_BoxRigids = 0x488 # CUtlVector<FeBoxRigid_t>
m_DynNodeVertexSet = 0x4A0 # CUtlVector<uint8_t>
m_VertexSetNames = 0x4B8 # CUtlVector<uint32_t>
m_RigidColliderPriorities = 0x4D0 # CUtlVector<FeRigidColliderIndices_t>
m_MorphLayers = 0x4E8 # CUtlVector<FeMorphLayerDepr_t>
m_MorphSetData = 0x500 # CUtlVector<uint8_t>
m_VertexMaps = 0x518 # CUtlVector<FeVertexMapDesc_t>
m_VertexMapValues = 0x530 # CUtlVector<uint8_t>
m_Effects = 0x548 # CUtlVector<FeEffectDesc_t>
m_LockToParent = 0x560 # CUtlVector<FeCtrlOffset_t>
m_LockToGoal = 0x578 # CUtlVector<uint16_t>
m_DynNodeWindBases = 0x590 # CUtlVector<FeNodeWindBase_t>
m_flInternalPressure = 0x5A8 # float
m_flDefaultTimeDilation = 0x5AC # float
m_flWindage = 0x5B0 # float
m_flWindDrag = 0x5B4 # float
m_flDefaultSurfaceStretch = 0x5B8 # float
m_flDefaultThreadStretch = 0x5BC # float
m_flDefaultGravityScale = 0x5C0 # float
m_flDefaultVelAirDrag = 0x5C4 # float
m_flDefaultExpAirDrag = 0x5C8 # float
m_flDefaultVelQuadAirDrag = 0x5CC # float
m_flDefaultExpQuadAirDrag = 0x5D0 # float
m_flRodVelocitySmoothRate = 0x5D4 # float
m_flQuadVelocitySmoothRate = 0x5D8 # float
m_flAddWorldCollisionRadius = 0x5DC # float
m_flDefaultVolumetricSolveAmount = 0x5E0 # float
m_nRodVelocitySmoothIterations = 0x5E4 # uint16_t
m_nQuadVelocitySmoothIterations = 0x5E6 # uint16_t
class RnBlendVertex_t:
m_nWeight0 = 0x0 # uint16_t
m_nIndex0 = 0x2 # uint16_t
m_nWeight1 = 0x4 # uint16_t
m_nIndex1 = 0x6 # uint16_t
m_nWeight2 = 0x8 # uint16_t
m_nIndex2 = 0xA # uint16_t
m_nFlags = 0xC # uint16_t
m_nTargetIndex = 0xE # uint16_t
class RnBodyDesc_t:
m_sDebugName = 0x0 # CUtlString
m_vPosition = 0x8 # Vector
m_qOrientation = 0x14 # QuaternionStorage
m_vLinearVelocity = 0x24 # Vector
m_vAngularVelocity = 0x30 # Vector
m_vLocalMassCenter = 0x3C # Vector
m_LocalInertiaInv = 0x48 # Vector[3]
m_flMassInv = 0x6C # float
m_flGameMass = 0x70 # float
m_flInertiaScaleInv = 0x74 # float
m_flLinearDamping = 0x78 # float
m_flAngularDamping = 0x7C # float
m_flLinearDrag = 0x80 # float
m_flAngularDrag = 0x84 # float
m_flLinearBuoyancyDrag = 0x88 # float
m_flAngularBuoyancyDrag = 0x8C # float
m_vLastAwakeForceAccum = 0x90 # Vector
m_vLastAwakeTorqueAccum = 0x9C # Vector
m_flBuoyancyFactor = 0xA8 # float
m_flGravityScale = 0xAC # float
m_flTimeScale = 0xB0 # float
m_nBodyType = 0xB4 # int32_t
m_nGameIndex = 0xB8 # uint32_t
m_nGameFlags = 0xBC # uint32_t
m_nMinVelocityIterations = 0xC0 # int8_t
m_nMinPositionIterations = 0xC1 # int8_t
m_nMassPriority = 0xC2 # int8_t
m_bEnabled = 0xC3 # bool
m_bSleeping = 0xC4 # bool
m_bIsContinuousEnabled = 0xC5 # bool
m_bDragEnabled = 0xC6 # bool
m_bBuoyancyDragEnabled = 0xC7 # bool
m_bGravityDisabled = 0xC8 # bool
m_bSpeculativeEnabled = 0xC9 # bool
m_bHasShadowController = 0xCA # bool
class RnCapsuleDesc_t:
m_Capsule = 0x10 # RnCapsule_t
class RnCapsule_t:
m_vCenter = 0x0 # Vector[2]
m_flRadius = 0x18 # float
class RnFace_t:
m_nEdge = 0x0 # uint8_t
class RnHalfEdge_t:
m_nNext = 0x0 # uint8_t
m_nTwin = 0x1 # uint8_t
m_nOrigin = 0x2 # uint8_t
m_nFace = 0x3 # uint8_t
class RnHullDesc_t:
m_Hull = 0x10 # RnHull_t
class RnHull_t:
m_vCentroid = 0x0 # Vector
m_flMaxAngularRadius = 0xC # float
m_Bounds = 0x10 # AABB_t
m_vOrthographicAreas = 0x28 # Vector
m_MassProperties = 0x34 # matrix3x4_t
m_flVolume = 0x64 # float
m_Vertices = 0x68 # CUtlVector<Vector>
m_Edges = 0x80 # CUtlVector<RnHalfEdge_t>
m_Faces = 0x98 # CUtlVector<RnFace_t>
m_Planes = 0xB0 # CUtlVector<RnPlane_t>
m_nFlags = 0xC8 # uint32_t
m_pRegionSVM = 0xD0 # CRegionSVM*
class RnMeshDesc_t:
m_Mesh = 0x10 # RnMesh_t
class RnMesh_t:
m_vMin = 0x0 # Vector
m_vMax = 0xC # Vector
m_Nodes = 0x18 # CUtlVector<RnNode_t>
m_Vertices = 0x30 # CUtlVectorSIMDPaddedVector
m_Triangles = 0x48 # CUtlVector<RnTriangle_t>
m_Wings = 0x60 # CUtlVector<RnWing_t>
m_Materials = 0x78 # CUtlVector<uint8_t>
m_vOrthographicAreas = 0x90 # Vector
m_nFlags = 0x9C # uint32_t
m_nDebugFlags = 0xA0 # uint32_t
class RnNode_t:
m_vMin = 0x0 # Vector
m_nChildren = 0xC # uint32_t
m_vMax = 0x10 # Vector
m_nTriangleOffset = 0x1C # uint32_t
class RnPlane_t:
m_vNormal = 0x0 # Vector
m_flOffset = 0xC # float
class RnShapeDesc_t:
m_nCollisionAttributeIndex = 0x0 # uint32_t
m_nSurfacePropertyIndex = 0x4 # uint32_t
m_UserFriendlyName = 0x8 # CUtlString
class RnSoftbodyCapsule_t:
m_vCenter = 0x0 # Vector[2]
m_flRadius = 0x18 # float
m_nParticle = 0x1C # uint16_t[2]
class RnSoftbodyParticle_t:
m_flMassInv = 0x0 # float
class RnSoftbodySpring_t:
m_nParticle = 0x0 # uint16_t[2]
m_flLength = 0x4 # float
class RnSphereDesc_t:
m_Sphere = 0x10 # RnSphere_t
class RnSphere_t:
m_vCenter = 0x0 # Vector
m_flRadius = 0xC # float
class RnTriangle_t:
m_nIndex = 0x0 # int32_t[3]
class RnWing_t:
m_nIndex = 0x0 # int32_t[3]
class VertexPositionColor_t:
m_vPosition = 0x0 # Vector
class VertexPositionNormal_t:
m_vPosition = 0x0 # Vector
m_vNormal = 0xC # Vector
class constraint_axislimit_t:
flMinRotation = 0x0 # float
flMaxRotation = 0x4 # float
flMotorTargetAngSpeed = 0x8 # float
flMotorMaxTorque = 0xC # float
class constraint_breakableparams_t:
strength = 0x0 # float
forceLimit = 0x4 # float
torqueLimit = 0x8 # float
bodyMassScale = 0xC # float[2]
isActive = 0x14 # bool
class constraint_hingeparams_t:
worldPosition = 0x0 # Vector
worldAxisDirection = 0xC # Vector
hingeAxis = 0x18 # constraint_axislimit_t
constraint = 0x28 # constraint_breakableparams_t
class vphysics_save_cphysicsbody_t:
m_nOldPointer = 0xD0 # uint64_t

6
generated/vphysics2.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.638771500 UTC
* 2023-10-17 02:04:50.002943900 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod CFeIndexedJiggleBone {
pub const m_nNode: usize = 0x0; // uint32_t
pub const m_nJiggleParent: usize = 0x4; // uint32_t

2
generated/worldrenderer.dll.cs
View File

@ -1,6 +1,6 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.691751700 UTC
* 2023-10-17 02:04:50.063331200 UTC
*/
public static class AggregateLODSetup_t {

10
generated/worldrenderer.dll.hpp
View File

@ -1,12 +1,12 @@
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-17 02:04:50.060524800 UTC
*/
#pragma once
#include <cstddef>
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.689004 UTC
*/
namespace AggregateLODSetup_t {
constexpr std::ptrdiff_t m_vLODOrigin = 0x0; // Vector
constexpr std::ptrdiff_t m_fMaxObjectScale = 0xC; // float

197
generated/worldrenderer.dll.py Normal file
View File

@ -0,0 +1,197 @@
'''
https://github.com/a2x/cs2-dumper
2023-10-17 02:04:50.066321500 UTC
'''
class AggregateLODSetup_t:
m_vLODOrigin = 0x0 # Vector
m_fMaxObjectScale = 0xC # float
m_fSwitchDistances = 0x10 # CUtlVectorFixedGrowable<float>
class AggregateMeshInfo_t:
m_nVisClusterMemberOffset = 0x0 # uint32_t
m_nVisClusterMemberCount = 0x4 # uint8_t
m_bHasTransform = 0x5 # bool
m_nDrawCallIndex = 0x6 # int16_t
m_nLODSetupIndex = 0x8 # int16_t
m_nLODGroupMask = 0xA # uint8_t
m_vTintColor = 0xB # Color
m_objectFlags = 0x10 # ObjectTypeFlags_t
m_nLightProbeVolumePrecomputedHandshake = 0x14 # int32_t
class AggregateSceneObject_t:
m_allFlags = 0x0 # ObjectTypeFlags_t
m_anyFlags = 0x4 # ObjectTypeFlags_t
m_nLayer = 0x8 # int16_t
m_aggregateMeshes = 0x10 # CUtlVector<AggregateMeshInfo_t>
m_lodSetups = 0x28 # CUtlVector<AggregateLODSetup_t>
m_visClusterMembership = 0x40 # CUtlVector<uint16_t>
m_fragmentTransforms = 0x58 # CUtlVector<matrix3x4_t>
m_renderableModel = 0x70 # CStrongHandle<InfoForResourceTypeCModel>
class BakedLightingInfo_t:
m_nLightmapVersionNumber = 0x0 # uint32_t
m_nLightmapGameVersionNumber = 0x4 # uint32_t
m_vLightmapUvScale = 0x8 # Vector2D
m_bHasLightmaps = 0x10 # bool
m_lightMaps = 0x18 # CUtlVector<CStrongHandle<InfoForResourceTypeCTextureBase>>
class BaseSceneObjectOverride_t:
m_nSceneObjectIndex = 0x0 # uint32_t
class CEntityIdentity:
m_nameStringableIndex = 0x14 # int32_t
m_name = 0x18 # CUtlSymbolLarge
m_designerName = 0x20 # CUtlSymbolLarge
m_flags = 0x30 # uint32_t
m_worldGroupId = 0x38 # WorldGroupId_t
m_fDataObjectTypes = 0x3C # uint32_t
m_PathIndex = 0x40 # ChangeAccessorFieldPathIndex_t
m_pPrev = 0x58 # CEntityIdentity*
m_pNext = 0x60 # CEntityIdentity*
m_pPrevByClass = 0x68 # CEntityIdentity*
m_pNextByClass = 0x70 # CEntityIdentity*
class CEntityInstance:
m_iszPrivateVScripts = 0x8 # CUtlSymbolLarge
m_pEntity = 0x10 # CEntityIdentity*
m_CScriptComponent = 0x28 # CScriptComponent*
class CScriptComponent:
m_scriptClassName = 0x30 # CUtlSymbolLarge
class CVoxelVisibility:
m_nBaseClusterCount = 0x40 # uint32_t
m_nPVSBytesPerCluster = 0x44 # uint32_t
m_vMinBounds = 0x48 # Vector
m_vMaxBounds = 0x54 # Vector
m_flGridSize = 0x60 # float
m_nSkyVisibilityCluster = 0x64 # uint32_t
m_nSunVisibilityCluster = 0x68 # uint32_t
m_NodeBlock = 0x6C # VoxelVisBlockOffset_t
m_RegionBlock = 0x74 # VoxelVisBlockOffset_t
m_EnclosedClusterListBlock = 0x7C # VoxelVisBlockOffset_t
m_EnclosedClustersBlock = 0x84 # VoxelVisBlockOffset_t
m_MasksBlock = 0x8C # VoxelVisBlockOffset_t
m_nVisBlocks = 0x94 # VoxelVisBlockOffset_t
class ClutterSceneObject_t:
m_Bounds = 0x0 # AABB_t
m_flags = 0x18 # ObjectTypeFlags_t
m_nLayer = 0x1C # int16_t
m_instancePositions = 0x20 # CUtlVector<Vector>
m_instanceScales = 0x50 # CUtlVector<float>
m_instanceTintSrgb = 0x68 # CUtlVector<Color>
m_tiles = 0x80 # CUtlVector<ClutterTile_t>
m_renderableModel = 0x98 # CStrongHandle<InfoForResourceTypeCModel>
class ClutterTile_t:
m_nFirstInstance = 0x0 # uint32_t
m_nLastInstance = 0x4 # uint32_t
m_BoundsWs = 0x8 # AABB_t
class EntityIOConnectionData_t:
m_outputName = 0x0 # CUtlString
m_targetType = 0x8 # uint32_t
m_targetName = 0x10 # CUtlString
m_inputName = 0x18 # CUtlString
m_overrideParam = 0x20 # CUtlString
m_flDelay = 0x28 # float
m_nTimesToFire = 0x2C # int32_t
class EntityKeyValueData_t:
m_connections = 0x8 # CUtlVector<EntityIOConnectionData_t>
m_keyValuesData = 0x20 # CUtlBinaryBlock
class ExtraVertexStreamOverride_t:
m_nSubSceneObject = 0x4 # uint32_t
m_nDrawCallIndex = 0x8 # uint32_t
m_nAdditionalMeshDrawPrimitiveFlags = 0xC # MeshDrawPrimitiveFlags_t
m_extraBufferBinding = 0x10 # CRenderBufferBinding
class InfoOverlayData_t:
m_transform = 0x0 # matrix3x4_t
m_flWidth = 0x30 # float
m_flHeight = 0x34 # float
m_flDepth = 0x38 # float
m_vUVStart = 0x3C # Vector2D
m_vUVEnd = 0x44 # Vector2D
m_pMaterial = 0x50 # CStrongHandle<InfoForResourceTypeIMaterial2>
m_nRenderOrder = 0x58 # int32_t
m_vTintColor = 0x5C # Vector4D
m_nSequenceOverride = 0x6C # int32_t
class MaterialOverride_t:
m_nSubSceneObject = 0x4 # uint32_t
m_nDrawCallIndex = 0x8 # uint32_t
m_pMaterial = 0x10 # CStrongHandle<InfoForResourceTypeIMaterial2>
class NodeData_t:
m_nParent = 0x0 # int32_t
m_vOrigin = 0x4 # Vector
m_vMinBounds = 0x10 # Vector
m_vMaxBounds = 0x1C # Vector
m_flMinimumDistance = 0x28 # float
m_ChildNodeIndices = 0x30 # CUtlVector<int32_t>
m_worldNodePrefix = 0x48 # CUtlString
class PermEntityLumpData_t:
m_name = 0x8 # CUtlString
m_hammerUniqueId = 0x10 # CUtlString
m_childLumps = 0x18 # CUtlVector<CStrongHandleCopyable<InfoForResourceTypeCEntityLump>>
m_entityKeyValues = 0x30 # CUtlLeanVector<EntityKeyValueData_t>
class SceneObject_t:
m_nObjectID = 0x0 # uint32_t
m_vTransform = 0x4 # Vector4D[3]
m_flFadeStartDistance = 0x34 # float
m_flFadeEndDistance = 0x38 # float
m_vTintColor = 0x3C # Vector4D
m_skin = 0x50 # CUtlString
m_nObjectTypeFlags = 0x58 # ObjectTypeFlags_t
m_vLightingOrigin = 0x5C # Vector
m_nLightGroup = 0x68 # uint32_t
m_nOverlayRenderOrder = 0x6C # int16_t
m_nLODOverride = 0x6E # int16_t
m_nCubeMapPrecomputedHandshake = 0x70 # int32_t
m_nLightProbeVolumePrecomputedHandshake = 0x74 # int32_t
m_renderableModel = 0x80 # CStrongHandle<InfoForResourceTypeCModel>
m_renderable = 0x88 # CStrongHandle<InfoForResourceTypeCRenderMesh>
class VoxelVisBlockOffset_t:
m_nOffset = 0x0 # uint32_t
m_nElementCount = 0x4 # uint32_t
class WorldBuilderParams_t:
m_flMinDrawVolumeSize = 0x0 # float
m_bBuildBakedLighting = 0x4 # bool
m_vLightmapUvScale = 0x8 # Vector2D
m_nCompileTimestamp = 0x10 # uint64_t
m_nCompileFingerprint = 0x18 # uint64_t
class WorldNodeOnDiskBufferData_t:
m_nElementCount = 0x0 # int32_t
m_nElementSizeInBytes = 0x4 # int32_t
m_inputLayoutFields = 0x8 # CUtlVector<RenderInputLayoutField_t>
m_pData = 0x20 # CUtlVector<uint8_t>
class WorldNode_t:
m_sceneObjects = 0x0 # CUtlVector<SceneObject_t>
m_infoOverlays = 0x18 # CUtlVector<InfoOverlayData_t>
m_visClusterMembership = 0x30 # CUtlVector<uint16_t>
m_aggregateSceneObjects = 0x48 # CUtlVector<AggregateSceneObject_t>
m_clutterSceneObjects = 0x60 # CUtlVector<ClutterSceneObject_t>
m_extraVertexStreamOverrides = 0x78 # CUtlVector<ExtraVertexStreamOverride_t>
m_materialOverrides = 0x90 # CUtlVector<MaterialOverride_t>
m_extraVertexStreams = 0xA8 # CUtlVector<WorldNodeOnDiskBufferData_t>
m_layerNames = 0xC0 # CUtlVector<CUtlString>
m_sceneObjectLayerIndices = 0xD8 # CUtlVector<uint8_t>
m_overlayLayerIndices = 0xF0 # CUtlVector<uint8_t>
m_grassFileName = 0x108 # CUtlString
m_nodeLightingInfo = 0x110 # BakedLightingInfo_t
class World_t:
m_builderParams = 0x0 # WorldBuilderParams_t
m_worldNodes = 0x20 # CUtlVector<NodeData_t>
m_worldLightingInfo = 0x38 # BakedLightingInfo_t
m_entityLumps = 0x68 # CUtlVector<CStrongHandleCopyable<InfoForResourceTypeCEntityLump>>

6
generated/worldrenderer.dll.rs
View File

@ -1,10 +1,10 @@
#![allow(non_snake_case, non_upper_case_globals)]
/*
* https://github.com/a2x/cs2-dumper
* 2023-10-15 12:13:31.694871800 UTC
* 2023-10-17 02:04:50.069165400 UTC
*/
#![allow(non_snake_case, non_upper_case_globals)]
pub mod AggregateLODSetup_t {
pub const m_vLODOrigin: usize = 0x0; // Vector
pub const m_fMaxObjectScale: usize = 0xC; // float

10
src/builder/json_file_builder.rs
View File

@ -7,14 +7,14 @@ use super::FileBuilder;
#[derive(Debug, PartialEq)]
pub struct JsonFileBuilder {
json: Value,
namespace: String,
current_namespace: String,
}
impl Default for JsonFileBuilder {
fn default() -> Self {
Self {
json: Value::Object(Map::new()),
namespace: String::new(),
current_namespace: String::new(),
}
}
}
@ -29,7 +29,7 @@ impl FileBuilder for JsonFileBuilder {
}
fn write_namespace(&mut self, _output: &mut dyn Write, name: &str) -> Result<()> {
self.namespace = name.to_string();
self.current_namespace = name.to_string();
Ok(())
}
@ -42,7 +42,9 @@ impl FileBuilder for JsonFileBuilder {
_comment: Option<&str>,
) -> Result<()> {
if let Some(map) = self.json.as_object_mut() {
let entry = map.entry(&self.namespace).or_insert_with(|| json!({}));
let entry = map
.entry(&self.current_namespace)
.or_insert_with(|| json!({}));
if let Some(object) = entry.as_object_mut() {
object.insert(name.to_string(), json!(value));

4
src/builder/mod.rs
View File

@ -4,12 +4,14 @@ pub use cpp_file_builder::CppFileBuilder;
pub use csharp_file_builder::CSharpFileBuilder;
pub use file_builder::FileBuilder;
pub use json_file_builder::JsonFileBuilder;
pub use python_file_builder::PythonFileBuilder;
pub use rust_file_builder::RustFileBuilder;
pub mod cpp_file_builder;
pub mod csharp_file_builder;
pub mod file_builder;
pub mod json_file_builder;
pub mod python_file_builder;
pub mod rust_file_builder;
#[derive(Debug, PartialEq)]
@ -17,6 +19,7 @@ pub enum FileBuilderEnum {
CppFileBuilder(CppFileBuilder),
CSharpFileBuilder(CSharpFileBuilder),
JsonFileBuilder(JsonFileBuilder),
PythonFileBuilder(PythonFileBuilder),
RustFileBuilder(RustFileBuilder),
}
@ -54,6 +57,7 @@ impl FileBuilderEnum {
FileBuilderEnum::CppFileBuilder(builder) => builder,
FileBuilderEnum::CSharpFileBuilder(builder) => builder,
FileBuilderEnum::JsonFileBuilder(builder) => builder,
FileBuilderEnum::PythonFileBuilder(builder) => builder,
FileBuilderEnum::RustFileBuilder(builder) => builder,
}
}

43
src/builder/python_file_builder.rs Normal file
View File

@ -0,0 +1,43 @@
use std::io::{Result, Write};
use super::FileBuilder;
#[derive(Debug, PartialEq)]
pub struct PythonFileBuilder;
impl FileBuilder for PythonFileBuilder {
fn extension(&mut self) -> &str {
"py"
}
fn write_top_level(&mut self, _output: &mut dyn Write) -> Result<()> {
Ok(())
}
fn write_namespace(&mut self, output: &mut dyn Write, name: &str) -> Result<()> {
write!(output, "class {}:\n", name)?;
Ok(())
}
fn write_variable(
&mut self,
output: &mut dyn Write,
name: &str,
value: usize,
comment: Option<&str>,
) -> Result<()> {
match comment {
Some(comment) => write!(output, " {} = {:#X} # {}\n", name, value, comment),
None => write!(output, " {} = {:#X}\n", name, value),
}
}
fn write_closure(&mut self, output: &mut dyn Write, eof: bool) -> Result<()> {
if !eof {
write!(output, "\n")?;
}
Ok(())
}
}

51
src/dumpers/interfaces.rs
View File

@ -1,51 +1,21 @@
use std::ffi::c_char;
use std::mem::offset_of;
use convert_case::{Case, Casing};
use crate::builder::FileBuilderEnum;
use crate::dumpers::Entry;
use crate::error::Result;
use crate::remote::Process;
use crate::sdk::InterfaceReg;
use super::{generate_files, Entries};
#[derive(Debug)]
#[repr(C)]
struct InterfaceReg {
create_fn: *const (), // 0x0000
name: *const c_char, // 0x0008
next: *mut InterfaceReg, // 0x0010
}
impl InterfaceReg {
pub fn ptr(&self, process: &Process) -> Result<usize> {
process
.read_memory::<usize>(self as *const _ as usize + offset_of!(InterfaceReg, create_fn))
}
pub fn name(&self, process: &Process) -> Result<String> {
let name_ptr = process
.read_memory::<usize>(self as *const _ as usize + offset_of!(InterfaceReg, name))?;
process.read_string(name_ptr)
}
pub fn next(&self, process: &Process) -> Result<*mut InterfaceReg> {
process.read_memory::<*mut InterfaceReg>(
self as *const _ as usize + offset_of!(InterfaceReg, next),
)
}
}
pub fn dump_interfaces(builders: &mut Vec<FileBuilderEnum>, process: &Process) -> Result<()> {
let module_names = process.get_loaded_modules()?;
let mut entries = Entries::new();
for module_name in module_names {
if module_name == "crashhandler64.dll" {
continue;
}
for module_name in process
.get_loaded_modules()?
.into_iter()
.filter(|module_name| *module_name != "crashhandler64.dll")
{
let module = process.get_module_by_name(&module_name)?;
if let Some(create_interface_export) = module.export("CreateInterface") {
@ -70,7 +40,12 @@ pub fn dump_interfaces(builders: &mut Vec<FileBuilderEnum>, process: &Process) -
);
entries
.entry(module_name.replace(".", "_"))
.entry(
module_name
.replace(".", "_")
.to_case(Case::Snake)
.to_case(Case::Pascal),
)
.or_default()
.push(Entry {
name: name.clone(),

40
src/dumpers/mod.rs
View File

@ -2,6 +2,8 @@ use std::collections::BTreeMap;
use std::fs::File;
use std::io::Write;
use chrono::Utc;
use crate::builder::{FileBuilder, FileBuilderEnum};
use crate::error::Result;
@ -34,29 +36,23 @@ pub fn generate_file(
let mut file = File::create(file_path)?;
builder.write_top_level(&mut file)?;
write_banner_to_file(&mut file, builder.extension())?;
if builder.extension() != "json" {
write!(
file,
"/*\n * https://github.com/a2x/cs2-dumper\n * {}\n */\n\n",
chrono::Utc::now()
)?;
}
builder.write_top_level(&mut file)?;
let len = entries.len();
for (i, pair) in entries.iter().enumerate() {
builder.write_namespace(&mut file, pair.0)?;
for entry in pair.1 {
pair.1.iter().try_for_each(|entry| {
builder.write_variable(
&mut file,
&entry.name,
entry.value,
entry.comment.as_deref(),
)?;
}
)
})?;
builder.write_closure(&mut file, i == len - 1)?;
}
@ -65,12 +61,28 @@ pub fn generate_file(
}
pub fn generate_files(
builders: &mut Vec<FileBuilderEnum>,
builders: &mut [FileBuilderEnum],
entries: &Entries,
file_name: &str,
) -> Result<()> {
for builder in builders {
generate_file(builder, &entries, file_name)?;
builders
.iter_mut()
.try_for_each(|builder| generate_file(builder, entries, file_name))
}
fn write_banner_to_file(file: &mut File, extension: &str) -> Result<()> {
let chrono_now = Utc::now();
const URL: &str = "https://github.com/a2x/cs2-dumper";
let banner = match extension {
"json" => None,
"py" => Some(format!("'''\n{}\n{}\n'''\n\n", URL, chrono_now)),
_ => Some(format!("/*\n * {}\n * {}\n */\n\n", URL, chrono_now)),
};
if let Some(banner) = banner {
write!(file, "{}", banner)?;
}
Ok(())

129
src/dumpers/offsets.rs
View File

@ -1,5 +1,7 @@
use std::fs::File;
use convert_case::{Case, Casing};
use crate::builder::FileBuilderEnum;
use crate::config::{Config, Operation::*};
use crate::dumpers::Entry;
@ -84,72 +86,81 @@ pub fn dump_offsets(builders: &mut Vec<FileBuilderEnum>, process: &Process) -> R
for signature in config.signatures {
let module = process.get_module_by_name(&signature.module)?;
if let Ok(address) = process.find_pattern(&signature.module, &signature.pattern) {
let mut address = Address::from(address);
let mut address = match process.find_pattern(&signature.module, &signature.pattern) {
Ok(a) => Address::from(a),
Err(_) => {
log::error!("Failed to find pattern for {}.", signature.name);
for operation in signature.operations {
match operation {
Add { value } => address += value,
Dereference { times, size } => {
let times = times.unwrap_or(1);
let size = size.unwrap_or(8);
for _ in 0..times {
process.read_memory_raw(
address.0,
&mut address.0 as *mut _ as *mut _,
size,
)?;
}
}
Jmp { offset, length } => {
address = process.resolve_jmp(address.0, offset, length)?.into()
}
RipRelative { offset, length } => {
address = process.resolve_rip(address.0, offset, length)?.into()
}
Slice { start, end } => {
let mut result: usize = 0;
process.read_memory_raw(
address.add(start).0,
&mut result as *mut _ as *mut _,
end - start,
)?;
address = result.into();
}
Subtract { value } => address -= value,
}
continue;
}
};
let (name, value) = if address.0 < module.base() {
log::debug!(" └─ {} @ {:#X}", signature.name, address.0);
for operation in signature.operations {
match operation {
Add { value } => address += value,
Dereference { times, size } => {
let times = times.unwrap_or(1);
let size = size.unwrap_or(8);
(signature.name, address.0)
} else {
log::debug!(
" └─ {} @ {:#X} ({} + {:#X})",
signature.name,
address,
signature.module,
address.sub(module.base())
);
for _ in 0..times {
process.read_memory_raw(
address.0,
&mut address.0 as *mut _ as *mut _,
size,
)?;
}
}
Jmp { offset, length } => {
address = process.resolve_jmp(address.0, offset, length)?.into()
}
RipRelative { offset, length } => {
address = process.resolve_rip(address.0, offset, length)?.into()
}
Slice { start, end } => {
let mut result: usize = 0;
(signature.name, address.sub(module.base()).0)
};
process.read_memory_raw(
address.add(start).0,
&mut result as *mut _ as *mut _,
end - start,
)?;
entries
.entry(signature.module.replace(".", "_"))
.or_default()
.push(Entry {
name,
value,
comment: None,
});
} else {
log::error!("Failed to find pattern for {}.", signature.name);
address = result.into();
}
Subtract { value } => address -= value,
}
}
let (name, value) = if address.0 < module.base() {
log::debug!(" └─ {} @ {:#X}", signature.name, address.0);
(signature.name, address.0)
} else {
log::debug!(
" └─ {} @ {:#X} ({} + {:#X})",
signature.name,
address,
signature.module,
address.sub(module.base())
);
(signature.name, address.sub(module.base()).0)
};
entries
.entry(
signature
.module
.replace(".", "_")
.to_case(Case::Snake)
.to_case(Case::Pascal),
)
.or_default()
.push(Entry {
name,
value,
comment: None,
});
}
generate_files(builders, &entries, "offsets")?;

14
src/error.rs
View File

@ -9,7 +9,7 @@ use windows::core::Error as WindowsError;
#[derive(Debug, Error)]
pub enum Error {
#[error("Buffer size mismatch: expected {0}, got {1}")]
#[error("Buffer size mismatch. Expected {0}, got {1}")]
BufferSizeMismatch(usize, usize),
#[error("Invalid magic: {0:#X}")]
@ -18,14 +18,14 @@ pub enum Error {
#[error("IO error: {0}")]
IOError(#[from] io::Error),
#[error("Module not found")]
ModuleNotFound,
#[error("Module not found: {0}")]
ModuleNotFound(String),
#[error("Pattern not found")]
PatternNotFound,
#[error("Pattern not found: {0}")]
PatternNotFound(String),
#[error("Process not found")]
ProcessNotFound,
#[error("Process not found: {0}")]
ProcessNotFound(String),
#[error("Serde error: {0}")]
SerdeError(#[from] SerdeError),

1
src/main.rs
View File

@ -67,6 +67,7 @@ fn main() -> Result<()> {
FileBuilderEnum::CppFileBuilder(CppFileBuilder),
FileBuilderEnum::CSharpFileBuilder(CSharpFileBuilder),
FileBuilderEnum::JsonFileBuilder(JsonFileBuilder::default()),
FileBuilderEnum::PythonFileBuilder(PythonFileBuilder),
FileBuilderEnum::RustFileBuilder(RustFileBuilder),
];

6
src/remote/process.rs
View File

@ -58,7 +58,7 @@ impl Process {
}
}
Err(Error::PatternNotFound)
Err(Error::PatternNotFound(pattern.to_owned()))
}
pub fn get_loaded_modules(&self) -> Result<Vec<String>> {
@ -108,7 +108,7 @@ impl Process {
}
}
Err(Error::ModuleNotFound)
Err(Error::ModuleNotFound(module_name.to_owned()))
}
pub fn read_memory_raw(&self, address: usize, buffer: *mut c_void, size: usize) -> Result<()> {
@ -215,7 +215,7 @@ impl Process {
}
}
Err(Error::ProcessNotFound)
Err(Error::ProcessNotFound(process_name.to_owned()))
}
fn pattern_to_bytes(pattern: &str) -> Vec<i32> {

33
src/sdk/interface.rs Normal file
View File

@ -0,0 +1,33 @@
use std::ffi::c_char;
use std::mem::offset_of;
use crate::error::Result;
use crate::remote::Process;
#[derive(Debug)]
#[repr(C)]
pub struct InterfaceReg {
pub create_fn: *const (), // 0x0000
pub name: *const c_char, // 0x0008
pub next: *mut InterfaceReg, // 0x0010
}
impl InterfaceReg {
pub fn ptr(&self, process: &Process) -> Result<usize> {
process
.read_memory::<usize>(self as *const _ as usize + offset_of!(InterfaceReg, create_fn))
}
pub fn name(&self, process: &Process) -> Result<String> {
let name_ptr = process
.read_memory::<usize>(self as *const _ as usize + offset_of!(InterfaceReg, name))?;
process.read_string(name_ptr)
}
pub fn next(&self, process: &Process) -> Result<*mut InterfaceReg> {
process.read_memory::<*mut InterfaceReg>(
self as *const _ as usize + offset_of!(InterfaceReg, next),
)
}
}

2
src/sdk/mod.rs
View File

@ -1,3 +1,4 @@
pub use interface::InterfaceReg;
pub use schema_class_field_data::SchemaClassFieldData;
pub use schema_class_info::SchemaClassInfo;
pub use schema_system::SchemaSystem;
@ -6,6 +7,7 @@ pub use schema_type::SchemaType;
pub use schema_type_declared_class::SchemaTypeDeclaredClass;
pub use utl_ts_hash::UtlTsHash;
pub mod interface;
pub mod schema_class_field_data;
pub mod schema_class_info;
pub mod schema_system;