Commonwealth-Online/Commonwealth-Online-Public
3
0
Fork 0
Code Pull Requests Activity

docs: add plugin setup guide

Browse Source
This commit is contained in:
andrew
2026-05-30 18:33:24 +12:00
parent f3db41c402
commit b61043a3fe
1776 changed files with 122386 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugin/lib/commonlibf4/include/Scaleform/A/AcquireInterface.h
+20
View File
@@ -0,0 +1,20 @@
#pragma once
namespace Scaleform
{
class __declspec(novtable) AcquireInterface
{
public:
static constexpr auto RTTI{ RE::RTTI::Scaleform__AcquireInterface };
static constexpr auto VTABLE{ RE::VTABLE::Scaleform__AcquireInterface };
virtual ~AcquireInterface() = default; // 00
// add
virtual bool CanAcquire(); // 01
virtual bool TryAcquire(); // 02
virtual bool TryAcquireCommit(); // 03
virtual bool TryAcquireCancel(); // 04
};
static_assert(sizeof(AcquireInterface) == 0x8);
}
plugin/lib/commonlibf4/include/Scaleform/A/AllocInfo.h
+14
View File
@@ -0,0 +1,14 @@
#pragma once
namespace Scaleform
{
class AllocInfo
{
public:
~AllocInfo() noexcept {}
// members
std::uint32_t statID;
};
static_assert(sizeof(AllocInfo) == 0x4);
}
plugin/lib/commonlibf4/include/Scaleform/A/Allocator.h
+153
View File
@@ -0,0 +1,153 @@
#pragma once
#include "Scaleform/S/StatBasicValues.h"
namespace Scaleform
{
template <std::int32_t SID = kStat_Default_Mem>
class AllocatorBaseDH
{
public:
};
static_assert(std::is_empty_v<AllocatorBaseDH<kStat_Default_Mem>>);
template <std::int32_t SID = kStat_Default_Mem>
class AllocatorBaseGH
{
public:
};
static_assert(std::is_empty_v<AllocatorBaseGH<kStat_Default_Mem>>);
template <std::int32_t SID = kStat_Default_Mem>
class AllocatorBaseLH
{
public:
};
static_assert(std::is_empty_v<AllocatorBaseLH<kStat_Default_Mem>>);
template <class T>
class ConstructorPOD
{
public:
};
static_assert(std::is_empty_v<ConstructorPOD<void*>>);
template <class T>
class ConstructorMov
{
public:
};
static_assert(std::is_empty_v<ConstructorMov<void*>>);
template <class T>
class ConstructorCPP
{
public:
};
static_assert(std::is_empty_v<ConstructorCPP<void*>>);
template <class T>
class ConstructorPagedPOD :
public ConstructorPOD<T>
{
public:
};
static_assert(std::is_empty_v<ConstructorPagedPOD<void*>>);
template <class T>
class ConstructorPagedMov :
public ConstructorMov<T>
{
public:
};
static_assert(std::is_empty_v<ConstructorPagedMov<void*>>);
template <typename T>
class ConstructorPagedMovCC :
public ConstructorMov<T>
{
public:
};
static_assert(std::is_empty_v<ConstructorPagedMovCC<void*>>);
template <class T, std::int32_t SID = kStat_Default_Mem>
class AllocatorGH :
public AllocatorBaseGH<SID>,
public ConstructorMov<T>
{
public:
};
static_assert(std::is_empty_v<AllocatorGH<void*, kStat_Default_Mem>>);
template <class T, std::int32_t SID = kStat_Default_Mem>
class AllocatorLH :
public AllocatorBaseLH<SID>,
public ConstructorMov<T>
{
public:
};
static_assert(std::is_empty_v<AllocatorLH<void*, kStat_Default_Mem>>);
template <class T, std::int32_t SID = kStat_Default_Mem>
class AllocatorDH :
public AllocatorBaseDH<SID>,
public ConstructorMov<T>
{
public:
};
static_assert(std::is_empty_v<AllocatorDH<void*, kStat_Default_Mem>>);
template <class T, std::int32_t SID = kStat_Default_Mem>
class AllocatorGH_POD :
public AllocatorBaseGH<SID>,
public ConstructorPOD<T>
{
public:
};
static_assert(std::is_empty_v<AllocatorGH_POD<void*, kStat_Default_Mem>>);
template <class T, int SID>
class AllocatorPagedGH :
AllocatorBaseGH<SID>,
ConstructorPagedMov<T>
{
public:
};
static_assert(std::is_empty_v<AllocatorPagedGH<void*, kStat_Default_Mem>>);
template <class T, int SID>
class AllocatorPagedLH :
AllocatorBaseLH<SID>,
ConstructorPagedMov<T>
{
public:
};
static_assert(std::is_empty_v<AllocatorPagedLH<void*, kStat_Default_Mem>>);
template <typename T, int SID>
class AllocatorPagedCC :
AllocatorBaseLH<SID>,
ConstructorPagedMovCC<T>
{
public:
};
static_assert(std::is_empty_v<AllocatorPagedCC<void*, kStat_Default_Mem>>);
template <class T, int SID>
class AllocatorPagedGH_POD :
AllocatorBaseGH<SID>,
ConstructorPagedPOD<T>
{
public:
};
static_assert(std::is_empty_v<AllocatorPagedGH_POD<void*, kStat_Default_Mem>>);
template <class T, int SID>
class AllocatorPagedLH_POD :
AllocatorBaseLH<SID>,
ConstructorPagedPOD<T>
{
public:
};
static_assert(std::is_empty_v<AllocatorPagedLH_POD<void*, kStat_Default_Mem>>);
}
plugin/lib/commonlibf4/include/Scaleform/A/Array.h
+117
View File
@@ -0,0 +1,117 @@
#pragma once
#include "Scaleform/A/Allocator.h"
#include "Scaleform/S/StatBasicValues.h"
namespace Scaleform
{
class MemoryHeap;
class ArrayDefaultPolicy
{
public:
~ArrayDefaultPolicy() noexcept {}
// members
std::size_t capacity; // 0
};
static_assert(sizeof(ArrayDefaultPolicy) == 0x8);
template <std::int32_t MinCapacity = 0, std::int32_t Granularity = 4, bool NeverShrink = false>
class ArrayConstPolicy
{
public:
~ArrayConstPolicy() noexcept {}
// members
std::size_t capacity; // 0
};
static_assert(sizeof(ArrayConstPolicy<>) == 0x8);
template <class T, class Allocator, class SizePolicy>
class ArrayDataBase
{
public:
// members
T* data; // 00
std::size_t size; // 08
SizePolicy policy; // 10
};
static_assert(sizeof(ArrayDataBase<void*, void*, ArrayDefaultPolicy>) == 0x18);
template <class T, class Allocator, class SizePolicy>
class ArrayData :
public ArrayDataBase<T, Allocator, SizePolicy>
{
public:
};
static_assert(sizeof(ArrayData<void*, void*, ArrayDefaultPolicy>) == 0x18);
template <class T, class Allocator, class SizePolicy>
class ArrayDataDH :
ArrayDataBase<T, Allocator, SizePolicy>
{
public:
// members
const MemoryHeap* pHeap;
};
static_assert(sizeof(ArrayDataDH<void*, void*, ArrayDefaultPolicy>) == 0x20);
template <class T, class Allocator, class SizePolicy>
class ArrayDataCC :
public ArrayDataBase<T, Allocator, SizePolicy>
{
public:
T defaultValue;
};
static_assert(sizeof(ArrayDataCC<void*, void*, ArrayDefaultPolicy>) == 0x20);
template <class T>
class ArrayBase
{
public:
// members
T data; // 00
};
static_assert(sizeof(ArrayBase<void*>) == 0x08);
template <class T, std::int32_t SID = kStat_Default_Mem, class SizePolicy = ArrayDefaultPolicy>
class Array :
public ArrayBase<ArrayData<T, AllocatorGH<T, SID>, SizePolicy>>
{
public:
};
static_assert(sizeof(Array<void*, kStat_Default_Mem, ArrayDefaultPolicy>) == 0x18);
template <class T, std::int32_t SID = kStat_Default_Mem, class SizePolicy = ArrayDefaultPolicy>
class ArrayLH :
public ArrayBase<ArrayData<T, AllocatorLH<T, SID>, SizePolicy>>
{
public:
};
static_assert(sizeof(ArrayLH<void*, kStat_Default_Mem, ArrayDefaultPolicy>) == 0x18);
template <class T, std::int32_t SID = kStat_Default_Mem, class SizePolicy = ArrayDefaultPolicy>
class ArrayDH :
public ArrayBase<ArrayDataDH<T, AllocatorDH<T, SID>, SizePolicy>>
{
public:
};
static_assert(sizeof(ArrayDH<void*, kStat_Default_Mem, ArrayDefaultPolicy>) == 0x20);
template <class T, std::int32_t SID = kStat_Default_Mem, class SizePolicy = ArrayDefaultPolicy>
class ArrayCC :
public ArrayBase<ArrayDataCC<T, AllocatorLH<T, SID>, SizePolicy>>
{
public:
};
static_assert(sizeof(ArrayCC<void*, kStat_Default_Mem, ArrayDefaultPolicy>) == 0x20);
template <class T, std::int32_t SID = kStat_Default_Mem, class SizePolicy = ArrayDefaultPolicy>
class ArrayPOD :
public ArrayBase<ArrayData<T, AllocatorGH_POD<T, SID>, SizePolicy>>
{
public:
};
static_assert(sizeof(ArrayPOD<void*, kStat_Default_Mem, ArrayDefaultPolicy>) == 0x18);
}
plugin/lib/commonlibf4/include/Scaleform/A/ArrayPaged.h
+37
View File
@@ -0,0 +1,37 @@
#pragma once
#include "Scaleform/A/Allocator.h"
#include "Scaleform/S/StatBasicValues.h"
namespace Scaleform
{
template <class T, std::int32_t PageSh = 0, std::int32_t PtrPoolInc = 0, class Allocator = AllocatorPagedCC<T, 0>>
class ArrayPagedBase :
public Allocator
{
public:
// members
std::uint64_t size; // 08
std::uint64_t numPages; // 10
std::uint64_t maxPages; // 18
T** pages; // 20
};
static_assert(sizeof(ArrayPagedBase<void*>) == 0x28);
template <class T, std::int32_t PageSh = 6, std::int32_t PtrPoolInc = 64, std::int32_t SID = kStat_Default_Mem>
class ArrayPagedPOD :
public ArrayPagedBase<T, PageSh, PtrPoolInc, AllocatorPagedGH_POD<T, SID>>
{
public:
};
static_assert(sizeof(ArrayPagedPOD<void*>) == 0x28);
template <class T, std::int32_t PageSh = 0, std::int32_t PtrPoolInc = 0, std::int32_t SID = 0>
class ArrayPagedCC :
public ArrayPagedBase<T, PageSh, PtrPoolInc, AllocatorPagedCC<T, SID>>
{
public:
T defaultValue; // 28
};
static_assert(sizeof(ArrayPagedCC<void*>) == 0x30);
}
plugin/lib/commonlibf4/include/Scaleform/A/Atomic.h
+21
View File
@@ -0,0 +1,21 @@
#pragma once
namespace Scaleform
{
template <class T>
class AtomicValueBase
{
public:
// members
volatile T value; // 0
};
static_assert(sizeof(AtomicValueBase<std::int32_t>) == 0x04);
template <class T>
class AtomicInt :
public AtomicValueBase<T> // 0
{
public:
};
static_assert(sizeof(AtomicInt<std::int32_t>) == 0x04);
}
plugin/lib/commonlibf4/include/Scaleform/A/AutoPtr.h
+14
View File
@@ -0,0 +1,14 @@
#pragma once
namespace Scaleform
{
template <class T>
class AutoPtr
{
public:
// members
T* object; // 00
bool owner; // 08
};
static_assert(sizeof(AutoPtr<void>) == 0x10);
}