amacocian/gMod
1
0
Fork 0
mirror of https://github.com/gwdevhub/gMod.git synced 2026-07-15 15:09:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

1.5.8 (#17)

Browse Source 
* remove d3dx9.dll dependency (still requires dx legacy sdk for development, but not for end users)

* fix

* Fix to allow gMod to be loaded as "d3d9.dll"
Don't check for d3d9 functions when checking dll's, its not that deep.
Fix to allow gMod to load "d3d9.dll" using the default method rather than defaulting to system directory

* use d3dx sdk for wic texture loading until we figure out how to load volume/cube textures without it

* fix jons commit

* 1.5.7

* create warning message

* pass correct pointer type, shouldn't matter but lets see

* use Warning instead of Message for failed actions

* need to use d3dpool_managed...

* use specialised methods

* actually do something in the Direct3DCreate9Ex method?

* spaces

* test loading WIC textures with modified WICTextureLoader9.cpp

* include

* Hook into GetProcAddress instead of d3d9 dll

* extern "C" the Direct3DCreate9/Ex functions

* turn on debug messages

* add back in creating of our replacement textures, woopsies

* add messages back in, not loading yet, debug later

* remove SingleTexture stuff

* dont rely on d3dx anymore :)

* Tidied up assertion error box
Added logic to use gmod as d3d9.dll or gmod.dll
Added check to avoid recursive calls to create d3d9

