Backups/EGameTools
1
0
Fork 0
mirror of https://github.com/EricPlayZ/EGameTools.git synced 2025-07-18 17:37:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

scripts update and SDK update with lots of new classes - gonna have to do this automatically somehow because it will take the entire weekend to generate each class manually!

Browse Source
This commit is contained in:
EricPlayZ
2025-03-08 03:39:31 +02:00
parent 6f030f6cc6
commit 0e7674c15a
118 changed files with 6363 additions and 39183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
.gitignore vendored
View File

@ -1,4 +1,7 @@
# Ultimate-ASI-Loader
_IDAScripts/.env
_IDAScripts/_generated/
# Ultimate-ASI-Loader
data/
!data/**/*.ini

10
EGameSDK.sln
View File

@ -12,8 +12,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EGameSDK", "EGameSDK\EGameS
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Ultimate-ASI-Loader-x64", "Ultimate-ASI-Loader-x64\Ultimate-ASI-Loader-x64.vcxproj", "{47F0BD81-B327-0619-BC31-6A3C28E82C12}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "engine_x64_rwdi", "EGameSDK\proxies\engine_x64_rwdi\engine_x64_rwdi.vcxproj", "{43D9B339-9A92-4D78-BD8E-5026ABFC8604}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
@ -46,14 +44,6 @@ Global
{47F0BD81-B327-0619-BC31-6A3C28E82C12}.Release|x64.Build.0 = Release|x64
{47F0BD81-B327-0619-BC31-6A3C28E82C12}.Release|x86.ActiveCfg = Release|x64
{47F0BD81-B327-0619-BC31-6A3C28E82C12}.Release|x86.Build.0 = Release|x64
{43D9B339-9A92-4D78-BD8E-5026ABFC8604}.Debug|x64.ActiveCfg = Debug_Release|x64
{43D9B339-9A92-4D78-BD8E-5026ABFC8604}.Debug|x64.Build.0 = Debug_Release|x64
{43D9B339-9A92-4D78-BD8E-5026ABFC8604}.Debug|x86.ActiveCfg = Debug|Win32
{43D9B339-9A92-4D78-BD8E-5026ABFC8604}.Debug|x86.Build.0 = Debug|Win32
{43D9B339-9A92-4D78-BD8E-5026ABFC8604}.Release|x64.ActiveCfg = Release|x64
{43D9B339-9A92-4D78-BD8E-5026ABFC8604}.Release|x64.Build.0 = Release|x64
{43D9B339-9A92-4D78-BD8E-5026ABFC8604}.Release|x86.ActiveCfg = Release|Win32
{43D9B339-9A92-4D78-BD8E-5026ABFC8604}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

42
EGameSDK/EGameSDK.vcxproj
View File

@ -72,29 +72,65 @@
<ClCompile Include="src\Vec4.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\_IDAScripts\generated\MED.h" />
<ClInclude Include="include\EGSDK\ClassHelpers.h" />
<ClInclude Include="include\EGSDK\Core\Core.h" />
<ClInclude Include="include\EGSDK\Core\SaveGameManager.h" />
<ClInclude Include="include\EGSDK\Core\SteamAPI.h" />
<ClInclude Include="include\EGSDK\Engine\CBaseCamera.h" />
<ClInclude Include="include\EGSDK\Engine\cbs.h" />
<ClInclude Include="include\EGSDK\Engine\CBulletPhysicsCharacter.h" />
<ClInclude Include="include\EGSDK\Engine\CGame.h" />
<ClInclude Include="include\EGSDK\Engine\CGSObject.h" />
<ClInclude Include="include\EGSDK\Engine\CGSObject2.h" />
<ClInclude Include="include\EGSDK\Engine\CInput.h" />
<ClInclude Include="include\EGSDK\Engine\ClassReaderResolve.h" />
<ClInclude Include="include\EGSDK\Engine\CLevel.h" />
<ClInclude Include="include\EGSDK\Engine\CLevel2.h" />
<ClInclude Include="include\EGSDK\Engine\CLobbySteam.h" />
<ClInclude Include="include\EGSDK\Engine\CoPhysicsProperty.h" />
<ClInclude Include="include\EGSDK\Engine\CRTTI.h" />
<ClInclude Include="include\EGSDK\Engine\CRTTIDebugVis.h" />
<ClInclude Include="include\EGSDK\Engine\CRTTIField.h" />
<ClInclude Include="include\EGSDK\Engine\CRTTIMethod.h" />
<ClInclude Include="include\EGSDK\Engine\CRTTIObject.h" />
<ClInclude Include="include\EGSDK\Engine\EMem.h" />
<ClInclude Include="include\EGSDK\Engine\ERTTIClassFlags.h" />
<ClInclude Include="include\EGSDK\Engine\IBaseCamera.h" />
<ClInclude Include="include\EGSDK\Engine\IClassWriter.h" />
<ClInclude Include="include\EGSDK\Engine\IControlObject.h" />
<ClInclude Include="include\EGSDK\Engine\IGSObject.h" />
<ClInclude Include="include\EGSDK\Engine\IMaterial.h" />
<ClInclude Include="include\EGSDK\Engine\IModelObject.h" />
<ClInclude Include="include\EGSDK\Engine\IObject.h" />
<ClInclude Include="include\EGSDK\Engine\IPhysicsCharacter.h" />
<ClInclude Include="include\EGSDK\Engine\CVars.h" />
<ClInclude Include="include\EGSDK\Engine\CVideoSettings.h" />
<ClInclude Include="include\EGSDK\Engine\Engine_Misc.h" />
<ClInclude Include="include\EGSDK\Engine\ttl.h" />
<ClInclude Include="include\EGSDK\Engine\IPtrResolver.h" />
<ClInclude Include="include\EGSDK\Engine\IRTTIEnumerationTyped.h" />
<ClInclude Include="include\EGSDK\Engine\IScriptManager.h" />
<ClInclude Include="include\EGSDK\Engine\ITextDeserializer.h" />
<ClInclude Include="include\EGSDK\Engine\ITextSerializer.h" />
<ClInclude Include="include\EGSDK\Engine\MaterialEditorCommon.h" />
<ClInclude Include="include\EGSDK\Engine\Net\Repl\CRttiInfo.h" />
<ClInclude Include="include\EGSDK\Engine\Net\Repl\Rtti\Serializer.h" />
<ClInclude Include="include\EGSDK\Engine\parser.h" />
<ClInclude Include="include\EGSDK\Engine\rtti.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\allocator.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\char_traits.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\function_ref.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\less.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\list.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\map.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\pstring.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\set.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\string_base.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\string_const.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\string_view_base.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\vector.h" />
<ClInclude Include="include\EGSDK\Engine\ttl\vector_allocators\heap_allocator.h" />
<ClInclude Include="include\EGSDK\Engine\Uid.h" />
<ClInclude Include="include\EGSDK\Engine\VarBase.h" />
<ClInclude Include="include\EGSDK\Engine\VarManagerBase.h" />
<ClInclude Include="include\EGSDK\Engine\VarMapBase.h" />
@ -229,7 +265,7 @@
</OptimizeReferences>
<EnableCOMDATFolding>
</EnableCOMDATFolding>
<AdditionalLibraryDirectories>deps\MinHook\lib;$(SolutionDir)$(Platform)\$(Configuration)\;</AdditionalLibraryDirectories>
<AdditionalLibraryDirectories>deps\MinHook\lib;deps\game_libs;</AdditionalLibraryDirectories>
<AssemblyDebug>true</AssemblyDebug>
<ImportLibrary />
<FixedBaseAddress>
@ -260,7 +296,7 @@
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<AdditionalLibraryDirectories>deps\MinHook\lib;$(SolutionDir)$(Platform)\$(Configuration)\;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalLibraryDirectories>deps\MinHook\lib;deps\game_libs;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>DbgHelp.lib;Version.lib;libMinHook-x64-v141-mdd.lib;engine_x64_rwdi.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
<ImportLibrary />
<AdditionalOptions>%(AdditionalOptions)</AdditionalOptions>

129
EGameSDK/EGameSDK.vcxproj.filters
View File

@ -225,6 +225,21 @@
<Filter Include="src\GamePH\TimeWeather">
<UniqueIdentifier>{5af79ed5-d275-484f-b7b0-0f23aef9f33d}</UniqueIdentifier>
</Filter>
<Filter Include="include\Engine\ttl">
<UniqueIdentifier>{2fc040c8-107c-4446-8c48-9fee784cc37a}</UniqueIdentifier>
</Filter>
<Filter Include="include\Engine\ttl\vector_allocators">
<UniqueIdentifier>{84c86ad8-9a3c-4e82-8862-93de4642f3a2}</UniqueIdentifier>
</Filter>
<Filter Include="include\Engine\Net">
<UniqueIdentifier>{4b772580-5ad3-4e62-a63a-1a9100604e94}</UniqueIdentifier>
</Filter>
<Filter Include="include\Engine\Net\Repl">
<UniqueIdentifier>{61c6c447-32b2-4b9d-a20c-3c6ca2da58e5}</UniqueIdentifier>
</Filter>
<Filter Include="include\Engine\Net\Repl\Rtti">
<UniqueIdentifier>{ba49d269-bd73-48d3-b366-2f7eb1df2a1a}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="include\EGSDK\ClassHelpers.h">
@ -428,11 +443,119 @@
<ClInclude Include="include\EGSDK\Engine\IModelObject.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Imports.h">
<Filter>include</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\CRTTI.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\CRTTIField.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\allocator.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\less.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\list.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\map.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\string_base.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\string_const.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\vector.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\vector_allocators\heap_allocator.h">
<Filter>include\Engine\ttl\vector_allocators</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\parser.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="..\_IDAScripts\generated\MED.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\rtti.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\MaterialEditorCommon.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\IMaterial.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\set.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\cbs.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ClassReaderResolve.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\IScriptManager.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ERTTIClassFlags.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\CRTTIMethod.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\CRTTIObject.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\IObject.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\Net\Repl\CRttiInfo.h">
<Filter>include\Engine\Net\Repl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\pstring.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\EMem.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\CRTTIDebugVis.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\Net\Repl\Rtti\Serializer.h">
<Filter>include\Engine\Net\Repl\Rtti</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\string_view_base.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\char_traits.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\IRTTIEnumerationTyped.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\Uid.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ITextDeserializer.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ITextSerializer.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\ttl\function_ref.h">
<Filter>include\Engine\ttl</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\IPtrResolver.h">
<Filter>include\Engine</Filter>
</ClInclude>
<ClInclude Include="include\EGSDK\Engine\IClassWriter.h">
<Filter>include\Engine</Filter>
</ClInclude>
</ItemGroup>
</Project>

BIN
EGameSDK/deps/game_libs/engine_x64_rwdi.lib Normal file
View File

Binary file not shown.

87
EGameSDK/include/EGSDK/Engine/CBaseCamera.h
View File

@ -1,49 +1,50 @@
#pragma once
#include <EGSDK\Engine\IBaseCamera.h>
#include <EGSDK\Imports.h>
#include <EGSDK\Engine\rtti\Type.h>
#include <EGSDK\Engine\ttl\list.h>
#include <EGSDK\Engine\ttl\allocator.h>
namespace EGSDK::Engine {
class EGameSDK_API CBaseCamera : public IBaseCamera {
class CBaseCamera {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
GAME_IMPORT static rtti::Type& m_RTTI;
public:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
GAME_IMPORT static rtti::Type& m_RTTI;
VIRTUAL_CALL(0, uint64_t*, sub_405720, (char a1), a1);
VIRTUAL_CALL(1, int64_t, sub_10E8140, (int64_t a1), a1);
VIRTUAL_CALL(2, int64_t, sub_10E8260, (int64_t a1), a1);
VIRTUAL_CALL(3, int64_t, sub_10E8390, (int64_t a1), a1);
VIRTUAL_CALL(4, int64_t, sub_10E8730, (__int128* a1, char a2), a1, a2);
VIRTUAL_CALL(5, ttl::list<MED::CMaterialTemplate::FieldDefinition, ttl::allocator> const&, fields, ());
VIRTUAL_CALL(6, SpawnMaskingPath const&, GetSpawnMaskingPath, ());
VIRTUAL_CALL(7, CRTTIObject* const&, GetValueConstValue, (gui::CActionGraphInstance*), gui::CActionGraphInstance*);
VIRTUAL_CALL(8, ttl::list<MED::CMaterialTemplate::FieldDefinition, ttl::allocator> const&, _fields1, ());
VIRTUAL_CALL(9, int64_t, sub_10E8800, ());
VIRTUAL_CALL(10, int64_t, sub_417620, ());
VIRTUAL_CALL(11, int64_t, sub_42B070, ());
VIRTUAL_CALL(12, int64_t, sub_43D650, ());
VIRTUAL_CALL(13, double, sub_43B610, (int a1, int a2, int a3), a1, a2, a3);
VIRTUAL_CALL(14, int64_t, sub_43C1F0, (int a1), a1);
VIRTUAL_CALL(15, int64_t, sub_43CAC0, ());
VIRTUAL_CALL(16, const char*, sub_419DF0, ());
VIRTUAL_CALL(17, int64_t, sub_40B260, ());
VIRTUAL_CALL(18, void, sub_4136E0, (float a1, float a2, float a3, int a4), a1, a2, a3, a4);
VIRTUAL_CALL(19, void, sub_4136A0, (float a1, float a2), a1, a2);
VIRTUAL_CALL(20, void, sub_41FFA0, ());
VIRTUAL_CALL(21, int64_t, sub_43D620, (float a1), a1);
VIRTUAL_CALL(22, float, sub_41DD20, ());
VIRTUAL_CALL(23, char*, sub_419B40, ());
VIRTUAL_CALL(24, int64_t, sub_4461D0, (int64_t a1, int64_t a2), a1, a2);
VIRTUAL_CALL(0, uint64_t*, sub_405720, (char a1), a1);
VIRTUAL_CALL(1, int64_t, sub_10E8140, (int64_t a1), a1);
VIRTUAL_CALL(2, int64_t, sub_10E8260, (int64_t a1), a1);
VIRTUAL_CALL(3, int64_t, sub_10E8390, (int64_t a1), a1);
VIRTUAL_CALL(4, int64_t, sub_10E8730, (__int128* a1, char a2), a1, a2);
VIRTUAL_CALL(5, ttl::list<MED::CMaterialTemplate::FieldDefinition, ttl::allocator> const&, fields, ());
VIRTUAL_CALL(6, SpawnMaskingPath const&, GetSpawnMaskingPath, ());
VIRTUAL_CALL(7, CRTTIObject* const&, GetValueConstValue, (gui::CActionGraphInstance*), gui::CActionGraphInstance*);
VIRTUAL_CALL(8, ttl::list<MED::CMaterialTemplate::FieldDefinition, ttl::allocator> const&, _fields1, ());
VIRTUAL_CALL(9, int64_t, sub_10E8800, ());
VIRTUAL_CALL(10, int64_t, sub_417620, ());
VIRTUAL_CALL(11, int64_t, sub_42B070, ());
VIRTUAL_CALL(12, int64_t, sub_43D650, ());
VIRTUAL_CALL(13, double, sub_43B610, (int a1, int a2, int a3), a1, a2, a3);
VIRTUAL_CALL(14, int64_t, sub_43C1F0, (int a1), a1);
VIRTUAL_CALL(15, int64_t, sub_43CAC0, ());
VIRTUAL_CALL(16, const char*, sub_419DF0, ());
VIRTUAL_CALL(17, int64_t, sub_40B260, ());
VIRTUAL_CALL(18, void, sub_4136E0, (float a1, float a2, float a3, int a4), a1, a2, a3, a4);
VIRTUAL_CALL(19, void, sub_4136A0, (float a1, float a2), a1, a2);
VIRTUAL_CALL(20, void, sub_41FFA0, ());
VIRTUAL_CALL(21, int64_t, sub_43D620, (float a1), a1);
VIRTUAL_CALL(22, float, sub_41DD20, ());
VIRTUAL_CALL(23, char*, sub_419B40, ());
VIRTUAL_CALL(24, int64_t, sub_4461D0, (int64_t a1, int64_t a2), a1, a2);
GAME_IMPORT static rtti::Type& typeinfo();
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT static CRTTI* GetSTTI();
private:
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
public:
GAME_IMPORT static CBaseCamera::CBaseCameraMemento const* LoadMemento(fs::ifile&);
GAME_IMPORT static rtti::Type& typeinfo();
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT static CRTTI* GetSTTI();
private:
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
public:
GAME_IMPORT static CBaseCamera::CBaseCameraMemento const* LoadMemento(fs::ifile&);
#pragma endregion
};
}
};

146
EGameSDK/include/EGSDK/Engine/CRTTI.h Normal file
View File

@ -0,0 +1,146 @@
#pragma once
#include <EGSDK\Imports.h>
#include <EGSDK\Engine\cbs.h>
#include <EGSDK\Engine\ClassReaderResolve.h>
#include <EGSDK\Engine\CRTTIField.h>
#include <EGSDK\Engine\CRTTIObject.h>
#include <EGSDK\Engine\CRTTIMethod.h>
#include <EGSDK\Engine\CRTTIDebugVis.h>
#include <EGSDK\Engine\ERTTIClassFlags.h>
#include <EGSDK\Engine\IScriptManager.h>
#include <EGSDK\Engine\EMem.h>
#include <EGSDK\Engine\Net\Repl\CRttiInfo.h>
#include <EGSDK\Engine\Net\Repl\Rtti\Serializer.h>
#include <EGSDK\Engine\ttl\vector_allocators\heap_allocator.h>
#include <EGSDK\Engine\ttl\string_base.h>
#include <EGSDK\Engine\ttl\string_const.h>
#include <EGSDK\Engine\ttl\string_view_base.h>
#include <EGSDK\Engine\ttl\char_traits.h>
#include <EGSDK\Engine\ttl\vector.h>
#include <EGSDK\Engine\ttl\list.h>
#include <EGSDK\Engine\ttl\pstring.h>
#include <EGSDK\Engine\ttl\allocator.h>
class CRTTI {
public:
struct SEditorData;
#pragma region GENERATED by ExportClassToCPPH.py
protected:
GAME_IMPORT static bool s_CheckDuplicated;
public:
VIRTUAL_CALL(0, CRTTI*, sub_11D3F0, (char a1), a1);
GAME_IMPORT virtual void ReleaseUnusedMemory();
GAME_IMPORT virtual void InitializeRttiReplication();
VIRTUAL_CALL(3, void, SetPlatform, ());
VIRTUAL_CALL(4, int64_t, RunUnitTests, ());
VIRTUAL_CALL(5, int64_t, _RunUnitTests1, ());
VIRTUAL_CALL(6, int64_t, _RunUnitTests2, ());
protected:
GAME_IMPORT virtual CRTTI::SEditorData* CreateEditorData();
public:
GAME_IMPORT virtual ttl::string_base<char> ClassWriterCompare(CRTTI const*, CRTTI const*, CRTTI const&) const;
VIRTUAL_CALL(9, bool, updateRttiParams, ());
GAME_IMPORT CRTTI(ClassReaderResolve const&);
GAME_IMPORT void HideField(char const*);
GAME_IMPORT bool FromClassOrInterface(rtti::Type const*) const;
GAME_IMPORT bool FromEngineClass(CRTTI const*) const;
GAME_IMPORT bool ParseInfoString(char const*);
GAME_IMPORT bool FromClassOrInterface(CRTTI const*) const;
GAME_IMPORT CRTTIField const* FindRenamedField(char const*) const;
GAME_IMPORT CRTTI(char const*, int, void (* )( CRTTI* ), CRTTI*, CRTTI const*, IScriptManager*, bool, bool, bool, int, EMem::TYPE, bool);
GAME_IMPORT void RemoveField(CRTTIField const*);
GAME_IMPORT void GetFieldsToEditUnsorted(ttl::list<CRTTIField const*, ttl::allocator>&) const;
GAME_IMPORT CRTTI& operator=(CRTTI const&);
GAME_IMPORT void GetAllFields(ttl::vector<CRTTIField const*, ttl::vector_allocators::heap_allocator<CRTTIField const*>, 64>&) const;
GAME_IMPORT CRTTI::SEditorData& EditorData();
GAME_IMPORT bool FromEngineClass(int) const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(char const*) const;
GAME_IMPORT void InitializeRttiSerialization();
GAME_IMPORT void ClearClassFlags(ERTTIClassFlags);
GAME_IMPORT static void CheckDuplicated(bool);
GAME_IMPORT void SetForcedToSaveField(CRTTIField const&, bool);
GAME_IMPORT bool FromClass(rtti::Type const&) const;
GAME_IMPORT void UnhideField(char const*);
GAME_IMPORT void ResolveMyAndBaseFields();
GAME_IMPORT bool IsAbstract() const;
GAME_IMPORT void AddExternalField(CRTTIField const*);
GAME_IMPORT void CreateGuiGameDataEventDispatcher();
GAME_IMPORT cbs::msg::RttiMessageDispatcher const* FindMessageDispatcherForPipe(uint64_t) const;
GAME_IMPORT CRTTIField const* FindFieldAtOffset(uint32_t) const;
GAME_IMPORT void SetPrefabName(ttl::string_base<char> const&);
GAME_IMPORT bool CopyFields(CRTTIObject*, CRTTIObject const*, bool) const;
GAME_IMPORT CRTTI const* GetBaseClass(CRTTI const*) const;
GAME_IMPORT bool IsSetFieldForcedToSave(CRTTIField const&) const;
GAME_IMPORT CRTTI const* GetProxyComponentClass() const;
GAME_IMPORT void AddMethod(CRTTIMethod const*);
GAME_IMPORT bool IsImplementingInterface(int) const;
GAME_IMPORT ttl::string_const<char> GetClassNameWithoutNamespace() const;
GAME_IMPORT Net::Repl::CRttiInfo const* ToIRtti() const;
GAME_IMPORT bool IsReplicationPossible() const;
GAME_IMPORT void AddField(CRTTIField*);
GAME_IMPORT CRTTIField const* FindField(ttl::pstring) const;
GAME_IMPORT CRTTI(ttl::string_const<char>, CRTTI*, EMem::TYPE);
GAME_IMPORT CRTTIDebugVis const& GetVis() const;
GAME_IMPORT bool IsFieldHidden(CRTTIField const*) const;
GAME_IMPORT void AddImplementation(CRTTI const*);
GAME_IMPORT CRTTI(CRTTI const&);
GAME_IMPORT bool FromAbstractClass() const;
GAME_IMPORT CRTTI const* GetNativeClass() const;
GAME_IMPORT void CreateRttiSerialization();
GAME_IMPORT void ResolveGuiGameDataEventDispatchers();
GAME_IMPORT cbs::msg::RttiMessageDispatcher* GetMessageDispatcherForPipe(uint64_t);
GAME_IMPORT bool FromClassByName(char const*) const;
GAME_IMPORT void CopyGuiGameDataEventDispatcher(CRTTI const*);
GAME_IMPORT bool FromClassOrInterfaceByName(char const*) const;
GAME_IMPORT CRTTIField const* FindRenamedField(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT bool FromClass(int) const;
GAME_IMPORT Net::Repl::Rtti::Serializer const* RttiSerializer() const;
GAME_IMPORT void PreInitializeRttiSerialization();
GAME_IMPORT bool RequiresMatrixChangedNotifications() const;
GAME_IMPORT bool ArePresetsLoaded() const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT bool IsExactClass(rtti::Type const*) const;
GAME_IMPORT void ResolvePStorageAndSaveGameFields();
GAME_IMPORT void ResolveHiddenFields() const;
GAME_IMPORT void Shutdown();
GAME_IMPORT void ReResolveMyAndBaseFields();
GAME_IMPORT bool Initialize();
GAME_IMPORT bool IsReplicated() const;
GAME_IMPORT bool IsExactClass(CRTTI const*) const;
GAME_IMPORT bool HasVis() const;
GAME_IMPORT bool FromClass(rtti::Type const*) const;
GAME_IMPORT void SetSystem(cbs::CSystemBase*);
GAME_IMPORT bool FromClassOrInterface(int) const;
GAME_IMPORT bool IsImplementingInterface(CRTTI const*) const;
GAME_IMPORT void AddInterface(CRTTI const*);
GAME_IMPORT bool FromEngineClass(rtti::Type const&) const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(ttl::pstring) const;
GAME_IMPORT void GetFieldsToEdit(ttl::list<CRTTIField const*, ttl::allocator>&) const;
GAME_IMPORT CRTTIField const* FindField(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT void SetPresetsLoaded(bool) const;
GAME_IMPORT CRTTIField const* FindField(char const*) const;
GAME_IMPORT CRTTIMethod const* FindMethod(char const*) const;
GAME_IMPORT cbs::CSystemBase* GetSystem() const;
GAME_IMPORT CRTTIField const* FindField(ttl::pstring, unsigned short&) const;
GAME_IMPORT bool ExchangePointerFields(CRTTIObject*, CRTTIObject*) const;
GAME_IMPORT char const* GetClassNameA() const;
GAME_IMPORT bool FromClass(CRTTI const*) const;
GAME_IMPORT bool IsObsolete() const;
private:
GAME_IMPORT void PrepareReplicatedFields();
public:
GAME_IMPORT bool IsExactClass(int) const;
GAME_IMPORT void SetClassFlags(ERTTIClassFlags);
GAME_IMPORT gui::CGameDataEventDispatcher* GetGuiGameDataEventDispatcher() const;
GAME_IMPORT CRTTIField const* FindRenamedField(ttl::pstring) const;
GAME_IMPORT void OverrideField(char const*);
GAME_IMPORT CRTTI::SEditorData const& GetEditorData() const;
GAME_IMPORT void ClearFieldsList();
GAME_IMPORT EMem::TYPE GetMemCategory() const;
GAME_IMPORT bool CopyPointerFields(CRTTIObject*, CRTTIObject const*) const;
GAME_IMPORT bool IsClassFlag(ERTTIClassFlags) const;
#pragma endregion
};

18
EGameSDK/include/EGSDK/Engine/CRTTIDebugVis.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIDebugVis {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_C5A630, (char a1), a1);
VIRTUAL_CALL(1, int64_t, sub_CC4480, ());
VIRTUAL_CALL(2, void, sub_CAEF40, ());
VIRTUAL_CALL(3, uint64_t, sub_C5D570, (char a1, int64_t a2, int64_t a3, int a4, char a5), a1, a2, a3, a4, a5);
VIRTUAL_CALL(4, uint64_t, sub_C5D470, (char a1, int64_t a2, int64_t a3, int a4, char a5), a1, a2, a3, a4, a5);
VIRTUAL_CALL(5, uint64_t, sub_C5D630, (char a1, const char* a2, int64_t a3, int a4, char a5), a1, a2, a3, a4, a5);
VIRTUAL_CALL(6, uint64_t, sub_C5D780, (char a1, const char* a2, int64_t a3, int64_t a4, int a5, char a6), a1, a2, a3, a4, a5, a6);
VIRTUAL_CALL(7, uint64_t, sub_C5D330, (char a1, int64_t a2, const char* a3, int64_t a4, int a5, char a6), a1, a2, a3, a4, a5, a6);
VIRTUAL_CALL(8, uint64_t, sub_C5E6E0, (char a1, const char* a2, int64_t a3, char a4), a1, a2, a3, a4);
VIRTUAL_CALL(9, uint64_t, sub_C5C800, (char a1, const char* a2, int64_t a3, char a4), a1, a2, a3, a4);
#pragma endregion
};

106
EGameSDK/include/EGSDK/Engine/CRTTIField.h Normal file
View File

@ -0,0 +1,106 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIField {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, CRTTIField*, sub_119B50, (char a1), a1);
VIRTUAL_CALL(1, int64_t, RunUnitTests, ());
GAME_IMPORT virtual CRTTIField::Variant* GetFieldDefaultVariantPtr(CRTTI const*) const;
VIRTUAL_CALL(3, int64_t, _RunUnitTests1, ());
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
VIRTUAL_CALL(7, bool, updateRttiParams, ());
GAME_IMPORT virtual bool GetValidValuesEditor(CRTTIObject*, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&) const;
virtual void _StrippedVFunc4() = 0;
virtual void _StrippedVFunc5() = 0;
VIRTUAL_CALL(11, int64_t, _RunUnitTests2, ());
VIRTUAL_CALL(12, bool, _updateRttiParams1, ());
virtual void _StrippedVFunc6() = 0;
virtual void _StrippedVFunc7() = 0;
virtual void _StrippedVFunc8() = 0;
VIRTUAL_CALL(16, int64_t, _RunUnitTests3, ());
GAME_IMPORT virtual bool Copy(CRTTIObject*, CRTTIObject const*) const;
GAME_IMPORT virtual bool Exchange(CRTTIObject*, CRTTIObject*) const;
VIRTUAL_CALL(19, bool, _updateRttiParams2, ());
GAME_IMPORT virtual ttl::string_base<char> const ClampString(char const*) const;
VIRTUAL_CALL(21, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool AddVirtualFieldDestination(CRTTIField const*, uint32_t, ttl::string_base<char>*);
VIRTUAL_CALL(23, bool, _updateRttiParams3, ());
VIRTUAL_CALL(24, int64_t, _RunUnitTests5, ());
VIRTUAL_CALL(25, void, SetPlatform, ());
GAME_IMPORT virtual bool OverwriteVirtualFieldFlags(CRTTIField const*);
VIRTUAL_CALL(27, int64_t, _RunUnitTests6, ());
VIRTUAL_CALL(28, void, _SetPlatform1, ());
VIRTUAL_CALL(29, int64_t, _RunUnitTests7, ());
VIRTUAL_CALL(30, void, _SetPlatform2, ());
GAME_IMPORT virtual void WriteToDom(dom::IWriter&, CRTTIObject const*) const;
GAME_IMPORT virtual void ReadFromDom(dom::IReader::Array const&, CRTTIObject*) const;
protected:
GAME_IMPORT virtual bool ParseInitToken(char, char const*);
GAME_IMPORT virtual void ParseFlagsTokenData(char const*, uint32_t64_t);
GAME_IMPORT virtual void ParseEditorFlagsTokenData(ERTTIEditFlags&, char const*, uint32_t64_t);
public:
GAME_IMPORT virtual ttl::string_base<char> ClassWriterCompare(CRTTI const*, CRTTI const*, CRTTIField const&) const;
GAME_IMPORT CRTTIField(ClassReaderResolve const&);
GAME_IMPORT ERTTIType GetType() const;
GAME_IMPORT bool IsMessagePipeIn() const;
GAME_IMPORT bool HasIndividualSize() const;
GAME_IMPORT bool IsUuidRefFlagSet() const;
GAME_IMPORT bool IsEditable() const;
GAME_IMPORT CRTTIField();
GAME_IMPORT bool Initialize(ttl::string_const<char>, ttl::string_const<char>, unsigned char, void (* )( ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>& ));
GAME_IMPORT bool IsPStorageField() const;
GAME_IMPORT bool IsPropertyIn() const;
GAME_IMPORT bool HasStaticSize() const;
GAME_IMPORT bool IsGamescript() const;
GAME_IMPORT bool IsVirtual() const;
GAME_IMPORT char const* GetName() const;
GAME_IMPORT void GetDefaultValue(CRTTI const*, CRTTIField::Variant&) const;
GAME_IMPORT bool IsFieldInternal() const;
protected:
GAME_IMPORT void SetDefaultValueInternal(CRTTI const*, CRTTIField::Variant*);
public:
GAME_IMPORT void SetExposed(bool) const;
GAME_IMPORT bool IsProperty() const;
GAME_IMPORT bool HasDefaultValue() const;
GAME_IMPORT bool IsMessagePipe() const;
GAME_IMPORT bool IsExposed() const;
GAME_IMPORT bool IsPresetFlagSet() const;
GAME_IMPORT ttl::pstring GetSubtype() const;
GAME_IMPORT void SetExpanded(bool) const;
protected:
GAME_IMPORT void SetVirtualFlag();
GAME_IMPORT static bool EatWhiteChars(char* &);
GAME_IMPORT void SetPropertyFlag();
public:
GAME_IMPORT bool IsPipeInternal() const;
GAME_IMPORT void SetPipeInternal(bool) const;
GAME_IMPORT bool IsReplicated() const;
GAME_IMPORT void RestoreDefaultValue(CRTTI const*, CRTTIObject*);
GAME_IMPORT bool IsQuestField() const;
GAME_IMPORT void SetGamescript(bool) const;
GAME_IMPORT char const* GetPreviousName() const;
GAME_IMPORT bool IsSaveGameField() const;
GAME_IMPORT bool IsSelfUuidFlagSet() const;
protected:
GAME_IMPORT char const* ExtractClassName(CRTTI const*) const;
public:
GAME_IMPORT void SetEditable(bool) const;
GAME_IMPORT bool IsPropertyOut() const;
GAME_IMPORT bool HasDynamicSize() const;
GAME_IMPORT bool IsMessagePipeOut() const;
protected:
GAME_IMPORT void SetPrecision(int);
public:
GAME_IMPORT CRTTIField(CRTTIField const&);
GAME_IMPORT void SetPresetFlag(bool) const;
GAME_IMPORT bool CmpName(char const*) const;
GAME_IMPORT bool IsExpanded() const;
GAME_IMPORT bool HasDefaultValue(CRTTI const*) const;
GAME_IMPORT void SetSerialize(bool) const;
GAME_IMPORT bool IsSerialize() const;
#pragma endregion
};

21
EGameSDK/include/EGSDK/Engine/CRTTIMethod.h Normal file
View File

@ -0,0 +1,21 @@
#pragma once
#include <EGSDK\Imports.h>
#include <EGSDK\Engine\ClassReaderResolve.h>
class CRTTI;
class CRTTIMethod {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_11DDE0, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
GAME_IMPORT char const* GetMethodClassName() const;
GAME_IMPORT CRTTIMethod(CRTTI*, char const*);
GAME_IMPORT void DecTimeHandlerRefcount();
GAME_IMPORT CRTTIMethod(ClassReaderResolve const&);
GAME_IMPORT CRTTIMethod(CRTTIMethod const&);
GAME_IMPORT CRTTIMethod& operator=(CRTTIMethod const&);
#pragma endregion
};

168
EGameSDK/include/EGSDK/Engine/CRTTIObject.h Normal file
View File

@ -0,0 +1,168 @@
#pragma once
#include <optional>
#include <functional>
#include <EGSDK\Imports.h>
#include <EGSDK\Engine\rtti.h>
#include <EGSDK\Engine\IObject.h>
#include <EGSDK\Engine\ttl\vector_allocators\heap_allocator.h>
#include <EGSDK\Engine\ttl\allocator.h>
#include <EGSDK\Engine\ttl\list.h>
#include <EGSDK\Engine\ttl\vector.h>
#include <EGSDK\Engine\ttl\set.h>
#include <EGSDK\Engine\ttl\less.h>
#include <EGSDK\Engine\Uid.h>
class IGSObject;
class MED {
public:
struct SModelOutfitGroup;
};
class CRTTIObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static rtti::Type& m_RTTI;
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
VIRTUAL_CALL(0, void, SetPlatform, ());
VIRTUAL_CALL(1, IObject*, sub_11DE70, (char a1), a1);
GAME_IMPORT virtual CRTTI const* GetRTTI() const;
VIRTUAL_CALL(3, CRTTI const*, _GetRTTI1, ());
VIRTUAL_CALL(4, MED::SModelOutfitGroup const*, unassigned, ());
VIRTUAL_CALL(5, MED::SModelOutfitGroup const*, _unassigned1, ());
VIRTUAL_CALL(6, MED::SModelOutfitGroup const*, _unassigned2, ());
VIRTUAL_CALL(7, MED::SModelOutfitGroup const*, _unassigned3, ());
VIRTUAL_CALL(8, int64_t, RunUnitTests, ());
VIRTUAL_CALL(9, int64_t, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(ttl::list<IGSObject*, ttl::allocator>*, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, int64_t, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(ttl::vector<IGSObject*, ttl::vector_allocators::heap_allocator<IGSObject*>, 1>&, bool);
GAME_IMPORT virtual void GetAllObjects(ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, bool, std::optional<ttl::function_ref<bool ( CRTTIObject* )>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void, _SetPlatform1, ());
GAME_IMPORT virtual char const* GetString(char const*) const;
VIRTUAL_CALL(18, void, _SetPlatform2, ());
VIRTUAL_CALL(19, static bool, ValidateVec4, (IGSObject const*, vec4 const&), const*, const&);
VIRTUAL_CALL(20, void, _SetPlatform3, ());
VIRTUAL_CALL(21, MED::SModelOutfitGroup const*, _unassigned4, ());
VIRTUAL_CALL(22, void, _SetPlatform4, ());
GAME_IMPORT virtual Uid const& GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams1, ());
VIRTUAL_CALL(25, bool, _updateRttiParams2, ());
VIRTUAL_CALL(26, bool, _updateRttiParams3, ());
VIRTUAL_CALL(27, bool, _updateRttiParams4, ());
VIRTUAL_CALL(28, bool, _updateRttiParams5, ());
VIRTUAL_CALL(29, bool, _updateRttiParams6, ());
VIRTUAL_CALL(30, bool, _updateRttiParams7, ());
VIRTUAL_CALL(31, bool, _updateRttiParams8, ());
VIRTUAL_CALL(32, bool, _updateRttiParams9, ());
GAME_IMPORT virtual void CallVoidMethod(char const*, ...);
GAME_IMPORT virtual cbs::msg::IMessagePipeSet const& GetMessagePipeSet() const;
VIRTUAL_CALL(35, int64_t, _RunUnitTests3, ());
VIRTUAL_CALL(36, MED::SModelOutfitGroup const*, _unassigned5, ());
VIRTUAL_CALL(37, MED::SModelOutfitGroup const*, _unassigned6, ());
VIRTUAL_CALL(38, MED::SModelOutfitGroup const*, _unassigned7, ());
VIRTUAL_CALL(39, MED::SModelOutfitGroup const*, _unassigned8, ());
GAME_IMPORT virtual cbs::prop::IPropertySet const& GetPropertySet() const;
VIRTUAL_CALL(41, void, _SetPlatform5, ());
VIRTUAL_CALL(42, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(CRTTIField const*, unsigned char, fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(dom::IReader::Object const&, IPtrResolver&, bool, bool (* )(char const*, CRTTIObject* ));
GAME_IMPORT virtual void LoadFields(ITextDeserializer&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void SaveFields(dom::IWriter&, ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char*, int);
GAME_IMPORT virtual int FromBufferReplicated(char*, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void, _SetPlatform6, ());
VIRTUAL_CALL(52, static bool, _ValidateVec41, (IGSObject const* a1, vec4 const& a2), a1, a2);
GAME_IMPORT virtual bool CopyFields(CRTTIObject const*, bool);
GAME_IMPORT virtual bool CopyPointerFields(CRTTIObject const*);
GAME_IMPORT virtual bool ExchangePointerFields(CRTTIObject*);
VIRTUAL_CALL(56, int64_t, _RunUnitTests5, ());
VIRTUAL_CALL(57, int64_t, _RunUnitTests6, ());
VIRTUAL_CALL(58, int64_t, _RunUnitTests7, ());
GAME_IMPORT virtual SRttiNetPointer GetNetPointer() const;
VIRTUAL_CALL(60, int64_t, _RunUnitTests8, ());
GAME_IMPORT virtual ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(SObjectMemoryUsage&) const;
VIRTUAL_CALL(63, void, _SetPlatform7, ());
GAME_IMPORT virtual bool GetValidFieldValuesEditor(CRTTIField const&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&);
VIRTUAL_CALL(65, bool, _updateRttiParams10, ());
VIRTUAL_CALL(66, static bool, _ValidateVec42, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, int64_t, _RunUnitTests9, ());
GAME_IMPORT virtual ttl::string_base<char> ValueToString(CRTTIObject* const&) const;
GAME_IMPORT virtual bool IsFieldChanged(CRTTIField const*) const;
GAME_IMPORT virtual void SetFieldChangedFlag(CRTTIField const*, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams11, ());
GAME_IMPORT virtual bool OnFieldChanged2(CRTTIField const*, bool);
VIRTUAL_CALL(73, void, _SetPlatform8, ());
VIRTUAL_CALL(74, int64_t, _RunUnitTests10, ());
VIRTUAL_CALL(75, void, _SetPlatform9, ());
VIRTUAL_CALL(76, bool, _updateRttiParams12, ());
protected:
GAME_IMPORT virtual bool OnFieldChanged(CRTTIField const*, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams13, ());
VIRTUAL_CALL(79, bool, _updateRttiParams14, ());
VIRTUAL_CALL(80, int64_t, _RunUnitTests11, ());
VIRTUAL_CALL(81, int64_t, _RunUnitTests12, ());
VIRTUAL_CALL(82, void, _SetPlatform10, ());
GAME_IMPORT virtual void Query(IBaseValidator&, ttl::vector<CRTTIObject*, ttl::vector_allocators::heap_allocator<CRTTIObject*>, 1>&) const;
GAME_IMPORT bool FromEngineClass(CRTTI const*) const;
private:
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
public:
GAME_IMPORT CRTTIField const* FindFieldDynamic(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT bool FromClassByName(char const*) const;
GAME_IMPORT CRTTIFieldEmbeddedObject const* SetFieldEmbeddedObject(ttl::string_const<char>, CEmbeddedObject* const&);
GAME_IMPORT bool FromClassOrInterfaceByName(char const*) const;
GAME_IMPORT CRTTIMethod const* FindMethod(char const*) const;
GAME_IMPORT CRTTIFieldTyped<unsigned short> const* SetFieldUShort(ttl::string_const<char>, unsigned short);
GAME_IMPORT CRTTIFieldTyped<float> const* SetFieldFloat(ttl::string_const<char>, float);
GAME_IMPORT bool FromClassOrInterface(int) const;
GAME_IMPORT bool FromClass(rtti::Type const*) const;
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT CRTTIFieldTyped<unsigned char> const* SetFieldUChar(ttl::string_const<char>, unsigned char);
GAME_IMPORT bool IsExactClass(rtti::Type const*) const;
GAME_IMPORT bool FromEngineClass(int) const;
GAME_IMPORT bool FromClass(int) const;
GAME_IMPORT void GetLocalFields(ttl::vector<CRTTIField const*, ttl::vector_allocators::heap_allocator<CRTTIField const*>, 64>&) const;
GAME_IMPORT static CRTTIObject* LoadObjectHierarchy(fs::ifile&, bool, cbs::WorldIndex);
GAME_IMPORT CRTTIFieldTyped<vec4> const* GetFieldVec4(ttl::string_const<char>, vec4&) const;
GAME_IMPORT bool FromEngineClass(rtti::Type const&) const;
GAME_IMPORT CRTTIFieldVectorTyped<vec4> const* GetFieldVec4Vector(ttl::string_const<char>, ttl::vector<vec4, ttl::vector_allocators::heap_allocator<vec4>, 0>&) const;
private:
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
public:
GAME_IMPORT CRTTIFieldTyped<vec4> const* SetFieldVec4(ttl::string_const<char>, vec4 const&);
GAME_IMPORT static rtti::Type& typeinfo();
GAME_IMPORT static CRTTIObject* LoadObjectHierarchy(ITextDeserializer&, bool, cbs::WorldIndex);
GAME_IMPORT bool FromClassOrInterface(rtti::Type const*) const;
GAME_IMPORT static CRTTINative<CRTTIObject>* GetSTTI();
GAME_IMPORT CRTTIField const* FindField(char const*) const;
GAME_IMPORT bool FromClass(CRTTI const*) const;
GAME_IMPORT bool IsExactEngineClass(int) const;
GAME_IMPORT CRTTIFieldVectorTyped<vec4> const* SetFieldVec4Vector(ttl::string_const<char>, ttl::vector<vec4, ttl::vector_allocators::heap_allocator<vec4>, 0> const&);
GAME_IMPORT char const* GetClassNameA() const;
GAME_IMPORT bool IsExactClass(CRTTI const*) const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT bool IsExactClass(int) const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(char const*) const;
GAME_IMPORT bool IsExactClassByName(char const*) const;
GAME_IMPORT CRTTIObject();
GAME_IMPORT CRTTIFieldString const* SetFieldString(ttl::string_const<char>, ttl::string_const<char>);
GAME_IMPORT void GetAllLocalFields(ttl::vector<CRTTIField const*, ttl::vector_allocators::heap_allocator<CRTTIField const*>, 64>&) const;
GAME_IMPORT CRTTIField const* FindField(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT CRTTIField const* FindFieldDynamic(char const*) const;
GAME_IMPORT static void RegisterValidator(IBaseValidator&, CRTTI const&);
GAME_IMPORT CRTTIFieldTyped<uint32_t> const* SetFieldUInt(ttl::string_const<char>, uint32_t);
GAME_IMPORT ttl::temp_string_base<char, 240> GetClassNameWithoutNamespace() const;
GAME_IMPORT bool FromClassOrInterface(CRTTI const*) const;
GAME_IMPORT CEmbeddedObject* CreateRawEmbeddedObject(CRTTI const*, char const*, CRTTIObject*, CRTTIField const*) const;
#pragma endregion
};

2
EGameSDK/include/EGSDK/Engine/ClassReaderResolve.h Normal file
View File

@ -0,0 +1,2 @@
#pragma once
class ClassReaderResolve;

6
EGameSDK/include/EGSDK/Engine/EMem.h Normal file
View File

@ -0,0 +1,6 @@
#pragma once
#include <EGSDK\Imports.h>
namespace EMem {
enum TYPE;
}

2
EGameSDK/include/EGSDK/Engine/ERTTIClassFlags.h Normal file
View File

@ -0,0 +1,2 @@
#pragma once
enum ERTTIClassFlags;

110
EGameSDK/include/EGSDK/Engine/IClassWriter.h Normal file
View File

@ -0,0 +1,110 @@
#pragma once
#include <EGSDK\Imports.h>
class IClassWriter {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_FDA280, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
virtual void _StrippedVFunc4() = 0;
virtual void _StrippedVFunc5() = 0;
virtual void _StrippedVFunc6() = 0;
virtual void _StrippedVFunc7() = 0;
virtual void _StrippedVFunc8() = 0;
virtual void _StrippedVFunc9() = 0;
virtual void _StrippedVFunc10() = 0;
virtual void _StrippedVFunc11() = 0;
virtual void _StrippedVFunc12() = 0;
virtual void _StrippedVFunc13() = 0;
virtual void _StrippedVFunc14() = 0;
virtual void _StrippedVFunc15() = 0;
virtual void _StrippedVFunc16() = 0;
virtual void _StrippedVFunc17() = 0;
virtual void _StrippedVFunc18() = 0;
virtual void _StrippedVFunc19() = 0;
virtual void _StrippedVFunc20() = 0;
virtual void _StrippedVFunc21() = 0;
virtual void _StrippedVFunc22() = 0;
virtual void _StrippedVFunc23() = 0;
virtual void _StrippedVFunc24() = 0;
virtual void _StrippedVFunc25() = 0;
virtual void _StrippedVFunc26() = 0;
virtual void _StrippedVFunc27() = 0;
virtual void _StrippedVFunc28() = 0;
virtual void _StrippedVFunc29() = 0;
virtual void _StrippedVFunc30() = 0;
virtual void _StrippedVFunc31() = 0;
virtual void _StrippedVFunc32() = 0;
virtual void _StrippedVFunc33() = 0;
virtual void _StrippedVFunc34() = 0;
virtual void _StrippedVFunc35() = 0;
virtual void _StrippedVFunc36() = 0;
virtual void _StrippedVFunc37() = 0;
virtual void _StrippedVFunc38() = 0;
virtual void _StrippedVFunc39() = 0;
virtual void _StrippedVFunc40() = 0;
virtual void _StrippedVFunc41() = 0;
virtual void _StrippedVFunc42() = 0;
virtual void _StrippedVFunc43() = 0;
virtual void _StrippedVFunc44() = 0;
virtual void _StrippedVFunc45() = 0;
virtual void _StrippedVFunc46() = 0;
virtual void _StrippedVFunc47() = 0;
virtual void _StrippedVFunc48() = 0;
virtual void _StrippedVFunc49() = 0;
virtual void _StrippedVFunc50() = 0;
virtual void _StrippedVFunc51() = 0;
virtual void _StrippedVFunc52() = 0;
virtual void _StrippedVFunc53() = 0;
virtual void _StrippedVFunc54() = 0;
virtual void _StrippedVFunc55() = 0;
virtual void _StrippedVFunc56() = 0;
virtual void _StrippedVFunc57() = 0;
virtual void _StrippedVFunc58() = 0;
virtual void _StrippedVFunc59() = 0;
virtual void _StrippedVFunc60() = 0;
virtual void _StrippedVFunc61() = 0;
virtual void _StrippedVFunc62() = 0;
virtual void _StrippedVFunc63() = 0;
virtual void _StrippedVFunc64() = 0;
virtual void _StrippedVFunc65() = 0;
virtual void _StrippedVFunc66() = 0;
virtual void _StrippedVFunc67() = 0;
virtual void _StrippedVFunc68() = 0;
virtual void _StrippedVFunc69() = 0;
virtual void _StrippedVFunc70() = 0;
virtual void _StrippedVFunc71() = 0;
virtual void _StrippedVFunc72() = 0;
virtual void _StrippedVFunc73() = 0;
virtual void _StrippedVFunc74() = 0;
virtual void _StrippedVFunc75() = 0;
virtual void _StrippedVFunc76() = 0;
virtual void _StrippedVFunc77() = 0;
virtual void _StrippedVFunc78() = 0;
virtual void _StrippedVFunc79() = 0;
virtual void _StrippedVFunc80() = 0;
virtual void _StrippedVFunc81() = 0;
virtual void _StrippedVFunc82() = 0;
virtual void _StrippedVFunc83() = 0;
virtual void _StrippedVFunc84() = 0;
virtual void _StrippedVFunc85() = 0;
virtual void _StrippedVFunc86() = 0;
virtual void _StrippedVFunc87() = 0;
virtual void _StrippedVFunc88() = 0;
virtual void _StrippedVFunc89() = 0;
virtual void _StrippedVFunc90() = 0;
virtual void _StrippedVFunc91() = 0;
virtual void _StrippedVFunc92() = 0;
virtual void _StrippedVFunc93() = 0;
virtual void _StrippedVFunc94() = 0;
virtual void _StrippedVFunc95() = 0;
virtual void _StrippedVFunc96() = 0;
virtual void _StrippedVFunc97() = 0;
virtual void _StrippedVFunc98() = 0;
virtual void _StrippedVFunc99() = 0;
virtual void _StrippedVFunc100() = 0;
virtual void _StrippedVFunc101() = 0;
#pragma endregion
};

356
EGameSDK/include/EGSDK/Engine/IGSObject.h Normal file
View File

@ -0,0 +1,356 @@
#pragma once
#include <optional>
#include <EGSDK\Imports.h>
#include <EGSDK\Engine\rtti.h>
#include <EGSDK\Engine\IClassWriter.h>
#include <EGSDK\Engine\ttl\vector_allocators\heap_allocator.h>
#include <EGSDK\Engine\ttl\vector.h>
#include <EGSDK\Engine\ttl\set.h>
#include <EGSDK\Engine\ttl\less.h>
#include <EGSDK\Engine\ttl\list.h>
#include <EGSDK\Engine\ttl\allocator.h>
#include <EGSDK\Engine\ttl\function_ref.h>
#include <EGSDK\Engine\Uid.h>
#include <EGSDK\Engine\IPtrResolver.h>
#include <EGSDK\Engine\ClassReaderResolve.h>
#include <EGSDK\vec3.h>
#include <EGSDK\vec4.h>
class MED {
public:
class SModelOutfitGroup;
};
class cbs {
public:
class prop {
public:
class IPropertySet;
};
class msg {
public:
class IMessagePipeSet;
};
};
class CRTTIObject;
class IGSObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
GAME_IMPORT static rtti::Type& m_RTTI;
GAME_IMPORT virtual void ClassWriterSave(IClassWriter*, bool) const;
VIRTUAL_CALL(1, IGSObject*, sub_11FF80, (char a1), a1);
VIRTUAL_CALL(2, static CRTTIGameScript<IGSObject>*, GetSTTI, ());
GAME_IMPORT virtual CRTTI const* GetEngineRTTI() const;
protected:
VIRTUAL_CALL(4, gui::CPackage*, ToCPackage, ());
public:
VIRTUAL_CALL(5, gui::CPackage*, _ToCPackage1, ());
VIRTUAL_CALL(6, MED::SModelOutfitGroup const*, unassigned, ());
VIRTUAL_CALL(7, MED::SModelOutfitGroup const*, _unassigned1, ());
VIRTUAL_CALL(8, int64_t, RunUnitTests, ());
VIRTUAL_CALL(9, int64_t, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(ttl::list<IGSObject*, ttl::allocator>*, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, int64_t, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(ttl::vector<IGSObject*, ttl::vector_allocators::heap_allocator<IGSObject*>, 1>&, bool);
GAME_IMPORT virtual void GetAllObjects(ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, bool, std::optional<ttl::function_ref<bool ( CRTTIObject* )>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void, SetPlatform, ());
GAME_IMPORT virtual char const* GetString(char const*) const;
VIRTUAL_CALL(18, void, _SetPlatform1, ());
VIRTUAL_CALL(19, static bool, ValidateVec4, (IGSObject const*, vec4 const&), const*, const&);
VIRTUAL_CALL(20, void, _SetPlatform2, ());
VIRTUAL_CALL(21, MED::SModelOutfitGroup const*, _unassigned2, ());
VIRTUAL_CALL(22, void, _SetPlatform3, ());
GAME_IMPORT virtual Uid const& GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams1, ());
VIRTUAL_CALL(25, bool, _updateRttiParams2, ());
VIRTUAL_CALL(26, bool, _updateRttiParams3, ());
VIRTUAL_CALL(27, bool, _updateRttiParams4, ());
VIRTUAL_CALL(28, bool, _updateRttiParams5, ());
VIRTUAL_CALL(29, bool, _updateRttiParams6, ());
VIRTUAL_CALL(30, bool, _updateRttiParams7, ());
VIRTUAL_CALL(31, bool, _updateRttiParams8, ());
VIRTUAL_CALL(32, bool, _updateRttiParams9, ());
GAME_IMPORT virtual void CallVoidMethod(char const*, ...);
GAME_IMPORT virtual cbs::msg::IMessagePipeSet const& GetMessagePipeSet() const;
VIRTUAL_CALL(35, int64_t, _RunUnitTests3, ());
VIRTUAL_CALL(36, MED::SModelOutfitGroup const*, _unassigned3, ());
VIRTUAL_CALL(37, MED::SModelOutfitGroup const*, _unassigned4, ());
VIRTUAL_CALL(38, MED::SModelOutfitGroup const*, _unassigned5, ());
VIRTUAL_CALL(39, MED::SModelOutfitGroup const*, _unassigned6, ());
GAME_IMPORT virtual cbs::prop::IPropertySet const& GetPropertySet() const;
VIRTUAL_CALL(41, void, _SetPlatform4, ());
VIRTUAL_CALL(42, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(CRTTIField const*, unsigned char, fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(dom::IReader::Object const&, IPtrResolver&, bool, bool (* )(char const*, CRTTIObject* ));
GAME_IMPORT virtual void LoadFields(ITextDeserializer&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void SaveFields(dom::IWriter&, ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char*, int);
GAME_IMPORT virtual int FromBufferReplicated(char*, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void, _SetPlatform5, ());
VIRTUAL_CALL(52, static bool, _ValidateVec41, (IGSObject const* a1, vec4 const& a2), a1, a2);
GAME_IMPORT virtual bool CopyFields(CRTTIObject const*, bool);
GAME_IMPORT virtual bool CopyPointerFields(CRTTIObject const*);
GAME_IMPORT virtual bool ExchangePointerFields(CRTTIObject*);
GAME_IMPORT virtual IGSObject* FindObjectByID(int) const;
GAME_IMPORT virtual IGSObject* FindObjectByNetPointer(SRttiNetPointer const&) const;
GAME_IMPORT virtual cbs::CEntity* FindEntityByNetPointer(SRttiNetPointer const&) const;
GAME_IMPORT virtual SRttiNetPointer GetNetPointer() const;
VIRTUAL_CALL(60, int64_t, _RunUnitTests5, ());
GAME_IMPORT virtual ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(SObjectMemoryUsage&) const;
VIRTUAL_CALL(63, void, _SetPlatform6, ());
VIRTUAL_CALL(64, bool, _updateRttiParams10, ());
VIRTUAL_CALL(65, bool, _updateRttiParams11, ());
VIRTUAL_CALL(66, static bool, _ValidateVec42, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, int64_t, _RunUnitTests6, ());
GAME_IMPORT virtual ttl::string_base<char> ValueToString(CRTTIObject* const&) const;
GAME_IMPORT virtual bool IsFieldChanged(CRTTIField const*) const;
GAME_IMPORT virtual void SetFieldChangedFlag(CRTTIField const*, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams12, ());
GAME_IMPORT virtual bool OnFieldChanged2(CRTTIField const*, bool);
VIRTUAL_CALL(73, void, _SetPlatform7, ());
GAME_IMPORT virtual char const* GetPresetsData() const;
VIRTUAL_CALL(75, void, _SetPlatform8, ());
VIRTUAL_CALL(76, bool, _updateRttiParams13, ());
private:
GAME_IMPORT virtual bool OnFieldChanged(CRTTIField const*, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams14, ());
VIRTUAL_CALL(79, bool, _updateRttiParams15, ());
VIRTUAL_CALL(80, int64_t, _RunUnitTests7, ());
VIRTUAL_CALL(81, int64_t, _RunUnitTests8, ());
VIRTUAL_CALL(82, void, _SetPlatform9, ());
GAME_IMPORT virtual void Query(IBaseValidator&, ttl::vector<CRTTIObject*, ttl::vector_allocators::heap_allocator<CRTTIObject*>, 1>&) const;
protected:
GAME_IMPORT virtual void SetEngineObject(CGSObject*);
public:
VIRTUAL_CALL(85, MED::SModelOutfitGroup const*, _unassigned7, ());
VIRTUAL_CALL(86, MED::SModelOutfitGroup const*, _unassigned8, ());
VIRTUAL_CALL(87, int64_t, _RunUnitTests9, ());
VIRTUAL_CALL(88, int64_t, _RunUnitTests10, ());
VIRTUAL_CALL(89, int64_t, _RunUnitTests11, ());
VIRTUAL_CALL(90, int64_t, _RunUnitTests12, ());
VIRTUAL_CALL(91, int64_t, _RunUnitTests13, ());
VIRTUAL_CALL(92, int64_t, _RunUnitTests14, ());
VIRTUAL_CALL(93, int64_t, _RunUnitTests15, ());
VIRTUAL_CALL(94, int64_t, _RunUnitTests16, ());
VIRTUAL_CALL(95, void, _SetPlatform10, ());
GAME_IMPORT virtual ttl::string_base<char> toString() const;
VIRTUAL_CALL(97, void, _SetPlatform11, ());
VIRTUAL_CALL(98, void, _SetPlatform12, ());
VIRTUAL_CALL(99, bool, _updateRttiParams16, ());
VIRTUAL_CALL(100, void, _SetPlatform13, ());
VIRTUAL_CALL(101, void, _SetPlatform14, ());
VIRTUAL_CALL(102, void, _SetPlatform15, ());
VIRTUAL_CALL(103, void, _SetPlatform16, ());
VIRTUAL_CALL(104, void, _SetPlatform17, ());
VIRTUAL_CALL(105, void, _SetPlatform18, ());
VIRTUAL_CALL(106, void, _SetPlatform19, ());
private:
VIRTUAL_CALL(107, void, UnregisterInTimeHandlerManager, ());
public:
VIRTUAL_CALL(108, void, _UnregisterInTimeHandlerManager1, ());
VIRTUAL_CALL(109, void, _SetPlatform20, ());
VIRTUAL_CALL(110, void, _SetPlatform21, ());
VIRTUAL_CALL(111, void, _SetPlatform22, ());
VIRTUAL_CALL(112, void, _SetPlatform23, ());
VIRTUAL_CALL(113, void, _SetPlatform24, ());
VIRTUAL_CALL(114, void, _SetPlatform25, ());
VIRTUAL_CALL(115, void, _SetPlatform26, ());
VIRTUAL_CALL(116, void, _SetPlatform27, ());
VIRTUAL_CALL(117, void, _SetPlatform28, ());
VIRTUAL_CALL(118, void, _SetPlatform29, ());
VIRTUAL_CALL(119, void, _SetPlatform30, ());
VIRTUAL_CALL(120, void, _SetPlatform31, ());
GAME_IMPORT virtual void OnActivateOnModule();
VIRTUAL_CALL(122, void, _SetPlatform32, ());
VIRTUAL_CALL(123, void, _SetPlatform33, ());
VIRTUAL_CALL(124, void, _SetPlatform34, ());
VIRTUAL_CALL(125, void, _SetPlatform35, ());
VIRTUAL_CALL(126, void, _SetPlatform36, ());
VIRTUAL_CALL(127, void, _SetPlatform37, ());
VIRTUAL_CALL(128, void, _SetPlatform38, ());
VIRTUAL_CALL(129, void, _SetPlatform39, ());
VIRTUAL_CALL(130, void, _SetPlatform40, ());
VIRTUAL_CALL(131, void, _SetPlatform41, ());
VIRTUAL_CALL(132, void, _SetPlatform42, ());
VIRTUAL_CALL(133, void, _SetPlatform43, ());
VIRTUAL_CALL(134, void, _SetPlatform44, ());
VIRTUAL_CALL(135, void, _SetPlatform45, ());
VIRTUAL_CALL(136, void, _SetPlatform46, ());
VIRTUAL_CALL(137, void, _SetPlatform47, ());
VIRTUAL_CALL(138, void, _SetPlatform48, ());
VIRTUAL_CALL(139, void, _SetPlatform49, ());
VIRTUAL_CALL(140, bool, _updateRttiParams17, ());
GAME_IMPORT virtual void SetHiddenByLogicEditor(bool);
VIRTUAL_CALL(142, void, _SetPlatform50, ());
VIRTUAL_CALL(143, static bool, _ValidateVec43, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(144, static bool, _ValidateVec44, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(145, static bool, _ValidateVec45, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(146, static bool, _ValidateVec46, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(147, static bool, _ValidateVec47, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(148, static bool, _ValidateVec48, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(149, static bool, _ValidateVec49, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(150, static bool, _ValidateVec410, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(151, static bool, _ValidateVec411, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(152, static bool, _ValidateVec412, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(153, static bool, _ValidateVec413, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(154, static bool, _ValidateVec414, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(155, static bool, _ValidateVec415, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(156, static bool, _ValidateVec416, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(157, static bool, _ValidateVec417, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(158, static bool, _ValidateVec418, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(159, static bool, _ValidateVec419, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(160, static bool, _ValidateVec420, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(161, static bool, _ValidateVec421, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(162, static bool, _ValidateVec422, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(163, static bool, _ValidateVec423, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(164, static bool, _ValidateVec424, (IGSObject const* a1, vec4 const& a2), a1, a2);
GAME_IMPORT virtual void SetSerializable(bool);
VIRTUAL_CALL(166, void, _SetPlatform51, ());
VIRTUAL_CALL(167, bool, _updateRttiParams18, ());
VIRTUAL_CALL(168, bool, _updateRttiParams19, ());
GAME_IMPORT virtual void DeactivateOnModule();
VIRTUAL_CALL(170, void, _SetPlatform52, ());
VIRTUAL_CALL(171, ttl::list<SCommandParam, ttl::allocator>::const_reverse_iterator, rend, ());
VIRTUAL_CALL(172, void, _SetPlatform53, ());
GAME_IMPORT virtual bool ISharedObject_IsValid() const;
GAME_IMPORT virtual float GetTime() const;
GAME_IMPORT virtual float GetLastTime() const;
GAME_IMPORT virtual float GetTimeDelta() const;
GAME_IMPORT virtual int64_t GetTimeDeltaMiliseconds() const;
GAME_IMPORT void DisableOnFrameEditorHandler();
GAME_IMPORT void EnableOnPostUpdateEditorHandler();
GAME_IMPORT void CallMethodEvery(CRTTIVoidMethod const*, float, float) const;
GAME_IMPORT ttl::string_const<char> GetPresetsDataStr() const;
GAME_IMPORT float ReplGetRelevance(unsigned short) const;
GAME_IMPORT IGSObject* CreateObjectWithID(rtti::Type const&, int, bool, ttl::string_base<char> const*);
GAME_IMPORT IGpuFx_Manager* GetGpuFxManager();
GAME_IMPORT virtual void OnKeyboardClosed(ttl::string_base<wchar_t>);
GAME_IMPORT uint32_t EditorGetAttributeMarkedToSaveCount() const;
GAME_IMPORT bool ReplIsOwner() const;
GAME_IMPORT bool ReplIsReplicated() const;
GAME_IMPORT void CallMethodIn(CRTTIVoidMethod const*, float) const;
GAME_IMPORT bool EditorIsSelected() const;
GAME_IMPORT bool ReplIsReplicable() const;
GAME_IMPORT ttl::string_base<char> ReplGetRequestingString() const;
GAME_IMPORT void EnableOnFrameHandler(EFrameHandlerPriority::TYPE, bool);
GAME_IMPORT bool IsActiveOnModule() const;
GAME_IMPORT void DisableOnPostAnimUpdateHandler();
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT void SetGSOFlags(uint32_t64_t);
GAME_IMPORT void SetComment(ttl::string_base<wchar_t> const&);
GAME_IMPORT void EnableOnPostUpdateHandler(EFrameHandlerPriority::TYPE, bool);
GAME_IMPORT ILevel* GetLevel() const;
GAME_IMPORT void MakePrivate(IGSObject*);
GAME_IMPORT void SetLevel(CLevel*, bool);
GAME_IMPORT void SetAndProcessPresets(ttl::string_base<char> const&);
GAME_IMPORT EMem::TYPE GetMemCategory();
private:
GAME_IMPORT void ActivateOnModuleInternal();
public:
GAME_IMPORT char const* GetNameCStr() const;
GAME_IMPORT IGSObject* CreateObjectWithID(CRTTI const&, int, bool, ttl::string_base<char> const*);
GAME_IMPORT void DisableOnPostAnimatorUpdateHandler();
GAME_IMPORT int GetLocalClientId() const;
GAME_IMPORT float ReplGetRelevance() const;
GAME_IMPORT void ProcessPresets(PresetId);
GAME_IMPORT void SetName(ttl::string_base<char> const&);
GAME_IMPORT ttl::string_base<char> const GetNameAndClass() const;
GAME_IMPORT IGSObject* CreateObject(EEntityRootType::TYPE, CRTTI const&, std::optional<Replication::CreateObjectOptions>, bool, ttl::string_base<char> const*);
GAME_IMPORT void AcquireObjectModule(IGSObject*);
GAME_IMPORT void RequestOwnership();
GAME_IMPORT bool IsCreating() const;
GAME_IMPORT ttl::string_base<char> GetName() const;
GAME_IMPORT void DisableCallMethod(CRTTIVoidMethod const*) const;
GAME_IMPORT void MultiRaytest(unsigned char, vec3 const&, ttl::vector<vec3, ttl::vector_allocators::heap_allocator<vec3>, 0> const&, ttl::vector<bool, ttl::vector_allocators::heap_allocator<bool>, 8>&, unsigned short, bool, IControlObject*, cbs::CEntity*, uint32_t, unsigned short, int64_t);
GAME_IMPORT wchar_t const* GetComment() const;
private:
GAME_IMPORT void DeactivateOnModuleInternal();
public:
GAME_IMPORT unsigned char ReplGetObjectIdx() const;
GAME_IMPORT IGSObject(IGSObject const&);
GAME_IMPORT void EnableOnPostAnimatorUpdateHandler();
GAME_IMPORT void ReplSetLocalReplicationInterval(float, float);
GAME_IMPORT void EditorRemoveAtCompilation(bool);
GAME_IMPORT bool IsLevelShutdown();
GAME_IMPORT void EnableOnPostAnimUpdateHandler();
GAME_IMPORT uint64_t GetGSOFlags() const;
GAME_IMPORT CRTTIField const* EditorGetAttributeMarkedToSave(uint32_t) const;
GAME_IMPORT void EditorMarkAttributeToSave(ttl::string_base<char> const&);
GAME_IMPORT void FinalizeReplicationObject();
protected:
GAME_IMPORT IGSObject();
public:
GAME_IMPORT void InitializeReplicationObject(Replication::CreateObjectOptions);
GAME_IMPORT void EnableOnPreAnimUpdateHandler();
GAME_IMPORT void ReplSetRelevance(float);
GAME_IMPORT IGSObject* GetPrivateOwner();
GAME_IMPORT IGSObject& operator=(IGSObject const&);
GAME_IMPORT void PreDestroy();
private:
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
public:
GAME_IMPORT unsigned char Raytrace(unsigned char, SCollision*, vec3 const&, vec3&, unsigned short, bool, IControlObject*, uint32_t, unsigned short, int64_t, ttl::span<cbs::CEntity const*, 4294967295>);
GAME_IMPORT IGSObject(ClassReaderResolve const&);
GAME_IMPORT bool ReplIsAuthoritative() const;
GAME_IMPORT void DisableOnPostUpdateEditorHandler();
GAME_IMPORT Net::Repl::CObjectId ReplGetId() const;
GAME_IMPORT uint32_t PlayAudioEvent(ttl::string_base<char> const&, Audio::SAudioEventExtraData const*, vec3 const&);
GAME_IMPORT bool EditorIsRemoveAtCompilationSet();
GAME_IMPORT bool ReplIsBlockChangeOwnership() const;
GAME_IMPORT PresetId GetPresetsId() const;
GAME_IMPORT void ProcessPresets(ttl::string_base<char> const&);
GAME_IMPORT Replication::IObject const& ReplicationObject() const;
GAME_IMPORT ttl::string_base<char> ReplGetAuthoritativeString() const;
GAME_IMPORT void SetIGSOFlags(uint64_t);
private:
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
public:
GAME_IMPORT void DisableOnPreAnimUpdateHandler();
GAME_IMPORT unsigned short ReplGetOwnerId() const;
GAME_IMPORT void ActivateOnModule();
GAME_IMPORT static rtti::Type& typeinfo();
GAME_IMPORT IGSObject* CreateObjectWithGuid(rtti::Type const&, uint64_t, bool, ttl::string_base<char> const*);
GAME_IMPORT void ReplBlockChangeOwnership(bool);
GAME_IMPORT void ReplSendNow();
GAME_IMPORT void ReplSetRelevance(unsigned short, float);
GAME_IMPORT bool Raytest(unsigned char, vec3 const&, vec3 const&, unsigned short, bool, IControlObject*, uint32_t, unsigned short, int64_t, ttl::span<cbs::CEntity const*, 4294967295>);
GAME_IMPORT void DeleteThis();
GAME_IMPORT bool EditorIsNeverStatic() const;
GAME_IMPORT void DisableOnPostUpdateHandler();
GAME_IMPORT void ClearGSOFlags(uint64_t);
GAME_IMPORT void DisableOnFrameHandler();
GAME_IMPORT unsigned short ReplGetAuthoritativeId() const;
GAME_IMPORT void SetReplicationRelevance(float);
GAME_IMPORT void InitObject(IGSObject*);
GAME_IMPORT IGSObject* CreateObject(EEntityRootType::TYPE, CRTTI const&, bool, ttl::string_base<char> const*, bool);
GAME_IMPORT void ClearIGSOFlags(uint64_t);
GAME_IMPORT static void RegisterSTTI(CRTTI*);
GAME_IMPORT void EnableOnFrameEditorHandler();
GAME_IMPORT bool ReplIsOwnerNoLocal() const;
GAME_IMPORT IGSObject* GetNext() const;
GAME_IMPORT IGSObject* CreateObjectWithGuid(CRTTI const&, uint64_t, bool, ttl::string_base<char> const*);
GAME_IMPORT bool IsDestroying() const;
GAME_IMPORT bool IsCreated() const;
GAME_IMPORT int GetNetOwnerID() const;
GAME_IMPORT bool IsPrivate() const;
GAME_IMPORT bool GetNetIsUniqueOwner() const;
GAME_IMPORT int GetID() const;
GAME_IMPORT void SetAndProcessPresets(PresetId);
GAME_IMPORT bool IsDestroyed() const;
GAME_IMPORT void SetIsReplicationEnabled(bool);
#pragma endregion
};

2
EGameSDK/include/EGSDK/Engine/IMaterial.h Normal file
View File

@ -0,0 +1,2 @@
#pragma once
class IMaterial;

12
EGameSDK/include/EGSDK/Engine/IObject.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include <EGSDK\Imports.h>
class IObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, void, SetPlatform, ());
VIRTUAL_CALL(1, IObject*, sub_11DE70, (char a1), a1);
GAME_IMPORT IObject();
#pragma endregion
};

16
EGameSDK/include/EGSDK/Engine/IPtrResolver.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <EGSDK\Imports.h>
class IPtrResolver {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_C5AF60, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
VIRTUAL_CALL(3, int64_t, RunUnitTests, ());
VIRTUAL_CALL(4, void, SetPlatform, ());
VIRTUAL_CALL(5, int64_t, _RunUnitTests1, ());
VIRTUAL_CALL(6, int64_t, _RunUnitTests2, ());
VIRTUAL_CALL(7, void, _SetPlatform1, ());
#pragma endregion
};

3
EGameSDK/include/EGSDK/Engine/IRTTIEnumerationTyped.h Normal file
View File

@ -0,0 +1,3 @@
#pragma once
template<typename T>
class IRTTIEnumerationTyped;

24
EGameSDK/include/EGSDK/Engine/IScriptManager.h Normal file
View File

@ -0,0 +1,24 @@
#pragma once
#include <EGSDK\Imports.h>
#include <EGSDK\Engine\rtti.h>
class CRTTI;
class IScriptManager {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_1207C0, (char a1), a1);
private:
VIRTUAL_CALL(1, void, RunAllInitializationCallbacks, ());
public:
VIRTUAL_CALL(2, void, SetPlatform, ());
VIRTUAL_CALL(3, void, _SetPlatform1, ());
virtual void _StrippedVFunc1() = 0;
VIRTUAL_CALL(5, void, _SetPlatform2, ());
VIRTUAL_CALL(6, bool, updateRttiParams, ());
GAME_IMPORT static bool AddInitializationCallback(void (* )(void));
GAME_IMPORT static void RegisterForceUsage(CRTTI&);
GAME_IMPORT IScriptManager();
GAME_IMPORT static void RegisterForceUsage(rtti::Type&);
#pragma endregion
};

2
EGameSDK/include/EGSDK/Engine/ITextDeserializer.h Normal file
View File

@ -0,0 +1,2 @@
#pragma once
class ITextDeserializer;

2
EGameSDK/include/EGSDK/Engine/ITextSerializer.h Normal file
View File

@ -0,0 +1,2 @@
#pragma once
class ITextSerializer;

8
EGameSDK/include/EGSDK/Engine/MaterialEditorCommon.h Normal file
View File

@ -0,0 +1,8 @@
#pragma once
class MaterialEditorCommon {
public:
class TemplateDesc {
public:
struct Parameter;
};
};

11
EGameSDK/include/EGSDK/Engine/Net/Repl/CRttiInfo.h Normal file
View File

@ -0,0 +1,11 @@
#pragma once
#include <EGSDK\Imports.h>
namespace Net::Repl {
class CRttiInfo {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_C5A6F0, (char a1), a1);
#pragma endregion
};
}

4
EGameSDK/include/EGSDK/Engine/Net/Repl/Rtti/Serializer.h Normal file
View File

@ -0,0 +1,4 @@
#pragma once
namespace Net::Repl::Rtti {
class Serializer;
}

28
EGameSDK/include/EGSDK/Engine/Uid.h Normal file
View File

@ -0,0 +1,28 @@
#pragma once
#include <EGSDK\Imports.h>
#include <EGSDK\Engine\ttl\string_base.h>
#include <EGSDK\Engine\ITextSerializer.h>
#include <EGSDK\Engine\ITextDeserializer.h>
class Uid {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static Uid const INVALID;
GAME_IMPORT Uid(ttl::string_base<char> const&);
GAME_IMPORT ttl::string_base<char> ToString() const;
GAME_IMPORT bool operator!() const;
GAME_IMPORT bool operator>(Uid const&) const;
GAME_IMPORT Uid();
GAME_IMPORT bool Write(ITextSerializer&, char const*) const;
GAME_IMPORT bool operator<=(Uid const&) const;
GAME_IMPORT Uid& operator=(Uid const&);
GAME_IMPORT bool IsValid() const;
GAME_IMPORT bool operator!=(Uid const&) const;
GAME_IMPORT Uid(int64_t);
GAME_IMPORT bool operator>=(Uid const&) const;
GAME_IMPORT void FromString(ttl::string_base<char> const&);
GAME_IMPORT bool Read(ITextDeserializer&, char const*);
GAME_IMPORT void Generate();
#pragma endregion
};

865
EGameSDK/include/EGSDK/Engine/cbs.h Normal file
View File

@ -0,0 +1,865 @@
#pragma once
#include <optional>
#include <memory>
#include <EGSDK\Imports.h>
#include <EGSDK\Engine\rtti.h>
#include <EGSDK\Engine\IRTTIEnumerationTyped.h>
#include <EGSDK\Engine\ttl\vector.h>
#include <EGSDK\Engine\ttl\string_base.h>
#include <EGSDK\Engine\ttl\list.h>
#include <EGSDK\Engine\ttl\set.h>
#include <EGSDK\Engine\ttl\less.h>
#include <EGSDK\Engine\ttl\allocator.h>
#include <EGSDK\Engine\ttl\function_ref.h>
#include <EGSDK\Engine\ttl\vector_allocators\heap_allocator.h>
#include <EGSDK\Engine\Uid.h>
#include <EGSDK\Engine\IPtrResolver.h>
class CRTTI;
class CRTTIObject;
class ILevel;
class IGSObject;
class MED {
public:
struct SModelOutfitGroup;
};
class cbs {
public:
struct WorldIndex;
class detail {
public:
enum Handle;
};
class prop {
public:
class IPropertySet;
};
class msg {
public:
class RttiMessageDispatcher {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, unknown_libname_171, (char a1), a1);
#pragma endregion
};
class IMessagePipeSet {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_1233F0, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
virtual void _StrippedVFunc4() = 0;
virtual void _StrippedVFunc5() = 0;
virtual void _StrippedVFunc6() = 0;
virtual void _StrippedVFunc7() = 0;
virtual void _StrippedVFunc8() = 0;
virtual void _StrippedVFunc9() = 0;
virtual void _StrippedVFunc10() = 0;
virtual void _StrippedVFunc11() = 0;
GAME_IMPORT virtual ttl::string_base<char> ToString(CRTTIObject const*) const;
#pragma endregion
};
};
class Call {
public:
enum TYPE;
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static IRTTIEnumerationTyped<cbs::Call::TYPE> const* GetRTTI();
#pragma endregion
};
class CBaseObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static rtti::Type& m_RTTI;
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
VIRTUAL_CALL(0, void, SetPlatform, ());
VIRTUAL_CALL(1, cbs::CBaseObject*, sub_11A890, (char a1), a1);
GAME_IMPORT virtual CRTTI const* GetRTTI() const;
VIRTUAL_CALL(3, CRTTI const*, _GetRTTI1, ());
VIRTUAL_CALL(4, MED::SModelOutfitGroup const*, unassigned, ());
VIRTUAL_CALL(5, MED::SModelOutfitGroup const*, _unassigned1, ());
VIRTUAL_CALL(6, MED::SModelOutfitGroup const*, _unassigned2, ());
VIRTUAL_CALL(7, MED::SModelOutfitGroup const*, _unassigned3, ());
VIRTUAL_CALL(8, int64_t, RunUnitTests, ());
VIRTUAL_CALL(9, int64_t, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(ttl::list<IGSObject*, ttl::allocator>*, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, int64_t, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(ttl::vector<IGSObject*, ttl::vector_allocators::heap_allocator<IGSObject*>, 1>&, bool);
GAME_IMPORT virtual void GetAllObjects(ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, bool, std::optional<ttl::function_ref<bool(CRTTIObject*)>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void, _SetPlatform1, ());
GAME_IMPORT virtual char const* GetString(char const*) const;
VIRTUAL_CALL(18, void, _SetPlatform2, ());
VIRTUAL_CALL(19, bool, _updateRttiParams1, ());
VIRTUAL_CALL(20, void, _SetPlatform3, ());
VIRTUAL_CALL(21, MED::SModelOutfitGroup const*, _unassigned4, ());
VIRTUAL_CALL(22, void, _SetPlatform4, ());
GAME_IMPORT virtual Uid const& GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams2, ());
VIRTUAL_CALL(25, bool, _updateRttiParams3, ());
VIRTUAL_CALL(26, bool, _updateRttiParams4, ());
VIRTUAL_CALL(27, bool, _updateRttiParams5, ());
VIRTUAL_CALL(28, bool, _updateRttiParams6, ());
VIRTUAL_CALL(29, bool, _updateRttiParams7, ());
VIRTUAL_CALL(30, bool, _updateRttiParams8, ());
VIRTUAL_CALL(31, bool, _updateRttiParams9, ());
VIRTUAL_CALL(32, bool, _updateRttiParams10, ());
GAME_IMPORT virtual void CallVoidMethod(char const*, ...);
GAME_IMPORT virtual cbs::msg::IMessagePipeSet const& GetMessagePipeSet() const;
VIRTUAL_CALL(35, int64_t, _RunUnitTests3, ());
VIRTUAL_CALL(36, MED::SModelOutfitGroup const*, _unassigned5, ());
VIRTUAL_CALL(37, MED::SModelOutfitGroup const*, _unassigned6, ());
VIRTUAL_CALL(38, MED::SModelOutfitGroup const*, _unassigned7, ());
VIRTUAL_CALL(39, MED::SModelOutfitGroup const*, _unassigned8, ());
GAME_IMPORT virtual cbs::prop::IPropertySet const& GetPropertySet() const;
VIRTUAL_CALL(41, void, _SetPlatform5, ());
VIRTUAL_CALL(42, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(CRTTIField const*, unsigned char, fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(dom::IReader::Object const&, IPtrResolver&, bool, bool (*)(char const*, CRTTIObject*));
GAME_IMPORT virtual void LoadFields(ITextDeserializer&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void SaveFields(dom::IWriter&, ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char*, int);
GAME_IMPORT virtual int FromBufferReplicated(char*, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void, _SetPlatform6, ());
VIRTUAL_CALL(52, static bool, ValidateVec4, (IGSObject const*, vec4 const&), const*, const&);
GAME_IMPORT virtual bool CopyFields(CRTTIObject const*, bool);
GAME_IMPORT virtual bool CopyPointerFields(CRTTIObject const*);
GAME_IMPORT virtual bool ExchangePointerFields(CRTTIObject*);
VIRTUAL_CALL(56, int64_t, _RunUnitTests5, ());
VIRTUAL_CALL(57, int64_t, _RunUnitTests6, ());
VIRTUAL_CALL(58, int64_t, _RunUnitTests7, ());
GAME_IMPORT virtual SRttiNetPointer GetNetPointer() const;
VIRTUAL_CALL(60, int64_t, _RunUnitTests8, ());
GAME_IMPORT virtual ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(SObjectMemoryUsage&) const;
VIRTUAL_CALL(63, void, _SetPlatform7, ());
GAME_IMPORT virtual bool GetValidFieldValuesEditor(CRTTIField const&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&);
VIRTUAL_CALL(65, bool, _updateRttiParams11, ());
VIRTUAL_CALL(66, static bool, _ValidateVec41, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, int64_t, _RunUnitTests9, ());
GAME_IMPORT virtual ttl::string_base<char> ValueToString(CRTTIObject* const&) const;
GAME_IMPORT virtual bool IsFieldChanged(CRTTIField const*) const;
GAME_IMPORT virtual void SetFieldChangedFlag(CRTTIField const*, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams12, ());
GAME_IMPORT virtual bool OnFieldChanged2(CRTTIField const*, bool);
VIRTUAL_CALL(73, void, _SetPlatform8, ());
VIRTUAL_CALL(74, int64_t, _RunUnitTests10, ());
VIRTUAL_CALL(75, void, _SetPlatform9, ());
VIRTUAL_CALL(76, bool, _updateRttiParams13, ());
protected:
GAME_IMPORT virtual bool OnFieldChanged(CRTTIField const*, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams14, ());
VIRTUAL_CALL(79, bool, _updateRttiParams15, ());
VIRTUAL_CALL(80, int64_t, _RunUnitTests11, ());
VIRTUAL_CALL(81, int64_t, _RunUnitTests12, ());
VIRTUAL_CALL(82, void, _SetPlatform10, ());
GAME_IMPORT virtual void Query(IBaseValidator&, ttl::vector<CRTTIObject*, ttl::vector_allocators::heap_allocator<CRTTIObject*>, 1>&) const;
VIRTUAL_CALL(84, void, _SetPlatform11, ());
protected:
GAME_IMPORT virtual void OnRelease(cbs::contracts::ApiComponentOnRelease);
public:
GAME_IMPORT static CRTTI* GetSTTI();
GAME_IMPORT cbs::WorldIndex GetWorldId() const;
GAME_IMPORT CLevel* GetCLevel() const;
protected:
GAME_IMPORT CBaseObject();
GAME_IMPORT bool GetLowLevelActive() const;
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT static rtti::Type& typeinfo();
protected:
GAME_IMPORT void SetLowLevelActive(bool);
private:
GAME_IMPORT void InvalidateHandle();
public:
GAME_IMPORT void InvalidateHandle(cbs::contracts::ApiInvalidatePointer);
GAME_IMPORT void Release();
GAME_IMPORT CBaseObject(cbs::CBaseObject const&);
GAME_IMPORT ILevel* GetILevel() const;
private:
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
#pragma endregion
};
template<typename T1, typename T2>
class CAbstractSystem;
template<typename T1>
class CSystemWorldData;
class CComponent {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static cbs::CAbstractSystem<cbs::CComponent, cbs::CSystemWorldData<cbs::CComponent>>& s_System;
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
GAME_IMPORT static rtti::Type& m_RTTI;
VIRTUAL_CALL(0, void, SetPlatform, ());
VIRTUAL_CALL(1, cbs::CBaseObject*, sub_11ADA0, (char a1), a1);
GAME_IMPORT virtual CRTTI const* GetRTTI() const;
VIRTUAL_CALL(3, CRTTI const*, _GetRTTI1, ());
VIRTUAL_CALL(4, MED::SModelOutfitGroup const*, unassigned, ());
VIRTUAL_CALL(5, MED::SModelOutfitGroup const*, _unassigned1, ());
VIRTUAL_CALL(6, MED::SModelOutfitGroup const*, _unassigned2, ());
VIRTUAL_CALL(7, MED::SModelOutfitGroup const*, _unassigned3, ());
VIRTUAL_CALL(8, int64_t, RunUnitTests, ());
VIRTUAL_CALL(9, int64_t, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(ttl::list<IGSObject*, ttl::allocator>*, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, int64_t, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(ttl::vector<IGSObject*, ttl::vector_allocators::heap_allocator<IGSObject*>, 1>&, bool);
GAME_IMPORT virtual void GetAllObjects(ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, bool, std::optional<ttl::function_ref<bool(CRTTIObject*)>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void, _SetPlatform1, ());
GAME_IMPORT virtual char const* GetString(char const*) const;
VIRTUAL_CALL(18, void, _SetPlatform2, ());
VIRTUAL_CALL(19, bool, _updateRttiParams1, ());
VIRTUAL_CALL(20, void, _SetPlatform3, ());
VIRTUAL_CALL(21, MED::SModelOutfitGroup const*, _unassigned4, ());
VIRTUAL_CALL(22, void, _SetPlatform4, ());
GAME_IMPORT virtual Uid const& GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams2, ());
VIRTUAL_CALL(25, bool, _updateRttiParams3, ());
VIRTUAL_CALL(26, bool, _updateRttiParams4, ());
VIRTUAL_CALL(27, bool, _updateRttiParams5, ());
VIRTUAL_CALL(28, bool, _updateRttiParams6, ());
VIRTUAL_CALL(29, bool, _updateRttiParams7, ());
VIRTUAL_CALL(30, bool, _updateRttiParams8, ());
VIRTUAL_CALL(31, bool, _updateRttiParams9, ());
VIRTUAL_CALL(32, bool, _updateRttiParams10, ());
GAME_IMPORT virtual void CallVoidMethod(char const*, ...);
GAME_IMPORT virtual cbs::msg::IMessagePipeSet const& GetMessagePipeSet() const;
VIRTUAL_CALL(35, int64_t, _RunUnitTests3, ());
VIRTUAL_CALL(36, MED::SModelOutfitGroup const*, _unassigned5, ());
VIRTUAL_CALL(37, MED::SModelOutfitGroup const*, _unassigned6, ());
VIRTUAL_CALL(38, MED::SModelOutfitGroup const*, _unassigned7, ());
VIRTUAL_CALL(39, MED::SModelOutfitGroup const*, _unassigned8, ());
GAME_IMPORT virtual cbs::prop::IPropertySet const& GetPropertySet() const;
VIRTUAL_CALL(41, void, _SetPlatform5, ());
VIRTUAL_CALL(42, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(CRTTIField const*, unsigned char, fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(dom::IReader::Object const&, IPtrResolver&, bool, bool (*)(char const*, CRTTIObject*));
GAME_IMPORT virtual void LoadFields(ITextDeserializer&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void SaveFields(dom::IWriter&, ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char*, int);
GAME_IMPORT virtual int FromBufferReplicated(char*, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void, _SetPlatform6, ());
VIRTUAL_CALL(52, static bool, ValidateVec4, (IGSObject const*, vec4 const&), const*, const&);
GAME_IMPORT virtual bool CopyFields(CRTTIObject const*, bool);
GAME_IMPORT virtual bool CopyPointerFields(CRTTIObject const*);
GAME_IMPORT virtual bool ExchangePointerFields(CRTTIObject*);
VIRTUAL_CALL(56, int64_t, _RunUnitTests5, ());
GAME_IMPORT virtual IGSObject* FindObjectByNetPointer(SRttiNetPointer const&) const;
GAME_IMPORT virtual cbs::CEntity* FindEntityByNetPointer(SRttiNetPointer const&) const;
GAME_IMPORT virtual SRttiNetPointer GetNetPointer() const;
GAME_IMPORT virtual cbs::pcid_t GetPcId() const;
GAME_IMPORT virtual ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(SObjectMemoryUsage&) const;
VIRTUAL_CALL(63, void, _SetPlatform7, ());
GAME_IMPORT virtual bool GetValidFieldValuesEditor(CRTTIField const&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&);
VIRTUAL_CALL(65, bool, _updateRttiParams11, ());
VIRTUAL_CALL(66, static bool, _ValidateVec41, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, int64_t, _RunUnitTests6, ());
GAME_IMPORT virtual ttl::string_base<char> ValueToString(CRTTIObject* const&) const;
GAME_IMPORT virtual bool IsFieldChanged(CRTTIField const*) const;
GAME_IMPORT virtual void SetFieldChangedFlag(CRTTIField const*, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams12, ());
GAME_IMPORT virtual bool OnFieldChanged2(CRTTIField const*, bool);
VIRTUAL_CALL(73, void, _SetPlatform8, ());
VIRTUAL_CALL(74, int64_t, _RunUnitTests7, ());
VIRTUAL_CALL(75, void, _SetPlatform9, ());
VIRTUAL_CALL(76, bool, _updateRttiParams13, ());
protected:
GAME_IMPORT virtual bool OnFieldChanged(CRTTIField const*, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams14, ());
VIRTUAL_CALL(79, bool, _updateRttiParams15, ());
VIRTUAL_CALL(80, int64_t, _RunUnitTests8, ());
VIRTUAL_CALL(81, int64_t, _RunUnitTests9, ());
VIRTUAL_CALL(82, void, _SetPlatform10, ());
GAME_IMPORT virtual void Query(IBaseValidator&, ttl::vector<CRTTIObject*, ttl::vector_allocators::heap_allocator<CRTTIObject*>, 1>&) const;
GAME_IMPORT virtual void OnDestroy(cbs::contracts::ApiComponentOnDestroy);
GAME_IMPORT virtual void OnRelease(cbs::contracts::ApiComponentOnRelease);
GAME_IMPORT virtual cbs::CSystemBase& GetSystem() const;
GAME_IMPORT virtual void OnConstructObject(cbs::contracts::ApiComponentOnConstructObject);
GAME_IMPORT virtual void OnPreCreate(cbs::contracts::ApiComponentOnPreCreate);
VIRTUAL_CALL(89, void, _SetPlatform11, ());
VIRTUAL_CALL(90, void, _SetPlatform12, ());
protected:
GAME_IMPORT virtual void OnReplicationPrepare();
public:
VIRTUAL_CALL(92, bool, _updateRttiParams16, ());
VIRTUAL_CALL(93, int64_t, _RunUnitTests10, ());
VIRTUAL_CALL(94, int64_t, _RunUnitTests11, ());
VIRTUAL_CALL(95, bool, _updateRttiParams17, ());
VIRTUAL_CALL(96, void, _SetPlatform13, ());
GAME_IMPORT virtual ICoWorldXform const* GetXformComponent() const;
VIRTUAL_CALL(98, ICoWorldXform const*, _GetXformComponent1, ());
VIRTUAL_CALL(99, void, _SetPlatform14, ());
VIRTUAL_CALL(100, void, _SetPlatform15, ());
VIRTUAL_CALL(101, void, _SetPlatform16, ());
VIRTUAL_CALL(102, static bool, _ValidateVec42, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(103, void, _SetPlatform17, ());
VIRTUAL_CALL(104, void, _SetPlatform18, ());
VIRTUAL_CALL(105, int64_t, _RunUnitTests12, ());
protected:
GAME_IMPORT virtual bool IsCreated() const;
GAME_IMPORT virtual void OnResolvePrefab(SpawnContext const&, PrefabResolveContext const&);
public:
VIRTUAL_CALL(108, void, _SetPlatform19, ());
VIRTUAL_CALL(109, void, _SetPlatform20, ());
protected:
GAME_IMPORT virtual void ApplyActivate(bool);
GAME_IMPORT virtual void ApplyDeactivate(bool);
GAME_IMPORT virtual void CallPendingActivationHandlers(CDeferredCallSystem*);
public:
VIRTUAL_CALL(113, void, _SetPlatform21, ());
VIRTUAL_CALL(114, void, _SetPlatform22, ());
VIRTUAL_CALL(115, void, _SetPlatform23, ());
VIRTUAL_CALL(116, void, _OnReplicationPrepare1, ());
VIRTUAL_CALL(117, void, _SetPlatform24, ());
protected:
GAME_IMPORT virtual void OnReplicationResolve();
public:
VIRTUAL_CALL(119, void, _SetPlatform25, ());
VIRTUAL_CALL(120, void, _SetPlatform26, ());
VIRTUAL_CALL(121, void, _SetPlatform27, ());
VIRTUAL_CALL(122, void, _SetPlatform28, ());
VIRTUAL_CALL(123, void, _SetPlatform29, ());
VIRTUAL_CALL(124, void, _SetPlatform30, ());
VIRTUAL_CALL(125, void, _SetPlatform31, ());
GAME_IMPORT void CallRegistered();
private:
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
public:
GAME_IMPORT static cbs::CAbstractSystem<cbs::CComponent, cbs::CSystemWorldData<cbs::CComponent>>& GetSystemInstance();
GAME_IMPORT void MsgDeactivate();
protected:
GAME_IMPORT void DeactivateInternal(bool);
public:
GAME_IMPORT bool IsActive() const;
GAME_IMPORT Replication::IObject& ReplicationObject() const;
GAME_IMPORT cbs::CSystemWorldData<cbs::CComponent>& GetWorldDataInstance();
GAME_IMPORT bool AllComponentFlagsSet(cbs::FComponent::TYPE) const;
protected:
GAME_IMPORT void SetFlags(cbs::FComponent::TYPE, bool);
public:
GAME_IMPORT bool WasRegistered() const;
GAME_IMPORT void MakeFullyInitialized(cbs::contracts::ApiMakeFullyInitializedComponent);
GAME_IMPORT bool IsAlive() const;
GAME_IMPORT void ActivateByParent(bool);
GAME_IMPORT void Activate();
protected:
GAME_IMPORT void ClearFlags(cbs::FComponent::TYPE, bool);
public:
GAME_IMPORT void MsgActivate();
GAME_IMPORT CComponent(cbs::CComponent const&);
GAME_IMPORT static rtti::Type& typeinfo();
protected:
GAME_IMPORT void ActivateInternal(bool);
private:
GAME_IMPORT static bool SetSelfActive(CRTTIObject*, bool const&);
public:
GAME_IMPORT static CRTTI* GetSTTI();
GAME_IMPORT void DeactivateByParent(bool);
GAME_IMPORT void SetComponentFlags(cbs::FComponent::TYPE);
GAME_IMPORT void ClearComponentFlags(cbs::FComponent::TYPE);
private:
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
protected:
GAME_IMPORT CComponent();
public:
GAME_IMPORT static void RegisterSTTI(CRTTI*);
private:
GAME_IMPORT static void GetSelfActive(CRTTIObject const*, bool&);
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT static cbs::CSystemWorldData<cbs::CComponent>& GetWorldDataInstance(cbs::WorldIndex);
#pragma endregion
};
class CSystemBase;
class CSystemCallManager {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, cbs::CSystemCallManager*, sub_4034E0, (char a1), a1);
protected:
GAME_IMPORT virtual void AddCall(cbs::CComponent*, void (*)(cbs::CComponentBase*), cbs::Call::TYPE);
GAME_IMPORT virtual void RemoveCall(cbs::CComponent*, void (*)(cbs::CComponentBase*), cbs::Call::TYPE);
public:
GAME_IMPORT void UnregisterCalls(cbs::CComponent*);
GAME_IMPORT CSystemCallManager(cbs::CSystemBase*);
GAME_IMPORT bool IsEmpty() const;
GAME_IMPORT void InvokeSystemCalls(cbs::WorldIndex, cbs::Call::TYPE, char const*);
GAME_IMPORT void GetFrameStats(cbs::CallManagerFrameStats&) const;
private:
GAME_IMPORT void Debug_EnsureSingleSlotsCreated();
public:
GAME_IMPORT void InvokeSingleCalls(cbs::WorldIndex, cbs::Call::TYPE, bool, char const*);
protected:
GAME_IMPORT virtual void RemoveSystemCall(cbs::WorldIndex, cbs::ICallable*, void*, void (* const&)(void*, cbs::WorldIndex, cbs::Call::TYPE), cbs::Call::TYPE);
private:
GAME_IMPORT static cbs::Call::TYPE GetSlot(cbs::Call::TYPE);
protected:
GAME_IMPORT virtual void AddSystemCall(cbs::WorldIndex, cbs::ICallable*, void*, void (* const&)(void*, cbs::WorldIndex, cbs::Call::TYPE), cbs::Call::TYPE);
#pragma endregion
};
class CSystemBase {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_462480, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
virtual void _StrippedVFunc4() = 0;
virtual void _StrippedVFunc5() = 0;
virtual void _StrippedVFunc6() = 0;
GAME_IMPORT virtual void Release(cbs::detail::Handle);
virtual void _StrippedVFunc7() = 0;
virtual void _StrippedVFunc8() = 0;
virtual void _StrippedVFunc9() = 0;
GAME_IMPORT static uint32_t Count(cbs::WorldIndex, CRTTI const*, bool);
GAME_IMPORT static uint32_t Count(cbs::WorldIndex, rtti::Type const&, bool);
GAME_IMPORT bool CanInvokeFrame(uint32_t) const;
GAME_IMPORT bool IsAbstract() const;
GAME_IMPORT cbs::CSystemCallManager& GetSystemCallManager();
GAME_IMPORT void CallSystemHandlers(cbs::WorldIndex, cbs::Call::TYPE);
GAME_IMPORT CSystemBase(uint32_t);
GAME_IMPORT bool TryReleaseCallManager();
GAME_IMPORT void CallHandlers(cbs::WorldIndex, cbs::Call::TYPE, bool);
GAME_IMPORT void RegisterAsCallableSystem();
GAME_IMPORT void RegisterAsCallable();
#pragma endregion
};
class Prefab {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static char const* const s_KeyPid;
GAME_IMPORT static char const* const s_KeyCustomExteriorsDistance;
GAME_IMPORT static char const* const s_KeyInit;
GAME_IMPORT static int const PROPERTY_CONTAINER_SUB_OBJECT_IDX;
GAME_IMPORT static char const* const WORKCOPY_POSTFIX;
GAME_IMPORT static char const* const s_KeyUser;
GAME_IMPORT static char const* const s_KeyClass;
GAME_IMPORT static char const* const s_KeyProperties;
GAME_IMPORT static char const* const LOD0_POSTFIX;
GAME_IMPORT static char const* const s_KeyLodAssetName;
GAME_IMPORT static char const* const s_KeyLodType;
GAME_IMPORT static char const* const s_KeyLod;
GAME_IMPORT static char const* const LOD1_IN_LOD2_POSTFIX;
GAME_IMPORT static char const* const INT_FLT_POSTFIX;
GAME_IMPORT static char const* const s_KeyBindings;
GAME_IMPORT static char const* const s_KeyComponents;
GAME_IMPORT static char const* const MESH_FILE_EXT;
GAME_IMPORT static char const* const MAP3D_POSTFIX;
GAME_IMPORT static char const* const s_KeyInterface;
GAME_IMPORT static char const* const s_KeyIgnorePresetClassNameValidation;
GAME_IMPORT static char const* const s_KeySpawnType;
GAME_IMPORT static char const* const INTDTL_FLT_POSTFIX;
GAME_IMPORT static char const* const s_KeyDestinationFields;
GAME_IMPORT static char const* const PREFAB_DEFAULT;
GAME_IMPORT static char const* const PREFAB_FILE_EXT;
GAME_IMPORT static char const* const s_KeyExtents;
GAME_IMPORT static char const* const LOD1_POSTFIX;
GAME_IMPORT static char const* const s_KeyRuntimeData;
GAME_IMPORT static char const* const s_KeyDetailSpawnType;
GAME_IMPORT static char const* const LOD1_NAME;
GAME_IMPORT static char const* const s_KeyName;
GAME_IMPORT static char const* const LOD2_NAME;
GAME_IMPORT static char const* const s_PrefabInterfaces;
GAME_IMPORT static char const* const s_KeySourceUuid;
GAME_IMPORT static char const* const EXT_FLT_POSTFIX;
GAME_IMPORT static char const* const LOD0_NAME;
GAME_IMPORT static char const* const LOD_TERRAIN_POSTFIX;
GAME_IMPORT static char const* const s_KeyDestinationUuid;
GAME_IMPORT static char const* const MATERIAL_FILE_EXT;
GAME_IMPORT static char const* const s_KeyPipes;
GAME_IMPORT static char const* const s_KeyDestination;
GAME_IMPORT static char const* const EXTDTL_FLT_POSTFIX;
GAME_IMPORT static char const* const s_KeyVirtualFields;
GAME_IMPORT static char const* const GENPIN_INFIX;
GAME_IMPORT static char const* const s_KeyVersion;
GAME_IMPORT static char const* const s_KeyDependenciesHash;
GAME_IMPORT static char const* const s_KeySource;
GAME_IMPORT static char const* const s_KeyUseCacheToConnectPipes;
GAME_IMPORT static char const* const LOD2_POSTFIX;
GAME_IMPORT static char const* const s_KeyFilename;
GAME_IMPORT static char const* const s_KeyEditorOnly;
GAME_IMPORT static char const* const s_KeyPrefabEditorData;
GAME_IMPORT static char const* const NONFLT_POSTFIX;
GAME_IMPORT static char const* const FLT_POSTFIX;
GAME_IMPORT static char const* const s_KeyProductionState;
GAME_IMPORT static char const* const PREFABDUMP_FILE_EXT;
VIRTUAL_CALL(0, cbs::Prefab*, sub_1214E0, (char a1), a1);
private:
GAME_IMPORT virtual void ReleaseUnusedMemory();
public:
GAME_IMPORT virtual void InitializeRttiReplication();
VIRTUAL_CALL(3, void, SetPlatform, ());
VIRTUAL_CALL(4, int64_t, RunUnitTests, ());
VIRTUAL_CALL(5, int64_t, _RunUnitTests1, ());
VIRTUAL_CALL(6, int64_t, _RunUnitTests2, ());
private:
GAME_IMPORT virtual CRTTI::SEditorData* CreateEditorData();
public:
GAME_IMPORT virtual ttl::string_base<char> ClassWriterCompare(CRTTI const*, CRTTI const*, CRTTI const&) const;
VIRTUAL_CALL(9, bool, updateRttiParams, ());
private:
GAME_IMPORT virtual void Preprocess_Internal(bool);
GAME_IMPORT void ConnectComponents(PrefabResolveContext const&, int) const;
GAME_IMPORT void SavePipeBindings(dom::IWriter&) const;
public:
GAME_IMPORT void SetFormat(dom::EFormat::TYPE);
private:
GAME_IMPORT void ProcessMatrixByRandomizer(cbs::CEntity*, SpawnContext const&, mtx34&) const;
GAME_IMPORT void UpdateReplicationInfo(CRTTI const*);
GAME_IMPORT void ResolvePipeIsPartOfBindingScript(cbs::PipeBinding const&) const;
GAME_IMPORT bool Parse(dom::IReader::Value const&);
public:
GAME_IMPORT static ttl::string_base<char> GetOriginalPrefabName(char const*);
GAME_IMPORT cbs::PrefabElement const* FindComponent(cbs::pcid_t) const;
GAME_IMPORT cbs::ParseInfo& GetParseInfo();
GAME_IMPORT cbs::pcid_t AddPrefabComponent(cbs::PrefabElement*, int);
GAME_IMPORT cbs::PrefabEntityComponent const* FindPrefabEntityComponent(cbs::Prefab const*) const;
GAME_IMPORT ttl::vector<cbs::PrefabElement*, ttl::vector_allocators::heap_allocator<cbs::PrefabElement*>, 1> const& GetPrefabComponents() const;
GAME_IMPORT cbs::Prefab& operator=(cbs::Prefab const&);
private:
GAME_IMPORT cbs::pcid_t AssignPrefabComponentId();
GAME_IMPORT void ClearSerializationHierarchy();
public:
GAME_IMPORT cbs::PrefabMessagePipeSet const& GetPrefabMessagePipeSet() const;
GAME_IMPORT void AddPropertyBinding(cbs::pcid_t, ttl::string_const<char>, cbs::pcid_t, ttl::string_const<char>);
GAME_IMPORT void SetIgnorePresetClassNameValidation(bool);
GAME_IMPORT ttl::string_base<char> GetLoggedName() const;
GAME_IMPORT void RemovePropertyBinding(cbs::pcid_t, ttl::string_const<char>, cbs::pcid_t, ttl::string_const<char>);
GAME_IMPORT cbs::Prefab const* GetContainerPrefab() const;
private:
GAME_IMPORT void CreateFieldsForInterface(CRTTI const*);
public:
GAME_IMPORT static ttl::string_base<char> GetWorkCopyPrefabName(char const*);
private:
GAME_IMPORT void SaveComponents(dom::IWriter&) const;
GAME_IMPORT bool ParseInterface(dom::IReader::Value const&);
public:
GAME_IMPORT bool IsPartOfBindingScript(cbs::PropertyBinding const&) const;
private:
GAME_IMPORT bool ParseRuntimeData(dom::IReader::Value const&);
GAME_IMPORT void SaveVirtualFields(dom::IWriter&) const;
GAME_IMPORT guid PrepareGuid(SpawnContext&) const;
GAME_IMPORT void ApplyDataPresets(cbs::CEntity*, PresetId) const;
GAME_IMPORT void ClearInterface();
public:
GAME_IMPORT bool ImplementsPrefabInterface(rtti::Type const&) const;
GAME_IMPORT bool CreateFromBuffer(char const*);
private:
GAME_IMPORT bool LinkInterfaceVirtualFieldsToEntity(cbs::PrefabInterfaceInfo const&, cbs::EntityInterface&, cbs::CEntity const*) const;
GAME_IMPORT void ProcessForcedCoHierarchy(cbs::CEntity*, SpawnContext const&) const;
public:
GAME_IMPORT bool IsPartOfBindingScript(cbs::PipeBinding const&) const;
private:
GAME_IMPORT void SaveInterface(dom::IWriter&) const;
public:
GAME_IMPORT bool IsStreamingRoot() const;
GAME_IMPORT Prefab(ClassReaderResolve const&);
GAME_IMPORT ttl::string_base<char> const& GetContainerPrefabName() const;
private:
GAME_IMPORT void ResolvePropertyIsPartOfBindingScript(cbs::PropertyBinding const&) const;
public:
GAME_IMPORT void Preprocess(bool);
private:
GAME_IMPORT void ClearComponents();
public:
GAME_IMPORT cbs::PrefabPropertySet const& GetPrefabPropertySet() const;
private:
GAME_IMPORT bool ParseData(dom::IReader::Value const&);
GAME_IMPORT bool LoadFromBuffer(char const*, uint32_t, bool);
GAME_IMPORT bool LinkInterfaceMessagePipesToEntity(cbs::PrefabInterfaceInfo const&, cbs::EntityInterface&, cbs::CEntity const*) const;
GAME_IMPORT PresetId ObtainPresetID(guid, SpawnContext const&) const;
public:
GAME_IMPORT static ttl::string_base<char> GetOriginalPrefabFileName(char const*);
GAME_IMPORT bool GetEditorOnly() const;
GAME_IMPORT cbs::Prefab::SPrefabEditorData& EditorData();
private:
GAME_IMPORT void CreateEntityComponents(cbs::CEntity*, SpawnContext const&, CPtrResolverDeferred&, int&) const;
GAME_IMPORT void SetEntityData(cbs::CEntity*, SpawnContext const&, CPtrResolverDeferred&, PrefabResolveContext&) const;
public:
GAME_IMPORT ttl::string_base<char> GetContainerPrefabScriptName() const;
private:
GAME_IMPORT void ConnectComponents(PrefabResolveContext const&) const;
GAME_IMPORT void InitializeEntity(cbs::CEntity*, SpawnContext const&) const;
public:
GAME_IMPORT void GetScriptName(ttl::temp_string_base<char, 240>&) const;
private:
GAME_IMPORT void ClearBindings();
GAME_IMPORT bool ParseBindings(dom::IReader::Value const&);
public:
GAME_IMPORT bool CheckPrefabComponentPcids(ttl::string_base<char>&) const;
private:
GAME_IMPORT void Delete();
public:
GAME_IMPORT void SetDirty();
private:
GAME_IMPORT void PreprocessPrefabInterfaceMessagePipes();
public:
GAME_IMPORT void SetFromRpackCompact();
GAME_IMPORT static ttl::string_base<char> RemovePrefabExtensions(ttl::string_base<char> const&);
private:
GAME_IMPORT void Clear();
public:
GAME_IMPORT void SetFromRpackLoose();
GAME_IMPORT cbs::PrefabXformComponent const* GetRootXformComponent() const;
private:
GAME_IMPORT void PreprocessConvertUserColor();
GAME_IMPORT void PreprocessVirtualFields();
public:
GAME_IMPORT cbs::PrefabEntityComponent const* FindPrefabEntityComponent(char const*) const;
GAME_IMPORT bool CreateFromBuffer(char const*, uint32_t);
GAME_IMPORT bool IsPcidForbiddenInThisGameMode(cbs::pcid_t const&) const;
private:
GAME_IMPORT bool ParseVirtualFields(dom::IReader::Value const&);
GAME_IMPORT void ConnectComponentPipes(PrefabResolveContext const&) const;
public:
GAME_IMPORT cbs::CEntity* Spawn(SpawnContext&) const;
private:
GAME_IMPORT void ConnectComponentPipes(PrefabResolveContext const&, int) const;
public:
GAME_IMPORT ttl::vector<cbs::PropertyBinding, ttl::vector_allocators::heap_allocator<cbs::PropertyBinding>, 0> const& GetPropertyBinding() const;
private:
GAME_IMPORT void ConnectComponentProperties(PrefabResolveContext const&, int) const;
GAME_IMPORT int GenerateEnityVariantHash(ttl::vector<uint32_t, ttl::vector_allocators::heap_allocator<uint32_t>, 2> const&) const;
public:
GAME_IMPORT cbs::Prefab::SPrefabEditorData const& GetEditorData() const;
GAME_IMPORT static ttl::string_base<char> GetWorkCopyPrefabFileName(char const*);
private:
GAME_IMPORT bool ParseVirtualFieldDestinations(dom::IReader::Value const&, cbs::Prefab::SVirtualField&);
public:
GAME_IMPORT cbs::PrefabEntityComponent const* FindPrefabEntityComponent(cbs::CPcidPathView) const;
GAME_IMPORT cbs::PrefabElement const* FindComponent(rtti::Type const&) const;
private:
GAME_IMPORT bool LinkInterfacePropertiesToEntity(cbs::PrefabInterfaceInfo const&, cbs::EntityInterface&, cbs::CEntity const*) const;
public:
GAME_IMPORT void RemovePipeBinding(cbs::pcid_t, ttl::string_const<char>, cbs::pcid_t, ttl::string_const<char>);
private:
GAME_IMPORT void ConnectComponentProperties(PrefabResolveContext const&) const;
GAME_IMPORT void PreprocessComponentsAvailability();
public:
GAME_IMPORT Prefab(cbs::Prefab const&);
private:
GAME_IMPORT void SaveComponentsAndGlobalProperties(dom::IWriter&) const;
public:
GAME_IMPORT ttl::string_base<char> GetScriptName() const;
private:
GAME_IMPORT void ValidateInitStringOfEntityInterfaceField(ttl::string_const<char>, ttl::string_base<char>&) const;
GAME_IMPORT cbs::CEntity* CreateEntityObject(SpawnContext const&) const;
public:
GAME_IMPORT cbs::PrefabEntityComponent const* FindPrefabEntityComponentByPrefabName(char const*) const;
GAME_IMPORT bool LinkInterfaceToEntity(cbs::EntityInterface&, cbs::CEntity const*) const;
private:
GAME_IMPORT void CreateMessagePipeFieldForInterface(CRTTIFieldPIMessagePipe const*);
GAME_IMPORT void SaveBindings(dom::IWriter&) const;
public:
GAME_IMPORT void Save(dom::IWriter&, void*, cbs::Prefab::ESavePrefabHierarchy) const;
private:
GAME_IMPORT bool ParsePrefabInterfaces(dom::IReader::Value const&);
GAME_IMPORT ttl::string_base<char> GetDefaultPropertyValue(CRTTI const*, CRTTIFieldPIProperty const*);
public:
GAME_IMPORT bool SupportsAttaching() const;
private:
GAME_IMPORT bool ParseComponents(dom::IReader::Value const&);
public:
GAME_IMPORT ttl::vector<cbs::Prefab::SVirtualField, ttl::vector_allocators::heap_allocator<cbs::Prefab::SVirtualField>, 0> const& GetRawVirtualFields() const;
GAME_IMPORT void SaveData(dom::IWriter&, void*) const;
GAME_IMPORT bool IsFromRpackCompact() const;
private:
GAME_IMPORT void CreatePropertyFieldForInterface(CRTTI const*, CRTTIFieldPIProperty const*);
public:
GAME_IMPORT cbs::CEntity* CreateEntity(SpawnContext&) const;
private:
GAME_IMPORT void SavePrefabInterfaces(dom::IWriter&) const;
public:
GAME_IMPORT static ttl::string_base<char> RemovePrefabExtensions(ttl::string_base<char>&&);
private:
GAME_IMPORT void SetEntityRootXform(cbs::CEntity*, SpawnContext const&) const;
public:
GAME_IMPORT bool IsFromRpackLoose() const;
GAME_IMPORT void RemovePrefabComponents(ttl::vector<cbs::PrefabElement*, ttl::vector_allocators::heap_allocator<cbs::PrefabElement*>, 1> const&, bool);
protected:
GAME_IMPORT Prefab(ttl::string_const<char>);
public:
GAME_IMPORT ttl::string_base<char> SaveToString(dom::EFormat::TYPE, cbs::Prefab::ESavePrefabHierarchy) const;
private:
GAME_IMPORT static cbs::Prefab* LoadFromFile(ttl::string_const<char>);
public:
GAME_IMPORT bool IsDefaultPlaceholder() const;
private:
GAME_IMPORT void SavePropertyBindings(dom::IWriter&) const;
public:
GAME_IMPORT ttl::vector<cbs::PipeBinding, ttl::vector_allocators::heap_allocator<cbs::PipeBinding>, 0> const& GetPipeBinding() const;
private:
GAME_IMPORT void CreateVirtualFields();
public:
GAME_IMPORT void SetEditorOnly(bool);
GAME_IMPORT bool HasIgnorePresetClassNameValidation() const;
GAME_IMPORT static ttl::string_base<char> GetCleanPrefabName(char const*);
GAME_IMPORT void AddPipeBinding(cbs::pcid_t, ttl::string_const<char>, cbs::pcid_t, ttl::string_const<char>);
private:
GAME_IMPORT void PreprocessPrefabInterfaceProperties();
GAME_IMPORT void ResolveBindingScript(cbs::CPointer<cbs::CEntity>, SpawnContext const&) const;
#pragma endregion
};
class PrefabManager {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static bool s_EnablePrefabsInRpacks;
GAME_IMPORT void GetPrefabsNames(ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&) const;
GAME_IMPORT void SetIsGameInEditorMode(bool);
GAME_IMPORT bool LogPrefabUsage(cbs::Prefab const*);
GAME_IMPORT bool GetLoadEditorSpecificPrefabs() const;
private:
GAME_IMPORT void RemoveEmptyEntities(cbs::Prefab*);
public:
GAME_IMPORT bool ReleasePrefabPreloadedFromRpack(cbs::Prefab*);
GAME_IMPORT bool GetIsGameInEditorMode();
GAME_IMPORT cbs::Prefab* LoadPrefab(ttl::string_const<char>, char const*, uint32_t, bool*);
GAME_IMPORT static cbs::PrefabElement* CreatePrefabElement(CRTTI const*);
private:
GAME_IMPORT void LoadTags();
public:
GAME_IMPORT cbs::Prefab* ReloadPrefab(cbs::Prefab* const, char const*, uint32_t);
private:
GAME_IMPORT void LoadPrefabPost(cbs::Prefab*);
public:
GAME_IMPORT void SavePrefab(cbs::Prefab const*, ttl::string_const<char>) const;
GAME_IMPORT bool IsPrefabSpawned(cbs::Prefab const*) const;
GAME_IMPORT void Dump() const;
private:
GAME_IMPORT void TestValidateBinaryPrefabs();
public:
GAME_IMPORT void PrefabFromRpackHandleStreamingRoot(cbs::Prefab*, bool);
GAME_IMPORT bool ReleasePrefabPreloadedFromRpack(ttl::string_const<char>);
GAME_IMPORT void LoadAllConfigs();
GAME_IMPORT static cbs::PrefabElement* CreatePrefabElementBasedOnTargetRtti(rtti::Type const*);
GAME_IMPORT uint64_t GetTags(ttl::string_const<char>, ttl::string_const<char>) const;
GAME_IMPORT static cbs::PrefabComponent* CreatePrefabComponentBasedOnTargetRtti(rtti::Type const*);
GAME_IMPORT void ReleasePrefab(cbs::Prefab*);
private:
GAME_IMPORT void Release();
public:
GAME_IMPORT cbs::Prefab* LoadTextPrefab(ttl::string_const<char>, char const*);
private:
GAME_IMPORT void UnregisterPrefab(ttl::string_const<char>);
public:
GAME_IMPORT void SetLoadEditorSpecificPrefabs(bool);
GAME_IMPORT char const* GetPrefabTagsScript() const;
GAME_IMPORT void SetTags(ttl::string_const<char>, ttl::string_const<char>, uint32_t64_t);
GAME_IMPORT static void SanitizePrefabName(ttl::string_base<char>&);
GAME_IMPORT cbs::Prefab* PreloadPrefabFromRpack(ttl::string_const<char>, char const*, uint32_t);
private:
GAME_IMPORT void LoadDefaultPrefab();
public:
GAME_IMPORT cbs::Prefab* FindPrefab(ttl::string_const<char>) const;
private:
GAME_IMPORT void RegisterPrefab(cbs::Prefab*);
GAME_IMPORT cbs::Prefab* LoadPrefabFromFile(ttl::string_const<char>, bool*);
public:
GAME_IMPORT void ReleasePrefabsFromFolder(ttl::string_const<char>);
GAME_IMPORT void ReleaseCityBuilderGenericPrefabs(ttl::string_const<char>);
GAME_IMPORT static ttl::string_base<char> GetPrefabNameFromClass(CRTTI const*);
GAME_IMPORT void PrefabFromRpackHandleSetStreamingRoot(cbs::Prefab*);
GAME_IMPORT void SetVcsCheckFileAccessCallback(bool (*)(ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1> const&));
GAME_IMPORT std::unique_ptr<cbs::PrefabReloadMemento, std::default_delete<cbs::PrefabReloadMemento>> BeginPrefabReload(cbs::Prefab*);
GAME_IMPORT void OverrideInGameFlagForOfflineProcessing(bool);
GAME_IMPORT static cbs::PrefabElement* CreatePrefabElementBasedOnTargetRtti(CRTTI const*);
GAME_IMPORT PrefabManager();
GAME_IMPORT void Initialize();
GAME_IMPORT void DumpEntities() const;
GAME_IMPORT ttl::pair<cbs::Prefab*, bool> FindPrefabByNormalizedName(ttl::string_const<char>) const;
GAME_IMPORT static cbs::PrefabElement* CreatePrefabElement(rtti::Type const*);
private:
GAME_IMPORT static uint32_t64_t HashPrefabName(ttl::string_const<char>);
public:
GAME_IMPORT void GetPrefabs(ttl::vector<cbs::Prefab*, ttl::vector_allocators::heap_allocator<cbs::Prefab*>, 1>&) const;
GAME_IMPORT static cbs::PrefabComponent* CreatePrefabComponentBasedOnTargetRtti(CRTTI const*);
GAME_IMPORT cbs::Prefab* GetPrefab(ttl::string_const<char>, bool, bool*);
GAME_IMPORT void ReloadPrefabInPlace(cbs::Prefab&, char const*, uint32_t);
private:
GAME_IMPORT void TestValidateBinaryPresets();
GAME_IMPORT void RegisterPrefab(ttl::string_const<char>, cbs::Prefab*);
public:
GAME_IMPORT void FinishPrefabReload(cbs::Prefab*, cbs::Prefab*, std::unique_ptr<cbs::PrefabReloadMemento, std::default_delete<cbs::PrefabReloadMemento>>);
#pragma endregion
};
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT cbs::PrefabManager* g_PrefabManager;
GAME_IMPORT void GetPECHierarchyPath(ttl::span<cbs::PrefabEntityComponent const* const, 4294967295>, uint32_t, ttl::string_base<char>&);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPathView, cbs::CPcidPathView);
GAME_IMPORT void GatherSubtypeEntityInterfaces(ttl::set<CRTTI const*, ttl::less<CRTTI const*>, ttl::allocator>&, CRTTIField const*);
GAME_IMPORT bool CreateEntityFromPrefabDeferred(cbs::CPointer<cbs::CEntity>&, ttl::string_const<char>, ILevel*, mtx34 const&, PresetId, Replication::CreateObjectOptions, bool);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPath& &, cbs::CPcidPath const&);
GAME_IMPORT bool operator!=(cbs::CPointer<cbs::CEntity>, cbs::CEntityPointer);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPath const&, cbs::CPcidPathView);
GAME_IMPORT void GetEntityDebugHierarchyPath(cbs::CEntity const*, ttl::string_base<char>&);
GAME_IMPORT cbs::ComponentsPool& GetComponentsPool();
GAME_IMPORT CLevel* GetCLevel(cbs::WorldIndex);
GAME_IMPORT bool IsAnyAncestorAlwaysSpawned(cbs::CPointer<cbs::CEntity>);
GAME_IMPORT void GetPCIDHierarchyPath(ttl::span<cbs::PrefabEntityComponent const* const, 4294967295>, uint32_t, ttl::string_base<char>&);
GAME_IMPORT bool operator!=(cbs::CEntity const*, cbs::CEntityPointer);
GAME_IMPORT ILevel* GetILevel(cbs::WorldIndex);
GAME_IMPORT bool operator==(cbs::CPointer<cbs::CEntity>, cbs::CEntityPointer);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPathView, cbs::CPcidPath const&);
GAME_IMPORT IPhysicsManager* GetPhysicsManager(cbs::WorldIndex);
GAME_IMPORT bool GetPrefabEntityComponents(cbs::CEntity const*, ttl::vector<cbs::PrefabEntityComponent const*, ttl::vector_allocators::heap_allocator<cbs::PrefabEntityComponent const*>, 16>&);
GAME_IMPORT cbs::EntitySpawnOrigin GetEntitySpawnOrigin(cbs::CEntity const*);
GAME_IMPORT cbs::PrefabManager& GetPrefabManager();
GAME_IMPORT float GetTimeDelta(cbs::WorldIndex);
GAME_IMPORT ttl::string_base<char> GetEntityDebugInfoString(cbs::CEntity const*);
GAME_IMPORT cbs::CPointer<cbs::CEntity> CreateEntityFromPrefab(ttl::string_const<char>, ILevel*, mtx34 const&, ttl::string_const<char>, Replication::CreateObjectOptions, bool, bool);
GAME_IMPORT cbs::CPcidPath operator+(cbs::pcid_t, cbs::CPcidPath const&);
GAME_IMPORT cbs::EntitySpawnOrigin GetEntitySpawnOrigin(cbs::PrefabEntityComponent const*);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPath const&, cbs::pcid_t);
GAME_IMPORT ttl::string_base<char> GetSpawnContextDebugInfoString(SpawnContext const&);
GAME_IMPORT bool operator<(cbs::CPcidPath const&, cbs::CPcidPath const&);
GAME_IMPORT bool CreateEntityFromPrefabDeferred(cbs::CPointer<cbs::CEntity>&, ttl::string_const<char>, ILevel*, mtx34 const&, ttl::string_const<char>, Replication::CreateObjectOptions, bool, bool);
GAME_IMPORT cbs::CPointer<cbs::CEntity> CreateEntityFromPrefab(ttl::string_const<char>, ILevel*, mtx34 const&, PresetId, Replication::CreateObjectOptions, bool);
GAME_IMPORT bool operator==(cbs::CEntity const*, cbs::CEntityPointer);
GAME_IMPORT bool IsInDynamicRoot(cbs::CPointer<cbs::CEntity>, bool);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPath const&, cbs::CPcidPath const&);
GAME_IMPORT float GetTime(cbs::WorldIndex);
GAME_IMPORT cbs::CPointer<cbs::CEntity> CreateEntityFromPrefab(ttl::string_const<char>, SpawnContext&);
GAME_IMPORT bool operator==(cbs::CPcidPath const&, cbs::CPcidPath const&);
GAME_IMPORT cbs::EnumPropertyManager& GetEnumPropertyManager();
GAME_IMPORT bool CreateEntityFromPrefabDeferred(cbs::CPointer<cbs::CEntity>&, ttl::string_const<char>, SpawnContext&);
#pragma endregion
};

8
EGameSDK/include/EGSDK/Engine/parser.h Normal file
View File

@ -0,0 +1,8 @@
#pragma once
class parser {
public:
enum EVarType;
class writer;
class func_iterator;
};

28
EGameSDK/include/EGSDK/Engine/rtti.h Normal file
View File

@ -0,0 +1,28 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTI;
class CRTTIField;
class rtti {
public:
class IRttiFactory;
class Type {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT Type(char const*, rtti::IRttiFactory const&);
GAME_IMPORT char const* GetClassNameA() const;
GAME_IMPORT Type(char const*, rtti::IRttiFactory const&, char const*, int);
GAME_IMPORT void AddField(CRTTIField*);
GAME_IMPORT CRTTI const* GetNativeClass() const;
#pragma endregion
};
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT bool operator==(rtti::Type const&, CRTTI const*);
GAME_IMPORT bool operator!=(rtti::Type const&, CRTTI const*);
GAME_IMPORT bool operator==(CRTTI const*, rtti::Type const&);
GAME_IMPORT bool operator!=(CRTTI const*, rtti::Type const&);
#pragma endregion
};

39
EGameSDK/include/EGSDK/Engine/ttl.h
View File

@ -1,39 +0,0 @@
#pragma once
#include <cstdint>
namespace ttl {
namespace vector_allocators {
template <typename T>
class heap_allocator;
}
template <typename T>
class string_base;
template <>
class string_base<char> {
char* m_Buffer;
uint32_t m_Size;
uint32_t m_Capacity;
};
template <typename T>
class string_const;
template <typename T1, typename T2, size_t T3>
class vector;
template <typename T1, typename T2, typename T3, typename T4>
class map;
template <typename T1>
struct less;
class allocator;
template <typename T1, typename T2>
class list {
public:
class const_reverse_iterator;
};
}

4
EGameSDK/include/EGSDK/Engine/ttl/allocator.h Normal file
View File

@ -0,0 +1,4 @@
#pragma once
namespace ttl {
class allocator;
}

7
EGameSDK/include/EGSDK/Engine/ttl/char_traits.h Normal file
View File

@ -0,0 +1,7 @@
#pragma once
#include <cstdint>
namespace ttl {
template <typename T>
struct char_traits;
}

5
EGameSDK/include/EGSDK/Engine/ttl/function_ref.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
namespace ttl {
template <typename T>
class function_ref;
}

5
EGameSDK/include/EGSDK/Engine/ttl/less.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
namespace ttl {
template <typename T1>
struct less;
}

8
EGameSDK/include/EGSDK/Engine/ttl/list.h Normal file
View File

@ -0,0 +1,8 @@
#pragma once
namespace ttl {
template <typename T1, typename T2>
class list {
public:
class const_reverse_iterator;
};
}

5
EGameSDK/include/EGSDK/Engine/ttl/map.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
namespace ttl {
template <typename T1, typename T2, typename T3, typename T4>
class map;
}

4
EGameSDK/include/EGSDK/Engine/ttl/pstring.h Normal file
View File

@ -0,0 +1,4 @@
#pragma once
namespace ttl {
class pstring;
}

5
EGameSDK/include/EGSDK/Engine/ttl/set.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
namespace ttl {
template <typename T1, typename T2, typename T3>
class set;
}

14
EGameSDK/include/EGSDK/Engine/ttl/string_base.h Normal file
View File

@ -0,0 +1,14 @@
#pragma once
#include <cstdint>
namespace ttl {
template <typename T>
class string_base;
template <>
class string_base<char> {
char* m_Buffer;
uint32_t m_Size;
uint32_t m_Capacity;
};
}

5
EGameSDK/include/EGSDK/Engine/ttl/string_const.h Normal file
View File

@ -0,0 +1,5 @@
#pragma once
namespace ttl {
template <typename T>
class string_const;
}

7
EGameSDK/include/EGSDK/Engine/ttl/string_view_base.h Normal file
View File

@ -0,0 +1,7 @@
#pragma once
#include <cstdint>
namespace ttl {
template <typename T1, typename T2>
class string_view_base;
}

7
EGameSDK/include/EGSDK/Engine/ttl/vector.h Normal file
View File

@ -0,0 +1,7 @@
#pragma once
#include <cstdint>
namespace ttl {
template <typename T1, typename T2, size_t T3>
class vector;
}

7
EGameSDK/include/EGSDK/Engine/ttl/vector_allocators/heap_allocator.h Normal file
View File

@ -0,0 +1,7 @@
#pragma once
namespace ttl {
namespace vector_allocators {
template <typename T>
class heap_allocator;
}
}

38770
EGameSDK/proxies/engine_x64_rwdi/dllmain.cpp
View File

File diff suppressed because it is too large Load Diff

272
EGameSDK/proxies/engine_x64_rwdi/engine_x64_rwdi.vcxproj
View File

@ -1,272 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug_Release|Win32">
<Configuration>Debug_Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug_Release|x64">
<Configuration>Debug_Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{43D9B339-9A92-4D78-BD8E-5026ABFC8604}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>DllProxyTemplate</RootNamespace>
<ProjectName>engine_x64_rwdi</ProjectName>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug_Release|Win32'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug_Release|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug_Release|Win32'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug_Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<LinkIncremental>true</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<LinkIncremental>true</LinkIncremental>
<TargetName>$(ProjectName)</TargetName>
<GenerateManifest>false</GenerateManifest>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug_Release|Win32'">
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<TargetName>$(ProjectName)</TargetName>
<GenerateManifest>false</GenerateManifest>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug_Release|x64'">
<LinkIncremental>false</LinkIncremental>
<TargetName>$(ProjectName)</TargetName>
<OutDir>$(SolutionDir)$(Platform)\Debug\</OutDir>
<IntDir>$(Platform)\Debug\</IntDir>
<GenerateManifest>false</GenerateManifest>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>_SCL_SECURE_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_WINDOWS;_USRDLL;DllProxyTemplate_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
<ExceptionHandling>Async</ExceptionHandling>
<EnablePREfast>false</EnablePREfast>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<ModuleDefinitionFile>Forwarded.def</ModuleDefinitionFile>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level4</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>_WIN64;_AMD64;_SCL_SECURE_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;WIN32;_DEBUG;_WINDOWS;_USRDLL;engine_x64_rwdi_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
<ExceptionHandling>Async</ExceptionHandling>
<EnablePREfast>true</EnablePREfast>
<LanguageStandard>stdcpplatest</LanguageStandard>
<LanguageStandard_C>stdclatest</LanguageStandard_C>
<DebugInformationFormat>None</DebugInformationFormat>
<SupportJustMyCode>false</SupportJustMyCode>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>false</GenerateDebugInformation>
<ModuleDefinitionFile>
</ModuleDefinitionFile>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level4</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>_SCL_SECURE_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_WINDOWS;_USRDLL;DllProxyTemplate_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
<ExceptionHandling>Async</ExceptionHandling>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<EnablePREfast>true</EnablePREfast>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<ModuleDefinitionFile>Forwarded.def</ModuleDefinitionFile>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug_Release|Win32'">
<ClCompile>
<WarningLevel>Level4</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>_SCL_SECURE_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_WINDOWS;_USRDLL;DllProxyTemplate_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
<ExceptionHandling>Async</ExceptionHandling>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<EnablePREfast>true</EnablePREfast>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<ModuleDefinitionFile>Forwarded.def</ModuleDefinitionFile>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level4</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>_WIN64;_AMD64;_SCL_SECURE_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_WINDOWS;_USRDLL;engine_x64_rwdi_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
<ExceptionHandling>Async</ExceptionHandling>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<EnablePREfast>true</EnablePREfast>
<LanguageStandard>stdcpplatest</LanguageStandard>
<LanguageStandard_C>stdclatest</LanguageStandard_C>
<DebugInformationFormat>None</DebugInformationFormat>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<ModuleDefinitionFile>
</ModuleDefinitionFile>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug_Release|x64'">
<ClCompile>
<WarningLevel>Level4</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>_WIN64;_AMD64;_SCL_SECURE_NO_WARNINGS;_CRT_SECURE_NO_WARNINGS;WIN32;NDEBUG;_WINDOWS;_USRDLL;engine_x64_rwdi_EXPORTS;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<RuntimeLibrary>MultiThreaded</RuntimeLibrary>
<RuntimeTypeInfo>false</RuntimeTypeInfo>
<ExceptionHandling>Async</ExceptionHandling>
<FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>
<EnablePREfast>true</EnablePREfast>
<LanguageStandard>stdcpplatest</LanguageStandard>
<LanguageStandard_C>Default</LanguageStandard_C>
<DebugInformationFormat>None</DebugInformationFormat>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<ModuleDefinitionFile>
</ModuleDefinitionFile>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="dllmain.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

6
EGameSDK/proxies/engine_x64_rwdi/engine_x64_rwdi.vcxproj.filters
View File

@ -1,6 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<ClCompile Include="dllmain.cpp" />
</ItemGroup>
</Project>

1
EGameSDK/proxies/engine_x64_rwdi/scripts/.env
View File

@ -1 +0,0 @@
PYTHONPATH=%PYTHONPATH%;D:\Program Files\IDA Pro 8.3\python\3

4
EGameSDK/proxies/engine_x64_rwdi/scripts/ExportClassToCPPH.json
View File

@ -1,4 +0,0 @@
{
"PROJECT_INCLUDES_PATH": "D:\\PROJECTS\\Visual Studio\\EGameSDK\\EGameSDK\\include",
"OUTPUT_PATH": "D:\\PROJECTS\\Visual Studio\\EGameSDK\\EGameSDK\\proxies\\engine_x64_rwdi\\scripts"
}

4
EGameTools/EGameTools.vcxproj
View File

@ -157,7 +157,7 @@
</OptimizeReferences>
<EnableCOMDATFolding>
</EnableCOMDATFolding>
<AdditionalLibraryDirectories>..\EGameSDK\deps\MinHook\lib;deps\freetype\lib;$(SolutionDir)$(Platform)\$(Configuration);</AdditionalLibraryDirectories>
<AdditionalLibraryDirectories>..\EGameSDK\deps\MinHook\lib;deps\freetype\lib;..\EGameSDK\deps\game_libs;</AdditionalLibraryDirectories>
<AssemblyDebug>true</AssemblyDebug>
<ImportLibrary />
<FixedBaseAddress>
@ -192,7 +192,7 @@
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>DebugFull</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<AdditionalLibraryDirectories>..\EGameSDK\deps\MinHook\lib;deps\freetype\lib;$(SolutionDir)$(Platform)\$(Configuration);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalLibraryDirectories>..\EGameSDK\deps\MinHook\lib;deps\freetype\lib;..\EGameSDK\deps\game_libs;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
<AdditionalDependencies>DbgHelp.lib;Version.lib;EGameSDK.lib;libMinHook-x64-v141-mdd.lib;engine_x64_rwdi.lib;freetype-md.lib;$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
<ImportLibrary />
<AdditionalOptions>/NOIMPLIB /NOEXP %(AdditionalOptions)</AdditionalOptions>

66
EGameSDK/proxies/engine_x64_rwdi/scripts/ExportClassToCPPH.py → _IDAScripts/ExportClassToCPPH.py
View File

@ -788,17 +788,38 @@ def ExportClassHeader(targetClass: ClassName):
# UI Integration
# -----------------------------------------------------------------------------
def SetConfigVars(settings):
Config.PROJECT_INCLUDES_PATH = settings["PROJECT_INCLUDES_PATH"]
Config.OUTPUT_PATH = settings["OUTPUT_PATH"]
Config.LAST_CLICKED_RADIO = settings["LAST_CLICKED_RADIO"]
Config.HEADER_OUTPUT_PATH = os.path.join(Config.OUTPUT_PATH, "generated")
Config.CACHE_OUTPUT_PATH = os.path.join(Config.OUTPUT_PATH, "cache")
Config.PARSED_VARS_CACHE_FILENAME = os.path.join(Config.CACHE_OUTPUT_PATH, "parsedClassVarsByClass.cache")
Config.PARSED_FUNCS_CACHE_FILENAME = os.path.join(Config.CACHE_OUTPUT_PATH, "parsedFuncsByClass.cache")
# Load settings from file
def load_settings():
def LoadConfig():
if os.path.exists(CONFIG_FILE):
with open(CONFIG_FILE, "r") as f:
return json.load(f)
loadedJson = json.load(f)
SetConfigVars(loadedJson)
return loadedJson
return Config.DEFAULT_CONFIG
# Save settings to file
def save_settings(settings):
def SaveConfig(settings = {}):
if not settings:
settings = {
"PROJECT_INCLUDES_PATH": Config.PROJECT_INCLUDES_PATH,
"OUTPUT_PATH": Config.OUTPUT_PATH,
"LAST_CLICKED_RADIO": Config.LAST_CLICKED_RADIO
}
with open(CONFIG_FILE, "w") as f:
json.dump(settings, f, indent=4)
SetConfigVars(settings)
class SettingsDialog(ida_kernwin.Form):
def __init__(self, current_config):
@ -820,7 +841,8 @@ Modify the paths below:
def GetValues(self):
return {
"PROJECT_INCLUDES_PATH": self.i_project_path.value,
"OUTPUT_PATH": self.i_output_path.value
"OUTPUT_PATH": self.i_output_path.value,
"LAST_CLICKED_RADIO": Config.LAST_CLICKED_RADIO
}
def OnFormChange(self, fid):
@ -846,31 +868,36 @@ Export Class to C++ Header
def OnFormChange(self, fid):
return 1 # Required for form functionality
def open_settings_dialog():
def OpenSettingsDlg():
"""Opens the Settings Dialog and returns to Main Dialog on Cancel"""
settings = load_settings()
settings = LoadConfig()
settingsDlg = SettingsDialog(settings)
settingsDlg.Compile()
result = settingsDlg.Execute()
if result == 1: # Save clicked
new_settings = settingsDlg.GetValues()
save_settings(new_settings) # Save new settings to file
newSettings = settingsDlg.GetValues()
SaveConfig(newSettings) # Save new settings to file
print("[INFO] Settings saved successfully!")
settingsDlg.Free()
# Always return to the main dialog after closing settings
open_main_dialog()
OpenMainDlg()
def open_main_dialog():
def OpenMainDlg():
"""Reopens the Main Dialog"""
LoadConfig()
mainDlg = MainDialog()
mainDlg.Compile()
mainDlg.radioGroup.value = Config.LAST_CLICKED_RADIO
result = mainDlg.Execute()
if result == 1: # OK clicked
selectedOption = mainDlg.radioGroup.value
Config.LAST_CLICKED_RADIO = selectedOption
SaveConfig()
if selectedOption == 0:
print("[INFO] Update Project Code selected!")
@ -884,7 +911,7 @@ def open_main_dialog():
ExportClassHeader(ClassName(targetClassName))
elif selectedOption == 2:
print("[INFO] Settings selected!")
open_settings_dialog() # Open settings when selected
OpenSettingsDlg() # Open settings when selected
else:
print("[INFO] User clicked Cancel. No action taken.")
@ -892,7 +919,7 @@ def open_main_dialog():
def Main():
"""Main entry point for the script."""
open_main_dialog()
OpenMainDlg()
# Reload modules to apply any changes
@ -904,21 +931,6 @@ def Main():
importlib.reload(ExportClassToCPPH.Config)
importlib.reload(ExportClassToCPPH.Utils)
# def Main():
# """Main entry point for the script."""
# ProcessExistingHeaders()
# # Ask user for target class
# #targetClass = ida_kernwin.ask_str("IModelObject", 0, "Enter target class name (supports namespaces and templates):")
# # targetClassName: str = "CLevel"
# # if not targetClassName:
# # print("No target class specified. Aborting.")
# # return
# # targetClass: ClassName = ClassName(targetClassName)
# # breakpoint()
# # ExportClassHeader(targetClass)
# importlib.reload(ExportClassToCPPH.ClassDefs)
# -----------------------------------------------------------------------------
# IDA plugin integration
# -----------------------------------------------------------------------------

0
EGameSDK/proxies/engine_x64_rwdi/scripts/ExportClassToCPPH/ClassDefs.py → _IDAScripts/ExportClassToCPPH/ClassDefs.py
View File

7
EGameSDK/proxies/engine_x64_rwdi/scripts/ExportClassToCPPH/Config.py → _IDAScripts/ExportClassToCPPH/Config.py
View File

@ -1,14 +1,17 @@
import os
INTERNAL_SCRIPT_NAME = "ExportClassToCPPH"
PROJECT_INCLUDES_PATH = r"D:\PROJECTS\Visual Studio\EGameSDK\EGameSDK\include"
OUTPUT_PATH = r"D:\PROJECTS\Visual Studio\EGameSDK\EGameSDK\proxies\engine_x64_rwdi\scripts"
OUTPUT_PATH = r"D:\PROJECTS\Visual Studio\EGameSDK\_IDAScripts"
HEADER_OUTPUT_PATH = os.path.join(OUTPUT_PATH, "generated")
CACHE_OUTPUT_PATH = os.path.join(OUTPUT_PATH, "cache")
PARSED_VARS_CACHE_FILENAME = os.path.join(CACHE_OUTPUT_PATH, "parsedClassVarsByClass.cache")
PARSED_FUNCS_CACHE_FILENAME = os.path.join(CACHE_OUTPUT_PATH, "parsedFuncsByClass.cache")
LAST_CLICKED_RADIO = 0
DEFAULT_CONFIG = {
"PROJECT_INCLUDES_PATH": PROJECT_INCLUDES_PATH,
"OUTPUT_PATH": OUTPUT_PATH
"OUTPUT_PATH": OUTPUT_PATH,
"LAST_CLICKED_RADIO": LAST_CLICKED_RADIO,
}

0
EGameSDK/proxies/engine_x64_rwdi/scripts/ExportClassToCPPH/Utils.py → _IDAScripts/ExportClassToCPPH/Utils.py
View File

0
EGameSDK/proxies/engine_x64_rwdi/scripts/ExportClassToCPPH/__init__.py → _IDAScripts/ExportClassToCPPH/__init__.py
View File

0
EGameSDK/proxies/engine_x64_rwdi/scripts/RTTIExtractorPlugin.py → _IDAScripts/RTTIExtractorPlugin.py
View File

123
_IDAScripts/generated/CRTTI-unclean.h Normal file
View File

@ -0,0 +1,123 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTI {
#pragma region GENERATED by ExportClassToCPPH.py
protected:
GAME_IMPORT static bool s_CheckDuplicated;
public:
VIRTUAL_CALL(0, CRTTI *__fastcall, sub_11D3F0, (char a1), a1);
GAME_IMPORT virtual void ReleaseUnusedMemory();
GAME_IMPORT virtual void InitializeRttiReplication();
VIRTUAL_CALL(3, void __fastcall, SetPlatform, ());
VIRTUAL_CALL(4, __int64, RunUnitTests, ());
VIRTUAL_CALL(5, __int64, _RunUnitTests1, ());
VIRTUAL_CALL(6, __int64, _RunUnitTests2, ());
protected:
GAME_IMPORT virtual struct CRTTI::SEditorData * CreateEditorData();
public:
GAME_IMPORT virtual class ttl::string_base<char> ClassWriterCompare(class CRTTI const *, class CRTTI const *, class CRTTI const &) const;
VIRTUAL_CALL(9, bool, updateRttiParams, ());
GAME_IMPORT CRTTI(class ClassReaderResolve const &);
GAME_IMPORT void HideField(char const *);
GAME_IMPORT bool FromClassOrInterface(class rtti::Type const *) const;
GAME_IMPORT bool FromEngineClass(class CRTTI const *) const;
GAME_IMPORT bool ParseInfoString(char const *);
GAME_IMPORT bool FromClassOrInterface(class CRTTI const *) const;
GAME_IMPORT class CRTTIField const * FindRenamedField(char const *) const;
GAME_IMPORT CRTTI(char const *, int, void (*)(class CRTTI *), class CRTTI *, class CRTTI const *, class IScriptManager *, bool, bool, bool, int, enum EMem::TYPE, bool);
GAME_IMPORT void RemoveField(class CRTTIField const *);
GAME_IMPORT void GetFieldsToEditUnsorted(class ttl::list<class CRTTIField const *, class ttl::allocator> &) const;
GAME_IMPORT class CRTTI & operator=(class CRTTI const &);
GAME_IMPORT void GetAllFields(class ttl::vector<class CRTTIField const *, class ttl::vector_allocators::heap_allocator<class CRTTIField const *>, 64> &) const;
GAME_IMPORT struct CRTTI::SEditorData & EditorData();
GAME_IMPORT bool FromEngineClass(int) const;
GAME_IMPORT class CRTTIField const * FindFieldIncludingAliases(char const *) const;
GAME_IMPORT void InitializeRttiSerialization();
GAME_IMPORT void ClearClassFlags(enum ERTTIClassFlags);
GAME_IMPORT static void CheckDuplicated(bool);
GAME_IMPORT void SetForcedToSaveField(class CRTTIField const &, bool);
GAME_IMPORT bool FromClass(class rtti::Type const &) const;
GAME_IMPORT void UnhideField(char const *);
GAME_IMPORT void ResolveMyAndBaseFields();
GAME_IMPORT bool IsAbstract() const;
GAME_IMPORT void AddExternalField(class CRTTIField const *);
GAME_IMPORT void CreateGuiGameDataEventDispatcher();
GAME_IMPORT class cbs::msg::RttiMessageDispatcher const * FindMessageDispatcherForPipe(unsigned __int64) const;
GAME_IMPORT class CRTTIField const * FindFieldAtOffset(unsigned int) const;
GAME_IMPORT void SetPrefabName(class ttl::string_base<char> const &);
GAME_IMPORT bool CopyFields(class CRTTIObject *, class CRTTIObject const *, bool) const;
GAME_IMPORT class CRTTI const * GetBaseClass(class CRTTI const *) const;
GAME_IMPORT bool IsSetFieldForcedToSave(class CRTTIField const &) const;
GAME_IMPORT class CRTTI const * GetProxyComponentClass() const;
GAME_IMPORT void AddMethod(class CRTTIMethod const *);
GAME_IMPORT bool IsImplementingInterface(int) const;
GAME_IMPORT class ttl::string_const<char> GetClassNameWithoutNamespace() const;
GAME_IMPORT class Net::Repl::CRttiInfo const * ToIRtti() const;
GAME_IMPORT bool IsReplicationPossible() const;
GAME_IMPORT void AddField(class CRTTIField *);
GAME_IMPORT class CRTTIField const * FindField(class ttl::pstring) const;
GAME_IMPORT CRTTI(class ttl::string_const<char>, class CRTTI *, enum EMem::TYPE);
GAME_IMPORT class CRTTIDebugVis const & GetVis() const;
GAME_IMPORT bool IsFieldHidden(class CRTTIField const *) const;
GAME_IMPORT void AddImplementation(class CRTTI const *);
GAME_IMPORT CRTTI(class CRTTI const &);
GAME_IMPORT bool FromAbstractClass() const;
GAME_IMPORT class CRTTI const * GetNativeClass() const;
GAME_IMPORT void CreateRttiSerialization();
GAME_IMPORT void ResolveGuiGameDataEventDispatchers();
GAME_IMPORT class cbs::msg::RttiMessageDispatcher * GetMessageDispatcherForPipe(unsigned __int64);
GAME_IMPORT bool FromClassByName(char const *) const;
GAME_IMPORT void CopyGuiGameDataEventDispatcher(class CRTTI const *);
GAME_IMPORT bool FromClassOrInterfaceByName(char const *) const;
GAME_IMPORT class CRTTIField const * FindRenamedField(class ttl::string_view_base<char, struct ttl::char_traits<char>>) const;
GAME_IMPORT bool FromClass(int) const;
GAME_IMPORT class Net::Repl::Rtti::Serializer const * RttiSerializer() const;
GAME_IMPORT void PreInitializeRttiSerialization();
GAME_IMPORT bool RequiresMatrixChangedNotifications() const;
GAME_IMPORT bool ArePresetsLoaded() const;
GAME_IMPORT class CRTTIField const * FindFieldIncludingAliases(class ttl::string_view_base<char, struct ttl::char_traits<char>>) const;
GAME_IMPORT bool IsExactClass(class rtti::Type const *) const;
GAME_IMPORT void ResolvePStorageAndSaveGameFields();
GAME_IMPORT void ResolveHiddenFields() const;
GAME_IMPORT void Shutdown();
GAME_IMPORT void ReResolveMyAndBaseFields();
GAME_IMPORT bool Initialize();
GAME_IMPORT bool IsReplicated() const;
GAME_IMPORT bool IsExactClass(class CRTTI const *) const;
GAME_IMPORT bool HasVis() const;
GAME_IMPORT bool FromClass(class rtti::Type const *) const;
GAME_IMPORT void SetSystem(class cbs::CSystemBase *);
GAME_IMPORT bool FromClassOrInterface(int) const;
GAME_IMPORT bool IsImplementingInterface(class CRTTI const *) const;
GAME_IMPORT void AddInterface(class CRTTI const *);
GAME_IMPORT bool FromEngineClass(class rtti::Type const &) const;
GAME_IMPORT class CRTTIField const * FindFieldIncludingAliases(class ttl::pstring) const;
GAME_IMPORT void GetFieldsToEdit(class ttl::list<class CRTTIField const *, class ttl::allocator> &) const;
GAME_IMPORT class CRTTIField const * FindField(class ttl::string_view_base<char, struct ttl::char_traits<char>>) const;
GAME_IMPORT void SetPresetsLoaded(bool) const;
GAME_IMPORT class CRTTIField const * FindField(char const *) const;
GAME_IMPORT class CRTTIMethod const * FindMethod(char const *) const;
GAME_IMPORT class cbs::CSystemBase * GetSystem() const;
GAME_IMPORT class CRTTIField const * FindField(class ttl::pstring, unsigned short &) const;
GAME_IMPORT bool ExchangePointerFields(class CRTTIObject *, class CRTTIObject *) const;
GAME_IMPORT char const * GetClassNameA() const;
GAME_IMPORT bool FromClass(class CRTTI const *) const;
GAME_IMPORT bool IsObsolete() const;
private:
GAME_IMPORT void PrepareReplicatedFields();
public:
GAME_IMPORT bool IsExactClass(int) const;
GAME_IMPORT void SetClassFlags(enum ERTTIClassFlags);
GAME_IMPORT class gui::CGameDataEventDispatcher * GetGuiGameDataEventDispatcher() const;
GAME_IMPORT class CRTTIField const * FindRenamedField(class ttl::pstring) const;
GAME_IMPORT void OverrideField(char const *);
GAME_IMPORT struct CRTTI::SEditorData const & GetEditorData() const;
GAME_IMPORT void ClearFieldsList();
GAME_IMPORT enum EMem::TYPE GetMemCategory() const;
GAME_IMPORT bool CopyPointerFields(class CRTTIObject *, class CRTTIObject const *) const;
GAME_IMPORT bool IsClassFlag(enum ERTTIClassFlags) const;
#pragma endregion
};

123
_IDAScripts/generated/CRTTI.h Normal file
View File

@ -0,0 +1,123 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTI {
#pragma region GENERATED by ExportClassToCPPH.py
protected:
GAME_IMPORT static bool s_CheckDuplicated;
public:
VIRTUAL_CALL(0, CRTTI*, sub_11D3F0, (char a1), a1);
GAME_IMPORT virtual void ReleaseUnusedMemory();
GAME_IMPORT virtual void InitializeRttiReplication();
VIRTUAL_CALL(3, void, SetPlatform, ());
VIRTUAL_CALL(4, int64_t, RunUnitTests, ());
VIRTUAL_CALL(5, int64_t, _RunUnitTests1, ());
VIRTUAL_CALL(6, int64_t, _RunUnitTests2, ());
protected:
GAME_IMPORT virtual CRTTI::SEditorData* CreateEditorData();
public:
GAME_IMPORT virtual ttl::string_base<char> ClassWriterCompare(CRTTI const*, CRTTI const*, CRTTI const&) const;
VIRTUAL_CALL(9, bool, updateRttiParams, ());
GAME_IMPORT CRTTI(ClassReaderResolve const&);
GAME_IMPORT void HideField(char const*);
GAME_IMPORT bool FromClassOrInterface(rtti::Type const*) const;
GAME_IMPORT bool FromEngineClass(CRTTI const*) const;
GAME_IMPORT bool ParseInfoString(char const*);
GAME_IMPORT bool FromClassOrInterface(CRTTI const*) const;
GAME_IMPORT CRTTIField const* FindRenamedField(char const*) const;
GAME_IMPORT CRTTI(char const*, int, void (* )( CRTTI* ), CRTTI*, CRTTI const*, IScriptManager*, bool, bool, bool, int, EMem::TYPE, bool);
GAME_IMPORT void RemoveField(CRTTIField const*);
GAME_IMPORT void GetFieldsToEditUnsorted(ttl::list<CRTTIField const*, ttl::allocator>&) const;
GAME_IMPORT CRTTI& operator=(CRTTI const&);
GAME_IMPORT void GetAllFields(ttl::vector<CRTTIField const*, ttl::vector_allocators::heap_allocator<CRTTIField const*>, 64>&) const;
GAME_IMPORT CRTTI::SEditorData& EditorData();
GAME_IMPORT bool FromEngineClass(int) const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(char const*) const;
GAME_IMPORT void InitializeRttiSerialization();
GAME_IMPORT void ClearClassFlags(ERTTIClassFlags);
GAME_IMPORT static void CheckDuplicated(bool);
GAME_IMPORT void SetForcedToSaveField(CRTTIField const&, bool);
GAME_IMPORT bool FromClass(rtti::Type const&) const;
GAME_IMPORT void UnhideField(char const*);
GAME_IMPORT void ResolveMyAndBaseFields();
GAME_IMPORT bool IsAbstract() const;
GAME_IMPORT void AddExternalField(CRTTIField const*);
GAME_IMPORT void CreateGuiGameDataEventDispatcher();
GAME_IMPORT cbs::msg::RttiMessageDispatcher const* FindMessageDispatcherForPipe(uint32_t64_t) const;
GAME_IMPORT CRTTIField const* FindFieldAtOffset(uint32_t) const;
GAME_IMPORT void SetPrefabName(ttl::string_base<char> const&);
GAME_IMPORT bool CopyFields(CRTTIObject*, CRTTIObject const*, bool) const;
GAME_IMPORT CRTTI const* GetBaseClass(CRTTI const*) const;
GAME_IMPORT bool IsSetFieldForcedToSave(CRTTIField const&) const;
GAME_IMPORT CRTTI const* GetProxyComponentClass() const;
GAME_IMPORT void AddMethod(CRTTIMethod const*);
GAME_IMPORT bool IsImplementingInterface(int) const;
GAME_IMPORT ttl::string_const<char> GetClassNameWithoutNamespace() const;
GAME_IMPORT Net::Repl::CRttiInfo const* ToIRtti() const;
GAME_IMPORT bool IsReplicationPossible() const;
GAME_IMPORT void AddField(CRTTIField*);
GAME_IMPORT CRTTIField const* FindField(ttl::pstring) const;
GAME_IMPORT CRTTI(ttl::string_const<char>, CRTTI*, EMem::TYPE);
GAME_IMPORT CRTTIDebugVis const& GetVis() const;
GAME_IMPORT bool IsFieldHidden(CRTTIField const*) const;
GAME_IMPORT void AddImplementation(CRTTI const*);
GAME_IMPORT CRTTI(CRTTI const&);
GAME_IMPORT bool FromAbstractClass() const;
GAME_IMPORT CRTTI const* GetNativeClass() const;
GAME_IMPORT void CreateRttiSerialization();
GAME_IMPORT void ResolveGuiGameDataEventDispatchers();
GAME_IMPORT cbs::msg::RttiMessageDispatcher* GetMessageDispatcherForPipe(uint32_t64_t);
GAME_IMPORT bool FromClassByName(char const*) const;
GAME_IMPORT void CopyGuiGameDataEventDispatcher(CRTTI const*);
GAME_IMPORT bool FromClassOrInterfaceByName(char const*) const;
GAME_IMPORT CRTTIField const* FindRenamedField(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT bool FromClass(int) const;
GAME_IMPORT Net::Repl::Rtti::Serializer const* RttiSerializer() const;
GAME_IMPORT void PreInitializeRttiSerialization();
GAME_IMPORT bool RequiresMatrixChangedNotifications() const;
GAME_IMPORT bool ArePresetsLoaded() const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT bool IsExactClass(rtti::Type const*) const;
GAME_IMPORT void ResolvePStorageAndSaveGameFields();
GAME_IMPORT void ResolveHiddenFields() const;
GAME_IMPORT void Shutdown();
GAME_IMPORT void ReResolveMyAndBaseFields();
GAME_IMPORT bool Initialize();
GAME_IMPORT bool IsReplicated() const;
GAME_IMPORT bool IsExactClass(CRTTI const*) const;
GAME_IMPORT bool HasVis() const;
GAME_IMPORT bool FromClass(rtti::Type const*) const;
GAME_IMPORT void SetSystem(cbs::CSystemBase*);
GAME_IMPORT bool FromClassOrInterface(int) const;
GAME_IMPORT bool IsImplementingInterface(CRTTI const*) const;
GAME_IMPORT void AddInterface(CRTTI const*);
GAME_IMPORT bool FromEngineClass(rtti::Type const&) const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(ttl::pstring) const;
GAME_IMPORT void GetFieldsToEdit(ttl::list<CRTTIField const*, ttl::allocator>&) const;
GAME_IMPORT CRTTIField const* FindField(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT void SetPresetsLoaded(bool) const;
GAME_IMPORT CRTTIField const* FindField(char const*) const;
GAME_IMPORT CRTTIMethod const* FindMethod(char const*) const;
GAME_IMPORT cbs::CSystemBase* GetSystem() const;
GAME_IMPORT CRTTIField const* FindField(ttl::pstring, unsigned short&) const;
GAME_IMPORT bool ExchangePointerFields(CRTTIObject*, CRTTIObject*) const;
GAME_IMPORT char const* GetClassNameA() const;
GAME_IMPORT bool FromClass(CRTTI const*) const;
GAME_IMPORT bool IsObsolete() const;
private:
GAME_IMPORT void PrepareReplicatedFields();
public:
GAME_IMPORT bool IsExactClass(int) const;
GAME_IMPORT void SetClassFlags(ERTTIClassFlags);
GAME_IMPORT gui::CGameDataEventDispatcher* GetGuiGameDataEventDispatcher() const;
GAME_IMPORT CRTTIField const* FindRenamedField(ttl::pstring) const;
GAME_IMPORT void OverrideField(char const*);
GAME_IMPORT CRTTI::SEditorData const& GetEditorData() const;
GAME_IMPORT void ClearFieldsList();
GAME_IMPORT EMem::TYPE GetMemCategory() const;
GAME_IMPORT bool CopyPointerFields(CRTTIObject*, CRTTIObject const*) const;
GAME_IMPORT bool IsClassFlag(ERTTIClassFlags) const;
#pragma endregion
};

18
_IDAScripts/generated/CRTTIDebugVis-unclean.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIDebugVis {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, _QWORD *__fastcall, sub_C5A630, (char a1), a1);
VIRTUAL_CALL(1, __int64 __fastcall, sub_CC4480, ());
VIRTUAL_CALL(2, void __fastcall, sub_CAEF40, ());
VIRTUAL_CALL(3, unsigned __int64 __fastcall, sub_C5D570, (char a1, __int64 a2, __int64 a3, int a4, char a5), a1, a2, a3, a4, a5);
VIRTUAL_CALL(4, unsigned __int64 __fastcall, sub_C5D470, (char a1, __int64 a2, __int64 a3, int a4, char a5), a1, a2, a3, a4, a5);
VIRTUAL_CALL(5, unsigned __int64 __fastcall, sub_C5D630, (char a1, const char* a2, __int64 a3, int a4, char a5), a1, a2, a3, a4, a5);
VIRTUAL_CALL(6, unsigned __int64 __fastcall, sub_C5D780, (char a1, const char* a2, __int64 a3, __int64 a4, int a5, char a6), a1, a2, a3, a4, a5, a6);
VIRTUAL_CALL(7, unsigned __int64 __fastcall, sub_C5D330, (char a1, __int64 a2, const char* a3, __int64 a4, int a5, char a6), a1, a2, a3, a4, a5, a6);
VIRTUAL_CALL(8, unsigned __int64 __fastcall, sub_C5E6E0, (char a1, const char* a2, __int64 a3, char a4), a1, a2, a3, a4);
VIRTUAL_CALL(9, unsigned __int64 __fastcall, sub_C5C800, (char a1, const char* a2, __int64 a3, char a4), a1, a2, a3, a4);
#pragma endregion
};

18
_IDAScripts/generated/CRTTIDebugVis.h Normal file
View File

@ -0,0 +1,18 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIDebugVis {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_C5A630, (char a1), a1);
VIRTUAL_CALL(1, int64_t, sub_CC4480, ());
VIRTUAL_CALL(2, void, sub_CAEF40, ());
VIRTUAL_CALL(3, uint32_t64_t, sub_C5D570, (char a1, int64_t a2, int64_t a3, int a4, char a5), a1, a2, a3, a4, a5);
VIRTUAL_CALL(4, uint32_t64_t, sub_C5D470, (char a1, int64_t a2, int64_t a3, int a4, char a5), a1, a2, a3, a4, a5);
VIRTUAL_CALL(5, uint32_t64_t, sub_C5D630, (char a1, const char* a2, int64_t a3, int a4, char a5), a1, a2, a3, a4, a5);
VIRTUAL_CALL(6, uint32_t64_t, sub_C5D780, (char a1, const char* a2, int64_t a3, int64_t a4, int a5, char a6), a1, a2, a3, a4, a5, a6);
VIRTUAL_CALL(7, uint32_t64_t, sub_C5D330, (char a1, int64_t a2, const char* a3, int64_t a4, int a5, char a6), a1, a2, a3, a4, a5, a6);
VIRTUAL_CALL(8, uint32_t64_t, sub_C5E6E0, (char a1, const char* a2, int64_t a3, char a4), a1, a2, a3, a4);
VIRTUAL_CALL(9, uint32_t64_t, sub_C5C800, (char a1, const char* a2, int64_t a3, char a4), a1, a2, a3, a4);
#pragma endregion
};

106
_IDAScripts/generated/CRTTIField-unclean.h Normal file
View File

@ -0,0 +1,106 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIField {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, CRTTIField *__fastcall, sub_119B50, (char a1), a1);
VIRTUAL_CALL(1, __int64, RunUnitTests, ());
GAME_IMPORT virtual struct CRTTIField::Variant * GetFieldDefaultVariantPtr(class CRTTI const *) const;
VIRTUAL_CALL(3, __int64, _RunUnitTests1, ());
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
VIRTUAL_CALL(7, bool, updateRttiParams, ());
GAME_IMPORT virtual bool GetValidValuesEditor(class CRTTIObject *, class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &, class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &) const;
virtual void _StrippedVFunc4() = 0;
virtual void _StrippedVFunc5() = 0;
VIRTUAL_CALL(11, __int64, _RunUnitTests2, ());
VIRTUAL_CALL(12, bool, _updateRttiParams1, ());
virtual void _StrippedVFunc6() = 0;
virtual void _StrippedVFunc7() = 0;
virtual void _StrippedVFunc8() = 0;
VIRTUAL_CALL(16, __int64, _RunUnitTests3, ());
GAME_IMPORT virtual bool Copy(class CRTTIObject *, class CRTTIObject const *) const;
GAME_IMPORT virtual bool Exchange(class CRTTIObject *, class CRTTIObject *) const;
VIRTUAL_CALL(19, bool, _updateRttiParams2, ());
GAME_IMPORT virtual class ttl::string_base<char> const ClampString(char const *) const;
VIRTUAL_CALL(21, __int64, _RunUnitTests4, ());
GAME_IMPORT virtual bool AddVirtualFieldDestination(class CRTTIField const *, unsigned int, class ttl::string_base<char> *);
VIRTUAL_CALL(23, bool, _updateRttiParams3, ());
VIRTUAL_CALL(24, __int64, _RunUnitTests5, ());
VIRTUAL_CALL(25, void __fastcall, SetPlatform, ());
GAME_IMPORT virtual bool OverwriteVirtualFieldFlags(class CRTTIField const *);
VIRTUAL_CALL(27, __int64, _RunUnitTests6, ());
VIRTUAL_CALL(28, void __fastcall, _SetPlatform1, ());
VIRTUAL_CALL(29, __int64, _RunUnitTests7, ());
VIRTUAL_CALL(30, void __fastcall, _SetPlatform2, ());
GAME_IMPORT virtual void WriteToDom(class dom::IWriter &, class CRTTIObject const *) const;
GAME_IMPORT virtual void ReadFromDom(class dom::IReader::Array const &, class CRTTIObject *) const;
protected:
GAME_IMPORT virtual bool ParseInitToken(char, char const *);
GAME_IMPORT virtual void ParseFlagsTokenData(char const *, unsigned __int64);
GAME_IMPORT virtual void ParseEditorFlagsTokenData(enum ERTTIEditFlags &, char const *, unsigned __int64);
public:
GAME_IMPORT virtual class ttl::string_base<char> ClassWriterCompare(class CRTTI const *, class CRTTI const *, class CRTTIField const &) const;
GAME_IMPORT CRTTIField(class ClassReaderResolve const &);
GAME_IMPORT enum ERTTIType GetType() const;
GAME_IMPORT bool IsMessagePipeIn() const;
GAME_IMPORT bool HasIndividualSize() const;
GAME_IMPORT bool IsUuidRefFlagSet() const;
GAME_IMPORT bool IsEditable() const;
GAME_IMPORT CRTTIField();
GAME_IMPORT bool Initialize(class ttl::string_const<char>, class ttl::string_const<char>, unsigned char, void (*)(class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &, class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &));
GAME_IMPORT bool IsPStorageField() const;
GAME_IMPORT bool IsPropertyIn() const;
GAME_IMPORT bool HasStaticSize() const;
GAME_IMPORT bool IsGamescript() const;
GAME_IMPORT bool IsVirtual() const;
GAME_IMPORT char const * GetName() const;
GAME_IMPORT void GetDefaultValue(class CRTTI const *, struct CRTTIField::Variant &) const;
GAME_IMPORT bool IsFieldInternal() const;
protected:
GAME_IMPORT void SetDefaultValueInternal(class CRTTI const *, struct CRTTIField::Variant *);
public:
GAME_IMPORT void SetExposed(bool) const;
GAME_IMPORT bool IsProperty() const;
GAME_IMPORT bool HasDefaultValue() const;
GAME_IMPORT bool IsMessagePipe() const;
GAME_IMPORT bool IsExposed() const;
GAME_IMPORT bool IsPresetFlagSet() const;
GAME_IMPORT class ttl::pstring GetSubtype() const;
GAME_IMPORT void SetExpanded(bool) const;
protected:
GAME_IMPORT void SetVirtualFlag();
GAME_IMPORT static bool EatWhiteChars(char * &);
GAME_IMPORT void SetPropertyFlag();
public:
GAME_IMPORT bool IsPipeInternal() const;
GAME_IMPORT void SetPipeInternal(bool) const;
GAME_IMPORT bool IsReplicated() const;
GAME_IMPORT void RestoreDefaultValue(class CRTTI const *, class CRTTIObject *);
GAME_IMPORT bool IsQuestField() const;
GAME_IMPORT void SetGamescript(bool) const;
GAME_IMPORT char const * GetPreviousName() const;
GAME_IMPORT bool IsSaveGameField() const;
GAME_IMPORT bool IsSelfUuidFlagSet() const;
protected:
GAME_IMPORT char const * ExtractClassName(class CRTTI const *) const;
public:
GAME_IMPORT void SetEditable(bool) const;
GAME_IMPORT bool IsPropertyOut() const;
GAME_IMPORT bool HasDynamicSize() const;
GAME_IMPORT bool IsMessagePipeOut() const;
protected:
GAME_IMPORT void SetPrecision(int);
public:
GAME_IMPORT CRTTIField(class CRTTIField const &);
GAME_IMPORT void SetPresetFlag(bool) const;
GAME_IMPORT bool CmpName(char const *) const;
GAME_IMPORT bool IsExpanded() const;
GAME_IMPORT bool HasDefaultValue(class CRTTI const *) const;
GAME_IMPORT void SetSerialize(bool) const;
GAME_IMPORT bool IsSerialize() const;
#pragma endregion
};

106
_IDAScripts/generated/CRTTIField.h Normal file
View File

@ -0,0 +1,106 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIField {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, CRTTIField*, sub_119B50, (char a1), a1);
VIRTUAL_CALL(1, int64_t, RunUnitTests, ());
GAME_IMPORT virtual CRTTIField::Variant* GetFieldDefaultVariantPtr(CRTTI const*) const;
VIRTUAL_CALL(3, int64_t, _RunUnitTests1, ());
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
VIRTUAL_CALL(7, bool, updateRttiParams, ());
GAME_IMPORT virtual bool GetValidValuesEditor(CRTTIObject*, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&) const;
virtual void _StrippedVFunc4() = 0;
virtual void _StrippedVFunc5() = 0;
VIRTUAL_CALL(11, int64_t, _RunUnitTests2, ());
VIRTUAL_CALL(12, bool, _updateRttiParams1, ());
virtual void _StrippedVFunc6() = 0;
virtual void _StrippedVFunc7() = 0;
virtual void _StrippedVFunc8() = 0;
VIRTUAL_CALL(16, int64_t, _RunUnitTests3, ());
GAME_IMPORT virtual bool Copy(CRTTIObject*, CRTTIObject const*) const;
GAME_IMPORT virtual bool Exchange(CRTTIObject*, CRTTIObject*) const;
VIRTUAL_CALL(19, bool, _updateRttiParams2, ());
GAME_IMPORT virtual ttl::string_base<char> const ClampString(char const*) const;
VIRTUAL_CALL(21, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool AddVirtualFieldDestination(CRTTIField const*, uint32_t, ttl::string_base<char>*);
VIRTUAL_CALL(23, bool, _updateRttiParams3, ());
VIRTUAL_CALL(24, int64_t, _RunUnitTests5, ());
VIRTUAL_CALL(25, void, SetPlatform, ());
GAME_IMPORT virtual bool OverwriteVirtualFieldFlags(CRTTIField const*);
VIRTUAL_CALL(27, int64_t, _RunUnitTests6, ());
VIRTUAL_CALL(28, void, _SetPlatform1, ());
VIRTUAL_CALL(29, int64_t, _RunUnitTests7, ());
VIRTUAL_CALL(30, void, _SetPlatform2, ());
GAME_IMPORT virtual void WriteToDom(dom::IWriter&, CRTTIObject const*) const;
GAME_IMPORT virtual void ReadFromDom(dom::IReader::Array const&, CRTTIObject*) const;
protected:
GAME_IMPORT virtual bool ParseInitToken(char, char const*);
GAME_IMPORT virtual void ParseFlagsTokenData(char const*, uint32_t64_t);
GAME_IMPORT virtual void ParseEditorFlagsTokenData(ERTTIEditFlags&, char const*, uint32_t64_t);
public:
GAME_IMPORT virtual ttl::string_base<char> ClassWriterCompare(CRTTI const*, CRTTI const*, CRTTIField const&) const;
GAME_IMPORT CRTTIField(ClassReaderResolve const&);
GAME_IMPORT ERTTIType GetType() const;
GAME_IMPORT bool IsMessagePipeIn() const;
GAME_IMPORT bool HasIndividualSize() const;
GAME_IMPORT bool IsUuidRefFlagSet() const;
GAME_IMPORT bool IsEditable() const;
GAME_IMPORT CRTTIField();
GAME_IMPORT bool Initialize(ttl::string_const<char>, ttl::string_const<char>, unsigned char, void (* )( ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>& ));
GAME_IMPORT bool IsPStorageField() const;
GAME_IMPORT bool IsPropertyIn() const;
GAME_IMPORT bool HasStaticSize() const;
GAME_IMPORT bool IsGamescript() const;
GAME_IMPORT bool IsVirtual() const;
GAME_IMPORT char const* GetName() const;
GAME_IMPORT void GetDefaultValue(CRTTI const*, CRTTIField::Variant&) const;
GAME_IMPORT bool IsFieldInternal() const;
protected:
GAME_IMPORT void SetDefaultValueInternal(CRTTI const*, CRTTIField::Variant*);
public:
GAME_IMPORT void SetExposed(bool) const;
GAME_IMPORT bool IsProperty() const;
GAME_IMPORT bool HasDefaultValue() const;
GAME_IMPORT bool IsMessagePipe() const;
GAME_IMPORT bool IsExposed() const;
GAME_IMPORT bool IsPresetFlagSet() const;
GAME_IMPORT ttl::pstring GetSubtype() const;
GAME_IMPORT void SetExpanded(bool) const;
protected:
GAME_IMPORT void SetVirtualFlag();
GAME_IMPORT static bool EatWhiteChars(char* &);
GAME_IMPORT void SetPropertyFlag();
public:
GAME_IMPORT bool IsPipeInternal() const;
GAME_IMPORT void SetPipeInternal(bool) const;
GAME_IMPORT bool IsReplicated() const;
GAME_IMPORT void RestoreDefaultValue(CRTTI const*, CRTTIObject*);
GAME_IMPORT bool IsQuestField() const;
GAME_IMPORT void SetGamescript(bool) const;
GAME_IMPORT char const* GetPreviousName() const;
GAME_IMPORT bool IsSaveGameField() const;
GAME_IMPORT bool IsSelfUuidFlagSet() const;
protected:
GAME_IMPORT char const* ExtractClassName(CRTTI const*) const;
public:
GAME_IMPORT void SetEditable(bool) const;
GAME_IMPORT bool IsPropertyOut() const;
GAME_IMPORT bool HasDynamicSize() const;
GAME_IMPORT bool IsMessagePipeOut() const;
protected:
GAME_IMPORT void SetPrecision(int);
public:
GAME_IMPORT CRTTIField(CRTTIField const&);
GAME_IMPORT void SetPresetFlag(bool) const;
GAME_IMPORT bool CmpName(char const*) const;
GAME_IMPORT bool IsExpanded() const;
GAME_IMPORT bool HasDefaultValue(CRTTI const*) const;
GAME_IMPORT void SetSerialize(bool) const;
GAME_IMPORT bool IsSerialize() const;
#pragma endregion
};

19
_IDAScripts/generated/CRTTIMethod-unclean.h Normal file
View File

@ -0,0 +1,19 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIMethod {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, _QWORD *__fastcall, sub_11DDE0, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
GAME_IMPORT char const * GetMethodClassName() const;
GAME_IMPORT CRTTIMethod(class CRTTI *, char const *);
GAME_IMPORT void DecTimeHandlerRefcount();
GAME_IMPORT CRTTIMethod(class ClassReaderResolve const &);
GAME_IMPORT CRTTIMethod(class CRTTIMethod const &);
GAME_IMPORT class CRTTIMethod & operator=(class CRTTIMethod const &);
#pragma endregion
};

19
_IDAScripts/generated/CRTTIMethod.h Normal file
View File

@ -0,0 +1,19 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIMethod {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_11DDE0, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
GAME_IMPORT char const* GetMethodClassName() const;
GAME_IMPORT CRTTIMethod(CRTTI*, char const*);
GAME_IMPORT void DecTimeHandlerRefcount();
GAME_IMPORT CRTTIMethod(ClassReaderResolve const&);
GAME_IMPORT CRTTIMethod(CRTTIMethod const&);
GAME_IMPORT CRTTIMethod& operator=(CRTTIMethod const&);
#pragma endregion
};

151
_IDAScripts/generated/CRTTIObject-unclean.h Normal file
View File

@ -0,0 +1,151 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static class rtti::Type & m_RTTI;
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
VIRTUAL_CALL(0, void __fastcall, SetPlatform, ());
VIRTUAL_CALL(1, IObject *__fastcall, sub_11DE70, (char a1), a1);
GAME_IMPORT virtual class CRTTI const * GetRTTI() const;
VIRTUAL_CALL(3, class CRTTI const *, _GetRTTI1, ());
VIRTUAL_CALL(4, struct MED::SModelOutfitGroup const *, unassigned, ());
VIRTUAL_CALL(5, struct MED::SModelOutfitGroup const *, _unassigned1, ());
VIRTUAL_CALL(6, struct MED::SModelOutfitGroup const *, _unassigned2, ());
VIRTUAL_CALL(7, struct MED::SModelOutfitGroup const *, _unassigned3, ());
VIRTUAL_CALL(8, __int64, RunUnitTests, ());
VIRTUAL_CALL(9, __int64, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(class ttl::list<class IGSObject *, class ttl::allocator> *, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, __int64, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(class ttl::vector<class IGSObject *, class ttl::vector_allocators::heap_allocator<class IGSObject *>, 1> &, bool);
GAME_IMPORT virtual void GetAllObjects(class ttl::set<class CRTTIObject *, struct ttl::less<class CRTTIObject *>, class ttl::allocator> &, class ttl::set<class CRTTIObject *, struct ttl::less<class CRTTIObject *>, class ttl::allocator> &, bool, class std::optional<class ttl::function_ref<bool (class CRTTIObject *)>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void __fastcall, _SetPlatform1, ());
GAME_IMPORT virtual char const * GetString(char const *) const;
VIRTUAL_CALL(18, void __fastcall, _SetPlatform2, ());
VIRTUAL_CALL(19, static bool, ValidateVec4, (class IGSObject const *, class vec4 const &), *, &);
VIRTUAL_CALL(20, void __fastcall, _SetPlatform3, ());
VIRTUAL_CALL(21, struct MED::SModelOutfitGroup const *, _unassigned4, ());
VIRTUAL_CALL(22, void __fastcall, _SetPlatform4, ());
GAME_IMPORT virtual class Uid const & GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams1, ());
VIRTUAL_CALL(25, bool, _updateRttiParams2, ());
VIRTUAL_CALL(26, bool, _updateRttiParams3, ());
VIRTUAL_CALL(27, bool, _updateRttiParams4, ());
VIRTUAL_CALL(28, bool, _updateRttiParams5, ());
VIRTUAL_CALL(29, bool, _updateRttiParams6, ());
VIRTUAL_CALL(30, bool, _updateRttiParams7, ());
VIRTUAL_CALL(31, bool, _updateRttiParams8, ());
VIRTUAL_CALL(32, bool, _updateRttiParams9, ());
GAME_IMPORT virtual void CallVoidMethod(char const *, ...);
GAME_IMPORT virtual class cbs::msg::IMessagePipeSet const & GetMessagePipeSet() const;
VIRTUAL_CALL(35, __int64, _RunUnitTests3, ());
VIRTUAL_CALL(36, struct MED::SModelOutfitGroup const *, _unassigned5, ());
VIRTUAL_CALL(37, struct MED::SModelOutfitGroup const *, _unassigned6, ());
VIRTUAL_CALL(38, struct MED::SModelOutfitGroup const *, _unassigned7, ());
VIRTUAL_CALL(39, struct MED::SModelOutfitGroup const *, _unassigned8, ());
GAME_IMPORT virtual class cbs::prop::IPropertySet const & GetPropertySet() const;
VIRTUAL_CALL(41, void __fastcall, _SetPlatform5, ());
VIRTUAL_CALL(42, __int64, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(class CRTTIField const *, unsigned char, class fs::ifile &, class IPtrResolver &, bool);
GAME_IMPORT virtual void LoadFields(class dom::IReader::Object const &, class IPtrResolver &, bool, bool (*)(char const *, class CRTTIObject *));
GAME_IMPORT virtual void LoadFields(class ITextDeserializer &, class IPtrResolver &, bool);
GAME_IMPORT virtual void LoadFields(class fs::ifile &, class IPtrResolver &, bool);
GAME_IMPORT virtual void SaveFields(class dom::IWriter &, enum ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char *, int);
GAME_IMPORT virtual int FromBufferReplicated(char *, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void __fastcall, _SetPlatform6, ());
VIRTUAL_CALL(52, static bool, _ValidateVec41, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
GAME_IMPORT virtual bool CopyFields(class CRTTIObject const *, bool);
GAME_IMPORT virtual bool CopyPointerFields(class CRTTIObject const *);
GAME_IMPORT virtual bool ExchangePointerFields(class CRTTIObject *);
VIRTUAL_CALL(56, __int64, _RunUnitTests5, ());
VIRTUAL_CALL(57, __int64, _RunUnitTests6, ());
VIRTUAL_CALL(58, __int64, _RunUnitTests7, ());
GAME_IMPORT virtual struct SRttiNetPointer GetNetPointer() const;
VIRTUAL_CALL(60, __int64, _RunUnitTests8, ());
GAME_IMPORT virtual class ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(struct SObjectMemoryUsage &) const;
VIRTUAL_CALL(63, void __fastcall, _SetPlatform7, ());
GAME_IMPORT virtual bool GetValidFieldValuesEditor(class CRTTIField const &, class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &, class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &);
VIRTUAL_CALL(65, bool, _updateRttiParams10, ());
VIRTUAL_CALL(66, static bool, _ValidateVec42, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, __int64, _RunUnitTests9, ());
GAME_IMPORT virtual class ttl::string_base<char> ValueToString(class CRTTIObject * const &) const;
GAME_IMPORT virtual bool IsFieldChanged(class CRTTIField const *) const;
GAME_IMPORT virtual void SetFieldChangedFlag(class CRTTIField const *, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams11, ());
GAME_IMPORT virtual bool OnFieldChanged2(class CRTTIField const *, bool);
VIRTUAL_CALL(73, void __fastcall, _SetPlatform8, ());
VIRTUAL_CALL(74, __int64, _RunUnitTests10, ());
VIRTUAL_CALL(75, void __fastcall, _SetPlatform9, ());
VIRTUAL_CALL(76, bool, _updateRttiParams12, ());
protected:
GAME_IMPORT virtual bool OnFieldChanged(class CRTTIField const *, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams13, ());
VIRTUAL_CALL(79, bool, _updateRttiParams14, ());
VIRTUAL_CALL(80, __int64, _RunUnitTests11, ());
VIRTUAL_CALL(81, __int64, _RunUnitTests12, ());
VIRTUAL_CALL(82, void __fastcall, _SetPlatform10, ());
GAME_IMPORT virtual void Query(class IBaseValidator &, class ttl::vector<class CRTTIObject *, class ttl::vector_allocators::heap_allocator<class CRTTIObject *>, 1> &) const;
GAME_IMPORT bool FromEngineClass(class CRTTI const *) const;
private:
GAME_IMPORT static class CRTTI * __INTERNAL_crtti_factory();
public:
GAME_IMPORT class CRTTIField const * FindFieldDynamic(class ttl::string_view_base<char, struct ttl::char_traits<char>>) const;
GAME_IMPORT bool FromClassByName(char const *) const;
GAME_IMPORT class CRTTIFieldEmbeddedObject const * SetFieldEmbeddedObject(class ttl::string_const<char>, class CEmbeddedObject * const &);
GAME_IMPORT bool FromClassOrInterfaceByName(char const *) const;
GAME_IMPORT class CRTTIMethod const * FindMethod(char const *) const;
GAME_IMPORT class CRTTIFieldTyped<unsigned short> const * SetFieldUShort(class ttl::string_const<char>, unsigned short);
GAME_IMPORT class CRTTIFieldTyped<float> const * SetFieldFloat(class ttl::string_const<char>, float);
GAME_IMPORT bool FromClassOrInterface(int) const;
GAME_IMPORT bool FromClass(class rtti::Type const *) const;
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT class CRTTIFieldTyped<unsigned char> const * SetFieldUChar(class ttl::string_const<char>, unsigned char);
GAME_IMPORT bool IsExactClass(class rtti::Type const *) const;
GAME_IMPORT bool FromEngineClass(int) const;
GAME_IMPORT bool FromClass(int) const;
GAME_IMPORT void GetLocalFields(class ttl::vector<class CRTTIField const *, class ttl::vector_allocators::heap_allocator<class CRTTIField const *>, 64> &) const;
GAME_IMPORT static class CRTTIObject * LoadObjectHierarchy(class fs::ifile &, bool, struct cbs::WorldIndex);
GAME_IMPORT class CRTTIFieldTyped<class vec4> const * GetFieldVec4(class ttl::string_const<char>, class vec4 &) const;
GAME_IMPORT bool FromEngineClass(class rtti::Type const &) const;
GAME_IMPORT class CRTTIFieldVectorTyped<class vec4> const * GetFieldVec4Vector(class ttl::string_const<char>, class ttl::vector<class vec4, class ttl::vector_allocators::heap_allocator<class vec4>, 0> &) const;
private:
GAME_IMPORT static class rtti::Type & __INTERNAL_type_factory();
public:
GAME_IMPORT class CRTTIFieldTyped<class vec4> const * SetFieldVec4(class ttl::string_const<char>, class vec4 const &);
GAME_IMPORT static class rtti::Type & typeinfo();
GAME_IMPORT static class CRTTIObject * LoadObjectHierarchy(class ITextDeserializer &, bool, struct cbs::WorldIndex);
GAME_IMPORT bool FromClassOrInterface(class rtti::Type const *) const;
GAME_IMPORT static class CRTTINative<class CRTTIObject> * GetSTTI();
GAME_IMPORT class CRTTIField const * FindField(char const *) const;
GAME_IMPORT bool FromClass(class CRTTI const *) const;
GAME_IMPORT bool IsExactEngineClass(int) const;
GAME_IMPORT class CRTTIFieldVectorTyped<class vec4> const * SetFieldVec4Vector(class ttl::string_const<char>, class ttl::vector<class vec4, class ttl::vector_allocators::heap_allocator<class vec4>, 0> const &);
GAME_IMPORT char const * GetClassNameA() const;
GAME_IMPORT bool IsExactClass(class CRTTI const *) const;
GAME_IMPORT class CRTTIField const * FindFieldIncludingAliases(class ttl::string_view_base<char, struct ttl::char_traits<char>>) const;
GAME_IMPORT bool IsExactClass(int) const;
GAME_IMPORT class CRTTIField const * FindFieldIncludingAliases(char const *) const;
GAME_IMPORT bool IsExactClassByName(char const *) const;
GAME_IMPORT CRTTIObject();
GAME_IMPORT class CRTTIFieldString const * SetFieldString(class ttl::string_const<char>, class ttl::string_const<char>);
GAME_IMPORT void GetAllLocalFields(class ttl::vector<class CRTTIField const *, class ttl::vector_allocators::heap_allocator<class CRTTIField const *>, 64> &) const;
GAME_IMPORT class CRTTIField const * FindField(class ttl::string_view_base<char, struct ttl::char_traits<char>>) const;
GAME_IMPORT class CRTTIField const * FindFieldDynamic(char const *) const;
GAME_IMPORT static void RegisterValidator(class IBaseValidator &, class CRTTI const &);
GAME_IMPORT class CRTTIFieldTyped<unsigned int> const * SetFieldUInt(class ttl::string_const<char>, unsigned int);
GAME_IMPORT class ttl::temp_string_base<char, 240> GetClassNameWithoutNamespace() const;
GAME_IMPORT bool FromClassOrInterface(class CRTTI const *) const;
GAME_IMPORT class CEmbeddedObject * CreateRawEmbeddedObject(class CRTTI const *, char const *, class CRTTIObject *, class CRTTIField const *) const;
#pragma endregion
};

151
_IDAScripts/generated/CRTTIObject.h Normal file
View File

@ -0,0 +1,151 @@
#pragma once
#include <EGSDK\Imports.h>
class CRTTIObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static rtti::Type& m_RTTI;
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
VIRTUAL_CALL(0, void, SetPlatform, ());
VIRTUAL_CALL(1, IObject*, sub_11DE70, (char a1), a1);
GAME_IMPORT virtual CRTTI const* GetRTTI() const;
VIRTUAL_CALL(3, CRTTI const*, _GetRTTI1, ());
VIRTUAL_CALL(4, MED::SModelOutfitGroup const*, unassigned, ());
VIRTUAL_CALL(5, MED::SModelOutfitGroup const*, _unassigned1, ());
VIRTUAL_CALL(6, MED::SModelOutfitGroup const*, _unassigned2, ());
VIRTUAL_CALL(7, MED::SModelOutfitGroup const*, _unassigned3, ());
VIRTUAL_CALL(8, int64_t, RunUnitTests, ());
VIRTUAL_CALL(9, int64_t, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(ttl::list<IGSObject*, ttl::allocator>*, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, int64_t, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(ttl::vector<IGSObject*, ttl::vector_allocators::heap_allocator<IGSObject*>, 1>&, bool);
GAME_IMPORT virtual void GetAllObjects(ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, bool, std::optional<ttl::function_ref<bool ( CRTTIObject* )>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void, _SetPlatform1, ());
GAME_IMPORT virtual char const* GetString(char const*) const;
VIRTUAL_CALL(18, void, _SetPlatform2, ());
VIRTUAL_CALL(19, static bool, ValidateVec4, (IGSObject const*, vec4 const&), const*, const&);
VIRTUAL_CALL(20, void, _SetPlatform3, ());
VIRTUAL_CALL(21, MED::SModelOutfitGroup const*, _unassigned4, ());
VIRTUAL_CALL(22, void, _SetPlatform4, ());
GAME_IMPORT virtual Uid const& GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams1, ());
VIRTUAL_CALL(25, bool, _updateRttiParams2, ());
VIRTUAL_CALL(26, bool, _updateRttiParams3, ());
VIRTUAL_CALL(27, bool, _updateRttiParams4, ());
VIRTUAL_CALL(28, bool, _updateRttiParams5, ());
VIRTUAL_CALL(29, bool, _updateRttiParams6, ());
VIRTUAL_CALL(30, bool, _updateRttiParams7, ());
VIRTUAL_CALL(31, bool, _updateRttiParams8, ());
VIRTUAL_CALL(32, bool, _updateRttiParams9, ());
GAME_IMPORT virtual void CallVoidMethod(char const*, ...);
GAME_IMPORT virtual cbs::msg::IMessagePipeSet const& GetMessagePipeSet() const;
VIRTUAL_CALL(35, int64_t, _RunUnitTests3, ());
VIRTUAL_CALL(36, MED::SModelOutfitGroup const*, _unassigned5, ());
VIRTUAL_CALL(37, MED::SModelOutfitGroup const*, _unassigned6, ());
VIRTUAL_CALL(38, MED::SModelOutfitGroup const*, _unassigned7, ());
VIRTUAL_CALL(39, MED::SModelOutfitGroup const*, _unassigned8, ());
GAME_IMPORT virtual cbs::prop::IPropertySet const& GetPropertySet() const;
VIRTUAL_CALL(41, void, _SetPlatform5, ());
VIRTUAL_CALL(42, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(CRTTIField const*, unsigned char, fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(dom::IReader::Object const&, IPtrResolver&, bool, bool (* )(char const*, CRTTIObject* ));
GAME_IMPORT virtual void LoadFields(ITextDeserializer&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void SaveFields(dom::IWriter&, ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char*, int);
GAME_IMPORT virtual int FromBufferReplicated(char*, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void, _SetPlatform6, ());
VIRTUAL_CALL(52, static bool, _ValidateVec41, (IGSObject const* a1, vec4 const& a2), a1, a2);
GAME_IMPORT virtual bool CopyFields(CRTTIObject const*, bool);
GAME_IMPORT virtual bool CopyPointerFields(CRTTIObject const*);
GAME_IMPORT virtual bool ExchangePointerFields(CRTTIObject*);
VIRTUAL_CALL(56, int64_t, _RunUnitTests5, ());
VIRTUAL_CALL(57, int64_t, _RunUnitTests6, ());
VIRTUAL_CALL(58, int64_t, _RunUnitTests7, ());
GAME_IMPORT virtual SRttiNetPointer GetNetPointer() const;
VIRTUAL_CALL(60, int64_t, _RunUnitTests8, ());
GAME_IMPORT virtual ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(SObjectMemoryUsage&) const;
VIRTUAL_CALL(63, void, _SetPlatform7, ());
GAME_IMPORT virtual bool GetValidFieldValuesEditor(CRTTIField const&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&);
VIRTUAL_CALL(65, bool, _updateRttiParams10, ());
VIRTUAL_CALL(66, static bool, _ValidateVec42, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, int64_t, _RunUnitTests9, ());
GAME_IMPORT virtual ttl::string_base<char> ValueToString(CRTTIObject* const&) const;
GAME_IMPORT virtual bool IsFieldChanged(CRTTIField const*) const;
GAME_IMPORT virtual void SetFieldChangedFlag(CRTTIField const*, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams11, ());
GAME_IMPORT virtual bool OnFieldChanged2(CRTTIField const*, bool);
VIRTUAL_CALL(73, void, _SetPlatform8, ());
VIRTUAL_CALL(74, int64_t, _RunUnitTests10, ());
VIRTUAL_CALL(75, void, _SetPlatform9, ());
VIRTUAL_CALL(76, bool, _updateRttiParams12, ());
protected:
GAME_IMPORT virtual bool OnFieldChanged(CRTTIField const*, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams13, ());
VIRTUAL_CALL(79, bool, _updateRttiParams14, ());
VIRTUAL_CALL(80, int64_t, _RunUnitTests11, ());
VIRTUAL_CALL(81, int64_t, _RunUnitTests12, ());
VIRTUAL_CALL(82, void, _SetPlatform10, ());
GAME_IMPORT virtual void Query(IBaseValidator&, ttl::vector<CRTTIObject*, ttl::vector_allocators::heap_allocator<CRTTIObject*>, 1>&) const;
GAME_IMPORT bool FromEngineClass(CRTTI const*) const;
private:
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
public:
GAME_IMPORT CRTTIField const* FindFieldDynamic(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT bool FromClassByName(char const*) const;
GAME_IMPORT CRTTIFieldEmbeddedObject const* SetFieldEmbeddedObject(ttl::string_const<char>, CEmbeddedObject* const&);
GAME_IMPORT bool FromClassOrInterfaceByName(char const*) const;
GAME_IMPORT CRTTIMethod const* FindMethod(char const*) const;
GAME_IMPORT CRTTIFieldTyped<unsigned short> const* SetFieldUShort(ttl::string_const<char>, unsigned short);
GAME_IMPORT CRTTIFieldTyped<float> const* SetFieldFloat(ttl::string_const<char>, float);
GAME_IMPORT bool FromClassOrInterface(int) const;
GAME_IMPORT bool FromClass(rtti::Type const*) const;
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT CRTTIFieldTyped<unsigned char> const* SetFieldUChar(ttl::string_const<char>, unsigned char);
GAME_IMPORT bool IsExactClass(rtti::Type const*) const;
GAME_IMPORT bool FromEngineClass(int) const;
GAME_IMPORT bool FromClass(int) const;
GAME_IMPORT void GetLocalFields(ttl::vector<CRTTIField const*, ttl::vector_allocators::heap_allocator<CRTTIField const*>, 64>&) const;
GAME_IMPORT static CRTTIObject* LoadObjectHierarchy(fs::ifile&, bool, cbs::WorldIndex);
GAME_IMPORT CRTTIFieldTyped<vec4> const* GetFieldVec4(ttl::string_const<char>, vec4&) const;
GAME_IMPORT bool FromEngineClass(rtti::Type const&) const;
GAME_IMPORT CRTTIFieldVectorTyped<vec4> const* GetFieldVec4Vector(ttl::string_const<char>, ttl::vector<vec4, ttl::vector_allocators::heap_allocator<vec4>, 0>&) const;
private:
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
public:
GAME_IMPORT CRTTIFieldTyped<vec4> const* SetFieldVec4(ttl::string_const<char>, vec4 const&);
GAME_IMPORT static rtti::Type& typeinfo();
GAME_IMPORT static CRTTIObject* LoadObjectHierarchy(ITextDeserializer&, bool, cbs::WorldIndex);
GAME_IMPORT bool FromClassOrInterface(rtti::Type const*) const;
GAME_IMPORT static CRTTINative<CRTTIObject>* GetSTTI();
GAME_IMPORT CRTTIField const* FindField(char const*) const;
GAME_IMPORT bool FromClass(CRTTI const*) const;
GAME_IMPORT bool IsExactEngineClass(int) const;
GAME_IMPORT CRTTIFieldVectorTyped<vec4> const* SetFieldVec4Vector(ttl::string_const<char>, ttl::vector<vec4, ttl::vector_allocators::heap_allocator<vec4>, 0> const&);
GAME_IMPORT char const* GetClassNameA() const;
GAME_IMPORT bool IsExactClass(CRTTI const*) const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT bool IsExactClass(int) const;
GAME_IMPORT CRTTIField const* FindFieldIncludingAliases(char const*) const;
GAME_IMPORT bool IsExactClassByName(char const*) const;
GAME_IMPORT CRTTIObject();
GAME_IMPORT CRTTIFieldString const* SetFieldString(ttl::string_const<char>, ttl::string_const<char>);
GAME_IMPORT void GetAllLocalFields(ttl::vector<CRTTIField const*, ttl::vector_allocators::heap_allocator<CRTTIField const*>, 64>&) const;
GAME_IMPORT CRTTIField const* FindField(ttl::string_view_base<char, ttl::char_traits<char>>) const;
GAME_IMPORT CRTTIField const* FindFieldDynamic(char const*) const;
GAME_IMPORT static void RegisterValidator(IBaseValidator&, CRTTI const&);
GAME_IMPORT CRTTIFieldTyped<uint32_t> const* SetFieldUInt(ttl::string_const<char>, uint32_t);
GAME_IMPORT ttl::temp_string_base<char, 240> GetClassNameWithoutNamespace() const;
GAME_IMPORT bool FromClassOrInterface(CRTTI const*) const;
GAME_IMPORT CEmbeddedObject* CreateRawEmbeddedObject(CRTTI const*, char const*, CRTTIObject*, CRTTIField const*) const;
#pragma endregion
};

110
_IDAScripts/generated/IClassWriter-unclean.h Normal file
View File

@ -0,0 +1,110 @@
#pragma once
#include <EGSDK\Imports.h>
class IClassWriter {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, _QWORD *__fastcall, sub_FDA280, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
virtual void _StrippedVFunc4() = 0;
virtual void _StrippedVFunc5() = 0;
virtual void _StrippedVFunc6() = 0;
virtual void _StrippedVFunc7() = 0;
virtual void _StrippedVFunc8() = 0;
virtual void _StrippedVFunc9() = 0;
virtual void _StrippedVFunc10() = 0;
virtual void _StrippedVFunc11() = 0;
virtual void _StrippedVFunc12() = 0;
virtual void _StrippedVFunc13() = 0;
virtual void _StrippedVFunc14() = 0;
virtual void _StrippedVFunc15() = 0;
virtual void _StrippedVFunc16() = 0;
virtual void _StrippedVFunc17() = 0;
virtual void _StrippedVFunc18() = 0;
virtual void _StrippedVFunc19() = 0;
virtual void _StrippedVFunc20() = 0;
virtual void _StrippedVFunc21() = 0;
virtual void _StrippedVFunc22() = 0;
virtual void _StrippedVFunc23() = 0;
virtual void _StrippedVFunc24() = 0;
virtual void _StrippedVFunc25() = 0;
virtual void _StrippedVFunc26() = 0;
virtual void _StrippedVFunc27() = 0;
virtual void _StrippedVFunc28() = 0;
virtual void _StrippedVFunc29() = 0;
virtual void _StrippedVFunc30() = 0;
virtual void _StrippedVFunc31() = 0;
virtual void _StrippedVFunc32() = 0;
virtual void _StrippedVFunc33() = 0;
virtual void _StrippedVFunc34() = 0;
virtual void _StrippedVFunc35() = 0;
virtual void _StrippedVFunc36() = 0;
virtual void _StrippedVFunc37() = 0;
virtual void _StrippedVFunc38() = 0;
virtual void _StrippedVFunc39() = 0;
virtual void _StrippedVFunc40() = 0;
virtual void _StrippedVFunc41() = 0;
virtual void _StrippedVFunc42() = 0;
virtual void _StrippedVFunc43() = 0;
virtual void _StrippedVFunc44() = 0;
virtual void _StrippedVFunc45() = 0;
virtual void _StrippedVFunc46() = 0;
virtual void _StrippedVFunc47() = 0;
virtual void _StrippedVFunc48() = 0;
virtual void _StrippedVFunc49() = 0;
virtual void _StrippedVFunc50() = 0;
virtual void _StrippedVFunc51() = 0;
virtual void _StrippedVFunc52() = 0;
virtual void _StrippedVFunc53() = 0;
virtual void _StrippedVFunc54() = 0;
virtual void _StrippedVFunc55() = 0;
virtual void _StrippedVFunc56() = 0;
virtual void _StrippedVFunc57() = 0;
virtual void _StrippedVFunc58() = 0;
virtual void _StrippedVFunc59() = 0;
virtual void _StrippedVFunc60() = 0;
virtual void _StrippedVFunc61() = 0;
virtual void _StrippedVFunc62() = 0;
virtual void _StrippedVFunc63() = 0;
virtual void _StrippedVFunc64() = 0;
virtual void _StrippedVFunc65() = 0;
virtual void _StrippedVFunc66() = 0;
virtual void _StrippedVFunc67() = 0;
virtual void _StrippedVFunc68() = 0;
virtual void _StrippedVFunc69() = 0;
virtual void _StrippedVFunc70() = 0;
virtual void _StrippedVFunc71() = 0;
virtual void _StrippedVFunc72() = 0;
virtual void _StrippedVFunc73() = 0;
virtual void _StrippedVFunc74() = 0;
virtual void _StrippedVFunc75() = 0;
virtual void _StrippedVFunc76() = 0;
virtual void _StrippedVFunc77() = 0;
virtual void _StrippedVFunc78() = 0;
virtual void _StrippedVFunc79() = 0;
virtual void _StrippedVFunc80() = 0;
virtual void _StrippedVFunc81() = 0;
virtual void _StrippedVFunc82() = 0;
virtual void _StrippedVFunc83() = 0;
virtual void _StrippedVFunc84() = 0;
virtual void _StrippedVFunc85() = 0;
virtual void _StrippedVFunc86() = 0;
virtual void _StrippedVFunc87() = 0;
virtual void _StrippedVFunc88() = 0;
virtual void _StrippedVFunc89() = 0;
virtual void _StrippedVFunc90() = 0;
virtual void _StrippedVFunc91() = 0;
virtual void _StrippedVFunc92() = 0;
virtual void _StrippedVFunc93() = 0;
virtual void _StrippedVFunc94() = 0;
virtual void _StrippedVFunc95() = 0;
virtual void _StrippedVFunc96() = 0;
virtual void _StrippedVFunc97() = 0;
virtual void _StrippedVFunc98() = 0;
virtual void _StrippedVFunc99() = 0;
virtual void _StrippedVFunc100() = 0;
virtual void _StrippedVFunc101() = 0;
#pragma endregion
};

110
_IDAScripts/generated/IClassWriter.h Normal file
View File

@ -0,0 +1,110 @@
#pragma once
#include <EGSDK\Imports.h>
class IClassWriter {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_FDA280, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
virtual void _StrippedVFunc3() = 0;
virtual void _StrippedVFunc4() = 0;
virtual void _StrippedVFunc5() = 0;
virtual void _StrippedVFunc6() = 0;
virtual void _StrippedVFunc7() = 0;
virtual void _StrippedVFunc8() = 0;
virtual void _StrippedVFunc9() = 0;
virtual void _StrippedVFunc10() = 0;
virtual void _StrippedVFunc11() = 0;
virtual void _StrippedVFunc12() = 0;
virtual void _StrippedVFunc13() = 0;
virtual void _StrippedVFunc14() = 0;
virtual void _StrippedVFunc15() = 0;
virtual void _StrippedVFunc16() = 0;
virtual void _StrippedVFunc17() = 0;
virtual void _StrippedVFunc18() = 0;
virtual void _StrippedVFunc19() = 0;
virtual void _StrippedVFunc20() = 0;
virtual void _StrippedVFunc21() = 0;
virtual void _StrippedVFunc22() = 0;
virtual void _StrippedVFunc23() = 0;
virtual void _StrippedVFunc24() = 0;
virtual void _StrippedVFunc25() = 0;
virtual void _StrippedVFunc26() = 0;
virtual void _StrippedVFunc27() = 0;
virtual void _StrippedVFunc28() = 0;
virtual void _StrippedVFunc29() = 0;
virtual void _StrippedVFunc30() = 0;
virtual void _StrippedVFunc31() = 0;
virtual void _StrippedVFunc32() = 0;
virtual void _StrippedVFunc33() = 0;
virtual void _StrippedVFunc34() = 0;
virtual void _StrippedVFunc35() = 0;
virtual void _StrippedVFunc36() = 0;
virtual void _StrippedVFunc37() = 0;
virtual void _StrippedVFunc38() = 0;
virtual void _StrippedVFunc39() = 0;
virtual void _StrippedVFunc40() = 0;
virtual void _StrippedVFunc41() = 0;
virtual void _StrippedVFunc42() = 0;
virtual void _StrippedVFunc43() = 0;
virtual void _StrippedVFunc44() = 0;
virtual void _StrippedVFunc45() = 0;
virtual void _StrippedVFunc46() = 0;
virtual void _StrippedVFunc47() = 0;
virtual void _StrippedVFunc48() = 0;
virtual void _StrippedVFunc49() = 0;
virtual void _StrippedVFunc50() = 0;
virtual void _StrippedVFunc51() = 0;
virtual void _StrippedVFunc52() = 0;
virtual void _StrippedVFunc53() = 0;
virtual void _StrippedVFunc54() = 0;
virtual void _StrippedVFunc55() = 0;
virtual void _StrippedVFunc56() = 0;
virtual void _StrippedVFunc57() = 0;
virtual void _StrippedVFunc58() = 0;
virtual void _StrippedVFunc59() = 0;
virtual void _StrippedVFunc60() = 0;
virtual void _StrippedVFunc61() = 0;
virtual void _StrippedVFunc62() = 0;
virtual void _StrippedVFunc63() = 0;
virtual void _StrippedVFunc64() = 0;
virtual void _StrippedVFunc65() = 0;
virtual void _StrippedVFunc66() = 0;
virtual void _StrippedVFunc67() = 0;
virtual void _StrippedVFunc68() = 0;
virtual void _StrippedVFunc69() = 0;
virtual void _StrippedVFunc70() = 0;
virtual void _StrippedVFunc71() = 0;
virtual void _StrippedVFunc72() = 0;
virtual void _StrippedVFunc73() = 0;
virtual void _StrippedVFunc74() = 0;
virtual void _StrippedVFunc75() = 0;
virtual void _StrippedVFunc76() = 0;
virtual void _StrippedVFunc77() = 0;
virtual void _StrippedVFunc78() = 0;
virtual void _StrippedVFunc79() = 0;
virtual void _StrippedVFunc80() = 0;
virtual void _StrippedVFunc81() = 0;
virtual void _StrippedVFunc82() = 0;
virtual void _StrippedVFunc83() = 0;
virtual void _StrippedVFunc84() = 0;
virtual void _StrippedVFunc85() = 0;
virtual void _StrippedVFunc86() = 0;
virtual void _StrippedVFunc87() = 0;
virtual void _StrippedVFunc88() = 0;
virtual void _StrippedVFunc89() = 0;
virtual void _StrippedVFunc90() = 0;
virtual void _StrippedVFunc91() = 0;
virtual void _StrippedVFunc92() = 0;
virtual void _StrippedVFunc93() = 0;
virtual void _StrippedVFunc94() = 0;
virtual void _StrippedVFunc95() = 0;
virtual void _StrippedVFunc96() = 0;
virtual void _StrippedVFunc97() = 0;
virtual void _StrippedVFunc98() = 0;
virtual void _StrippedVFunc99() = 0;
virtual void _StrippedVFunc100() = 0;
virtual void _StrippedVFunc101() = 0;
#pragma endregion
};

321
_IDAScripts/generated/IGSObject-unclean.h Normal file
View File

@ -0,0 +1,321 @@
#pragma once
#include <EGSDK\Imports.h>
class IGSObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
GAME_IMPORT static class rtti::Type & m_RTTI;
GAME_IMPORT virtual void ClassWriterSave(class IClassWriter *, bool) const;
VIRTUAL_CALL(1, IGSObject *__fastcall, sub_11FF80, (char a1), a1);
VIRTUAL_CALL(2, static class CRTTIGameScript<class IGSObject> *, GetSTTI, ());
GAME_IMPORT virtual class CRTTI const * GetEngineRTTI() const;
protected:
VIRTUAL_CALL(4, class gui::CPackage *, ToCPackage, ());
public:
VIRTUAL_CALL(5, class gui::CPackage *, _ToCPackage1, ());
VIRTUAL_CALL(6, struct MED::SModelOutfitGroup const *, unassigned, ());
VIRTUAL_CALL(7, struct MED::SModelOutfitGroup const *, _unassigned1, ());
VIRTUAL_CALL(8, __int64, RunUnitTests, ());
VIRTUAL_CALL(9, __int64, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(class ttl::list<class IGSObject *, class ttl::allocator> *, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, __int64, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(class ttl::vector<class IGSObject *, class ttl::vector_allocators::heap_allocator<class IGSObject *>, 1> &, bool);
GAME_IMPORT virtual void GetAllObjects(class ttl::set<class CRTTIObject *, struct ttl::less<class CRTTIObject *>, class ttl::allocator> &, class ttl::set<class CRTTIObject *, struct ttl::less<class CRTTIObject *>, class ttl::allocator> &, bool, class std::optional<class ttl::function_ref<bool (class CRTTIObject *)>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void __fastcall, SetPlatform, ());
GAME_IMPORT virtual char const * GetString(char const *) const;
VIRTUAL_CALL(18, void __fastcall, _SetPlatform1, ());
VIRTUAL_CALL(19, static bool, ValidateVec4, (class IGSObject const *, class vec4 const &), *, &);
VIRTUAL_CALL(20, void __fastcall, _SetPlatform2, ());
VIRTUAL_CALL(21, struct MED::SModelOutfitGroup const *, _unassigned2, ());
VIRTUAL_CALL(22, void __fastcall, _SetPlatform3, ());
GAME_IMPORT virtual class Uid const & GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams1, ());
VIRTUAL_CALL(25, bool, _updateRttiParams2, ());
VIRTUAL_CALL(26, bool, _updateRttiParams3, ());
VIRTUAL_CALL(27, bool, _updateRttiParams4, ());
VIRTUAL_CALL(28, bool, _updateRttiParams5, ());
VIRTUAL_CALL(29, bool, _updateRttiParams6, ());
VIRTUAL_CALL(30, bool, _updateRttiParams7, ());
VIRTUAL_CALL(31, bool, _updateRttiParams8, ());
VIRTUAL_CALL(32, bool, _updateRttiParams9, ());
GAME_IMPORT virtual void CallVoidMethod(char const *, ...);
GAME_IMPORT virtual class cbs::msg::IMessagePipeSet const & GetMessagePipeSet() const;
VIRTUAL_CALL(35, __int64, _RunUnitTests3, ());
VIRTUAL_CALL(36, struct MED::SModelOutfitGroup const *, _unassigned3, ());
VIRTUAL_CALL(37, struct MED::SModelOutfitGroup const *, _unassigned4, ());
VIRTUAL_CALL(38, struct MED::SModelOutfitGroup const *, _unassigned5, ());
VIRTUAL_CALL(39, struct MED::SModelOutfitGroup const *, _unassigned6, ());
GAME_IMPORT virtual class cbs::prop::IPropertySet const & GetPropertySet() const;
VIRTUAL_CALL(41, void __fastcall, _SetPlatform4, ());
VIRTUAL_CALL(42, __int64, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(class CRTTIField const *, unsigned char, class fs::ifile &, class IPtrResolver &, bool);
GAME_IMPORT virtual void LoadFields(class dom::IReader::Object const &, class IPtrResolver &, bool, bool (*)(char const *, class CRTTIObject *));
GAME_IMPORT virtual void LoadFields(class ITextDeserializer &, class IPtrResolver &, bool);
GAME_IMPORT virtual void LoadFields(class fs::ifile &, class IPtrResolver &, bool);
GAME_IMPORT virtual void SaveFields(class dom::IWriter &, enum ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char *, int);
GAME_IMPORT virtual int FromBufferReplicated(char *, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void __fastcall, _SetPlatform5, ());
VIRTUAL_CALL(52, static bool, _ValidateVec41, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
GAME_IMPORT virtual bool CopyFields(class CRTTIObject const *, bool);
GAME_IMPORT virtual bool CopyPointerFields(class CRTTIObject const *);
GAME_IMPORT virtual bool ExchangePointerFields(class CRTTIObject *);
GAME_IMPORT virtual class IGSObject * FindObjectByID(int) const;
GAME_IMPORT virtual class IGSObject * FindObjectByNetPointer(struct SRttiNetPointer const &) const;
GAME_IMPORT virtual class cbs::CEntity * FindEntityByNetPointer(struct SRttiNetPointer const &) const;
GAME_IMPORT virtual struct SRttiNetPointer GetNetPointer() const;
VIRTUAL_CALL(60, __int64, _RunUnitTests5, ());
GAME_IMPORT virtual class ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(struct SObjectMemoryUsage &) const;
VIRTUAL_CALL(63, void __fastcall, _SetPlatform6, ());
VIRTUAL_CALL(64, bool, _updateRttiParams10, ());
VIRTUAL_CALL(65, bool, _updateRttiParams11, ());
VIRTUAL_CALL(66, static bool, _ValidateVec42, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, __int64, _RunUnitTests6, ());
GAME_IMPORT virtual class ttl::string_base<char> ValueToString(class CRTTIObject * const &) const;
GAME_IMPORT virtual bool IsFieldChanged(class CRTTIField const *) const;
GAME_IMPORT virtual void SetFieldChangedFlag(class CRTTIField const *, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams12, ());
GAME_IMPORT virtual bool OnFieldChanged2(class CRTTIField const *, bool);
VIRTUAL_CALL(73, void __fastcall, _SetPlatform7, ());
GAME_IMPORT virtual char const * GetPresetsData() const;
VIRTUAL_CALL(75, void __fastcall, _SetPlatform8, ());
VIRTUAL_CALL(76, bool, _updateRttiParams13, ());
private:
GAME_IMPORT virtual bool OnFieldChanged(class CRTTIField const *, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams14, ());
VIRTUAL_CALL(79, bool, _updateRttiParams15, ());
VIRTUAL_CALL(80, __int64, _RunUnitTests7, ());
VIRTUAL_CALL(81, __int64, _RunUnitTests8, ());
VIRTUAL_CALL(82, void __fastcall, _SetPlatform9, ());
GAME_IMPORT virtual void Query(class IBaseValidator &, class ttl::vector<class CRTTIObject *, class ttl::vector_allocators::heap_allocator<class CRTTIObject *>, 1> &) const;
protected:
GAME_IMPORT virtual void SetEngineObject(class CGSObject *);
public:
VIRTUAL_CALL(85, struct MED::SModelOutfitGroup const *, _unassigned7, ());
VIRTUAL_CALL(86, struct MED::SModelOutfitGroup const *, _unassigned8, ());
VIRTUAL_CALL(87, __int64, _RunUnitTests9, ());
VIRTUAL_CALL(88, __int64, _RunUnitTests10, ());
VIRTUAL_CALL(89, __int64, _RunUnitTests11, ());
VIRTUAL_CALL(90, __int64, _RunUnitTests12, ());
VIRTUAL_CALL(91, __int64, _RunUnitTests13, ());
VIRTUAL_CALL(92, __int64, _RunUnitTests14, ());
VIRTUAL_CALL(93, __int64, _RunUnitTests15, ());
VIRTUAL_CALL(94, __int64, _RunUnitTests16, ());
VIRTUAL_CALL(95, void __fastcall, _SetPlatform10, ());
GAME_IMPORT virtual class ttl::string_base<char> toString() const;
VIRTUAL_CALL(97, void __fastcall, _SetPlatform11, ());
VIRTUAL_CALL(98, void __fastcall, _SetPlatform12, ());
VIRTUAL_CALL(99, bool, _updateRttiParams16, ());
VIRTUAL_CALL(100, void __fastcall, _SetPlatform13, ());
VIRTUAL_CALL(101, void __fastcall, _SetPlatform14, ());
VIRTUAL_CALL(102, void __fastcall, _SetPlatform15, ());
VIRTUAL_CALL(103, void __fastcall, _SetPlatform16, ());
VIRTUAL_CALL(104, void __fastcall, _SetPlatform17, ());
VIRTUAL_CALL(105, void __fastcall, _SetPlatform18, ());
VIRTUAL_CALL(106, void __fastcall, _SetPlatform19, ());
private:
VIRTUAL_CALL(107, void, UnregisterInTimeHandlerManager, ());
public:
VIRTUAL_CALL(108, void, _UnregisterInTimeHandlerManager1, ());
VIRTUAL_CALL(109, void __fastcall, _SetPlatform20, ());
VIRTUAL_CALL(110, void __fastcall, _SetPlatform21, ());
VIRTUAL_CALL(111, void __fastcall, _SetPlatform22, ());
VIRTUAL_CALL(112, void __fastcall, _SetPlatform23, ());
VIRTUAL_CALL(113, void __fastcall, _SetPlatform24, ());
VIRTUAL_CALL(114, void __fastcall, _SetPlatform25, ());
VIRTUAL_CALL(115, void __fastcall, _SetPlatform26, ());
VIRTUAL_CALL(116, void __fastcall, _SetPlatform27, ());
VIRTUAL_CALL(117, void __fastcall, _SetPlatform28, ());
VIRTUAL_CALL(118, void __fastcall, _SetPlatform29, ());
VIRTUAL_CALL(119, void __fastcall, _SetPlatform30, ());
VIRTUAL_CALL(120, void __fastcall, _SetPlatform31, ());
GAME_IMPORT virtual void OnActivateOnModule();
VIRTUAL_CALL(122, void __fastcall, _SetPlatform32, ());
VIRTUAL_CALL(123, void __fastcall, _SetPlatform33, ());
VIRTUAL_CALL(124, void __fastcall, _SetPlatform34, ());
VIRTUAL_CALL(125, void __fastcall, _SetPlatform35, ());
VIRTUAL_CALL(126, void __fastcall, _SetPlatform36, ());
VIRTUAL_CALL(127, void __fastcall, _SetPlatform37, ());
VIRTUAL_CALL(128, void __fastcall, _SetPlatform38, ());
VIRTUAL_CALL(129, void __fastcall, _SetPlatform39, ());
VIRTUAL_CALL(130, void __fastcall, _SetPlatform40, ());
VIRTUAL_CALL(131, void __fastcall, _SetPlatform41, ());
VIRTUAL_CALL(132, void __fastcall, _SetPlatform42, ());
VIRTUAL_CALL(133, void __fastcall, _SetPlatform43, ());
VIRTUAL_CALL(134, void __fastcall, _SetPlatform44, ());
VIRTUAL_CALL(135, void __fastcall, _SetPlatform45, ());
VIRTUAL_CALL(136, void __fastcall, _SetPlatform46, ());
VIRTUAL_CALL(137, void __fastcall, _SetPlatform47, ());
VIRTUAL_CALL(138, void __fastcall, _SetPlatform48, ());
VIRTUAL_CALL(139, void __fastcall, _SetPlatform49, ());
VIRTUAL_CALL(140, bool, _updateRttiParams17, ());
GAME_IMPORT virtual void SetHiddenByLogicEditor(bool);
VIRTUAL_CALL(142, void __fastcall, _SetPlatform50, ());
VIRTUAL_CALL(143, static bool, _ValidateVec43, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(144, static bool, _ValidateVec44, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(145, static bool, _ValidateVec45, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(146, static bool, _ValidateVec46, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(147, static bool, _ValidateVec47, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(148, static bool, _ValidateVec48, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(149, static bool, _ValidateVec49, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(150, static bool, _ValidateVec410, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(151, static bool, _ValidateVec411, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(152, static bool, _ValidateVec412, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(153, static bool, _ValidateVec413, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(154, static bool, _ValidateVec414, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(155, static bool, _ValidateVec415, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(156, static bool, _ValidateVec416, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(157, static bool, _ValidateVec417, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(158, static bool, _ValidateVec418, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(159, static bool, _ValidateVec419, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(160, static bool, _ValidateVec420, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(161, static bool, _ValidateVec421, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(162, static bool, _ValidateVec422, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(163, static bool, _ValidateVec423, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(164, static bool, _ValidateVec424, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
GAME_IMPORT virtual void SetSerializable(bool);
VIRTUAL_CALL(166, void __fastcall, _SetPlatform51, ());
VIRTUAL_CALL(167, bool, _updateRttiParams18, ());
VIRTUAL_CALL(168, bool, _updateRttiParams19, ());
GAME_IMPORT virtual void DeactivateOnModule();
VIRTUAL_CALL(170, void __fastcall, _SetPlatform52, ());
VIRTUAL_CALL(171, class ttl::list<struct SCommandParam, class ttl::allocator>::const_reverse_iterator, rend, ());
VIRTUAL_CALL(172, void __fastcall, _SetPlatform53, ());
GAME_IMPORT virtual bool ISharedObject_IsValid() const;
GAME_IMPORT virtual float GetTime() const;
GAME_IMPORT virtual float GetLastTime() const;
GAME_IMPORT virtual float GetTimeDelta() const;
GAME_IMPORT virtual __int64 GetTimeDeltaMiliseconds() const;
GAME_IMPORT void DisableOnFrameEditorHandler();
GAME_IMPORT void EnableOnPostUpdateEditorHandler();
GAME_IMPORT void CallMethodEvery(class CRTTIVoidMethod const *, float, float) const;
GAME_IMPORT class ttl::string_const<char> GetPresetsDataStr() const;
GAME_IMPORT float ReplGetRelevance(unsigned short) const;
GAME_IMPORT class IGSObject * CreateObjectWithID(class rtti::Type const &, int, bool, class ttl::string_base<char> const *);
GAME_IMPORT class IGpuFx_Manager * GetGpuFxManager();
GAME_IMPORT virtual void OnKeyboardClosed(class ttl::string_base<wchar_t>);
GAME_IMPORT unsigned int EditorGetAttributeMarkedToSaveCount() const;
GAME_IMPORT bool ReplIsOwner() const;
GAME_IMPORT bool ReplIsReplicated() const;
GAME_IMPORT void CallMethodIn(class CRTTIVoidMethod const *, float) const;
GAME_IMPORT bool EditorIsSelected() const;
GAME_IMPORT bool ReplIsReplicable() const;
GAME_IMPORT class ttl::string_base<char> ReplGetRequestingString() const;
GAME_IMPORT void EnableOnFrameHandler(enum EFrameHandlerPriority::TYPE, bool);
GAME_IMPORT bool IsActiveOnModule() const;
GAME_IMPORT void DisableOnPostAnimUpdateHandler();
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT void SetGSOFlags(unsigned __int64);
GAME_IMPORT void SetComment(class ttl::string_base<wchar_t> const &);
GAME_IMPORT void EnableOnPostUpdateHandler(enum EFrameHandlerPriority::TYPE, bool);
GAME_IMPORT class ILevel * GetLevel() const;
GAME_IMPORT void MakePrivate(class IGSObject *);
GAME_IMPORT void SetLevel(class CLevel *, bool);
GAME_IMPORT void SetAndProcessPresets(class ttl::string_base<char> const &);
GAME_IMPORT enum EMem::TYPE GetMemCategory();
private:
GAME_IMPORT void ActivateOnModuleInternal();
public:
GAME_IMPORT char const * GetNameCStr() const;
GAME_IMPORT class IGSObject * CreateObjectWithID(class CRTTI const &, int, bool, class ttl::string_base<char> const *);
GAME_IMPORT void DisableOnPostAnimatorUpdateHandler();
GAME_IMPORT int GetLocalClientId() const;
GAME_IMPORT float ReplGetRelevance() const;
GAME_IMPORT void ProcessPresets(struct PresetId);
GAME_IMPORT void SetName(class ttl::string_base<char> const &);
GAME_IMPORT class ttl::string_base<char> const GetNameAndClass() const;
GAME_IMPORT class IGSObject * CreateObject(enum EEntityRootType::TYPE, class CRTTI const &, class std::optional<class Replication::CreateObjectOptions>, bool, class ttl::string_base<char> const *);
GAME_IMPORT void AcquireObjectModule(class IGSObject *);
GAME_IMPORT void RequestOwnership();
GAME_IMPORT bool IsCreating() const;
GAME_IMPORT class ttl::string_base<char> GetName() const;
GAME_IMPORT void DisableCallMethod(class CRTTIVoidMethod const *) const;
GAME_IMPORT void MultiRaytest(unsigned char, class vec3 const &, class ttl::vector<class vec3, class ttl::vector_allocators::heap_allocator<class vec3>, 0> const &, class ttl::vector<bool, class ttl::vector_allocators::heap_allocator<bool>, 8> &, unsigned short, bool, class IControlObject *, class cbs::CEntity *, unsigned int, unsigned short, __int64);
GAME_IMPORT wchar_t const * GetComment() const;
private:
GAME_IMPORT void DeactivateOnModuleInternal();
public:
GAME_IMPORT unsigned char ReplGetObjectIdx() const;
GAME_IMPORT IGSObject(class IGSObject const &);
GAME_IMPORT void EnableOnPostAnimatorUpdateHandler();
GAME_IMPORT void ReplSetLocalReplicationInterval(float, float);
GAME_IMPORT void EditorRemoveAtCompilation(bool);
GAME_IMPORT bool IsLevelShutdown();
GAME_IMPORT void EnableOnPostAnimUpdateHandler();
GAME_IMPORT unsigned __int64 GetGSOFlags() const;
GAME_IMPORT class CRTTIField const * EditorGetAttributeMarkedToSave(unsigned int) const;
GAME_IMPORT void EditorMarkAttributeToSave(class ttl::string_base<char> const &);
GAME_IMPORT void FinalizeReplicationObject();
protected:
GAME_IMPORT IGSObject();
public:
GAME_IMPORT void InitializeReplicationObject(class Replication::CreateObjectOptions);
GAME_IMPORT void EnableOnPreAnimUpdateHandler();
GAME_IMPORT void ReplSetRelevance(float);
GAME_IMPORT class IGSObject * GetPrivateOwner();
GAME_IMPORT class IGSObject & operator=(class IGSObject const &);
GAME_IMPORT void PreDestroy();
private:
GAME_IMPORT static class CRTTI * __INTERNAL_crtti_factory();
public:
GAME_IMPORT unsigned char Raytrace(unsigned char, struct SCollision *, class vec3 const &, class vec3 &, unsigned short, bool, class IControlObject *, unsigned int, unsigned short, __int64, class ttl::span<class cbs::CEntity const *, 4294967295>);
GAME_IMPORT IGSObject(class ClassReaderResolve const &);
GAME_IMPORT bool ReplIsAuthoritative() const;
GAME_IMPORT void DisableOnPostUpdateEditorHandler();
GAME_IMPORT struct Net::Repl::CObjectId ReplGetId() const;
GAME_IMPORT unsigned int PlayAudioEvent(class ttl::string_base<char> const &, struct Audio::SAudioEventExtraData const *, class vec3 const &);
GAME_IMPORT bool EditorIsRemoveAtCompilationSet();
GAME_IMPORT bool ReplIsBlockChangeOwnership() const;
GAME_IMPORT struct PresetId GetPresetsId() const;
GAME_IMPORT void ProcessPresets(class ttl::string_base<char> const &);
GAME_IMPORT class Replication::IObject const & ReplicationObject() const;
GAME_IMPORT class ttl::string_base<char> ReplGetAuthoritativeString() const;
GAME_IMPORT void SetIGSOFlags(unsigned __int64);
private:
GAME_IMPORT static class rtti::Type & __INTERNAL_type_factory();
public:
GAME_IMPORT void DisableOnPreAnimUpdateHandler();
GAME_IMPORT unsigned short ReplGetOwnerId() const;
GAME_IMPORT void ActivateOnModule();
GAME_IMPORT static class rtti::Type & typeinfo();
GAME_IMPORT class IGSObject * CreateObjectWithGuid(class rtti::Type const &, unsigned __int64, bool, class ttl::string_base<char> const *);
GAME_IMPORT void ReplBlockChangeOwnership(bool);
GAME_IMPORT void ReplSendNow();
GAME_IMPORT void ReplSetRelevance(unsigned short, float);
GAME_IMPORT bool Raytest(unsigned char, class vec3 const &, class vec3 const &, unsigned short, bool, class IControlObject *, unsigned int, unsigned short, __int64, class ttl::span<class cbs::CEntity const *, 4294967295>);
GAME_IMPORT void DeleteThis();
GAME_IMPORT bool EditorIsNeverStatic() const;
GAME_IMPORT void DisableOnPostUpdateHandler();
GAME_IMPORT void ClearGSOFlags(unsigned __int64);
GAME_IMPORT void DisableOnFrameHandler();
GAME_IMPORT unsigned short ReplGetAuthoritativeId() const;
GAME_IMPORT void SetReplicationRelevance(float);
GAME_IMPORT void InitObject(class IGSObject *);
GAME_IMPORT class IGSObject * CreateObject(enum EEntityRootType::TYPE, class CRTTI const &, bool, class ttl::string_base<char> const *, bool);
GAME_IMPORT void ClearIGSOFlags(unsigned __int64);
GAME_IMPORT static void RegisterSTTI(class CRTTI *);
GAME_IMPORT void EnableOnFrameEditorHandler();
GAME_IMPORT bool ReplIsOwnerNoLocal() const;
GAME_IMPORT class IGSObject * GetNext() const;
GAME_IMPORT class IGSObject * CreateObjectWithGuid(class CRTTI const &, unsigned __int64, bool, class ttl::string_base<char> const *);
GAME_IMPORT bool IsDestroying() const;
GAME_IMPORT bool IsCreated() const;
GAME_IMPORT int GetNetOwnerID() const;
GAME_IMPORT bool IsPrivate() const;
GAME_IMPORT bool GetNetIsUniqueOwner() const;
GAME_IMPORT int GetID() const;
GAME_IMPORT void SetAndProcessPresets(struct PresetId);
GAME_IMPORT bool IsDestroyed() const;
GAME_IMPORT void SetIsReplicationEnabled(bool);
#pragma endregion
};

321
_IDAScripts/generated/IGSObject.h Normal file
View File

@ -0,0 +1,321 @@
#pragma once
#include <EGSDK\Imports.h>
class IGSObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
GAME_IMPORT static rtti::Type& m_RTTI;
GAME_IMPORT virtual void ClassWriterSave(IClassWriter*, bool) const;
VIRTUAL_CALL(1, IGSObject*, sub_11FF80, (char a1), a1);
VIRTUAL_CALL(2, static CRTTIGameScript<IGSObject>*, GetSTTI, ());
GAME_IMPORT virtual CRTTI const* GetEngineRTTI() const;
protected:
VIRTUAL_CALL(4, gui::CPackage*, ToCPackage, ());
public:
VIRTUAL_CALL(5, gui::CPackage*, _ToCPackage1, ());
VIRTUAL_CALL(6, MED::SModelOutfitGroup const*, unassigned, ());
VIRTUAL_CALL(7, MED::SModelOutfitGroup const*, _unassigned1, ());
VIRTUAL_CALL(8, int64_t, RunUnitTests, ());
VIRTUAL_CALL(9, int64_t, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(ttl::list<IGSObject*, ttl::allocator>*, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, int64_t, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(ttl::vector<IGSObject*, ttl::vector_allocators::heap_allocator<IGSObject*>, 1>&, bool);
GAME_IMPORT virtual void GetAllObjects(ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, bool, std::optional<ttl::function_ref<bool ( CRTTIObject* )>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void, SetPlatform, ());
GAME_IMPORT virtual char const* GetString(char const*) const;
VIRTUAL_CALL(18, void, _SetPlatform1, ());
VIRTUAL_CALL(19, static bool, ValidateVec4, (IGSObject const*, vec4 const&), const*, const&);
VIRTUAL_CALL(20, void, _SetPlatform2, ());
VIRTUAL_CALL(21, MED::SModelOutfitGroup const*, _unassigned2, ());
VIRTUAL_CALL(22, void, _SetPlatform3, ());
GAME_IMPORT virtual Uid const& GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams1, ());
VIRTUAL_CALL(25, bool, _updateRttiParams2, ());
VIRTUAL_CALL(26, bool, _updateRttiParams3, ());
VIRTUAL_CALL(27, bool, _updateRttiParams4, ());
VIRTUAL_CALL(28, bool, _updateRttiParams5, ());
VIRTUAL_CALL(29, bool, _updateRttiParams6, ());
VIRTUAL_CALL(30, bool, _updateRttiParams7, ());
VIRTUAL_CALL(31, bool, _updateRttiParams8, ());
VIRTUAL_CALL(32, bool, _updateRttiParams9, ());
GAME_IMPORT virtual void CallVoidMethod(char const*, ...);
GAME_IMPORT virtual cbs::msg::IMessagePipeSet const& GetMessagePipeSet() const;
VIRTUAL_CALL(35, int64_t, _RunUnitTests3, ());
VIRTUAL_CALL(36, MED::SModelOutfitGroup const*, _unassigned3, ());
VIRTUAL_CALL(37, MED::SModelOutfitGroup const*, _unassigned4, ());
VIRTUAL_CALL(38, MED::SModelOutfitGroup const*, _unassigned5, ());
VIRTUAL_CALL(39, MED::SModelOutfitGroup const*, _unassigned6, ());
GAME_IMPORT virtual cbs::prop::IPropertySet const& GetPropertySet() const;
VIRTUAL_CALL(41, void, _SetPlatform4, ());
VIRTUAL_CALL(42, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(CRTTIField const*, unsigned char, fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(dom::IReader::Object const&, IPtrResolver&, bool, bool (* )(char const*, CRTTIObject* ));
GAME_IMPORT virtual void LoadFields(ITextDeserializer&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void SaveFields(dom::IWriter&, ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char*, int);
GAME_IMPORT virtual int FromBufferReplicated(char*, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void, _SetPlatform5, ());
VIRTUAL_CALL(52, static bool, _ValidateVec41, (IGSObject const* a1, vec4 const& a2), a1, a2);
GAME_IMPORT virtual bool CopyFields(CRTTIObject const*, bool);
GAME_IMPORT virtual bool CopyPointerFields(CRTTIObject const*);
GAME_IMPORT virtual bool ExchangePointerFields(CRTTIObject*);
GAME_IMPORT virtual IGSObject* FindObjectByID(int) const;
GAME_IMPORT virtual IGSObject* FindObjectByNetPointer(SRttiNetPointer const&) const;
GAME_IMPORT virtual cbs::CEntity* FindEntityByNetPointer(SRttiNetPointer const&) const;
GAME_IMPORT virtual SRttiNetPointer GetNetPointer() const;
VIRTUAL_CALL(60, int64_t, _RunUnitTests5, ());
GAME_IMPORT virtual ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(SObjectMemoryUsage&) const;
VIRTUAL_CALL(63, void, _SetPlatform6, ());
VIRTUAL_CALL(64, bool, _updateRttiParams10, ());
VIRTUAL_CALL(65, bool, _updateRttiParams11, ());
VIRTUAL_CALL(66, static bool, _ValidateVec42, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, int64_t, _RunUnitTests6, ());
GAME_IMPORT virtual ttl::string_base<char> ValueToString(CRTTIObject* const&) const;
GAME_IMPORT virtual bool IsFieldChanged(CRTTIField const*) const;
GAME_IMPORT virtual void SetFieldChangedFlag(CRTTIField const*, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams12, ());
GAME_IMPORT virtual bool OnFieldChanged2(CRTTIField const*, bool);
VIRTUAL_CALL(73, void, _SetPlatform7, ());
GAME_IMPORT virtual char const* GetPresetsData() const;
VIRTUAL_CALL(75, void, _SetPlatform8, ());
VIRTUAL_CALL(76, bool, _updateRttiParams13, ());
private:
GAME_IMPORT virtual bool OnFieldChanged(CRTTIField const*, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams14, ());
VIRTUAL_CALL(79, bool, _updateRttiParams15, ());
VIRTUAL_CALL(80, int64_t, _RunUnitTests7, ());
VIRTUAL_CALL(81, int64_t, _RunUnitTests8, ());
VIRTUAL_CALL(82, void, _SetPlatform9, ());
GAME_IMPORT virtual void Query(IBaseValidator&, ttl::vector<CRTTIObject*, ttl::vector_allocators::heap_allocator<CRTTIObject*>, 1>&) const;
protected:
GAME_IMPORT virtual void SetEngineObject(CGSObject*);
public:
VIRTUAL_CALL(85, MED::SModelOutfitGroup const*, _unassigned7, ());
VIRTUAL_CALL(86, MED::SModelOutfitGroup const*, _unassigned8, ());
VIRTUAL_CALL(87, int64_t, _RunUnitTests9, ());
VIRTUAL_CALL(88, int64_t, _RunUnitTests10, ());
VIRTUAL_CALL(89, int64_t, _RunUnitTests11, ());
VIRTUAL_CALL(90, int64_t, _RunUnitTests12, ());
VIRTUAL_CALL(91, int64_t, _RunUnitTests13, ());
VIRTUAL_CALL(92, int64_t, _RunUnitTests14, ());
VIRTUAL_CALL(93, int64_t, _RunUnitTests15, ());
VIRTUAL_CALL(94, int64_t, _RunUnitTests16, ());
VIRTUAL_CALL(95, void, _SetPlatform10, ());
GAME_IMPORT virtual ttl::string_base<char> toString() const;
VIRTUAL_CALL(97, void, _SetPlatform11, ());
VIRTUAL_CALL(98, void, _SetPlatform12, ());
VIRTUAL_CALL(99, bool, _updateRttiParams16, ());
VIRTUAL_CALL(100, void, _SetPlatform13, ());
VIRTUAL_CALL(101, void, _SetPlatform14, ());
VIRTUAL_CALL(102, void, _SetPlatform15, ());
VIRTUAL_CALL(103, void, _SetPlatform16, ());
VIRTUAL_CALL(104, void, _SetPlatform17, ());
VIRTUAL_CALL(105, void, _SetPlatform18, ());
VIRTUAL_CALL(106, void, _SetPlatform19, ());
private:
VIRTUAL_CALL(107, void, UnregisterInTimeHandlerManager, ());
public:
VIRTUAL_CALL(108, void, _UnregisterInTimeHandlerManager1, ());
VIRTUAL_CALL(109, void, _SetPlatform20, ());
VIRTUAL_CALL(110, void, _SetPlatform21, ());
VIRTUAL_CALL(111, void, _SetPlatform22, ());
VIRTUAL_CALL(112, void, _SetPlatform23, ());
VIRTUAL_CALL(113, void, _SetPlatform24, ());
VIRTUAL_CALL(114, void, _SetPlatform25, ());
VIRTUAL_CALL(115, void, _SetPlatform26, ());
VIRTUAL_CALL(116, void, _SetPlatform27, ());
VIRTUAL_CALL(117, void, _SetPlatform28, ());
VIRTUAL_CALL(118, void, _SetPlatform29, ());
VIRTUAL_CALL(119, void, _SetPlatform30, ());
VIRTUAL_CALL(120, void, _SetPlatform31, ());
GAME_IMPORT virtual void OnActivateOnModule();
VIRTUAL_CALL(122, void, _SetPlatform32, ());
VIRTUAL_CALL(123, void, _SetPlatform33, ());
VIRTUAL_CALL(124, void, _SetPlatform34, ());
VIRTUAL_CALL(125, void, _SetPlatform35, ());
VIRTUAL_CALL(126, void, _SetPlatform36, ());
VIRTUAL_CALL(127, void, _SetPlatform37, ());
VIRTUAL_CALL(128, void, _SetPlatform38, ());
VIRTUAL_CALL(129, void, _SetPlatform39, ());
VIRTUAL_CALL(130, void, _SetPlatform40, ());
VIRTUAL_CALL(131, void, _SetPlatform41, ());
VIRTUAL_CALL(132, void, _SetPlatform42, ());
VIRTUAL_CALL(133, void, _SetPlatform43, ());
VIRTUAL_CALL(134, void, _SetPlatform44, ());
VIRTUAL_CALL(135, void, _SetPlatform45, ());
VIRTUAL_CALL(136, void, _SetPlatform46, ());
VIRTUAL_CALL(137, void, _SetPlatform47, ());
VIRTUAL_CALL(138, void, _SetPlatform48, ());
VIRTUAL_CALL(139, void, _SetPlatform49, ());
VIRTUAL_CALL(140, bool, _updateRttiParams17, ());
GAME_IMPORT virtual void SetHiddenByLogicEditor(bool);
VIRTUAL_CALL(142, void, _SetPlatform50, ());
VIRTUAL_CALL(143, static bool, _ValidateVec43, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(144, static bool, _ValidateVec44, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(145, static bool, _ValidateVec45, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(146, static bool, _ValidateVec46, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(147, static bool, _ValidateVec47, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(148, static bool, _ValidateVec48, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(149, static bool, _ValidateVec49, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(150, static bool, _ValidateVec410, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(151, static bool, _ValidateVec411, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(152, static bool, _ValidateVec412, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(153, static bool, _ValidateVec413, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(154, static bool, _ValidateVec414, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(155, static bool, _ValidateVec415, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(156, static bool, _ValidateVec416, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(157, static bool, _ValidateVec417, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(158, static bool, _ValidateVec418, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(159, static bool, _ValidateVec419, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(160, static bool, _ValidateVec420, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(161, static bool, _ValidateVec421, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(162, static bool, _ValidateVec422, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(163, static bool, _ValidateVec423, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(164, static bool, _ValidateVec424, (IGSObject const* a1, vec4 const& a2), a1, a2);
GAME_IMPORT virtual void SetSerializable(bool);
VIRTUAL_CALL(166, void, _SetPlatform51, ());
VIRTUAL_CALL(167, bool, _updateRttiParams18, ());
VIRTUAL_CALL(168, bool, _updateRttiParams19, ());
GAME_IMPORT virtual void DeactivateOnModule();
VIRTUAL_CALL(170, void, _SetPlatform52, ());
VIRTUAL_CALL(171, ttl::list<SCommandParam, ttl::allocator>::const_reverse_iterator, rend, ());
VIRTUAL_CALL(172, void, _SetPlatform53, ());
GAME_IMPORT virtual bool ISharedObject_IsValid() const;
GAME_IMPORT virtual float GetTime() const;
GAME_IMPORT virtual float GetLastTime() const;
GAME_IMPORT virtual float GetTimeDelta() const;
GAME_IMPORT virtual int64_t GetTimeDeltaMiliseconds() const;
GAME_IMPORT void DisableOnFrameEditorHandler();
GAME_IMPORT void EnableOnPostUpdateEditorHandler();
GAME_IMPORT void CallMethodEvery(CRTTIVoidMethod const*, float, float) const;
GAME_IMPORT ttl::string_const<char> GetPresetsDataStr() const;
GAME_IMPORT float ReplGetRelevance(unsigned short) const;
GAME_IMPORT IGSObject* CreateObjectWithID(rtti::Type const&, int, bool, ttl::string_base<char> const*);
GAME_IMPORT IGpuFx_Manager* GetGpuFxManager();
GAME_IMPORT virtual void OnKeyboardClosed(ttl::string_base<wchar_t>);
GAME_IMPORT uint32_t EditorGetAttributeMarkedToSaveCount() const;
GAME_IMPORT bool ReplIsOwner() const;
GAME_IMPORT bool ReplIsReplicated() const;
GAME_IMPORT void CallMethodIn(CRTTIVoidMethod const*, float) const;
GAME_IMPORT bool EditorIsSelected() const;
GAME_IMPORT bool ReplIsReplicable() const;
GAME_IMPORT ttl::string_base<char> ReplGetRequestingString() const;
GAME_IMPORT void EnableOnFrameHandler(EFrameHandlerPriority::TYPE, bool);
GAME_IMPORT bool IsActiveOnModule() const;
GAME_IMPORT void DisableOnPostAnimUpdateHandler();
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT void SetGSOFlags(uint32_t64_t);
GAME_IMPORT void SetComment(ttl::string_base<wchar_t> const&);
GAME_IMPORT void EnableOnPostUpdateHandler(EFrameHandlerPriority::TYPE, bool);
GAME_IMPORT ILevel* GetLevel() const;
GAME_IMPORT void MakePrivate(IGSObject*);
GAME_IMPORT void SetLevel(CLevel*, bool);
GAME_IMPORT void SetAndProcessPresets(ttl::string_base<char> const&);
GAME_IMPORT EMem::TYPE GetMemCategory();
private:
GAME_IMPORT void ActivateOnModuleInternal();
public:
GAME_IMPORT char const* GetNameCStr() const;
GAME_IMPORT IGSObject* CreateObjectWithID(CRTTI const&, int, bool, ttl::string_base<char> const*);
GAME_IMPORT void DisableOnPostAnimatorUpdateHandler();
GAME_IMPORT int GetLocalClientId() const;
GAME_IMPORT float ReplGetRelevance() const;
GAME_IMPORT void ProcessPresets(PresetId);
GAME_IMPORT void SetName(ttl::string_base<char> const&);
GAME_IMPORT ttl::string_base<char> const GetNameAndClass() const;
GAME_IMPORT IGSObject* CreateObject(EEntityRootType::TYPE, CRTTI const&, std::optional<Replication::CreateObjectOptions>, bool, ttl::string_base<char> const*);
GAME_IMPORT void AcquireObjectModule(IGSObject*);
GAME_IMPORT void RequestOwnership();
GAME_IMPORT bool IsCreating() const;
GAME_IMPORT ttl::string_base<char> GetName() const;
GAME_IMPORT void DisableCallMethod(CRTTIVoidMethod const*) const;
GAME_IMPORT void MultiRaytest(unsigned char, vec3 const&, ttl::vector<vec3, ttl::vector_allocators::heap_allocator<vec3>, 0> const&, ttl::vector<bool, ttl::vector_allocators::heap_allocator<bool>, 8>&, unsigned short, bool, IControlObject*, cbs::CEntity*, uint32_t, unsigned short, int64_t);
GAME_IMPORT wchar_t const* GetComment() const;
private:
GAME_IMPORT void DeactivateOnModuleInternal();
public:
GAME_IMPORT unsigned char ReplGetObjectIdx() const;
GAME_IMPORT IGSObject(IGSObject const&);
GAME_IMPORT void EnableOnPostAnimatorUpdateHandler();
GAME_IMPORT void ReplSetLocalReplicationInterval(float, float);
GAME_IMPORT void EditorRemoveAtCompilation(bool);
GAME_IMPORT bool IsLevelShutdown();
GAME_IMPORT void EnableOnPostAnimUpdateHandler();
GAME_IMPORT uint32_t64_t GetGSOFlags() const;
GAME_IMPORT CRTTIField const* EditorGetAttributeMarkedToSave(uint32_t) const;
GAME_IMPORT void EditorMarkAttributeToSave(ttl::string_base<char> const&);
GAME_IMPORT void FinalizeReplicationObject();
protected:
GAME_IMPORT IGSObject();
public:
GAME_IMPORT void InitializeReplicationObject(Replication::CreateObjectOptions);
GAME_IMPORT void EnableOnPreAnimUpdateHandler();
GAME_IMPORT void ReplSetRelevance(float);
GAME_IMPORT IGSObject* GetPrivateOwner();
GAME_IMPORT IGSObject& operator=(IGSObject const&);
GAME_IMPORT void PreDestroy();
private:
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
public:
GAME_IMPORT unsigned char Raytrace(unsigned char, SCollision*, vec3 const&, vec3&, unsigned short, bool, IControlObject*, uint32_t, unsigned short, int64_t, ttl::span<cbs::CEntity const*, 4294967295>);
GAME_IMPORT IGSObject(ClassReaderResolve const&);
GAME_IMPORT bool ReplIsAuthoritative() const;
GAME_IMPORT void DisableOnPostUpdateEditorHandler();
GAME_IMPORT Net::Repl::CObjectId ReplGetId() const;
GAME_IMPORT uint32_t PlayAudioEvent(ttl::string_base<char> const&, Audio::SAudioEventExtraData const*, vec3 const&);
GAME_IMPORT bool EditorIsRemoveAtCompilationSet();
GAME_IMPORT bool ReplIsBlockChangeOwnership() const;
GAME_IMPORT PresetId GetPresetsId() const;
GAME_IMPORT void ProcessPresets(ttl::string_base<char> const&);
GAME_IMPORT Replication::IObject const& ReplicationObject() const;
GAME_IMPORT ttl::string_base<char> ReplGetAuthoritativeString() const;
GAME_IMPORT void SetIGSOFlags(uint32_t64_t);
private:
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
public:
GAME_IMPORT void DisableOnPreAnimUpdateHandler();
GAME_IMPORT unsigned short ReplGetOwnerId() const;
GAME_IMPORT void ActivateOnModule();
GAME_IMPORT static rtti::Type& typeinfo();
GAME_IMPORT IGSObject* CreateObjectWithGuid(rtti::Type const&, uint32_t64_t, bool, ttl::string_base<char> const*);
GAME_IMPORT void ReplBlockChangeOwnership(bool);
GAME_IMPORT void ReplSendNow();
GAME_IMPORT void ReplSetRelevance(unsigned short, float);
GAME_IMPORT bool Raytest(unsigned char, vec3 const&, vec3 const&, unsigned short, bool, IControlObject*, uint32_t, unsigned short, int64_t, ttl::span<cbs::CEntity const*, 4294967295>);
GAME_IMPORT void DeleteThis();
GAME_IMPORT bool EditorIsNeverStatic() const;
GAME_IMPORT void DisableOnPostUpdateHandler();
GAME_IMPORT void ClearGSOFlags(uint32_t64_t);
GAME_IMPORT void DisableOnFrameHandler();
GAME_IMPORT unsigned short ReplGetAuthoritativeId() const;
GAME_IMPORT void SetReplicationRelevance(float);
GAME_IMPORT void InitObject(IGSObject*);
GAME_IMPORT IGSObject* CreateObject(EEntityRootType::TYPE, CRTTI const&, bool, ttl::string_base<char> const*, bool);
GAME_IMPORT void ClearIGSOFlags(uint32_t64_t);
GAME_IMPORT static void RegisterSTTI(CRTTI*);
GAME_IMPORT void EnableOnFrameEditorHandler();
GAME_IMPORT bool ReplIsOwnerNoLocal() const;
GAME_IMPORT IGSObject* GetNext() const;
GAME_IMPORT IGSObject* CreateObjectWithGuid(CRTTI const&, uint32_t64_t, bool, ttl::string_base<char> const*);
GAME_IMPORT bool IsDestroying() const;
GAME_IMPORT bool IsCreated() const;
GAME_IMPORT int GetNetOwnerID() const;
GAME_IMPORT bool IsPrivate() const;
GAME_IMPORT bool GetNetIsUniqueOwner() const;
GAME_IMPORT int GetID() const;
GAME_IMPORT void SetAndProcessPresets(PresetId);
GAME_IMPORT bool IsDestroyed() const;
GAME_IMPORT void SetIsReplicationEnabled(bool);
#pragma endregion
};

12
_IDAScripts/generated/IObject-unclean.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include <EGSDK\Imports.h>
class IObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, void __fastcall, SetPlatform, ());
VIRTUAL_CALL(1, IObject *__fastcall, sub_11DE70, (char a1), a1);
GAME_IMPORT IObject();
#pragma endregion
};

12
_IDAScripts/generated/IObject.h Normal file
View File

@ -0,0 +1,12 @@
#pragma once
#include <EGSDK\Imports.h>
class IObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, void, SetPlatform, ());
VIRTUAL_CALL(1, IObject*, sub_11DE70, (char a1), a1);
GAME_IMPORT IObject();
#pragma endregion
};

16
_IDAScripts/generated/IPtrResolver-unclean.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <EGSDK\Imports.h>
class IPtrResolver {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, _QWORD *__fastcall, sub_C5AF60, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
VIRTUAL_CALL(3, __int64, RunUnitTests, ());
VIRTUAL_CALL(4, void __fastcall, SetPlatform, ());
VIRTUAL_CALL(5, __int64, _RunUnitTests1, ());
VIRTUAL_CALL(6, __int64, _RunUnitTests2, ());
VIRTUAL_CALL(7, void __fastcall, _SetPlatform1, ());
#pragma endregion
};

16
_IDAScripts/generated/IPtrResolver.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <EGSDK\Imports.h>
class IPtrResolver {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_C5AF60, (char a1), a1);
virtual void _StrippedVFunc1() = 0;
virtual void _StrippedVFunc2() = 0;
VIRTUAL_CALL(3, int64_t, RunUnitTests, ());
VIRTUAL_CALL(4, void, SetPlatform, ());
VIRTUAL_CALL(5, int64_t, _RunUnitTests1, ());
VIRTUAL_CALL(6, int64_t, _RunUnitTests2, ());
VIRTUAL_CALL(7, void, _SetPlatform1, ());
#pragma endregion
};

22
_IDAScripts/generated/IScriptManager-unclean.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
#include <EGSDK\Imports.h>
class IScriptManager {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, _QWORD *__fastcall, sub_1207C0, (char a1), a1);
private:
VIRTUAL_CALL(1, static void, RunAllInitializationCallbacks, ());
public:
VIRTUAL_CALL(2, void __fastcall, SetPlatform, ());
VIRTUAL_CALL(3, void __fastcall, _SetPlatform1, ());
virtual void _StrippedVFunc1() = 0;
VIRTUAL_CALL(5, void __fastcall, _SetPlatform2, ());
VIRTUAL_CALL(6, bool, updateRttiParams, ());
GAME_IMPORT static bool AddInitializationCallback(void (*)(void));
GAME_IMPORT static void RegisterForceUsage(class CRTTI &);
GAME_IMPORT IScriptManager();
GAME_IMPORT static void RegisterForceUsage(class rtti::Type &);
#pragma endregion
};

22
_IDAScripts/generated/IScriptManager.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
#include <EGSDK\Imports.h>
class IScriptManager {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_1207C0, (char a1), a1);
private:
VIRTUAL_CALL(1, static void, RunAllInitializationCallbacks, ());
public:
VIRTUAL_CALL(2, void, SetPlatform, ());
VIRTUAL_CALL(3, void, _SetPlatform1, ());
virtual void _StrippedVFunc1() = 0;
VIRTUAL_CALL(5, void, _SetPlatform2, ());
VIRTUAL_CALL(6, bool, updateRttiParams, ());
GAME_IMPORT static bool AddInitializationCallback(void (* )(void));
GAME_IMPORT static void RegisterForceUsage(CRTTI&);
GAME_IMPORT IScriptManager();
GAME_IMPORT static void RegisterForceUsage(rtti::Type&);
#pragma endregion
};

39
_IDAScripts/generated/MED-unclean.h Normal file
View File

@ -0,0 +1,39 @@
#pragma once
#include <EGSDK\Imports.h>
class MED {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT enum MED::HeadType StringToHeadType(class ttl::string_base<char> const &);
GAME_IMPORT enum MED::SkeletonType StringToSkeletonType(class ttl::string_base<char> const &);
GAME_IMPORT class ttl::string_const<char> editorSceneEnvprobeFilename(class cbs::CComponent const &);
GAME_IMPORT enum MED::EPropertyConfig operator|(enum MED::EPropertyConfig, enum MED::EPropertyConfig);
GAME_IMPORT class ttl::string_const<char> SkeletonTypeToString(enum MED::SkeletonType);
GAME_IMPORT struct MED::SEditorSceneSetupData const * editorSceneSetupDataByPrefabName(class ttl::string_const<char>);
GAME_IMPORT class ttl::string_base<char> join_strings(class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> const &, class ttl::string_base<char> const &);
GAME_IMPORT class ttl::string_base<char> trimText(class ttl::string_base<char> const &, char const *);
GAME_IMPORT enum MED::EPropertyConfig operator&(enum MED::EPropertyConfig, enum MED::EPropertyConfig);
GAME_IMPORT unsigned int splitIndexedString(class ttl::string_base<char> const &, class ttl::string_base<char> &, char const *);
GAME_IMPORT bool operator==(struct MED::EnumItemType const &, struct MED::EnumItemType const &);
GAME_IMPORT class ttl::string_base<char> LodVisibilityPresetString(enum MED::LodVisibilityPreset);
GAME_IMPORT struct MED::SEditorSceneSetupData const & editorSceneSetupData(enum MED::EditorSceneSetup);
GAME_IMPORT class ttl::string_base<char> join_strings(class std::initializer_list<class ttl::string_base<char>> const &, class ttl::string_base<char> const &);
GAME_IMPORT enum MED::ModelUsage ModelUsageFromFileName(class ttl::string_const<char>);
GAME_IMPORT bool operator!=(struct MED::EnumItemType const &, struct MED::EnumItemType const &);
GAME_IMPORT bool operator!=(struct MED::EnumGroupType const &, struct MED::EnumGroupType const &);
GAME_IMPORT class ttl::string_const<char> StringFromModelUsage(enum MED::ModelUsage);
GAME_IMPORT bool isRunningInEditor();
GAME_IMPORT struct MED::TextList const & DefaultPlayersNames();
GAME_IMPORT class ttl::string_base<char> HeadTypeToString(enum MED::HeadType);
GAME_IMPORT class ttl::string_base<char> ModelSlotPresetTypeString(enum MED::ModelSlotPresetType);
GAME_IMPORT enum MED::ModelUsage ModelUsageFromString(class ttl::string_const<char>);
GAME_IMPORT bool operator==(struct MED::EnumGroupType const &, struct MED::EnumGroupType const &);
GAME_IMPORT enum MED::SkeletonType DetectSkeletonTypeFromName(class ttl::string_base<char> const &);
GAME_IMPORT class ttl::string_base<char> join_strings(class ttl::set<class ttl::string_base<char>, struct ttl::less<class ttl::string_base<char>>, class ttl::allocator> const &, class ttl::string_base<char> const &);
GAME_IMPORT class ttl::string_base<char> uniqueIndexedString(class ttl::string_base<char> const &, char, class std::function<bool (class ttl::string_base<char> const &)>);
GAME_IMPORT class ttl::string_base<char> normalizeToAscii(class ttl::string_base<char> const &, char, class ttl::string_base<char> const &);
GAME_IMPORT bool disableRunningInEditor();
GAME_IMPORT bool isRunningInGame();
GAME_IMPORT void restoreRunningInEditor(bool);
#pragma endregion
};

186
_IDAScripts/generated/MED.h Normal file
View File

@ -0,0 +1,186 @@
#pragma once
#include <functional>
#include <EGSDK\Imports.h>
#include <EGSDK\Engine\ttl\string_base.h>
#include <EGSDK\Engine\ttl\string_const.h>
#include <EGSDK\Engine\ttl\map.h>
#include <EGSDK\Engine\ttl\less.h>
#include <EGSDK\Engine\ttl\list.h>
#include <EGSDK\Engine\ttl\set.h>
#include <EGSDK\Engine\ttl\vector.h>
#include <EGSDK\Engine\ttl\allocator.h>
#include <EGSDK\Engine\ttl\vector_allocators\heap_allocator.h>
#include <EGSDK\Engine\parser.h>
#include <EGSDK\Engine\IMaterial.h>
#include <EGSDK\Engine\MaterialEditorCommon.h>
class cbs {
public:
class CComponent;
};
class MED {
public:
enum HeadType;
enum SkeletonType;
enum EPropertyConfig;
enum ModelUsage;
enum EnumItemType;
enum EnumGroupType;
enum ModelSlotPresetType;
enum LodVisibilityPreset;
enum EditorSceneSetup;
struct SEditorSceneSetupData {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT SEditorSceneSetupData();
#pragma endregion
};
struct SModelOutfitGroup {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static char const* const UNASSIGNED_GROUP_NAME;
GAME_IMPORT SModelOutfitGroup();
GAME_IMPORT void write(parser::writer*) const;
GAME_IMPORT SModelOutfitGroup(MED::SModelOutfitGroup&&);
GAME_IMPORT bool isUnassignedName() const;
GAME_IMPORT bool read(parser::func_iterator const&);
GAME_IMPORT MED::SModelOutfitGroup& operator=(MED::SModelOutfitGroup&&);
GAME_IMPORT ttl::string_base<char> labelText() const;
GAME_IMPORT bool operator==(MED::SModelOutfitGroup const&) const;
GAME_IMPORT SModelOutfitGroup(MED::SModelOutfitGroup const&);
GAME_IMPORT MED::SModelOutfitGroup& operator=(MED::SModelOutfitGroup const&);
GAME_IMPORT ttl::string_base<char> toDebugString() const;
#pragma endregion
};
class CMaterialTemplate {
public:
struct FieldDefinition {
#pragma region GENERATED by ExportClassToCPPH.py
private:
GAME_IMPORT bool isSection(ttl::string_base<char> const&);
public:
GAME_IMPORT bool isTypeSupported();
GAME_IMPORT FieldDefinition(MED::CMaterialTemplate::FieldDefinition const&);
GAME_IMPORT ttl::string_const<char> parameterCategory() const;
private:
GAME_IMPORT void initialize(MaterialEditorCommon::TemplateDesc::Parameter&);
public:
GAME_IMPORT ttl::string_base<char> getDescription() const;
GAME_IMPORT ttl::string_const<char> typeString() const;
GAME_IMPORT ttl::string_base<char> toDebugString() const;
GAME_IMPORT FieldDefinition(MED::CMaterialTemplate::FieldDefinition&&);
GAME_IMPORT MED::CMaterialTemplate::FieldDefinition& operator=(MED::CMaterialTemplate::FieldDefinition&&);
private:
GAME_IMPORT ttl::string_base<char> section(ttl::string_base<char> const&);
public:
GAME_IMPORT ttl::map<int, ttl::string_base<char>, ttl::less<int>, ttl::allocator> const& mapEnum() const;
GAME_IMPORT bool isTypeString() const;
GAME_IMPORT bool isFieldVisible();
GAME_IMPORT ttl::string_const<char> parameterLabel() const;
GAME_IMPORT ttl::string_base<char> parameterLowercaseLabel() const;
GAME_IMPORT FieldDefinition();
private:
GAME_IMPORT static ttl::string_base<char> normalizeCategoryName(ttl::string_base<char>);
public:
GAME_IMPORT parser::EVarType const& type() const;
private:
GAME_IMPORT ttl::map<int, ttl::string_base<char>, ttl::less<int>, ttl::allocator> decodeEnum(ttl::string_base<char> const&);
public:
GAME_IMPORT ttl::string_base<char> parameterPath() const;
GAME_IMPORT MED::CMaterialTemplate::FieldDefinition& operator=(MED::CMaterialTemplate::FieldDefinition const&);
GAME_IMPORT bool isPresetValueEmpty() const;
#pragma endregion
};
struct Parameter {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT ttl::string_base<char> toNameString();
GAME_IMPORT MED::CMaterialTemplate::Parameter& operator=(MED::CMaterialTemplate::Parameter const&);
GAME_IMPORT Parameter(MED::CMaterialTemplate::Parameter&&);
GAME_IMPORT void initialize(MED::CMaterialTemplate::FieldDefinition&);
GAME_IMPORT Parameter();
GAME_IMPORT MED::CMaterialTemplate::Parameter& operator=(MED::CMaterialTemplate::Parameter&&);
GAME_IMPORT Parameter(MED::CMaterialTemplate::Parameter const&);
GAME_IMPORT ttl::string_base<char> toString();
#pragma endregion
};
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, MED::CMaterialTemplate*, sub_11C2D0, (char a1), a1);
GAME_IMPORT void queryData(IMaterial*);
GAME_IMPORT static std::initializer_list<ttl::string_base<char>>& fixedMaterialParametersLabelsForSearch();
GAME_IMPORT CMaterialTemplate(MED::CMaterialTemplate const&);
GAME_IMPORT MaterialEditorCommon::TemplateDesc::Parameter const* parameter(parser::EVarType, ttl::string_base<char> const&) const;
GAME_IMPORT void getMaterialParametersByLabel(ttl::list<MED::CMaterialTemplate::Parameter, ttl::allocator>&, ttl::string_base<char> const&, ttl::string_base<char> const&);
GAME_IMPORT ttl::list<MED::CMaterialTemplate::FieldDefinition, ttl::allocator> const& fields();
GAME_IMPORT static std::initializer_list<ttl::string_base<char>>& fixedMaterialParametersLabelsForEdit();
GAME_IMPORT MED::CMaterialTemplate::FieldDefinition const* fieldByName(ttl::string_base<char> const&) const;
GAME_IMPORT CMaterialTemplate();
private:
GAME_IMPORT void updateFieldsDefinitions();
public:
GAME_IMPORT ttl::string_base<char> const presetEncodedString();
GAME_IMPORT MED::CMaterialTemplate& operator=(MED::CMaterialTemplate const&);
GAME_IMPORT void getMaterialParameters(ttl::list<MED::CMaterialTemplate::Parameter, ttl::allocator>&);
GAME_IMPORT static std::initializer_list<ttl::string_base<char>>& fixedMaterialParametersCategories();
GAME_IMPORT void clear();
#pragma endregion
};
struct TextList {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT bool contains(ttl::string_base<char> const&) const;
GAME_IMPORT TextList(std::initializer_list<ttl::string_base<char>>);
GAME_IMPORT TextList(MED::TextList&&);
GAME_IMPORT MED::TextList& operator=(MED::TextList&&);
GAME_IMPORT TextList(MED::TextList const&);
GAME_IMPORT bool starts(ttl::string_base<char> const&) const;
GAME_IMPORT MED::TextList& operator=(MED::TextList const&);
GAME_IMPORT bool match(ttl::string_base<char> const&) const;
#pragma endregion
};
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT MED::HeadType StringToHeadType(ttl::string_base<char> const&);
GAME_IMPORT MED::SkeletonType StringToSkeletonType(ttl::string_base<char> const&);
GAME_IMPORT ttl::string_const<char> editorSceneEnvprobeFilename(cbs::CComponent const&);
GAME_IMPORT MED::EPropertyConfig operator|(MED::EPropertyConfig, MED::EPropertyConfig);
GAME_IMPORT ttl::string_const<char> SkeletonTypeToString(MED::SkeletonType);
GAME_IMPORT MED::SEditorSceneSetupData const* editorSceneSetupDataByPrefabName(ttl::string_const<char>);
GAME_IMPORT ttl::string_base<char> join_strings(ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1> const&, ttl::string_base<char> const&);
GAME_IMPORT ttl::string_base<char> trimText(ttl::string_base<char> const&, char const*);
GAME_IMPORT MED::EPropertyConfig operator&(MED::EPropertyConfig, MED::EPropertyConfig);
GAME_IMPORT uint32_t splitIndexedString(ttl::string_base<char> const&, ttl::string_base<char>&, char const*);
GAME_IMPORT bool operator==(MED::EnumItemType const&, MED::EnumItemType const&);
GAME_IMPORT ttl::string_base<char> LodVisibilityPresetString(MED::LodVisibilityPreset);
GAME_IMPORT MED::SEditorSceneSetupData const& editorSceneSetupData(MED::EditorSceneSetup);
GAME_IMPORT ttl::string_base<char> join_strings(std::initializer_list<ttl::string_base<char>> const&, ttl::string_base<char> const&);
GAME_IMPORT MED::ModelUsage ModelUsageFromFileName(ttl::string_const<char>);
GAME_IMPORT bool operator!=(MED::EnumItemType const&, MED::EnumItemType const&);
GAME_IMPORT bool operator!=(MED::EnumGroupType const&, MED::EnumGroupType const&);
GAME_IMPORT ttl::string_const<char> StringFromModelUsage(MED::ModelUsage);
GAME_IMPORT bool isRunningInEditor();
GAME_IMPORT MED::TextList const& DefaultPlayersNames();
GAME_IMPORT ttl::string_base<char> HeadTypeToString(MED::HeadType);
GAME_IMPORT ttl::string_base<char> ModelSlotPresetTypeString(MED::ModelSlotPresetType);
GAME_IMPORT MED::ModelUsage ModelUsageFromString(ttl::string_const<char>);
GAME_IMPORT bool operator==(MED::EnumGroupType const&, MED::EnumGroupType const&);
GAME_IMPORT MED::SkeletonType DetectSkeletonTypeFromName(ttl::string_base<char> const&);
GAME_IMPORT ttl::string_base<char> join_strings(ttl::set<ttl::string_base<char>, ttl::less<ttl::string_base<char>>, ttl::allocator> const&, ttl::string_base<char> const&);
GAME_IMPORT ttl::string_base<char> uniqueIndexedString(ttl::string_base<char> const&, char, std::function<bool ( ttl::string_base<char> const& )>);
GAME_IMPORT ttl::string_base<char> normalizeToAscii(ttl::string_base<char> const&, char, ttl::string_base<char> const&);
GAME_IMPORT bool disableRunningInEditor();
GAME_IMPORT bool isRunningInGame();
GAME_IMPORT void restoreRunningInEditor(bool);
#pragma endregion
};

27
_IDAScripts/generated/MED/CMaterialTemplate-unclean.h Normal file
View File

@ -0,0 +1,27 @@
#pragma once
#include <EGSDK\Imports.h>
class CMaterialTemplate {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, MED::CMaterialTemplate *__fastcall, sub_11C2D0, (char a1), a1);
GAME_IMPORT void queryData(class IMaterial *);
GAME_IMPORT static class std::initializer_list<class ttl::string_base<char>> & fixedMaterialParametersLabelsForSearch();
GAME_IMPORT CMaterialTemplate(class MED::CMaterialTemplate const &);
GAME_IMPORT struct MaterialEditorCommon::TemplateDesc::Parameter const * parameter(enum parser::EVarType, class ttl::string_base<char> const &) const;
GAME_IMPORT void getMaterialParametersByLabel(class ttl::list<struct MED::CMaterialTemplate::Parameter, class ttl::allocator> &, class ttl::string_base<char> const &, class ttl::string_base<char> const &);
GAME_IMPORT class ttl::list<struct MED::CMaterialTemplate::FieldDefinition, class ttl::allocator> const & fields();
GAME_IMPORT static class std::initializer_list<class ttl::string_base<char>> & fixedMaterialParametersLabelsForEdit();
GAME_IMPORT struct MED::CMaterialTemplate::FieldDefinition const * fieldByName(class ttl::string_base<char> const &) const;
GAME_IMPORT CMaterialTemplate();
private:
GAME_IMPORT void updateFieldsDefinitions();
public:
GAME_IMPORT class ttl::string_base<char> const presetEncodedString();
GAME_IMPORT class MED::CMaterialTemplate & operator=(class MED::CMaterialTemplate const &);
GAME_IMPORT void getMaterialParameters(class ttl::list<struct MED::CMaterialTemplate::Parameter, class ttl::allocator> &);
GAME_IMPORT static class std::initializer_list<class ttl::string_base<char>> & fixedMaterialParametersCategories();
GAME_IMPORT void clear();
#pragma endregion
};

27
_IDAScripts/generated/MED/CMaterialTemplate.h Normal file
View File

@ -0,0 +1,27 @@
#pragma once
#include <EGSDK\Imports.h>
class CMaterialTemplate {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, MED::CMaterialTemplate*, sub_11C2D0, (char a1), a1);
GAME_IMPORT void queryData(IMaterial*);
GAME_IMPORT static std::initializer_list<ttl::string_base<char>>& fixedMaterialParametersLabelsForSearch();
GAME_IMPORT CMaterialTemplate(MED::CMaterialTemplate const&);
GAME_IMPORT MaterialEditorCommon::TemplateDesc::Parameter const* parameter(parser::EVarType, ttl::string_base<char> const&) const;
GAME_IMPORT void getMaterialParametersByLabel(ttl::list<MED::CMaterialTemplate::Parameter, ttl::allocator>&, ttl::string_base<char> const&, ttl::string_base<char> const&);
GAME_IMPORT ttl::list<MED::CMaterialTemplate::FieldDefinition, ttl::allocator> const& fields();
GAME_IMPORT static std::initializer_list<ttl::string_base<char>>& fixedMaterialParametersLabelsForEdit();
GAME_IMPORT MED::CMaterialTemplate::FieldDefinition const* fieldByName(ttl::string_base<char> const&) const;
GAME_IMPORT CMaterialTemplate();
private:
GAME_IMPORT void updateFieldsDefinitions();
public:
GAME_IMPORT ttl::string_base<char> const presetEncodedString();
GAME_IMPORT MED::CMaterialTemplate& operator=(MED::CMaterialTemplate const&);
GAME_IMPORT void getMaterialParameters(ttl::list<MED::CMaterialTemplate::Parameter, ttl::allocator>&);
GAME_IMPORT static std::initializer_list<ttl::string_base<char>>& fixedMaterialParametersCategories();
GAME_IMPORT void clear();
#pragma endregion
};

40
_IDAScripts/generated/MED/CMaterialTemplate/FieldDefinition-unclean.h Normal file
View File

@ -0,0 +1,40 @@
#pragma once
#include <EGSDK\Imports.h>
struct FieldDefinition {
#pragma region GENERATED by ExportClassToCPPH.py
private:
GAME_IMPORT bool isSection(class ttl::string_base<char> const &);
public:
GAME_IMPORT bool isTypeSupported();
GAME_IMPORT FieldDefinition(struct MED::CMaterialTemplate::FieldDefinition const &);
GAME_IMPORT class ttl::string_const<char> parameterCategory() const;
private:
GAME_IMPORT void initialize(struct MaterialEditorCommon::TemplateDesc::Parameter &);
public:
GAME_IMPORT class ttl::string_base<char> getDescription() const;
GAME_IMPORT class ttl::string_const<char> typeString() const;
GAME_IMPORT class ttl::string_base<char> toDebugString() const;
GAME_IMPORT FieldDefinition(struct MED::CMaterialTemplate::FieldDefinition &&);
GAME_IMPORT struct MED::CMaterialTemplate::FieldDefinition & operator=(struct MED::CMaterialTemplate::FieldDefinition &&);
private:
GAME_IMPORT class ttl::string_base<char> section(class ttl::string_base<char> const &);
public:
GAME_IMPORT class ttl::map<int, class ttl::string_base<char>, struct ttl::less<int>, class ttl::allocator> const & mapEnum() const;
GAME_IMPORT bool isTypeString() const;
GAME_IMPORT bool isFieldVisible();
GAME_IMPORT class ttl::string_const<char> parameterLabel() const;
GAME_IMPORT class ttl::string_base<char> parameterLowercaseLabel() const;
GAME_IMPORT FieldDefinition();
private:
GAME_IMPORT static class ttl::string_base<char> normalizeCategoryName(class ttl::string_base<char>);
public:
GAME_IMPORT enum parser::EVarType const & type() const;
private:
GAME_IMPORT class ttl::map<int, class ttl::string_base<char>, struct ttl::less<int>, class ttl::allocator> decodeEnum(class ttl::string_base<char> const &);
public:
GAME_IMPORT class ttl::string_base<char> parameterPath() const;
GAME_IMPORT struct MED::CMaterialTemplate::FieldDefinition & operator=(struct MED::CMaterialTemplate::FieldDefinition const &);
GAME_IMPORT bool isPresetValueEmpty() const;
#pragma endregion
};

40
_IDAScripts/generated/MED/CMaterialTemplate/FieldDefinition.h Normal file
View File

@ -0,0 +1,40 @@
#pragma once
#include <EGSDK\Imports.h>
struct FieldDefinition {
#pragma region GENERATED by ExportClassToCPPH.py
private:
GAME_IMPORT bool isSection(ttl::string_base<char> const&);
public:
GAME_IMPORT bool isTypeSupported();
GAME_IMPORT FieldDefinition(MED::CMaterialTemplate::FieldDefinition const&);
GAME_IMPORT ttl::string_const<char> parameterCategory() const;
private:
GAME_IMPORT void initialize(MaterialEditorCommon::TemplateDesc::Parameter&);
public:
GAME_IMPORT ttl::string_base<char> getDescription() const;
GAME_IMPORT ttl::string_const<char> typeString() const;
GAME_IMPORT ttl::string_base<char> toDebugString() const;
GAME_IMPORT FieldDefinition(MED::CMaterialTemplate::FieldDefinition& &);
GAME_IMPORT MED::CMaterialTemplate::FieldDefinition& operator=(MED::CMaterialTemplate::FieldDefinition& &);
private:
GAME_IMPORT ttl::string_base<char> section(ttl::string_base<char> const&);
public:
GAME_IMPORT ttl::map<int, ttl::string_base<char>, ttl::less<int>, ttl::allocator> const& mapEnum() const;
GAME_IMPORT bool isTypeString() const;
GAME_IMPORT bool isFieldVisible();
GAME_IMPORT ttl::string_const<char> parameterLabel() const;
GAME_IMPORT ttl::string_base<char> parameterLowercaseLabel() const;
GAME_IMPORT FieldDefinition();
private:
GAME_IMPORT static ttl::string_base<char> normalizeCategoryName(ttl::string_base<char>);
public:
GAME_IMPORT parser::EVarType const& type() const;
private:
GAME_IMPORT ttl::map<int, ttl::string_base<char>, ttl::less<int>, ttl::allocator> decodeEnum(ttl::string_base<char> const&);
public:
GAME_IMPORT ttl::string_base<char> parameterPath() const;
GAME_IMPORT MED::CMaterialTemplate::FieldDefinition& operator=(MED::CMaterialTemplate::FieldDefinition const&);
GAME_IMPORT bool isPresetValueEmpty() const;
#pragma endregion
};

16
_IDAScripts/generated/MED/CMaterialTemplate/Parameter-unclean.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <EGSDK\Imports.h>
struct Parameter {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT class ttl::string_base<char> toNameString();
GAME_IMPORT struct MED::CMaterialTemplate::Parameter & operator=(struct MED::CMaterialTemplate::Parameter const &);
GAME_IMPORT Parameter(struct MED::CMaterialTemplate::Parameter &&);
GAME_IMPORT void initialize(struct MED::CMaterialTemplate::FieldDefinition &);
GAME_IMPORT Parameter();
GAME_IMPORT struct MED::CMaterialTemplate::Parameter & operator=(struct MED::CMaterialTemplate::Parameter &&);
GAME_IMPORT Parameter(struct MED::CMaterialTemplate::Parameter const &);
GAME_IMPORT class ttl::string_base<char> toString();
#pragma endregion
};

16
_IDAScripts/generated/MED/CMaterialTemplate/Parameter.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <EGSDK\Imports.h>
struct Parameter {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT ttl::string_base<char> toNameString();
GAME_IMPORT MED::CMaterialTemplate::Parameter& operator=(MED::CMaterialTemplate::Parameter const&);
GAME_IMPORT Parameter(MED::CMaterialTemplate::Parameter& &);
GAME_IMPORT void initialize(MED::CMaterialTemplate::FieldDefinition&);
GAME_IMPORT Parameter();
GAME_IMPORT MED::CMaterialTemplate::Parameter& operator=(MED::CMaterialTemplate::Parameter& &);
GAME_IMPORT Parameter(MED::CMaterialTemplate::Parameter const&);
GAME_IMPORT ttl::string_base<char> toString();
#pragma endregion
};

9
_IDAScripts/generated/MED/SEditorSceneSetupData-unclean.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
#include <EGSDK\Imports.h>
class SEditorSceneSetupData {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT SEditorSceneSetupData();
#pragma endregion
};

9
_IDAScripts/generated/MED/SEditorSceneSetupData.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
#include <EGSDK\Imports.h>
class SEditorSceneSetupData {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT SEditorSceneSetupData();
#pragma endregion
};

22
_IDAScripts/generated/MED/SModelOutfitGroup-unclean.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
#include <EGSDK\Imports.h>
struct SModelOutfitGroup {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static char const * const UNASSIGNED_GROUP_NAME;
GAME_IMPORT SModelOutfitGroup();
GAME_IMPORT void write(class parser::writer *) const;
GAME_IMPORT SModelOutfitGroup(struct MED::SModelOutfitGroup &&);
GAME_IMPORT bool isUnassignedName() const;
GAME_IMPORT bool read(class parser::func_iterator const &);
GAME_IMPORT struct MED::SModelOutfitGroup & operator=(struct MED::SModelOutfitGroup &&);
GAME_IMPORT class ttl::string_base<char> labelText() const;
GAME_IMPORT bool operator==(struct MED::SModelOutfitGroup const &) const;
GAME_IMPORT SModelOutfitGroup(struct MED::SModelOutfitGroup const &);
GAME_IMPORT struct MED::SModelOutfitGroup & operator=(struct MED::SModelOutfitGroup const &);
GAME_IMPORT class ttl::string_base<char> toDebugString() const;
#pragma endregion
};

22
_IDAScripts/generated/MED/SModelOutfitGroup.h Normal file
View File

@ -0,0 +1,22 @@
#pragma once
#include <EGSDK\Imports.h>
struct SModelOutfitGroup {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static char const* const UNASSIGNED_GROUP_NAME;
GAME_IMPORT SModelOutfitGroup();
GAME_IMPORT void write(parser::writer*) const;
GAME_IMPORT SModelOutfitGroup(MED::SModelOutfitGroup& &);
GAME_IMPORT bool isUnassignedName() const;
GAME_IMPORT bool read(parser::func_iterator const&);
GAME_IMPORT MED::SModelOutfitGroup& operator=(MED::SModelOutfitGroup& &);
GAME_IMPORT ttl::string_base<char> labelText() const;
GAME_IMPORT bool operator==(MED::SModelOutfitGroup const&) const;
GAME_IMPORT SModelOutfitGroup(MED::SModelOutfitGroup const&);
GAME_IMPORT MED::SModelOutfitGroup& operator=(MED::SModelOutfitGroup const&);
GAME_IMPORT ttl::string_base<char> toDebugString() const;
#pragma endregion
};

16
_IDAScripts/generated/MED/TextList-unclean.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <EGSDK\Imports.h>
struct TextList {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT bool contains(class ttl::string_base<char> const &) const;
GAME_IMPORT TextList(class std::initializer_list<class ttl::string_base<char>>);
GAME_IMPORT TextList(struct MED::TextList &&);
GAME_IMPORT struct MED::TextList & operator=(struct MED::TextList &&);
GAME_IMPORT TextList(struct MED::TextList const &);
GAME_IMPORT bool starts(class ttl::string_base<char> const &) const;
GAME_IMPORT struct MED::TextList & operator=(struct MED::TextList const &);
GAME_IMPORT bool match(class ttl::string_base<char> const &) const;
#pragma endregion
};

16
_IDAScripts/generated/MED/TextList.h Normal file
View File

@ -0,0 +1,16 @@
#pragma once
#include <EGSDK\Imports.h>
struct TextList {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT bool contains(ttl::string_base<char> const&) const;
GAME_IMPORT TextList(std::initializer_list<ttl::string_base<char>>);
GAME_IMPORT TextList(MED::TextList& &);
GAME_IMPORT MED::TextList& operator=(MED::TextList& &);
GAME_IMPORT TextList(MED::TextList const&);
GAME_IMPORT bool starts(ttl::string_base<char> const&) const;
GAME_IMPORT MED::TextList& operator=(MED::TextList const&);
GAME_IMPORT bool match(ttl::string_base<char> const&) const;
#pragma endregion
};

9
_IDAScripts/generated/Net/Repl/CRttiInfo-unclean.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
#include <EGSDK\Imports.h>
class CRttiInfo {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, _QWORD *__fastcall, sub_C5A6F0, (char a1), a1);
#pragma endregion
};

9
_IDAScripts/generated/Net/Repl/CRttiInfo.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
#include <EGSDK\Imports.h>
class CRttiInfo {
#pragma region GENERATED by ExportClassToCPPH.py
public:
VIRTUAL_CALL(0, uint64_t*, sub_C5A6F0, (char a1), a1);
#pragma endregion
};

26
_IDAScripts/generated/Uid-unclean.h Normal file
View File

@ -0,0 +1,26 @@
#pragma once
#include <EGSDK\Imports.h>
class Uid {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static class Uid const INVALID;
GAME_IMPORT Uid(class ttl::string_base<char> const &);
GAME_IMPORT class ttl::string_base<char> ToString() const;
GAME_IMPORT bool operator!() const;
GAME_IMPORT bool operator>(class Uid const &) const;
GAME_IMPORT Uid();
GAME_IMPORT bool Write(class ITextSerializer &, char const *) const;
GAME_IMPORT bool operator<=(class Uid const &) const;
GAME_IMPORT class Uid & operator=(class Uid const &);
GAME_IMPORT bool IsValid() const;
GAME_IMPORT bool operator!=(class Uid const &) const;
GAME_IMPORT Uid(__int64);
GAME_IMPORT bool operator>=(class Uid const &) const;
GAME_IMPORT void FromString(class ttl::string_base<char> const &);
GAME_IMPORT bool Read(class ITextDeserializer &, char const *);
GAME_IMPORT void Generate();
#pragma endregion
};

26
_IDAScripts/generated/Uid.h Normal file
View File

@ -0,0 +1,26 @@
#pragma once
#include <EGSDK\Imports.h>
class Uid {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static Uid const INVALID;
GAME_IMPORT Uid(ttl::string_base<char> const&);
GAME_IMPORT ttl::string_base<char> ToString() const;
GAME_IMPORT bool operator!() const;
GAME_IMPORT bool operator>(Uid const&) const;
GAME_IMPORT Uid();
GAME_IMPORT bool Write(ITextSerializer&, char const*) const;
GAME_IMPORT bool operator<=(Uid const&) const;
GAME_IMPORT Uid& operator=(Uid const&);
GAME_IMPORT bool IsValid() const;
GAME_IMPORT bool operator!=(Uid const&) const;
GAME_IMPORT Uid(int64_t);
GAME_IMPORT bool operator>=(Uid const&) const;
GAME_IMPORT void FromString(ttl::string_base<char> const&);
GAME_IMPORT bool Read(ITextDeserializer&, char const*);
GAME_IMPORT void Generate();
#pragma endregion
};

49
_IDAScripts/generated/cbs-unclean.h Normal file
View File

@ -0,0 +1,49 @@
#pragma once
#include <EGSDK\Imports.h>
class cbs {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT class cbs::PrefabManager * g_PrefabManager;
GAME_IMPORT void GetPECHierarchyPath(class ttl::span<class cbs::PrefabEntityComponent const * const, 4294967295>, unsigned int, class ttl::string_base<char> &);
GAME_IMPORT class cbs::CPcidPath operator+(class cbs::CPcidPathView, class cbs::CPcidPathView);
GAME_IMPORT void GatherSubtypeEntityInterfaces(class ttl::set<class CRTTI const *, struct ttl::less<class CRTTI const *>, class ttl::allocator> &, class CRTTIField const *);
GAME_IMPORT bool CreateEntityFromPrefabDeferred(class cbs::CPointer<class cbs::CEntity> &, class ttl::string_const<char>, class ILevel *, class mtx34 const &, struct PresetId, class Replication::CreateObjectOptions, bool);
GAME_IMPORT class cbs::CPcidPath operator+(class cbs::CPcidPath &&, class cbs::CPcidPath const &);
GAME_IMPORT bool operator!=(class cbs::CPointer<class cbs::CEntity>, class cbs::CEntityPointer);
GAME_IMPORT class cbs::CPcidPath operator+(class cbs::CPcidPath const &, class cbs::CPcidPathView);
GAME_IMPORT void GetEntityDebugHierarchyPath(class cbs::CEntity const *, class ttl::string_base<char> &);
GAME_IMPORT class cbs::ComponentsPool & GetComponentsPool();
GAME_IMPORT class CLevel * GetCLevel(struct cbs::WorldIndex);
GAME_IMPORT bool IsAnyAncestorAlwaysSpawned(class cbs::CPointer<class cbs::CEntity>);
GAME_IMPORT void GetPCIDHierarchyPath(class ttl::span<class cbs::PrefabEntityComponent const * const, 4294967295>, unsigned int, class ttl::string_base<char> &);
GAME_IMPORT bool operator!=(class cbs::CEntity const *, class cbs::CEntityPointer);
GAME_IMPORT class ILevel * GetILevel(struct cbs::WorldIndex);
GAME_IMPORT bool operator==(class cbs::CPointer<class cbs::CEntity>, class cbs::CEntityPointer);
GAME_IMPORT class cbs::CPcidPath operator+(class cbs::CPcidPathView, class cbs::CPcidPath const &);
GAME_IMPORT class IPhysicsManager * GetPhysicsManager(struct cbs::WorldIndex);
GAME_IMPORT bool GetPrefabEntityComponents(class cbs::CEntity const *, class ttl::vector<class cbs::PrefabEntityComponent const *, class ttl::vector_allocators::heap_allocator<class cbs::PrefabEntityComponent const *>, 16> &);
GAME_IMPORT enum cbs::EntitySpawnOrigin GetEntitySpawnOrigin(class cbs::CEntity const *);
GAME_IMPORT class cbs::PrefabManager & GetPrefabManager();
GAME_IMPORT float GetTimeDelta(struct cbs::WorldIndex);
GAME_IMPORT class ttl::string_base<char> GetEntityDebugInfoString(class cbs::CEntity const *);
GAME_IMPORT class cbs::CPointer<class cbs::CEntity> CreateEntityFromPrefab(class ttl::string_const<char>, class ILevel *, class mtx34 const &, class ttl::string_const<char>, class Replication::CreateObjectOptions, bool, bool);
GAME_IMPORT class cbs::CPcidPath operator+(enum cbs::pcid_t, class cbs::CPcidPath const &);
GAME_IMPORT enum cbs::EntitySpawnOrigin GetEntitySpawnOrigin(class cbs::PrefabEntityComponent const *);
GAME_IMPORT class cbs::CPcidPath operator+(class cbs::CPcidPath const &, enum cbs::pcid_t);
GAME_IMPORT class ttl::string_base<char> GetSpawnContextDebugInfoString(class SpawnContext const &);
GAME_IMPORT bool operator<(class cbs::CPcidPath const &, class cbs::CPcidPath const &);
GAME_IMPORT bool CreateEntityFromPrefabDeferred(class cbs::CPointer<class cbs::CEntity> &, class ttl::string_const<char>, class ILevel *, class mtx34 const &, class ttl::string_const<char>, class Replication::CreateObjectOptions, bool, bool);
GAME_IMPORT class cbs::CPointer<class cbs::CEntity> CreateEntityFromPrefab(class ttl::string_const<char>, class ILevel *, class mtx34 const &, struct PresetId, class Replication::CreateObjectOptions, bool);
GAME_IMPORT bool operator==(class cbs::CEntity const *, class cbs::CEntityPointer);
GAME_IMPORT bool IsInDynamicRoot(class cbs::CPointer<class cbs::CEntity>, bool);
GAME_IMPORT class cbs::CPcidPath operator+(class cbs::CPcidPath const &, class cbs::CPcidPath const &);
GAME_IMPORT float GetTime(struct cbs::WorldIndex);
GAME_IMPORT class cbs::CPointer<class cbs::CEntity> CreateEntityFromPrefab(class ttl::string_const<char>, class SpawnContext &);
GAME_IMPORT bool operator==(class cbs::CPcidPath const &, class cbs::CPcidPath const &);
GAME_IMPORT class cbs::EnumPropertyManager & GetEnumPropertyManager();
GAME_IMPORT bool CreateEntityFromPrefabDeferred(class cbs::CPointer<class cbs::CEntity> &, class ttl::string_const<char>, class SpawnContext &);
#pragma endregion
};

49
_IDAScripts/generated/cbs.h Normal file
View File

@ -0,0 +1,49 @@
#pragma once
#include <EGSDK\Imports.h>
class cbs {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT cbs::PrefabManager* g_PrefabManager;
GAME_IMPORT void GetPECHierarchyPath(ttl::span<cbs::PrefabEntityComponent const* const, 4294967295>, uint32_t, ttl::string_base<char>&);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPathView, cbs::CPcidPathView);
GAME_IMPORT void GatherSubtypeEntityInterfaces(ttl::set<CRTTI const*, ttl::less<CRTTI const*>, ttl::allocator>&, CRTTIField const*);
GAME_IMPORT bool CreateEntityFromPrefabDeferred(cbs::CPointer<cbs::CEntity>&, ttl::string_const<char>, ILevel*, mtx34 const&, PresetId, Replication::CreateObjectOptions, bool);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPath& &, cbs::CPcidPath const&);
GAME_IMPORT bool operator!=(cbs::CPointer<cbs::CEntity>, cbs::CEntityPointer);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPath const&, cbs::CPcidPathView);
GAME_IMPORT void GetEntityDebugHierarchyPath(cbs::CEntity const*, ttl::string_base<char>&);
GAME_IMPORT cbs::ComponentsPool& GetComponentsPool();
GAME_IMPORT CLevel* GetCLevel(cbs::WorldIndex);
GAME_IMPORT bool IsAnyAncestorAlwaysSpawned(cbs::CPointer<cbs::CEntity>);
GAME_IMPORT void GetPCIDHierarchyPath(ttl::span<cbs::PrefabEntityComponent const* const, 4294967295>, uint32_t, ttl::string_base<char>&);
GAME_IMPORT bool operator!=(cbs::CEntity const*, cbs::CEntityPointer);
GAME_IMPORT ILevel* GetILevel(cbs::WorldIndex);
GAME_IMPORT bool operator==(cbs::CPointer<cbs::CEntity>, cbs::CEntityPointer);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPathView, cbs::CPcidPath const&);
GAME_IMPORT IPhysicsManager* GetPhysicsManager(cbs::WorldIndex);
GAME_IMPORT bool GetPrefabEntityComponents(cbs::CEntity const*, ttl::vector<cbs::PrefabEntityComponent const*, ttl::vector_allocators::heap_allocator<cbs::PrefabEntityComponent const*>, 16>&);
GAME_IMPORT cbs::EntitySpawnOrigin GetEntitySpawnOrigin(cbs::CEntity const*);
GAME_IMPORT cbs::PrefabManager& GetPrefabManager();
GAME_IMPORT float GetTimeDelta(cbs::WorldIndex);
GAME_IMPORT ttl::string_base<char> GetEntityDebugInfoString(cbs::CEntity const*);
GAME_IMPORT cbs::CPointer<cbs::CEntity> CreateEntityFromPrefab(ttl::string_const<char>, ILevel*, mtx34 const&, ttl::string_const<char>, Replication::CreateObjectOptions, bool, bool);
GAME_IMPORT cbs::CPcidPath operator+(cbs::pcid_t, cbs::CPcidPath const&);
GAME_IMPORT cbs::EntitySpawnOrigin GetEntitySpawnOrigin(cbs::PrefabEntityComponent const*);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPath const&, cbs::pcid_t);
GAME_IMPORT ttl::string_base<char> GetSpawnContextDebugInfoString(SpawnContext const&);
GAME_IMPORT bool operator<(cbs::CPcidPath const&, cbs::CPcidPath const&);
GAME_IMPORT bool CreateEntityFromPrefabDeferred(cbs::CPointer<cbs::CEntity>&, ttl::string_const<char>, ILevel*, mtx34 const&, ttl::string_const<char>, Replication::CreateObjectOptions, bool, bool);
GAME_IMPORT cbs::CPointer<cbs::CEntity> CreateEntityFromPrefab(ttl::string_const<char>, ILevel*, mtx34 const&, PresetId, Replication::CreateObjectOptions, bool);
GAME_IMPORT bool operator==(cbs::CEntity const*, cbs::CEntityPointer);
GAME_IMPORT bool IsInDynamicRoot(cbs::CPointer<cbs::CEntity>, bool);
GAME_IMPORT cbs::CPcidPath operator+(cbs::CPcidPath const&, cbs::CPcidPath const&);
GAME_IMPORT float GetTime(cbs::WorldIndex);
GAME_IMPORT cbs::CPointer<cbs::CEntity> CreateEntityFromPrefab(ttl::string_const<char>, SpawnContext&);
GAME_IMPORT bool operator==(cbs::CPcidPath const&, cbs::CPcidPath const&);
GAME_IMPORT cbs::EnumPropertyManager& GetEnumPropertyManager();
GAME_IMPORT bool CreateEntityFromPrefabDeferred(cbs::CPointer<cbs::CEntity>&, ttl::string_const<char>, SpawnContext&);
#pragma endregion
};

124
_IDAScripts/generated/cbs/CBaseObject-unclean.h Normal file
View File

@ -0,0 +1,124 @@
#pragma once
#include <EGSDK\Imports.h>
class CBaseObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static class rtti::Type & m_RTTI;
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
VIRTUAL_CALL(0, void __fastcall, SetPlatform, ());
VIRTUAL_CALL(1, cbs::CBaseObject *__fastcall, sub_11A890, (char a1), a1);
GAME_IMPORT virtual class CRTTI const * GetRTTI() const;
VIRTUAL_CALL(3, class CRTTI const *, _GetRTTI1, ());
VIRTUAL_CALL(4, struct MED::SModelOutfitGroup const *, unassigned, ());
VIRTUAL_CALL(5, struct MED::SModelOutfitGroup const *, _unassigned1, ());
VIRTUAL_CALL(6, struct MED::SModelOutfitGroup const *, _unassigned2, ());
VIRTUAL_CALL(7, struct MED::SModelOutfitGroup const *, _unassigned3, ());
VIRTUAL_CALL(8, __int64, RunUnitTests, ());
VIRTUAL_CALL(9, __int64, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(class ttl::list<class IGSObject *, class ttl::allocator> *, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, __int64, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(class ttl::vector<class IGSObject *, class ttl::vector_allocators::heap_allocator<class IGSObject *>, 1> &, bool);
GAME_IMPORT virtual void GetAllObjects(class ttl::set<class CRTTIObject *, struct ttl::less<class CRTTIObject *>, class ttl::allocator> &, class ttl::set<class CRTTIObject *, struct ttl::less<class CRTTIObject *>, class ttl::allocator> &, bool, class std::optional<class ttl::function_ref<bool (class CRTTIObject *)>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void __fastcall, _SetPlatform1, ());
GAME_IMPORT virtual char const * GetString(char const *) const;
VIRTUAL_CALL(18, void __fastcall, _SetPlatform2, ());
VIRTUAL_CALL(19, bool, _updateRttiParams1, ());
VIRTUAL_CALL(20, void __fastcall, _SetPlatform3, ());
VIRTUAL_CALL(21, struct MED::SModelOutfitGroup const *, _unassigned4, ());
VIRTUAL_CALL(22, void __fastcall, _SetPlatform4, ());
GAME_IMPORT virtual class Uid const & GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams2, ());
VIRTUAL_CALL(25, bool, _updateRttiParams3, ());
VIRTUAL_CALL(26, bool, _updateRttiParams4, ());
VIRTUAL_CALL(27, bool, _updateRttiParams5, ());
VIRTUAL_CALL(28, bool, _updateRttiParams6, ());
VIRTUAL_CALL(29, bool, _updateRttiParams7, ());
VIRTUAL_CALL(30, bool, _updateRttiParams8, ());
VIRTUAL_CALL(31, bool, _updateRttiParams9, ());
VIRTUAL_CALL(32, bool, _updateRttiParams10, ());
GAME_IMPORT virtual void CallVoidMethod(char const *, ...);
GAME_IMPORT virtual class cbs::msg::IMessagePipeSet const & GetMessagePipeSet() const;
VIRTUAL_CALL(35, __int64, _RunUnitTests3, ());
VIRTUAL_CALL(36, struct MED::SModelOutfitGroup const *, _unassigned5, ());
VIRTUAL_CALL(37, struct MED::SModelOutfitGroup const *, _unassigned6, ());
VIRTUAL_CALL(38, struct MED::SModelOutfitGroup const *, _unassigned7, ());
VIRTUAL_CALL(39, struct MED::SModelOutfitGroup const *, _unassigned8, ());
GAME_IMPORT virtual class cbs::prop::IPropertySet const & GetPropertySet() const;
VIRTUAL_CALL(41, void __fastcall, _SetPlatform5, ());
VIRTUAL_CALL(42, __int64, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(class CRTTIField const *, unsigned char, class fs::ifile &, class IPtrResolver &, bool);
GAME_IMPORT virtual void LoadFields(class dom::IReader::Object const &, class IPtrResolver &, bool, bool (*)(char const *, class CRTTIObject *));
GAME_IMPORT virtual void LoadFields(class ITextDeserializer &, class IPtrResolver &, bool);
GAME_IMPORT virtual void LoadFields(class fs::ifile &, class IPtrResolver &, bool);
GAME_IMPORT virtual void SaveFields(class dom::IWriter &, enum ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char *, int);
GAME_IMPORT virtual int FromBufferReplicated(char *, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void __fastcall, _SetPlatform6, ());
VIRTUAL_CALL(52, static bool, ValidateVec4, (class IGSObject const *, class vec4 const &), *, &);
GAME_IMPORT virtual bool CopyFields(class CRTTIObject const *, bool);
GAME_IMPORT virtual bool CopyPointerFields(class CRTTIObject const *);
GAME_IMPORT virtual bool ExchangePointerFields(class CRTTIObject *);
VIRTUAL_CALL(56, __int64, _RunUnitTests5, ());
VIRTUAL_CALL(57, __int64, _RunUnitTests6, ());
VIRTUAL_CALL(58, __int64, _RunUnitTests7, ());
GAME_IMPORT virtual struct SRttiNetPointer GetNetPointer() const;
VIRTUAL_CALL(60, __int64, _RunUnitTests8, ());
GAME_IMPORT virtual class ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(struct SObjectMemoryUsage &) const;
VIRTUAL_CALL(63, void __fastcall, _SetPlatform7, ());
GAME_IMPORT virtual bool GetValidFieldValuesEditor(class CRTTIField const &, class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &, class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &);
VIRTUAL_CALL(65, bool, _updateRttiParams11, ());
VIRTUAL_CALL(66, static bool, _ValidateVec41, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, __int64, _RunUnitTests9, ());
GAME_IMPORT virtual class ttl::string_base<char> ValueToString(class CRTTIObject * const &) const;
GAME_IMPORT virtual bool IsFieldChanged(class CRTTIField const *) const;
GAME_IMPORT virtual void SetFieldChangedFlag(class CRTTIField const *, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams12, ());
GAME_IMPORT virtual bool OnFieldChanged2(class CRTTIField const *, bool);
VIRTUAL_CALL(73, void __fastcall, _SetPlatform8, ());
VIRTUAL_CALL(74, __int64, _RunUnitTests10, ());
VIRTUAL_CALL(75, void __fastcall, _SetPlatform9, ());
VIRTUAL_CALL(76, bool, _updateRttiParams13, ());
protected:
GAME_IMPORT virtual bool OnFieldChanged(class CRTTIField const *, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams14, ());
VIRTUAL_CALL(79, bool, _updateRttiParams15, ());
VIRTUAL_CALL(80, __int64, _RunUnitTests11, ());
VIRTUAL_CALL(81, __int64, _RunUnitTests12, ());
VIRTUAL_CALL(82, void __fastcall, _SetPlatform10, ());
GAME_IMPORT virtual void Query(class IBaseValidator &, class ttl::vector<class CRTTIObject *, class ttl::vector_allocators::heap_allocator<class CRTTIObject *>, 1> &) const;
VIRTUAL_CALL(84, void __fastcall, _SetPlatform11, ());
protected:
GAME_IMPORT virtual void OnRelease(class cbs::contracts::ApiComponentOnRelease);
public:
GAME_IMPORT static class CRTTI * GetSTTI();
GAME_IMPORT struct cbs::WorldIndex GetWorldId() const;
GAME_IMPORT class CLevel * GetCLevel() const;
protected:
GAME_IMPORT CBaseObject();
GAME_IMPORT bool GetLowLevelActive() const;
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT static class rtti::Type & typeinfo();
protected:
GAME_IMPORT void SetLowLevelActive(bool);
private:
GAME_IMPORT void InvalidateHandle();
public:
GAME_IMPORT void InvalidateHandle(class cbs::contracts::ApiInvalidatePointer);
GAME_IMPORT void Release();
GAME_IMPORT CBaseObject(class cbs::CBaseObject const &);
GAME_IMPORT class ILevel * GetILevel() const;
private:
GAME_IMPORT static class CRTTI * __INTERNAL_crtti_factory();
GAME_IMPORT static class rtti::Type & __INTERNAL_type_factory();
#pragma endregion
};

124
_IDAScripts/generated/cbs/CBaseObject.h Normal file
View File

@ -0,0 +1,124 @@
#pragma once
#include <EGSDK\Imports.h>
class CBaseObject {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static rtti::Type& m_RTTI;
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
VIRTUAL_CALL(0, void, SetPlatform, ());
VIRTUAL_CALL(1, cbs::CBaseObject*, sub_11A890, (char a1), a1);
GAME_IMPORT virtual CRTTI const* GetRTTI() const;
VIRTUAL_CALL(3, CRTTI const*, _GetRTTI1, ());
VIRTUAL_CALL(4, MED::SModelOutfitGroup const*, unassigned, ());
VIRTUAL_CALL(5, MED::SModelOutfitGroup const*, _unassigned1, ());
VIRTUAL_CALL(6, MED::SModelOutfitGroup const*, _unassigned2, ());
VIRTUAL_CALL(7, MED::SModelOutfitGroup const*, _unassigned3, ());
VIRTUAL_CALL(8, int64_t, RunUnitTests, ());
VIRTUAL_CALL(9, int64_t, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(ttl::list<IGSObject*, ttl::allocator>*, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, int64_t, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(ttl::vector<IGSObject*, ttl::vector_allocators::heap_allocator<IGSObject*>, 1>&, bool);
GAME_IMPORT virtual void GetAllObjects(ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, bool, std::optional<ttl::function_ref<bool ( CRTTIObject* )>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void, _SetPlatform1, ());
GAME_IMPORT virtual char const* GetString(char const*) const;
VIRTUAL_CALL(18, void, _SetPlatform2, ());
VIRTUAL_CALL(19, bool, _updateRttiParams1, ());
VIRTUAL_CALL(20, void, _SetPlatform3, ());
VIRTUAL_CALL(21, MED::SModelOutfitGroup const*, _unassigned4, ());
VIRTUAL_CALL(22, void, _SetPlatform4, ());
GAME_IMPORT virtual Uid const& GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams2, ());
VIRTUAL_CALL(25, bool, _updateRttiParams3, ());
VIRTUAL_CALL(26, bool, _updateRttiParams4, ());
VIRTUAL_CALL(27, bool, _updateRttiParams5, ());
VIRTUAL_CALL(28, bool, _updateRttiParams6, ());
VIRTUAL_CALL(29, bool, _updateRttiParams7, ());
VIRTUAL_CALL(30, bool, _updateRttiParams8, ());
VIRTUAL_CALL(31, bool, _updateRttiParams9, ());
VIRTUAL_CALL(32, bool, _updateRttiParams10, ());
GAME_IMPORT virtual void CallVoidMethod(char const*, ...);
GAME_IMPORT virtual cbs::msg::IMessagePipeSet const& GetMessagePipeSet() const;
VIRTUAL_CALL(35, int64_t, _RunUnitTests3, ());
VIRTUAL_CALL(36, MED::SModelOutfitGroup const*, _unassigned5, ());
VIRTUAL_CALL(37, MED::SModelOutfitGroup const*, _unassigned6, ());
VIRTUAL_CALL(38, MED::SModelOutfitGroup const*, _unassigned7, ());
VIRTUAL_CALL(39, MED::SModelOutfitGroup const*, _unassigned8, ());
GAME_IMPORT virtual cbs::prop::IPropertySet const& GetPropertySet() const;
VIRTUAL_CALL(41, void, _SetPlatform5, ());
VIRTUAL_CALL(42, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(CRTTIField const*, unsigned char, fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(dom::IReader::Object const&, IPtrResolver&, bool, bool (* )(char const*, CRTTIObject* ));
GAME_IMPORT virtual void LoadFields(ITextDeserializer&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void SaveFields(dom::IWriter&, ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char*, int);
GAME_IMPORT virtual int FromBufferReplicated(char*, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void, _SetPlatform6, ());
VIRTUAL_CALL(52, static bool, ValidateVec4, (IGSObject const*, vec4 const&), const*, const&);
GAME_IMPORT virtual bool CopyFields(CRTTIObject const*, bool);
GAME_IMPORT virtual bool CopyPointerFields(CRTTIObject const*);
GAME_IMPORT virtual bool ExchangePointerFields(CRTTIObject*);
VIRTUAL_CALL(56, int64_t, _RunUnitTests5, ());
VIRTUAL_CALL(57, int64_t, _RunUnitTests6, ());
VIRTUAL_CALL(58, int64_t, _RunUnitTests7, ());
GAME_IMPORT virtual SRttiNetPointer GetNetPointer() const;
VIRTUAL_CALL(60, int64_t, _RunUnitTests8, ());
GAME_IMPORT virtual ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(SObjectMemoryUsage&) const;
VIRTUAL_CALL(63, void, _SetPlatform7, ());
GAME_IMPORT virtual bool GetValidFieldValuesEditor(CRTTIField const&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&);
VIRTUAL_CALL(65, bool, _updateRttiParams11, ());
VIRTUAL_CALL(66, static bool, _ValidateVec41, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, int64_t, _RunUnitTests9, ());
GAME_IMPORT virtual ttl::string_base<char> ValueToString(CRTTIObject* const&) const;
GAME_IMPORT virtual bool IsFieldChanged(CRTTIField const*) const;
GAME_IMPORT virtual void SetFieldChangedFlag(CRTTIField const*, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams12, ());
GAME_IMPORT virtual bool OnFieldChanged2(CRTTIField const*, bool);
VIRTUAL_CALL(73, void, _SetPlatform8, ());
VIRTUAL_CALL(74, int64_t, _RunUnitTests10, ());
VIRTUAL_CALL(75, void, _SetPlatform9, ());
VIRTUAL_CALL(76, bool, _updateRttiParams13, ());
protected:
GAME_IMPORT virtual bool OnFieldChanged(CRTTIField const*, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams14, ());
VIRTUAL_CALL(79, bool, _updateRttiParams15, ());
VIRTUAL_CALL(80, int64_t, _RunUnitTests11, ());
VIRTUAL_CALL(81, int64_t, _RunUnitTests12, ());
VIRTUAL_CALL(82, void, _SetPlatform10, ());
GAME_IMPORT virtual void Query(IBaseValidator&, ttl::vector<CRTTIObject*, ttl::vector_allocators::heap_allocator<CRTTIObject*>, 1>&) const;
VIRTUAL_CALL(84, void, _SetPlatform11, ());
protected:
GAME_IMPORT virtual void OnRelease(cbs::contracts::ApiComponentOnRelease);
public:
GAME_IMPORT static CRTTI* GetSTTI();
GAME_IMPORT cbs::WorldIndex GetWorldId() const;
GAME_IMPORT CLevel* GetCLevel() const;
protected:
GAME_IMPORT CBaseObject();
GAME_IMPORT bool GetLowLevelActive() const;
private:
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT static rtti::Type& typeinfo();
protected:
GAME_IMPORT void SetLowLevelActive(bool);
private:
GAME_IMPORT void InvalidateHandle();
public:
GAME_IMPORT void InvalidateHandle(cbs::contracts::ApiInvalidatePointer);
GAME_IMPORT void Release();
GAME_IMPORT CBaseObject(cbs::CBaseObject const&);
GAME_IMPORT ILevel* GetILevel() const;
private:
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
#pragma endregion
};

196
_IDAScripts/generated/cbs/CComponent-unclean.h Normal file
View File

@ -0,0 +1,196 @@
#pragma once
#include <EGSDK\Imports.h>
class CComponent {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static class cbs::CAbstractSystem<class cbs::CComponent, class cbs::CSystemWorldData<class cbs::CComponent>> & s_System;
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
GAME_IMPORT static class rtti::Type & m_RTTI;
VIRTUAL_CALL(0, void __fastcall, SetPlatform, ());
VIRTUAL_CALL(1, cbs::CBaseObject *__fastcall, sub_11ADA0, (char a1), a1);
GAME_IMPORT virtual class CRTTI const * GetRTTI() const;
VIRTUAL_CALL(3, class CRTTI const *, _GetRTTI1, ());
VIRTUAL_CALL(4, struct MED::SModelOutfitGroup const *, unassigned, ());
VIRTUAL_CALL(5, struct MED::SModelOutfitGroup const *, _unassigned1, ());
VIRTUAL_CALL(6, struct MED::SModelOutfitGroup const *, _unassigned2, ());
VIRTUAL_CALL(7, struct MED::SModelOutfitGroup const *, _unassigned3, ());
VIRTUAL_CALL(8, __int64, RunUnitTests, ());
VIRTUAL_CALL(9, __int64, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(class ttl::list<class IGSObject *, class ttl::allocator> *, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, __int64, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(class ttl::vector<class IGSObject *, class ttl::vector_allocators::heap_allocator<class IGSObject *>, 1> &, bool);
GAME_IMPORT virtual void GetAllObjects(class ttl::set<class CRTTIObject *, struct ttl::less<class CRTTIObject *>, class ttl::allocator> &, class ttl::set<class CRTTIObject *, struct ttl::less<class CRTTIObject *>, class ttl::allocator> &, bool, class std::optional<class ttl::function_ref<bool (class CRTTIObject *)>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void __fastcall, _SetPlatform1, ());
GAME_IMPORT virtual char const * GetString(char const *) const;
VIRTUAL_CALL(18, void __fastcall, _SetPlatform2, ());
VIRTUAL_CALL(19, bool, _updateRttiParams1, ());
VIRTUAL_CALL(20, void __fastcall, _SetPlatform3, ());
VIRTUAL_CALL(21, struct MED::SModelOutfitGroup const *, _unassigned4, ());
VIRTUAL_CALL(22, void __fastcall, _SetPlatform4, ());
GAME_IMPORT virtual class Uid const & GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams2, ());
VIRTUAL_CALL(25, bool, _updateRttiParams3, ());
VIRTUAL_CALL(26, bool, _updateRttiParams4, ());
VIRTUAL_CALL(27, bool, _updateRttiParams5, ());
VIRTUAL_CALL(28, bool, _updateRttiParams6, ());
VIRTUAL_CALL(29, bool, _updateRttiParams7, ());
VIRTUAL_CALL(30, bool, _updateRttiParams8, ());
VIRTUAL_CALL(31, bool, _updateRttiParams9, ());
VIRTUAL_CALL(32, bool, _updateRttiParams10, ());
GAME_IMPORT virtual void CallVoidMethod(char const *, ...);
GAME_IMPORT virtual class cbs::msg::IMessagePipeSet const & GetMessagePipeSet() const;
VIRTUAL_CALL(35, __int64, _RunUnitTests3, ());
VIRTUAL_CALL(36, struct MED::SModelOutfitGroup const *, _unassigned5, ());
VIRTUAL_CALL(37, struct MED::SModelOutfitGroup const *, _unassigned6, ());
VIRTUAL_CALL(38, struct MED::SModelOutfitGroup const *, _unassigned7, ());
VIRTUAL_CALL(39, struct MED::SModelOutfitGroup const *, _unassigned8, ());
GAME_IMPORT virtual class cbs::prop::IPropertySet const & GetPropertySet() const;
VIRTUAL_CALL(41, void __fastcall, _SetPlatform5, ());
VIRTUAL_CALL(42, __int64, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(class CRTTIField const *, unsigned char, class fs::ifile &, class IPtrResolver &, bool);
GAME_IMPORT virtual void LoadFields(class dom::IReader::Object const &, class IPtrResolver &, bool, bool (*)(char const *, class CRTTIObject *));
GAME_IMPORT virtual void LoadFields(class ITextDeserializer &, class IPtrResolver &, bool);
GAME_IMPORT virtual void LoadFields(class fs::ifile &, class IPtrResolver &, bool);
GAME_IMPORT virtual void SaveFields(class dom::IWriter &, enum ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char *, int);
GAME_IMPORT virtual int FromBufferReplicated(char *, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void __fastcall, _SetPlatform6, ());
VIRTUAL_CALL(52, static bool, ValidateVec4, (class IGSObject const *, class vec4 const &), *, &);
GAME_IMPORT virtual bool CopyFields(class CRTTIObject const *, bool);
GAME_IMPORT virtual bool CopyPointerFields(class CRTTIObject const *);
GAME_IMPORT virtual bool ExchangePointerFields(class CRTTIObject *);
VIRTUAL_CALL(56, __int64, _RunUnitTests5, ());
GAME_IMPORT virtual class IGSObject * FindObjectByNetPointer(struct SRttiNetPointer const &) const;
GAME_IMPORT virtual class cbs::CEntity * FindEntityByNetPointer(struct SRttiNetPointer const &) const;
GAME_IMPORT virtual struct SRttiNetPointer GetNetPointer() const;
GAME_IMPORT virtual enum cbs::pcid_t GetPcId() const;
GAME_IMPORT virtual class ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(struct SObjectMemoryUsage &) const;
VIRTUAL_CALL(63, void __fastcall, _SetPlatform7, ());
GAME_IMPORT virtual bool GetValidFieldValuesEditor(class CRTTIField const &, class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &, class ttl::vector<class ttl::string_base<char>, class ttl::vector_allocators::heap_allocator<class ttl::string_base<char>>, 1> &);
VIRTUAL_CALL(65, bool, _updateRttiParams11, ());
VIRTUAL_CALL(66, static bool, _ValidateVec41, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, __int64, _RunUnitTests6, ());
GAME_IMPORT virtual class ttl::string_base<char> ValueToString(class CRTTIObject * const &) const;
GAME_IMPORT virtual bool IsFieldChanged(class CRTTIField const *) const;
GAME_IMPORT virtual void SetFieldChangedFlag(class CRTTIField const *, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams12, ());
GAME_IMPORT virtual bool OnFieldChanged2(class CRTTIField const *, bool);
VIRTUAL_CALL(73, void __fastcall, _SetPlatform8, ());
VIRTUAL_CALL(74, __int64, _RunUnitTests7, ());
VIRTUAL_CALL(75, void __fastcall, _SetPlatform9, ());
VIRTUAL_CALL(76, bool, _updateRttiParams13, ());
protected:
GAME_IMPORT virtual bool OnFieldChanged(class CRTTIField const *, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams14, ());
VIRTUAL_CALL(79, bool, _updateRttiParams15, ());
VIRTUAL_CALL(80, __int64, _RunUnitTests8, ());
VIRTUAL_CALL(81, __int64, _RunUnitTests9, ());
VIRTUAL_CALL(82, void __fastcall, _SetPlatform10, ());
GAME_IMPORT virtual void Query(class IBaseValidator &, class ttl::vector<class CRTTIObject *, class ttl::vector_allocators::heap_allocator<class CRTTIObject *>, 1> &) const;
GAME_IMPORT virtual void OnDestroy(class cbs::contracts::ApiComponentOnDestroy);
GAME_IMPORT virtual void OnRelease(class cbs::contracts::ApiComponentOnRelease);
GAME_IMPORT virtual class cbs::CSystemBase & GetSystem() const;
GAME_IMPORT virtual void OnConstructObject(class cbs::contracts::ApiComponentOnConstructObject);
GAME_IMPORT virtual void OnPreCreate(class cbs::contracts::ApiComponentOnPreCreate);
VIRTUAL_CALL(89, void __fastcall, _SetPlatform11, ());
VIRTUAL_CALL(90, void __fastcall, _SetPlatform12, ());
protected:
GAME_IMPORT virtual void OnReplicationPrepare();
public:
VIRTUAL_CALL(92, bool, _updateRttiParams16, ());
VIRTUAL_CALL(93, __int64, _RunUnitTests10, ());
VIRTUAL_CALL(94, __int64, _RunUnitTests11, ());
VIRTUAL_CALL(95, bool, _updateRttiParams17, ());
VIRTUAL_CALL(96, void __fastcall, _SetPlatform13, ());
GAME_IMPORT virtual class ICoWorldXform const * GetXformComponent() const;
VIRTUAL_CALL(98, class ICoWorldXform const *, _GetXformComponent1, ());
VIRTUAL_CALL(99, void __fastcall, _SetPlatform14, ());
VIRTUAL_CALL(100, void __fastcall, _SetPlatform15, ());
VIRTUAL_CALL(101, void __fastcall, _SetPlatform16, ());
VIRTUAL_CALL(102, static bool, _ValidateVec42, (class IGSObject const* a1, class vec4 const& a2), a1, a2);
VIRTUAL_CALL(103, void __fastcall, _SetPlatform17, ());
VIRTUAL_CALL(104, void __fastcall, _SetPlatform18, ());
VIRTUAL_CALL(105, __int64, _RunUnitTests12, ());
protected:
GAME_IMPORT virtual bool IsCreated() const;
GAME_IMPORT virtual void OnResolvePrefab(class SpawnContext const &, class PrefabResolveContext const &);
public:
VIRTUAL_CALL(108, void __fastcall, _SetPlatform19, ());
VIRTUAL_CALL(109, void __fastcall, _SetPlatform20, ());
protected:
GAME_IMPORT virtual void ApplyActivate(bool);
GAME_IMPORT virtual void ApplyDeactivate(bool);
GAME_IMPORT virtual void CallPendingActivationHandlers(class CDeferredCallSystem *);
public:
VIRTUAL_CALL(113, void __fastcall, _SetPlatform21, ());
VIRTUAL_CALL(114, void __fastcall, _SetPlatform22, ());
VIRTUAL_CALL(115, void __fastcall, _SetPlatform23, ());
VIRTUAL_CALL(116, void, _OnReplicationPrepare1, ());
VIRTUAL_CALL(117, void __fastcall, _SetPlatform24, ());
protected:
GAME_IMPORT virtual void OnReplicationResolve();
public:
VIRTUAL_CALL(119, void __fastcall, _SetPlatform25, ());
VIRTUAL_CALL(120, void __fastcall, _SetPlatform26, ());
VIRTUAL_CALL(121, void __fastcall, _SetPlatform27, ());
VIRTUAL_CALL(122, void __fastcall, _SetPlatform28, ());
VIRTUAL_CALL(123, void __fastcall, _SetPlatform29, ());
VIRTUAL_CALL(124, void __fastcall, _SetPlatform30, ());
VIRTUAL_CALL(125, void __fastcall, _SetPlatform31, ());
GAME_IMPORT void CallRegistered();
private:
GAME_IMPORT static class CRTTI * __INTERNAL_crtti_factory();
public:
GAME_IMPORT static class cbs::CAbstractSystem<class cbs::CComponent, class cbs::CSystemWorldData<class cbs::CComponent>> & GetSystemInstance();
GAME_IMPORT void MsgDeactivate();
protected:
GAME_IMPORT void DeactivateInternal(bool);
public:
GAME_IMPORT bool IsActive() const;
GAME_IMPORT class Replication::IObject & ReplicationObject() const;
GAME_IMPORT class cbs::CSystemWorldData<class cbs::CComponent> & GetWorldDataInstance();
GAME_IMPORT bool AllComponentFlagsSet(enum cbs::FComponent::TYPE) const;
protected:
GAME_IMPORT void SetFlags(enum cbs::FComponent::TYPE, bool);
public:
GAME_IMPORT bool WasRegistered() const;
GAME_IMPORT void MakeFullyInitialized(class cbs::contracts::ApiMakeFullyInitializedComponent);
GAME_IMPORT bool IsAlive() const;
GAME_IMPORT void ActivateByParent(bool);
GAME_IMPORT void Activate();
protected:
GAME_IMPORT void ClearFlags(enum cbs::FComponent::TYPE, bool);
public:
GAME_IMPORT void MsgActivate();
GAME_IMPORT CComponent(class cbs::CComponent const &);
GAME_IMPORT static class rtti::Type & typeinfo();
protected:
GAME_IMPORT void ActivateInternal(bool);
private:
GAME_IMPORT static bool SetSelfActive(class CRTTIObject *, bool const &);
public:
GAME_IMPORT static class CRTTI * GetSTTI();
GAME_IMPORT void DeactivateByParent(bool);
GAME_IMPORT void SetComponentFlags(enum cbs::FComponent::TYPE);
GAME_IMPORT void ClearComponentFlags(enum cbs::FComponent::TYPE);
private:
GAME_IMPORT static class rtti::Type & __INTERNAL_type_factory();
protected:
GAME_IMPORT CComponent();
public:
GAME_IMPORT static void RegisterSTTI(class CRTTI *);
private:
GAME_IMPORT static void GetSelfActive(class CRTTIObject const *, bool &);
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT static class cbs::CSystemWorldData<class cbs::CComponent> & GetWorldDataInstance(struct cbs::WorldIndex);
#pragma endregion
};

196
_IDAScripts/generated/cbs/CComponent.h Normal file
View File

@ -0,0 +1,196 @@
#pragma once
#include <EGSDK\Imports.h>
class CComponent {
#pragma region GENERATED by ExportClassToCPPH.py
public:
GAME_IMPORT static cbs::CAbstractSystem<cbs::CComponent, cbs::CSystemWorldData<cbs::CComponent>>& s_System;
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_field;
GAME_IMPORT static rtti::Type& m_RTTI;
VIRTUAL_CALL(0, void, SetPlatform, ());
VIRTUAL_CALL(1, cbs::CBaseObject*, sub_11ADA0, (char a1), a1);
GAME_IMPORT virtual CRTTI const* GetRTTI() const;
VIRTUAL_CALL(3, CRTTI const*, _GetRTTI1, ());
VIRTUAL_CALL(4, MED::SModelOutfitGroup const*, unassigned, ());
VIRTUAL_CALL(5, MED::SModelOutfitGroup const*, _unassigned1, ());
VIRTUAL_CALL(6, MED::SModelOutfitGroup const*, _unassigned2, ());
VIRTUAL_CALL(7, MED::SModelOutfitGroup const*, _unassigned3, ());
VIRTUAL_CALL(8, int64_t, RunUnitTests, ());
VIRTUAL_CALL(9, int64_t, _RunUnitTests1, ());
GAME_IMPORT virtual void GetPrivateObjects(ttl::list<IGSObject*, ttl::allocator>*, bool, bool);
GAME_IMPORT virtual void DestroyPrivateObjects();
VIRTUAL_CALL(12, int64_t, _RunUnitTests2, ());
GAME_IMPORT virtual void GetAllObjects(ttl::vector<IGSObject*, ttl::vector_allocators::heap_allocator<IGSObject*>, 1>&, bool);
GAME_IMPORT virtual void GetAllObjects(ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, ttl::set<CRTTIObject*, ttl::less<CRTTIObject*>, ttl::allocator>&, bool, std::optional<ttl::function_ref<bool ( CRTTIObject* )>>);
VIRTUAL_CALL(15, bool, updateRttiParams, ());
VIRTUAL_CALL(16, void, _SetPlatform1, ());
GAME_IMPORT virtual char const* GetString(char const*) const;
VIRTUAL_CALL(18, void, _SetPlatform2, ());
VIRTUAL_CALL(19, bool, _updateRttiParams1, ());
VIRTUAL_CALL(20, void, _SetPlatform3, ());
VIRTUAL_CALL(21, MED::SModelOutfitGroup const*, _unassigned4, ());
VIRTUAL_CALL(22, void, _SetPlatform4, ());
GAME_IMPORT virtual Uid const& GetUid() const;
VIRTUAL_CALL(24, bool, _updateRttiParams2, ());
VIRTUAL_CALL(25, bool, _updateRttiParams3, ());
VIRTUAL_CALL(26, bool, _updateRttiParams4, ());
VIRTUAL_CALL(27, bool, _updateRttiParams5, ());
VIRTUAL_CALL(28, bool, _updateRttiParams6, ());
VIRTUAL_CALL(29, bool, _updateRttiParams7, ());
VIRTUAL_CALL(30, bool, _updateRttiParams8, ());
VIRTUAL_CALL(31, bool, _updateRttiParams9, ());
VIRTUAL_CALL(32, bool, _updateRttiParams10, ());
GAME_IMPORT virtual void CallVoidMethod(char const*, ...);
GAME_IMPORT virtual cbs::msg::IMessagePipeSet const& GetMessagePipeSet() const;
VIRTUAL_CALL(35, int64_t, _RunUnitTests3, ());
VIRTUAL_CALL(36, MED::SModelOutfitGroup const*, _unassigned5, ());
VIRTUAL_CALL(37, MED::SModelOutfitGroup const*, _unassigned6, ());
VIRTUAL_CALL(38, MED::SModelOutfitGroup const*, _unassigned7, ());
VIRTUAL_CALL(39, MED::SModelOutfitGroup const*, _unassigned8, ());
GAME_IMPORT virtual cbs::prop::IPropertySet const& GetPropertySet() const;
VIRTUAL_CALL(41, void, _SetPlatform5, ());
VIRTUAL_CALL(42, int64_t, _RunUnitTests4, ());
GAME_IMPORT virtual bool LoadField(CRTTIField const*, unsigned char, fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(dom::IReader::Object const&, IPtrResolver&, bool, bool (* )(char const*, CRTTIObject* ));
GAME_IMPORT virtual void LoadFields(ITextDeserializer&, IPtrResolver&, bool);
GAME_IMPORT virtual void LoadFields(fs::ifile&, IPtrResolver&, bool);
GAME_IMPORT virtual void SaveFields(dom::IWriter&, ERTTIFlags, bool) const;
GAME_IMPORT virtual int ToBufferReplicated(char*, int);
GAME_IMPORT virtual int FromBufferReplicated(char*, int);
GAME_IMPORT virtual int GetBufferReplicatedDataSize();
VIRTUAL_CALL(51, void, _SetPlatform6, ());
VIRTUAL_CALL(52, static bool, ValidateVec4, (IGSObject const*, vec4 const&), const*, const&);
GAME_IMPORT virtual bool CopyFields(CRTTIObject const*, bool);
GAME_IMPORT virtual bool CopyPointerFields(CRTTIObject const*);
GAME_IMPORT virtual bool ExchangePointerFields(CRTTIObject*);
VIRTUAL_CALL(56, int64_t, _RunUnitTests5, ());
GAME_IMPORT virtual IGSObject* FindObjectByNetPointer(SRttiNetPointer const&) const;
GAME_IMPORT virtual cbs::CEntity* FindEntityByNetPointer(SRttiNetPointer const&) const;
GAME_IMPORT virtual SRttiNetPointer GetNetPointer() const;
GAME_IMPORT virtual cbs::pcid_t GetPcId() const;
GAME_IMPORT virtual ttl::string_base<char> GetDebugDescription() const;
GAME_IMPORT virtual void CalcMemoryUsage(SObjectMemoryUsage&) const;
VIRTUAL_CALL(63, void, _SetPlatform7, ());
GAME_IMPORT virtual bool GetValidFieldValuesEditor(CRTTIField const&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&, ttl::vector<ttl::string_base<char>, ttl::vector_allocators::heap_allocator<ttl::string_base<char>>, 1>&);
VIRTUAL_CALL(65, bool, _updateRttiParams11, ());
VIRTUAL_CALL(66, static bool, _ValidateVec41, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(67, int64_t, _RunUnitTests6, ());
GAME_IMPORT virtual ttl::string_base<char> ValueToString(CRTTIObject* const&) const;
GAME_IMPORT virtual bool IsFieldChanged(CRTTIField const*) const;
GAME_IMPORT virtual void SetFieldChangedFlag(CRTTIField const*, bool);
VIRTUAL_CALL(71, bool, _updateRttiParams12, ());
GAME_IMPORT virtual bool OnFieldChanged2(CRTTIField const*, bool);
VIRTUAL_CALL(73, void, _SetPlatform8, ());
VIRTUAL_CALL(74, int64_t, _RunUnitTests7, ());
VIRTUAL_CALL(75, void, _SetPlatform9, ());
VIRTUAL_CALL(76, bool, _updateRttiParams13, ());
protected:
GAME_IMPORT virtual bool OnFieldChanged(CRTTIField const*, bool);
public:
VIRTUAL_CALL(78, bool, _updateRttiParams14, ());
VIRTUAL_CALL(79, bool, _updateRttiParams15, ());
VIRTUAL_CALL(80, int64_t, _RunUnitTests8, ());
VIRTUAL_CALL(81, int64_t, _RunUnitTests9, ());
VIRTUAL_CALL(82, void, _SetPlatform10, ());
GAME_IMPORT virtual void Query(IBaseValidator&, ttl::vector<CRTTIObject*, ttl::vector_allocators::heap_allocator<CRTTIObject*>, 1>&) const;
GAME_IMPORT virtual void OnDestroy(cbs::contracts::ApiComponentOnDestroy);
GAME_IMPORT virtual void OnRelease(cbs::contracts::ApiComponentOnRelease);
GAME_IMPORT virtual cbs::CSystemBase& GetSystem() const;
GAME_IMPORT virtual void OnConstructObject(cbs::contracts::ApiComponentOnConstructObject);
GAME_IMPORT virtual void OnPreCreate(cbs::contracts::ApiComponentOnPreCreate);
VIRTUAL_CALL(89, void, _SetPlatform11, ());
VIRTUAL_CALL(90, void, _SetPlatform12, ());
protected:
GAME_IMPORT virtual void OnReplicationPrepare();
public:
VIRTUAL_CALL(92, bool, _updateRttiParams16, ());
VIRTUAL_CALL(93, int64_t, _RunUnitTests10, ());
VIRTUAL_CALL(94, int64_t, _RunUnitTests11, ());
VIRTUAL_CALL(95, bool, _updateRttiParams17, ());
VIRTUAL_CALL(96, void, _SetPlatform13, ());
GAME_IMPORT virtual ICoWorldXform const* GetXformComponent() const;
VIRTUAL_CALL(98, ICoWorldXform const*, _GetXformComponent1, ());
VIRTUAL_CALL(99, void, _SetPlatform14, ());
VIRTUAL_CALL(100, void, _SetPlatform15, ());
VIRTUAL_CALL(101, void, _SetPlatform16, ());
VIRTUAL_CALL(102, static bool, _ValidateVec42, (IGSObject const* a1, vec4 const& a2), a1, a2);
VIRTUAL_CALL(103, void, _SetPlatform17, ());
VIRTUAL_CALL(104, void, _SetPlatform18, ());
VIRTUAL_CALL(105, int64_t, _RunUnitTests12, ());
protected:
GAME_IMPORT virtual bool IsCreated() const;
GAME_IMPORT virtual void OnResolvePrefab(SpawnContext const&, PrefabResolveContext const&);
public:
VIRTUAL_CALL(108, void, _SetPlatform19, ());
VIRTUAL_CALL(109, void, _SetPlatform20, ());
protected:
GAME_IMPORT virtual void ApplyActivate(bool);
GAME_IMPORT virtual void ApplyDeactivate(bool);
GAME_IMPORT virtual void CallPendingActivationHandlers(CDeferredCallSystem*);
public:
VIRTUAL_CALL(113, void, _SetPlatform21, ());
VIRTUAL_CALL(114, void, _SetPlatform22, ());
VIRTUAL_CALL(115, void, _SetPlatform23, ());
VIRTUAL_CALL(116, void, _OnReplicationPrepare1, ());
VIRTUAL_CALL(117, void, _SetPlatform24, ());
protected:
GAME_IMPORT virtual void OnReplicationResolve();
public:
VIRTUAL_CALL(119, void, _SetPlatform25, ());
VIRTUAL_CALL(120, void, _SetPlatform26, ());
VIRTUAL_CALL(121, void, _SetPlatform27, ());
VIRTUAL_CALL(122, void, _SetPlatform28, ());
VIRTUAL_CALL(123, void, _SetPlatform29, ());
VIRTUAL_CALL(124, void, _SetPlatform30, ());
VIRTUAL_CALL(125, void, _SetPlatform31, ());
GAME_IMPORT void CallRegistered();
private:
GAME_IMPORT static CRTTI* __INTERNAL_crtti_factory();
public:
GAME_IMPORT static cbs::CAbstractSystem<cbs::CComponent, cbs::CSystemWorldData<cbs::CComponent>>& GetSystemInstance();
GAME_IMPORT void MsgDeactivate();
protected:
GAME_IMPORT void DeactivateInternal(bool);
public:
GAME_IMPORT bool IsActive() const;
GAME_IMPORT Replication::IObject& ReplicationObject() const;
GAME_IMPORT cbs::CSystemWorldData<cbs::CComponent>& GetWorldDataInstance();
GAME_IMPORT bool AllComponentFlagsSet(cbs::FComponent::TYPE) const;
protected:
GAME_IMPORT void SetFlags(cbs::FComponent::TYPE, bool);
public:
GAME_IMPORT bool WasRegistered() const;
GAME_IMPORT void MakeFullyInitialized(cbs::contracts::ApiMakeFullyInitializedComponent);
GAME_IMPORT bool IsAlive() const;
GAME_IMPORT void ActivateByParent(bool);
GAME_IMPORT void Activate();
protected:
GAME_IMPORT void ClearFlags(cbs::FComponent::TYPE, bool);
public:
GAME_IMPORT void MsgActivate();
GAME_IMPORT CComponent(cbs::CComponent const&);
GAME_IMPORT static rtti::Type& typeinfo();
protected:
GAME_IMPORT void ActivateInternal(bool);
private:
GAME_IMPORT static bool SetSelfActive(CRTTIObject*, bool const&);
public:
GAME_IMPORT static CRTTI* GetSTTI();
GAME_IMPORT void DeactivateByParent(bool);
GAME_IMPORT void SetComponentFlags(cbs::FComponent::TYPE);
GAME_IMPORT void ClearComponentFlags(cbs::FComponent::TYPE);
private:
GAME_IMPORT static rtti::Type& __INTERNAL_type_factory();
protected:
GAME_IMPORT CComponent();
public:
GAME_IMPORT static void RegisterSTTI(CRTTI*);
private:
GAME_IMPORT static void GetSelfActive(CRTTIObject const*, bool&);
GAME_IMPORT static bool __INTERNAL_crtti_fields_initialized_function();
public:
GAME_IMPORT static cbs::CSystemWorldData<cbs::CComponent>& GetWorldDataInstance(cbs::WorldIndex);
#pragma endregion
};

Some files were not shown because too many files have changed in this diff Show More