ModdingRX/YimMenu
Archived
1
0
Fork 0
Code Actions Releases Activity

Custom Sky Color and unify some stuff (#1779)

Browse Source
This commit is contained in:
Bugisoft
2023-07-20 22:46:32 +02:00
committed by GitHub
parent 7e50d5377a
commit 74ba7b6860
169 changed files with 612 additions and 649 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/gta/color.hpp
View File

@ -1,23 +0,0 @@
#pragma once
#include <cstdint>
namespace rage
{
struct rgbaColor
{
rgbaColor(std::uint8_t r = 0, std::uint8_t g = 0, std::uint8_t b = 0, std::uint8_t a = 255) :
r(r),
g(g),
b(b),
a(a)
{
}
std::uint8_t r;
std::uint8_t g;
std::uint8_t b;
std::uint8_t a;
};
static_assert(sizeof(rgbaColor) == sizeof(std::uint8_t) * 4);
}

90
src/gta/decal_controller.hpp
View File

@ -1,90 +0,0 @@
#pragma once
#include "array.hpp"
namespace rage
{
class decal;
class decal_list;
class decal_controller
{
public:
char pad_0x0000[0xB0];//0x0000
decal_list* ped_decal_list[69];
decal_list* all_tattoo_decals_active;//0x02D8
};//Size=0x02E0
class decal_list
{
public:
virtual ~decal_list() = default;
virtual __int64 refresh_list(__int64) = 0;
char pad_0x0000[0x15E0]; //0x0000
rage::atArray<decal> decal_array;//0x15E8
void clear_non_perm_decals_from_decal_array()
{
DWORD v1;// edx
BYTE* v2;// rax
__int64 a1 = (__int64)this;
v1 = 0;
if (*(DWORD*)(a1 + 0x15E0) > 0)
{
v2 = (BYTE*)(a1 + 0x1E4);
do
{
*v2 |= 0x40u;
++v1;
v2 += 0x28;
} while (v1 < *(DWORD*)(a1 + 0x15E0));
}
*(DWORD*)(a1 + 0x15E0) = 0;
}
};//Size=0x15F1
class decal_helper
{
public:
virtual ~decal_helper() = default;
virtual Hash* get_decal_type(char*) = 0;
};
class decal
{
public:
std::uint32_t N00000001; //0x0000
std::uint8_t N00000028; //0x0004
std::uint8_t N0000002A; //0x0005
char pad_0x0006[0x2]; //0x0006
std::uint64_t N00000002; //0x0008
std::uint64_t N00000003; //0x0010
std::uint64_t N00000004; //0x0018
std::uint32_t N00000005; //0x0020
std::uint32_t N00000022; //0x0024
std::uint32_t N00000006; //0x0028
char pad_0x002C[0x4]; //0x002C
decal_helper* m_decal_helper;//0x0030
std::uint32_t collection; //0x0038
std::uint32_t overlay; //0x003C
std::uint16_t N00000009; //0x0040
std::uint16_t N00000035; //0x0042
std::uint16_t N00000036; //0x0044
char pad_0x0046[0x2]; //0x0046
std::uint32_t N0000000A; //0x0048
std::uint32_t N00000041; //0x004C
std::uint32_t N0000000B; //0x0050
char pad_0x0054[0x4]; //0x0054
std::uint32_t N0000000C; //0x0058
std::uint32_t N00000046; //0x005C
std::uint32_t N0000000D; //0x0060
char pad_0x0064[0x4]; //0x0064
std::uint64_t N0000000E; //0x0068
std::uint8_t N0000000F; //0x0070
char pad_0x0071[0x7]; //0x0071
};//Size=0x0078
static_assert(sizeof(decal) == 0x78, "decal is not sized properly.");
}

14
src/gta/enums.hpp
View File

@ -3,7 +3,7 @@
constexpr auto MAX_PLAYERS = 32;
enum class ControllerInputs : std::uint32_t
enum class ControllerInputs : uint32_t
{
INPUT_NEXT_CAMERA,
INPUT_LOOK_LR,
@ -372,7 +372,7 @@ enum class ControllerInputs : std::uint32_t
SCRIPTED_INPUT_LAST
};
enum class RadioStationIndexes : std::uint32_t
enum class RadioStationIndexes : uint32_t
{
RADIO_LSROCKRADIO,
RADIO_NONSTOPPOPFM,
@ -509,7 +509,7 @@ enum class eNetworkEvents : uint16_t
NETWORK_CHECK_CATALOG_CRC
};
enum class KickReason : std::uint8_t
enum class KickReason : uint8_t
{
VOTED_OUT,
PEER_COMPLAINTS,
@ -1043,7 +1043,7 @@ enum class BlipRenderBits
BlipIsOnScreen = (1 << 6)
};
enum class eFrameFlags : std::uint32_t
enum class eFrameFlags : uint32_t
{
eFrameFlagExplosiveAmmo = 1 << 11,
eFrameFlagFireAmmo = 1 << 12,
@ -1069,13 +1069,13 @@ enum class eNetObjType
NET_OBJ_TYPE_TRAIN
};
enum class eNetObjectFlags : std::uint16_t
enum class eNetObjectFlags : uint16_t
{
NET_OBJ_FLAGS_FROM_SCRIPT = 1 << 2,
NET_OBJ_FLAGS_SCRIPTED = 1 << 6,
};
enum class eAckCode : std::uint32_t
enum class eAckCode : uint32_t
{
ACKCODE_SUCCESS,
ACKCODE_FAIL,
@ -1088,7 +1088,7 @@ enum class eAckCode : std::uint32_t
ACKCODE_NONE
};
enum class PedBones : std::uint32_t
enum class PedBones : uint32_t
{
SKEL_ROOT = 0x0,
SKEL_Pelvis = 0x2E28,

21
src/gta/gxt2.hpp
View File

@ -1,21 +0,0 @@
#pragma once
struct GXT2_metadata
{
static constexpr auto header = "2TXG";
};
#pragma pack(push, 1)
struct GXT2_key
{
rage::joaat_t key_hash = -1;
uint32_t file_offset_to_text = -1;
};
static_assert(sizeof(GXT2_key) == 8);
#pragma pack(pop)
struct GXT2_entry
{
rage::joaat_t hash = -1;
std::string text;
};

11
src/gta/matrix.hpp
View File

@ -1,5 +1,6 @@
#pragma once
#include "vector.hpp"
#include "rage/vector.hpp"
#include <cstdint>
namespace rage
{
@ -9,10 +10,10 @@ namespace rage
union {
struct
{
vector4 _1;
vector4 _2;
vector4 _3;
vector4 _4;
fvector4 _1;
fvector4 _2;
fvector4 _3;
fvector4 _4;
};
float raw[4 * 4] = {};

28
src/gta/natives.hpp
View File

@ -19,22 +19,22 @@ namespace rage
template<typename T>
void push_arg(T&& value)
{
static_assert(sizeof(T) <= sizeof(std::uint64_t));
*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(reinterpret_cast<std::uint64_t*>(m_args) + (m_arg_count++)) = std::forward<T>(value);
static_assert(sizeof(T) <= sizeof(uint64_t));
*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(reinterpret_cast<uint64_t*>(m_args) + (m_arg_count++)) = std::forward<T>(value);
}
template<typename T>
T& get_arg(std::size_t index)
{
static_assert(sizeof(T) <= sizeof(std::uint64_t));
return *reinterpret_cast<T*>(reinterpret_cast<std::uint64_t*>(m_args) + index);
static_assert(sizeof(T) <= sizeof(uint64_t));
return *reinterpret_cast<T*>(reinterpret_cast<uint64_t*>(m_args) + index);
}
template<typename T>
void set_arg(std::size_t index, T&& value)
{
static_assert(sizeof(T) <= sizeof(std::uint64_t));
*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(reinterpret_cast<std::uint64_t*>(m_args) + index) = std::forward<T>(value);
static_assert(sizeof(T) <= sizeof(uint64_t));
*reinterpret_cast<std::remove_cv_t<std::remove_reference_t<T>>*>(reinterpret_cast<uint64_t*>(m_args) + index) = std::forward<T>(value);
}
template<typename T>
@ -57,13 +57,13 @@ namespace rage
protected:
void* m_return_value;
std::uint32_t m_arg_count;
uint32_t m_arg_count;
void* m_args;
std::int32_t m_data_count;
std::uint32_t m_data[48];
uint32_t m_data[48];
};
static_assert(sizeof(scrNativeCallContext) == 0xE0);
using scrNativeHash = std::uint64_t;
using scrNativeHash = uint64_t;
using scrNativeMapping = std::pair<scrNativeHash, scrNativeHash>;
using scrNativeHandler = void (*)(scrNativeCallContext*);
@ -89,14 +89,14 @@ namespace rage
}
return reinterpret_cast<scrNativeRegistration*>(result);
}
std::uint32_t get_num_entries()
uint32_t get_num_entries()
{
return static_cast<std::uint32_t>(((std::uintptr_t)&m_numEntries1) ^ m_numEntries1 ^ m_numEntries2);
return static_cast<uint32_t>(((std::uintptr_t)&m_numEntries1) ^ m_numEntries1 ^ m_numEntries2);
}
std::uint64_t get_hash(std::uint32_t index)
uint64_t get_hash(uint32_t index)
{
auto nativeAddress = 16 * index + std::uintptr_t(&m_nextRegistration1) + 0x54;
std::uint64_t result;
uint64_t result;
auto charTableOfRegs = (char*)&result - nativeAddress;
auto addressIndex = nativeAddress ^ *(DWORD*)(nativeAddress + 8);
for (auto i = 0; i < 3; i++)
@ -112,7 +112,7 @@ namespace rage
class scrNativeRegistrationTable
{
scrNativeRegistration* m_entries[0xFF];
std::uint32_t m_unk;
uint32_t m_unk;
bool m_initialized;
};
#pragma pack(pop)

20
src/gta/net_game_event.hpp
View File

@ -592,7 +592,7 @@ namespace rage
{
return 0;
};
virtual bool time_to_resend(std::uint32_t time)
virtual bool time_to_resend(uint32_t time)
{
return 0;
};
@ -645,19 +645,19 @@ namespace rage
};
public:
std::uint16_t m_id; // 0x08
uint16_t m_id; // 0x08
bool m_requires_reply; // 0x0A
private:
char m_padding1[0x05]; // 0x0B
public:
netPlayer* m_source_player; // 0x10
netPlayer* m_target_player; // 0x18
std::uint32_t m_resend_time; // 0x20
uint32_t m_resend_time; // 0x20
private:
std::uint16_t m_0x24; // 0x24
std::uint8_t m_0x26; // 0x26
std::uint8_t m_0x27; // 0x27
std::uint32_t m_0x28; // 0x28
uint16_t m_0x24; // 0x24
uint8_t m_0x26; // 0x26
uint8_t m_0x27; // 0x27
uint32_t m_0x28; // 0x28
char m_padding2[0x04];
};
}
@ -667,14 +667,14 @@ class CScriptedGameEvent : public rage::netGameEvent
public:
char m_padding[0x40]; // 0x30
std::int64_t m_args[54]; // 0x70
std::uint32_t m_bitset; // 0x220
std::uint32_t m_args_size; // 0x224
uint32_t m_bitset; // 0x220
uint32_t m_args_size; // 0x224
};
class CNetworkIncrementStatEvent : public rage::netGameEvent
{
public:
Hash m_stat; // 0x30
std::uint32_t m_amount; // 0x34
uint32_t m_amount; // 0x34
};
#pragma pack(pop)

