feat(Classes): Split classes to their correct inheritance (#25)

base/CObject.hpp

@@ -1,6 +1,24 @@
 #pragma once
-#include "../rage/fwEntity.hpp"
+#include "../entities/CPhysical.hpp"
 
-class CObject : public rage::fwEntity
+#pragma pack(push, 2)
-{}; //Size: 0x018C
+class CObject : public rage::CPhysical
-static_assert(sizeof(CObject) == 0x018C);
+{
+    char gap30C[60];
+    uint64_t qword348;
+    char gap350[8];
+    uint64_t qword358;
+    uint16_t word360;
+    uint32_t dword362;
+    uint16_t word366;
+    char gap368[120];
+    uint64_t qword3E0;
+    char gap3E8[8];
+    uint64_t qword3F0;
+    uint64_t qword3F8;
+    uint64_t qword400;
+    uint64_t qword408;
+    uint64_t qword410;
+};
+static_assert(sizeof(CObject) == 0x418);
+#pragma pack(pop)

draw_handlers/CEntityDrawHandler.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "fwDrawData.hpp"
+
+namespace rage
+{
+    class CEntityDrawHandler : public rage::fwDrawData
+    {
+    public:
+
+    };
+    static_assert(sizeof(CEntityDrawHandler) == 0x2C);
+}

draw_handlers/CObjectDrawHandler.hpp

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "CEntityDrawHandler.hpp"
+
+namespace rage
+{
+    class CObjectFragmentDrawHandler : public CEntityDrawHandler
+    {
+    };
+    static_assert(sizeof(CObjectFragmentDrawHandler) == 0x2C);
+}

draw_handlers/CPedDrawHandler.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <cstdint>
+
+#include "CEntityDrawHandler.hpp"
+
+namespace rage
+{
+#pragma pack(push, 4)
+    class CPedDrawHandler : public CEntityDrawHandler
+    {
+    public:
+        uint64_t qword30;
+        uint64_t qword38;
+        char gap40[752];
+        uint32_t dword330;
+    };
+    static_assert(sizeof(CPedDrawHandler) == 0x330);
+#pragma pack(pop)
+}

draw_handlers/CVehicleDrawHandler.hpp

@@ -2,22 +2,25 @@
 
 #include <cstdint>
 
+#include "CEntityDrawHandler.hpp"
+
 namespace rage
 {
-    class fwDrawData
+    class CVehicleDrawHandler : public CEntityDrawHandler
     {
     public:
-        char pad_0000[904]; //0x0000
+        uint64_t qword30;
+        char gap38[848];
         uint8_t m_primary_color; //0x0388
-        char pad_0389[3]; //0x0389
+        char gap389[3]; //0x0389
         uint8_t m_pearlescent; //0x038C
-        char pad_038D[3]; //0x038D
+        char gap38D[3]; //0x038D
         uint8_t m_secondary_color; //0x0390
-        char pad_0391[15]; //0x0391
+        char gap391[15]; //0x0391
         uint8_t m_neon_blue; //0x03A0
         uint8_t m_neon_green; //0x03A1
         uint8_t m_neon_red; //0x03A2
-        char pad_03A3[15]; //0x03A3
+        char gap3A3[15]; //0x03A3
         uint8_t m_spoiler; //0x03B2
         uint8_t m_bumper_front; //0x03B3
         uint8_t m_bumper_rear; //0x03B4
@@ -29,17 +32,17 @@ namespace rage
         uint8_t m_fenders; //0x03BA
         uint8_t m_bullbars; //0x03BB
         uint8_t m_roof; //0x03BC
-        char pad_03BD[3]; //0x03BD
+        char gap3BD[3]; //0x03BD
         uint8_t m_ornaments; //0x03C0
-        char pad_03C1[1]; //0x03C1
+        char gap3C1[1]; //0x03C1
         uint8_t m_dail_design; //0x03C2
         uint8_t m_sunstrips; //0x03C3
         uint8_t m_seats; //0x03C4
         uint8_t m_steering_wheel; //0x03C5
         uint8_t m_column_shifter_levers; //0x03C6
-        char pad_03C7[2]; //0x03C7
+        char gap3C7[2]; //0x03C7
         uint8_t m_truck_beds; //0x03C9
-        char pad_03CA[4]; //0x03CA
+        char gap3CA[4]; //0x03CA
         uint8_t m_roll_cages; //0x03CE
         uint8_t m_skid_plate; //0x03CF
         uint8_t m_secondary_light_surrounds; //0x03D0
@@ -47,29 +50,37 @@ namespace rage
         uint8_t m_doors; //0x03D2
         uint8_t m_snorkel; //0x03D3
         uint8_t m_livery; //0x03D4
-        char pad_03D5[1]; //0x03D5
+        char gap3D5[1]; //0x03D5
         uint8_t m_engine; //0x03D6
         uint8_t m_brakes; //0x03D7
         uint8_t m_transmission; //0x03D8
         uint8_t m_horn; //0x03D9
         uint8_t m_suspension; //0x03DA
         uint8_t m_armor; //0x03DB
-        char pad_03DC[1]; //0x03DC
+        char gap3DC[1]; //0x03DC
         uint8_t m_turbo; //0x03DD
-        char pad_03DE[3]; //0x03DE
+        char gap3DE[3]; //0x03DE
         uint8_t m_xenon; //0x03E1
         uint8_t m_tire_design; //0x03E2
-        char pad_03E3[16]; //0x03E3
+        char gap3E3[16]; //0x03E3
         uint8_t m_truck_bed; //0x03F3
-        char pad_03F4[5]; //0x03F4
+        char gap3F4[2];
-        uint8_t m_wheel_color; //0x03F9
+        uint8_t byte3F6;
-        char pad_03FA[5]; //0x03FA
+        uint8_t byte3F7;
-        uint8_t m_window; //0x03FF
+        uint8_t byte3F8;
-        char pad_0400[2]; //0x0400
+        uint8_t m_wheel_color;
-        uint8_t m_neon_left; //0x0402
+        uint8_t byte3FA;
-        uint8_t m_neon_right; //0x0403
+        uint8_t byte3FB;
-        uint8_t m_neon_front; //0x0404
+        char gap3FC[3];
-        uint8_t m_neon_rear; //0x0405
+        uint8_t m_window;
-    }; //Size: 0x0406
+        char gap400[2];
-    static_assert(sizeof(fwDrawData) == 0x406);
+        uint8_t m_neon_left;
+        uint8_t m_neon_right;
+        uint8_t m_neon_front;
+        uint8_t m_neon_rear;
+        char gap406[9];
+        uint32_t dword410;
+        uint32_t dword414;
+    };
+    static_assert(sizeof(CVehicleDrawHandler) == 0x418);
 }

