Add template function for calling native gta functions

[FileEX]

This PR adds a simple template function that is used to call native GTA functions. This is more readable than manually casting or "using".

The PrepareSignature function prepares arguments of the appropriate types, and CallGTAFunction calls the function and optionally returns the result.

The syntax is simple

CallGTAFunction<return type, calling convention>(function address, arguments returned by PrepareSignature)

Example

    auto args = PrepareSignature(self, colModel, applyToPairedModel);
    CallGTAFunction<void, __THISCALL>(0x4C4BC0, args);

Calling conventions are given in capital letters.

[CrosRoad95]

In my opinion for now you should refactor only few functions calls, see how it behave in production, and then refactor more. You may miss something, make mistake and it is kinda hard to verify if all your refactors are allright.

[TracerDS]

I see you've taken a liking to my method :)
This way dealing with raw memory would be much better.

[FileEX]

In my opinion for now you should refactor only few functions calls, see how it behave in production, and then refactor more. You may miss something, make mistake and it is kinda hard to verify if all your refactors are allright.

I tested some functions that I changed and so far everything works fine, but maybe you're right, that's why this is enough for now. Only when the next nightly after merging this PR turns out to work without any problems, then I will finish the remaining files

[TheNormalnij]

MSVC doesn't optimize your calls. link

[FileEX]

MSVC doesn't optimize your calls. link

Is there anything I can do about it?

[TheNormalnij]

Is there anything I can do about it?

My bad there was an invalid compiler option. There should be /O2 instead of -O3

[sbx320]

This seems like a suboptimal approach to me. I think we should rather replace address #defines with proper typed function declarations.

e.g.

instead of

#define FUNC_HasCollisionBeenLoaded                         0x410CE0

and

    DWORD dwFunc = FUNC_HasCollisionBeenLoaded;
    bool  bRet = false;
    _asm
    {
        push    0
        push    vecPosition
        call    dwFunc
        mov     bRet, al
        add     esp, 8
    }
    return bRet;

just do

static auto FUNC_HasCollisionBeenLoaded = reinterpret_cast<bool(__cdecl*)(CVector* vecPosition, bool flag)>(0x410CE0);

and

    return FUNC_HasCollisionBeenLoaded(vecPosition, false);

[TracerDS]

This seems like a suboptimal approach to me. I think we should rather replace address #defines with proper typed function declarations.

e.g.

instead of

#define FUNC_HasCollisionBeenLoaded                         0x410CE0

and

    DWORD dwFunc = FUNC_HasCollisionBeenLoaded;
    bool  bRet = false;
    _asm
    {
        push    0
        push    vecPosition
        call    dwFunc
        mov     bRet, al
        add     esp, 8
    }
    return bRet;

just do

static auto FUNC_HasCollisionBeenLoaded = reinterpret_cast<bool(__cdecl*)(CVector* vecPosition, bool flag)>(0x410CE0);

and

    return FUNC_HasCollisionBeenLoaded(vecPosition, false);

Even better, create the appropriate methods in the class you are calling it for (if any) and then call that method instead (definition would just be reinterpreted mem address).
But thats for other PR maybe

[FileEX]

This seems like a suboptimal approach to me. I think we should rather replace address #defines with proper typed function declarations.

e.g.

instead of

#define FUNC_HasCollisionBeenLoaded                         0x410CE0

and

    DWORD dwFunc = FUNC_HasCollisionBeenLoaded;
    bool  bRet = false;
    _asm
    {
        push    0
        push    vecPosition
        call    dwFunc
        mov     bRet, al
        add     esp, 8
    }
    return bRet;

just do

static auto FUNC_HasCollisionBeenLoaded = reinterpret_cast<bool(__cdecl*)(CVector* vecPosition, bool flag)>(0x410CE0);

and

    return FUNC_HasCollisionBeenLoaded(vecPosition, false);