14
src/gta/net_object_mgr.hpp
View File

@ -114,14 +114,14 @@ namespace rage
virtual void _0x88() = 0;
virtual const char* _0x90(int) = 0;
virtual bool HandleCloneCreate(CNetGamePlayer* source, CNetGamePlayer* target, eNetObjType object_type, std::uint16_t object_id, eNetObjectFlags object_flags, void*, std::uint32_t timestamp) = 0;
virtual void HandleCloneCreateAck(CNetGamePlayer* source, CNetGamePlayer* target, std::uint16_t object_flags, eAckCode ack_code) = 0;
virtual bool HandleCloneCreate(CNetGamePlayer* source, CNetGamePlayer* target, eNetObjType object_type, uint16_t object_id, eNetObjectFlags object_flags, void*, uint32_t timestamp) = 0;
virtual void HandleCloneCreateAck(CNetGamePlayer* source, CNetGamePlayer* target, uint16_t object_flags, eAckCode ack_code) = 0;
virtual int HandleCloneSync(CNetGamePlayer* source, CNetGamePlayer* target, eNetObjType object_type, std::uint16_t object_id, void*, std::uint16_t, std::uint32_t timestamp) = 0;
virtual void HandleCloneSyncAck(CNetGamePlayer* source, CNetGamePlayer* target, void*, std::uint16_t objectId, eAckCode ack_code) = 0;
virtual int HandleCloneSync(CNetGamePlayer* source, CNetGamePlayer* target, eNetObjType object_type, uint16_t object_id, void*, uint16_t, uint32_t timestamp) = 0;
virtual void HandleCloneSyncAck(CNetGamePlayer* source, CNetGamePlayer* target, void*, uint16_t objectId, eAckCode ack_code) = 0;
virtual void HandleCloneRemove(CNetGamePlayer* source, CNetGamePlayer* target, std::uint16_t object_id, int) = 0;
virtual void HandleCloneRemoveAck(CNetGamePlayer* source, CNetGamePlayer* target, std::uint16_t object_id, eAckCode ack_code) = 0;
virtual void HandleCloneRemove(CNetGamePlayer* source, CNetGamePlayer* target, uint16_t object_id, int) = 0;
virtual void HandleCloneRemoveAck(CNetGamePlayer* source, CNetGamePlayer* target, uint16_t object_id, eAckCode ack_code) = 0;
virtual void _0xC8() = 0;
@ -133,7 +133,7 @@ namespace rage
class CNetworkObjectMgr : public rage::netObjectMgrBase
{
public:
rage::netObject* find_object_by_id(std::uint16_t object_id, bool can_delete_be_pending)
rage::netObject* find_object_by_id(uint16_t object_id, bool can_delete_be_pending)
{
return big::g_pointers->m_gta.m_get_net_object(this, object_id, can_delete_be_pending);
}

34
src/gta/script_handler.hpp
View File

@ -15,7 +15,7 @@ namespace rage
{
public:
scriptResource* m_data; // 0x00
std::uint32_t m_unk; // 0x04
uint32_t m_unk; // 0x04
char m_padding[0x0C]; // 0x0C
scriptResourceEntry* m_next;// 0x18
};
@ -75,22 +75,22 @@ public:
class CGameScriptHandlerNetwork : public CGameScriptHandler
{
public:
std::uint8_t m_0xA0; // 0xA0
std::uint8_t m_0xA1; // 0xA1
std::uint8_t m_0xA2; // 0xA2
std::uint8_t m_0xA3; // 0xA3
std::uint8_t m_num_players;// 0xA4
std::uint8_t m_0xA5; // 0xA5
std::uint8_t m_0xA6; // 0xA6
std::uint8_t m_0xA7; // 0xA7
std::uint8_t m_0xA8; // 0xA8
std::uint8_t m_0xA9; // 0xA9
std::uint8_t m_0xAA; // 0xAA
std::uint8_t m_0xAB; // 0xAB
std::uint8_t m_0xAC; // 0xAC
std::uint8_t m_0xAD; // 0xAD
std::uint8_t m_0xAE; // 0xAE
std::uint8_t m_0xAF; // 0xAF
uint8_t m_0xA0; // 0xA0
uint8_t m_0xA1; // 0xA1
uint8_t m_0xA2; // 0xA2
uint8_t m_0xA3; // 0xA3
uint8_t m_num_players;// 0xA4
uint8_t m_0xA5; // 0xA5
uint8_t m_0xA6; // 0xA6
uint8_t m_0xA7; // 0xA7
uint8_t m_0xA8; // 0xA8
uint8_t m_0xA9; // 0xA9
uint8_t m_0xAA; // 0xAA
uint8_t m_0xAB; // 0xAB
uint8_t m_0xAC; // 0xAC
uint8_t m_0xAD; // 0xAD
uint8_t m_0xAE; // 0xAE
uint8_t m_0xAF; // 0xAF
};
class CScriptParticipant

36
src/gta/script_program.hpp
View File

@ -12,22 +12,22 @@ namespace rage
class scrProgram : public pgBase
{
public:
std::uint8_t** m_code_blocks; // 0x10
std::uint32_t m_hash; // 0x18
std::uint32_t m_code_size; // 0x1C
std::uint32_t m_arg_count; // 0x20
std::uint32_t m_local_count; // 0x24
std::uint32_t m_global_count; // 0x28
std::uint32_t m_native_count; // 0x2C
uint8_t** m_code_blocks; // 0x10
uint32_t m_hash; // 0x18
uint32_t m_code_size; // 0x1C
uint32_t m_arg_count; // 0x20
uint32_t m_local_count; // 0x24
uint32_t m_global_count; // 0x28
uint32_t m_native_count; // 0x2C
void* m_local_data; // 0x30
std::int64_t** m_global_data; // 0x38
void** m_native_entrypoints; // 0x40
char m_padding6[0x10]; // 0x48
std::uint32_t m_name_hash; // 0x58
uint32_t m_name_hash; // 0x58
char m_padding7[0x04]; // 0x5C
const char* m_name; // 0x60
const char** m_strings_data; // 0x68
std::uint32_t m_strings_count;// 0x70
uint32_t m_strings_count;// 0x70
char m_padding8[0x0C]; // 0x74
bool is_valid() const
@ -35,12 +35,12 @@ namespace rage
return m_code_size != 0;
}
std::uint32_t get_num_code_pages() const
uint32_t get_num_code_pages() const
{
return (m_code_size + 0x3FFF) >> 14;
}
std::uint32_t get_code_page_size(std::uint32_t page) const
uint32_t get_code_page_size(uint32_t page) const
{
auto num = get_num_code_pages();
if (page < num)
@ -53,7 +53,7 @@ namespace rage
return 0;
}
std::uint32_t get_full_code_size() const
uint32_t get_full_code_size() const
{
auto numPages = get_num_code_pages();
if (!numPages)
@ -64,12 +64,12 @@ namespace rage
return (numPages * 0x4000) + (m_code_size & 0x3FFF);
}
std::uint8_t* get_code_page(std::uint32_t page) const
uint8_t* get_code_page(uint32_t page) const
{
return m_code_blocks[page];
}
std::uint8_t* get_code_address(std::uint32_t index) const
uint8_t* get_code_address(uint32_t index) const
{
if (index < m_code_size)
return &m_code_blocks[index >> 14][index & 0x3FFF];
@ -77,7 +77,7 @@ namespace rage
return nullptr;
}
const char* get_string(std::uint32_t index) const
const char* get_string(uint32_t index) const
{
if (index < m_strings_count)
return &m_strings_data[index >> 14][index & 0x3FFF];
@ -87,7 +87,7 @@ namespace rage
void** get_address_of_native_entrypoint(void* entrypoint)
{
for (std::uint32_t i = 0; i < m_native_count; ++i)
for (uint32_t i = 0; i < m_native_count; ++i)
{
if (m_native_entrypoints[i] == entrypoint)
{
@ -112,7 +112,7 @@ namespace rage
public:
scrProgramTableEntry* m_data;// 0x00
char m_padding[0x10]; // 0x08
std::uint32_t m_size; // 0x18
uint32_t m_size; // 0x18
std::list<joaat_t> all_script_hashes()
{
@ -144,7 +144,7 @@ namespace rage
scrProgram* find_script(joaat_t hash)
{
for (std::uint32_t i = 0; i < m_size; ++i)
for (uint32_t i = 0; i < m_size; ++i)
{
if (m_data[i].m_hash == hash)
{

2
src/gta/script_thread.hpp
View File

@ -13,7 +13,7 @@ public:
char m_padding3[0x14]; // 0x124
std::int32_t m_instance_id; // 0x138
char m_padding4[0x04]; // 0x13C
std::uint8_t m_flag1; // 0x140
uint8_t m_flag1; // 0x140
bool m_safe_for_network_game; // 0x141
char m_padding5[0x02]; // 0x142
bool m_is_minigame_script; // 0x144