draw_handlers/fwDrawData.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <cstdint>
+
+namespace rage
+{
+#pragma pack(push, 4)
+    class fwDrawData
+    {
+    public:
+        std::uint64_t qword0;
+        std::uint64_t qword8;
+        char gap10[8];
+        std::uint32_t dword18;
+        std::uint32_t dword1C;
+        std::uint64_t qword20;
+        std::uint32_t dword28;
+    };
+    static_assert(sizeof(fwDrawData) == 0x2C);
+#pragma pack(pop)
+}

entities/CDynamicEntity.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "CEntity.hpp"
+#include "../network/netObject.hpp"
+
+#include <cstdint>
+
+namespace rage
+{
+    class CDynamicEntity : public CEntity
+    {
+    public:
+        class rage::netObject *m_net_object; //0x00D0
+        char gapD8[16];
+        uint64_t qwordE8;
+    };
+    static_assert(sizeof(CDynamicEntity) == 0xF0);
+}

entities/CEntity.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "fwEntity.hpp"
+
+#include <cstdint>
+
+namespace rage
+{
+    class CEntity : public rage::fwEntity
+    {
+    public:
+        char gapB9[7];
+        uint32_t dwordC0;
+        uint32_t dwordC4;
+        uint32_t dwordC8;
+        uint32_t dwordCC;
+    };
+    static_assert(sizeof(CEntity) == 0xD0);
+}

