Thread V2

Hooks_Threads.cpp

#include "Hooks_Threads.h"
#include "SafeWrite.h"
#include "Utilities.h"

#include "GameThreads.h"


void ProcessCommonTask_Hook(PackedTask * task)
{
    if(task->id ==  SKSEPackedTask::kTaskId)
    {
        SKSEPackedTask * skseTask = (SKSEPackedTask*)task;
        skseTask->taskDelegate->Run();
        skseTask->taskDelegate->Dispose();
        skseTask->taskDelegate = NULL;
        return;
    }

    ProcessCommonTask(task);
}

void Hooks_Threads_Init(void)
{

}

void Hooks_Threads_Commit(void)
{
    WriteRelCall(0x006A292D, (UInt32)ProcessCommonTask_Hook);
    WriteRelCall(0x006A2B97, (UInt32)ProcessCommonTask_Hook);
    SafeWrite32(0x0069BE0D + 3, (UInt32)ProcessCommonTask_Hook);
    SafeWrite32(0x0069BE4C + 3, (UInt32)ProcessCommonTask_Hook);
}








GameThreads.h

#pragma once

#include "Utilities.h"
#include "GameAPI.h"

class Actor;
class BGSHeadPart;
class NiAVObject;
class BGSTextureSet;

class PackedTask
{
public:
    UInt32 id;
};

class SKSETaskDelegate
{
public:
    virtual void Run() = 0;
    virtual void Dispose() { delete this; };

    static void * operator new(std::size_t size)
    {
        return FormHeap_Allocate(size);
    }

    static void * operator new(std::size_t size, const std::nothrow_t &)
    {
        return FormHeap_Allocate(size);
    }

    // placement new
    static void * operator new(std::size_t size, void * ptr)
    {
        return ptr;
    }

    static void operator delete(void * ptr)
    {
        FormHeap_Free(ptr);
    }

    static void operator delete(void * ptr, const std::nothrow_t &)
    {
        FormHeap_Free(ptr);
    }

    static void operator delete(void *, void *)
    {
        // placement delete
    }
};

class SKSEPackedTask : public PackedTask
{
public:
    enum {
        kTaskId = 1000
    };
    SKSETaskDelegate * taskDelegate;
};

class SKSETaskDelegateUpdateTintMasks : public SKSETaskDelegate
{
public:
    virtual void Run();
};

class SKSETaskDelegateUpdateHairColor : public SKSETaskDelegate
{
public:
    virtual void Run();
};

class SKSETaskDelegateRegenHead : public SKSETaskDelegate
{
public:
    SKSETaskDelegateRegenHead(Actor * actor) : m_actor(actor) {};
    virtual void Run();

private:
    Actor* m_actor;
};

class SKSETaskDelegateChangeHeadPart : public SKSETaskDelegate
{
public:
    SKSETaskDelegateChangeHeadPart(Actor* actor, BGSHeadPart* newPart) : m_actor(actor), m_newPart(newPart) {};
    virtual void Run();
private:
    Actor* m_actor;
    BGSHeadPart* m_newPart;
};

typedef void (__cdecl * _ProcessCommonTask)(PackedTask * task);
extern _ProcessCommonTask ProcessCommonTask;

class BSTaskPool
{
public:
    MEMBER_FN_PREFIX(BSTaskPool);
    DEFINE_MEMBER_FN(SetNiGeometryTexture, UInt32, 0x006A4300, NiAVObject * geometry, BGSTextureSet * textureSet);
    DEFINE_MEMBER_FN(ProcessTask, void, 0x006A28E0, PackedTask*);

    void UpdateTintMasks();
    void UpdateHairColor();

    void RegenerateHead(Actor * actor);
    void ChangeHeadPart(Actor * actor, BGSHeadPart * headPart);

    static BSTaskPool * GetSingleton(void)
    {
        return *((BSTaskPool **)0x01B375F8);
    }
};








GameThreads.cpp

#include "GameThreads.h"
#include "GameAPI.h"
#include "GameReferences.h"
#include "GameData.h"
#include "GameForms.h"
#include "GameRTTI.h"

_ProcessCommonTask ProcessCommonTask = (_ProcessCommonTask)0x006A1080;

void BSTaskPool::UpdateTintMasks()
{
    SKSEPackedTask task;
    task.id = SKSEPackedTask::kTaskId;
    task.taskDelegate = new SKSETaskDelegateUpdateTintMasks();
    CALL_MEMBER_FN(this, ProcessTask)(&task);
}

void BSTaskPool::UpdateHairColor()
{
    SKSEPackedTask task;
    task.id = SKSEPackedTask::kTaskId;
    task.taskDelegate = new SKSETaskDelegateUpdateHairColor();
    CALL_MEMBER_FN(this, ProcessTask)(&task);
}

void BSTaskPool::RegenerateHead(Actor * actor)
{
    SKSEPackedTask task;
    task.id = SKSEPackedTask::kTaskId;
    task.taskDelegate = new SKSETaskDelegateRegenHead(actor);
    // InterlockIncrement
    CALL_MEMBER_FN(this, ProcessTask)(&task);
}

void BSTaskPool::ChangeHeadPart(Actor * actor, BGSHeadPart * headPart)
{
    SKSEPackedTask task;
    task.id = SKSEPackedTask::kTaskId;
    task.taskDelegate = new SKSETaskDelegateChangeHeadPart(actor, headPart);
    // InterlockIncrement
    CALL_MEMBER_FN(this, ProcessTask)(&task);
}

void SKSETaskDelegateUpdateTintMasks::Run()
{
    (*g_thePlayer)->UpdateSkinColor();
    UpdatePlayerTints();
}

void SKSETaskDelegateUpdateHairColor::Run()
{
    (*g_thePlayer)->UpdateHairColor();
}

void SKSETaskDelegateRegenHead::Run()
{
    TESNPC * npc = DYNAMIC_CAST(m_actor->baseForm, TESForm, TESNPC);
    BSFaceGenNiNode * faceNode = m_actor->GetFaceGenNiNode();
    BGSHeadPart * facePart = NULL;
    if(CALL_MEMBER_FN(npc, HasOverlays)()) {
        facePart = npc->GetHeadPartOverlayByType(BGSHeadPart::kTypeFace);
    } else {
        facePart = CALL_MEMBER_FN(npc, GetHeadPartByType)(BGSHeadPart::kTypeFace);
    }
    if(npc && faceNode && facePart) {
        CALL_MEMBER_FN(FaceGen::GetSingleton(), RegenerateHead)(faceNode, facePart, npc);
    }
}

void SKSETaskDelegateChangeHeadPart::Run()
{
    if(m_actor && m_newPart) {
        if(m_newPart->type != BGSHeadPart::kTypeMisc) {
            TESNPC * npc = DYNAMIC_CAST(m_actor->baseForm, TESForm, TESNPC);
            if(npc) {
                BGSHeadPart * oldPart = NULL;
                if(CALL_MEMBER_FN(npc, HasOverlays)())
                    oldPart = npc->GetHeadPartOverlayByType(m_newPart->type);
                if(!oldPart)
                    oldPart = CALL_MEMBER_FN(npc, GetHeadPartByType)(m_newPart->type);

                CALL_MEMBER_FN(npc, ChangeHeadPart)(m_newPart);
                ChangeActorHeadPart(m_actor, oldPart, m_newPart);
            }
        }
    }
}