* Remove unused func
This commit is contained in:
DubbleClick
2023-11-30 16:57:09 +01:00
committed by GitHub
parent a1cadde802
commit ae2c93fc32
15 changed files with 272 additions and 450 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cmake/dxtk.cmake
+14 -2
View File
@@ -4,7 +4,7 @@ include(FetchContent)
FetchContent_Declare(
DirectXTex
GIT_REPOSITORY https://github.com/microsoft/DirectXTex
GIT_TAG jul2022)
GIT_TAG oct2023)
FetchContent_GetProperties(directxtex)
if (directxtex_POPULATED)
return()
@@ -12,12 +12,24 @@ endif()
FetchContent_Populate(directxtex)
file(READ "${directxtex_SOURCE_DIR}/WICTextureLoader/WICTextureLoader9.cpp" FILE_CONTENT)
string(REPLACE
"hr = frame->GetPixelFormat(&pixelFormat);\n"
"hr = frame->GetPixelFormat(&pixelFormat); if (pixelFormat == GUID_WICPixelFormat32bppBGR) pixelFormat = GUID_WICPixelFormat32bppBGRA;\n"
FILE_CONTENT "${FILE_CONTENT}" )
file(WRITE "${directxtex_SOURCE_DIR}/WICTextureLoader/WICTextureLoader9.cpp" "${FILE_CONTENT}")
add_library(directxtex)
set(SOURCES
file(GLOB SOURCES
"${directxtex_SOURCE_DIR}/DDSTextureLoader/DDSTextureLoader9.h"
"${directxtex_SOURCE_DIR}/DDSTextureLoader/DDSTextureLoader9.cpp"
"${directxtex_SOURCE_DIR}/WICTextureLoader/WICTextureLoader9.h"
"${directxtex_SOURCE_DIR}/WICTextureLoader/WICTextureLoader9.cpp"
"${directxtex_SOURCE_DIR}/DirectXTex/*.h"
"${directxtex_SOURCE_DIR}/DirectXTex/*.cpp"
)
list(REMOVE_ITEM SOURCES
"${directxtex_SOURCE_DIR}/DirectXTex/BCDirectCompute.cpp"
)
source_group(TREE ${directxtex_SOURCE_DIR} FILES ${SOURCES})
target_sources(directxtex PRIVATE ${SOURCES})
header/Defines.h
+10
View File
@@ -7,9 +7,19 @@ using HashType = DWORD32;
#include <iostream>
#ifdef _DEBUG
#if 1
#define Message(...) { printf(__VA_ARGS__); }
#else
#define Message(...)
#endif
#define Warning(...) { fprintf(stderr, __VA_ARGS__); }
#else
#define Message(...)
#define Warning(...)
#endif
#endif
header/Main.h
+2
View File
@@ -4,6 +4,8 @@
#include <cstdlib>
#include <cstdio>
#include <filesystem>
#include <map>
#include "Utils.h"
#include <d3d9.h>
header/TextureClient.h
+35 -35
View File
@@ -1,7 +1,5 @@
#pragma once
#include <map>
#include "FileLoader.h"
#include "uMod_IDirect3DTexture9.h"
#include <DDSTextureLoader/DDSTextureLoader9.h>
@@ -61,12 +59,9 @@ private:
bool isDirectXExDevice = false;
// DX9 proxy functions
uMod_IDirect3DTexture9* GetSingleTexture();
uMod_IDirect3DVolumeTexture9* GetSingleVolumeTexture();
uMod_IDirect3DCubeTexture9* GetSingleCubeTexture();
int SetLastCreatedTexture(uMod_IDirect3DTexture9*);
int SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9*);
int SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9*);
void SetLastCreatedTexture(uMod_IDirect3DTexture9*);
void SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9*);
void SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9*);
bool should_update = false;
@@ -176,11 +171,13 @@ int TextureClient::LookUpToMod(uModTexturePtr auto pTexture)
return ret;
}
extern HINSTANCE gl_hThisInstance;
int TextureClient::LoadTexture(TextureFileStruct* file_in_memory, uModTexturePtrPtr auto ppTexture)
{
Message("LoadTexture( %p, %p, %#lX): %p\n", file_in_memory, ppTexture, file_in_memory->crc_hash, this);
if (file_in_memory->is_wic_texture) {
if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DTexture9**>) {
Warning("(%#lX)\n", file_in_memory->crc_hash);
#if 0
if (D3D_OK != D3DXCreateTextureFromFileInMemoryEx(
D3D9Device, file_in_memory->data.data(),
file_in_memory->data.size(), D3DX_DEFAULT, D3DX_DEFAULT,
@@ -188,47 +185,50 @@ int TextureClient::LoadTexture(TextureFileStruct* file_in_memory, uModTexturePtr
D3DX_DEFAULT, D3DX_DEFAULT, 0, nullptr, nullptr,
reinterpret_cast<IDirect3DTexture9**>(ppTexture))) {
*ppTexture = nullptr;
Message("LoadWICTexture( %p, %#lX): FAILED\n", *ppTexture, file_in_memory->crc_hash);
Warning("LoadWICTexture(%p, %#lX): FAILED\n", *ppTexture, file_in_memory->crc_hash);
return RETURN_TEXTURE_NOT_LOADED;
}
D3DXIMAGE_INFO info;
D3DXGetImageInfoFromFileInMemory(file_in_memory->data.data(), file_in_memory->data.size(), &info);
char dllpath[MAX_PATH]{};
GetModuleFileName(gl_hThisInstance, dllpath, MAX_PATH); //ask for name and path of this dll
const auto dds_export_path = std::filesystem::path(dllpath).parent_path() / "d3dxout" / std::format("GW.EXE_{:X}.dds", file_in_memory->crc_hash);
if (!std::filesystem::exists(dds_export_path)) {
D3DXSaveTextureToFile(dds_export_path.string().c_str(), D3DXIFF_DDS, *ppTexture, nullptr);
}
else if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DVolumeTexture9**>) {
if (D3D_OK != D3DXCreateVolumeTextureFromFileInMemoryEx(
D3D9Device, file_in_memory->data.data(),
file_in_memory->data.size(), D3DX_DEFAULT, D3DX_DEFAULT,
D3DX_DEFAULT, D3DX_DEFAULT, 0, D3DFMT_UNKNOWN,
D3DPOOL_MANAGED, D3DX_DEFAULT, D3DX_DEFAULT, 0,
nullptr,
nullptr,
reinterpret_cast<IDirect3DVolumeTexture9**>(ppTexture))) {
#else
if (D3D_OK != DirectX::CreateWICTextureFromMemoryEx(
D3D9Device,
file_in_memory->data.data(),
file_in_memory->data.size(),
0, 0, D3DPOOL_MANAGED, DirectX::WIC_LOADER_MIP_AUTOGEN,
reinterpret_cast<IDirect3DTexture9**>(ppTexture))) {
*ppTexture = nullptr;
Message("LoadWICTexture( %p, %#lX): FAILED\n", *ppTexture, file_in_memory->crc_hash);
Warning("LoadWICTexture(%p, %#lX): FAILED\n", *ppTexture, file_in_memory->crc_hash);
return RETURN_TEXTURE_NOT_LOADED;
}
SetLastCreatedVolumeTexture(nullptr);
}
else if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DCubeTexture9**>) {
if (D3D_OK != D3DXCreateCubeTextureFromFileInMemoryEx(
D3D9Device, file_in_memory->data.data(), file_in_memory->data.size(), D3DX_DEFAULT, D3DX_DEFAULT, 0,
D3DFMT_UNKNOWN, D3DPOOL_MANAGED,
D3DX_DEFAULT, D3DX_DEFAULT, 0, nullptr, nullptr,
reinterpret_cast<IDirect3DCubeTexture9**>(ppTexture))) {
*ppTexture = nullptr;
Message("LoadWICTexture( %p, %#lX): FAILED\n", *ppTexture, file_in_memory->crc_hash);
return RETURN_TEXTURE_NOT_LOADED;
}
}
#endif
}
else if (D3D_OK != DirectX::CreateDDSTextureFromMemoryEx(
D3D9Device,
file_in_memory->data.data(),
file_in_memory->data.size(),
0, D3DPOOL_MANAGED, false, reinterpret_cast<LPDIRECT3DTEXTURE9*>(ppTexture))) {
0, D3DPOOL_MANAGED, false,
reinterpret_cast<LPDIRECT3DTEXTURE9*>(ppTexture))) {
*ppTexture = nullptr;
Message("LoadDDSTexture( %p, 0x%#lX): FAILED\n", *ppTexture, file_in_memory->crc_hash);
Warning("LoadDDSTexture Normal(%p, %#lX): FAILED\n", *ppTexture, file_in_memory->crc_hash);
return RETURN_TEXTURE_NOT_LOADED;
}
if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DTexture9**>) {
SetLastCreatedTexture(nullptr);
}
else if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DVolumeTexture9**>) {
SetLastCreatedVolumeTexture(nullptr);
}
else if constexpr (std::same_as<decltype(ppTexture), uMod_IDirect3DCubeTexture9**>) {
SetLastCreatedCubeTexture(nullptr);
}
(*ppTexture)->FAKE = true;
Message("LoadTexture( %p, %#lX): DONE\n", *ppTexture, file_in_memory->crc_hash);
header/uMod_IDirect3DDevice9.h
+5 -22
View File
@@ -139,48 +139,31 @@ public:
uMod_IDirect3DTexture9* GetLastCreatedTexture() { return LastCreatedTexture; }
int SetLastCreatedTexture(uMod_IDirect3DTexture9* pTexture)
void SetLastCreatedTexture(uMod_IDirect3DTexture9* pTexture)
{
LastCreatedTexture = pTexture;
return RETURN_OK;
}
uMod_IDirect3DVolumeTexture9* GetLastCreatedVolumeTexture() { return LastCreatedVolumeTexture; }
int SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* pTexture)
void SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* pTexture)
{
LastCreatedVolumeTexture = pTexture;
return RETURN_OK;
}
uMod_IDirect3DCubeTexture9* GetLastCreatedCubeTexture() { return LastCreatedCubeTexture; }
int SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* pTexture)
void SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* pTexture)
{
LastCreatedCubeTexture = pTexture;
return RETURN_OK;
}
uMod_IDirect3DTexture9* GetSingleTexture() { return SingleTexture; }
uMod_IDirect3DVolumeTexture9* GetSingleVolumeTexture() { return SingleVolumeTexture; }
uMod_IDirect3DCubeTexture9* GetSingleCubeTexture() { return SingleCubeTexture; }
private:
int CreateSingleTexture();
IDirect3DDevice9* m_pIDirect3DDevice9 = nullptr;
int CounterSaveSingleTexture;
uMod_IDirect3DTexture9* SingleTexture = nullptr;
uMod_IDirect3DVolumeTexture9* SingleVolumeTexture = nullptr;
uMod_IDirect3DCubeTexture9* SingleCubeTexture = nullptr;
char SingleTextureMod;
D3DCOLOR TextureColour;
int BackBufferCount;
bool NormalRendering;
int uMod_Reference;
bool NormalRendering = true;
int uMod_Reference = 1;
uMod_IDirect3DTexture9* LastCreatedTexture = nullptr;
uMod_IDirect3DVolumeTexture9* LastCreatedVolumeTexture = nullptr;
header/uMod_IDirect3DDevice9Ex.h
+9 -25
View File
@@ -161,52 +161,36 @@ public:
uMod_IDirect3DTexture9* GetLastCreatedTexture() { return LastCreatedTexture; }
int SetLastCreatedTexture(uMod_IDirect3DTexture9* pTexture)
void SetLastCreatedTexture(uMod_IDirect3DTexture9* pTexture)
{
LastCreatedTexture = pTexture;
return RETURN_OK;
}
uMod_IDirect3DVolumeTexture9* GetLastCreatedVolumeTexture() { return LastCreatedVolumeTexture; }
int SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* pTexture)
void SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* pTexture)
{
LastCreatedVolumeTexture = pTexture;
return RETURN_OK;
}
uMod_IDirect3DCubeTexture9* GetLastCreatedCubeTexture() { return LastCreatedCubeTexture; }
int SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* pTexture)
void SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* pTexture)
{
LastCreatedCubeTexture = pTexture;
return RETURN_OK;
}
uMod_IDirect3DTexture9* GetSingleTexture() { return SingleTexture; }
uMod_IDirect3DVolumeTexture9* GetSingleVolumeTexture() { return SingleVolumeTexture; }
uMod_IDirect3DCubeTexture9* GetSingleCubeTexture() { return SingleCubeTexture; }
private:
int CreateSingleTexture();
IDirect3DDevice9Ex* m_pIDirect3DDevice9Ex;
int CounterSaveSingleTexture;
uMod_IDirect3DTexture9* SingleTexture;
uMod_IDirect3DVolumeTexture9* SingleVolumeTexture;
uMod_IDirect3DCubeTexture9* SingleCubeTexture;
char SingleTextureMod;
D3DCOLOR TextureColour;
int BackBufferCount;
bool NormalRendering;
bool NormalRendering = true;
int uMod_Reference;
int uMod_Reference = 1;
uMod_IDirect3DTexture9* LastCreatedTexture;
uMod_IDirect3DVolumeTexture9* LastCreatedVolumeTexture;
uMod_IDirect3DCubeTexture9* LastCreatedCubeTexture;
uMod_IDirect3DTexture9* LastCreatedTexture = nullptr;
uMod_IDirect3DVolumeTexture9* LastCreatedVolumeTexture = nullptr;
uMod_IDirect3DCubeTexture9* LastCreatedCubeTexture = nullptr;
TextureClient* uMod_Client;
TextureClient* uMod_Client = nullptr;
};
header/uMod_IDirect3DTexture9.h
+4 -1
View File
@@ -7,11 +7,14 @@ interface uMod_IDirect3DTexture9 : public IDirect3DTexture9 {
{
m_D3Dtex = *ppTex; //Texture which will be displayed and will be passed to the game
m_D3Ddev = pIDirect3DDevice9; //device pointer
CrossRef_D3Dtex = nullptr; //cross reference
// fake texture: store the pointer to the original uMod_IDirect3DTexture9 object, needed if a fake texture is unselected
// original texture: stores the pointer to the fake texture object, is needed if original texture is deleted,
// thus the fake texture can also be deleted
}
virtual ~uMod_IDirect3DTexture9()
{
}
// callback interface
IDirect3DTexture9* m_D3Dtex = nullptr;
source/Error.cpp
+14 -6
View File
@@ -1,8 +1,9 @@
#include "Error.h"
#include <Windows.h>
#include <stdio.h>
#include <cstdio>
#include <process.h>
#include <Main.h>
__declspec(noreturn) void FatalAssert(
const char *expr,
@@ -10,13 +11,20 @@ const char *file,
unsigned int line,
const char *function)
{
const char* fmt = "%s\n%s\n%s line %d";
int len = snprintf(NULL, 0, fmt, expr, file, function, line);
char module_path[MAX_PATH]{};
if (gl_hThisInstance) {
GetModuleFileName(gl_hThisInstance, module_path, _countof(module_path));
}
if (!*module_path) {
strcpy(module_path, "Unknown");
}
const char* fmt = "Module: %s\n\nExpr: %s\n\nFile: %s\n\nFunction: %s, line %d";
int len = snprintf(NULL, 0, fmt, module_path, expr, file, function, line);
char* buf = new char[len + 1];
snprintf(buf,len + 1, fmt, expr, file, function, line);
snprintf(buf,len + 1, fmt, module_path, expr, file, function, line);
MessageBox(0, "uMod Assertion", buf, MB_OK | MB_ICONERROR);
MessageBox(0, buf, "uMod Assertion Failure", MB_OK | MB_ICONERROR);
delete[] buf;
abort();
source/FileLoader.cpp
+5 -5
View File
@@ -14,7 +14,7 @@ std::vector<TextureFileStruct> FileLoader::GetContents()
return file_name.ends_with(".tpf") ? GetTpfContents() : GetFileContents();
}
catch (const std::exception&) {
Message("Failed to open mod file: %s\n", file_name.c_str());
Warning("Failed to open mod file: %s\n", file_name.c_str());
}
return {};
}
@@ -26,7 +26,7 @@ std::vector<TextureFileStruct> FileLoader::GetTpfContents()
const auto buffer = tpf_reader.ReadToEnd();
const auto zip_archive = libzippp::ZipArchive::fromBuffer(buffer.data(), buffer.size(), false, TPF_PASSWORD);
if (!zip_archive) {
Message("Failed to open tpf file: %s - %u bytes!", file_name.c_str(), buffer.size());
Warning("Failed to open tpf file: %s - %u bytes!", file_name.c_str(), buffer.size());
return {};
}
zip_archive->setErrorHandlerCallback(
@@ -84,7 +84,7 @@ void ParseSimpleArchive(const libzippp::ZipArchive& archive, std::vector<Texture
crc_hash = std::stoul(name, nullptr, 16);
}
catch (const std::invalid_argument& e) {
Message("Failed to parse %s as a hash", name.c_str());
Warning("Failed to parse %s as a hash", name.c_str());
continue;
}
catch (const std::out_of_range& e) {
@@ -148,11 +148,11 @@ void ParseTexmodArchive(std::vector<std::string>& lines, libzippp::ZipArchive& a
crc_hash = std::stoul(addrstr, nullptr, 16);
}
catch (const std::invalid_argument& e) {
Message("Failed to parse %s as a hash", addrstr.c_str());
Warning("Failed to parse %s as a hash", addrstr.c_str());
continue;
}
catch (const std::out_of_range& e) {
Message("Out of range while parsing %s as a hash", addrstr.c_str());
Warning("Out of range while parsing %s as a hash", addrstr.c_str());
continue;
}
source/TextureClient.cpp
+7 -41
View File
@@ -37,24 +37,18 @@ int TextureClient::MergeUpdate()
Message("MergeUpdate(): %p\n", this);
const auto single_texture = GetSingleTexture();
for (const auto pTexture : OriginalTextures) {
if (pTexture->CrossRef_D3Dtex == nullptr || pTexture->CrossRef_D3Dtex == single_texture) {
UnswitchTextures(pTexture); //this we can do always, so we unswitch the single texture
if (pTexture->CrossRef_D3Dtex == nullptr) {
LookUpToMod(pTexture);
}
}
const auto single_volume_texture = GetSingleVolumeTexture();
for (const auto pTexture : OriginalVolumeTextures) {
if (pTexture->CrossRef_D3Dtex == nullptr || pTexture->CrossRef_D3Dtex == single_volume_texture) {
UnswitchTextures(pTexture); //this we can do always, so we unswitch the single texture
if (pTexture->CrossRef_D3Dtex == nullptr) {
LookUpToMod(pTexture);
}
}
const auto single_cube_texture = GetSingleCubeTexture();
for (const auto pTexture : OriginalCubeTextures) {
if (pTexture->CrossRef_D3Dtex == nullptr || pTexture->CrossRef_D3Dtex == single_cube_texture) {
UnswitchTextures(pTexture); //this we can do always, so we unswitch the single texture
if (pTexture->CrossRef_D3Dtex == nullptr) {
LookUpToMod(pTexture);
}
}
@@ -62,55 +56,27 @@ int TextureClient::MergeUpdate()
return UnlockMutex();
}
uMod_IDirect3DTexture9* TextureClient::GetSingleTexture()
{
if (isDirectXExDevice)
return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->GetSingleTexture();
//this texture must no be added twice
return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->GetSingleTexture();
}
uMod_IDirect3DVolumeTexture9* TextureClient::GetSingleVolumeTexture()
{
if (isDirectXExDevice)
return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->GetSingleVolumeTexture();
//this texture must no be added twice
return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->GetSingleVolumeTexture();
}
uMod_IDirect3DCubeTexture9* TextureClient::GetSingleCubeTexture()
{
if (isDirectXExDevice)
return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->GetSingleCubeTexture();
//this texture must no be added twice
return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->GetSingleCubeTexture();
}
int TextureClient::SetLastCreatedTexture(uMod_IDirect3DTexture9* texture)
void TextureClient::SetLastCreatedTexture(uMod_IDirect3DTexture9* texture)
{
if (isDirectXExDevice)
return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->SetLastCreatedTexture(texture);
//this texture must no be added twice
return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->SetLastCreatedTexture(texture);
}
int TextureClient::SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* texture)
void TextureClient::SetLastCreatedVolumeTexture(uMod_IDirect3DVolumeTexture9* texture)
{
if (isDirectXExDevice)
return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->SetLastCreatedVolumeTexture(texture);
//this texture must no be added twice
return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->SetLastCreatedVolumeTexture(texture);
}
int TextureClient::SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* texture)
void TextureClient::SetLastCreatedCubeTexture(uMod_IDirect3DCubeTexture9* texture)
{
if (isDirectXExDevice)
return static_cast<uMod_IDirect3DDevice9Ex*>(D3D9Device)->SetLastCreatedCubeTexture(texture);
//this texture must no be added twice
return static_cast<uMod_IDirect3DDevice9*>(D3D9Device)->SetLastCreatedCubeTexture(texture);
}
int TextureClient::LockMutex()
{
if ((gl_ErrorState & (uMod_ERROR_FATAL | uMod_ERROR_MUTEX))) {
@@ -151,7 +117,7 @@ void TextureClient::LoadModsFromFile(const char* source)
std::ifstream file(source);
if (!file.is_open()) {
Message("LoadModsFromFile: failed to open modlist.txt for reading; aborting!!!");
Warning("LoadModsFromFile: failed to open modlist.txt for reading; aborting!!!");
return;
}
Message("Initialize: found modlist.txt. Reading\n");
source/dll_main.cpp
+122 -99
View File
@@ -1,6 +1,5 @@
#include "dll_main.h"
#include <array>
#include <Windows.h>
#include "Main.h"
#include <Psapi.h>
@@ -10,42 +9,29 @@
namespace {
#define DISABLE_HOOK(var) if(var) { MH_DisableHook(var);}
using Direct3DCreate9_type = IDirect3D9* (APIENTRY*)(UINT);
using Direct3DCreate9Ex_type = HRESULT(APIENTRY*)(UINT SDKVersion, IDirect3D9Ex** ppD3D);
using GetProcAddress_type = FARPROC(APIENTRY*)(HMODULE, LPCSTR);
// Pointer to original address of Direct3DCreate9
Direct3DCreate9_type Direct3DCreate9_fn = nullptr;
Direct3DCreate9_type Direct3DCreate9_ret = nullptr;
// Pointer to original address of Direct3DCreate9
Direct3DCreate9Ex_type Direct3DCreate9Ex_fn = nullptr;
Direct3DCreate9Ex_type Direct3DCreate9Ex_ret = nullptr;
GetProcAddress_type GetProcAddress_fn = nullptr;
GetProcAddress_type GetProcAddress_ret = nullptr;
static FILE* stdout_proxy;
static FILE* stderr_proxy;
FILE* stdout_proxy;
FILE* stderr_proxy;
// If not nullptr, we're responsible for freeing this library on termination
HMODULE gMod_Loaded_d3d9_Module_Handle = nullptr;
// If this hModule called d3d9.dll?
bool IsD3d9Dll(HMODULE hModule)
{
TCHAR szModuleName[MAX_PATH];
ASSERT(GetModuleFileName(hModule, szModuleName, sizeof(szModuleName) / sizeof(*szModuleName)) > 0);
const auto basename = strrchr(szModuleName, '\\');
return basename && strcmp(basename + 1, "d3d9.dll") == 0;
}
// Does this module contain exported function calls for creating a d3d9 device?
bool HasD3d9Methods(HMODULE hModule)
{
return GetProcAddress(hModule, "Direct3DCreate9")
&& GetProcAddress(hModule, "Direct3DCreate9Ex");
}
HMODULE FindLoadedDll()
{
HMODULE FindLoadedModuleByName(const char* name, bool include_this_module = false) {
HMODULE hModules[1024];
HANDLE hProcess;
DWORD cbNeeded;
@@ -56,46 +42,137 @@ namespace {
if (!EnumProcessModules(hProcess, hModules, sizeof(hModules), &cbNeeded))
return nullptr;
for (i = 0; i < (cbNeeded / sizeof(HMODULE)); i++) {
if (hModules[i] == gl_hThisInstance)
if (hModules[i] == gl_hThisInstance && !include_this_module)
continue;
if (IsD3d9Dll(hModules[i])) {
TCHAR szModuleName[MAX_PATH];
ASSERT(GetModuleFileName(hModules[i], szModuleName, _countof(szModuleName)) > 0);
const auto basename = strrchr(szModuleName, '\\');
if (basename && stricmp(basename + 1, name) == 0)
return hModules[i];
}
}
return nullptr;
}
HMODULE LoadD3d9Dll()
{
HMODULE found = FindLoadedModuleByName("d3d9.dll");
if (!found) {
char executable_path[MAX_PATH]{};
ASSERT(GetModuleFileName(GetModuleHandle(nullptr), executable_path, _countof(executable_path)) > 0);
char dll_path[MAX_PATH]{};
ASSERT(GetModuleFileName(gl_hThisInstance, dll_path, _countof(dll_path)) > 0);
const auto exe_path = std::filesystem::path(executable_path);
const auto gmod_path = std::filesystem::path(dll_path);
bool successful_load = false;
if (exe_path.parent_path() != gmod_path.parent_path()
|| gmod_path.filename() != "d3d9.dll") {
// Call basic LoadLibrary function; we're not in the same directory as the exe.
gMod_Loaded_d3d9_Module_Handle = LoadLibrary("d3d9.dll");
}
if (!gMod_Loaded_d3d9_Module_Handle) {
// Tried resolving d3d9.dll locally, didn't work. Try system directory
char buffer[MAX_PATH] ;
ASSERT(GetSystemDirectory(buffer, _countof(buffer)) > 0); //get the system directory, we need to open the original d3d9.dll
// Append dll name
strcat_s(buffer, _countof(buffer), "\\d3d9.dll");
gMod_Loaded_d3d9_Module_Handle = LoadLibrary(buffer);
}
ASSERT(gMod_Loaded_d3d9_Module_Handle);
found = FindLoadedModuleByName("d3d9.dll");
ASSERT(found && found == gMod_Loaded_d3d9_Module_Handle);
}
DISABLE_HOOK(GetProcAddress_fn);
// GetProcAddress, hooked via OnGetProcAddress
Direct3DCreate9_ret = (Direct3DCreate9_type)GetProcAddress(found, "Direct3DCreate9");
Direct3DCreate9Ex_ret = (Direct3DCreate9Ex_type)GetProcAddress(found, "Direct3DCreate9Ex");
return found;
}
FARPROC APIENTRY OnGetProcAddress(HMODULE hModule, LPCSTR lpProcName) {
ASSERT(GetProcAddress_ret);
if ((int)lpProcName < 0xffff)
return GetProcAddress_ret(hModule, lpProcName); // lpProcName is ordinal offset, not string
if (strcmp(lpProcName, "Direct3DCreate9") == 0) {
Direct3DCreate9_ret = (Direct3DCreate9_type)GetProcAddress_ret(hModule, lpProcName);
return (FARPROC)Direct3DCreate9;
}
if (strcmp(lpProcName, "Direct3DCreate9Ex") == 0) {
Direct3DCreate9Ex_ret = (Direct3DCreate9Ex_type)GetProcAddress_ret(hModule, lpProcName);
return (FARPROC)Direct3DCreate9Ex;
}
return GetProcAddress_ret(hModule, lpProcName);
}
// If the original d3d9 function is nullptr or points to gMod, load the actual d3d9 dll and redirect the addresses
void CheckLoadD3d9Dll() {
if (!(Direct3DCreate9_ret && Direct3DCreate9_ret != Direct3DCreate9)) {
ASSERT(LoadD3d9Dll());
ASSERT(Direct3DCreate9_ret && Direct3DCreate9_ret != Direct3DCreate9);
}
if (!(Direct3DCreate9Ex_ret && Direct3DCreate9Ex_ret != Direct3DCreate9Ex)) {
ASSERT(LoadD3d9Dll());
ASSERT(Direct3DCreate9Ex_ret && Direct3DCreate9Ex_ret != Direct3DCreate9Ex);
}
}
// There may be a sitation where more than 1 gmod is loaded; avoid recursions!
bool creating_d3d9 = false;
}
unsigned int gl_ErrorState = 0;
HINSTANCE gl_hThisInstance = nullptr;
IDirect3D9* APIENTRY Direct3DCreate9(UINT SDKVersion)
extern "C" IDirect3D9* APIENTRY Direct3DCreate9(UINT SDKVersion)
{
Message("uMod_Direct3DCreate9: original %p, uMod %p\n", Direct3DCreate9_fn, Direct3DCreate9);
Message("uMod_Direct3DCreate9: uMod %p\n", Direct3DCreate9);
ASSERT(Direct3DCreate9_ret);
ASSERT(!creating_d3d9);
creating_d3d9 = true;
DISABLE_HOOK(GetProcAddress_fn);
CheckLoadD3d9Dll();
IDirect3D9* pIDirect3D9_orig = Direct3DCreate9_ret(SDKVersion); //creating the original IDirect3D9 object
ASSERT(pIDirect3D9_orig);
creating_d3d9 = false;
return new uMod_IDirect3D9(pIDirect3D9_orig); //return our object instead of the "real one"
}
HRESULT APIENTRY Direct3DCreate9Ex(UINT SDKVersion, IDirect3D9Ex** ppD3D)
extern "C" HRESULT APIENTRY Direct3DCreate9Ex(UINT SDKVersion, IDirect3D9Ex** ppD3D)
{
Message("uMod_Direct3DCreate9Ex: original %p, uMod %p\n", Direct3DCreate9Ex_fn, Direct3DCreate9Ex);
Message("uMod_Direct3DCreate9Ex: uMod %p\n", Direct3DCreate9Ex);
ASSERT(Direct3DCreate9Ex_ret);
ASSERT(!creating_d3d9);
creating_d3d9 = true;
DISABLE_HOOK(GetProcAddress_fn);
CheckLoadD3d9Dll();
IDirect3D9Ex* pIDirect3D9Ex_orig = nullptr;
HRESULT ret = Direct3DCreate9Ex_ret(SDKVersion, &pIDirect3D9Ex_orig); //creating the original IDirect3D9 object
creating_d3d9 = false;
if (ret != S_OK)
return ret;
// @Cleanup: should be we freeing pIDirect3D9Ex at the end of our own lifecycle?
uMod_IDirect3D9Ex* pIDirect3D9Ex = new uMod_IDirect3D9Ex(pIDirect3D9Ex_orig);
ppD3D = (IDirect3D9Ex**)&pIDirect3D9Ex;
const auto pIDirect3D9Ex = new uMod_IDirect3D9Ex(pIDirect3D9Ex_orig);
// original umod does not do this for some reason
*ppD3D = static_cast<IDirect3D9Ex*>(pIDirect3D9Ex);
return ret;
}
@@ -135,42 +212,29 @@ void InitInstance(HINSTANCE hModule)
// Store the handle to this module
gl_hThisInstance = hModule;
const auto d3d9_dll = LoadOriginalDll();
ASSERT(d3d9_dll);
// d3d9.dll shouldn't be loaded at this point.
const auto d3d9_loaded = FindLoadedModuleByName("d3d9.dll");
ASSERT(!d3d9_loaded);
MH_Initialize();
// Hook our loaded Dll's dx9 calls though to uMod's functions
Direct3DCreate9_fn = reinterpret_cast<Direct3DCreate9_type>(GetProcAddress(d3d9_dll, "Direct3DCreate9"));
ASSERT(Direct3DCreate9_fn);
if (Direct3DCreate9_fn) {
MH_CreateHook(Direct3DCreate9_fn, Direct3DCreate9, (void**)&Direct3DCreate9_ret);
MH_EnableHook(Direct3DCreate9_fn);
// Hook into LoadLibraryA - we'll do our hooks on the flip side
GetProcAddress_fn = reinterpret_cast<GetProcAddress_type>(GetProcAddress);
ASSERT(GetProcAddress_fn);
if (GetProcAddress_fn) {
MH_CreateHook(GetProcAddress_fn, OnGetProcAddress, (void**)&GetProcAddress_ret);
MH_EnableHook(GetProcAddress_fn);
}
Direct3DCreate9Ex_fn = reinterpret_cast<Direct3DCreate9Ex_type>(GetProcAddress(d3d9_dll, "Direct3DCreate9Ex"));
ASSERT(Direct3DCreate9Ex_fn);
if (Direct3DCreate9Ex_fn) {
MH_CreateHook(Direct3DCreate9Ex_fn, Direct3DCreate9Ex, (void**)&Direct3DCreate9Ex_ret);
MH_EnableHook(Direct3DCreate9Ex_fn);
}
}
void ExitInstance()
{
if (Direct3DCreate9_fn)
MH_DisableHook(Direct3DCreate9_fn);
if (Direct3DCreate9Ex_fn)
MH_DisableHook(Direct3DCreate9Ex_fn);
DISABLE_HOOK(GetProcAddress_fn);
MH_Uninitialize();
// Release the system's d3d9.dll
if (gMod_Loaded_d3d9_Module_Handle != nullptr) {
ASSERT(FreeLibrary(gMod_Loaded_d3d9_Module_Handle));
gMod_Loaded_d3d9_Module_Handle = nullptr;
}
if (gMod_Loaded_d3d9_Module_Handle)
FreeLibrary(gMod_Loaded_d3d9_Module_Handle);
#ifdef _DEBUG
if (stdout_proxy)
@@ -184,44 +248,3 @@ void ExitInstance()
#endif
}
HMODULE LoadOriginalDll()
{
HMODULE found = FindLoadedDll();
if (found)
return found;
char executable_path[MAX_PATH]{};
ASSERT(GetModuleFileName(GetModuleHandle(nullptr), executable_path, _countof(executable_path)) > 0);
char gMod_path[MAX_PATH]{};
ASSERT(GetModuleFileName(gl_hThisInstance, gMod_path, _countof(gMod_path)) > 0);
const auto exe_fs_path = std::filesystem::path(executable_path);
const auto gMod_fs_path = std::filesystem::path(gMod_path);
if (exe_fs_path.parent_path() != gMod_fs_path.parent_path()
|| gMod_fs_path.filename() != "d3d9.dll") {
// Call basic LoadLibrary function; we're not in the same directory as the exe.
gMod_Loaded_d3d9_Module_Handle = LoadLibrary("d3d9.dll");
}
else {
// We're in the same directory as the exe, and we're called 'd3d9.dll'. Calling vanilla "LoadLibrary" will be recursive!
char buffer[MAX_PATH];
ASSERT(GetSystemDirectory(buffer, _countof(buffer) > 0)); //get the system directory, we need to open the original d3d9.dll
// Append dll name
strcat_s(buffer, _countof(buffer), "\\d3d9.dll");
gMod_Loaded_d3d9_Module_Handle = LoadLibrary(buffer);
}
ASSERT(gMod_Loaded_d3d9_Module_Handle);
found = FindLoadedDll();
ASSERT(found && found == gMod_Loaded_d3d9_Module_Handle);
return found;
}
/*
* We inject the dll into the game, thus we retour the original Direct3DCreate9 function to our MyDirect3DCreate9 function
*/
source/uMod_IDirect3DCubeTexture9.cpp
+4 -15
View File
@@ -62,18 +62,9 @@ ULONG APIENTRY uMod_IDirect3DCubeTexture9::Release()
if (count == 0) //if texture is released we switch the textures back
{
UnswitchTextures(this);
if (ret == 0x01000000L) {
if (static_cast<uMod_IDirect3DDevice9*>(m_D3Ddev)->GetSingleCubeTexture() != fake_texture) {
fake_texture->Release(); // we release the fake texture
}
}
else {
if (static_cast<uMod_IDirect3DDevice9Ex*>(m_D3Ddev)->GetSingleCubeTexture() != fake_texture) {
fake_texture->Release(); // we release the fake texture
}
}
}
}
else {
count = m_D3Dtex->Release();
}
@@ -233,8 +224,6 @@ HRESULT APIENTRY uMod_IDirect3DCubeTexture9::UnlockRect(D3DCUBEMAP_FACES FaceTyp
return m_D3Dtex->UnlockRect(FaceType, Level);
}
HashType uMod_IDirect3DCubeTexture9::GetHash() const
{
if (FAKE) {
@@ -251,7 +240,7 @@ HashType uMod_IDirect3DCubeTexture9::GetHash() const
if (pTexture->GetLevelDesc(0, &desc) != D3D_OK) //get the format and the size of the texture
{
Message("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetLevelDesc \n");
Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetLevelDesc \n");
return 0;
}
@@ -259,14 +248,14 @@ HashType uMod_IDirect3DCubeTexture9::GetHash() const
if (pTexture->LockRect(D3DCUBEMAP_FACE_POSITIVE_X, 0, &d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK)
{
Message("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 1\n");
Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 1\n");
if (pTexture->GetCubeMapSurface(D3DCUBEMAP_FACE_POSITIVE_X, 0, &pResolvedSurface) != D3D_OK) {
Message("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetSurfaceLevel\n");
Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: GetSurfaceLevel\n");
return 0;
}
if (pResolvedSurface->LockRect(&d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
pResolvedSurface->Release();
Message("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 2\n");
Warning("uMod_IDirect3DCubeTexture9::GetHash() Failed: LockRect 2\n");
return 0;
}
}
source/uMod_IDirect3DDevice9.cpp
+6 -141
View File
@@ -8,126 +8,15 @@
#define PRE_MESSAGE "uMod_IDirect3DDevice9"
#endif
int uMod_IDirect3DDevice9::CreateSingleTexture()
{
if (SingleTexture != nullptr && SingleVolumeTexture != nullptr && SingleCubeTexture != nullptr) {
return RETURN_OK;
}
if (SingleTexture == nullptr) //create texture
{
if (D3D_OK != CreateTexture(8, 8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, (IDirect3DTexture9**)&SingleTexture, nullptr)) {
Message(PRE_MESSAGE "::CreateSingleTexture(): CreateTexture Failed\n");
SingleTexture = nullptr;
return RETURN_TEXTURE_NOT_LOADED;
}
LastCreatedTexture = nullptr; // set LastCreatedTexture to NULL, cause LastCreatedTexture is equal SingleTexture
SingleTexture->FAKE = true; //this is no texture created from by game
}
{
D3DLOCKED_RECT d3dlr;
IDirect3DTexture9* pD3Dtex = SingleTexture->m_D3Dtex;
if (D3D_OK != pD3Dtex->LockRect(0, &d3dlr, nullptr, 0)) {
Message(PRE_MESSAGE "::CreateSingleTexture(): LockRect Failed\n");
SingleTexture->Release();
SingleTexture = nullptr;
return RETURN_TEXTURE_NOT_LOADED;
}
const auto pDst = static_cast<DWORD*>(d3dlr.pBits);
for (int i = 0; i < 8 * 8; i++) {
pDst[i] = TextureColour;
}
pD3Dtex->UnlockRect(0);
}
if (SingleVolumeTexture == nullptr) //create texture
{
if (D3D_OK != CreateVolumeTexture(8, 8, 8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, (IDirect3DVolumeTexture9**)&SingleVolumeTexture, nullptr)) {
Message(PRE_MESSAGE "::CreateSingleTexture(): CreateVolumeTexture Failed\n");
SingleVolumeTexture = nullptr;
return RETURN_TEXTURE_NOT_LOADED;
}
LastCreatedVolumeTexture = nullptr; // set LastCreatedTexture to NULL, cause LastCreatedTexture is equal SingleTexture
SingleVolumeTexture->FAKE = true; //this is no texture created from by game
}
{
D3DLOCKED_BOX d3dlr;
IDirect3DVolumeTexture9* pD3Dtex = SingleVolumeTexture->m_D3Dtex;
//LockBox)(UINT Level, D3DLOCKED_BOX *pLockedVolume, CONST D3DBOX *pBox,
if (D3D_OK != pD3Dtex->LockBox(0, &d3dlr, nullptr, 0)) {
Message(PRE_MESSAGE "::CreateSingleTexture(): LockBox Failed\n");
SingleVolumeTexture->Release();
SingleVolumeTexture = nullptr;
return RETURN_TEXTURE_NOT_LOADED;
}
const auto pDst = static_cast<DWORD*>(d3dlr.pBits);
for (int i = 0; i < 8 * 8 * 8; i++) {
pDst[i] = TextureColour;
}
pD3Dtex->UnlockBox(0);
}
if (SingleCubeTexture == nullptr) //create texture
{
if (D3D_OK != CreateCubeTexture(8, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, (IDirect3DCubeTexture9**)&SingleCubeTexture, nullptr)) {
Message(PRE_MESSAGE "::CreateSingleTexture(): CreateCubeTexture Failed\n");
SingleCubeTexture = nullptr;
return RETURN_TEXTURE_NOT_LOADED;
}
LastCreatedCubeTexture = nullptr; // set LastCreatedTexture to NULL, cause LastCreatedTexture is equal SingleTexture
SingleCubeTexture->FAKE = true; //this is no texture created from by game
}
{
D3DLOCKED_RECT d3dlr;
IDirect3DCubeTexture9* pD3Dtex = SingleCubeTexture->m_D3Dtex;
for (int c = 0; c < 6; c++) {
if (D3D_OK != pD3Dtex->LockRect(static_cast<D3DCUBEMAP_FACES>(c), 0, &d3dlr, nullptr, 0)) {
Message(PRE_MESSAGE "::CreateSingleTexture(): LockRect (Cube) Failed\n");
SingleCubeTexture->Release();
SingleCubeTexture = nullptr;
return RETURN_TEXTURE_NOT_LOADED;
}
const auto pDst = static_cast<DWORD*>(d3dlr.pBits);
for (int i = 0; i < 8 * 8; i++) {
pDst[i] = TextureColour;
}
pD3Dtex->UnlockRect(static_cast<D3DCUBEMAP_FACES>(c), 0);
}
}
return RETURN_OK;
}
uMod_IDirect3DDevice9::uMod_IDirect3DDevice9(IDirect3DDevice9* pOriginal, int back_buffer_count)
{
Message(PRE_MESSAGE "::" PRE_MESSAGE " (%p): %p\n", pOriginal, this);
BackBufferCount = back_buffer_count;
NormalRendering = true;
uMod_Client = new TextureClient(this); //get a new texture client for this device
uMod_Client->Initialize();
LastCreatedTexture = nullptr;
LastCreatedVolumeTexture = nullptr;
LastCreatedCubeTexture = nullptr;
m_pIDirect3DDevice9 = pOriginal; // store the pointer to original object
TextureColour = D3DCOLOR_ARGB(255, 0, 255, 0);
CounterSaveSingleTexture = -20;
SingleTextureMod = 0;
SingleTexture = nullptr;
SingleVolumeTexture = nullptr;
SingleCubeTexture = nullptr;
uMod_Reference = 1;
}
uMod_IDirect3DDevice9::~uMod_IDirect3DDevice9()
@@ -170,19 +59,8 @@ ULONG uMod_IDirect3DDevice9::Release()
// we must not release the fake textures, cause they are released if the target textures are released
// and the target textures are released by the game.
if (SingleTexture != nullptr) {
SingleTexture->Release(); //this is the only texture we must release by ourself
}
if (SingleVolumeTexture != nullptr) {
SingleVolumeTexture->Release(); //this is the only texture we must release by ourself
}
if (SingleCubeTexture != nullptr) {
SingleCubeTexture->Release(); //this is the only texture we must release by ourself
}
delete uMod_Client; //must be deleted at the end, because other releases might call a function of this object
uMod_Client = nullptr;
SingleTexture = nullptr;
}
const ULONG count = m_pIDirect3DDevice9->Release();
@@ -301,24 +179,19 @@ void uMod_IDirect3DDevice9::GetGammaRamp(UINT iSwapChain, D3DGAMMARAMP* pRamp)
HRESULT uMod_IDirect3DDevice9::CreateTexture(UINT Width, UINT Height, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DTexture9** ppTexture, HANDLE* pSharedHandle)
{
//create real texture
//Message("uMod_IDirect3DDevice9::CreateTexture()\n");
Message("uMod_IDirect3DDevice9::CreateTexture()\n");
const HRESULT ret = m_pIDirect3DDevice9->CreateTexture(Width, Height, Levels, Usage, Format, Pool, ppTexture, pSharedHandle);
if (ret != D3D_OK) {
return ret;
}
//create fake texture
const auto texture = new uMod_IDirect3DTexture9(ppTexture, this);
if (texture) {
*ppTexture = texture;
}
if (LastCreatedTexture != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
if (LastCreatedTexture != nullptr && uMod_Client != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
{
if (uMod_Client != nullptr) {
uMod_Client->AddTexture(LastCreatedTexture);
}
}
LastCreatedTexture = texture;
return ret;
}
@@ -326,7 +199,7 @@ HRESULT uMod_IDirect3DDevice9::CreateTexture(UINT Width, UINT Height, UINT Level
HRESULT uMod_IDirect3DDevice9::CreateVolumeTexture(UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DVolumeTexture9** ppVolumeTexture, HANDLE* pSharedHandle)
{
//create real texture
//Message("uMod_IDirect3DDevice9::CreateVolumeTexture()\n");
Message("uMod_IDirect3DDevice9::CreateVolumeTexture()\n");
const HRESULT ret = m_pIDirect3DDevice9->CreateVolumeTexture(Width, Height, Depth, Levels, Usage, Format, Pool, ppVolumeTexture, pSharedHandle);
if (ret != D3D_OK) {
return ret;
@@ -334,16 +207,12 @@ HRESULT uMod_IDirect3DDevice9::CreateVolumeTexture(UINT Width, UINT Height, UINT
//create fake texture
const auto texture = new uMod_IDirect3DVolumeTexture9(ppVolumeTexture, this);
if (texture) {
*ppVolumeTexture = texture;
}
if (LastCreatedVolumeTexture != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
if (LastCreatedVolumeTexture != nullptr && uMod_Client != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
{
if (uMod_Client != nullptr) {
uMod_Client->AddTexture(LastCreatedVolumeTexture);
}
}
LastCreatedVolumeTexture = texture;
return ret;
}
@@ -351,7 +220,7 @@ HRESULT uMod_IDirect3DDevice9::CreateVolumeTexture(UINT Width, UINT Height, UINT
HRESULT uMod_IDirect3DDevice9::CreateCubeTexture(UINT EdgeLength, UINT Levels, DWORD Usage, D3DFORMAT Format, D3DPOOL Pool, IDirect3DCubeTexture9** ppCubeTexture, HANDLE* pSharedHandle)
{
//create real texture
//Message("uMod_IDirect3DDevice9::CreateCubeTexture()\n");
Message("uMod_IDirect3DDevice9::CreateCubeTexture()\n");
const HRESULT ret = m_pIDirect3DDevice9->CreateCubeTexture(EdgeLength, Levels, Usage, Format, Pool, ppCubeTexture, pSharedHandle);
if (ret != D3D_OK) {
return ret;
@@ -359,16 +228,12 @@ HRESULT uMod_IDirect3DDevice9::CreateCubeTexture(UINT EdgeLength, UINT Levels, D
//create fake texture
const auto texture = new uMod_IDirect3DCubeTexture9(ppCubeTexture, this);
if (texture) {
*ppCubeTexture = texture;
}
if (LastCreatedCubeTexture != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
if (LastCreatedCubeTexture != nullptr && uMod_Client != nullptr) //if a texture was loaded before, hopefully this texture contains now the data, so we can add it
{
if (uMod_Client != nullptr) {
uMod_Client->AddTexture(LastCreatedCubeTexture);
}
}
LastCreatedCubeTexture = texture;
return ret;
}
source/uMod_IDirect3DTexture9.cpp
+10 -19
View File
@@ -62,18 +62,9 @@ ULONG APIENTRY uMod_IDirect3DTexture9::Release()
if (count == 0) //if texture is released we switch the textures back
{
UnswitchTextures(this);
if (ret == 0x01000000L) {
if (static_cast<uMod_IDirect3DDevice9*>(m_D3Ddev)->GetSingleTexture() != fake_texture) {
fake_texture->Release(); // we release the fake texture
}
}
else {
if (static_cast<uMod_IDirect3DDevice9Ex*>(m_D3Ddev)->GetSingleTexture() != fake_texture) {
fake_texture->Release(); // we release the fake texture
}
}
}
}
else {
count = m_D3Dtex->Release();
}
@@ -252,7 +243,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
if (pTexture->GetLevelDesc(0, &desc) != D3D_OK) //get the format and the size of the texture
{
Message("uMod_IDirect3DTexture9::GetHash() Failed: GetLevelDesc \n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetLevelDesc \n");
return 0;
}
@@ -265,7 +256,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
IDirect3DSurface9* pSurfaceLevel_orig = nullptr;
if (pTexture->GetSurfaceLevel(0, &pSurfaceLevel_orig) != D3D_OK) {
Message("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel 1 (D3DPOOL_DEFAULT)\n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel 1 (D3DPOOL_DEFAULT)\n");
return 0;
}
@@ -273,12 +264,12 @@ HashType uMod_IDirect3DTexture9::GetHash() const
//Message("uMod_IDirect3DTexture9::GetHash() MultiSampleType\n");
if (D3D_OK != m_D3Ddev->CreateRenderTarget(desc.Width, desc.Height, desc.Format, D3DMULTISAMPLE_NONE, 0, FALSE, &pResolvedSurface, nullptr)) {
pSurfaceLevel_orig->Release();
Message("uMod_IDirect3DTexture9::GetHash() Failed: CreateRenderTarget (D3DPOOL_DEFAULT)\n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: CreateRenderTarget (D3DPOOL_DEFAULT)\n");
return 0;
}
if (D3D_OK != m_D3Ddev->StretchRect(pSurfaceLevel_orig, nullptr, pResolvedSurface, nullptr, D3DTEXF_NONE)) {
pSurfaceLevel_orig->Release();
Message("uMod_IDirect3DTexture9::GetHash() Failed: StretchRect (D3DPOOL_DEFAULT)\n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: StretchRect (D3DPOOL_DEFAULT)\n");
return 0;
}
@@ -290,7 +281,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
if (pResolvedSurface != nullptr) {
pResolvedSurface->Release();
}
Message("uMod_IDirect3DTexture9::GetHash() Failed: CreateOffscreenPlainSurface (D3DPOOL_DEFAULT)\n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: CreateOffscreenPlainSurface (D3DPOOL_DEFAULT)\n");
return 0;
}
@@ -300,7 +291,7 @@ HashType uMod_IDirect3DTexture9::GetHash() const
pResolvedSurface->Release();
}
pOffscreenSurface->Release();
Message("uMod_IDirect3DTexture9::GetHash() Failed: GetRenderTargetData (D3DPOOL_DEFAULT)\n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetRenderTargetData (D3DPOOL_DEFAULT)\n");
return 0;
}
pSurfaceLevel_orig->Release();
@@ -310,19 +301,19 @@ HashType uMod_IDirect3DTexture9::GetHash() const
pResolvedSurface->Release();
}
pOffscreenSurface->Release();
Message("uMod_IDirect3DTexture9::GetHash() Failed: LockRect (D3DPOOL_DEFAULT)\n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: LockRect (D3DPOOL_DEFAULT)\n");
return 0;
}
}
else if (pTexture->LockRect(0, &d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
Message("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 1\n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 1\n");
if (pTexture->GetSurfaceLevel(0, &pResolvedSurface) != D3D_OK) {
Message("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel\n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: GetSurfaceLevel\n");
return 0;
}
if (pResolvedSurface->LockRect(&d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
pResolvedSurface->Release();
Message("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 2\n");
Warning("uMod_IDirect3DTexture9::GetHash() Failed: LockRect 2\n");
return 0;
}
}
source/uMod_IDirect3DVolumeTexture9.cpp
+4 -18
View File
@@ -61,18 +61,9 @@ ULONG APIENTRY uMod_IDirect3DVolumeTexture9::Release()
if (count == 0) //if texture is released we switch the textures back
{
UnswitchTextures(this);
if (ret == 0x01000000L) {
if (static_cast<uMod_IDirect3DDevice9*>(m_D3Ddev)->GetSingleVolumeTexture() != fake_texture) {
fake_texture->Release(); // we release the fake texture
}
}
else {
if (static_cast<uMod_IDirect3DDevice9Ex*>(m_D3Ddev)->GetSingleVolumeTexture() != fake_texture) {
fake_texture->Release(); // we release the fake texture
}
}
}
}
else {
count = m_D3Dtex->Release();
}
@@ -187,8 +178,6 @@ void APIENTRY uMod_IDirect3DVolumeTexture9::GenerateMipSubLevels()
m_D3Dtex->GenerateMipSubLevels();
}
//this function yields for the non switched texture object
HRESULT APIENTRY uMod_IDirect3DVolumeTexture9::AddDirtyBox(CONST D3DBOX* pDirtyBox)
{
@@ -234,7 +223,6 @@ HRESULT APIENTRY uMod_IDirect3DVolumeTexture9::UnlockBox(UINT Level)
return m_D3Dtex->UnlockBox(Level);
}
HashType uMod_IDirect3DVolumeTexture9::GetHash() const
{
if (FAKE) {
@@ -251,26 +239,24 @@ HashType uMod_IDirect3DVolumeTexture9::GetHash() const
if (pTexture->GetLevelDesc(0, &desc) != D3D_OK) //get the format and the size of the texture
{
Message("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetLevelDesc \n");
Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetLevelDesc \n");
return 0;
}
Message("uMod_IDirect3DVolumeTexture9::GetHash() (%d %d %d) %d\n", desc.Width, desc.Height, desc.Depth, desc.Format);
if (pTexture->LockBox(0, &d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
Message("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 1\n");
Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 1\n");
if (pTexture->GetVolumeLevel(0, &pResolvedSurface) != D3D_OK) {
Message("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetSurfaceLevel\n");
Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: GetSurfaceLevel\n");
return 0;
}
if (pResolvedSurface->LockBox(&d3dlr, nullptr, D3DLOCK_READONLY) != D3D_OK) {
pResolvedSurface->Release();
Message("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 2\n");
Warning("uMod_IDirect3DVolumeTexture9::GetHash() Failed: LockRect 2\n");
return 0;
}
}
const int size = (GetBitsFromFormat(desc.Format) * desc.Width * desc.Height * desc.Depth) / 8;
const auto hash = GetCRC32(static_cast<char*>(d3dlr.pBits), size); //calculate the crc32 of the texture