entities/CPhysical.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "CDynamicEntity.hpp"
+
+#include <cstdint>
+
+namespace rage
+{
+#pragma pack(push, 1)
+    class CPhysical : public CDynamicEntity
+    {
+    public:
+        char gapF0[144];
+        uint64_t qword180;
+        uint32_t m_damage_bits; //0x0188
+        uint8_t m_hostility; //0x018C
+        char gap18D[3];
+        uint8_t byte190;
+        char gap191[3];
+        uint32_t dword194;
+        char gap198[232];
+	    float m_health; //0x0280
+	    char pad_0284[28];
+        uint32_t m_maxhealth; //0x02A0
+        char gap2A4[4];
+        uint64_t qword2A8;
+        char gap2B0[72];
+        uint64_t qword2F8;
+        uint64_t qword300;
+        uint32_t dword308;
+    };
+    static_assert(sizeof(CPhysical) == 0x30C);
+#pragma pack(pop)
+}

entities/fwEntity.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "../base/CBaseModelInfo.hpp"
+#include "../base/CNavigation.hpp"
+#include "../base/fwExtensibleBase.hpp"
+
+#include "../draw_handlers/fwDrawData.hpp"
+
+#include <cstdint>
+
+namespace rage
+{
+#pragma pack(push, 1)
+    class fwEntity : public fwExtensibleBase
+    {
+    public:
+        class CBaseModelInfo *m_model_info;
+        char gap28;
+        uint8_t m_entity_type;
+        char gap2A[2];
+        uint8_t m_invisible; //0x002C
+        char gap2D[3]; //0x002D
+        class CNavigation *m_navigation; //0x0030
+        char gap38[16]; //0x0038
+        class rage::fwDrawData *m_draw_data; //0x0048
+        char gap50[16]; //0x0050
+        rage::fvector3 m_right; //0x0060
+        char gap6C[4]; //0x006C
+        rage::fvector3 m_forward; //0x0070
+        char gap7C[4]; //0x007C
+        rage::fvector3 m_up; //0x0080
+        char gap8C[4]; //0x008C
+        rage::fvector3 m_position; //0x0090
+        char gap9C[4]; // 0x009C
+        uint64_t qwordA0;
+        uint32_t dwordA8;
+        uint32_t dwordAC;
+        uint32_t dwordB0;
+        char gapB4[4];
+        std::uint8_t byteB8;
+    };
+    static_assert(sizeof(fwEntity) == 0xB9);
+#pragma pack(pop)
+}

ped/CPed.hpp

@@ -1,29 +1,25 @@
 #pragma once
 
-#include "../vehicle/CAutomobile.hpp"
+
+#include "../vehicle/CVehicle.hpp"
 #include "../player/CPlayerInfo.hpp"
 #include "CPedModelInfo.hpp"
 #include "CPedWeaponManager.hpp"
 
-#include "../rage/fwEntity.hpp"
+#include "../entities/fwEntity.hpp"
 #include "../rage/vector.hpp"
 
 #include <cstdint>
 
 #pragma pack(push, 1)
 