In that case, I have an even better suggestion. Maybe we should create a single header file, something like gta_functions.h, where we define all native functions. This way, we will have access to native functions in every file, and they will be defined once in one place. It's similar to how it's done in gamesa_renderware.h

[TheNormalnij]

In that case, I have an even better suggestion. Maybe we should create a single header file, something like gta_functions.h, where we define all native functions. This way, we will have access to native functions in every file, and they will be defined once in one place. It's similar to how it's done in gamesa_renderware.h

This file will be too messy. I prefer declaring methods to to access engine functions.
Instead of

void someLogic() {
        // some code
        using CEntity_ResolveReferences = void*(__thiscall*)(CEntitySAInterface*);
        ((CEntity_ResolveReferences)0x571A40)(m_pInterface);
        // some code
}

CEntity_ResolveReferences can be declared in CEntitySAInterface

CEntitySAInterface {
 //...
    void* ResolveReferences()
   {
       // we can skip additional definition for 0x571A40
       // this number is described in the context
       return ((void*(__thiscall*)(CEntitySAInterface*))0x571A40)(this);
   };
}

void someLogic() {
    // code
    m_pInterface->ResolveReferences();
    // code
}

I kinda agree that this PR gives too small improvements.

[FileEX]

/////////////////////////////
/// CPed
/////////////////////////////
static auto FUNC_SetModelIndex = reinterpret_cast<void(__thiscall*)(CPedSAInterface* ped, int index)>(0x5E4880);
static auto FUNC_AttachPedToEntity = reinterpret_cast<void(__thiscall*)(CPedSAInterface* ped, CEntitySAInterface* entity, float offsetX, float offsetY, float offsetZ, int direction, float rotationLimit, std::uint32_t weaponType)>(0x5E7CB0);
static auto FUNC_SetIsStanding = reinterpret_cast<void(__thiscall*)(CPedSAInterface* ped, bool standing)>(0x4ABBE0);
static auto FUNC_SetCurrentWeapon = reinterpret_cast<void(__thiscall*)(CPedSAInterface* ped, std::uint8_t slot)>(0x5E61F0);
static auto FUNC_GiveWeapon = reinterpret_cast<std::uint32_t(__thiscall*)(CPedSAInterface* ped, std::uint32_t weaponID, int ammo, int unusedUnknown)>(0x5E6080);
static auto FUNC_GetBonePosition = reinterpret_cast<void(__thiscall*)(CPedSAInterface* ped, CVector* pos, std::uint32_t boneID, bool dynamic)>(0x5E4280);

/////////////////////////////
/// CPlayerPed
/////////////////////////////
static auto FUNC_MakeChangesForNewWeapon_Slot = reinterpret_cast<void(__thiscall*)(CPlayerPedSAInterface* playerPed, std::uint8_t weaponSlot)>(0x60D000);

Personally, I wouldn't say that it looks messy. Additionally, this file would be rarely edited.

Will editing CEntitySAInterface cause any issues due to incorrect size?

[TheNormalnij]

Personally, I wouldn't say that it looks messy. Additionally, this file would be rarely edited.

FUNC_SetModelIndex(pPedInterface, 200) vs pPedInterface->SetModelIndex(200)

Will editing CEntitySAInterface cause any issues due to incorrect size?

Methods don't change data struct. Only virtual functions add vtbl reference

[FileEX]

Personally, I wouldn't say that it looks messy. Additionally, this file would be rarely edited.

FUNC_SetModelIndex(pPedInterface, 200) vs pPedInterface->SetModelIndex(200)

Will editing CEntitySAInterface cause any issues due to incorrect size?

Methods don't change data struct. Only virtual functions add vtbl reference

What about cdecl functions that are not tied to any specific interface?

[TracerDS]

What about cdecl functions that are not tied to any specific interface?

What do you think about a namespace for all gta global funcs?

[TheNormalnij]

What about cdecl functions that are not tied to any specific interface?

cdecl functions can be added to related SA class.