ShibaGit/khaotic-engine-Reborn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 7 Wiki Activity

Minor Update - Logger transformer en Singleton

Browse Source
This commit is contained in:
CatChow0 2024-04-12 17:59:44 +02:00
parent 3bc9eee3cc
commit 25f05fe217
52 changed files with 535 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
enginecustom/Colorshaderclass.cpp
View File

@ -23,7 +23,7 @@ ColorShaderClass::~ColorShaderClass()
bool ColorShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing ColorShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing ColorShaderClass", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -35,7 +35,7 @@ bool ColorShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"../enginecustom/Color.vs");
if (error != 0)
{
logger.Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -43,7 +43,7 @@ bool ColorShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"../enginecustom/Color.ps");
if (error != 0)
{
logger.Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -51,11 +51,11 @@ bool ColorShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("ColorShaderClass initialized", __FILE__, __LINE__);
Logger::Get().Log("ColorShaderClass initialized", __FILE__, __LINE__);
return true;
}
@ -78,7 +78,7 @@ bool ColorShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix);
if (!result)
{
logger.Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -90,7 +90,7 @@ bool ColorShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount
bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
logger.Log("Initializing shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing shader", __FILE__, __LINE__);
HRESULT result;
ID3D10Blob* errorMessage;
@ -119,7 +119,7 @@ bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -138,7 +138,7 @@ bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -148,7 +148,7 @@ bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -156,7 +156,7 @@ bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -186,7 +186,7 @@ bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -209,18 +209,18 @@ bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Shader initialized", __FILE__, __LINE__);
return true;
}
void ColorShaderClass::ShutdownShader()
{
logger.Log("Shutting down shader", __FILE__, __LINE__);
Logger::Get().Log("Shutting down shader", __FILE__, __LINE__);
// Release the matrix constant buffer.
if (m_matrixBuffer)
@ -250,7 +250,7 @@ void ColorShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("Shader shut down", __FILE__, __LINE__);
Logger::Get().Log("Shader shut down", __FILE__, __LINE__);
return;
}
@ -293,7 +293,7 @@ void ColorShaderClass::OutputShaderErrorMessage(ID3D10Blob* errorMessage, HWND h
bool ColorShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix,
XMMATRIX projectionMatrix)
{
logger.Log("Setting shader parameters", __FILE__, __LINE__);
Logger::Get().Log("Setting shader parameters", __FILE__, __LINE__);
HRESULT result;
D3D11_MAPPED_SUBRESOURCE mappedResource;
@ -309,7 +309,7 @@ bool ColorShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, X
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

2
enginecustom/Colorshaderclass.h
View File

@ -52,8 +52,6 @@ private:
ID3D11PixelShader* m_pixelShader;
ID3D11InputLayout* m_layout;
ID3D11Buffer* m_matrixBuffer;
Logger logger;
};
#endif

46
enginecustom/Lightshaderclass.cpp
View File