-class CPed : public rage::fwEntity
+class CPed : public rage::CPhysical
 {
 public:
-	uint8_t m_hostility; //0x018C
+	char gap30C[20];
-	char pad_018D[243]; //0x018D
-	float m_health; //0x0280
-	char pad_0284[28]; //0x0284
-	float m_maxhealth; //0x02A0
-	char pad_02A4[124]; //0x02A4
 	rage::fvector3 m_velocity; //0x0320
 	char pad_032C[2564]; //0x032C
-	class CAutomobile *m_vehicle; //0x0D30
+	class CVehicle *m_vehicle; //0x0D30
 	char pad_0D38[912]; //0x0D38
 	class CPlayerInfo *m_player_info; //0x10C8
 	char pad_10D0[8]; //0x10D0

ped/CPedModelInfo.hpp

@@ -1,11 +1,46 @@
 #pragma once
 
+#include "../base/CBaseModelInfo.hpp"
+
 #include <cstdint>
 
-class CPedModelInfo
+class CPedModelInfo : public CBaseModelInfo
 {
 public:
-	char pad_0000[24]; //0x0000
+	char gapB0[48];
-	uint32_t m_model_hash; //0x0018
+	uint64_t qwordE0;
-}; //Size: 0x001C
+	uint32_t dwordE8;
-static_assert(sizeof(CPedModelInfo) == 0x1C);
+	char gapEC[4];
+	uint32_t dwordF0;
+	char gapF4[4];
+	uint64_t qwordF8;
+	uint32_t dword100;
+	uint64_t qword108;
+	uint64_t qword110;
+	uint64_t qword118;
+	uint64_t qword120;
+	uint64_t qword128;
+	uint32_t dword130;
+	char gap134[148];
+	uint64_t qword1C8;
+	uint32_t dword1D0;
+	uint64_t qword1D8;
+	uint32_t dword1E0;
+	char gap1E4[52];
+	uint64_t qword218;
+	char gap220[8];
+	uint64_t qword228;
+	uint32_t dword230;
+	char gap234[4];
+	uint32_t dword238;
+	char gap23C[12];
+	uint64_t qword248;
+	uint64_t qword250;
+	uint64_t qword258;
+	uint64_t qword260;
+	uint64_t qword268;
+	uint64_t qword270;
+	uint64_t qword278;
+	char gap280[16];
+};
+static_assert(sizeof(CPedModelInfo) == 0x290);

rage/fwEntity.hpp

@@ -1,41 +0,0 @@
-#pragma once
-
-#include "../base/CBaseModelInfo.hpp"
-#include "../base/CNavigation.hpp"
-#include "../base/fwExtensibleBase.hpp"
-#include "../network/netObject.hpp"
-#include "fwDrawData.hpp"
-
-#include <cstdint>
-
-namespace rage
-{
-#pragma pack(push, 4)
-    class fwEntity : public fwExtensibleBase
-    {
-    public:
-        class CBaseModelInfo *m_model_info; //0x0020
-        char pad_0028[1]; //0x0028
-        int8_t m_entity_type; //0x0029
-        char pad_002A[2]; //0x002A
-        uint8_t m_invisible; //0x002C
-        char pad_002D[3]; //0x002D
-        class CNavigation *m_navigation; //0x0030
-        char pad_0038[16]; //0x0038
-        class rage::fwDrawData *m_draw_data; //0x0048
-        char pad_0050[16]; //0x0050
-        rage::fvector3 m_right; //0x0060
-        char pad_006C[4]; //0x006C
-        rage::fvector3 m_forward; //0x0070
-        char pad_007C[4]; //0x007C
-        rage::fvector3 m_up; //0x0080
-        char pad_008C[4]; //0x008C
-        rage::fvector3 m_position; //0x0090
-        char pad_009C[52]; //0x009C
-        class rage::netObject *m_net_object; //0x00D0
-        char pad_00D8[176]; //0x00D8
-        uint32_t m_damage_bits; //0x0188
-    }; //Size: 0x018C
-    static_assert(sizeof(fwEntity) == 0x18C);
-#pragma pack(pop)
-}

vehicle/CAutomobile.hpp

