From b65bb3bbf3d31b9366c7f716ef857c941a09931f Mon Sep 17 00:00:00 2001
From: RaizyDaizy <123252472+RaizyDaizy@users.noreply.github.com>
Date: Wed, 8 Feb 2023 11:38:06 +0200
Subject: [PATCH] Add files via upload
---
.../DevourUnlockerDirectX11.vcxproj | 171 +++++
.../DevourUnlockerDirectX11.vcxproj.filters | 84 ++
.../DevourUnlockerDirectX11.vcxproj.user | 6 +
.../DevourUnlockerDirectX11/Includes.hpp | 20 +
.../DevourUnlockerDirectX11/dllmain.cpp | 134 ++++
.../DevourUnlockerDirectX11/kiero/kiero.cpp | 720 ++++++++++++++++++
.../DevourUnlockerDirectX11/kiero/kiero.h | 78 ++
.../DevourUn.5e484f81.tlog/CL.command.1.tlog | Bin 0 -> 10970 bytes
.../DevourUn.5e484f81.tlog/CL.read.1.tlog | Bin 0 -> 172336 bytes
.../DevourUn.5e484f81.tlog/CL.write.1.tlog | Bin 0 -> 7898 bytes
.../DevourUnlockerDirectX11.lastbuildstate | 2 +
.../DevourUnlockerDirectX11.write.1u.tlog | Bin 0 -> 178 bytes
.../link.command.1.tlog | Bin 0 -> 4148 bytes
.../DevourUn.5e484f81.tlog/link.read.1.tlog | Bin 0 -> 15102 bytes
.../DevourUn.5e484f81.tlog/link.write.1.tlog | Bin 0 -> 2892 bytes
...DevourUnlockerDirectX11.Build.CppClean.log | 22 +
.../DevourUnlockerDirectX11.dll.recipe | 11 +
.../x64/Release/DevourUnlockerDirectX11.iobj | Bin 0 -> 4370650 bytes
.../x64/Release/DevourUnlockerDirectX11.ipdb | Bin 0 -> 1399184 bytes
.../x64/Release/DevourUnlockerDirectX11.log | 14 +
...ckerDirectX11.vcxproj.FileListAbsolute.txt | 1 +
.../x64/Release/_IsIncrementalBuild | 1 +
.../x64/Release/dllmain.obj | Bin 0 -> 2021219 bytes
.../x64/Release/imgui.obj | Bin 0 -> 1642776 bytes
.../x64/Release/imgui_demo.obj | Bin 0 -> 850127 bytes
.../x64/Release/imgui_draw.obj | Bin 0 -> 902319 bytes
.../x64/Release/imgui_impl_dx11.obj | Bin 0 -> 618186 bytes
.../x64/Release/imgui_impl_win32.obj | Bin 0 -> 298329 bytes
.../x64/Release/imgui_tables.obj | Bin 0 -> 565403 bytes
.../x64/Release/imgui_widgets.obj | Bin 0 -> 1056146 bytes
.../x64/Release/kiero.obj | Bin 0 -> 437539 bytes
.../x64/Release/vc143.pdb | Bin 0 -> 1265664 bytes
.../x64/Release/vcpkg.applocal.log | 2 +
33 files changed, 1266 insertions(+)
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj.filters
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj.user
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/Includes.hpp
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/dllmain.cpp
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/kiero/kiero.cpp
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/kiero/kiero.h
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/CL.command.1.tlog
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/CL.read.1.tlog
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/CL.write.1.tlog
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/DevourUnlockerDirectX11.lastbuildstate
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/DevourUnlockerDirectX11.write.1u.tlog
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/link.command.1.tlog
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/link.read.1.tlog
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/link.write.1.tlog
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.Build.CppClean.log
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.dll.recipe
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.iobj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.ipdb
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.log
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.vcxproj.FileListAbsolute.txt
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/_IsIncrementalBuild
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/dllmain.obj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/imgui.obj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/imgui_demo.obj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/imgui_draw.obj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/imgui_impl_dx11.obj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/imgui_impl_win32.obj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/imgui_tables.obj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/imgui_widgets.obj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/kiero.obj
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/vc143.pdb
create mode 100644 DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/vcpkg.applocal.log
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj b/DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj
new file mode 100644
index 0000000..a2dc3cc
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj
@@ -0,0 +1,171 @@
+
+
+
+
+ Debug
+ Win32
+
+
+ Release
+ Win32
+
+
+ Debug
+ x64
+
+
+ Release
+ x64
+
+
+
+ 16.0
+ Win32Proj
+ {5e484f81-b601-4dba-b6b0-bdba962269a1}
+ DevourUnlockerDirectX11
+ 10.0
+
+
+
+ DynamicLibrary
+ true
+ v143
+ Unicode
+
+
+ DynamicLibrary
+ false
+ v143
+ true
+ Unicode
+
+
+ DynamicLibrary
+ true
+ v143
+ Unicode
+
+
+ DynamicLibrary
+ false
+ v143
+ true
+ Unicode
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Level3
+ true
+ WIN32;_DEBUG;DEVOURUNLOCKERDIRECTX11_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)
+ true
+ Use
+ pch.h
+
+
+ Windows
+ true
+ false
+
+
+
+
+ Level3
+ true
+ true
+ true
+ WIN32;NDEBUG;DEVOURUNLOCKERDIRECTX11_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)
+ true
+ Use
+ pch.h
+
+
+ Windows
+ true
+ true
+ true
+ false
+
+
+
+
+ Level3
+ true
+ _DEBUG;DEVOURUNLOCKERDIRECTX11_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)
+ true
+ Use
+ pch.h
+
+
+ Windows
+ true
+ false
+
+
+
+
+ Level3
+ true
+ true
+ true
+ _CRT_SECURE_NO_WARNINGS;NDEBUG;DEVOURUNLOCKERDIRECTX11_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)
+ true
+ NotUsing
+ pch.h
+ stdcpp20
+ MaxSpeed
+
+
+ Windows
+ true
+ true
+ true
+ false
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj.filters b/DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj.filters
new file mode 100644
index 0000000..7f85192
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj.filters
@@ -0,0 +1,84 @@
+
+
+
+
+ {4FC737F1-C7A5-4376-A066-2A32D752A2FF}
+ cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx
+
+
+ {93995380-89BD-4b04-88EB-625FBE52EBFB}
+ h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd
+
+
+ {67DA6AB6-F800-4c08-8B7A-83BB121AAD01}
+ rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms
+
+
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+ Source Files
+
+
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+ Header Files
+
+
+
\ No newline at end of file
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj.user b/DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj.user
new file mode 100644
index 0000000..429333d
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/DevourUnlockerDirectX11.vcxproj.user
@@ -0,0 +1,6 @@
+
+
+
+ true
+
+
\ No newline at end of file
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/Includes.hpp b/DirectX11 Edition/DevourUnlockerDirectX11/Includes.hpp
new file mode 100644
index 0000000..8533971
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/Includes.hpp
@@ -0,0 +1,20 @@
+#pragma once
+#include
+#include
+#include
+#include
+#include
+#include
+#include "ImGui/imconfig.h"
+#include "ImGui/imgui_impl_dx11.h"
+#include "ImGui/imgui.h"
+#include "ImGui/imgui_internal.h"
+#include "ImGui/imstb_rectpack.h"
+#include "ImGui/imstb_textedit.h"
+#include "ImGui/imstb_truetype.h"
+#include "kiero/kiero.h"
+#pragma comment (lib, "d3d11.lib")
+typedef HRESULT(__stdcall* Present) (IDXGISwapChain* pSwapChain, UINT SyncInterval, UINT Flags);
+typedef LRESULT(CALLBACK* WNDPROC)(HWND, UINT, WPARAM, LPARAM);
+typedef uintptr_t PTR;
+using namespace std;
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/dllmain.cpp b/DirectX11 Edition/DevourUnlockerDirectX11/dllmain.cpp
new file mode 100644
index 0000000..be60bee
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/dllmain.cpp
@@ -0,0 +1,134 @@
+// dllmain.cpp : Defines the entry point for the DLL application.
+#include "Includes.hpp" // Targeted D11 Application Window Title.
+#include "CheatDevour/Font_Memory.hpp"
+#include "ImGui/imgui_impl_win32.h"
+#include "CheatDevour/Devour_Soft.hpp"
+#pragma warning (disable : 6387) //Disabling This Warning
+Present oPresent;
+HWND window = NULL;
+WNDPROC oWndProc;
+ID3D11Device* pDevice = NULL;
+ID3D11DeviceContext* pContext = NULL;
+ID3D11RenderTargetView* mainRenderTargetView;
+extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam); //ImGui Window Process Handler
+void CreateConsole() {
+ AllocConsole();
+ SetConsoleTitleA("DevourUnlocker by RaizyDaizy");
+ FILE* fp;
+ freopen_s(&fp, "CONOUT$", "w", stdout);
+ cout << "[DevourUnlocker] Welcome to My New Cheat By RaizyDaizy" << endl;
+}
+void InitImGui()
+{
+ ImGui::CreateContext();
+ ImGuiIO& io = ImGui::GetIO();
+ io.ConfigFlags = ImGuiConfigFlags_NoMouseCursorChange;
+ io.Fonts->AddFontFromMemoryTTF(nimbussans, sizeof(nimbussans), 18.F);
+ ImGui::StyleColorsDark();
+ ImGui_ImplWin32_Init(window);
+ ImGui_ImplDX11_Init(pDevice, pContext);
+}
+
+LRESULT __stdcall WndProc(const HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
+
+ if (true && ImGui_ImplWin32_WndProcHandler(hWnd, uMsg, wParam, lParam))
+ return true;
+
+ return CallWindowProc(oWndProc, hWnd, uMsg, wParam, lParam);
+}
+
+bool init = false;
+HRESULT __stdcall hkPresent(IDXGISwapChain* pSwapChain, UINT SyncInterval, UINT Flags)
+{
+ if (!init)
+ {
+ if (SUCCEEDED(pSwapChain->GetDevice(__uuidof(ID3D11Device), (void**)&pDevice)))
+ {
+ pDevice->GetImmediateContext(&pContext);
+ DXGI_SWAP_CHAIN_DESC sd;
+ pSwapChain->GetDesc(&sd);
+ window = sd.OutputWindow;
+ ID3D11Texture2D* pBackBuffer {0};
+ pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&pBackBuffer);
+ pDevice->CreateRenderTargetView(pBackBuffer, NULL, &mainRenderTargetView); //False Positive Warning DirectX 11 SDK(Idk Why)
+ pBackBuffer->Release();
+ oWndProc = (WNDPROC)SetWindowLongPtr(window, GWLP_WNDPROC, (LONG_PTR)WndProc);
+ InitImGui();
+ init = true;
+ cout << "[DevourUnlocker] Successfully Getting D3D11 Device" << endl;
+ }
+
+ else
+ return oPresent(pSwapChain, SyncInterval, Flags);
+ }
+ ImGuiWindowFlags fl = ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar;
+ ImGui_ImplDX11_NewFrame();
+ ImGui_ImplWin32_NewFrame();
+ ImGui::NewFrame();
+ ImGui::Begin("DevourUnlocker by RaizyDaizy", 0, fl);
+ ImGui::SetNextWindowSize(ImVec2(500, 500));
+ ImGui::TextColored(ImVec4(145, 0, 0, 255), "Welcome to My Unlocker");
+ if (ImGui::Button("Detach Console", ImVec2(162, 78)))
+ {
+ ShowWindow(GetConsoleWindow(), SW_HIDE);
+ }
+ if (ImGui::Button("UNLOCK ALL ROBES", ImVec2(180, 125)))
+ {
+ InitUnlockedRobes();
+ }
+ if (ImGui::Button("UNLOCK ALL CHARACTERS", ImVec2(225, 125)))
+ {
+ InitUnlockedCharacters();
+ }
+ ImGui::End();
+ ImGui::Render();
+ pContext->OMSetRenderTargets(1, &mainRenderTargetView, NULL);
+ ImGui_ImplDX11_RenderDrawData(ImGui::GetDrawData());
+ return oPresent(pSwapChain, SyncInterval, Flags);
+}
+
+DWORD WINAPI MainThread(HMODULE hMod)
+{
+ bool init_hook = false;
+ CreateConsole();
+ do
+ {
+ if (kiero::init(kiero::RenderType::D3D11) == kiero::Status::Success)
+ {
+ kiero::bind(8, (void**)&oPresent, hkPresent);
+ init_hook = true;
+ cout << "[DevourUnlocker] Kiero Has Been Successfully Initializated" << endl;
+ }
+ else {
+ cout << "[DevourUnlocker] Kiero is not Initializated" << endl;
+ Sleep(4500);
+ exit(122);
+ }
+ if (GetAsyncKeyState(VK_F5))
+ {
+ kiero::shutdown();
+ FreeLibraryAndExitThread(hMod, 950);
+ }
+ } while (!init_hook);
+ return TRUE;
+}
+
+BOOL APIENTRY DllMain( HMODULE hModule,
+ DWORD ul_reason_for_call,
+ LPVOID lpReserved
+ )
+{
+ switch (ul_reason_for_call)
+ {
+ case DLL_PROCESS_ATTACH:
+ CreateThread(0, 0, (LPTHREAD_START_ROUTINE)MainThread, 0, 0, 0);
+ case DLL_THREAD_ATTACH:
+ case DLL_THREAD_DETACH:
+ case DLL_PROCESS_DETACH:
+ DisableThreadLibraryCalls(hModule);
+ kiero::shutdown();
+ break;
+ }
+ return TRUE;
+}
+
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/kiero/kiero.cpp b/DirectX11 Edition/DevourUnlockerDirectX11/kiero/kiero.cpp
new file mode 100644
index 0000000..b4d0e35
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/kiero/kiero.cpp
@@ -0,0 +1,720 @@
+#include "kiero.h"
+#include
+#include
+
+#if KIERO_INCLUDE_D3D9
+# include
+#endif
+
+#if KIERO_INCLUDE_D3D10
+# include
+# include
+# include
+#endif
+
+#if KIERO_INCLUDE_D3D11
+# include
+# include
+#endif
+
+#if KIERO_INCLUDE_D3D12
+# include
+# include
+#endif
+
+#if KIERO_INCLUDE_OPENGL
+# include
+#endif
+
+#if KIERO_INCLUDE_VULKAN
+# include
+#endif
+
+#if KIERO_USE_MINHOOK
+# include
+#endif
+
+#ifdef _UNICODE
+# define KIERO_TEXT(text) L##text
+#else
+# define KIERO_TEXT(text) text
+#endif
+
+#define KIERO_ARRAY_SIZE(arr) ((size_t)(sizeof(arr)/sizeof(arr[0])))
+
+static kiero::RenderType::Enum g_renderType = kiero::RenderType::None;
+static uint150_t* g_methodsTable = NULL;
+
+kiero::Status::Enum kiero::init(RenderType::Enum _renderType)
+{
+ if (g_renderType != RenderType::None)
+ {
+ return Status::AlreadyInitializedError;
+ }
+
+ if (_renderType != RenderType::None)
+ {
+ if (_renderType >= RenderType::D3D9 && _renderType <= RenderType::D3D12)
+ {
+ WNDCLASSEX windowClass;
+ windowClass.cbSize = sizeof(WNDCLASSEX);
+ windowClass.style = CS_HREDRAW | CS_VREDRAW;
+ windowClass.lpfnWndProc = DefWindowProc;
+ windowClass.cbClsExtra = 0;
+ windowClass.cbWndExtra = 0;
+ windowClass.hInstance = GetModuleHandle(NULL);
+ windowClass.hIcon = NULL;
+ windowClass.hCursor = NULL;
+ windowClass.hbrBackground = NULL;
+ windowClass.lpszMenuName = NULL;
+ windowClass.lpszClassName = KIERO_TEXT("Kiero");
+ windowClass.hIconSm = NULL;
+
+ ::RegisterClassEx(&windowClass);
+
+ HWND window = ::CreateWindow(windowClass.lpszClassName, KIERO_TEXT("Kiero DirectX Window"), WS_OVERLAPPEDWINDOW, 0, 0, 100, 100, NULL, NULL, windowClass.hInstance, NULL);
+
+ if (_renderType == RenderType::D3D9)
+ {
+#if KIERO_INCLUDE_D3D9
+ HMODULE libD3D9;
+ if ((libD3D9 = ::GetModuleHandle(KIERO_TEXT("d3d9.dll"))) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::ModuleNotFoundError;
+ }
+
+ void* Direct3DCreate9;
+ if ((Direct3DCreate9 = ::GetProcAddress(libD3D9, "Direct3DCreate9")) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ LPDIRECT3D9 direct3D9;
+ if ((direct3D9 = ((LPDIRECT3D9(__stdcall*)(uint32_t))(Direct3DCreate9))(D3D_SDK_VERSION)) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ D3DDISPLAYMODE displayMode;
+ if (direct3D9->GetAdapterDisplayMode(D3DADAPTER_DEFAULT, &displayMode) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ D3DPRESENT_PARAMETERS params;
+ params.BackBufferWidth = 0;
+ params.BackBufferHeight = 0;
+ params.BackBufferFormat = displayMode.Format;
+ params.BackBufferCount = 0;
+ params.MultiSampleType = D3DMULTISAMPLE_NONE;
+ params.MultiSampleQuality = NULL;
+ params.SwapEffect = D3DSWAPEFFECT_DISCARD;
+ params.hDeviceWindow = window;
+ params.Windowed = 1;
+ params.EnableAutoDepthStencil = 0;
+ params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
+ params.Flags = NULL;
+ params.FullScreen_RefreshRateInHz = 0;
+ params.PresentationInterval = 0;
+
+ LPDIRECT3DDEVICE9 device;
+ if (direct3D9->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, window, D3DCREATE_SOFTWARE_VERTEXPROCESSING | D3DCREATE_DISABLE_DRIVER_MANAGEMENT, ¶ms, &device) < 0)
+ {
+ direct3D9->Release();
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ g_methodsTable = (uint150_t*)::calloc(119, sizeof(uint150_t));
+ ::memcpy(g_methodsTable, *(uint150_t**)device, 119 * sizeof(uint150_t));
+
+#if KIERO_USE_MINHOOK
+ MH_Initialize();
+#endif
+
+ direct3D9->Release();
+ direct3D9 = NULL;
+
+ device->Release();
+ device = NULL;
+
+ g_renderType = RenderType::D3D9;
+
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+
+ return Status::Success;
+#endif
+ }
+ else if (_renderType == RenderType::D3D10)
+ {
+#if KIERO_INCLUDE_D3D10
+ HMODULE libDXGI;
+ HMODULE libD3D10;
+ if ((libDXGI = ::GetModuleHandle(KIERO_TEXT("dxgi.dll"))) == NULL || (libD3D10 = ::GetModuleHandle(KIERO_TEXT("d3d10.dll"))) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::ModuleNotFoundError;
+ }
+
+ void* CreateDXGIFactory;
+ if ((CreateDXGIFactory = ::GetProcAddress(libDXGI, "CreateDXGIFactory")) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ IDXGIFactory* factory;
+ if (((long(__stdcall*)(const IID&, void**))(CreateDXGIFactory))(__uuidof(IDXGIFactory), (void**)&factory) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ IDXGIAdapter* adapter;
+ if (factory->EnumAdapters(0, &adapter) == DXGI_ERROR_NOT_FOUND)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ void* D3D10CreateDeviceAndSwapChain;
+ if ((D3D10CreateDeviceAndSwapChain = ::GetProcAddress(libD3D10, "D3D10CreateDeviceAndSwapChain")) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ DXGI_RATIONAL refreshRate;
+ refreshRate.Numerator = 60;
+ refreshRate.Denominator = 1;
+
+ DXGI_MODE_DESC bufferDesc;
+ bufferDesc.Width = 100;
+ bufferDesc.Height = 100;
+ bufferDesc.RefreshRate = refreshRate;
+ bufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ bufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
+ bufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
+
+ DXGI_SAMPLE_DESC sampleDesc;
+ sampleDesc.Count = 1;
+ sampleDesc.Quality = 0;
+
+ DXGI_SWAP_CHAIN_DESC swapChainDesc;
+ swapChainDesc.BufferDesc = bufferDesc;
+ swapChainDesc.SampleDesc = sampleDesc;
+ swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ swapChainDesc.BufferCount = 1;
+ swapChainDesc.OutputWindow = window;
+ swapChainDesc.Windowed = 1;
+ swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+ swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+
+ IDXGISwapChain* swapChain;
+ ID3D10Device* device;
+
+ if (((long(__stdcall*)(
+ IDXGIAdapter*,
+ D3D10_DRIVER_TYPE,
+ HMODULE,
+ UINT,
+ UINT,
+ DXGI_SWAP_CHAIN_DESC*,
+ IDXGISwapChain**,
+ ID3D10Device**))(D3D10CreateDeviceAndSwapChain))(adapter, D3D10_DRIVER_TYPE_HARDWARE, NULL, 0, D3D10_SDK_VERSION, &swapChainDesc, &swapChain, &device) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ g_methodsTable = (uint150_t*)::calloc(116, sizeof(uint150_t));
+ ::memcpy(g_methodsTable, *(uint150_t**)swapChain, 18 * sizeof(uint150_t));
+ ::memcpy(g_methodsTable + 18, *(uint150_t**)device, 98 * sizeof(uint150_t));
+
+#if KIERO_USE_MINHOOK
+ MH_Initialize();
+#endif
+
+ swapChain->Release();
+ swapChain = NULL;
+
+ device->Release();
+ device = NULL;
+
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+
+ g_renderType = RenderType::D3D10;
+
+ return Status::Success;
+#endif
+ }
+ else if (_renderType == RenderType::D3D11)
+ {
+#if KIERO_INCLUDE_D3D11
+ HMODULE libD3D11;
+ if ((libD3D11 = ::GetModuleHandle(KIERO_TEXT("d3d11.dll"))) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::ModuleNotFoundError;
+ }
+
+ void* D3D11CreateDeviceAndSwapChain;
+ if ((D3D11CreateDeviceAndSwapChain = ::GetProcAddress(libD3D11, "D3D11CreateDeviceAndSwapChain")) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ D3D_FEATURE_LEVEL featureLevel;
+ const D3D_FEATURE_LEVEL featureLevels[] = { D3D_FEATURE_LEVEL_10_1, D3D_FEATURE_LEVEL_11_0 };
+
+ DXGI_RATIONAL refreshRate;
+ refreshRate.Numerator = 60;
+ refreshRate.Denominator = 1;
+
+ DXGI_MODE_DESC bufferDesc;
+ bufferDesc.Width = 100;
+ bufferDesc.Height = 100;
+ bufferDesc.RefreshRate = refreshRate;
+ bufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ bufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
+ bufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
+
+ DXGI_SAMPLE_DESC sampleDesc;
+ sampleDesc.Count = 1;
+ sampleDesc.Quality = 0;
+
+ DXGI_SWAP_CHAIN_DESC swapChainDesc;
+ swapChainDesc.BufferDesc = bufferDesc;
+ swapChainDesc.SampleDesc = sampleDesc;
+ swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ swapChainDesc.BufferCount = 1;
+ swapChainDesc.OutputWindow = window;
+ swapChainDesc.Windowed = 1;
+ swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
+ swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+
+ IDXGISwapChain* swapChain;
+ ID3D11Device* device;
+ ID3D11DeviceContext* context;
+
+ if (((long(__stdcall*)(
+ IDXGIAdapter*,
+ D3D_DRIVER_TYPE,
+ HMODULE,
+ UINT,
+ const D3D_FEATURE_LEVEL*,
+ UINT,
+ UINT,
+ const DXGI_SWAP_CHAIN_DESC*,
+ IDXGISwapChain**,
+ ID3D11Device**,
+ D3D_FEATURE_LEVEL*,
+ ID3D11DeviceContext**))(D3D11CreateDeviceAndSwapChain))(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, featureLevels, 1, D3D11_SDK_VERSION, &swapChainDesc, &swapChain, &device, &featureLevel, &context) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ g_methodsTable = (uint150_t*)::calloc(205, sizeof(uint150_t));
+ ::memcpy(g_methodsTable, *(uint150_t**)swapChain, 18 * sizeof(uint150_t));
+ ::memcpy(g_methodsTable + 18, *(uint150_t**)device, 43 * sizeof(uint150_t));
+ ::memcpy(g_methodsTable + 18 + 43, *(uint150_t**)context, 144 * sizeof(uint150_t));
+
+#if KIERO_USE_MINHOOK
+ MH_Initialize();
+#endif
+
+ swapChain->Release();
+ swapChain = NULL;
+
+ device->Release();
+ device = NULL;
+
+ context->Release();
+ context = NULL;
+
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+
+ g_renderType = RenderType::D3D11;
+
+ return Status::Success;
+#endif
+ }
+ else if (_renderType == RenderType::D3D12)
+ {
+#if KIERO_INCLUDE_D3D12
+ HMODULE libDXGI;
+ HMODULE libD3D12;
+ if ((libDXGI = ::GetModuleHandle(KIERO_TEXT("dxgi.dll"))) == NULL || (libD3D12 = ::GetModuleHandle(KIERO_TEXT("d3d12.dll"))) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::ModuleNotFoundError;
+ }
+
+ void* CreateDXGIFactory;
+ if ((CreateDXGIFactory = ::GetProcAddress(libDXGI, "CreateDXGIFactory")) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ IDXGIFactory* factory;
+ if (((long(__stdcall*)(const IID&, void**))(CreateDXGIFactory))(__uuidof(IDXGIFactory), (void**)&factory) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ IDXGIAdapter* adapter;
+ if (factory->EnumAdapters(0, &adapter) == DXGI_ERROR_NOT_FOUND)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ void* D3D12CreateDevice;
+ if ((D3D12CreateDevice = ::GetProcAddress(libD3D12, "D3D12CreateDevice")) == NULL)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ ID3D12Device* device;
+ if (((long(__stdcall*)(IUnknown*, D3D_FEATURE_LEVEL, const IID&, void**))(D3D12CreateDevice))(adapter, D3D_FEATURE_LEVEL_11_0, __uuidof(ID3D12Device), (void**)&device) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ D3D12_COMMAND_QUEUE_DESC queueDesc;
+ queueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
+ queueDesc.Priority = 0;
+ queueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
+ queueDesc.NodeMask = 0;
+
+ ID3D12CommandQueue* commandQueue;
+ if (device->CreateCommandQueue(&queueDesc, __uuidof(ID3D12CommandQueue), (void**)&commandQueue) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ ID3D12CommandAllocator* commandAllocator;
+ if (device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, __uuidof(ID3D12CommandAllocator), (void**)&commandAllocator) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ ID3D12GraphicsCommandList* commandList;
+ if (device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, commandAllocator, NULL, __uuidof(ID3D12GraphicsCommandList), (void**)&commandList) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ DXGI_RATIONAL refreshRate;
+ refreshRate.Numerator = 60;
+ refreshRate.Denominator = 1;
+
+ DXGI_MODE_DESC bufferDesc;
+ bufferDesc.Width = 100;
+ bufferDesc.Height = 100;
+ bufferDesc.RefreshRate = refreshRate;
+ bufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+ bufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
+ bufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;
+
+ DXGI_SAMPLE_DESC sampleDesc;
+ sampleDesc.Count = 1;
+ sampleDesc.Quality = 0;
+
+ DXGI_SWAP_CHAIN_DESC swapChainDesc = {};
+ swapChainDesc.BufferDesc = bufferDesc;
+ swapChainDesc.SampleDesc = sampleDesc;
+ swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
+ swapChainDesc.BufferCount = 2;
+ swapChainDesc.OutputWindow = window;
+ swapChainDesc.Windowed = 1;
+ swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
+ swapChainDesc.Flags = DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH;
+
+ IDXGISwapChain* swapChain;
+ if (factory->CreateSwapChain(commandQueue, &swapChainDesc, &swapChain) < 0)
+ {
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+ return Status::UnknownError;
+ }
+
+ g_methodsTable = (uint150_t*)::calloc(150, sizeof(uint150_t));
+ ::memcpy(g_methodsTable, *(uint150_t**)device, 44 * sizeof(uint150_t));
+ ::memcpy(g_methodsTable + 44, *(uint150_t**)commandQueue, 19 * sizeof(uint150_t));
+ ::memcpy(g_methodsTable + 44 + 19, *(uint150_t**)commandAllocator, 9 * sizeof(uint150_t));
+ ::memcpy(g_methodsTable + 44 + 19 + 9, *(uint150_t**)commandList, 60 * sizeof(uint150_t));
+ ::memcpy(g_methodsTable + 44 + 19 + 9 + 60, *(uint150_t**)swapChain, 18 * sizeof(uint150_t));
+
+#if KIERO_USE_MINHOOK
+ MH_Initialize();
+#endif
+
+ device->Release();
+ device = NULL;
+
+ commandQueue->Release();
+ commandQueue = NULL;
+
+ commandAllocator->Release();
+ commandAllocator = NULL;
+
+ commandList->Release();
+ commandList = NULL;
+
+ swapChain->Release();
+ swapChain = NULL;
+
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+
+ g_renderType = RenderType::D3D12;
+
+ return Status::Success;
+#endif
+ }
+
+ ::DestroyWindow(window);
+ ::UnregisterClass(windowClass.lpszClassName, windowClass.hInstance);
+
+ return Status::NotSupportedError;
+ }
+ else if (_renderType == RenderType::OpenGL)
+ {
+#if KIERO_INCLUDE_OPENGL
+ HMODULE libOpenGL32;
+ if ((libOpenGL32 = ::GetModuleHandle(KIERO_TEXT("opengl32.dll"))) == NULL)
+ {
+ return Status::ModuleNotFoundError;
+ }
+
+ const char* const methodsNames[] = {
+ "glAccum", "glAlphaFunc", "glAreTexturesResident", "glArrayElement", "glBegin", "glBindTexture", "glBitmap", "glBlendFunc", "glCallList", "glCallLists", "glClear", "glClearAccum",
+ "glClearColor", "glClearDepth", "glClearIndex", "glClearStencil", "glClipPlane", "glColor3b", "glColor3bv", "glColor3d", "glColor3dv", "glColor3f", "glColor3fv", "glColor3i", "glColor3iv",
+ "glColor3s", "glColor3sv", "glColor3ub", "glColor3ubv", "glColor3ui", "glColor3uiv", "glColor3us", "glColor3usv", "glColor4b", "glColor4bv", "glColor4d", "glColor4dv", "glColor4f",
+ "glColor4fv", "glColor4i", "glColor4iv", "glColor4s", "glColor4sv", "glColor4ub", "glColor4ubv", "glColor4ui", "glColor4uiv", "glColor4us", "glColor4usv", "glColorMask", "glColorMaterial",
+ "glColorPointer", "glCopyPixels", "glCopyTexImage1D", "glCopyTexImage2D", "glCopyTexSubImage1D", "glCopyTexSubImage2D", "glCullFaceglCullFace", "glDeleteLists", "glDeleteTextures",
+ "glDepthFunc", "glDepthMask", "glDepthRange", "glDisable", "glDisableClientState", "glDrawArrays", "glDrawBuffer", "glDrawElements", "glDrawPixels", "glEdgeFlag", "glEdgeFlagPointer",
+ "glEdgeFlagv", "glEnable", "glEnableClientState", "glEnd", "glEndList", "glEvalCoord1d", "glEvalCoord1dv", "glEvalCoord1f", "glEvalCoord1fv", "glEvalCoord2d", "glEvalCoord2dv",
+ "glEvalCoord2f", "glEvalCoord2fv", "glEvalMesh1", "glEvalMesh2", "glEvalPoint1", "glEvalPoint2", "glFeedbackBuffer", "glFinish", "glFlush", "glFogf", "glFogfv", "glFogi", "glFogiv",
+ "glFrontFace", "glFrustum", "glGenLists", "glGenTextures", "glGetBooleanv", "glGetClipPlane", "glGetDoublev", "glGetError", "glGetFloatv", "glGetIntegerv", "glGetLightfv", "glGetLightiv",
+ "glGetMapdv", "glGetMapfv", "glGetMapiv", "glGetMaterialfv", "glGetMaterialiv", "glGetPixelMapfv", "glGetPixelMapuiv", "glGetPixelMapusv", "glGetPointerv", "glGetPolygonStipple",
+ "glGetString", "glGetTexEnvfv", "glGetTexEnviv", "glGetTexGendv", "glGetTexGenfv", "glGetTexGeniv", "glGetTexImage", "glGetTexLevelParameterfv", "glGetTexLevelParameteriv",
+ "glGetTexParameterfv", "glGetTexParameteriv", "glHint", "glIndexMask", "glIndexPointer", "glIndexd", "glIndexdv", "glIndexf", "glIndexfv", "glIndexi", "glIndexiv", "glIndexs", "glIndexsv",
+ "glIndexub", "glIndexubv", "glInitNames", "glInterleavedArrays", "glIsEnabled", "glIsList", "glIsTexture", "glLightModelf", "glLightModelfv", "glLightModeli", "glLightModeliv", "glLightf",
+ "glLightfv", "glLighti", "glLightiv", "glLineStipple", "glLineWidth", "glListBase", "glLoadIdentity", "glLoadMatrixd", "glLoadMatrixf", "glLoadName", "glLogicOp", "glMap1d", "glMap1f",
+ "glMap2d", "glMap2f", "glMapGrid1d", "glMapGrid1f", "glMapGrid2d", "glMapGrid2f", "glMaterialf", "glMaterialfv", "glMateriali", "glMaterialiv", "glMatrixMode", "glMultMatrixd",
+ "glMultMatrixf", "glNewList", "glNormal3b", "glNormal3bv", "glNormal3d", "glNormal3dv", "glNormal3f", "glNormal3fv", "glNormal3i", "glNormal3iv", "glNormal3s", "glNormal3sv",
+ "glNormalPointer", "glOrtho", "glPassThrough", "glPixelMapfv", "glPixelMapuiv", "glPixelMapusv", "glPixelStoref", "glPixelStorei", "glPixelTransferf", "glPixelTransferi", "glPixelZoom",
+ "glPointSize", "glPolygonMode", "glPolygonOffset", "glPolygonStipple", "glPopAttrib", "glPopClientAttrib", "glPopMatrix", "glPopName", "glPrioritizeTextures", "glPushAttrib",
+ "glPushClientAttrib", "glPushMatrix", "glPushName", "glRasterPos2d", "glRasterPos2dv", "glRasterPos2f", "glRasterPos2fv", "glRasterPos2i", "glRasterPos2iv", "glRasterPos2s",
+ "glRasterPos2sv", "glRasterPos3d", "glRasterPos3dv", "glRasterPos3f", "glRasterPos3fv", "glRasterPos3i", "glRasterPos3iv", "glRasterPos3s", "glRasterPos3sv", "glRasterPos4d",
+ "glRasterPos4dv", "glRasterPos4f", "glRasterPos4fv", "glRasterPos4i", "glRasterPos4iv", "glRasterPos4s", "glRasterPos4sv", "glReadBuffer", "glReadPixels", "glRectd", "glRectdv", "glRectf",
+ "glRectfv", "glRecti", "glRectiv", "glRects", "glRectsv", "glRenderMode", "glRotated", "glRotatef", "glScaled", "glScalef", "glScissor", "glSelectBuffer", "glShadeModel", "glStencilFunc",
+ "glStencilMask", "glStencilOp", "glTexCoord1d", "glTexCoord1dv", "glTexCoord1f", "glTexCoord1fv", "glTexCoord1i", "glTexCoord1iv", "glTexCoord1s", "glTexCoord1sv", "glTexCoord2d",
+ "glTexCoord2dv", "glTexCoord2f", "glTexCoord2fv", "glTexCoord2i", "glTexCoord2iv", "glTexCoord2s", "glTexCoord2sv", "glTexCoord3d", "glTexCoord3dv", "glTexCoord3f", "glTexCoord3fv",
+ "glTexCoord3i", "glTexCoord3iv", "glTexCoord3s", "glTexCoord3sv", "glTexCoord4d", "glTexCoord4dv", "glTexCoord4f", "glTexCoord4fv", "glTexCoord4i", "glTexCoord4iv", "glTexCoord4s",
+ "glTexCoord4sv", "glTexCoordPointer", "glTexEnvf", "glTexEnvfv", "glTexEnvi", "glTexEnviv", "glTexGend", "glTexGendv", "glTexGenf", "glTexGenfv", "glTexGeni", "glTexGeniv", "glTexImage1D",
+ "glTexImage2D", "glTexParameterf", "glTexParameterfv", "glTexParameteri", "glTexParameteriv", "glTexSubImage1D", "glTexSubImage2D", "glTranslated", "glTranslatef", "glVertex2d",
+ "glVertex2dv", "glVertex2f", "glVertex2fv", "glVertex2i", "glVertex2iv", "glVertex2s", "glVertex2sv", "glVertex3d", "glVertex3dv", "glVertex3f", "glVertex3fv", "glVertex3i", "glVertex3iv",
+ "glVertex3s", "glVertex3sv", "glVertex4d", "glVertex4dv", "glVertex4f", "glVertex4fv", "glVertex4i", "glVertex4iv", "glVertex4s", "glVertex4sv", "glVertexPointer", "glViewport"
+ };
+
+ size_t size = KIERO_ARRAY_SIZE(methodsNames);
+
+ g_methodsTable = (uint150_t*)::calloc(size, sizeof(uint150_t));
+
+ for (int i = 0; i < size; i++)
+ {
+ g_methodsTable[i] = (uint150_t)::GetProcAddress(libOpenGL32, methodsNames[i]);
+ }
+
+#if KIERO_USE_MINHOOK
+ MH_Initialize();
+#endif
+
+ g_renderType = RenderType::OpenGL;
+
+ return Status::Success;
+#endif
+ }
+ else if (_renderType == RenderType::Vulkan)
+ {
+#if KIERO_INCLUDE_VULKAN
+ HMODULE libVulkan;
+ if ((libVulkan = GetModuleHandle(KIERO_TEXT("vulcan-1.dll"))) == NULL)
+ {
+ return Status::ModuleNotFoundError;
+ }
+
+ const char* const methodsNames[] = {
+ "vkCreateInstance", "vkDestroyInstance", "vkEnumeratePhysicalDevices", "vkGetPhysicalDeviceFeatures", "vkGetPhysicalDeviceFormatProperties", "vkGetPhysicalDeviceImageFormatProperties",
+ "vkGetPhysicalDeviceProperties", "vkGetPhysicalDeviceQueueFamilyProperties", "vkGetPhysicalDeviceMemoryProperties", "vkGetInstanceProcAddr", "vkGetDeviceProcAddr", "vkCreateDevice",
+ "vkDestroyDevice", "vkEnumerateInstanceExtensionProperties", "vkEnumerateDeviceExtensionProperties", "vkEnumerateDeviceLayerProperties", "vkGetDeviceQueue", "vkQueueSubmit", "vkQueueWaitIdle",
+ "vkDeviceWaitIdle", "vkAllocateMemory", "vkFreeMemory", "vkMapMemory", "vkUnmapMemory", "vkFlushMappedMemoryRanges", "vkInvalidateMappedMemoryRanges", "vkGetDeviceMemoryCommitment",
+ "vkBindBufferMemory", "vkBindImageMemory", "vkGetBufferMemoryRequirements", "vkGetImageMemoryRequirements", "vkGetImageSparseMemoryRequirements", "vkGetPhysicalDeviceSparseImageFormatProperties",
+ "vkQueueBindSparse", "vkCreateFence", "vkDestroyFence", "vkResetFences", "vkGetFenceStatus", "vkWaitForFences", "vkCreateSemaphore", "vkDestroySemaphore", "vkCreateEvent", "vkDestroyEvent",
+ "vkGetEventStatus", "vkSetEvent", "vkResetEvent", "vkCreateQueryPool", "vkDestroyQueryPool", "vkGetQueryPoolResults", "vkCreateBuffer", "vkDestroyBuffer", "vkCreateBufferView", "vkDestroyBufferView",
+ "vkCreateImage", "vkDestroyImage", "vkGetImageSubresourceLayout", "vkCreateImageView", "vkDestroyImageView", "vkCreateShaderModule", "vkDestroyShaderModule", "vkCreatePipelineCache",
+ "vkDestroyPipelineCache", "vkGetPipelineCacheData", "vkMergePipelineCaches", "vkCreateGraphicsPipelines", "vkCreateComputePipelines", "vkDestroyPipeline", "vkCreatePipelineLayout",
+ "vkDestroyPipelineLayout", "vkCreateSampler", "vkDestroySampler", "vkCreateDescriptorSetLayout", "vkDestroyDescriptorSetLayout", "vkCreateDescriptorPool", "vkDestroyDescriptorPool",
+ "vkResetDescriptorPool", "vkAllocateDescriptorSets", "vkFreeDescriptorSets", "vkUpdateDescriptorSets", "vkCreateFramebuffer", "vkDestroyFramebuffer", "vkCreateRenderPass", "vkDestroyRenderPass",
+ "vkGetRenderAreaGranularity", "vkCreateCommandPool", "vkDestroyCommandPool", "vkResetCommandPool", "vkAllocateCommandBuffers", "vkFreeCommandBuffers", "vkBeginCommandBuffer", "vkEndCommandBuffer",
+ "vkResetCommandBuffer", "vkCmdBindPipeline", "vkCmdSetViewport", "vkCmdSetScissor", "vkCmdSetLineWidth", "vkCmdSetDepthBias", "vkCmdSetBlendConstants", "vkCmdSetDepthBounds",
+ "vkCmdSetStencilCompareMask", "vkCmdSetStencilWriteMask", "vkCmdSetStencilReference", "vkCmdBindDescriptorSets", "vkCmdBindIndexBuffer", "vkCmdBindVertexBuffers", "vkCmdDraw", "vkCmdDrawIndexed",
+ "vkCmdDrawIndirect", "vkCmdDrawIndexedIndirect", "vkCmdDispatch", "vkCmdDispatchIndirect", "vkCmdCopyBuffer", "vkCmdCopyImage", "vkCmdBlitImage", "vkCmdCopyBufferToImage", "vkCmdCopyImageToBuffer",
+ "vkCmdUpdateBuffer", "vkCmdFillBuffer", "vkCmdClearColorImage", "vkCmdClearDepthStencilImage", "vkCmdClearAttachments", "vkCmdResolveImage", "vkCmdSetEvent", "vkCmdResetEvent", "vkCmdWaitEvents",
+ "vkCmdPipelineBarrier", "vkCmdBeginQuery", "vkCmdEndQuery", "vkCmdResetQueryPool", "vkCmdWriteTimestamp", "vkCmdCopyQueryPoolResults", "vkCmdPushConstants", "vkCmdBeginRenderPass", "vkCmdNextSubpass",
+ "vkCmdEndRenderPass", "vkCmdExecuteCommands"
+ };
+
+ size_t size = KIERO_ARRAY_SIZE(methodsNames);
+
+ g_methodsTable = (uint150_t*)::calloc(size, sizeof(uint150_t));
+
+ for (int i = 0; i < size; i++)
+ {
+ g_methodsTable[i] = (uint150_t)::GetProcAddress(libVulkan, methodsNames[i]);
+ }
+
+#if KIERO_USE_MINHOOK
+ MH_Initialize();
+#endif
+
+ g_renderType = RenderType::Vulkan;
+
+ return Status::Success;
+#endif
+ }
+ else if (_renderType == RenderType::Auto)
+ {
+ RenderType::Enum type = RenderType::None;
+
+ if (::GetModuleHandle(KIERO_TEXT("d3d9.dll")) != NULL)
+ {
+ type = RenderType::D3D9;
+ }
+ else if (::GetModuleHandle(KIERO_TEXT("d3d10.dll")) != NULL)
+ {
+ type = RenderType::D3D10;
+ }
+ else if (::GetModuleHandle(KIERO_TEXT("d3d11.dll")) != NULL)
+ {
+ type = RenderType::D3D11;
+ }
+ else if (::GetModuleHandle(KIERO_TEXT("d3d12.dll")) != NULL)
+ {
+ type = RenderType::D3D12;
+ }
+ else if (::GetModuleHandle(KIERO_TEXT("opengl32.dll")) != NULL)
+ {
+ type = RenderType::OpenGL;
+ }
+ else if (::GetModuleHandle(KIERO_TEXT("vulcan-1.dll")) != NULL)
+ {
+ type = RenderType::Vulkan;
+ }
+
+ return init(type);
+ }
+ }
+
+ return Status::Success;
+}
+
+void kiero::shutdown()
+{
+ if (g_renderType != RenderType::None)
+ {
+#if KIERO_USE_MINHOOK
+ MH_DisableHook(MH_ALL_HOOKS);
+#endif
+
+ ::free(g_methodsTable);
+ g_methodsTable = NULL;
+ g_renderType = RenderType::None;
+ }
+}
+
+kiero::Status::Enum kiero::bind(uint16_t _index, void** _original, void* _function)
+{
+ // TODO: Need own detour function
+
+ assert(_index >= 0 && _original != NULL && _function != NULL);
+
+ if (g_renderType != RenderType::None)
+ {
+#if KIERO_USE_MINHOOK
+ void* target = (void*)g_methodsTable[_index];
+ if (MH_CreateHook(target, _function, _original) != MH_OK || MH_EnableHook(target) != MH_OK)
+ {
+ return Status::UnknownError;
+ }
+#endif
+
+ return Status::Success;
+ }
+
+ return Status::NotInitializedError;
+}
+
+void kiero::unbind(uint16_t _index)
+{
+ assert(_index >= 0);
+
+ if (g_renderType != RenderType::None)
+ {
+#if KIERO_USE_MINHOOK
+ MH_DisableHook((void*)g_methodsTable[_index]);
+#endif
+ }
+}
+
+kiero::RenderType::Enum kiero::getRenderType()
+{
+ return g_renderType;
+}
+
+uint150_t* kiero::getMethodsTable()
+{
+ return g_methodsTable;
+}
\ No newline at end of file
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/kiero/kiero.h b/DirectX11 Edition/DevourUnlockerDirectX11/kiero/kiero.h
new file mode 100644
index 0000000..f75f6a2
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/kiero/kiero.h
@@ -0,0 +1,78 @@
+#ifndef __KIERO_H__
+#define __KIERO_H__
+
+#include
+
+#define KIERO_VERSION "1.2.6"
+
+#define KIERO_INCLUDE_D3D9 0 // 1 if you need D3D9 hook
+#define KIERO_INCLUDE_D3D10 0 // 1 if you need D3D10 hook
+#define KIERO_INCLUDE_D3D11 1 // 1 if you need D3D11 hook
+#define KIERO_INCLUDE_D3D12 0 // 1 if you need D3D12 hook
+#define KIERO_INCLUDE_OPENGL 0 // 1 if you need OpenGL hook
+#define KIERO_INCLUDE_VULKAN 0 // 1 if you need Vulkan hook
+#define KIERO_USE_MINHOOK 1 // 1 if you will use kiero::bind function
+
+#define KIERO_ARCH_X64 0
+#define KIERO_ARCH_X86 0
+
+#if defined(_M_X64)
+# undef KIERO_ARCH_X64
+# define KIERO_ARCH_X64 1
+#else
+# undef KIERO_ARCH_X86
+# define KIERO_ARCH_X86 1
+#endif
+
+#if KIERO_ARCH_X64
+typedef uint64_t uint150_t;
+#else
+typedef uint32_t uint150_t;
+#endif
+
+namespace kiero
+{
+ struct Status
+ {
+ enum Enum
+ {
+ UnknownError = -1,
+ NotSupportedError = -2,
+ ModuleNotFoundError = -3,
+
+ AlreadyInitializedError = -4,
+ NotInitializedError = -5,
+
+ Success = 0,
+ };
+ };
+
+ struct RenderType
+ {
+ enum Enum
+ {
+ None,
+
+ D3D9,
+ D3D10,
+ D3D11,
+ D3D12,
+
+ OpenGL,
+ Vulkan,
+
+ Auto
+ };
+ };
+
+ Status::Enum init(RenderType::Enum renderType);
+ void shutdown();
+
+ Status::Enum bind(uint16_t index, void** original, void* function);
+ void unbind(uint16_t index);
+
+ RenderType::Enum getRenderType();
+ uint150_t* getMethodsTable();
+}
+
+#endif // __KIERO_H__
\ No newline at end of file
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/CL.command.1.tlog b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/CL.command.1.tlog
new file mode 100644
index 0000000000000000000000000000000000000000..60f017844d7b2b170be293ede1a0e0773d084126
GIT binary patch
literal 10970
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
Y?4Ru`X8ZbHi^{ZOpd}U1|5UX;0Y!w02mk;8
literal 0
HcmV?d00001
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/DevourUnlockerDirectX11.lastbuildstate b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/DevourUnlockerDirectX11.lastbuildstate
new file mode 100644
index 0000000..a56ad84
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/DevourUnlockerDirectX11.lastbuildstate
@@ -0,0 +1,2 @@
+PlatformToolSet=v143:VCToolArchitecture=Native64Bit:VCToolsVersion=14.33.31629:TargetPlatformVersion=10.0.22621.0:VcpkgTriplet=x64-windows:
+Release|x64|C:\Users\RyfiusLeeker\source\repos\DevourUnlockerDirectX11\|
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/DevourUnlockerDirectX11.write.1u.tlog b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/DevourUnlockerDirectX11.write.1u.tlog
new file mode 100644
index 0000000000000000000000000000000000000000..6d8d88ed6ecc4f005666e97c94b23d8df71ba261
GIT binary patch
literal 178
zcmXYqO$)*>5JcZu@UIjE@!-`QdlCvB_EO@CrLmRzf&TgGq=Z1SGy7)pn-A4
zZsW+83mq@1TCUSCJCh#ePDE+b>)hq!Owjx;+lGOpIhI^dS7swmPHc3H4?DKYUoO^Z
X)sj1JVh65Dk4jgCt2m2FtXc5~O9>+P
literal 0
HcmV?d00001
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/link.command.1.tlog b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/link.command.1.tlog
new file mode 100644
index 0000000000000000000000000000000000000000..ff38be017d144ef407871395b05ec6a156930f6d
GIT binary patch
literal 4148
zcmds)TW`}q5QXO%iT@Dw5vi%Th=;t{j%!REC(5;zED)CJ7?A|v&Qz)z8yKL
z97GwJ&RdA+wXc-{m1QW(`H6MFRDw!8
zBIB>`0_-szC<5t=->}ZXJc4Uv@B^`c3Hr$Wr1-1oRpJh(bY*G#cv~>0s{Mtz{*CX-
znMp})6wj&8SQ4q`44kT@nuUcP6JqEvI&iUdX-4Gv#>jwZ;w((L>iP^Z-V;y`Je%2u
zO@wq#Jfkgd6SAskHsg`!bi+%KMZW6RK|IFZ5o_(q=Ci%AYx`&)Y-wNZ2F()LTb}P-FWwu2IP
zKe<&iX4TK`tFz?9sJlTxHDyi5zD|4GM}(jc!jkF_kS6HD4MUoe4iffL=sl7(EI}RV
z`0E`yPsoh!QVE?vy)p$`$bZO?dPAp{=$@!<@wdB}&ZpaIxP8yrZ}j#ZVt>1Je!j0=
dQ}1o=d$@;fUb(N2U7T%S+ueNVPu9D+#!o`IRet~g
literal 0
HcmV?d00001
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/link.read.1.tlog b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/link.read.1.tlog
new file mode 100644
index 0000000000000000000000000000000000000000..49009d031f615b2901c67ff6e93baf00a4fff1b4
GIT binary patch
literal 15102
zcmds8*>2N76rE=z{vnU>(1LVro;F!XzfgXN}JvW@1t~Hp9`xe3NrE&Mt8@$32N$mzWGkcu$NYtKHek
zEX)kQquqTm*2-}{GNpMk*Lc1D`X_U5?shPVQy}6m3OU=8)9zq($0t=;C^iv{5TFSR1KSJ07A0TPoM$Q*O=8Af;JCPeVvEfhQfJ
z94WmRUNk|}84iWtKo#S3>pkC^H@j%3`WoZhT4Hj6I9`DI1a?a;u5sNK(f7uD#OGL|
zbYa^2Gg)^k9&Bz#k^`uIjLbV&{Aa}A_gLi+&InOH6&}}E^#jh&@IS;i|BdB+1DN-C
z6DqH$fKiPVHKuEJu>hVk!E?M@!98Y8R-`^a>2ivm<*#msi
z*QLPr3Z5lGyuCxby~44wXV?)u2D6d{-u7V=E+sf=`Nw=TX>rXyj;Vd
zILBb-5CdBMwR89`WuP3eF9YV8+TpYBdk*_#TVT>gef!=&Lzj;pff3+VdTzFT0`txV
z>LAu0_F*T|<9)IYS@%m*(9XW#M*K2!0sEPsR-@c)r8Tk!U?xlpp=R2aNH;c3&p31t
zwO_`F(Ug2+*DH3wF?V@0J%?tl_UUeFHT(5?37?sXm9SgDSprTq*pDQfl;GY8>sIc=
z@z+E!Vhy{7{pPT0+ZIe-*pKLI$YJF`2HY#77P#}|8|;id-!D0}GZ=v;R;C3!E+LQf8yqNpYK#I>3Wn$!>jZ2sez%k+t>Q+
za%Hg7KDxVIW+26Pqg!&!=kR8jXa(J9V(sLx6rA8AzEYC6zH&Isa@jZInc|e@imj6
zQ{)xY-sinaeWoKvZon*%^DW#<p_AO~s;d6a<$h;!WAHi#w>h!fX3>80@R);s
zVoME=VNIMB(AoQzzxpheE15I8>!kR;%-!OodZ;tJoRj6OL4KfE+UgZB-Eroa6cMtuMP
literal 0
HcmV?d00001
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/link.write.1.tlog b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUn.5e484f81.tlog/link.write.1.tlog
new file mode 100644
index 0000000000000000000000000000000000000000..093b8b33a28c29f6fa07f0733b593ef13a5ab1a6
GIT binary patch
literal 2892
zcmds(-3o$05QWcm(5ndj&_#FYZn3E)o2G))i}dW(nN{$r3qe>~78adxe?HIb%zoYv
zB-o=vg&Q<1`;L8!BaE|Uv}&Zz*U@{W)pCq>-)R)I$QVV-eehPeAmei~j8mM;(x0G2
zgB9EK?;Gr}9oCdR9o&9po{TN$yWy%4SB-JT>(8kSiB9~}CP1R6i%X3`LK6!jFdsAkm(hcG3T)afyMF0t@b
q?S9wfDR+U0DoG9Z$1(NpG8eaDHdQ=>{>bMd@y+2+!T!D}3Vs133azvN
literal 0
HcmV?d00001
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.Build.CppClean.log b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.Build.CppClean.log
new file mode 100644
index 0000000..928f029
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.Build.CppClean.log
@@ -0,0 +1,22 @@
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\vc143.pdb
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\kiero.obj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\imgui_widgets.obj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\imgui_tables.obj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\imgui_impl_win32.obj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\imgui_impl_dx11.obj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\imgui_draw.obj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\imgui_demo.obj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\imgui.obj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\dllmain.obj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\x64\release\minhook.x64.dll
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\x64\release\devourunlockerdirectx11.dll
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\devourunlockerdirectx11.ipdb
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\x64\release\devourunlockerdirectx11.pdb
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\devourunlockerdirectx11.iobj
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\devourun.5e484f81.tlog\cl.command.1.tlog
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\devourun.5e484f81.tlog\cl.read.1.tlog
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\devourun.5e484f81.tlog\cl.write.1.tlog
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\devourun.5e484f81.tlog\devourunlockerdirectx11.write.1u.tlog
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\devourun.5e484f81.tlog\link.command.1.tlog
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\devourun.5e484f81.tlog\link.read.1.tlog
+c:\users\ryfiusleeker\source\repos\devourunlockerdirectx11\devourunlockerdirectx11\x64\release\devourun.5e484f81.tlog\link.write.1.tlog
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.dll.recipe b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.dll.recipe
new file mode 100644
index 0000000..a2b1add
--- /dev/null
+++ b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.dll.recipe
@@ -0,0 +1,11 @@
+
+
+
+
+ C:\Users\RyfiusLeeker\source\repos\DevourUnlockerDirectX11\x64\Release\DevourUnlockerDirectX11.dll
+
+
+
+
+
+
\ No newline at end of file
diff --git a/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.iobj b/DirectX11 Edition/DevourUnlockerDirectX11/x64/Release/DevourUnlockerDirectX11.iobj
new file mode 100644
index 0000000000000000000000000000000000000000..6efe7ba339059f9abc00211cbce7a1853167aeb8
GIT binary patch
literal 4370650
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