@ -30,7 +30,7 @@ LightShaderClass::~LightShaderClass()
bool LightShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing LightShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing LightShaderClass", __FILE__, __LINE__);
wchar_t vsFilename[128];
wchar_t psFilename[128];
@ -41,7 +41,7 @@ bool LightShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"light.vs");
if (error != 0)
{
logger.Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -49,18 +49,18 @@ bool LightShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"light.ps");
if (error != 0)
{
logger.Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Initialize the vertex and pixel shaders.
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("LightShaderClass initialized", __FILE__, __LINE__);
Logger::Get().Log("LightShaderClass initialized", __FILE__, __LINE__);
return true;
}
@ -84,7 +84,7 @@ bool LightShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, lightPosition);
if(!result)
{
logger.Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -127,7 +127,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -145,7 +145,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -155,7 +155,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -163,7 +163,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -201,7 +201,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
&m_layout);
if (FAILED(result))
{
logger.Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -231,7 +231,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -247,7 +247,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -265,7 +265,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateBuffer(&cameraBufferDesc, NULL, &m_cameraBuffer);
if (FAILED(result))
{
logger.Log("Failed to create camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -281,7 +281,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateBuffer(&lightColorBufferDesc, NULL, &m_lightColorBuffer);
if (FAILED(result))
{
logger.Log("Failed to create light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -297,11 +297,11 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateBuffer(&lightPositionBufferDesc, NULL, &m_lightPositionBuffer);
if (FAILED(result))
{
logger.Log("Failed to create light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Shader initialized", __FILE__, __LINE__);
return true;
}
@ -309,7 +309,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
void LightShaderClass::ShutdownShader()
{
logger.Log("Shutting down LightShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Shutting down LightShaderClass", __FILE__, __LINE__);
// Release the light constant buffers.
if (m_lightColorBuffer)
@ -373,7 +373,7 @@ void LightShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("LightShaderClass shut down", __FILE__, __LINE__);
Logger::Get().Log("LightShaderClass shut down", __FILE__, __LINE__);
return;
}
@ -434,7 +434,7 @@ bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, X
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -459,7 +459,7 @@ bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, X
result = deviceContext->Map(m_cameraBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -467,7 +467,7 @@ bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, X
result = deviceContext->Map(m_lightPositionBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -496,7 +496,7 @@ bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, X
result = deviceContext->Map(m_lightColorBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/Lightshaderclass.h
View File

@ -89,7 +89,6 @@ private:
ID3D11Buffer* m_lightColorBuffer;
ID3D11Buffer* m_lightPositionBuffer;
Logger logger;
};
#endif

56
enginecustom/Logger.h
View File

@ -5,11 +5,21 @@
#include <chrono>
#include <iomanip>
#include <sstream>
#include <filesystem>
class Logger
{
public:
static Logger& Get()
{
static Logger instance;
return instance;
}
Logger(Logger const&) = delete;
void operator=(Logger const&) = delete;
enum class LogLevel
{
Info,
@ -34,6 +44,8 @@ public:
std::string directoryPath = m_appdataPath + "\\Khaotic Engine";
CreateDirectoryA(directoryPath.c_str(), NULL);
ManageLogFiles(directoryPath);
m_logFilePath = directoryPath + "\\" + m_logFileName;
}
@ -77,9 +89,51 @@ public:
}
}
void ManageLogFiles(const std::string& directoryPath)
{
std::vector<std::filesystem::path> logFiles;
// Parcourez tous les fichiers dans le dossier
for (const auto& entry : std::filesystem::directory_iterator(directoryPath))
{
// Si le fichier est un fichier de log, ajoutez-le à la liste
if (entry.path().extension() == ".log")
{
logFiles.push_back(entry.path());
}
}
// Si nous avons plus de trois fichiers de log, supprimez le plus ancien
while (logFiles.size() >= 3)
{
// Triez les fichiers par date de modification, le plus ancien en premier
std::sort(logFiles.begin(), logFiles.end(), [](const std::filesystem::path& a, const std::filesystem::path& b)
{
return std::filesystem::last_write_time(a) < std::filesystem::last_write_time(b);
});
// Supprimez le fichier le plus ancien
std::filesystem::remove(logFiles[0]);
// Supprimez-le de la liste
logFiles.erase(logFiles.begin());
}
// Créez un nouveau fichier de log pour cette exécution
auto now = std::chrono::system_clock::now();
auto in_time_t = std::chrono::system_clock::to_time_t(now);
std::tm buf;
localtime_s(&buf, &in_time_t);
std::stringstream ss;
ss << "Khaotic_log_" << std::put_time(&buf, "%Y_%m_%d_%Hh%Mm%Ss") << ".log";
m_logFileName = ss.str();
}
private:
std::string m_filename;
std::string m_appdataPath;
std::string m_logFileName = "enginecustom.log";
std::string m_logFileName;
std::string m_logFilePath;
};

4
enginecustom/Main.cpp
View File

@ -5,8 +5,6 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pScmdline,
{
SystemClass* System;
bool result;
Logger logger;
// Create the system object.
System = new SystemClass;
@ -15,7 +13,7 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR pScmdline,
result = System->Initialize();
if (result)
{
logger.Log("System initialized", __FILE__, __LINE__);
Logger::Get().Log("System initialized", __FILE__, __LINE__);
System->Run();
}

34
enginecustom/Multitextureshaderclass.cpp
View File

@ -26,7 +26,7 @@ MultiTextureShaderClass::~MultiTextureShaderClass()
bool MultiTextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing MultiTextureShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing MultiTextureShaderClass", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -37,7 +37,7 @@ bool MultiTextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"multitexture.vs");
if (error != 0)
{
logger.Log("Failed to set the filename of the vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set the filename of the vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -45,7 +45,7 @@ bool MultiTextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"multitexture.ps");
if (error != 0)
{
logger.Log("Failed to set the filename of the pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set the filename of the pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -53,7 +53,7 @@ bool MultiTextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Failed to initialize the vertex and pixel shaders", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize the vertex and pixel shaders", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -78,7 +78,7 @@ bool MultiTextureShaderClass::Render(ID3D11DeviceContext* deviceContext, int ind
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2);
if (!result)
{
logger.Log("Failed to set the shader parameters that it will use for rendering", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set the shader parameters that it will use for rendering", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -90,7 +90,7 @@ bool MultiTextureShaderClass::Render(ID3D11DeviceContext* deviceContext, int ind
bool MultiTextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
logger.Log("Initializing the shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing the shader", __FILE__, __LINE__);
HRESULT result;
ID3D10Blob* errorMessage;
@ -120,7 +120,7 @@ bool MultiTextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Failed to compile the vertex shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile the vertex shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -139,7 +139,7 @@ bool MultiTextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Failed to compile the pixel shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile the pixel shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -149,7 +149,7 @@ bool MultiTextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd,
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Failed to create the vertex shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the vertex shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -157,7 +157,7 @@ bool MultiTextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd,
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Failed to create the pixel shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the pixel shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -194,7 +194,7 @@ bool MultiTextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd,
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Failed to create the vertex input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the vertex input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -217,7 +217,7 @@ bool MultiTextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Failed to create the constant buffer pointer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the constant buffer pointer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -240,18 +240,18 @@ bool MultiTextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd,
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Failed to create the texture sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the texture sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Shader initialized", __FILE__, __LINE__);
return true;
}
void MultiTextureShaderClass::ShutdownShader()
{
logger.Log("Shutting down the shader", __FILE__, __LINE__);
Logger::Get().Log("Shutting down the shader", __FILE__, __LINE__);
// Release the sampler state.
if (m_sampleState)
@ -288,7 +288,7 @@ void MultiTextureShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("Shader shut down", __FILE__, __LINE__);
Logger::Get().Log("Shader shut down", __FILE__, __LINE__);
return;
}
@ -346,7 +346,7 @@ bool MultiTextureShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceCon
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to lock the constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to lock the constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/Multitextureshaderclass.h
View File

@ -54,7 +54,6 @@ private:
ID3D11Buffer* m_matrixBuffer;
ID3D11SamplerState* m_sampleState;
Logger logger;
};
#endif

46
enginecustom/Systemclass.cpp
View File

@ -4,7 +4,7 @@
#include <windows.h>
extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
SystemClass::SystemClass() : logger()
SystemClass::SystemClass()
{
m_Input = 0;
m_Application = 0;
@ -25,7 +25,7 @@ bool SystemClass::Initialize()
int screenWidth, screenHeight;
bool result;
logger.Log("Initializing system class", __FILE__, __LINE__);
Logger::Get().Log("Initializing system class", __FILE__, __LINE__);
try
{
@ -46,7 +46,7 @@ bool SystemClass::Initialize()
result = m_Input->Initialize(m_hinstance, m_hwnd, screenWidth, screenHeight);
if (!result)
{
logger.Log("Failed to initialize input class", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize input class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -77,54 +77,54 @@ bool SystemClass::Initialize()
}
catch (const std::exception& e)
{
logger.Log(std::string("Exception caught during initialization: ") + e.what(), __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log(std::string("Exception caught during initialization: ") + e.what(), __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("System class initialized", __FILE__, __LINE__);
Logger::Get().Log("System class initialized", __FILE__, __LINE__);
return true;
}
void SystemClass::Shutdown()
{
logger.Log("Shutting down system class", __FILE__, __LINE__);
Logger::Get().Log("Shutting down system class", __FILE__, __LINE__);
std::lock_guard<std::mutex> guard(renderMutex);
// Shutdown imgui
if (m_imguiManager)
{
logger.Log("Shutting down imgui manager", __FILE__, __LINE__);
Logger::Get().Log("Shutting down imgui manager", __FILE__, __LINE__);
m_imguiManager->Shutdown();
delete m_imguiManager;
m_imguiManager = 0;
logger.Log("Imgui manager shut down", __FILE__, __LINE__);
Logger::Get().Log("Imgui manager shut down", __FILE__, __LINE__);
}
// Release the application class object.
if (m_Application)
{
logger.Log("Shutting down application", __FILE__, __LINE__);
Logger::Get().Log("Shutting down application", __FILE__, __LINE__);
m_Application->Shutdown();
delete m_Application;
m_Application = 0;
logger.Log("Application shut down", __FILE__, __LINE__);
Logger::Get().Log("Application shut down", __FILE__, __LINE__);
}
// Release the input object.
if (m_Input)
{
logger.Log("Shutting down input", __FILE__, __LINE__);
Logger::Get().Log("Shutting down input", __FILE__, __LINE__);
delete m_Input;
m_Input = 0;
logger.Log("Input shut down", __FILE__, __LINE__);
Logger::Get().Log("Input shut down", __FILE__, __LINE__);
}
@ -132,7 +132,7 @@ void SystemClass::Shutdown()
// Shutdown the window.
ShutdownWindows();
logger.Log("System class shut down", __FILE__, __LINE__);
Logger::Get().Log("System class shut down", __FILE__, __LINE__);
return;
}
@ -142,7 +142,7 @@ void SystemClass::Run()
MSG msg;
bool done, result;
logger.Log("Running the system", __FILE__, __LINE__);
Logger::Get().Log("Running the system", __FILE__, __LINE__);
// Initialize the message structure.
ZeroMemory(&msg, sizeof(MSG));
@ -168,7 +168,7 @@ void SystemClass::Run()
// If windows signals to end the application then exit out.
if (m_Application != nullptr && m_Application->GetShouldQuit())
{
logger.Log("Received quit signal from application", __FILE__, __LINE__);
Logger::Get().Log("Received quit signal from application", __FILE__, __LINE__);
done = true;
}
else
@ -177,7 +177,7 @@ void SystemClass::Run()
result = Frame();
if (!result)
{
logger.Log("Failed to process frame", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to process frame", __FILE__, __LINE__, Logger::LogLevel::Error);
done = true;
}
}
@ -197,7 +197,7 @@ bool SystemClass::Frame()
result = m_Input->Frame();
if (!result)
{
logger.Log("Failed to process input frame", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to process input frame", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -205,7 +205,7 @@ bool SystemClass::Frame()
result = m_imguiManager->ImGuiWidgetRenderer(m_Application);
if (!result)
{
logger.Log("Failed to render ImGui widgets", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to render ImGui widgets", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -213,7 +213,7 @@ bool SystemClass::Frame()
result = m_Application->Frame(m_Input);
if (!result)
{
logger.Log("Failed to process application frame", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to process application frame", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -303,7 +303,7 @@ LRESULT CALLBACK SystemClass::MessageHandler(HWND hwnd, UINT umsg, WPARAM wparam
}
case WM_CLOSE:
{
logger.Log("WM_CLOSE message received", __FILE__, __LINE__);
Logger::Get().Log("WM_CLOSE message received", __FILE__, __LINE__);
m_Application->SetShouldQuit(true);
return 0;
}
@ -324,7 +324,7 @@ void SystemClass::InitializeWindows(int& screenWidth, int& screenHeight)
DEVMODE dmScreenSettings;
int posX, posY;
logger.Log("Initializing windows", __FILE__, __LINE__);
Logger::Get().Log("Initializing windows", __FILE__, __LINE__);
// Get an external pointer to this object.
ApplicationHandle = this;
@ -405,9 +405,9 @@ void SystemClass::InitializeWindows(int& screenWidth, int& screenHeight)
void SystemClass::ShutdownWindows()
{
logger.Log("Shutting down windows", __FILE__, __LINE__);
Logger::Get().Log("Shutting down windows", __FILE__, __LINE__);
logger.Log("Shutting down the windows", __FILE__, __LINE__);
Logger::Get().Log("Shutting down the windows", __FILE__, __LINE__);
// Show the mouse cursor.
ShowCursor(true);

4
enginecustom/Timerclass.cpp
View File

@ -17,7 +17,7 @@ TimerClass::~TimerClass()
bool TimerClass::Initialize()
{
logger.Log("Initilazing timer class", __FILE__, __LINE__);
Logger::Get().Log("Initilazing timer class", __FILE__, __LINE__);
INT64 frequency;
@ -26,7 +26,7 @@ bool TimerClass::Initialize()
QueryPerformanceFrequency((LARGE_INTEGER*)&frequency);
if (frequency == 0)
{
logger.Log("QueryPerformanceFrequency failed", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("QueryPerformanceFrequency failed", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

2
enginecustom/Timerclass.h
View File

@ -29,8 +29,6 @@ private:
INT64 m_startTime;
float m_frameTime;
Logger logger;
};
#endif

32
enginecustom/alphamapshaderclass.cpp
View File

@ -23,7 +23,7 @@ AlphaMapShaderClass::~AlphaMapShaderClass()
bool AlphaMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing AlphaMapShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing AlphaMapShaderClass", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -34,7 +34,7 @@ bool AlphaMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"alphamap.vs");
if (error != 0)
{
logger.Log("Error copying string ", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string ", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -42,7 +42,7 @@ bool AlphaMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"alphamap.ps");
if (error != 0)
{
logger.Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -50,7 +50,7 @@ bool AlphaMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -89,7 +89,7 @@ bool AlphaMapShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCo
bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
logger.Log("Initializing shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing shader", __FILE__, __LINE__);
HRESULT result;
ID3D10Blob* errorMessage;
@ -119,7 +119,7 @@ bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -138,7 +138,7 @@ bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -148,7 +148,7 @@ bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -156,7 +156,7 @@ bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -193,7 +193,7 @@ bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -216,7 +216,7 @@ bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -239,11 +239,11 @@ bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Shader initialized", __FILE__, __LINE__);
return true;
}
@ -252,7 +252,7 @@ bool AlphaMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
void AlphaMapShaderClass::ShutdownShader()
{
logger.Log("Shutting down shader", __FILE__, __LINE__);
Logger::Get().Log("Shutting down shader", __FILE__, __LINE__);
// Release the sampler state.
if (m_sampleState)
@ -289,7 +289,7 @@ void AlphaMapShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("Shader shutdown complete", __FILE__, __LINE__);
Logger::Get().Log("Shader shutdown complete", __FILE__, __LINE__);
return;
}
@ -349,7 +349,7 @@ bool AlphaMapShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

2
enginecustom/alphamapshaderclass.h
View File

@ -50,8 +50,6 @@ private:
ID3D11InputLayout* m_layout;
ID3D11Buffer* m_matrixBuffer;
ID3D11SamplerState* m_sampleState;
Logger logger;
};
#endif

172
enginecustom/applicationclass.cpp
View File

@ -36,7 +36,7 @@ ApplicationClass::~ApplicationClass()
bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
{
logger.Log("Initializing application class", __FILE__, __LINE__);
Logger::Get().Log("Initializing application class", __FILE__, __LINE__);
try
{
@ -55,14 +55,14 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
m_Direct3D = new D3DClass;
if (!m_Direct3D)
{
logger.Log("Could not create the Direct3D object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not create the Direct3D object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
result = m_Direct3D->Initialize(screenWidth, screenHeight, VSYNC_ENABLED, hwnd, FULL_SCREEN, SCREEN_DEPTH, SCREEN_NEAR);
if (!result)
{
logger.Log("Could not initialize Direct3D", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize Direct3D", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -70,7 +70,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
m_Camera = new CameraClass;
if (!m_Camera)
{
logger.Log("Could not create the camera object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not create the camera object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -86,7 +86,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_FontShader->Initialize(m_Direct3D->GetDevice(), hwnd);
if (!result)
{
logger.Log("Could not initialize the font shader object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the font shader object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -96,7 +96,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_Font->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), 0);
if (!result)
{
logger.Log("Could not initialize the font object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the font object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -106,7 +106,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_RenderTexture->Initialize(m_Direct3D->GetDevice(), 256, 256, SCREEN_DEPTH, SCREEN_NEAR, 1);
if (!result)
{
logger.Log("Could not initialize the render texture object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the render texture object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -116,7 +116,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_DisplayPlane->Initialize(m_Direct3D->GetDevice(), 1.0f, 1.0f);
if (!result)
{
logger.Log("Could not initialize the display plane object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the display plane object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -130,7 +130,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_Sprite->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), screenWidth, screenHeight, spriteFilename, 50, 50);
if (!result)
{
logger.Log("Could not initialize the sprite object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the sprite object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -148,7 +148,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_MouseStrings[i].Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), screenWidth, screenHeight, 32, m_Font, mouseString1, 10, y, 1.0f, 1.0f, 1.0f);
if (!result)
{
logger.Log("Could not initialize the mouse strings", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the mouse strings", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
}
@ -162,7 +162,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_Bitmap->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), screenWidth, screenHeight, bitmapFilename, 50, 50);
if (!result)
{
logger.Log("Could not initialize the bitmap object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the bitmap object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -183,7 +183,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_Model->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), modelFilename, Filename);
if (!result)
{
logger.Log("Could not initialize the model object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the model object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -237,7 +237,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_ShaderManager->Initialize(m_Direct3D->GetDevice(), hwnd);
if (!result)
{
logger.Log("Could not initialize the shader manager object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the shader manager object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -250,7 +250,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_RenderCountString->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), screenWidth, screenHeight, 32, m_Font, renderString, 10, 10, 1.0f, 1.0f, 1.0f);
if (!result)
{
logger.Log("Could not initialize the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -264,7 +264,7 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_Timer->Initialize();
if (!result)
{
logger.Log("Could not initialize the timer object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the timer object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -289,16 +289,16 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
result = m_FpsString->Initialize(m_Direct3D->GetDevice(), m_Direct3D->GetDeviceContext(), screenWidth, screenHeight, 32, m_Font, fpsString, 10, 10, 0.0f, 1.0f, 0.0f);
if (!result)
{
logger.Log("Could not initialize the fps string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not initialize the fps string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
}
catch (const std::exception& e)
{
logger.Log(std::string("Exception caught during initialization: ") + e.what(), __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log(std::string("Exception caught during initialization: ") + e.what(), __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Application class initialized", __FILE__, __LINE__);
Logger::Get().Log("Application class initialized", __FILE__, __LINE__);
return true;
}
@ -306,82 +306,82 @@ bool ApplicationClass::Initialize(int screenWidth, int screenHeight, HWND hwnd)
void ApplicationClass::Shutdown()
{
logger.Log("Shutting down application class", __FILE__, __LINE__);
Logger::Get().Log("Shutting down application class", __FILE__, __LINE__);
// Release the shader manager object.
if (m_ShaderManager)
{
logger.Log("Releasing the shader manager object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the shader manager object", __FILE__, __LINE__);
m_ShaderManager->Shutdown();
delete m_ShaderManager;
m_ShaderManager = 0;
logger.Log("Shader manager object released", __FILE__, __LINE__);
Logger::Get().Log("Shader manager object released", __FILE__, __LINE__);
}
// Release the frustum class object.
if (m_Frustum)
{
logger.Log("Releasing the frustum class object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the frustum class object", __FILE__, __LINE__);
delete m_Frustum;
m_Frustum = 0;
logger.Log("Frustum class object released", __FILE__, __LINE__);
Logger::Get().Log("Frustum class object released", __FILE__, __LINE__);
}
// Release the display plane object.
if (m_DisplayPlane)
{
logger.Log("Releasing the display plane object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the display plane object", __FILE__, __LINE__);
m_DisplayPlane->Shutdown();
delete m_DisplayPlane;
m_DisplayPlane = 0;
logger.Log("Display plane object released", __FILE__, __LINE__);
Logger::Get().Log("Display plane object released", __FILE__, __LINE__);
}
// Release the position object.
if (m_Position)
{
logger.Log("Releasing the position object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the position object", __FILE__, __LINE__);
delete m_Position;
m_Position = 0;
logger.Log("Position object released", __FILE__, __LINE__);
Logger::Get().Log("Position object released", __FILE__, __LINE__);
}
// Release the model list object.
if (m_ModelList)
{
logger.Log("Releasing the model list object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the model list object", __FILE__, __LINE__);
m_ModelList->Shutdown();
delete m_ModelList;
m_ModelList = 0;
logger.Log("Model list object released", __FILE__, __LINE__);
Logger::Get().Log("Model list object released", __FILE__, __LINE__);
}
// Release the text objects for the render count string.
if (m_RenderCountString)
{
logger.Log("Releasing the render count string object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the render count string object", __FILE__, __LINE__);
m_RenderCountString->Shutdown();
delete m_RenderCountString;
m_RenderCountString = 0;
logger.Log("Render count string object released", __FILE__, __LINE__);
Logger::Get().Log("Render count string object released", __FILE__, __LINE__);
}
// Release the text objects for the mouse strings.
if (m_MouseStrings)
{
logger.Log("Releasing the mouse strings", __FILE__, __LINE__);
Logger::Get().Log("Releasing the mouse strings", __FILE__, __LINE__);
m_MouseStrings[0].Shutdown();
m_MouseStrings[1].Shutdown();
@ -390,107 +390,107 @@ void ApplicationClass::Shutdown()
delete[] m_MouseStrings;
m_MouseStrings = 0;
logger.Log("Mouse strings released", __FILE__, __LINE__);
Logger::Get().Log("Mouse strings released", __FILE__, __LINE__);
}
// Release the text object for the fps string.
if (m_FpsString)
{
logger.Log("Releasing the fps string object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the fps string object", __FILE__, __LINE__);
m_FpsString->Shutdown();
delete m_FpsString;
m_FpsString = 0;
logger.Log("Fps string object released", __FILE__, __LINE__);
Logger::Get().Log("Fps string object released", __FILE__, __LINE__);
}
// Release the fps object.
if (m_Fps)
{
logger.Log("Releasing the fps object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the fps object", __FILE__, __LINE__);
delete m_Fps;
m_Fps = 0;
logger.Log("Fps object released", __FILE__, __LINE__);
Logger::Get().Log("Fps object released", __FILE__, __LINE__);
}
// Release the font object.
if (m_Font)
{
logger.Log("Releasing the font object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the font object", __FILE__, __LINE__);
m_Font->Shutdown();
delete m_Font;
m_Font = 0;
logger.Log("Font object released", __FILE__, __LINE__);
Logger::Get().Log("Font object released", __FILE__, __LINE__);
}
// Release the font shader object.
if (m_FontShader)
{
logger.Log("Releasing the font shader object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the font shader object", __FILE__, __LINE__);
m_FontShader->Shutdown();
delete m_FontShader;
m_FontShader = 0;
logger.Log("Font shader object released", __FILE__, __LINE__);
Logger::Get().Log("Font shader object released", __FILE__, __LINE__);
}
// Release the timer object.
if (m_Timer)
{
logger.Log("Releasing the timer object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the timer object", __FILE__, __LINE__);
delete m_Timer;
m_Timer = 0;
logger.Log("Timer object released", __FILE__, __LINE__);
Logger::Get().Log("Timer object released", __FILE__, __LINE__);
}
// Release the sprite object.
if (m_Sprite)
{
logger.Log("Releasing the sprite object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the sprite object", __FILE__, __LINE__);
m_Sprite->Shutdown();
delete m_Sprite;
m_Sprite = 0;
logger.Log("Sprite object released", __FILE__, __LINE__);
Logger::Get().Log("Sprite object released", __FILE__, __LINE__);
}
for (auto light : m_Lights)
{
logger.Log("Releasing the light object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the light object", __FILE__, __LINE__);
if (light)
{
delete light;
light = 0;
}
logger.Log("Light object released", __FILE__, __LINE__);
Logger::Get().Log("Light object released", __FILE__, __LINE__);
}
// Release the light object.
if (m_Light)
{
logger.Log("Releasing the light object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the light object", __FILE__, __LINE__);
delete m_Light;
m_Light = 0;
logger.Log("Light object released", __FILE__, __LINE__);
Logger::Get().Log("Light object released", __FILE__, __LINE__);
}
// Release the model object.
if (m_Model)
{
logger.Log("Releasing the model object", __FILE__, __LINE__);
Logger::Get().Log("Releasing the model object", __FILE__, __LINE__);
m_Model->Shutdown();
delete m_Model;
m_Model = 0;
logger.Log("Model object released", __FILE__, __LINE__);
Logger::Get().Log("Model object released", __FILE__, __LINE__);
}
}
@ -520,7 +520,7 @@ bool ApplicationClass::Frame(InputClass* Input)
// Check if the user pressed escape and wants to exit the application.
if (Input->IsEscapePressed())
{
logger.Log("User pressed escape, exiting application", __FILE__, __LINE__);
Logger::Get().Log("User pressed escape, exiting application", __FILE__, __LINE__);
m_ShouldQuit = true;
}
@ -575,7 +575,7 @@ bool ApplicationClass::Frame(InputClass* Input)
result = Render(rotation, x, y, z, textureTranslation);
if (!result)
{
logger.Log("Could not render the graphics scene", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the graphics scene", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -583,7 +583,7 @@ bool ApplicationClass::Frame(InputClass* Input)
result = UpdateFps();
if (!result)
{
logger.Log("Could not update the frames per second", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not update the frames per second", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -606,7 +606,7 @@ bool ApplicationClass::Frame(InputClass* Input)
result = RenderSceneToTexture(rotation);
if (!result)
{
logger.Log("Could not render the scene to the render texture", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the scene to the render texture", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -614,7 +614,7 @@ bool ApplicationClass::Frame(InputClass* Input)
result = UpdateMouseStrings(mouseX, mouseY, leftMouseDown);
if (!result)
{
logger.Log("Could not update the mouse strings", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not update the mouse strings", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -752,7 +752,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
diffuseColor, lightPosition);
if (!result)
{
logger.Log("Could not render the cube model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the cube model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
}
@ -777,7 +777,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
if (!result)
{
logger.Log("Could not render the object model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the object model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
}
@ -800,7 +800,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
if (!result)
{
logger.Log("Could not render the terrain model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the terrain model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
}
@ -815,7 +815,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_RenderTexture->GetShaderResourceView());
if (!result)
{
logger.Log("Could not render the display plane using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the display plane using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -829,7 +829,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_RenderTexture->GetShaderResourceView());
if (!result)
{
logger.Log("Could not render the display plane using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the display plane using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -843,7 +843,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_RenderTexture->GetShaderResourceView());
if (!result)
{
logger.Log("Could not render the display plane using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the display plane using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -881,7 +881,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
diffuseColor, lightPosition);
if (!result)
{
logger.Log("Could not render the model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the model using the light shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -894,7 +894,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
result = UpdateRenderCountString(renderCount);
if (!result)
{
logger.Log("Could not update the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not update the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -912,7 +912,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Font->GetTexture(), m_RenderCountString->GetPixelColor());
if (!result)
{
logger.Log("Could not render the render count text string using the font shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the render count text string using the font shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -923,7 +923,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Font->GetTexture(), m_FpsString->GetPixelColor());
if (!result)
{
logger.Log("Could not render the fps text string using the font shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the fps text string using the font shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -936,7 +936,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Font->GetTexture(), m_MouseStrings[i].GetPixelColor());
if (!result)
{
logger.Log("Could not render the mouse text strings using the font shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the mouse text strings using the font shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
}
@ -953,7 +953,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Sprite->GetTexture());
if (!result)
{
logger.Log("Could not render the sprite using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the sprite using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1007,7 +1007,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Model->GetTexture(0), m_Model->GetTexture(5), m_Model->GetTexture(3));
if (!result)
{
logger.Log("Could not render the model using the alpha map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the model using the alpha map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1023,7 +1023,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Model->GetTexture(0));
if (!result)
{
logger.Log("Could not render the model using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the model using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1039,7 +1039,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Model->GetTexture(0), m_Model->GetTexture(1), m_Lights[0]->GetDirection(), m_Lights[0]->GetDiffuseColor());
if (!result)
{
logger.Log("Could not render the model using the normal map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the model using the normal map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1056,7 +1056,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Model->GetTexture(0), m_Model->GetTexture(5));
if (!result)
{
logger.Log("Could not render the model using the multitexture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the model using the multitexture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1073,7 +1073,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Model->GetTexture(0), textureTranslation);
if (!result)
{
logger.Log("Could not render the model using the translate shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the model using the translate shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1090,7 +1090,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
m_Camera->GetPosition(), m_Lights[0]->GetSpecularColor(), m_Lights[0]->GetSpecularPower());
if (!result)
{
logger.Log("Could not render the model using the specular map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the model using the specular map shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1105,7 +1105,7 @@ bool ApplicationClass::Render(float rotation, float x, float y, float z, float t
result = m_ShaderManager->RenderTransparentShader(m_Direct3D->GetDeviceContext(), m_Model->GetIndexCount(), worldMatrix, viewMatrix, projectionMatrix, m_Model->GetTexture(0), blendAmount);
if (!result)
{
logger.Log("Could not render the model using the transparent shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not render the model using the transparent shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1165,7 +1165,7 @@ int ApplicationClass::GetScreenHeight() const
void ApplicationClass::GenerateTerrain()
{
logger.Log("Generating terrain", __FILE__, __LINE__);
Logger::Get().Log("Generating terrain", __FILE__, __LINE__);
char modelFilename[128];
std::vector<string> Filename;
@ -1211,7 +1211,7 @@ void ApplicationClass::GenerateTerrain()
void ApplicationClass::AddKobject(WCHAR* filepath)
{
logger.Log("Adding object", __FILE__, __LINE__);
Logger::Get().Log("Adding object", __FILE__, __LINE__);
char modelFilename[128];
vector<string> Filename;
@ -1243,7 +1243,7 @@ void ApplicationClass::AddKobject(WCHAR* filepath)
void ApplicationClass::AddCube()
{
logger.Log("Adding cube", __FILE__, __LINE__);
Logger::Get().Log("Adding cube", __FILE__, __LINE__);
char modelFilename[128];
vector<string> Filename;
@ -1271,7 +1271,7 @@ void ApplicationClass::AddCube()
void ApplicationClass::DeleteKobject(int index)
{
logger.Log("Deleting object", __FILE__, __LINE__);
Logger::Get().Log("Deleting object", __FILE__, __LINE__);
if (index < m_object.size())
{
@ -1283,7 +1283,7 @@ void ApplicationClass::DeleteKobject(int index)
void ApplicationClass::DeleteTerrain()
{
logger.Log("Deleting terrain", __FILE__, __LINE__);
Logger::Get().Log("Deleting terrain", __FILE__, __LINE__);
for (auto cube : m_terrainChunk)
{
@ -1310,7 +1310,7 @@ bool ApplicationClass::UpdateMouseStrings(int mouseX, int mouseY, bool mouseDown
result = m_MouseStrings[0].UpdateText(m_Direct3D->GetDeviceContext(), m_Font, finalString, 10, 50, 1.0f, 1.0f, 1.0f);
if (!result)
{
logger.Log("Could not update the mouse X string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not update the mouse X string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1325,7 +1325,7 @@ bool ApplicationClass::UpdateMouseStrings(int mouseX, int mouseY, bool mouseDown
result = m_MouseStrings[1].UpdateText(m_Direct3D->GetDeviceContext(), m_Font, finalString, 10, 75, 1.0f, 1.0f, 1.0f);
if (!result)
{
logger.Log("Could not update the mouse Y string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not update the mouse Y string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1344,7 +1344,7 @@ bool ApplicationClass::UpdateMouseStrings(int mouseX, int mouseY, bool mouseDown
if (!result)
{
logger.Log("Could not update the mouse button string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not update the mouse button string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1415,7 +1415,7 @@ bool ApplicationClass::UpdateFps()
result = m_FpsString->UpdateText(m_Direct3D->GetDeviceContext(), m_Font, finalString, 10, 10, red, green, blue);
if (!result)
{
logger.Log("Could not update the fps string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not update the fps string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1439,7 +1439,7 @@ bool ApplicationClass::UpdateRenderCountString(int renderCount)
result = m_RenderCountString->UpdateText(m_Direct3D->GetDeviceContext(), m_Font, finalString, 10, 30, 1.0f, 1.0f, 1.0f);
if (!result)
{
logger.Log("Could not update the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not update the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -1484,7 +1484,7 @@ void ApplicationClass::SetLightPosition(int index, XMVECTOR position)
void ApplicationClass::DeleteLight(int index)
{
logger.Log("Deleting light", __FILE__, __LINE__);
Logger::Get().Log("Deleting light", __FILE__, __LINE__);
if (index < 0 || index >= m_Lights.size())
{

5
enginecustom/applicationclass.h
View File

@ -155,11 +155,6 @@ private :
TextClass* m_FpsString;
int m_previousFps;
// ------------------------------------------------- //
// ------------------- LOGGER ---------------------- //
// ------------------------------------------------- //
Logger logger;
// ------------------------------------------------- //
// ------------------- OTHER ----------------------- //
// ------------------------------------------------- //

22
enginecustom/bitmapclass.cpp
View File

@ -20,7 +20,7 @@ BitmapClass::~BitmapClass()
bool BitmapClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, int screenWidth, int screenHeight, char* textureFilename, int renderX, int renderY)
{
logger.Log("Initializing bitmap class", __FILE__, __LINE__);
Logger::Get().Log("Initializing bitmap class", __FILE__, __LINE__);
bool result;
@ -36,7 +36,7 @@ bool BitmapClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceCo
result = InitializeBuffers(device);
if (!result)
{
logger.Log("Failed to initialize buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -44,11 +44,11 @@ bool BitmapClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceCo
result = LoadTexture(device, deviceContext, textureFilename);
if (!result)
{
logger.Log("Failed to load texture", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to load texture", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Bitmap class initialized", __FILE__, __LINE__);
Logger::Get().Log("Bitmap class initialized", __FILE__, __LINE__);
return true;
}
@ -73,7 +73,7 @@ bool BitmapClass::Render(ID3D11DeviceContext* deviceContext)
result = UpdateBuffers(deviceContext);
if (!result)
{
logger.Log("Failed to update buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to update buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -95,7 +95,7 @@ ID3D11ShaderResourceView* BitmapClass::GetTexture()
bool BitmapClass::InitializeBuffers(ID3D11Device* device)
{
logger.Log("Initializing buffers", __FILE__, __LINE__);
Logger::Get().Log("Initializing buffers", __FILE__, __LINE__);
VertexType* vertices;
unsigned long* indices;
@ -146,7 +146,7 @@ bool BitmapClass::InitializeBuffers(ID3D11Device* device)
result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
if (FAILED(result))
{
logger.Log("Failed to create vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -167,7 +167,7 @@ bool BitmapClass::InitializeBuffers(ID3D11Device* device)
result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
if (FAILED(result))
{
logger.Log("Failed to create index buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create index buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -178,7 +178,7 @@ bool BitmapClass::InitializeBuffers(ID3D11Device* device)
delete[] indices;
indices = 0;
logger.Log("Buffers initialized", __FILE__, __LINE__);
Logger::Get().Log("Buffers initialized", __FILE__, __LINE__);
return true;
}
@ -260,7 +260,7 @@ bool BitmapClass::UpdateBuffers(ID3D11DeviceContext* deviceContent)
result = deviceContent->Map(m_vertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -316,7 +316,7 @@ bool BitmapClass::LoadTexture(ID3D11Device* device, ID3D11DeviceContext* deviceC
result = m_Texture->Initialize(device, deviceContext, filename);
if (!result)
{
logger.Log("Failed to initialize texture object", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize texture object", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/bitmapclass.h
View File

@ -54,7 +54,6 @@ private:
int m_vertexCount, m_indexCount, m_screenWidth, m_screenHeight, m_bitmapWidth, m_bitmapHeight, m_renderX, m_renderY, m_prevPosX, m_prevPosY;
TextureClass* m_Texture;
Logger logger;
};
#endif

62
enginecustom/d3dclass.cpp
View File

@ -32,7 +32,7 @@ D3DClass::~D3DClass()
bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear)
{
logger.Log("Initializing D3Dclass", __FILE__, __LINE__);
Logger::Get().Log("Initializing D3Dclass", __FILE__, __LINE__);
HRESULT result;
IDXGIFactory* factory;
@ -61,7 +61,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
logger.Log("Failed to create DXGIFactory", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create DXGIFactory", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -69,7 +69,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
logger.Log("Failed to create adapter", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create adapter", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -77,7 +77,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
logger.Log("Failed to create adapter output", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create adapter output", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -85,7 +85,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
logger.Log("Failed to get display mode list", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to get display mode list", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -93,7 +93,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
{
logger.Log("Failed to create display mode list", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create display mode list", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -101,7 +101,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
logger.Log("Failed to fill display mode list", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to fill display mode list", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -123,7 +123,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
logger.Log("Failed to get adapter description", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to get adapter description", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -134,7 +134,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
error = wcstombs_s(&stringLength, m_videoCardDescription, 128, adapterDesc.Description, 128);
if (error != 0)
{
logger.Log("Failed to convert video card name to character array", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to convert video card name to character array", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -217,7 +217,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
D3D11_SDK_VERSION, &swapChainDesc, &m_swapChain, &m_device, NULL, &m_deviceContext);
if (FAILED(result))
{
logger.Log("Failed to create swap chain, device and device context", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create swap chain, device and device context", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -225,7 +225,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
{
logger.Log("Failed to get pointer to back buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to get pointer to back buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -233,7 +233,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = m_device->CreateRenderTargetView(backBufferPtr, NULL, &m_renderTargetView);
if (FAILED(result))
{
logger.Log("Failed to create render target view", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create render target view", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -261,7 +261,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result))
{
logger.Log("Failed to create texture for depth buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create texture for depth buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -293,7 +293,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = m_device->CreateDepthStencilState(&depthStencilDesc, &m_depthStencilState);
if (FAILED(result))
{
logger.Log("Failed to create depth stencil state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create depth stencil state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -312,7 +312,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(result))
{
logger.Log("Failed to create depth stencil view", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create depth stencil view", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -335,7 +335,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = m_device->CreateRasterizerState(&rasterDesc, &m_rasterState);
if (FAILED(result))
{
logger.Log("Failed to create rasterizer state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create rasterizer state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -390,7 +390,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = m_device->CreateDepthStencilState(&depthDisabledStencilDesc, &m_depthDisabledStencilState);
if (FAILED(result))
{
logger.Log("Failed to create depth disabled stencil state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create depth disabled stencil state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -411,7 +411,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = m_device->CreateBlendState(&blendStateDescription, &m_alphaEnableBlendingState);
if (FAILED(result))
{
logger.Log("Failed to create alpha enabled blend state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create alpha enabled blend state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -422,7 +422,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
result = m_device->CreateBlendState(&blendStateDescription, &m_alphaDisableBlendingState);
if (FAILED(result))
{
logger.Log("Failed to create alpha disabled blend state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create alpha disabled blend state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -433,7 +433,7 @@ bool D3DClass::Initialize(int screenWidth, int screenHeight, bool vsync, HWND hw
void D3DClass::Shutdown()
{
logger.Log("Shutting down D3Dclass", __FILE__, __LINE__);
Logger::Get().Log("Shutting down D3Dclass", __FILE__, __LINE__);
// Before shutting down set to windowed mode or when you release the swap chain it will throw an exception.
if (m_swapChain)
@ -507,7 +507,7 @@ void D3DClass::Shutdown()
m_swapChain = 0;
}
logger.Log("D3Dclass shutdown", __FILE__, __LINE__);
Logger::Get().Log("D3Dclass shutdown", __FILE__, __LINE__);
return;
}
@ -614,7 +614,7 @@ void D3DClass::ResetViewport()
void D3DClass::ReleaseResources()
{
logger.Log("Releasing D3D resources", __FILE__, __LINE__);
Logger::Get().Log("Releasing D3D resources", __FILE__, __LINE__);
// libere la vue
if (m_renderTargetView)
@ -637,13 +637,13 @@ void D3DClass::ReleaseResources()
m_depthStencilView = 0;
}
logger.Log("D3D resources released", __FILE__, __LINE__);
Logger::Get().Log("D3D resources released", __FILE__, __LINE__);
}
// Reset the resources for the swap chain
void D3DClass::ResetResources(int newWidth, int newHeight)
{
logger.Log("Resetting D3D resources", __FILE__, __LINE__);
Logger::Get().Log("Resetting D3D resources", __FILE__, __LINE__);
HRESULT result;
@ -651,21 +651,21 @@ void D3DClass::ResetResources(int newWidth, int newHeight)
result = m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBuffer);
if (FAILED(result))
{
logger.Log("Failed to get back buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to get back buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return;
}
result = m_device->CreateRenderTargetView(backBuffer, NULL, &m_renderTargetView);
if (FAILED(result))
{
logger.Log("Failed to create render target view", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create render target view", __FILE__, __LINE__, Logger::LogLevel::Error);
return;
}
result = backBuffer->Release();
if (FAILED(result))
{
logger.Log("Failed to release back buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to release back buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return;
}
@ -694,14 +694,14 @@ void D3DClass::ResetResources(int newWidth, int newHeight)
result = m_device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result))
{
logger.Log("Failed to create depth stencil buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create depth stencil buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return;
}
result = m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(result))
{
logger.Log("Failed to create depth stencil view", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create depth stencil view", __FILE__, __LINE__, Logger::LogLevel::Error);
return;
}
@ -717,7 +717,7 @@ IDXGISwapChain* D3DClass::GetSwapChain()
void D3DClass::ResizeSwapChain(int newWidth, int newHeight)
{
logger.Log("Resizing swap chain", __FILE__, __LINE__);
Logger::Get().Log("Resizing swap chain", __FILE__, __LINE__);
HRESULT result;
@ -729,7 +729,7 @@ void D3DClass::ResizeSwapChain(int newWidth, int newHeight)
result = m_swapChain->ResizeBuffers(0, newWidth, newHeight, DXGI_FORMAT_UNKNOWN, 0);
if (FAILED(result))
{
logger.Log("Failed to resize swap chain", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to resize swap chain", __FILE__, __LINE__, Logger::LogLevel::Error);
return;
}

3
enginecustom/d3dclass.h
View File

@ -83,9 +83,6 @@ private:
ID3D11DepthStencilState* m_depthDisabledStencilState;
ID3D11BlendState* m_alphaEnableBlendingState;
ID3D11BlendState* m_alphaDisableBlendingState;
// Logger
Logger logger;
};
#endif

12
enginecustom/displayplaneclass.cpp
View File

@ -19,7 +19,7 @@ DisplayPlaneClass::~DisplayPlaneClass()
bool DisplayPlaneClass::Initialize(ID3D11Device* device, float width, float height)
{
logger.Log("Initializing DisplayPlaneClass, width: " + std::to_string(width) + ", height: " + std::to_string(height), __FILE__, __LINE__);
Logger::Get().Log("Initializing DisplayPlaneClass, width: " + std::to_string(width) + ", height: " + std::to_string(height), __FILE__, __LINE__);
bool result;
@ -27,7 +27,7 @@ bool DisplayPlaneClass::Initialize(ID3D11Device* device, float width, float heig
result = InitializeBuffers(device, width, height);
if (!result)
{
logger.Log("Could not initialize buffers", __FILE__, __LINE__);
Logger::Get().Log("Could not initialize buffers", __FILE__, __LINE__);
return false;
}
@ -60,7 +60,7 @@ int DisplayPlaneClass::GetIndexCount()
bool DisplayPlaneClass::InitializeBuffers(ID3D11Device* device, float width, float height)
{
logger.Log("Initializing buffers", __FILE__, __LINE__);
Logger::Get().Log("Initializing buffers", __FILE__, __LINE__);
VertexType* vertices;
unsigned long* indices;
@ -126,7 +126,7 @@ bool DisplayPlaneClass::InitializeBuffers(ID3D11Device* device, float width, flo
result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
if (FAILED(result))
{
logger.Log("Could not create vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not create vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -147,7 +147,7 @@ bool DisplayPlaneClass::InitializeBuffers(ID3D11Device* device, float width, flo
result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
if (FAILED(result))
{
logger.Log("Could not create index buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Could not create index buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -158,7 +158,7 @@ bool DisplayPlaneClass::InitializeBuffers(ID3D11Device* device, float width, flo
delete[] indices;
indices = 0;
logger.Log("Buffers initialized", __FILE__, __LINE__);
Logger::Get().Log("Buffers initialized", __FILE__, __LINE__);
return true;
}

1
enginecustom/displayplaneclass.h
View File

@ -40,7 +40,6 @@ private:
ID3D11Buffer* m_vertexBuffer, * m_indexBuffer;
int m_vertexCount, m_indexCount;
Logger logger;
};
#endif

20
enginecustom/fontclass.cpp
View File

@ -18,7 +18,7 @@ FontClass::~FontClass()
bool FontClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, int fontChoice)
{
logger.Log("Initializing font class", __FILE__, __LINE__);
Logger::Get().Log("Initializing font class", __FILE__, __LINE__);
char fontFilename[128];
char fontTextureFilename[128];
@ -49,7 +49,7 @@ bool FontClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceCont
result = LoadFontData(fontFilename);
if (!result)
{
logger.Log("Failed to load font data", __FILE__, __LINE__);
Logger::Get().Log("Failed to load font data", __FILE__, __LINE__);
return false;
}
@ -57,11 +57,11 @@ bool FontClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceCont
result = LoadTexture(device, deviceContext, fontTextureFilename);
if (!result)
{
logger.Log("Failed to load font texture", __FILE__, __LINE__);
Logger::Get().Log("Failed to load font texture", __FILE__, __LINE__);
return false;
}
logger.Log("Font class initialized", __FILE__, __LINE__);
Logger::Get().Log("Font class initialized", __FILE__, __LINE__);
return true;
}
@ -79,7 +79,7 @@ void FontClass::Shutdown()
bool FontClass::LoadFontData(char* filename)
{
logger.Log(("Loading font data from %s", filename), __FILE__, __LINE__);
Logger::Get().Log(("Loading font data from %s", filename), __FILE__, __LINE__);
std::ifstream fin;
int i;
@ -92,7 +92,7 @@ bool FontClass::LoadFontData(char* filename)
fin.open(filename);
if (fin.fail())
{
logger.Log("Failed to open font file", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to open font file", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -118,7 +118,7 @@ bool FontClass::LoadFontData(char* filename)
// Close the file.
fin.close();
logger.Log("Font data loaded", __FILE__, __LINE__);
Logger::Get().Log("Font data loaded", __FILE__, __LINE__);
return true;
}
@ -137,7 +137,7 @@ void FontClass::ReleaseFontData()
bool FontClass::LoadTexture(ID3D11Device* device, ID3D11DeviceContext* deviceContext, char* filename)
{
logger.Log(("Loading font texture from %s", filename), __FILE__, __LINE__);
Logger::Get().Log(("Loading font texture from %s", filename), __FILE__, __LINE__);
bool result;
@ -148,11 +148,11 @@ bool FontClass::LoadTexture(ID3D11Device* device, ID3D11DeviceContext* deviceCon
result = m_Texture->Initialize(device, deviceContext, filename);
if (!result)
{
logger.Log("Failed to initialize font texture", __FILE__, __LINE__);
Logger::Get().Log("Failed to initialize font texture", __FILE__, __LINE__);
return false;
}
logger.Log("Font texture loaded", __FILE__, __LINE__);
Logger::Get().Log("Font texture loaded", __FILE__, __LINE__);
return true;
}

2
enginecustom/fontclass.h
View File

@ -59,8 +59,6 @@ private:
TextureClass* m_Texture;
float m_fontHeight;
int m_spaceSize;
Logger logger;
};
#endif

40
enginecustom/fontshaderclass.cpp
View File

@ -24,7 +24,7 @@ FontShaderClass::~FontShaderClass()
bool FontShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing FontShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing FontShaderClass", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -35,7 +35,7 @@ bool FontShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"font.vs");
if (error != 0)
{
logger.Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -43,7 +43,7 @@ bool FontShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"font.ps");
if (error != 0)
{
logger.Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -51,11 +51,11 @@ bool FontShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("FontShaderClass initialized", __FILE__, __LINE__);
Logger::Get().Log("FontShaderClass initialized", __FILE__, __LINE__);
return true;
}
@ -78,7 +78,7 @@ bool FontShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount,
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, pixelColor);
if (!result)
{
logger.Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -90,7 +90,7 @@ bool FontShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount,
bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
logger.Log("Initializing shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing shader", __FILE__, __LINE__);
HRESULT result;
ID3D10Blob* errorMessage;
@ -121,7 +121,7 @@ bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* v
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -140,7 +140,7 @@ bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* v
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -150,7 +150,7 @@ bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -158,7 +158,7 @@ bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -187,7 +187,7 @@ bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* v
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -210,7 +210,7 @@ bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -233,7 +233,7 @@ bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -249,18 +249,18 @@ bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreateBuffer(&pixelBufferDesc, NULL, &m_pixelBuffer);
if (FAILED(result))
{
logger.Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Shader initialized", __FILE__, __LINE__);
return true;
}
void FontShaderClass::ShutdownShader()
{
logger.Log("Shutting down shader", __FILE__, __LINE__);
Logger::Get().Log("Shutting down shader", __FILE__, __LINE__);
// Release the pixel constant buffer.
if (m_pixelBuffer)
@ -304,7 +304,7 @@ void FontShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("Shader shut down", __FILE__, __LINE__);
Logger::Get().Log("Shader shut down", __FILE__, __LINE__);
return;
}
@ -364,7 +364,7 @@ bool FontShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XM
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -392,7 +392,7 @@ bool FontShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, XM
result = deviceContext->Map(m_pixelBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/fontshaderclass.h
View File

@ -57,7 +57,6 @@ private:
ID3D11SamplerState* m_sampleState;
ID3D11Buffer* m_pixelBuffer;
Logger logger;
};
#endif

4
enginecustom/imguiManager.cpp
View File

@ -13,7 +13,7 @@ imguiManager::~imguiManager()
bool imguiManager::Initialize(HWND hwnd, ID3D11Device* device, ID3D11DeviceContext* deviceContext)
{
logger.Log("Initializing imgui", __FILE__, __LINE__);
Logger::Get().Log("Initializing imgui", __FILE__, __LINE__);
IMGUI_CHECKVERSION();
ImGui::CreateContext();
@ -23,7 +23,7 @@ bool imguiManager::Initialize(HWND hwnd, ID3D11Device* device, ID3D11DeviceConte
ImGui_ImplDX11_Init(device, deviceContext);
ImGui::StyleColorsDark();
logger.Log("imgui initialized", __FILE__, __LINE__);
Logger::Get().Log("imgui initialized", __FILE__, __LINE__);
return true;
}

1
enginecustom/imguiManager.h
View File

@ -42,7 +42,6 @@ private :
private:
ImGuiIO* io;
Logger logger;
};
#endif

34
enginecustom/inputclass.cpp
View File

@ -20,7 +20,7 @@ InputClass::~InputClass()
bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int screenHeight)
{
logger.Log("Initializing input class", __FILE__, __LINE__);
Logger::Get().Log("Initializing input class", __FILE__, __LINE__);
HRESULT result;
int i;
@ -44,7 +44,7 @@ bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int
result = DirectInput8Create(hinstance, DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&m_directInput, NULL);
if (FAILED(result))
{
logger.Log("Failed to create direct input interface", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create direct input interface", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -52,7 +52,7 @@ bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int
result = m_directInput->CreateDevice(GUID_SysKeyboard, &m_keyboard, NULL);
if (FAILED(result))
{
logger.Log("Failed to create direct input interface for the keyboard", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create direct input interface for the keyboard", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -60,7 +60,7 @@ bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int
result = m_keyboard->SetDataFormat(&c_dfDIKeyboard);
if (FAILED(result))
{
logger.Log("Failed to set data format for the keyboard", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set data format for the keyboard", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -68,7 +68,7 @@ bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int
result = m_keyboard->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE);
if (FAILED(result))
{
logger.Log("Failed to set cooperative level of the keyboard", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set cooperative level of the keyboard", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -76,7 +76,7 @@ bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int
result = m_keyboard->Acquire();
if (FAILED(result))
{
logger.Log("Failed to acquire the keyboard", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to acquire the keyboard", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -84,7 +84,7 @@ bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int
result = m_directInput->CreateDevice(GUID_SysMouse, &m_mouse, NULL);
if (FAILED(result))
{
logger.Log("Failed to create direct input interface for the mouse", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create direct input interface for the mouse", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -92,7 +92,7 @@ bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int
result = m_mouse->SetDataFormat(&c_dfDIMouse);
if (FAILED(result))
{
logger.Log("Failed to set data format for the mouse", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set data format for the mouse", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -100,7 +100,7 @@ bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int
result = m_mouse->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);
if (FAILED(result))
{
logger.Log("Failed to set cooperative level of the mouse", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set cooperative level of the mouse", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -108,11 +108,11 @@ bool InputClass::Initialize(HINSTANCE hinstance, HWND hwnd, int screenWidth, int
result = m_mouse->Acquire();
if (FAILED(result))
{
logger.Log("Failed to acquire the mouse", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to acquire the mouse", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Input class initialized", __FILE__, __LINE__);
Logger::Get().Log("Input class initialized", __FILE__, __LINE__);
return true;
}
@ -144,7 +144,7 @@ bool InputClass::IsKeyDown(unsigned int key)
void InputClass::Shutdown()
{
logger.Log("Shutting down input class", __FILE__, __LINE__);
Logger::Get().Log("Shutting down input class", __FILE__, __LINE__);
// Release the mouse.
if (m_mouse)
@ -169,7 +169,7 @@ void InputClass::Shutdown()
m_directInput = 0;
}
logger.Log("Input class shut down", __FILE__, __LINE__);
Logger::Get().Log("Input class shut down", __FILE__, __LINE__);
return;
}
@ -183,7 +183,7 @@ bool InputClass::Frame()
result = ReadKeyboard();
if (!result)
{
logger.Log("Failed to read keyboard state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to read keyboard state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -191,7 +191,7 @@ bool InputClass::Frame()
result = ReadMouse();
if (!result)
{
logger.Log("Failed to read mouse state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to read mouse state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -217,7 +217,7 @@ bool InputClass::ReadKeyboard()
}
else
{
logger.Log("Failed to get keyboard device state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to get keyboard device state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
}
@ -241,7 +241,7 @@ bool InputClass::ReadMouse()
}
else
{
logger.Log("Failed to get mouse device state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to get mouse device state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
}

1
enginecustom/inputclass.h
View File

@ -66,7 +66,6 @@ private:
int m_screenWidth, m_screenHeight, m_mouseX, m_mouseY;
Logger logger;
};
#endif

34
enginecustom/lightmapshaderclass.cpp
View File

@ -23,7 +23,7 @@ LightMapShaderClass::~LightMapShaderClass()
bool LightMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing LightMapShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing LightMapShaderClass", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -34,7 +34,7 @@ bool LightMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"lightmap.vs");
if (error != 0)
{
logger.Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -42,7 +42,7 @@ bool LightMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"lightmap.ps");
if (error != 0)
{
logger.Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -50,11 +50,11 @@ bool LightMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("LightMapShaderClass initialized", __FILE__, __LINE__);
Logger::Get().Log("LightMapShaderClass initialized", __FILE__, __LINE__);
return true;
}
@ -79,7 +79,7 @@ bool LightMapShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCo
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2);
if (!result)
{
logger.Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -120,7 +120,7 @@ bool LightMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -139,7 +139,7 @@ bool LightMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -149,7 +149,7 @@ bool LightMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -157,7 +157,7 @@ bool LightMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -194,7 +194,7 @@ bool LightMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -217,7 +217,7 @@ bool LightMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -240,11 +240,11 @@ bool LightMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Shader initialized", __FILE__, __LINE__);
return true;
}
@ -252,7 +252,7 @@ bool LightMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
void LightMapShaderClass::ShutdownShader()
{
logger.Log("Shutting down LightMapShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Shutting down LightMapShaderClass", __FILE__, __LINE__);
// Release the sampler state.
if (m_sampleState)
@ -289,7 +289,7 @@ void LightMapShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("LightMapShaderClass shut down", __FILE__, __LINE__);
Logger::Get().Log("LightMapShaderClass shut down", __FILE__, __LINE__);
return;
}
@ -349,7 +349,7 @@ bool LightMapShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/lightmapshaderclass.h
View File

@ -52,7 +52,6 @@ private:
ID3D11Buffer* m_matrixBuffer;
ID3D11SamplerState* m_sampleState;
Logger logger;
};
#endif

46
enginecustom/lightshaderclass.cpp
View File

@ -30,7 +30,7 @@ LightShaderClass::~LightShaderClass()
bool LightShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing LightShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing LightShaderClass", __FILE__, __LINE__);
wchar_t vsFilename[128];
wchar_t psFilename[128];
@ -41,7 +41,7 @@ bool LightShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"light.vs");
if (error != 0)
{
logger.Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -49,18 +49,18 @@ bool LightShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"light.ps");
if (error != 0)
{
logger.Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Initialize the vertex and pixel shaders.
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("LightShaderClass initialized", __FILE__, __LINE__);
Logger::Get().Log("LightShaderClass initialized", __FILE__, __LINE__);
return true;
}
@ -84,7 +84,7 @@ bool LightShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCount
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, lightPosition);
if(!result)
{
logger.Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -127,7 +127,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -145,7 +145,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -155,7 +155,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -163,7 +163,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -201,7 +201,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
&m_layout);
if (FAILED(result))
{
logger.Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -231,7 +231,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -247,7 +247,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -265,7 +265,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateBuffer(&cameraBufferDesc, NULL, &m_cameraBuffer);
if (FAILED(result))
{
logger.Log("Failed to create camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -281,7 +281,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateBuffer(&lightColorBufferDesc, NULL, &m_lightColorBuffer);
if (FAILED(result))
{
logger.Log("Failed to create light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -297,11 +297,11 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
result = device->CreateBuffer(&lightPositionBufferDesc, NULL, &m_lightPositionBuffer);
if (FAILED(result))
{
logger.Log("Failed to create light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Shader initialized", __FILE__, __LINE__);
return true;
}
@ -309,7 +309,7 @@ bool LightShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR*
void LightShaderClass::ShutdownShader()
{
logger.Log("Shutting down LightShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Shutting down LightShaderClass", __FILE__, __LINE__);
// Release the light constant buffers.
if (m_lightColorBuffer)
@ -373,7 +373,7 @@ void LightShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("LightShaderClass shut down", __FILE__, __LINE__);
Logger::Get().Log("LightShaderClass shut down", __FILE__, __LINE__);
return;
}
@ -434,7 +434,7 @@ bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, X
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -459,7 +459,7 @@ bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, X
result = deviceContext->Map(m_cameraBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -467,7 +467,7 @@ bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, X
result = deviceContext->Map(m_lightPositionBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -496,7 +496,7 @@ bool LightShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, X
result = deviceContext->Map(m_lightColorBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/lightshaderclass.h
View File

@ -89,7 +89,6 @@ private:
ID3D11Buffer* m_lightColorBuffer;
ID3D11Buffer* m_lightPositionBuffer;
Logger logger;
};
#endif

46
enginecustom/modelclass.cpp
View File

@ -21,7 +21,7 @@ ModelClass::~ModelClass()
bool ModelClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, char* modelFilename, vector<string> filename)
{
logger.Log("Initializing model class", __FILE__, __LINE__);
Logger::Get().Log("Initializing model class", __FILE__, __LINE__);
bool result;
@ -29,7 +29,7 @@ bool ModelClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceCon
result = LoadModel(modelFilename);
if (!result)
{
logger.Log("Failed to load model data", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to load model data", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -40,18 +40,18 @@ bool ModelClass::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceCon
result = InitializeBuffers(device);
if (!result)
{
logger.Log("Failed to initialize buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Load the textures for this model.
result = LoadTextures(device, deviceContext, filename);
if (!result)
{
logger.Log("Failed to load textures", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to load textures", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Model class initialized", __FILE__, __LINE__);
Logger::Get().Log("Model class initialized", __FILE__, __LINE__);
return true;
}
@ -94,7 +94,7 @@ ID3D11ShaderResourceView* ModelClass::GetTexture(int index)
bool ModelClass::InitializeBuffers(ID3D11Device* device)
{
logger.Log("Initializing buffers", __FILE__, __LINE__);
Logger::Get().Log("Initializing buffers", __FILE__, __LINE__);
VertexType* vertices;
unsigned long* indices;
@ -138,7 +138,7 @@ bool ModelClass::InitializeBuffers(ID3D11Device* device)
result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
if (FAILED(result))
{
logger.Log("Failed to create vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -159,7 +159,7 @@ bool ModelClass::InitializeBuffers(ID3D11Device* device)
result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
if (FAILED(result))
{
logger.Log("Failed to create index buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create index buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -170,7 +170,7 @@ bool ModelClass::InitializeBuffers(ID3D11Device* device)
delete[] indices;
indices = 0;
logger.Log("Buffers initialized", __FILE__, __LINE__);
Logger::Get().Log("Buffers initialized", __FILE__, __LINE__);
return true;
}
@ -221,7 +221,7 @@ void ModelClass::RenderBuffers(ID3D11DeviceContext* deviceContext)
bool ModelClass::LoadTextures(ID3D11Device* device, ID3D11DeviceContext* deviceContext, vector<string> textureFile)
{
logger.Log("Loading textures", __FILE__, __LINE__);
Logger::Get().Log("Loading textures", __FILE__, __LINE__);
bool result;
@ -233,19 +233,19 @@ bool ModelClass::LoadTextures(ID3D11Device* device, ID3D11DeviceContext* deviceC
result = m_Textures[i].Initialize(device, deviceContext, textureFile[i]);
if (!result)
{
logger.Log("Failed to initialize texture", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize texture", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
}
logger.Log("Textures loaded", __FILE__, __LINE__);
Logger::Get().Log("Textures loaded", __FILE__, __LINE__);
return true;
}
void ModelClass::ReleaseTextures()
{
logger.Log("Releasing textures", __FILE__, __LINE__);
Logger::Get().Log("Releasing textures", __FILE__, __LINE__);
// Release the texture object array.
if (m_Textures)
@ -261,14 +261,14 @@ void ModelClass::ReleaseTextures()
m_Textures = 0;
}
logger.Log("Textures released", __FILE__, __LINE__);
Logger::Get().Log("Textures released", __FILE__, __LINE__);
return;
}
bool ModelClass::LoadModel(char* filename)
{
logger.Log("Loading model", __FILE__, __LINE__);
Logger::Get().Log("Loading model", __FILE__, __LINE__);
ifstream fin;
char input;
@ -281,7 +281,7 @@ bool ModelClass::LoadModel(char* filename)
// If it could not open the file then exit.
if (fin.fail())
{
logger.Log("Failed to open model file", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to open model file", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -321,14 +321,14 @@ bool ModelClass::LoadModel(char* filename)
// Close the model file.
fin.close();
logger.Log("Model loaded", __FILE__, __LINE__);
Logger::Get().Log("Model loaded", __FILE__, __LINE__);
return true;
}
void ModelClass::CalculateModelVectors()
{
logger.Log("Calculating model vectors", __FILE__, __LINE__);
Logger::Get().Log("Calculating model vectors", __FILE__, __LINE__);
int faceCount, i, index;
TempVertexType vertex1, vertex2, vertex3;
@ -392,14 +392,14 @@ void ModelClass::CalculateModelVectors()
m_model[index - 3].bz = binormal.z;
}
logger.Log("Model vectors calculated", __FILE__, __LINE__);
Logger::Get().Log("Model vectors calculated", __FILE__, __LINE__);
return;
}
void ModelClass::CalculateTangentBinormal(TempVertexType vertex1, TempVertexType vertex2, TempVertexType vertex3, VectorType& tangent, VectorType& binormal)
{
logger.Log("Calculating tangent and binormal", __FILE__, __LINE__);
Logger::Get().Log("Calculating tangent and binormal", __FILE__, __LINE__);
float vector1[3], vector2[3];
float tuVector[2], tvVector[2];
@ -451,14 +451,14 @@ void ModelClass::CalculateTangentBinormal(TempVertexType vertex1, TempVertexType
binormal.y = binormal.y / length;
binormal.z = binormal.z / length;
logger.Log("Tangent and binormal calculated", __FILE__, __LINE__);
Logger::Get().Log("Tangent and binormal calculated", __FILE__, __LINE__);
return;
}
void ModelClass::ReleaseModel()
{
logger.Log("Releasing model", __FILE__, __LINE__);
Logger::Get().Log("Releasing model", __FILE__, __LINE__);
if (m_model)
{
@ -466,7 +466,7 @@ void ModelClass::ReleaseModel()
m_model = 0;
}
logger.Log("Model released", __FILE__, __LINE__);
Logger::Get().Log("Model released", __FILE__, __LINE__);
return;
}

2
enginecustom/modelclass.h
View File

@ -107,8 +107,6 @@ private:
int m_vertexCount, m_indexCount;
TextureClass* m_Textures;
ModelType* m_model;
Logger logger;
};
#endif

38
enginecustom/normalmapshaderclass.cpp
View File

@ -24,7 +24,7 @@ NormalMapShaderClass::~NormalMapShaderClass()
bool NormalMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing normal map shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing normal map shader", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -35,7 +35,7 @@ bool NormalMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"normalmap.vs");
if (error != 0)
{
logger.Log("Failed to set the filename of the vertex shader", __FILE__, __LINE__);
Logger::Get().Log("Failed to set the filename of the vertex shader", __FILE__, __LINE__);
return false;
}
@ -43,7 +43,7 @@ bool NormalMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"normalmap.ps");
if (error != 0)
{
logger.Log("Failed to set the filename of the pixel shader", __FILE__, __LINE__);
Logger::Get().Log("Failed to set the filename of the pixel shader", __FILE__, __LINE__);
return false;
}
@ -51,7 +51,7 @@ bool NormalMapShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Failed to initialize the vertex and pixel shaders", __FILE__, __LINE__);
Logger::Get().Log("Failed to initialize the vertex and pixel shaders", __FILE__, __LINE__);
return false;
}
@ -77,7 +77,7 @@ bool NormalMapShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexC
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2, lightDirection, diffuseColor);
if (!result)
{
logger.Log("Failed to set the shader parameters that will be used for rendering", __FILE__, __LINE__);
Logger::Get().Log("Failed to set the shader parameters that will be used for rendering", __FILE__, __LINE__);
return false;
}
@ -90,7 +90,7 @@ bool NormalMapShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexC
bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
logger.Log("Initializing normal map shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing normal map shader", __FILE__, __LINE__);
HRESULT result;
ID3D10Blob* errorMessage;
@ -121,7 +121,7 @@ bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCH
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Failed to compile the vertex shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile the vertex shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -140,7 +140,7 @@ bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCH
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Failed to compile the pixel shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile the pixel shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -150,7 +150,7 @@ bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCH
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Failed to create the vertex shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the vertex shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -158,7 +158,7 @@ bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCH
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Failed to create the pixel shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the pixel shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -211,7 +211,7 @@ bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCH
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Failed to create the vertex input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the vertex input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -234,7 +234,7 @@ bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCH
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Failed to create the constant buffer pointer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the constant buffer pointer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -257,7 +257,7 @@ bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCH
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Failed to create the texture sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the texture sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -273,11 +273,11 @@ bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCH
result = device->CreateBuffer(&lightBufferDesc, NULL, &m_lightBuffer);
if (FAILED(result))
{
logger.Log("Failed to create the light constant buffer pointer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create the light constant buffer pointer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Successfully initialized normal map shader", __FILE__, __LINE__);
Logger::Get().Log("Successfully initialized normal map shader", __FILE__, __LINE__);
return true;
}
@ -285,7 +285,7 @@ bool NormalMapShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCH
void NormalMapShaderClass::ShutdownShader()
{
logger.Log("Shutting down normal map shader", __FILE__, __LINE__);
Logger::Get().Log("Shutting down normal map shader", __FILE__, __LINE__);
// Release the light constant buffer.
if (m_lightBuffer)
@ -329,7 +329,7 @@ void NormalMapShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("Successfully shut down normal map shader", __FILE__, __LINE__);
Logger::Get().Log("Successfully shut down normal map shader", __FILE__, __LINE__);
return;
}
@ -390,7 +390,7 @@ bool NormalMapShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to lock the constant buffer so it can be written to", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to lock the constant buffer so it can be written to", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -419,7 +419,7 @@ bool NormalMapShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to lock the light constant buffer so it can be written to", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to lock the light constant buffer so it can be written to", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/normalmapshaderclass.h
View File

@ -59,7 +59,6 @@ private:
ID3D11SamplerState* m_sampleState;
ID3D11Buffer* m_lightBuffer;
Logger logger;
};
#endif

38
enginecustom/reflectionshaderclass.cpp
View File

@ -21,7 +21,7 @@ ReflectionShaderClass::~ReflectionShaderClass()
bool ReflectionShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing reflection shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing reflection shader", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -32,7 +32,7 @@ bool ReflectionShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"../Engine/reflection.vs");
if (error != 0)
{
logger.Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -40,7 +40,7 @@ bool ReflectionShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"../Engine/reflection.ps");
if (error != 0)
{
logger.Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -48,7 +48,7 @@ bool ReflectionShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -73,7 +73,7 @@ bool ReflectionShaderClass::Render(ID3D11DeviceContext* deviceContext, int index
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, reflectionTexture, reflectionMatrix);
if (!result)
{
logger.Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -85,7 +85,7 @@ bool ReflectionShaderClass::Render(ID3D11DeviceContext* deviceContext, int index
bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
logger.Log("Initializing reflection shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing reflection shader", __FILE__, __LINE__);
HRESULT result;
ID3D10Blob* errorMessage;
@ -116,7 +116,7 @@ bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WC
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -134,7 +134,7 @@ bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WC
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -144,7 +144,7 @@ bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WC
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -152,7 +152,7 @@ bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WC
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -181,7 +181,7 @@ bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WC
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -204,7 +204,7 @@ bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WC
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create a texture sampler state description.
@ -226,7 +226,7 @@ bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WC
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Setup the description of the reflection dynamic constant buffer that is in the vertex shader.
@ -241,18 +241,18 @@ bool ReflectionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WC
result = device->CreateBuffer(&reflectionBufferDesc, NULL, &m_reflectionBuffer);
if (FAILED(result))
{
logger.Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Reflection shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Reflection shader initialized", __FILE__, __LINE__);
return true;
}
void ReflectionShaderClass::ShutdownShader()
{
logger.Log("Shutting down reflection shader", __FILE__, __LINE__);
Logger::Get().Log("Shutting down reflection shader", __FILE__, __LINE__);
// Release the reflection constant buffer.
if (m_reflectionBuffer)
@ -296,7 +296,7 @@ void ReflectionShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("Reflection shader shut down", __FILE__, __LINE__);
Logger::Get().Log("Reflection shader shut down", __FILE__, __LINE__);
return;
}
@ -359,7 +359,7 @@ bool ReflectionShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceConte
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -384,7 +384,7 @@ bool ReflectionShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceConte
result = deviceContext->Map(m_reflectionBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/reflectionshaderclass.h
View File

@ -60,7 +60,6 @@ private:
ID3D11SamplerState* m_sampleState;
ID3D11Buffer* m_reflectionBuffer;
Logger logger;
};
#endif

18
enginecustom/rendertextureclass.cpp
View File

@ -21,7 +21,7 @@ RenderTextureClass::~RenderTextureClass()
bool RenderTextureClass::Initialize(ID3D11Device * device, int textureWidth, int textureHeight, float screenDepth, float screenNear, int format)
{
logger.Log("Initializing RenderTextureClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing RenderTextureClass", __FILE__, __LINE__);
D3D11_TEXTURE2D_DESC textureDesc;
HRESULT result;
@ -70,7 +70,7 @@ bool RenderTextureClass::Initialize(ID3D11Device * device, int textureWidth, int
result = device->CreateTexture2D(&textureDesc, NULL, &m_renderTargetTexture);
if (FAILED(result))
{
logger.Log("Failed to create render target texture", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create render target texture", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -83,7 +83,7 @@ bool RenderTextureClass::Initialize(ID3D11Device * device, int textureWidth, int
result = device->CreateRenderTargetView(m_renderTargetTexture, &renderTargetViewDesc, &m_renderTargetView);
if (FAILED(result))
{
logger.Log("Failed to create render target view", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create render target view", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -97,7 +97,7 @@ bool RenderTextureClass::Initialize(ID3D11Device * device, int textureWidth, int
result = device->CreateShaderResourceView(m_renderTargetTexture, &shaderResourceViewDesc, &m_shaderResourceView);
if (FAILED(result))
{
logger.Log("Failed to create shader resource view", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create shader resource view", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -121,7 +121,7 @@ bool RenderTextureClass::Initialize(ID3D11Device * device, int textureWidth, int
result = device->CreateTexture2D(&depthBufferDesc, NULL, &m_depthStencilBuffer);
if (FAILED(result))
{
logger.Log("Failed to create depth buffer texture", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create depth buffer texture", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -137,7 +137,7 @@ bool RenderTextureClass::Initialize(ID3D11Device * device, int textureWidth, int
result = device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView);
if (FAILED(result))
{
logger.Log("Failed to create depth stencil view", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create depth stencil view", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -155,14 +155,14 @@ bool RenderTextureClass::Initialize(ID3D11Device * device, int textureWidth, int
// Create an orthographic projection matrix for 2D rendering.
m_orthoMatrix = XMMatrixOrthographicLH((float)textureWidth, (float)textureHeight, screenNear, screenDepth);
logger.Log("RenderTextureClass initialized", __FILE__, __LINE__);
Logger::Get().Log("RenderTextureClass initialized", __FILE__, __LINE__);
return true;
}
void RenderTextureClass::Shutdown()
{
logger.Log("Shutting down RenderTextureClass", __FILE__, __LINE__);
Logger::Get().Log("Shutting down RenderTextureClass", __FILE__, __LINE__);
if (m_depthStencilView)
{
@ -194,7 +194,7 @@ void RenderTextureClass::Shutdown()
m_renderTargetTexture = 0;
}
logger.Log("RenderTextureClass shut down", __FILE__, __LINE__);
Logger::Get().Log("RenderTextureClass shut down", __FILE__, __LINE__);
return;
}

1
enginecustom/rendertextureclass.h
View File

@ -48,7 +48,6 @@ private:
XMMATRIX m_projectionMatrix;
XMMATRIX m_orthoMatrix;
Logger logger;
};
#endif

36
enginecustom/shadermanagerclass.cpp
View File

@ -26,7 +26,7 @@ ShaderManagerClass::~ShaderManagerClass()
bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing ShaderManagerClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing ShaderManagerClass", __FILE__, __LINE__);
bool result;
@ -36,7 +36,7 @@ bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
result = m_TextureShader->Initialize(device, hwnd);
if (!result)
{
logger.Log("Error initializing TextureShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing TextureShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -46,7 +46,7 @@ bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
result = m_NormalMapShader->Initialize(device, hwnd);
if (!result)
{
logger.Log("Error initializing NormalMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing NormalMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -56,7 +56,7 @@ bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
result = m_MultitextureShader->Initialize(device, hwnd);
if (!result)
{
logger.Log("Error initializing MultiTextureShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing MultiTextureShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -66,7 +66,7 @@ bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
result = m_TranslateShader->Initialize(device, hwnd);
if (!result)
{
logger.Log("Error initializing TranslateShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing TranslateShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -76,7 +76,7 @@ bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
result = m_AlphaMapShader->Initialize(device, hwnd);
if (!result)
{
logger.Log("Error initializing AlphaMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing AlphaMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -86,7 +86,7 @@ bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
result = m_SpecMapShader->Initialize(device, hwnd);
if (!result)
{
logger.Log("Error initializing SpecMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing SpecMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -96,11 +96,11 @@ bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
result = m_TransparentShader->Initialize(device, hwnd);
if (!result)
{
logger.Log("Error initializing TransparentShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing TransparentShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("ShaderManagerClass initialized", __FILE__, __LINE__);
Logger::Get().Log("ShaderManagerClass initialized", __FILE__, __LINE__);
// Create and initialize the light shader object.
m_LightShader = new LightShaderClass;
@ -124,7 +124,7 @@ bool ShaderManagerClass::Initialize(ID3D11Device* device, HWND hwnd)
void ShaderManagerClass::Shutdown()
{
logger.Log("Shutting down ShaderManagerClass", __FILE__, __LINE__);
Logger::Get().Log("Shutting down ShaderManagerClass", __FILE__, __LINE__);
// Release the normal map shader object.
if (m_NormalMapShader)
@ -182,7 +182,7 @@ void ShaderManagerClass::Shutdown()
m_TransparentShader = 0;
}
logger.Log("ShaderManagerClass shut down", __FILE__, __LINE__);
Logger::Get().Log("ShaderManagerClass shut down", __FILE__, __LINE__);
// Release the light shader object.
if (m_LightShader)
{
@ -212,7 +212,7 @@ bool ShaderManagerClass::RenderTextureShader(ID3D11DeviceContext* deviceContext,
result = m_TextureShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture);
if (!result)
{
logger.Log("Error rendering TextureShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error rendering TextureShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -228,7 +228,7 @@ bool ShaderManagerClass::RenderNormalMapShader(ID3D11DeviceContext* deviceContex
result = m_NormalMapShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, colorTexture, normalTexture, lightDirection, diffuseColor);
if (!result)
{
logger.Log("Error rendering NormalMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error rendering NormalMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -244,7 +244,7 @@ bool ShaderManagerClass::RenderMultitextureShader(ID3D11DeviceContext* deviceCon
result = m_MultitextureShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2);
if (!result)
{
logger.Log("Error rendering MultiTextureShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error rendering MultiTextureShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -260,7 +260,7 @@ bool ShaderManagerClass::RenderTranslateShader(ID3D11DeviceContext* deviceContex
result = m_TranslateShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, valeur);
if (!result)
{
logger.Log("Error rendering TranslateShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error rendering TranslateShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -276,7 +276,7 @@ bool ShaderManagerClass::RenderAlphaMapShader(ID3D11DeviceContext* deviceContext
result = m_AlphaMapShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2, texture3);
if (!result)
{
logger.Log("Error rendering AlphaMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error rendering AlphaMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -294,7 +294,7 @@ bool ShaderManagerClass::RenderSpecMapShader(ID3D11DeviceContext* deviceContext,
diffuseColor, cameraPosition, specularColor, specularPower);
if (!result)
{
logger.Log("Error rendering SpecMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error rendering SpecMapShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -310,7 +310,7 @@ bool ShaderManagerClass::RenderTransparentShader(ID3D11DeviceContext* deviceCont
result = m_TransparentShader->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, blendAmount);
if (!result)
{
logger.Log("Error rendering TransparentShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error rendering TransparentShaderClass", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/shadermanagerclass.h
View File

@ -47,7 +47,6 @@ private:
SpecMapShaderClass* m_SpecMapShader;
TransparentShaderClass* m_TransparentShader;
Logger logger;
LightShaderClass* m_LightShader;
LightMapShaderClass* m_LightMapShader;
};

1
enginecustom/systemclass.h
View File

@ -33,7 +33,6 @@ private:
LPCWSTR m_applicationName;
HINSTANCE m_hinstance;
HWND m_hwnd;
Logger logger;
InputClass* m_Input;
ApplicationClass* m_Application;

22
enginecustom/textureclass.cpp
View File

@ -19,7 +19,7 @@ TextureClass::~TextureClass()
bool TextureClass::Initialize(ID3D11Device * device, ID3D11DeviceContext * deviceContext, std::string filename)
{
logger.Log(("Iinitializing texture: %s", filename), __FILE__, __LINE__);
Logger::Get().Log(("Iinitializing texture: %s", filename), __FILE__, __LINE__);
bool result;
D3D11_TEXTURE2D_DESC textureDesc;
@ -30,7 +30,7 @@ bool TextureClass::Initialize(ID3D11Device * device, ID3D11DeviceContext * devic
result = LoadTarga(filename);
if (!result)
{
logger.Log("Failed to load targa data", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to load targa data", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Setup the description of the texture.
@ -50,7 +50,7 @@ bool TextureClass::Initialize(ID3D11Device * device, ID3D11DeviceContext * devic
hResult = device->CreateTexture2D(&textureDesc, NULL, &m_texture);
if (FAILED(hResult))
{
logger.Log("Failed to create texture", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create texture", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -68,7 +68,7 @@ bool TextureClass::Initialize(ID3D11Device * device, ID3D11DeviceContext * devic
hResult = device->CreateShaderResourceView(m_texture, &srvDesc, &m_textureView);
if (FAILED(hResult))
{
logger.Log("Failed to create shader resource view", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create shader resource view", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -126,7 +126,7 @@ bool TextureClass::LoadTarga(std::string filename)
error = fopen_s(&filePtr, filename.c_str(), "rb");
if (error != 0)
{
logger.Log("Failed to open targa file", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to open targa file", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -134,7 +134,7 @@ bool TextureClass::LoadTarga(std::string filename)
count = (unsigned int)fread(&targaFileHeader, sizeof(TargaHeader), 1, filePtr);
if (count != 1)
{
logger.Log("Failed to read targa file header", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to read targa file header", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -146,7 +146,7 @@ bool TextureClass::LoadTarga(std::string filename)
// Check that it is 32 bit and not 24 bit.
if (bpp != 32 && bpp != 24)
{
logger.Log("Targa file is not 32 or 24 bit", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Targa file is not 32 or 24 bit", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -160,7 +160,7 @@ bool TextureClass::LoadTarga(std::string filename)
count = (unsigned int)fread(targaImage, 1, imageSize, filePtr);
if (count != imageSize)
{
logger.Log("Failed to read targa image data", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to read targa image data", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -168,7 +168,7 @@ bool TextureClass::LoadTarga(std::string filename)
error = fclose(filePtr);
if (error != 0)
{
logger.Log("Failed to close targa file", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to close targa file", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -198,7 +198,7 @@ bool TextureClass::LoadTarga(std::string filename)
}
else
{
logger.Log("Index out of bounds", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Index out of bounds", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -216,7 +216,7 @@ bool TextureClass::LoadTarga(std::string filename)
delete[] targaImage;
targaImage = 0;
logger.Log("Targa file loaded", __FILE__, __LINE__);
Logger::Get().Log("Targa file loaded", __FILE__, __LINE__);
return true;
}

1
enginecustom/textureclass.h
View File

@ -47,7 +47,6 @@ private:
ID3D11ShaderResourceView* m_textureView;
int m_width, m_height;
Logger logger;
};
#endif

36
enginecustom/textureshaderclass.cpp
View File

@ -23,7 +23,7 @@ TextureShaderClass::~TextureShaderClass()
bool TextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing texture shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing texture shader", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -33,7 +33,7 @@ bool TextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"texture.vs");
if (error != 0)
{
logger.Log("Error copying stirng", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying stirng", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -41,7 +41,7 @@ bool TextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"texture.ps");
if (error != 0)
{
logger.Log("Error copying stirng", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error copying stirng", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -49,11 +49,11 @@ bool TextureShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Texture shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Texture shader initialized", __FILE__, __LINE__);
return true;
}
@ -76,7 +76,7 @@ bool TextureShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCou
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture);
if (!result)
{
logger.Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -88,7 +88,7 @@ bool TextureShaderClass::Render(ID3D11DeviceContext* deviceContext, int indexCou
bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
logger.Log("Initializing shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing shader", __FILE__, __LINE__);
HRESULT result;
ID3D10Blob* errorMessage;
@ -117,7 +117,7 @@ bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -136,7 +136,7 @@ bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -146,7 +146,7 @@ bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -154,7 +154,7 @@ bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create the vertex input layout description.
@ -183,7 +183,7 @@ bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -206,7 +206,7 @@ bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create a texture sampler state description.
@ -228,18 +228,18 @@ bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Shader initialized", __FILE__, __LINE__);
return true;
}
void TextureShaderClass::ShutdownShader()
{
logger.Log("Shutting down shader", __FILE__, __LINE__);
Logger::Get().Log("Shutting down shader", __FILE__, __LINE__);
// Release the sampler state.
if (m_sampleState)
@ -276,7 +276,7 @@ void TextureShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("Shader shut down", __FILE__, __LINE__);
Logger::Get().Log("Shader shut down", __FILE__, __LINE__);
return;
}
@ -334,7 +334,7 @@ bool TextureShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext,
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/textureshaderclass.h
View File

@ -51,7 +51,6 @@ private:
ID3D11Buffer* m_matrixBuffer;
ID3D11SamplerState* m_sampleState;
Logger logger;
};
#endif

40
enginecustom/translateshaderclass.cpp
View File

@ -24,7 +24,7 @@ TranslateShaderClass::~TranslateShaderClass()
bool TranslateShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initilaizing TranslateShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Initilaizing TranslateShaderClass", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -35,7 +35,7 @@ bool TranslateShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"translate.vs");
if (error != 0)
{
logger.Log("Failed to copy vsFilename", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to copy vsFilename", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -43,7 +43,7 @@ bool TranslateShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"translate.ps");
if (error != 0)
{
logger.Log("Failed to copy psFilename", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to copy psFilename", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -51,11 +51,11 @@ bool TranslateShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("TranslateShaderClass initialized", __FILE__, __LINE__);
Logger::Get().Log("TranslateShaderClass initialized", __FILE__, __LINE__);
return true;
}
@ -79,7 +79,7 @@ bool TranslateShaderClass::Render(ID3D11DeviceContext * deviceContext, int index
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, translation);
if (!result)
{
logger.Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -92,7 +92,7 @@ bool TranslateShaderClass::Render(ID3D11DeviceContext * deviceContext, int index
bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WCHAR * vsFilename, WCHAR * psFilename)
{
logger.Log("Initializing translate shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing translate shader", __FILE__, __LINE__);
HRESULT result;
ID3D10Blob* errorMessage;
@ -123,7 +123,7 @@ bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WC
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -142,7 +142,7 @@ bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WC
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -152,7 +152,7 @@ bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WC
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -160,7 +160,7 @@ bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WC
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -189,7 +189,7 @@ bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WC
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -212,7 +212,7 @@ bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WC
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -235,7 +235,7 @@ bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WC
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -251,11 +251,11 @@ bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WC
result = device->CreateBuffer(&translateBufferDesc, NULL, &m_translateBuffer);
if (FAILED(result))
{
logger.Log("Failed to create translate buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create translate buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Translate shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Translate shader initialized", __FILE__, __LINE__);
return true;
}
@ -263,7 +263,7 @@ bool TranslateShaderClass::InitializeShader(ID3D11Device * device, HWND hwnd, WC
void TranslateShaderClass::ShutdownShader()
{
logger.Log("Shutting down translate shader", __FILE__, __LINE__);
Logger::Get().Log("Shutting down translate shader", __FILE__, __LINE__);
// Release the texture translation constant buffer.
if (m_translateBuffer)
@ -307,7 +307,7 @@ void TranslateShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("Translate shader shut down", __FILE__, __LINE__);
Logger::Get().Log("Translate shader shut down", __FILE__, __LINE__);
return;
}
@ -368,7 +368,7 @@ bool TranslateShaderClass::SetShaderParameters(ID3D11DeviceContext * deviceConte
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -396,7 +396,7 @@ bool TranslateShaderClass::SetShaderParameters(ID3D11DeviceContext * deviceConte
result = deviceContext->Map(m_translateBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map translate buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map translate buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/translateshaderclass.h
View File

@ -58,7 +58,6 @@ private:
ID3D11SamplerState* m_sampleState;
ID3D11Buffer* m_translateBuffer;
Logger logger;
};
#endif

40
enginecustom/transparentshaderclass.cpp
View File

@ -24,7 +24,7 @@ TransparentShaderClass::~TransparentShaderClass()
bool TransparentShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
{
logger.Log("Initializing TransparentShaderClass", __FILE__, __LINE__);
Logger::Get().Log("Initializing TransparentShaderClass", __FILE__, __LINE__);
bool result;
wchar_t vsFilename[128];
@ -35,7 +35,7 @@ bool TransparentShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"transparent.vs");
if (error != 0)
{
logger.Log("Failed to copy vertex shader filename", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to copy vertex shader filename", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -43,7 +43,7 @@ bool TransparentShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"transparent.ps");
if (error != 0)
{
logger.Log("Failed to copy pixel shader filename", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to copy pixel shader filename", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -51,11 +51,11 @@ bool TransparentShaderClass::Initialize(ID3D11Device* device, HWND hwnd)
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
logger.Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("TransparentShaderClass initialized", __FILE__, __LINE__);
Logger::Get().Log("TransparentShaderClass initialized", __FILE__, __LINE__);
return true;
}
@ -79,7 +79,7 @@ bool TransparentShaderClass::Render(ID3D11DeviceContext* deviceContext, int inde
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, blend);
if (!result)
{
logger.Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -92,7 +92,7 @@ bool TransparentShaderClass::Render(ID3D11DeviceContext* deviceContext, int inde
bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
logger.Log("Initializing transparent shader", __FILE__, __LINE__);
Logger::Get().Log("Initializing transparent shader", __FILE__, __LINE__);
HRESULT result;
ID3D10Blob* errorMessage;
@ -123,7 +123,7 @@ bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, W
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
logger.Log("Failed to compile vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -142,7 +142,7 @@ bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, W
// If there was nothing in the error message then it simply could not find the file itself.
else
{
logger.Log("Failed to compile pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to compile pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
}
return false;
@ -152,7 +152,7 @@ bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, W
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
logger.Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -160,7 +160,7 @@ bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, W
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
logger.Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -189,7 +189,7 @@ bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, W
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
logger.Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -212,7 +212,7 @@ bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, W
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
logger.Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -235,7 +235,7 @@ bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, W
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
logger.Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -251,11 +251,11 @@ bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, W
result = device->CreateBuffer(&transparentBufferDesc, NULL, &m_transparentBuffer);
if (FAILED(result))
{
logger.Log("Failed to create transparent buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to create transparent buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
logger.Log("Transparent shader initialized", __FILE__, __LINE__);
Logger::Get().Log("Transparent shader initialized", __FILE__, __LINE__);
return true;
}
@ -263,7 +263,7 @@ bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, W
void TransparentShaderClass::ShutdownShader()
{
logger.Log("Shutting down transparent shader", __FILE__, __LINE__);
Logger::Get().Log("Shutting down transparent shader", __FILE__, __LINE__);
// Release the transparent constant buffer.
if (m_transparentBuffer)
@ -307,7 +307,7 @@ void TransparentShaderClass::ShutdownShader()
m_vertexShader = 0;
}
logger.Log("Transparent shader shut down", __FILE__, __LINE__);
Logger::Get().Log("Transparent shader shut down", __FILE__, __LINE__);
return;
}
@ -367,7 +367,7 @@ bool TransparentShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceCont
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
@ -395,7 +395,7 @@ bool TransparentShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceCont
result = deviceContext->Map(m_transparentBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
logger.Log("Failed to map transparent buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
Logger::Get().Log("Failed to map transparent buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}

1
enginecustom/transparentshaderclass.h
View File

@ -58,7 +58,6 @@ private:
ID3D11SamplerState* m_sampleState;
ID3D11Buffer* m_transparentBuffer;
Logger logger;
};
#endif