@@ -1,51 +0,0 @@
-#pragma once
-
-#include "CHandlingData.hpp"
-#include "CVehicleDrawHandler.hpp"
-#include "CVehicleModelInfo.hpp"
-
-#include "../rage/fwEntity.hpp"
-
-#include <cstdint>
-
-#pragma pack(push, 4)
-class CAutomobile : public rage::fwEntity
-{
-public:
-	char pad_018C[244]; //0x018C
-	float m_health; //0x0280
-	char pad_0284[28]; //0x0284
-	float m_health_max; //0x02A0
-	char pad_02A4[116]; //0x02A4
-	uint8_t m_boost_state; //0x0318
-	char pad_0319[2]; //0x0319
-	uint8_t m_boost_allow_recharge; //0x031B
-	char pad_031C[4]; //0x031C
-	float m_boost; //0x0320
-	float m_rocket_recharge_speed; //0x0324
-	char pad_0328[136]; //0x0328
-	float m_jump_boost_charge; //0x03B0
-	char pad_03B4[1164]; //0x03B4
-	float m_body_health; //0x0840
-	float m_petrol_tank_health; //0x0844
-	char pad_0848[192]; //0x0848
-	float m_engine_health; //0x0908
-	char pad_090C[44]; //0x090C
-	class CHandlingData *m_handling; //0x0938
-	char pad_0940[2]; //0x0940
-	uint8_t m_is_drivable; //0x0942
-	uint8_t m_tyres_can_burst; //0x0943
-	uint8_t m_deform_god; //0x0944
-	char pad_0945[179]; //0x0945
-	float m_dirt_level; //0x09F8
-	char pad_09FC[194]; //0x09FC
-	uint8_t m_is_targetable; //0x0ABE
-	char pad_0ABF[413]; //0x0ABF
-	float m_gravity; //0x0C5C
-	char pad_0C60[8]; //0x0C60
-	class CPed *m_driver; //0x0C68
-	class CPed *m_passengers[15]; //0x0C70
-	class CPed *m_last_driver; //0x0CE8
-}; //Size: 0x0CF0
-static_assert(sizeof(CAutomobile) == 0xCF0);
-#pragma pack(pop)

vehicle/CVehicle.hpp

@@ -0,0 +1,330 @@
+#pragma once
+
+#include "../entities/CPhysical.hpp"
+#include "CHandlingData.hpp"
+
+#include <cstdint>
+
+#pragma pack(push, 1)
+class CVehicle : public rage::CPhysical
+{
+public:
+    char gap30C[4];
+    uint32_t dword310;
+    uint32_t dword314;
+    uint8_t m_boost_state; // 0x318
+    char gap319[2];
+    uint8_t m_boost_allow_recharge; // 0x31B
+    uint16_t word31C;
+    char gap31E[2];
+    float m_boost; // 0x320
+    float m_rocket_recharge_speed; // 0x324
+    uint32_t dword328;
+    uint8_t byte32C;
+    char gap32D[3];
+    uint8_t byte330;
+    char gap331[3];
+    uint64_t qword334;
+    uint32_t dword33C;
+    uint8_t byte340;
+    char gap341[3];
+    uint32_t dword344;
+    uint8_t byte348;
+    char gap349[3];
+    uint64_t qword34C;
+    uint64_t qword354;
+    uint64_t qword35C;
+    uint64_t qword364;
+    uint32_t dword36C;
+    uint32_t dword370;
+    uint8_t byte374;
+    uint16_t word375;
+    uint8_t byte377;
+    uint64_t qword378;
+    uint64_t qword380;
+    uint64_t qword388;
+    uint32_t dword390;
+    uint32_t dword394;
+    uint8_t byte398;
+    char gap399[3];
+    uint64_t qword39C;
+    uint64_t qword3A4;
+    char gap3AC[4];
+    float m_jump_boost_charge; // 0x3B0
+    uint8_t byte3B4;
+    char gap3B5[3];
+    uint64_t qword3B8;
+    uint32_t dword3C0;
+    uint32_t dword3C4;
+    char gap3C8[8];
+    uint16_t oword3D0;
+    char gap3D2[30];
+    uint16_t oword3F0;
+    char gap3F2[14];
+    uint32_t dword400;
+    uint64_t qword404;
+    char gap40C[4];
+    uint32_t dword410;
+    uint64_t qword414;
+    char gap41C[4];
+    uint64_t qword420;
+    uint32_t dword428;
+    uint32_t dword42C;
+    char gap430[1032];
+    uint64_t qword838;
+    float m_body_health; // 0x840
+    float m_petrol_tank_health; // 0x844
+    char gap848[12];
+    float float854;
+    char gap858[176];
+    float m_engine_health; // 0x908
+    char gap90C[44];
+    CHandlingData* m_handling_data; // 0x938
+    char gap940[2];
+    uint8_t m_is_drivable; //0x0942
+    uint8_t m_tyres_can_burst; //0x0943
+    uint8_t m_deform_god; //0x0944
+    char gap945[6];
+    uint8_t byte94B;
+    char gap94C;
+    uint8_t byte94D;
+    char gap94E;
+    uint8_t byte94F;
+    char gap950[3];
+    uint8_t byte953;
+    uint8_t byte954;
+    char gap955;
+    uint8_t byte956;
+    uint8_t byte957;
+    char gap958[2];
+    uint8_t byte95A;
+    char gap95B[9];
+    uint64_t qword964;
+    char gap96C[4];
+    uint64_t qword970;
+    uint64_t qword978;
+    char gap980[8];
+    uint64_t qword988;
+    uint16_t word990;
+    uint32_t dword992;
+    uint16_t word996;
+    uint64_t qword998;
+    uint64_t qword9A0;
+    uint32_t dword9A8;
+    uint64_t qword9AC;
+    uint64_t qword9B4;
+    uint64_t qword9BC;
+    uint16_t word9C4;
+    uint8_t byte9C6;
+    char gap9C7;
+    uint32_t dword9C8;
+    uint8_t byte9CC;
+    char gap9CD;
+    uint16_t word9CE;
+    uint16_t word9D0;
+    char gap9D2[2];
+    uint32_t dword9D4;
+    char gap9D8[8];
+    uint32_t dword9E0;
+    uint64_t qword9E4;
+    uint32_t dword9EC;
+    uint32_t dword9F0;
+    char gap9F4[4];
+    float m_dirt_level; // 0x9F8
+    uint32_t dword9FC;
+    uint64_t qwordA00;
+    uint64_t qwordA08;
+    uint32_t dwordA10;
+    uint32_t dwordA14;
+    uint8_t byteA18;
+    uint16_t wordA19;
+    uint8_t byteA1B;
+    uint32_t dwordA1C;
+    uint64_t qwordA20;
+    uint32_t dwordA28;
+    uint32_t dwordA2C;
+    uint64_t qwordA30;
+    uint64_t qwordA38;
+    uint64_t qwordA40;
+    uint64_t qwordA48;
+    uint8_t byteA50;
+    char gapA51[7];
+    uint64_t qwordA58;
+    uint64_t qwordA60;
+    uint32_t dwordA68;
+    uint32_t dwordA6C;
+    uint32_t dwordA70;
+    uint32_t dwordA74;
+    uint32_t dwordA78;
+    uint32_t dwordA7C;
+    uint64_t qwordA80;
+    uint8_t byteA88;
+    char gapA89;
+    uint16_t wordA8A;
+    uint64_t qwordA8C;
+    uint64_t qwordA94;
+    uint64_t qwordA9C;
+    uint64_t qwordAA4;
+    uint32_t dwordAAC;
+    uint16_t wordAB0;
+    uint16_t wordAB2;
+    uint8_t byteAB4;
+    uint16_t wordAB5;
+    uint16_t wordAB7;
+    char gapAB9[2];
+    char gapABB[3]; // start of some kind of flag, default value 0x1000000i64
+    uint8_t m_is_targetable; // 0xABE
+    char gapABF[4]; // end of some kind of flag
+    uint32_t dwordAC3;
+    uint32_t dwordAC7;
+    uint16_t wordACB;
+    uint8_t byteACD;
+    uint8_t byteACE;
+    char gapACF;
+    uint64_t qwordAD0;
+    uint64_t qwordAD8;
+    uint8_t byteAE0;
+    char gapAE1[3];
+    uint32_t dwordAE4;
+    uint32_t dwordAE8;
+    uint32_t dwordAEC;
+    uint32_t dwordAF0;
+    char gapAF4[4];
+    uint32_t dwordAF8;
+    char gapAFC[20];
+    uint32_t dwordB10;
+    uint32_t dwordB14;
+    char gapB18[24];
+    uint32_t dwordB30;
+    uint64_t qwordB34;
+    char gapB3C[4];
+    uint32_t dwordB40;
+    uint64_t qwordB44;
+    char gapB4C[4];
+    uint16_t owordB50;
+    char gapB52[14];
+    uint16_t owordB60;
+    char gapB62[14];
+    uint32_t dwordB70;
+    uint32_t dwordB74;
+    uint64_t qwordB78;
+    uint32_t dwordB80;
+    uint32_t dwordB84;
+    uint32_t dwordB88;
+    uint32_t dwordB8C;
+    uint32_t dwordB90;
+    uint32_t dwordB94;
+    uint32_t dwordB98;
+    uint32_t dwordB9C;
+    uint32_t dwordBA0;
+    uint64_t qwordBA4;
+    char gapBAC[4];
+    uint32_t dwordBB0;
+    uint64_t qwordBB4;
+    char gapBBC[20];
+    uint64_t qwordBD0;
+    char gapBD8[16];
+    uint32_t dwordBE8;
+    char gapBEC[4];
+    uint64_t qwordBF0;
+    uint32_t dwordBF8;
+    uint64_t qwordBFC;
+    uint16_t wordC04;
+    uint8_t byteC06;
+    char gapC07;
+    uint64_t qwordC08;
+    uint32_t dwordC10;
+    uint32_t dwordC14;
+    uint16_t wordC18;
+    char gapC1A[2];
+    uint64_t qwordC1C;
+    uint64_t qwordC24;
+    uint64_t qwordC2C;
+    uint64_t qwordC34;
+    char gapC3C[4];
+    uint64_t qwordC40;
+    uint64_t qwordC48;
+    uint32_t dwordC50;
+    char gapC54[4];
+    uint32_t dwordC58;
+    float m_gravity; // 0xC5C - might be start of some sub-class
+    char gapC60[8];
+    class CPed* m_driver; //0x0C68
+    class CPed* m_passengers[15]; //0x0C70
+    class CPed* m_last_driver; //0x0CE8
+    char gapCF0[1424]; // end of sub-class
+    uint32_t dword1280;
+    char gap1284[4];
+    uint32_t dword1288;
+    char gap128C[12];
+    uint16_t word1298;
+    uint8_t byte129A;
+    char gap129B;
+    uint64_t qword129C;
+    uint64_t qword12A4;
+    uint64_t qword12AC;
+    uint64_t qword12B4;
+    char gap12BC[4];
+    uint64_t qword12C0;
+    uint64_t qword12C8;
+    uint16_t word12D0;
+    char gap12D2[14];
+    uint32_t dword12E0;
+    uint32_t dword12E4;
+    uint64_t qword12E8;
+    uint32_t dword12F0;
+    char gap12F4[4];
+    uint64_t qword12F8;
+    char gap1300[56];
+    uint64_t qword1338;
+    uint64_t qword1340;
+    uint32_t dword1348;
+    uint32_t dword134C;
+    uint32_t dword1350;
+    uint64_t qword1354;
+    uint32_t dword135C;
+    uint32_t dword1360;
+    uint32_t dword1364;
+    uint32_t dword1368;
+    char gap136C[4];
+    float float1370;
+    float float1374;
+    char gap1378[8];
+    uint64_t qword1380;
+    uint64_t qword1388;
+    uint32_t dword1390;
+    uint64_t qword1394;
+    uint16_t word139C;
+    uint16_t word139E;
+    uint8_t byte13A0;
+    uint16_t word13A1;
+    char gap13A3[2];
+    uint8_t byte13A5;
+    uint16_t word13A6;
+    uint8_t byte13A8;
+    char gap13A9[3];
+    uint32_t dword13AC;
+    uint8_t byte13B0;
+    char gap13B1[3];
+    uint64_t qword13B4;
+    uint32_t dword13BC;
+    uint32_t dword13C0;
+    uint32_t dword13C4;
+    uint32_t dword13C8;
+    uint8_t byte13CC;
+    char gap13CD[3];
+    uint64_t qword13D0;
+    uint8_t byte13D8;
+    char gap13D9[3];
+    uint32_t dword13DC;
+    char gap13E0[8];
+    uint32_t dword13E8;
+    char gap13EC[116];
+    uint32_t dword1460;
+    uint16_t word1464;
+    uint8_t byte1466;
+    char gap1467;
+    uint64_t qword1468;
+};
+static_assert(sizeof(CVehicle) == 0x1470);
+#pragma pack(pop)

vehicle/CVehicleDrawHandler.hpp

@@ -1,72 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-class CVehicleDrawHandler
-{
-public:
-	char pad_0000[904]; //0x0000
-	uint8_t m_primary_color; //0x0388
-	char pad_0389[3]; //0x0389
-	uint8_t m_pearlescent; //0x038C
-	char pad_038D[3]; //0x038D
-	uint8_t m_secondary_color; //0x0390
-	char pad_0391[15]; //0x0391
-	uint8_t m_neon_blue; //0x03A0
-	uint8_t m_neon_green; //0x03A1
-	uint8_t m_neon_red; //0x03A2
-	char pad_03A3[15]; //0x03A3
-	uint8_t m_spoiler; //0x03B2
-	uint8_t m_bumper_front; //0x03B3
-	uint8_t m_bumper_rear; //0x03B4
-	uint8_t m_sideskirts; //0x03B5
-	uint8_t m_exhaust; //0x03B6
-	uint8_t m_frame; //0x03B7
-	uint8_t m_grille; //0x03B8
-	uint8_t m_hood; //0x03B9
-	uint8_t m_fenders; //0x03BA
-	uint8_t m_bullbars; //0x03BB
-	uint8_t m_roof; //0x03BC
-	char pad_03BD[3]; //0x03BD
-	uint8_t m_ornaments; //0x03C0
-	char pad_03C1[1]; //0x03C1
-	uint8_t m_dail_design; //0x03C2
-	uint8_t m_sunstrips; //0x03C3
-	uint8_t m_seats; //0x03C4
-	uint8_t m_steering_wheel; //0x03C5
-	uint8_t m_column_shifter_levers; //0x03C6
-	char pad_03C7[2]; //0x03C7
-	uint8_t m_truck_beds; //0x03C9
-	char pad_03CA[4]; //0x03CA
-	uint8_t m_roll_cages; //0x03CE
-	uint8_t m_skid_plate; //0x03CF
-	uint8_t m_secondary_light_surrounds; //0x03D0
-	uint8_t m_hood_accessories; //0x03D1
-	uint8_t m_doors; //0x03D2
-	uint8_t m_snorkel; //0x03D3
-	uint8_t m_livery; //0x03D4
-	char pad_03D5[1]; //0x03D5
-	uint8_t m_engine; //0x03D6
-	uint8_t m_brakes; //0x03D7
-	uint8_t m_transmission; //0x03D8
-	uint8_t m_horn; //0x03D9
-	uint8_t m_suspension; //0x03DA
-	uint8_t m_armor; //0x03DB
-	char pad_03DC[1]; //0x03DC
-	uint8_t m_turbo; //0x03DD
-	char pad_03DE[3]; //0x03DE
-	uint8_t m_xenon; //0x03E1
-	uint8_t m_tire_design; //0x03E2
-	char pad_03E3[16]; //0x03E3
-	uint8_t m_truck_bed; //0x03F3
-	char pad_03F4[5]; //0x03F4
-	uint8_t m_wheel_color; //0x03F9
-	char pad_03FA[5]; //0x03FA
-	uint8_t m_window; //0x03FF
-	char pad_0400[2]; //0x0400
-	uint8_t m_neon_left; //0x0402
-	uint8_t m_neon_right; //0x0403
-	uint8_t m_neon_front; //0x0404
-	uint8_t m_neon_rear; //0x0405
-}; //Size: 0x0406
-static_assert(sizeof(CVehicleDrawHandler) == 0x406);