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

Patch - Adds macro for simplified logging - V14.5.28

Browse Source 
Introduces a macro to streamline logging, enhancing code readability and maintainability.

The new macro replaces direct Logger calls with more concise and expressive `LOG_INFO`, `LOG_ERROR` etc. calls, reducing boilerplate code and improving consistency in logging practices across the engine.
This commit is contained in:
CatChow0
2025-10-09 16:58:48 +02:00
parent fe77100612
commit 7c5a6435bb
60 changed files with 653 additions and 521 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
enginecustom/enginecustom.vcxproj
View File

@@ -141,6 +141,7 @@
<ClInclude Include="src\inc\system\input_class.h" />
<ClInclude Include="src\inc\system\light_class.h" />
<ClInclude Include="src\inc\system\Logger.h" />
<ClInclude Include="src\inc\system\macro.h" />
<ClInclude Include="src\inc\system\model_class.h" />
<ClInclude Include="src\inc\system\Modellistclass.h" />
<ClInclude Include="src\inc\system\object.h" />

1
enginecustom/src/inc/shader/alpha_map_shader_class.h
View File

@@ -10,6 +10,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/celshade_class.h
View File

@@ -5,6 +5,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/color_shader_class.h
View File

@@ -13,6 +13,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/depth_shader_class.h
View File

@@ -10,6 +10,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/font_shader_class.h
View File

@@ -10,6 +10,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/light_map_shader_class.h
View File

@@ -11,6 +11,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/light_shader_class.h
View File

@@ -17,6 +17,7 @@ constexpr int num_lights = 4;
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/master_shader.h
View File

@@ -2,6 +2,7 @@
#include <d3d11.h>
#include <DirectXMath.h>
#include <string>
#include "macro.h"
class master_shader

1
enginecustom/src/inc/shader/multi_texture_shader_class.h
View File

@@ -13,6 +13,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/normal_map_shader_class.h
View File

@@ -10,6 +10,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/reflection_shader_class.h
View File

@@ -13,6 +13,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/refraction_shader_class.h
View File

@@ -9,6 +9,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/shader_manager_class.h
View File

@@ -21,6 +21,7 @@
#include "skybox_shader_class.h"
#include "sunlight_shader_class.h"
#include "depth_shader_class.h"
#include "macro.h"
using namespace DirectX;

1
enginecustom/src/inc/shader/skybox_shader_class.h
View File

@@ -5,6 +5,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/spec_map_shader_class.h
View File

@@ -9,6 +9,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/sunlight_shader_class.h
View File

@@ -5,6 +5,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/texture_shader_class.h
View File

@@ -10,6 +10,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/translate_shader_class.h
View File

@@ -10,6 +10,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/transparent_shader_class.h
View File

@@ -10,6 +10,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

1
enginecustom/src/inc/shader/water_shader_class.h
View File

@@ -9,6 +9,7 @@
#include <d3dcompiler.h>
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;
using namespace std;

2
enginecustom/src/inc/system/application_class.h
View File

@@ -9,6 +9,8 @@
#include "camera_class.h"
#include "light_class.h"
#include "macro.h"
#include "Fmod/core/inc/fmod.hpp"
#include "bitmap_class.h"

1
enginecustom/src/inc/system/bitmap_class.h
View File

@@ -13,6 +13,7 @@ using namespace DirectX;
// MY CLASS INCLUDES //
///////////////////////
#include "texture_class.h"
#include "macro.h"
////////////////////////////////////////////////////////////////////////////////

1
enginecustom/src/inc/system/camera_class.h
View File

@@ -9,6 +9,7 @@
// INCLUDES //
//////////////
#include <directxmath.h>
#include "macro.h"
using namespace DirectX;

1
enginecustom/src/inc/system/d_3d_class.h
View File

@@ -21,6 +21,7 @@
#include "font_shader_class.h"
#include "font_class.h"
#include "text_class.h"
#include "macro.h"
using namespace DirectX;

2
enginecustom/src/inc/system/display_plane_class.h
View File

@@ -6,7 +6,7 @@
// MY CLASS INCLUDES //
///////////////////////
#include "d_3d_class.h"
#include "macro.h"
////////////////////////////////////////////////////////////////////////////////
// Class name: display_plane_class

2
enginecustom/src/inc/system/ecs/component.h
View File

@@ -5,7 +5,7 @@
#include <imgui.h>
#include "entity.h"
#include "Logger.h"
#include "macro.h"
/**
* namespace for the Entity-Component-System (ECS)

8
enginecustom/src/inc/system/ecs/components/audio_component.h
View File

@@ -80,13 +80,13 @@ public:
if (!m_system) return false;
}
Logger::Get().Log("Loading audio file: " + path, __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Loading audio file: " + path);
m_soundPath = path;
if (!std::filesystem::exists(path)) {
m_lastError = "Fichier non trouv<75>: " + path;
Logger::Get().Log(m_lastError, __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR(m_lastError);
return false;
}
@@ -109,6 +109,7 @@ public:
if (result != FMOD_OK) {
m_lastError = "<EFBFBD>chec du chargement du son: " + std::to_string(result) +
" (chemin: " + absolutePath.string() + ")";
LOG_ERROR(m_lastError);
return false;
}
@@ -297,6 +298,7 @@ public:
if (!m_lastError.empty()) {
ImGui::TextColored(ImVec4(1, 0, 0, 1), "Error: %s", m_lastError.c_str());
LOG_ERROR(m_lastError);
}
} else {
ImGui::Text("Loaded: %s", m_soundPath.c_str());
@@ -507,8 +509,6 @@ public:
std::getline(ss, s_priority, ':');
std::getline(ss, s_spatialized, ':');
std::getline(ss, s_use_velocity, ':');
Logger::Get().Log("Deserializing AudioComponent: path=" + m_soundPath, __FILE__, __LINE__, Logger::LogLevel::Warning);
m_volume = std::stof(s_volume);
m_pan = std::stof(s_pan);

2
enginecustom/src/inc/system/ecs/components/render_component.h
View File

@@ -284,7 +284,7 @@ public:
if (!token.empty()) {
paths.emplace_back(token.begin(), token.end());
Logger::Get().Log("Loaded path: " + std::string(token.begin(), token.end()), __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Loaded path: " + std::string(token.begin(), token.end()));
}
}
return true;

1
enginecustom/src/inc/system/font_class.h
View File

@@ -7,6 +7,7 @@
//////////////
#include <directxmath.h>
#include <fstream>
#include "macro.h"
using namespace DirectX;

1
enginecustom/src/inc/system/imguiManager.h
View File

@@ -5,6 +5,7 @@
#include "Logger.h"
#include "sceneManager.h"
#include "fps_limiter.h"
#include "macro.h"
#include <imgui.h>
#include <imgui_impl_dx11.h>

12
enginecustom/src/inc/system/macro.h Normal file
View File

@@ -0,0 +1,12 @@
#pragma once
// Include //
#include "Logger.h"
// Macros //
#define LOG(msg, level) Logger::Get().Log(msg, __FILE__, __LINE__, level)
#define LOG_INFO(msg) Logger::Get().Log(msg, __FILE__, __LINE__, Logger::LogLevel::Info)
#define LOG_WARNING(msg) Logger::Get().Log(msg, __FILE__, __LINE__, Logger::LogLevel::Warning)
#define LOG_ERROR(msg) Logger::Get().Log(msg, __FILE__, __LINE__, Logger::LogLevel::Error)
#define LOG_DEBUG(msg) Logger::Get().Log(msg, __FILE__, __LINE__, Logger::LogLevel::Debug)
#define LOG_SHUTDOWN(msg) Logger::Get().Log(msg, __FILE__, __LINE__, Logger::LogLevel::Shutdown)
#define LOG_INIT(msg) Logger::Get().Log(msg, __FILE__, __LINE__, Logger::LogLevel::Initialize)

54
enginecustom/src/src/shader/alpha_map_shader_class.cpp
View File

@@ -23,7 +23,7 @@ alpha_map_shader_class::~alpha_map_shader_class()
bool alpha_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing alpha_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing alpha_map_shader_class");
bool result;
wchar_t vsFilename[128];
@@ -34,7 +34,7 @@ bool alpha_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/alphamap.vs");
if (error != 0)
{
Logger::Get().Log("Error copying string ", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string ");
return false;
}
@@ -42,7 +42,7 @@ bool alpha_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/alphamap.ps");
if (error != 0)
{
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string");
return false;
}
@@ -50,7 +50,7 @@ bool alpha_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing shader");
return false;
}
@@ -77,7 +77,7 @@ bool alpha_map_shader_class::render(ID3D11DeviceContext* deviceContext, int inde
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2, texture3);
if (!result)
{
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error setting shader parameters");
return false;
}
@@ -90,7 +90,7 @@ bool alpha_map_shader_class::render(ID3D11DeviceContext* deviceContext, int inde
bool alpha_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -120,7 +120,7 @@ bool alpha_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -139,7 +139,7 @@ bool alpha_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -149,7 +149,7 @@ bool alpha_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating vertex shader");
return false;
}
@@ -157,7 +157,7 @@ bool alpha_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating pixel shader");
return false;
}
@@ -194,7 +194,7 @@ bool alpha_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating input layout");
return false;
}
@@ -217,7 +217,7 @@ bool alpha_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating constant buffer");
return false;
}
@@ -240,11 +240,11 @@ bool alpha_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating sampler state");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
@@ -253,54 +253,54 @@ bool alpha_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
void alpha_map_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down shader");
// Release the sampler state.
if (sample_state_)
{
Logger::Get().Log("Releasing sampler state", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing sampler state");
sample_state_->Release();
sample_state_ = 0;
Logger::Get().Log("Sampler state released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Sampler state released");
}
// Release the matrix constant buffer.
if (matrix_buffer_)
{
Logger::Get().Log("Releasing constant buffer", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing constant buffer");
matrix_buffer_->Release();
matrix_buffer_ = 0;
Logger::Get().Log("Constant buffer released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Constant buffer released");
}
// Release the layout.
if (layout_)
{
Logger::Get().Log("Releasing layout", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing layout");
layout_->Release();
layout_ = 0;
Logger::Get().Log("Layout released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Layout released");
}
// Release the pixel shader.
if (pixel_shader_)
{
Logger::Get().Log("Releasing pixel shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing pixel shader");
pixel_shader_->Release();
pixel_shader_ = 0;
Logger::Get().Log("Pixel shader released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Pixel shader released");
}
// Release the vertex shader.
if (vertex_shader_)
{
Logger::Get().Log("Releasing vertex shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing vertex shader");
vertex_shader_->Release();
vertex_shader_ = 0;
Logger::Get().Log("Vertex shader released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Vertex shader released");
}
Logger::Get().Log("Shader shutdown complete", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shader shutdown complete");
return;
}
@@ -360,7 +360,7 @@ bool alpha_map_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceCo
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error mapping constant buffer");
return false;
}

36
enginecustom/src/src/shader/celshade_class.cpp
View File

@@ -30,7 +30,7 @@ celshade_class::~celshade_class()
bool celshade_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing LightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing LightShaderClass");
wchar_t vsFilename[128];
wchar_t psFilename[128];
@@ -41,7 +41,7 @@ bool celshade_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/celshading.vs");
if (error != 0)
{
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy string");
return false;
}
@@ -49,18 +49,18 @@ bool celshade_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/celshading.ps");
if (error != 0)
{
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy string");
return false;
}
// initialize the vertex and pixel shaders.
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize shader");
return false;
}
Logger::Get().Log("SunLightShaderClass initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("SunLightShaderClass initialized");
return true;
}
@@ -84,7 +84,7 @@ bool celshade_class::render(ID3D11DeviceContext* deviceContext, int index_count,
result = set_shader_parameters(deviceContext, world_matrix, view_matrix, projection_matrix, texture, diffuse_color, ambient_color, sun_direction, sunIntensity);
if (!result)
{
Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to set shader parameters");
return false;
}
@@ -97,7 +97,7 @@ bool celshade_class::render(ID3D11DeviceContext* deviceContext, int index_count,
bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -124,7 +124,7 @@ bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* v
}
else
{
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile shader");
}
return false;
}
@@ -139,7 +139,7 @@ bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* v
}
else
{
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile shader");
}
return false;
}
@@ -148,7 +148,7 @@ bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create vertex shader");
return false;
}
@@ -156,7 +156,7 @@ bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create pixel shader");
return false;
}
@@ -192,7 +192,7 @@ bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create input layout");
return false;
}
@@ -222,7 +222,7 @@ bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create sampler state");
return false;
}
@@ -238,7 +238,7 @@ bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create matrix buffer");
return false;
}
@@ -254,11 +254,11 @@ bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* v
result = device->CreateBuffer(&sunlightBufferDesc, NULL, &sunlight_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create sunlight buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create sunlight buffer");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
@@ -268,7 +268,7 @@ bool celshade_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* v
void celshade_class::shutdown_shader()
{
Logger::Get().Log("Shutting down SunLightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down SunLightShaderClass");
// Release the light constant buffers.
if (sunlight_color_buffer_)
@@ -332,7 +332,7 @@ void celshade_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("SunLightShaderClass shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("SunLightShaderClass shut down");
return;
}

52
enginecustom/src/src/shader/color_shader_class.cpp
View File

@@ -23,7 +23,7 @@ color_shader_class::~color_shader_class()
bool color_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing color_shader_class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing color_shader_class");
bool result;
wchar_t vsFilename[128];
@@ -35,7 +35,7 @@ bool color_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/Color.vs");
if (error != 0)
{
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string");
return false;
}
@@ -43,7 +43,7 @@ bool color_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/Color.ps");
if (error != 0)
{
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string");
return false;
}
@@ -51,11 +51,11 @@ bool color_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing shader");
return false;
}
Logger::Get().Log("color_shader_class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("color_shader_class initialized");
return true;
}
@@ -78,7 +78,7 @@ bool color_shader_class::render(ID3D11DeviceContext* deviceContext, int indexCou
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix);
if (!result)
{
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error setting shader parameters");
return false;
}
@@ -90,7 +90,7 @@ bool color_shader_class::render(ID3D11DeviceContext* deviceContext, int indexCou
bool color_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -119,7 +119,7 @@ bool color_shader_class::initialize_shader(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::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -138,7 +138,7 @@ bool color_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -148,7 +148,7 @@ bool color_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating vertex shader");
return false;
}
@@ -156,7 +156,7 @@ bool color_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating pixel shader");
return false;
}
@@ -186,7 +186,7 @@ bool color_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating input layout");
return false;
}
@@ -209,56 +209,56 @@ bool color_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating constant buffer");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
void color_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down shader");
// Release the matrix constant buffer.
if (matrix_buffer_)
{
Logger::Get().Log("Releasing matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing matrix buffer");
matrix_buffer_->Release();
matrix_buffer_ = 0;
Logger::Get().Log("Matrix buffer released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Matrix buffer released");
}
// Release the layout.
if (layout_)
{
Logger::Get().Log("Releasing layout", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing layout");
layout_->Release();
layout_ = 0;
Logger::Get().Log("Layout released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Layout released");
}
// Release the pixel shader.
if (pixel_shader_)
{
Logger::Get().Log("Releasing pixel shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing pixel shader");
pixel_shader_->Release();
pixel_shader_ = 0;
Logger::Get().Log("Pixel shader released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Pixel shader released");
}
// Release the vertex shader.
if (vertex_shader_)
{
Logger::Get().Log("Releasing vertex shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing vertex shader");
vertex_shader_->Release();
vertex_shader_ = 0;
Logger::Get().Log("Vertex shader released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Vertex shader released");
}
Logger::Get().Log("Shader shut down", __FILE__, __LINE__);
LOG_SHUTDOWN("Shader shut down");
return;
}
@@ -301,7 +301,7 @@ void color_shader_class::output_shader_error_message(ID3D10Blob* errorMessage, H
bool color_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContext, XMMATRIX worldMatrix, XMMATRIX viewMatrix,
XMMATRIX projectionMatrix)
{
Logger::Get().Log("Setting shader parameters", __FILE__, __LINE__);
LOG_DEBUG("Setting shader parameters");
HRESULT result;
D3D11_MAPPED_SUBRESOURCE mappedResource;
@@ -317,7 +317,7 @@ bool color_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error mapping constant buffer");
return false;
}

37
enginecustom/src/src/shader/depth_shader_class.cpp
View File

@@ -23,7 +23,7 @@ depth_shader_class::~depth_shader_class()
bool depth_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing texture shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing texture shader");
bool result;
wchar_t vsFilename[128];
@@ -33,7 +33,7 @@ bool depth_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/depth.vs");
if (error != 0)
{
Logger::Get().Log("Error copying stirng", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying stirng");
return false;
}
@@ -41,7 +41,7 @@ bool depth_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/depth.ps");
if (error != 0)
{
Logger::Get().Log("Error copying stirng", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying stirng");
return false;
}
@@ -49,11 +49,11 @@ bool depth_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing shader");
return false;
}
Logger::Get().Log("Texture shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Texture shader initialized");
return true;
}
@@ -71,12 +71,11 @@ bool depth_shader_class::render(ID3D11DeviceContext* deviceContext, int indexCou
{
bool result;
// Set the shader parameters that it will use for rendering.
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture);
if (!result)
{
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error setting shader parameters");
return false;
}
@@ -88,7 +87,7 @@ bool depth_shader_class::render(ID3D11DeviceContext* deviceContext, int indexCou
bool depth_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -117,7 +116,7 @@ bool depth_shader_class::initialize_shader(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::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -136,7 +135,7 @@ bool depth_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -146,7 +145,7 @@ bool depth_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating vertex shader");
return false;
}
@@ -154,7 +153,7 @@ bool depth_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating pixel shader");
return false;
}
// Create the vertex input layout description.
@@ -183,7 +182,7 @@ bool depth_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating input layout");
return false;
}
@@ -206,7 +205,7 @@ bool depth_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating constant buffer");
return false;
}
// Create a texture sampler state description.
@@ -228,18 +227,18 @@ bool depth_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating sampler state");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
void depth_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down shader");
// Release the sampler state.
if (sample_state_)
@@ -276,7 +275,7 @@ void depth_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("Shader shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shader shut down");
return;
}
@@ -334,7 +333,7 @@ bool depth_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error mapping constant buffer");
return false;
}

42
enginecustom/src/src/shader/font_shader_class.cpp
View File

@@ -24,7 +24,7 @@ font_shader_class::~font_shader_class()
bool font_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing font_shader_class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing font_shader_class");
bool result;
wchar_t vsFilename[128];
@@ -35,7 +35,7 @@ bool font_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/font.vs");
if (error != 0)
{
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string");
return false;
}
@@ -43,7 +43,7 @@ bool font_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/font.ps");
if (error != 0)
{
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string");
return false;
}
@@ -51,11 +51,11 @@ bool font_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing shader");
return false;
}
Logger::Get().Log("font_shader_class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("font_shader_class initialized");
return true;
}
@@ -78,7 +78,7 @@ bool font_shader_class::render(ID3D11DeviceContext* deviceContext, int indexCoun
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, pixelColor);
if (!result)
{
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error setting shader parameters");
return false;
}
@@ -90,7 +90,7 @@ bool font_shader_class::render(ID3D11DeviceContext* deviceContext, int indexCoun
bool font_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -121,7 +121,7 @@ bool font_shader_class::initialize_shader(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::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -140,7 +140,7 @@ bool font_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -150,7 +150,7 @@ bool font_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating vertex shader");
return false;
}
@@ -158,7 +158,7 @@ bool font_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating pixel shader");
return false;
}
@@ -188,7 +188,7 @@ bool font_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating input layout");
return false;
}
@@ -211,7 +211,7 @@ bool font_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating constant buffer");
return false;
}
@@ -234,7 +234,7 @@ bool font_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating sampler state");
return false;
}
@@ -250,18 +250,18 @@ bool font_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR
result = device->CreateBuffer(&pixelBufferDesc, NULL, &pixel_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating constant buffer");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
void font_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down shader");
// Release the pixel constant buffer.
if (pixel_buffer_)
@@ -305,7 +305,7 @@ void font_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("Shader shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shader shut down");
return;
}
@@ -365,7 +365,7 @@ bool font_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContext
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error mapping constant buffer");
return false;
}
@@ -393,7 +393,7 @@ bool font_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContext
result = deviceContext->Map(pixel_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error mapping constant buffer");
return false;
}

37
enginecustom/src/src/shader/light_map_shader_class.cpp
View File

@@ -23,7 +23,7 @@ light_map_shader_class::~light_map_shader_class()
bool light_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing light_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing light_map_shader_class");
bool result;
wchar_t vsFilename[128];
@@ -34,7 +34,7 @@ bool light_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/lightmap.vs");
if (error != 0)
{
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string");
return false;
}
@@ -42,7 +42,7 @@ bool light_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/lightmap.ps");
if (error != 0)
{
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string");
return false;
}
@@ -50,11 +50,11 @@ bool light_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing shader");
return false;
}
Logger::Get().Log("light_map_shader_class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("light_map_shader_class initialized");
return true;
}
@@ -74,12 +74,11 @@ bool light_map_shader_class::render(ID3D11DeviceContext* deviceContext, int inde
{
bool result;
// Set the shader parameters that it will use for rendering.
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2);
if (!result)
{
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error setting shader parameters");
return false;
}
@@ -92,7 +91,7 @@ bool light_map_shader_class::render(ID3D11DeviceContext* deviceContext, int inde
bool light_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
@@ -121,7 +120,7 @@ bool light_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -140,7 +139,7 @@ bool light_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -150,7 +149,7 @@ bool light_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating vertex shader");
return false;
}
@@ -158,7 +157,7 @@ bool light_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating pixel shader");
return false;
}
@@ -195,7 +194,7 @@ bool light_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating input layout");
return false;
}
@@ -218,7 +217,7 @@ bool light_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating constant buffer");
return false;
}
@@ -241,11 +240,11 @@ bool light_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating sampler state");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
@@ -253,7 +252,7 @@ bool light_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
void light_map_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down light_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down light_map_shader_class");
// Release the sampler state.
if (sample_state_)
@@ -290,7 +289,7 @@ void light_map_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("light_map_shader_class shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("light_map_shader_class shut down");
return;
}
@@ -350,7 +349,7 @@ bool light_map_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceCo
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error mapping constant buffer");
return false;
}

48
enginecustom/src/src/shader/light_shader_class.cpp
View File

@@ -30,7 +30,7 @@ light_shader_class::~light_shader_class()
bool light_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing light_shader_class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing light_shader_class");
wchar_t vsFilename[128];
wchar_t psFilename[128];
@@ -41,7 +41,7 @@ bool light_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/light.vs");
if (error != 0)
{
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy string");
return false;
}
@@ -49,18 +49,18 @@ bool light_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/light.ps");
if (error != 0)
{
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy string");
return false;
}
// initialize the vertex and pixel shaders.
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize shader");
return false;
}
Logger::Get().Log("light_shader_class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("light_shader_class initialized");
return true;
}
@@ -84,7 +84,7 @@ bool light_shader_class::render(ID3D11DeviceContext* deviceContext, int indexCou
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, lightPosition, ambientClor);
if(!result)
{
Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to set shader parameters");
return false;
}
@@ -97,7 +97,7 @@ bool light_shader_class::render(ID3D11DeviceContext* deviceContext, int indexCou
bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -129,7 +129,7 @@ bool light_shader_class::initialize_shader(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::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile shader");
}
return false;
@@ -147,7 +147,7 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile shader");
}
return false;
@@ -157,7 +157,7 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create vertex shader");
return false;
}
@@ -165,7 +165,7 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create pixel shader");
return false;
}
@@ -203,7 +203,7 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
&layout_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create input layout");
return false;
}
@@ -233,7 +233,7 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create sampler state");
return false;
}
@@ -249,7 +249,7 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create matrix buffer");
return false;
}
@@ -267,7 +267,7 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&cameraBufferDesc, NULL, &camera_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create camera buffer");
return false;
}
@@ -283,7 +283,7 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&lightColorBufferDesc, NULL, &light_color_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create light color buffer");
return false;
}
@@ -299,11 +299,11 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&lightPositionBufferDesc, NULL, &light_position_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create light position buffer");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
@@ -311,7 +311,7 @@ bool light_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
void light_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down light_shader_class", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down light_shader_class");
// Release the light constant buffers.
if (light_color_buffer_)
@@ -375,7 +375,7 @@ void light_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("light_shader_class shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("light_shader_class shut down");
return;
}
@@ -436,7 +436,7 @@ bool light_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to map matrix buffer");
return false;
}
@@ -461,7 +461,7 @@ bool light_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(camera_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to map camera buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to map camera buffer");
return false;
}
@@ -469,7 +469,7 @@ bool light_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(light_position_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to map light position buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to map light position buffer");
return false;
}
@@ -498,7 +498,7 @@ bool light_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(light_color_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to map light color buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to map light color buffer");
return false;
}

3
enginecustom/src/src/shader/master_shader.cpp
View File

@@ -1,5 +1,4 @@
#include "master_shader.h"
#include "Logger.h"
master_shader::master_shader()
{
@@ -16,7 +15,7 @@ master_shader::~master_shader()
bool master_shader::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing master_shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing master_shader");
bool success = false;

36
enginecustom/src/src/shader/multi_texture_shader_class.cpp
View File

@@ -26,7 +26,7 @@ multi_texture_shader_class::~multi_texture_shader_class()
bool multi_texture_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing multi_texture_shader_class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing multi_texture_shader_class");
bool result;
wchar_t vsFilename[128];
@@ -37,7 +37,7 @@ bool multi_texture_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/multitexture.vs");
if (error != 0)
{
Logger::Get().Log("Failed to set the filename of the vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to set the filename of the vertex shader");
return false;
}
@@ -45,7 +45,7 @@ bool multi_texture_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/multitexture.ps");
if (error != 0)
{
Logger::Get().Log("Failed to set the filename of the pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to set the filename of the pixel shader");
return false;
}
@@ -53,11 +53,11 @@ bool multi_texture_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Failed to initialize the vertex and pixel shaders", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize the vertex and pixel shaders");
return false;
}
Logger::Get().Log("multi_texture_shader_class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("multi_texture_shader_class initialized");
return true;
}
@@ -80,7 +80,7 @@ bool multi_texture_shader_class::render(ID3D11DeviceContext* deviceContext, int
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2);
if (!result)
{
Logger::Get().Log("Failed to set the shader parameters that it will use for rendering", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to set the shader parameters that it will use for rendering");
return false;
}
@@ -92,7 +92,7 @@ bool multi_texture_shader_class::render(ID3D11DeviceContext* deviceContext, int
bool multi_texture_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing the shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing the shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -122,7 +122,7 @@ bool multi_texture_shader_class::initialize_shader(ID3D11Device* device, HWND hw
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
Logger::Get().Log("Failed to compile the vertex shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile the vertex shader code");
}
return false;
@@ -141,7 +141,7 @@ bool multi_texture_shader_class::initialize_shader(ID3D11Device* device, HWND hw
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Failed to compile the pixel shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile the pixel shader code");
}
return false;
@@ -151,7 +151,7 @@ bool multi_texture_shader_class::initialize_shader(ID3D11Device* device, HWND hw
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the vertex shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the vertex shader from the buffer");
return false;
}
@@ -159,7 +159,7 @@ bool multi_texture_shader_class::initialize_shader(ID3D11Device* device, HWND hw
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the pixel shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the pixel shader from the buffer");
return false;
}
@@ -196,7 +196,7 @@ bool multi_texture_shader_class::initialize_shader(ID3D11Device* device, HWND hw
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the vertex input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the vertex input layout");
return false;
}
@@ -219,7 +219,7 @@ bool multi_texture_shader_class::initialize_shader(ID3D11Device* device, HWND hw
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the constant buffer pointer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the constant buffer pointer");
return false;
}
@@ -242,18 +242,18 @@ bool multi_texture_shader_class::initialize_shader(ID3D11Device* device, HWND hw
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the texture sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the texture sampler state");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
void multi_texture_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down the shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down the shader");
// Release the sampler state.
if (sample_state_)
@@ -290,7 +290,7 @@ void multi_texture_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("Shader shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shader shut down");
return;
}
@@ -348,7 +348,7 @@ bool multi_texture_shader_class::set_shader_parameters(ID3D11DeviceContext* devi
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to lock the constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to lock the constant buffer");
return false;
}

40
enginecustom/src/src/shader/normal_map_shader_class.cpp
View File

@@ -24,7 +24,7 @@ normal_map_shader_class::~normal_map_shader_class()
bool normal_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing normal map shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing normal map shader");
bool result;
wchar_t vsFilename[128];
@@ -35,7 +35,7 @@ bool normal_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/normalmap.vs");
if (error != 0)
{
Logger::Get().Log("Failed to set the filename of the vertex shader", __FILE__, __LINE__);
LOG_ERROR("Failed to set the filename of the vertex shader");
return false;
}
@@ -43,7 +43,7 @@ bool normal_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/normalmap.ps");
if (error != 0)
{
Logger::Get().Log("Failed to set the filename of the pixel shader", __FILE__, __LINE__);
LOG_ERROR("Failed to set the filename of the pixel shader");
return false;
}
@@ -51,11 +51,11 @@ bool normal_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Failed to initialize the vertex and pixel shaders", __FILE__, __LINE__);
LOG_ERROR("Failed to initialize the vertex and pixel shaders");
return false;
}
Logger::Get().Log("Successfully initialized normal map shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Successfully initialized normal map shader");
return true;
}
@@ -79,7 +79,7 @@ bool normal_map_shader_class::render(ID3D11DeviceContext* deviceContext, int ind
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2, lightDirection, diffuseColor);
if (!result)
{
Logger::Get().Log("Failed to set the shader parameters that will be used for rendering", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to set the shader parameters that will be used for rendering");
return false;
}
@@ -92,7 +92,7 @@ bool normal_map_shader_class::render(ID3D11DeviceContext* deviceContext, int ind
bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing normal map shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing normal map shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -123,7 +123,7 @@ bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
Logger::Get().Log("Failed to compile the vertex shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile the vertex shader code");
}
return false;
@@ -142,7 +142,7 @@ bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Failed to compile the pixel shader code", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile the pixel shader code");
}
return false;
@@ -152,7 +152,7 @@ bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the vertex shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the vertex shader from the buffer");
return false;
}
@@ -160,7 +160,7 @@ bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the pixel shader from the buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the pixel shader from the buffer");
return false;
}
@@ -213,7 +213,7 @@ bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the vertex input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the vertex input layout");
return false;
}
@@ -236,7 +236,7 @@ bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the constant buffer pointer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the constant buffer pointer");
return false;
}
@@ -259,7 +259,7 @@ bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the texture sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the texture sampler state");
return false;
}
@@ -275,11 +275,11 @@ bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&lightBufferDesc, NULL, &light_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create the light constant buffer pointer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create the light constant buffer pointer");
return false;
}
Logger::Get().Log("Successfully initialized normal map shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Successfully initialized normal map shader");
return true;
}
@@ -287,7 +287,7 @@ bool normal_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
void normal_map_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down normal map shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down normal map shader");
// Release the light constant buffer.
if (light_buffer_)
@@ -331,7 +331,7 @@ void normal_map_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("Successfully shut down normal map shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Successfully shut down normal map shader");
return;
}
@@ -392,7 +392,7 @@ bool normal_map_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceC
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to lock the constant buffer so it can be written to", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to lock the constant buffer so it can be written to");
return false;
}
@@ -421,7 +421,7 @@ bool normal_map_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceC
result = deviceContext->Map(light_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to lock the light constant buffer so it can be written to", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to lock the light constant buffer so it can be written to");
return false;
}

41
enginecustom/src/src/shader/reflection_shader_class.cpp
View File

@@ -21,7 +21,7 @@ reflection_shader_class::~reflection_shader_class()
bool reflection_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing reflection shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing reflection shader");
bool result;
wchar_t vsFilename[128];
@@ -32,7 +32,7 @@ bool reflection_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/reflection.vs");
if (error != 0)
{
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string");
return false;
}
@@ -40,7 +40,7 @@ bool reflection_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/reflection.ps");
if (error != 0)
{
Logger::Get().Log("Error copying string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying string");
return false;
}
@@ -48,11 +48,11 @@ bool reflection_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing shader");
return false;
}
Logger::Get().Log("Reflection shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Reflection shader initialized");
return true;
}
@@ -70,12 +70,11 @@ bool reflection_shader_class::render(ID3D11DeviceContext* deviceContext, int ind
{
bool result;
// Set the shader parameters that it will use for rendering.
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, reflectionTexture, reflectionMatrix);
if (!result)
{
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error setting shader parameters");
return false;
}
@@ -87,7 +86,7 @@ bool reflection_shader_class::render(ID3D11DeviceContext* deviceContext, int ind
bool reflection_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing reflection shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing reflection shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -118,7 +117,7 @@ bool reflection_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -136,7 +135,7 @@ bool reflection_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -146,7 +145,7 @@ bool reflection_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating vertex shader");
return false;
}
@@ -154,7 +153,7 @@ bool reflection_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating pixel shader");
return false;
}
@@ -183,7 +182,7 @@ bool reflection_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating input layout");
return false;
}
@@ -206,7 +205,7 @@ bool reflection_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating constant buffer");
return false;
}
// Create a texture sampler state description.
@@ -228,7 +227,7 @@ bool reflection_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating sampler state");
return false;
}
// Setup the description of the reflection dynamic constant buffer that is in the vertex shader.
@@ -243,18 +242,18 @@ bool reflection_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&reflectionBufferDesc, NULL, &reflection_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating constant buffer");
return false;
}
Logger::Get().Log("Reflection shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Reflection shader initialized");
return true;
}
void reflection_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down reflection shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down reflection shader");
// Release the reflection constant buffer.
if (reflection_buffer_)
@@ -298,7 +297,7 @@ void reflection_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("Reflection shader shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Reflection shader shut down");
return;
}
@@ -361,7 +360,7 @@ bool reflection_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceC
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error mapping constant buffer");
return false;
}
@@ -386,7 +385,7 @@ bool reflection_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceC
result = deviceContext->Map(reflection_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error mapping constant buffer");
return false;
}

28
enginecustom/src/src/shader/refraction_shader_class.cpp
View File

@@ -25,6 +25,8 @@ refraction_shader_class::~refraction_shader_class()
bool refraction_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
LOG_INIT("Initializing refraction shader");
bool result;
wchar_t vsFilename[128];
wchar_t psFilename[128];
@@ -34,6 +36,7 @@ bool refraction_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/refraction.vs");
if (error != 0)
{
LOG_ERROR("Error copying vertex shader filename");
return false;
}
@@ -41,6 +44,7 @@ bool refraction_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/refraction.ps");
if (error != 0)
{
LOG_ERROR("Error copying pixel shader filename");
return false;
}
@@ -48,9 +52,12 @@ bool refraction_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
LOG_ERROR("Error initializing shader");
return false;
}
LOG_INIT("Refraction shader initialized");
return true;
}
@@ -68,11 +75,11 @@ bool refraction_shader_class::render(ID3D11DeviceContext* deviceContext, int ind
{
bool result;
// Set the shader parameters that it will use for rendering.
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, ambientColor, diffuseColor, lightPosition, clipPlane);
if (!result)
{
LOG_ERROR("Error setting shader parameters");
return false;
}
@@ -85,6 +92,8 @@ bool refraction_shader_class::render(ID3D11DeviceContext* deviceContext, int ind
bool refraction_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
LOG_INIT("Initializing refraction shader");
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
@@ -134,6 +143,7 @@ bool refraction_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
// If there was nothing in the error message then it simply could not find the file itself.
else
{
LOG_ERROR("Missing pixel shader file");
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
@@ -144,6 +154,7 @@ bool refraction_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
LOG_ERROR("Error creating vertex shader");
return false;
}
@@ -151,6 +162,7 @@ bool refraction_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
LOG_ERROR("Error creating pixel shader");
return false;
}
@@ -187,6 +199,7 @@ bool refraction_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
LOG_ERROR("Error creating input layout");
return false;
}
@@ -209,6 +222,7 @@ bool refraction_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
LOG_ERROR("Error creating matrix buffer");
return false;
}
@@ -231,6 +245,7 @@ bool refraction_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
LOG_ERROR("Error creating sampler state");
return false;
}
@@ -247,6 +262,7 @@ bool refraction_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&lightBufferDesc, NULL, &light_buffer_);
if (FAILED(result))
{
LOG_ERROR("Error creating light buffer");
return false;
}
@@ -262,15 +278,20 @@ bool refraction_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd,
result = device->CreateBuffer(&clipPlaneBufferDesc, NULL, &clip_plane_buffer_);
if (FAILED(result))
{
LOG_ERROR("Error creating clip plane buffer");
return false;
}
LOG_INIT("Refraction shader initialized");
return true;
}
void refraction_shader_class::shutdown_shader()
{
LOG_SHUTDOWN("Shutting down refraction shader");
// Release the clip plane constant buffer.
if (clip_plane_buffer_)
{
@@ -320,6 +341,8 @@ void refraction_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
LOG_SHUTDOWN("Refraction shader shut down");
return;
}
@@ -380,6 +403,7 @@ bool refraction_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceC
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
LOG_ERROR("Error mapping matrix buffer");
return false;
}
@@ -404,6 +428,7 @@ bool refraction_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceC
result = deviceContext->Map(clip_plane_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if(FAILED(result))
{
LOG_ERROR("Error mapping clip plane buffer");
return false;
}
@@ -429,6 +454,7 @@ bool refraction_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceC
result = deviceContext->Map(light_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if(FAILED(result))
{
LOG_ERROR("Error mapping light buffer");
return false;
}

54
enginecustom/src/src/shader/shader_manager_class.cpp
View File

@@ -30,7 +30,7 @@ shader_manager_class::~shader_manager_class()
bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing shader_manager_class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader_manager_class");
bool result;
@@ -39,7 +39,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = texture_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing texture_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing texture_shader_class");
return false;
}
@@ -48,7 +48,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = normal_map_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing normal_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing normal_map_shader_class");
return false;
}
@@ -57,7 +57,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = multitexture_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing multi_texture_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing multi_texture_shader_class");
return false;
}
@@ -66,7 +66,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = translate_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing translate_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing translate_shader_class");
return false;
}
@@ -75,7 +75,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = alpha_map_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing alpha_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing alpha_map_shader_class");
return false;
}
@@ -84,7 +84,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = spec_map_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing spec_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing spec_map_shader_class");
return false;
}
@@ -93,7 +93,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = transparent_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing transparent_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing transparent_shader_class");
return false;
}
@@ -102,7 +102,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = light_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing light_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing light_shader_class");
return false;
}
@@ -111,7 +111,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = light_map_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing light_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing light_map_shader_class");
return false;
}
@@ -149,7 +149,7 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = skybox_shader_->Initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing skybox_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing skybox_shader_class");
return false;
}
@@ -157,18 +157,18 @@ bool shader_manager_class::initialize(ID3D11Device* device, HWND hwnd)
result = depth_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing depth_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing depth_shader_class");
return false;
}
Logger::Get().Log("shader_manager_class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("shader_manager_class initialized");
return true;
}
void shader_manager_class::shutdown()
{
Logger::Get().Log("Shutting down shader_manager_class", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down shader_manager_class");
// Release the normal map shader object.
if (normal_map_shader_)
@@ -287,7 +287,9 @@ void shader_manager_class::shutdown()
depth_shader_ = 0;
}
Logger::Get().Log("shader_manager_class shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("shader_manager_class shut down");
return;
}
bool shader_manager_class::render_texture_shader(ID3D11DeviceContext* deviceContext, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix,
@@ -298,7 +300,7 @@ bool shader_manager_class::render_texture_shader(ID3D11DeviceContext* deviceCont
result = texture_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture);
if (!result)
{
Logger::Get().Log("Error rendering texture_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error rendering texture_shader_class");
return false;
}
@@ -313,7 +315,7 @@ bool shader_manager_class::render_normal_map_shader(ID3D11DeviceContext* deviceC
result = normal_map_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, colorTexture, normalTexture, lightDirection, diffuseColor);
if (!result)
{
Logger::Get().Log("Error rendering normal_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error rendering normal_map_shader_class");
return false;
}
@@ -328,7 +330,7 @@ bool shader_manager_class::render_multitexture_shader(ID3D11DeviceContext* devic
result = multitexture_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2);
if (!result)
{
Logger::Get().Log("Error rendering multi_texture_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error rendering multi_texture_shader_class");
return false;
}
@@ -343,7 +345,7 @@ bool shader_manager_class::render_translate_shader(ID3D11DeviceContext* deviceCo
result = translate_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, valeur);
if (!result)
{
Logger::Get().Log("Error rendering translate_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error rendering translate_shader_class");
return false;
}
@@ -358,7 +360,7 @@ bool shader_manager_class::render_alpha_map_shader(ID3D11DeviceContext* deviceCo
result = alpha_map_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2, texture3);
if (!result)
{
Logger::Get().Log("Error rendering alpha_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error rendering alpha_map_shader_class");
return false;
}
@@ -375,7 +377,7 @@ bool shader_manager_class::render_spec_map_shader(ID3D11DeviceContext* deviceCon
diffuseColor, cameraPosition, specularColor, specularPower);
if (!result)
{
Logger::Get().Log("Error rendering spec_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error rendering spec_map_shader_class");
return false;
}
@@ -390,7 +392,7 @@ bool shader_manager_class::render_transparent_shader(ID3D11DeviceContext* device
result = transparent_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, blendAmount);
if (!result)
{
Logger::Get().Log("Error rendering transparent_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error rendering transparent_shader_class");
return false;
}
@@ -405,6 +407,7 @@ bool shader_manager_class::renderlight_shader(ID3D11DeviceContext* deviceContext
result = light_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, lightPosition, ambientColor);
if (!result)
{
LOG_ERROR("Error rendering light_shader_class");
return false;
}
@@ -419,6 +422,7 @@ bool shader_manager_class::renderlight_map_shader(ID3D11DeviceContext* deviceCon
result = light_map_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2);
if (!result)
{
LOG_ERROR("Error rendering light_map_shader_class");
return false;
}
@@ -433,6 +437,7 @@ bool shader_manager_class::render_refraction_shader(ID3D11DeviceContext* deviceC
result = refraction_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, ambientColor, diffuseColor, lightPosition, clipPlane);
if (!result)
{
LOG_ERROR("Error rendering refraction_shader_class");
return false;
}
@@ -449,6 +454,7 @@ bool shader_manager_class::render_water_shader(ID3D11DeviceContext* deviceContex
refractionTexture, normalTexture, waterTranslation, reflectRefractScale);
if (!result)
{
LOG_ERROR("Error rendering water_shader_class");
return false;
}
@@ -463,6 +469,7 @@ bool shader_manager_class::render_cel_shading_shader(ID3D11DeviceContext* device
result = cel_shading_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, ambientColor, sunDirection, sunIntensity);
if (!result)
{
LOG_ERROR("Error rendering celshade_class");
return false;
}
@@ -477,6 +484,7 @@ bool shader_manager_class::render_sunlight_shader(ID3D11DeviceContext* deviceCon
result = sunlight_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, ambientColor, sunDirection, sunIntensity);
if (!result)
{
LOG_ERROR("Error rendering sunlight_shader_class");
return false;
}
@@ -491,6 +499,7 @@ bool shader_manager_class::render_skybox_shader(ID3D11DeviceContext* deviceConte
result = skybox_shader_->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, ambientColor, sunDirection, sunIntensity);
if (!result)
{
LOG_ERROR("Error rendering skybox_shader_class");
return false;
}
@@ -511,6 +520,7 @@ bool shader_manager_class::render_depth_shader(
result = depth_shader_->render(context, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture);
if (!result)
{
LOG_ERROR("Error rendering depth_shader_class");
return false;
}

36
enginecustom/src/src/shader/skybox_shader_class.cpp
View File

@@ -30,7 +30,7 @@ skybox_shader_class::~skybox_shader_class()
bool skybox_shader_class::Initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing LightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing LightShaderClass");
wchar_t vsFilename[128];
wchar_t psFilename[128];
@@ -41,7 +41,7 @@ bool skybox_shader_class::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/skybox.vs");
if (error != 0)
{
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy string");
return false;
}
@@ -49,18 +49,18 @@ bool skybox_shader_class::Initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/skybox.ps");
if (error != 0)
{
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy string");
return false;
}
// Initialize the vertex and pixel shaders.
result = InitializeShader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize shader");
return false;
}
Logger::Get().Log("skybox_shader_class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("skybox_shader_class initialized");
return true;
}
@@ -84,7 +84,7 @@ bool skybox_shader_class::Render(ID3D11DeviceContext* deviceContext, int indexCo
result = SetShaderParameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, ambientColor, sunDirection, sunIntensity);
if (!result)
{
Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to set shader parameters");
return false;
}
@@ -97,7 +97,7 @@ bool skybox_shader_class::Render(ID3D11DeviceContext* deviceContext, int indexCo
bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -124,7 +124,7 @@ bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
}
else
{
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile shader");
}
return false;
}
@@ -139,7 +139,7 @@ bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
}
else
{
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile shader");
}
return false;
}
@@ -148,7 +148,7 @@ bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create vertex shader");
return false;
}
@@ -156,7 +156,7 @@ bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create pixel shader");
return false;
}
@@ -192,7 +192,7 @@ bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create input layout");
return false;
}
@@ -222,7 +222,7 @@ bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create sampler state");
return false;
}
@@ -238,7 +238,7 @@ bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create matrix buffer");
return false;
}
@@ -254,11 +254,11 @@ bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&sunlightBufferDesc, NULL, &m_sunlightBuffer);
if (FAILED(result))
{
Logger::Get().Log("Failed to create sunlight buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create sunlight buffer");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
@@ -268,7 +268,7 @@ bool skybox_shader_class::InitializeShader(ID3D11Device* device, HWND hwnd, WCHA
void skybox_shader_class::ShutdownShader()
{
Logger::Get().Log("Shutting down SunLightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down SunLightShaderClass");
// Release the light constant buffers.
if (m_sunlightColorBuffer)
@@ -332,7 +332,7 @@ void skybox_shader_class::ShutdownShader()
m_vertexShader = 0;
}
Logger::Get().Log("SunLightShaderClass shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("SunLightShaderClass shut down");
return;
}

16
enginecustom/src/src/shader/spec_map_shader_class.cpp
View File

@@ -25,6 +25,9 @@ spec_map_shader_class::~spec_map_shader_class()
bool spec_map_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
LOG_INIT("Initializing SpecMapShaderClass");
bool result;
wchar_t vsFilename[128];
wchar_t psFilename[128];
@@ -75,6 +78,7 @@ bool spec_map_shader_class::render(ID3D11DeviceContext* deviceContext, int index
cameraPosition, specularColor, specularPower);
if (!result)
{
LOG_ERROR("Failed to set shader parameters in SpecMapShaderClass");
return false;
}
@@ -146,6 +150,7 @@ bool spec_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
LOG_ERROR("Failed to create vertex shader in SpecMapShaderClass");
return false;
}
@@ -153,6 +158,7 @@ bool spec_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
LOG_ERROR("Failed to create pixel shader in SpecMapShaderClass");
return false;
}
@@ -205,6 +211,7 @@ bool spec_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
LOG_ERROR("Failed to create input layout in SpecMapShaderClass");
return false;
}
@@ -227,6 +234,7 @@ bool spec_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
LOG_ERROR("Failed to create uniform buffer in SpecMapShaderClass");
return false;
}
@@ -249,6 +257,7 @@ bool spec_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
LOG_ERROR("Failed to create sample state in SpecMapShaderClass");
return false;
}
@@ -264,6 +273,7 @@ bool spec_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateBuffer(&lightBufferDesc, NULL, &light_buffer_);
if (FAILED(result))
{
LOG_ERROR("Failed to create light buffer in SpecMapShaderClass");
return false;
}
@@ -279,6 +289,7 @@ bool spec_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateBuffer(&cameraBufferDesc, NULL, &camera_buffer_);
if (FAILED(result))
{
LOG_ERROR("Failed to create camera buffer in SpecMapShaderClass");
return false;
}
@@ -288,6 +299,8 @@ bool spec_map_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
void spec_map_shader_class::shutdown_shader()
{
LOG_SHUTDOWN("Shutting down SpecMapShaderClass");
// Release the camera constant buffer.
if (camera_buffer_)
{
@@ -397,6 +410,7 @@ bool spec_map_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceCon
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
LOG_ERROR("Failed to map mapped buffer in SpecMapShaderClass");
return false;
}
@@ -426,6 +440,7 @@ bool spec_map_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceCon
result = deviceContext->Map(light_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
LOG_ERROR("Failed to map lighting buffer in SpecMapShaderClass");
return false;
}
@@ -451,6 +466,7 @@ bool spec_map_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceCon
result = deviceContext->Map(camera_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
LOG_ERROR("Failed to map camera buffer in SpecMapShaderClass");
return false;
}

36
enginecustom/src/src/shader/sunlight_shader_class.cpp
View File

@@ -30,7 +30,7 @@ sunlight_shader_class::~sunlight_shader_class()
bool sunlight_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing LightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing LightShaderClass");
wchar_t vsFilename[128];
wchar_t psFilename[128];
@@ -41,7 +41,7 @@ bool sunlight_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/sunlight.vs");
if (error != 0)
{
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy string");
return false;
}
@@ -49,18 +49,18 @@ bool sunlight_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/sunlight.ps");
if (error != 0)
{
Logger::Get().Log("Failed to copy string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy string");
return false;
}
// initialize the vertex and pixel shaders.
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize shader");
return false;
}
Logger::Get().Log("SunLightShaderClass initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("SunLightShaderClass initialized");
return true;
}
@@ -84,7 +84,7 @@ bool sunlight_shader_class::render(ID3D11DeviceContext* deviceContext, int index
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, ambientColor, sunDirection, sunIntensity);
if (!result)
{
Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to set shader parameters");
return false;
}
@@ -97,7 +97,7 @@ bool sunlight_shader_class::render(ID3D11DeviceContext* deviceContext, int index
bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -124,7 +124,7 @@ bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
}
else
{
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile shader");
}
return false;
}
@@ -139,7 +139,7 @@ bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
}
else
{
Logger::Get().Log("Failed to compile shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile shader");
}
return false;
}
@@ -148,7 +148,7 @@ bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create vertex shader");
return false;
}
@@ -156,7 +156,7 @@ bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create pixel shader");
return false;
}
@@ -192,7 +192,7 @@ bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create input layout");
return false;
}
@@ -222,7 +222,7 @@ bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create sampler state");
return false;
}
@@ -238,7 +238,7 @@ bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create matrix buffer");
return false;
}
@@ -254,11 +254,11 @@ bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
result = device->CreateBuffer(&sunlightBufferDesc, NULL, &sunlight_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create sunlight buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create sunlight buffer");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
@@ -268,7 +268,7 @@ bool sunlight_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, W
void sunlight_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down SunLightShaderClass", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down SunLightShaderClass");
// Release the light constant buffers.
if (sunlight_color_buffer_)
@@ -332,7 +332,7 @@ void sunlight_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("SunLightShaderClass shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("SunLightShaderClass shut down");
return;
}

36
enginecustom/src/src/shader/texture_shader_class.cpp
View File

@@ -23,7 +23,7 @@ texture_shader_class::~texture_shader_class()
bool texture_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing texture shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing texture shader");
bool result;
wchar_t vsFilename[128];
@@ -33,7 +33,7 @@ bool texture_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/texture.vs");
if (error != 0)
{
Logger::Get().Log("Error copying stirng", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying stirng");
return false;
}
@@ -41,7 +41,7 @@ bool texture_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/texture.ps");
if (error != 0)
{
Logger::Get().Log("Error copying stirng", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error copying stirng");
return false;
}
@@ -49,11 +49,11 @@ bool texture_shader_class::initialize(ID3D11Device* device, HWND hwnd)
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Error initializing shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error initializing shader");
return false;
}
Logger::Get().Log("Texture shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Texture shader initialized");
return true;
}
@@ -76,7 +76,7 @@ bool texture_shader_class::render(ID3D11DeviceContext* deviceContext, int indexC
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture);
if (!result)
{
Logger::Get().Log("Error setting shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error setting shader parameters");
return false;
}
@@ -88,7 +88,7 @@ bool texture_shader_class::render(ID3D11DeviceContext* deviceContext, int indexC
bool texture_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -117,7 +117,7 @@ bool texture_shader_class::initialize_shader(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::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -136,7 +136,7 @@ bool texture_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WC
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Error compiling shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error compiling shader");
}
return false;
@@ -146,7 +146,7 @@ bool texture_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WC
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating vertex shader");
return false;
}
@@ -154,7 +154,7 @@ bool texture_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WC
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Error creating pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating pixel shader");
return false;
}
// Create the vertex input layout description.
@@ -183,7 +183,7 @@ bool texture_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WC
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Error creating input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating input layout");
return false;
}
@@ -206,7 +206,7 @@ bool texture_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WC
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Error creating constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating constant buffer");
return false;
}
// Create a texture sampler state description.
@@ -228,18 +228,18 @@ bool texture_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WC
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Error creating sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error creating sampler state");
return false;
}
Logger::Get().Log("Shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Shader initialized");
return true;
}
void texture_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down shader");
// Release the sampler state.
if (sample_state_)
@@ -276,7 +276,7 @@ void texture_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("Shader shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shader shut down");
return;
}
@@ -334,7 +334,7 @@ bool texture_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceCont
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Error mapping constant buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Error mapping constant buffer");
return false;
}

40
enginecustom/src/src/shader/translate_shader_class.cpp
View File

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

42
enginecustom/src/src/shader/transparent_shader_class.cpp
View File

@@ -24,7 +24,7 @@ transparent_shader_class::~transparent_shader_class()
bool transparent_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
Logger::Get().Log("Initializing transparent_shader_class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing transparent_shader_class");
bool result;
wchar_t vsFilename[128];
@@ -35,7 +35,7 @@ bool transparent_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(vsFilename, 128, L"src/hlsl/transparent.vs");
if (error != 0)
{
Logger::Get().Log("Failed to copy vertex shader filename", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy vertex shader filename");
return false;
}
@@ -43,19 +43,19 @@ bool transparent_shader_class::initialize(ID3D11Device* device, HWND hwnd)
error = wcscpy_s(psFilename, 128, L"src/hlsl/transparent.ps");
if (error != 0)
{
Logger::Get().Log("Failed to copy pixel shader filename", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to copy pixel shader filename");
return false;
}
// initialize the vertex and pixel shaders.
// Initialize the vertex and pixel shaders.
result = initialize_shader(device, hwnd, vsFilename, psFilename);
if (!result)
{
Logger::Get().Log("Failed to initialize shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize shader");
return false;
}
Logger::Get().Log("transparent_shader_class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("transparent_shader_class initialized");
return true;
}
@@ -79,7 +79,7 @@ bool transparent_shader_class::render(ID3D11DeviceContext* deviceContext, int in
result = set_shader_parameters(deviceContext, worldMatrix, viewMatrix, projectionMatrix, texture, blend);
if (!result)
{
Logger::Get().Log("Failed to set shader parameters", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to set shader parameters");
return false;
}
@@ -92,7 +92,7 @@ bool transparent_shader_class::render(ID3D11DeviceContext* deviceContext, int in
bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
Logger::Get().Log("Initializing transparent shader", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing transparent shader");
HRESULT result;
ID3D10Blob* errorMessage;
@@ -123,7 +123,7 @@ bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
Logger::Get().Log("Failed to compile vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile vertex shader");
}
return false;
@@ -142,7 +142,7 @@ bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd
// If there was nothing in the error message then it simply could not find the file itself.
else
{
Logger::Get().Log("Failed to compile pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to compile pixel shader");
}
return false;
@@ -152,7 +152,7 @@ bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create vertex shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create vertex shader");
return false;
}
@@ -160,7 +160,7 @@ bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create pixel shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create pixel shader");
return false;
}
@@ -189,7 +189,7 @@ bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create input layout", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create input layout");
return false;
}
@@ -212,7 +212,7 @@ bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create matrix buffer");
return false;
}
@@ -235,7 +235,7 @@ bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create sampler state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create sampler state");
return false;
}
@@ -251,11 +251,11 @@ bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd
result = device->CreateBuffer(&transparentBufferDesc, NULL, &transparent_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create transparent buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create transparent buffer");
return false;
}
Logger::Get().Log("Transparent shader initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Transparent shader initialized");
return true;
}
@@ -263,7 +263,7 @@ bool transparent_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd
void transparent_shader_class::shutdown_shader()
{
Logger::Get().Log("Shutting down transparent shader", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down transparent shader");
// Release the transparent constant buffer.
if (transparent_buffer_)
@@ -307,7 +307,7 @@ void transparent_shader_class::shutdown_shader()
vertex_shader_ = 0;
}
Logger::Get().Log("Transparent shader shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Transparent shader shut down");
return;
}
@@ -367,7 +367,7 @@ bool transparent_shader_class::set_shader_parameters(ID3D11DeviceContext* device
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to map matrix buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to map matrix buffer");
return false;
}
@@ -395,7 +395,7 @@ bool transparent_shader_class::set_shader_parameters(ID3D11DeviceContext* device
result = deviceContext->Map(transparent_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to map transparent buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to map transparent buffer");
return false;
}

17
enginecustom/src/src/shader/water_shader_class.cpp
View File

@@ -25,6 +25,9 @@ water_shader_class::~water_shader_class()
bool water_shader_class::initialize(ID3D11Device* device, HWND hwnd)
{
LOG_INIT("Initializing Water Shader");
bool result;
wchar_t vsFilename[128];
wchar_t psFilename[128];
@@ -75,6 +78,7 @@ bool water_shader_class::render(ID3D11DeviceContext* deviceContext, int indexCou
refractionTexture, normalTexture, waterTranslation, reflectRefractScale);
if (!result)
{
LOG_ERROR("Failed to set shader parameters in water shader");
return false;
}
@@ -146,6 +150,7 @@ bool water_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertex_shader_);
if (FAILED(result))
{
LOG_ERROR("Error creating vertex shader in water shader");
return false;
}
@@ -153,6 +158,7 @@ bool water_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixel_shader_);
if (FAILED(result))
{
LOG_ERROR("Error creating pixel shader in water shader");
return false;
}
@@ -181,6 +187,7 @@ bool water_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
vertexShaderBuffer->GetBufferSize(), &layout_);
if (FAILED(result))
{
LOG_ERROR("Error creating input layout in water shader");
return false;
}
@@ -203,6 +210,7 @@ bool water_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrix_buffer_);
if (FAILED(result))
{
LOG_ERROR("Error creating matrix buffer in water shader");
return false;
}
@@ -225,6 +233,7 @@ bool water_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateSamplerState(&samplerDesc, &sample_state_);
if (FAILED(result))
{
LOG_ERROR("Error creating sampler state in water shader");
return false;
}
@@ -240,6 +249,7 @@ bool water_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&reflectionBufferDesc, NULL, &reflection_buffer_);
if (FAILED(result))
{
LOG_ERROR("Error creating reflection buffer in water shader");
return false;
}
@@ -255,6 +265,7 @@ bool water_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
result = device->CreateBuffer(&waterBufferDesc, NULL, &water_buffer_);
if (FAILED(result))
{
LOG_ERROR("Error creating water buffer in water shader");
return false;
}
@@ -264,6 +275,9 @@ bool water_shader_class::initialize_shader(ID3D11Device* device, HWND hwnd, WCHA
void water_shader_class::shutdown_shader()
{
LOG_SHUTDOWN("Shutting down Water Shader");
// Release the water constant buffer.
if (water_buffer_)
{
@@ -373,6 +387,7 @@ bool water_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(matrix_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
LOG_ERROR("Error mapping matrix buffer in water shader");
return false;
}
@@ -397,6 +412,7 @@ bool water_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(reflection_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
LOG_ERROR("Error mapping reflection buffer in water shader");
return false;
}
@@ -428,6 +444,7 @@ bool water_shader_class::set_shader_parameters(ID3D11DeviceContext* deviceContex
result = deviceContext->Map(water_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
LOG_ERROR("Error mapping water buffer in water shader");
return false;
}

210
enginecustom/src/src/system/application_class.cpp
View File

@@ -70,7 +70,7 @@ application_class::~application_class()
bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd, bool is_vulkan)
{
Logger::Get().Log("Initializing application class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing application class");
try
{
@@ -97,14 +97,14 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
direct_3d_ = new d_3d_class;
if (!direct_3d_)
{
Logger::Get().Log("Could not create the Direct3D object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not create the Direct3D object");
return false;
}
result = direct_3d_->initialize(screen_width_, screen_height_, vsync_enabled_, hwnd, full_screen, screen_depth, screen_near);
if (!result)
{
Logger::Get().Log("Could not initialize Direct3D", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize Direct3D");
return false;
}
@@ -112,14 +112,14 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
camera_ = new camera_class;
if (!camera_)
{
Logger::Get().Log("Could not create the camera object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not create the camera object");
return false;
}
sun_camera_ = new camera_class;
if (!sun_camera_)
{
Logger::Get().Log("Could not create the sun camera object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not create the sun camera object");
return false;
}
@@ -142,7 +142,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = font_shader_->initialize(direct_3d_->get_device(), hwnd);
if (!result)
{
Logger::Get().Log("Could not initialize the font shader object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the font shader object");
return false;
}
@@ -152,7 +152,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = font_->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), 0);
if (!result)
{
Logger::Get().Log("Could not initialize the font object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the font object");
return false;
}
@@ -162,7 +162,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = render_texture_->Initialize(direct_3d_->get_device(), 256, 256, screen_depth, screen_near, 1);
if (!result)
{
Logger::Get().Log("Could not initialize the render texture object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the render texture object");
return false;
}
@@ -173,7 +173,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = scene_texture_->Initialize(direct_3d_->get_device(), 256, 256, screen_depth, screen_near, 1);
if (!result)
{
Logger::Get().Log("Could not initialize the render texture object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the render texture object");
return false;
}
@@ -183,7 +183,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = display_plane_->Initialize(direct_3d_->get_device(), 1.0f, 1.0f);
if (!result)
{
Logger::Get().Log("Could not initialize the display plane object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the display plane object");
return false;
}
@@ -198,7 +198,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = sprite_->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), screenWidth, screenHeight, spriteFilename, 50, 50);
if (!result)
{
Logger::Get().Log("Could not initialize the sprite object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the sprite object");
return false;
}
@@ -216,7 +216,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = mouse_strings_[i].Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), screenWidth, screenHeight, 32, font_, mouseString1, 10, y, 1.0f, 1.0f, 1.0f);
if (!result)
{
Logger::Get().Log("Could not initialize the mouse strings", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the mouse strings");
return false;
}
}
@@ -230,7 +230,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = bitmap_->initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), screenWidth, screenHeight, bitmapFilename, 50, 50);
if (!result)
{
Logger::Get().Log("Could not initialize the bitmap object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the bitmap object");
return false;
}
@@ -250,7 +250,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
Hresult = DirectX::CreateWICTextureFromFile(direct_3d_->get_device(), direct_3d_->get_device_context(), textureFilename.c_str(), nullptr, &texture);
if (FAILED(Hresult))
{
Logger::Get().Log("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()), __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()));
return false;
}
CubeTextures.diffuse.push_back(texture);
@@ -263,7 +263,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = model_->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, CubeTextures);
if (!result)
{
Logger::Get().Log("Could not initialize the model object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the model object");
return false;
}
@@ -334,7 +334,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = shader_manager_->initialize(direct_3d_->get_device(), hwnd);
if (!result)
{
Logger::Get().Log("Could not initialize the shader manager object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the shader manager object");
return false;
}
@@ -347,7 +347,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = render_count_string_->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), screenWidth, screenHeight, 32, font_, renderString, 10, 10, 1.0f, 1.0f, 1.0f);
if (!result)
{
Logger::Get().Log("Could not initialize the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the render count string");
return false;
}
@@ -369,7 +369,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
Hresult = DirectX::CreateWICTextureFromFile(direct_3d_->get_device(), direct_3d_->get_device_context(), textureFilename.c_str(), nullptr, &texture);
if (FAILED(Hresult))
{
Logger::Get().Log("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()), __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()));
return false;
}
BathTextures.diffuse.push_back(texture);
@@ -404,7 +404,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
Hresult = DirectX::CreateWICTextureFromFile(direct_3d_->get_device(), direct_3d_->get_device_context(), textureFilename.c_str(), nullptr, &texture);
if (FAILED(Hresult))
{
Logger::Get().Log("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()), __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to load texture: " + std::string(textureFilename.begin(), textureFilename.end()));
return false;
}
WaterTextures.diffuse.push_back(texture);
@@ -452,7 +452,7 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = timer_->Initialize();
if (!result)
{
Logger::Get().Log("Could not initialize the timer object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the timer object");
return false;
}
@@ -474,21 +474,21 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
result = fps_string_->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), screenWidth, screenHeight, 32, font_, fpsString, 10, 10, 0.0f, 1.0f, 0.0f);
if (!result)
{
Logger::Get().Log("Could not initialize the fps string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the fps string");
return false;
}
shadow_map_ = new shadow_map();
if (!shadow_map_->initialize(direct_3d_->get_device(), 2048, 2048))
{
Logger::Get().Log("Could not initialize the shadow map object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the shadow map object");
return false;
}
stats_ = new stats();
if (!stats_->initialize(this))
{
Logger::Get().Log("Could not initialize the stats object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize the stats object");
return false;
}
@@ -525,10 +525,10 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
}
catch (const std::exception& e)
{
Logger::Get().Log(std::string("Exception caught during initialization: ") + e.what() , __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR(std::string("Exception caught during initialization: ") + e.what() );
return false;
}
Logger::Get().Log("Application class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Application class initialized");
@@ -537,18 +537,18 @@ bool application_class::initialize(int screenWidth, int screenHeight, HWND hwnd,
void application_class::shutdown()
{
Logger::Get().Log("Shutting down application class", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down application class");
// Release the shader manager object.
if (shader_manager_)
{
Logger::Get().Log("Releasing the shader manager object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the shader manager object");
shader_manager_->shutdown();
delete shader_manager_;
shader_manager_ = 0;
Logger::Get().Log("Shader manager object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shader manager object released");
}
// Release the reflection render texture object.
@@ -592,54 +592,54 @@ void application_class::shutdown()
// Release the display plane object.
if (display_plane_)
{
Logger::Get().Log("Releasing the display plane object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the display plane object");
display_plane_->Shutdown();
delete display_plane_;
display_plane_ = 0;
Logger::Get().Log("Display plane object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Display plane object released");
}
// Release the position object.
if (position_)
{
Logger::Get().Log("Releasing the position object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the position object");
delete position_;
position_ = 0;
Logger::Get().Log("Position object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Position object released");
}
// Release the model list object.
if (model_list_)
{
Logger::Get().Log("Releasing the model list object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the model list object");
model_list_->Shutdown();
delete model_list_;
model_list_ = 0;
Logger::Get().Log("Model list object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Model list object released");
}
// Release the text objects for the render count string.
if (render_count_string_)
{
Logger::Get().Log("Releasing the render count string object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the render count string object");
render_count_string_->Shutdown();
delete render_count_string_;
render_count_string_ = 0;
Logger::Get().Log("render count string object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("render count string object released");
}
// Release the text objects for the mouse strings.
if (mouse_strings_)
{
Logger::Get().Log("Releasing the mouse strings", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the mouse strings");
mouse_strings_[0].Shutdown();
mouse_strings_[1].Shutdown();
@@ -648,107 +648,107 @@ void application_class::shutdown()
delete[] mouse_strings_;
mouse_strings_ = 0;
Logger::Get().Log("Mouse strings released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Mouse strings released");
}
// Release the text object for the fps string.
if (fps_string_)
{
Logger::Get().Log("Releasing the fps string object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the fps string object");
fps_string_->Shutdown();
delete fps_string_;
fps_string_ = 0;
Logger::Get().Log("Fps string object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Fps string object released");
}
// Release the fps object.
if (fps_)
{
Logger::Get().Log("Releasing the fps object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the fps object");
delete fps_;
fps_ = 0;
Logger::Get().Log("Fps object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Fps object released");
}
// Release the font object.
if (font_)
{
Logger::Get().Log("Releasing the font object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the font object");
font_->Shutdown();
delete font_;
font_ = 0;
Logger::Get().Log("Font object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Font object released");
}
// Release the font shader object.
if (font_shader_)
{
Logger::Get().Log("Releasing the font shader object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the font shader object");
font_shader_->shutdown();
delete font_shader_;
font_shader_ = 0;
Logger::Get().Log("Font shader object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Font shader object released");
}
// Release the timer object.
if (timer_)
{
Logger::Get().Log("Releasing the timer object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the timer object");
delete timer_;
timer_ = 0;
Logger::Get().Log("Timer object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Timer object released");
}
// Release the sprite object.
if (sprite_)
{
Logger::Get().Log("Releasing the sprite object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the sprite object");
sprite_->Shutdown();
delete sprite_;
sprite_ = 0;
Logger::Get().Log("Sprite object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Sprite object released");
}
for (auto light : lights_)
{
Logger::Get().Log("Releasing the light object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the light object");
if (light)
{
delete light;
light = 0;
}
Logger::Get().Log("Light object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Light object released");
}
// Release the light object.
if (m_light_)
{
Logger::Get().Log("Releasing the light object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the light object");
delete m_light_;
m_light_ = 0;
Logger::Get().Log("Light object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Light object released");
}
// Release the model object.
if (model_)
{
Logger::Get().Log("Releasing the model object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the model object");
model_->Shutdown();
delete model_;
model_ = 0;
Logger::Get().Log("Model object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Model object released");
}
if (scene_texture_)
@@ -760,10 +760,10 @@ void application_class::shutdown()
if (sun_camera_)
{
Logger::Get().Log("Releasing the sun camera object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing the sun camera object");
delete sun_camera_;
sun_camera_ = nullptr;
Logger::Get().Log("Sun camera object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Sun camera object released");
}
if (shadow_map_) {
@@ -772,7 +772,7 @@ void application_class::shutdown()
shadow_map_ = nullptr;
}
Logger::Get().Log("Application class shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Application class shut down");
}
bool application_class::frame(input_class* Input)
@@ -802,7 +802,7 @@ bool application_class::frame(input_class* Input)
// Check if the user pressed escape and wants to exit the application.
if (Input->IsEscapePressed())
{
Logger::Get().Log("User pressed escape, exiting application", __FILE__, __LINE__, Logger::LogLevel::Input);
LOG("User pressed escape, exiting application",Logger::LogLevel::Input);
should_quit_ = true;
}
@@ -882,7 +882,7 @@ bool application_class::frame(input_class* Input)
result = render(rotation, x, y, z, textureTranslation);
if (!result)
{
Logger::Get().Log("Could not render the graphics scene", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not render the graphics scene");
return false;
}
@@ -890,7 +890,7 @@ bool application_class::frame(input_class* Input)
result = update_fps();
if (!result)
{
Logger::Get().Log("Could not update the frames per second", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not update the frames per second");
return false;
}
@@ -931,7 +931,7 @@ bool application_class::frame(input_class* Input)
result = render_scene_to_texture(rotation);
if (!result)
{
Logger::Get().Log("Could not render the scene to the render texture", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not render the scene to the render texture");
return false;
}
@@ -939,7 +939,7 @@ bool application_class::frame(input_class* Input)
result = update_mouse_strings(mouseX, mouseY, leftMouseDown);
if (!result)
{
Logger::Get().Log("Could not update the mouse strings", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not update the mouse strings");
return false;
}
@@ -1151,7 +1151,7 @@ bool application_class::render(float rotation, float x, float y, float z, float
result = render_pass(diffuseColor, lightPosition, ambientColor, viewMatrix, projectionMatrix);
if (!result)
{
Logger::Get().Log("Could not render the model using any shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not render the model using any shader");
return false;
}
@@ -1164,7 +1164,7 @@ bool application_class::render(float rotation, float x, float y, float z, float
// result = render_pass(render_queues_, diffuseColor, lightPosition, ambientColor, viewMatrix, projectionMatrix);
// if (!result)
// {
// Logger::Get().Log("Could not render the model using any shader", __FILE__, __LINE__, Logger::LogLevel::Error);
// LOG_ERROR("Could not render the model using any shader");
// return false;
// }
@@ -1174,7 +1174,7 @@ bool application_class::render(float rotation, float x, float y, float z, float
result = update_render_count_string(get_render_count());
if (!result)
{
Logger::Get().Log("Could not update the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not update the render count string");
return false;
}
@@ -1228,7 +1228,7 @@ bool application_class::render(float rotation, float x, float y, float z, float
font_->GetTexture(), render_count_string_->GetPixelColor());
if (!result)
{
Logger::Get().Log("Could not render the render count text string using the font shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not render the render count text string using the font shader");
return false;
}
@@ -1239,7 +1239,7 @@ bool application_class::render(float rotation, float x, float y, float z, float
font_->GetTexture(), fps_string_->GetPixelColor());
if (!result)
{
Logger::Get().Log("Could not render the fps text string using the font shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not render the fps text string using the font shader");
return false;
}
@@ -1252,7 +1252,7 @@ bool application_class::render(float rotation, float x, float y, float z, float
font_->GetTexture(), mouse_strings_[i].GetPixelColor());
if (!result)
{
Logger::Get().Log("Could not render the mouse text strings using the font shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not render the mouse text strings using the font shader");
return false;
}
}
@@ -1269,7 +1269,7 @@ bool application_class::render(float rotation, float x, float y, float z, float
sprite_->GetTexture());
if (!result)
{
Logger::Get().Log("Could not render the sprite using the texture shader", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not render the sprite using the texture shader");
return false;
}
@@ -1311,7 +1311,7 @@ int application_class::get_screen_height() const
void application_class::generate_terrain()
{
Logger::Get().Log("G<EFBFBD>n<EFBFBD>ration du terrain avec ECS", __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("G<EFBFBD>n<EFBFBD>ration du terrain avec ECS");
// delete previous terrain if it exists
delete_terrain();
@@ -1330,7 +1330,7 @@ void application_class::generate_terrain()
auto it = g_model_cache.find(modelName);
if (it != g_model_cache.end()) {
// Utiliser le mod<6F>le existant du cache
Logger::Get().Log("Using cached model for terrain: " + modelName, __FILE__, __LINE__);
LOG_INFO("Using cached model for terrain: " + modelName);
sharedModel = it->second;
}
else {
@@ -1348,14 +1348,14 @@ void application_class::generate_terrain()
newModel->PreloadTextures(direct_3d_->get_device(), direct_3d_->get_device_context(), textureContainer);
if (!newModel->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, textureContainer)) {
Logger::Get().Log("Impossible d'initialiser le mod<6F>le du terrain", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Impossible d'initialiser le mod<6F>le du terrain");
return;
}
// Ajouter le mod<6F>le au cache
g_model_cache[modelName] = newModel;
sharedModel = newModel;
Logger::Get().Log("Added terrain model to cache: " + modelName, __FILE__, __LINE__);
LOG_INFO("Added terrain model to cache: " + modelName);
}
// V<>rifier si l'entity manager est disponible
@@ -1391,13 +1391,13 @@ void application_class::generate_terrain()
update_stats_after_modification();
int totalTiles = gridSizeX * gridSizeZ;
Logger::Get().Log("Terrain g<>n<EFBFBD>r<EFBFBD> avec " + std::to_string(totalTiles) + " tuiles", __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Terrain g<>n<EFBFBD>r<EFBFBD> avec " + std::to_string(totalTiles) + " tuiles");
}
void application_class::add_kobject(std::wstring& filepath)
{
std::lock_guard<std::mutex> lock(objects_mutex_);
Logger::Get().Log("Adding object", __FILE__, __LINE__);
LOG_INFO("Adding object", __FILE__, __LINE__);
char modelFilename[128];
TextureContainer KobjectsTextures;
@@ -1428,7 +1428,7 @@ void application_class::add_kobject(std::wstring& filepath)
auto it = g_model_cache.find(modelKey);
if (it != g_model_cache.end()) {
// Utiliser le mod<6F>le existant du cache
Logger::Get().Log("Using cached model for " + modelKey, __FILE__, __LINE__);
LOG_INFO("Using cached model for " + modelKey, __FILE__, __LINE__);
sharedModel = it->second;
}
else {
@@ -1440,13 +1440,13 @@ void application_class::add_kobject(std::wstring& filepath)
// Initialiser le mod<6F>le
if (!sharedModel->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, KobjectsTextures)) {
Logger::Get().Log("Failed to initialize model for object: " + modelKey, __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize model for object: " + modelKey);
return;
}
// Ajouter le mod<6F>le au cache
g_model_cache[modelKey] = sharedModel;
Logger::Get().Log("Added model to cache: " + modelKey, __FILE__, __LINE__);
LOG_INFO("Added model to cache: " + modelKey, __FILE__, __LINE__);
}
// Cr<43>er une nouvelle entit<69>
@@ -1475,7 +1475,7 @@ void application_class::add_kobject(std::wstring& filepath)
auto modelPath = entity->AddComponent<ecs::ModelPathComponent>();
modelPath->SetPath(filepath);
Logger::Get().Log("ECS entity created with ID: " + std::to_string(identity->GetId()), __FILE__, __LINE__);
LOG_INFO("ECS entity created with ID: " + std::to_string(identity->GetId()), __FILE__, __LINE__);
update_stats_after_modification();
}
@@ -1483,7 +1483,7 @@ void application_class::add_kobject(std::wstring& filepath)
void application_class::add_cube()
{
std::lock_guard<std::mutex> lock(objects_mutex_);
Logger::Get().Log("Adding cube", __FILE__, __LINE__);
LOG_INFO("Adding cube", __FILE__, __LINE__);
std::string model_name = "assets/Model/TXT/cube.txt";
std::shared_ptr<model_class> sharedModel;
@@ -1491,7 +1491,7 @@ void application_class::add_cube()
auto it = g_model_cache.find(model_name);
if (it != g_model_cache.end())
{
Logger::Get().Log("Using cached model: " + model_name, __FILE__, __LINE__);
LOG_INFO("Using cached model: " + model_name, __FILE__, __LINE__);
sharedModel = it->second;
}
else
@@ -1507,13 +1507,13 @@ void application_class::add_cube()
auto newModel = std::make_shared<model_class>();
newModel->PreloadTextures(direct_3d_->get_device(), direct_3d_->get_device_context(), cube_textures);
if (!newModel->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), model_filename, cube_textures)) {
Logger::Get().Log("Failed to initialize cube model", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize cube model");
return;
}
g_model_cache[model_name] = newModel;
sharedModel = newModel;
Logger::Get().Log("Added cube model to cache: " + model_name, __FILE__, __LINE__);
LOG_INFO("Added cube model to cache: " + model_name, __FILE__, __LINE__);
if (entity_manager_)
@@ -1538,14 +1538,14 @@ void application_class::add_cube()
}
update_stats_after_modification();
Logger::Get().Log("Cube added successfully", __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Cube added successfully");
}
void application_class::delete_entity_by_id(int entity_id)
{
std::lock_guard<std::mutex> lock(objects_mutex_);
Logger::Get().Log("Deleting entity with ID: " + std::to_string(entity_id), __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Deleting entity with ID: " + std::to_string(entity_id));
if (entity_manager_) {
// Rechercher l'entit<69> avec l'ID sp<73>cifi<66> via le composant IdentityComponent
@@ -1555,7 +1555,7 @@ void application_class::delete_entity_by_id(int entity_id)
if (identity && identity->GetId() == entity_id) {
// Supprimer l'entit<69>
entity_manager_->DestroyEntity(entity->GetID());
Logger::Get().Log("Entity with ID " + std::to_string(entity_id) + " successfully deleted", __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Entity with ID " + std::to_string(entity_id) + " successfully deleted");
break;
}
}
@@ -1567,7 +1567,7 @@ void application_class::delete_entity_by_id(int entity_id)
void application_class::delete_terrain()
{
std::lock_guard<std::mutex> lock(objects_mutex_);
Logger::Get().Log("Deleting terrain", __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Deleting terrain");
// Get all entities with the Terrain type
auto entities_with_terrain = entity_manager_->GetEntitiesWithComponent<ecs::IdentityComponent>();
@@ -1576,7 +1576,7 @@ void application_class::delete_terrain()
if (identity && identity->GetType() == ecs::ObjectType::Terrain) {
// Destroy the entity
entity_manager_->DestroyEntity(entity->GetID());
Logger::Get().Log("Terrain entity with ID " + std::to_string(identity->GetId()) + " successfully deleted", __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Terrain entity with ID " + std::to_string(identity->GetId()) + " successfully deleted");
}
}
@@ -1600,7 +1600,7 @@ bool application_class::update_mouse_strings(int mouseX, int mouseY, bool mouseD
result = mouse_strings_[0].UpdateText(direct_3d_->get_device_context(), font_, finalString, 10, 50, 1.0f, 1.0f, 1.0f);
if (!result)
{
Logger::Get().Log("Could not update the mouse X string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not update the mouse X string");
return false;
}
@@ -1615,7 +1615,7 @@ bool application_class::update_mouse_strings(int mouseX, int mouseY, bool mouseD
result = mouse_strings_[1].UpdateText(direct_3d_->get_device_context(), font_, finalString, 10, 75, 1.0f, 1.0f, 1.0f);
if (!result)
{
Logger::Get().Log("Could not update the mouse Y string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not update the mouse Y string");
return false;
}
@@ -1634,7 +1634,7 @@ bool application_class::update_mouse_strings(int mouseX, int mouseY, bool mouseD
if (!result)
{
Logger::Get().Log("Could not update the mouse button string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not update the mouse button string");
return false;
}
@@ -1707,7 +1707,7 @@ bool application_class::update_fps()
result = fps_string_->UpdateText(direct_3d_->get_device_context(), font_, finalString, 10, 10, red, green, blue);
if (!result)
{
Logger::Get().Log("Could not update the fps string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not update the fps string");
return false;
}
@@ -1731,7 +1731,7 @@ bool application_class::update_render_count_string(int renderCount)
result = render_count_string_->UpdateText(direct_3d_->get_device_context(), font_, finalString, 10, 30, 1.0f, 1.0f, 1.0f);
if (!result)
{
Logger::Get().Log("Could not update the render count string", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not update the render count string");
return false;
}
@@ -1777,20 +1777,20 @@ void application_class::set_light_position(int index, XMVECTOR position)
void application_class::set_screen_height(int height)
{
// log the new screen height
Logger::Get().Log("Setting screen height to " + std::to_string(height), __FILE__, __LINE__);
LOG_INFO("Setting screen height to " + std::to_string(height), __FILE__, __LINE__);
screen_height_ = height;
}
void application_class::set_screen_width(int width)
{
// log the new screen width
Logger::Get().Log("Setting screen width to " + std::to_string(width), __FILE__, __LINE__);
LOG_INFO("Setting screen width to " + std::to_string(width), __FILE__, __LINE__);
screen_width_ = width;
}
void application_class::culling_thread_function()
{
Logger::Get().Log("Thread de culling d<>marr<72>", __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Thread de culling d<>marr<72>");
while (culling_active_)
{
@@ -1838,7 +1838,7 @@ void application_class::culling_thread_function()
std::this_thread::sleep_for(std::chrono::milliseconds(16)); // ~60 Hz
}
Logger::Get().Log("Thread de culling termin<69>", __FILE__, __LINE__, Logger::LogLevel::Info);
LOG_INFO("Thread de culling termin<69>");
}
@@ -1956,7 +1956,7 @@ void application_class::physics_thread_function()
bool result = render_physics(deltaTime);
if (!result)
{
Logger::Get().Log("Could not render the physics scene", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not render the physics scene");
return;
}
}
@@ -1988,7 +1988,7 @@ bool application_class::create_big_cube(int side_count)
textures.specularPaths.push_back(L"assets/Texture/BricksGLOSS2K.png");
newModel->PreloadTextures(direct_3d_->get_device(), direct_3d_->get_device_context(), textures);
if (!newModel->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(),model_file, textures)) {
Logger::Get().Log("Impossible d'initialiser le mod<6F>le du gros cube", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Impossible d'initialiser le mod<6F>le du gros cube");
return false;
}
g_model_cache[modelName] = newModel;
@@ -2077,7 +2077,7 @@ bool application_class::create_skysphere()
auto it = g_model_cache.find(modelKey);
if (it != g_model_cache.end())
{
Logger::Get().Log("Using cached model for sky sphere: " + modelKey, __FILE__, __LINE__);
LOG_INFO("Using cached model for sky sphere: " + modelKey, __FILE__, __LINE__);
sharedModel = it->second;
}
else
@@ -2086,18 +2086,18 @@ bool application_class::create_skysphere()
sharedModel->PreloadTextures(direct_3d_->get_device(), direct_3d_->get_device_context(), textures);
if (!sharedModel->Initialize(direct_3d_->get_device(), direct_3d_->get_device_context(), modelFilename, textures))
{
Logger::Get().Log("Failed to initialize model for sky sphere", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize model for sky sphere");
return false;
}
g_model_cache[modelKey] = sharedModel;
Logger::Get().Log("Added sky sphere model to cache: " + modelKey, __FILE__, __LINE__);
LOG_INFO("Added sky sphere model to cache: " + modelKey, __FILE__, __LINE__);
}
sky_entity_ = entity_manager_->CreateEntity();
if (!sky_entity_)
{
Logger::Get().Log("Failed to create sky entity", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create sky entity");
return false;
}

43
enginecustom/src/src/system/bitmap_class.cpp
View File

@@ -20,7 +20,7 @@ bitmap_class::~bitmap_class()
bool bitmap_class::initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, int screenWidth, int screenHeight, char* textureFilename, int renderX, int renderY)
{
Logger::Get().Log("Initializing bitmap class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing bitmap class");
bool result;
@@ -36,7 +36,7 @@ bool bitmap_class::initialize(ID3D11Device* device, ID3D11DeviceContext* deviceC
result = initialize_buffers(device);
if (!result)
{
Logger::Get().Log("Failed to initialize buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize buffers");
return false;
}
@@ -44,11 +44,11 @@ bool bitmap_class::initialize(ID3D11Device* device, ID3D11DeviceContext* deviceC
result = load_texture(device, deviceContext, textureFilename);
if (!result)
{
Logger::Get().Log("Failed to load texture", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to load texture");
return false;
}
Logger::Get().Log("Bitmap class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Bitmap class initialized");
return true;
}
@@ -68,12 +68,11 @@ bool bitmap_class::render(ID3D11DeviceContext* deviceContext)
{
bool result;
// Update the buffers if the position of the bitmap has changed from its original position.
result = update_buffers(deviceContext);
if (!result)
{
Logger::Get().Log("Failed to update buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to update buffers");
return false;
}
@@ -95,7 +94,7 @@ ID3D11ShaderResourceView* bitmap_class::get_texture()
bool bitmap_class::initialize_buffers(ID3D11Device* device)
{
Logger::Get().Log("Initializing buffers", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing buffers");
vertex_type* vertices;
unsigned long* indices;
@@ -146,7 +145,7 @@ bool bitmap_class::initialize_buffers(ID3D11Device* device)
result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &vertex_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create vertex buffer");
return false;
}
@@ -167,7 +166,7 @@ bool bitmap_class::initialize_buffers(ID3D11Device* device)
result = device->CreateBuffer(&indexBufferDesc, &indexData, &index_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create index buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create index buffer");
return false;
}
@@ -178,34 +177,34 @@ bool bitmap_class::initialize_buffers(ID3D11Device* device)
delete[] indices;
indices = 0;
Logger::Get().Log("Buffers initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Buffers initialized");
return true;
}
void bitmap_class::shutdown_buffers()
{
Logger::Get().Log("Shutting down buffers", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down buffers");
// Release the index buffer.
if (index_buffer_)
{
Logger::Get().Log("Releasing index buffer", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing index buffer");
index_buffer_->Release();
index_buffer_ = 0;
Logger::Get().Log("Index buffer released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Index buffer released");
}
// Release the vertex buffer.
if (vertex_buffer_)
{
Logger::Get().Log("Releasing vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing vertex buffer");
vertex_buffer_->Release();
vertex_buffer_ = 0;
Logger::Get().Log("Vertex buffer released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Vertex buffer released");
}
Logger::Get().Log("Buffers shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Buffers shut down");
return;
}
@@ -268,7 +267,7 @@ bool bitmap_class::update_buffers(ID3D11DeviceContext* deviceContent)
result = deviceContent->Map(vertex_buffer_, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
Logger::Get().Log("Failed to map vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to map vertex buffer");
return false;
}
@@ -324,7 +323,7 @@ bool bitmap_class::load_texture(ID3D11Device* device, ID3D11DeviceContext* devic
result = texture_->Initialize(device, deviceContext, filename);
if (!result)
{
Logger::Get().Log("Failed to initialize texture object", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize texture object");
return false;
}
@@ -337,18 +336,18 @@ bool bitmap_class::load_texture(ID3D11Device* device, ID3D11DeviceContext* devic
void bitmap_class::release_texture()
{
Logger::Get().Log("Releasing texture", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing texture");
// Release the texture object.
if (texture_)
{
Logger::Get().Log("Releasing texture object", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Releasing texture object");
texture_->Shutdown();
delete texture_;
texture_ = 0;
Logger::Get().Log("Texture object released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Texture object released");
}
Logger::Get().Log("Texture released", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Texture released");
return;
}

3
enginecustom/src/src/system/camera_class.cpp
View File

@@ -5,6 +5,7 @@
camera_class::camera_class()
{
LOG_INIT("Initializing camera class");
position_x_ = 0.0f;
position_y_ = 0.0f;
position_z_ = 0.0f;
@@ -12,6 +13,7 @@ camera_class::camera_class()
rotation_x_ = 0.0f;
rotation_y_ = 0.0f;
rotation_z_ = 0.0f;
LOG_INIT("Camera class initialized");
}
@@ -22,6 +24,7 @@ camera_class::camera_class(const camera_class& other)
camera_class::~camera_class()
{
LOG_SHUTDOWN("Camera class destructor called");
}
void camera_class::set_position(float x, float y, float z)

68
enginecustom/src/src/system/d_3d_class.cpp
View File

@@ -6,6 +6,7 @@
d_3d_class::d_3d_class()
{
LOG_INIT("Initializing D3D class constructor");
swap_chain = 0;
device_ = 0;
device_context_ = 0;
@@ -17,6 +18,7 @@ d_3d_class::d_3d_class()
depth_disabled_stencil_state_ = 0;
alpha_enable_blending_state_ = 0;
alpha_disable_blending_state_ = 0;
LOG_INIT("D3D class constructor initialized");
}
@@ -27,12 +29,13 @@ d_3d_class::d_3d_class(const d_3d_class& other)
d_3d_class::~d_3d_class()
{
LOG_SHUTDOWN("D3D class destructor called");
}
bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND hwnd, bool fullscreen, float screenDepth, float screenNear)
{
Logger::Get().Log("Initializing D3Dclass", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing D3Dclass");
HRESULT result;
IDXGIFactory* factory;
@@ -61,7 +64,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = CreateDXGIFactory(__uuidof(IDXGIFactory), (void**)&factory);
if (FAILED(result))
{
Logger::Get().Log("Failed to create DXGIFactory", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create DXGIFactory");
return false;
}
@@ -69,7 +72,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = factory->EnumAdapters(0, &adapter);
if (FAILED(result))
{
Logger::Get().Log("Failed to create adapter", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create adapter");
return false;
}
@@ -77,7 +80,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = adapter->EnumOutputs(0, &adapterOutput);
if (FAILED(result))
{
Logger::Get().Log("Failed to create adapter output", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create adapter output");
return false;
}
@@ -85,7 +88,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, NULL);
if (FAILED(result))
{
Logger::Get().Log("Failed to get display mode list", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to get display mode list");
return false;
}
@@ -93,7 +96,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
displayModeList = new DXGI_MODE_DESC[numModes];
if (!displayModeList)
{
Logger::Get().Log("Failed to create display mode list", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create display mode list");
return false;
}
@@ -101,7 +104,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = adapterOutput->GetDisplayModeList(DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_ENUM_MODES_INTERLACED, &numModes, displayModeList);
if (FAILED(result))
{
Logger::Get().Log("Failed to fill display mode list", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to fill display mode list");
return false;
}
@@ -123,7 +126,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = adapter->GetDesc(&adapterDesc);
if (FAILED(result))
{
Logger::Get().Log("Failed to get adapter description", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to get adapter description");
return false;
}
@@ -134,7 +137,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
error = wcstombs_s(&stringLength, video_card_description_, 128, adapterDesc.Description, 128);
if (error != 0)
{
Logger::Get().Log("Failed to convert video card name to character array", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to convert video card name to character array");
return false;
}
@@ -217,7 +220,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
D3D11_SDK_VERSION, &swapChainDesc, &swap_chain, &device_, NULL, &device_context_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create swap chain, device and device context", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create swap chain, device and device context");
return false;
}
@@ -225,7 +228,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = swap_chain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferPtr);
if (FAILED(result))
{
Logger::Get().Log("Failed to get pointer to back buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to get pointer to back buffer");
return false;
}
@@ -233,7 +236,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = device_->CreateRenderTargetView(backBufferPtr, NULL, &render_target_view_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create render target view", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create render target view");
return false;
}
@@ -261,7 +264,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = device_->CreateTexture2D(&depthBufferDesc, NULL, &depth_stencil_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create texture for depth buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create texture for depth buffer");
return false;
}
@@ -293,7 +296,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = device_->CreateDepthStencilState(&depthStencilDesc, &depth_stencil_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create depth stencil state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create depth stencil state");
return false;
}
@@ -312,7 +315,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = device_->CreateDepthStencilView(depth_stencil_buffer_, &depthStencilViewDesc, &depth_stencil_view_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create depth stencil view", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create depth stencil view");
return false;
}
@@ -335,7 +338,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = device_->CreateRasterizerState(&rasterDesc, &raster_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create rasterizer state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create rasterizer state");
return false;
}
@@ -390,7 +393,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = device_->CreateDepthStencilState(&depthDisabledStencilDesc, &depth_disabled_stencil_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create depth disabled stencil state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create depth disabled stencil state");
return false;
}
@@ -411,7 +414,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = device_->CreateBlendState(&blendStateDescription, &alpha_enable_blending_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create alpha enabled blend state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create alpha enabled blend state");
return false;
}
@@ -422,7 +425,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
result = device_->CreateBlendState(&blendStateDescription, &alpha_disable_blending_state_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create alpha disabled blend state", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create alpha disabled blend state");
return false;
}
@@ -432,8 +435,7 @@ bool d_3d_class::initialize(int screenWidth, int screenHeight, bool vsync, HWND
void d_3d_class::shutdown()
{
Logger::Get().Log("Shutting down D3Dclass", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down D3Dclass");
// Before shutting down set to windowed mode or when you release the swap chain it will throw an exception.
if (swap_chain)
@@ -507,7 +509,7 @@ void d_3d_class::shutdown()
swap_chain = 0;
}
Logger::Get().Log("D3Dclass shutdown", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("D3Dclass shutdown");
return;
}
@@ -592,7 +594,7 @@ void d_3d_class::reset_viewport()
void d_3d_class::release_resources()
{
Logger::Get().Log("Releasing D3D resources", __FILE__, __LINE__);
LOG_SHUTDOWN("Releasing D3D resources");
// libere la vue
if (render_target_view_)
@@ -615,13 +617,13 @@ void d_3d_class::release_resources()
depth_stencil_view_ = 0;
}
Logger::Get().Log("D3D resources released", __FILE__, __LINE__);
LOG_SHUTDOWN("D3D resources released");
}
// Reset the resources for the swap chain
void d_3d_class::reset_resources(int newWidth, int newHeight)
{
Logger::Get().Log("Resetting D3D resources", __FILE__, __LINE__);
LOG_INIT("Resetting D3D resources");
HRESULT result;
@@ -629,21 +631,21 @@ void d_3d_class::reset_resources(int newWidth, int newHeight)
result = swap_chain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBuffer);
if (FAILED(result))
{
Logger::Get().Log("Failed to get back buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to get back buffer");
return;
}
result = device_->CreateRenderTargetView(backBuffer, NULL, &render_target_view_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create render target view", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create render target view");
return;
}
result = backBuffer->Release();
if (FAILED(result))
{
Logger::Get().Log("Failed to release back buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to release back buffer");
return;
}
@@ -672,14 +674,14 @@ void d_3d_class::reset_resources(int newWidth, int newHeight)
result = device_->CreateTexture2D(&depthBufferDesc, NULL, &depth_stencil_buffer_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create depth stencil buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create depth stencil buffer");
return;
}
result = device_->CreateDepthStencilView(depth_stencil_buffer_, &depthStencilViewDesc, &depth_stencil_view_);
if (FAILED(result))
{
Logger::Get().Log("Failed to create depth stencil view", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to create depth stencil view");
return;
}
@@ -694,9 +696,7 @@ IDXGISwapChain* d_3d_class::get_swap_chain()
void d_3d_class::resize_swap_chain(int newWidth, int newHeight)
{
// log the new width and height
Logger::Get().Log("Resizing swap chain to " + std::to_string(newWidth) + "x" + std::to_string(newHeight), __FILE__, __LINE__);
LOG_INFO("Resizing swap chain to " + std::to_string(newWidth) + "x" + std::to_string(newHeight));
HRESULT result;
@@ -708,7 +708,7 @@ void d_3d_class::resize_swap_chain(int newWidth, int newHeight)
result = swap_chain->ResizeBuffers(0, newWidth, newHeight, DXGI_FORMAT_UNKNOWN, 0);
if (FAILED(result))
{
Logger::Get().Log("Failed to resize swap chain", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to resize swap chain");
return;
}

26
enginecustom/src/src/system/display_plane_class.cpp
View File

@@ -3,8 +3,10 @@
display_plane_class::display_plane_class()
{
LOG_INIT("Initializing display_plane_class constructor");
m_vertexBuffer = 0;
m_indexBuffer = 0;
LOG_INIT("Display_plane_class constructor initialized");
}
@@ -15,11 +17,12 @@ display_plane_class::display_plane_class(const display_plane_class& other)
display_plane_class::~display_plane_class()
{
LOG_SHUTDOWN("Display_plane_class destructor called");
}
bool display_plane_class::Initialize(ID3D11Device* device, float width, float height)
{
Logger::Get().Log("Initializing display_plane_class, width: " + std::to_string(width) + ", height: " + std::to_string(height), __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing display_plane_class, width: " + std::to_string(width) + ", height: " + std::to_string(height));
bool result;
@@ -27,18 +30,21 @@ bool display_plane_class::Initialize(ID3D11Device* device, float width, float he
result = InitializeBuffers(device, width, height);
if (!result)
{
Logger::Get().Log("Could not initialize buffers", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not initialize buffers");
return false;
}
LOG_INIT("Display_plane_class initialized");
return true;
}
void display_plane_class::Shutdown()
{
LOG_SHUTDOWN("Shutting down display_plane_class");
// Release the vertex and index buffers.
ShutdownBuffers();
LOG_SHUTDOWN("Display_plane_class shut down");
return;
}
@@ -60,7 +66,7 @@ int display_plane_class::GetIndexCount()
bool display_plane_class::InitializeBuffers(ID3D11Device* device, float width, float height)
{
Logger::Get().Log("Initializing buffers", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing buffers");
VertexType* vertices;
unsigned long* indices;
@@ -126,7 +132,7 @@ bool display_plane_class::InitializeBuffers(ID3D11Device* device, float width, f
result = device->CreateBuffer(&vertexBufferDesc, &vertexData, &m_vertexBuffer);
if (FAILED(result))
{
Logger::Get().Log("Could not create vertex buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not create vertex buffer");
return false;
}
@@ -147,7 +153,7 @@ bool display_plane_class::InitializeBuffers(ID3D11Device* device, float width, f
result = device->CreateBuffer(&indexBufferDesc, &indexData, &m_indexBuffer);
if (FAILED(result))
{
Logger::Get().Log("Could not create index buffer", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Could not create index buffer");
return false;
}
@@ -158,7 +164,7 @@ bool display_plane_class::InitializeBuffers(ID3D11Device* device, float width, f
delete[] indices;
indices = 0;
Logger::Get().Log("Buffers initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Buffers initialized");
return true;
}
@@ -166,23 +172,27 @@ bool display_plane_class::InitializeBuffers(ID3D11Device* device, float width, f
void display_plane_class::ShutdownBuffers()
{
Logger::Get().Log("Shutting down Plane buffers", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Shutting down Plane buffers");
// Release the index buffer.
if (m_indexBuffer)
{
LOG_SHUTDOWN("Releasing index buffer");
m_indexBuffer->Release();
m_indexBuffer = 0;
LOG_SHUTDOWN("Index buffer released");
}
// Release the vertex buffer.
if (m_vertexBuffer)
{
LOG_SHUTDOWN("Releasing vertex buffer");
m_vertexBuffer->Release();
m_vertexBuffer = 0;
LOG_SHUTDOWN("Vertex buffer released");
}
Logger::Get().Log("Plane buffers shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
LOG_SHUTDOWN("Plane buffers shut down");
return;
}

35
enginecustom/src/src/system/font_class.cpp
View File

@@ -2,8 +2,10 @@
font_class::font_class()
{
LOG_INIT("Initializing font class constructor");
m_Font = 0;
m_Texture = 0;
LOG_INIT("Font class constructor initialized");
}
@@ -14,11 +16,12 @@ font_class::font_class(const font_class& other)
font_class::~font_class()
{
LOG_SHUTDOWN("Font class destructor called");
}
bool font_class::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceContext, int fontChoice)
{
Logger::Get().Log("Initializing font class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Initializing font class");
char fontFilename[128];
char fontTextureFilename[128];
@@ -49,7 +52,7 @@ bool font_class::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceCon
result = LoadFontData(fontFilename);
if (!result)
{
Logger::Get().Log("Failed to load font data", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to load font data");
return false;
}
@@ -57,29 +60,31 @@ bool font_class::Initialize(ID3D11Device* device, ID3D11DeviceContext* deviceCon
result = LoadTexture(device, deviceContext, fontTextureFilename);
if (!result)
{
Logger::Get().Log("Failed to load font texture", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to load font texture");
return false;
}
Logger::Get().Log("Font class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
LOG_INIT("Font class initialized");
return true;
}
void font_class::Shutdown()
{
LOG_SHUTDOWN("Shutting down font class");
// Release the font texture.
ReleaseTexture();
// Release the font data.
ReleaseFontData();
LOG_SHUTDOWN("Font class shut down");
return;
}
bool font_class::LoadFontData(char* filename)
{
Logger::Get().Log(("Loading font data from %s", filename), __FILE__, __LINE__);
LOG_INFO("Loading font data from " + std::string(filename));
std::ifstream fin;
int i;
@@ -92,7 +97,7 @@ bool font_class::LoadFontData(char* filename)
fin.open(filename);
if (fin.fail())
{
Logger::Get().Log("Failed to open font file", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to open font file");
return false;
}
@@ -118,26 +123,31 @@ bool font_class::LoadFontData(char* filename)
// Close the file.
fin.close();
Logger::Get().Log("Font data loaded", __FILE__, __LINE__);
LOG_INFO("Font data loaded");
return true;
}
void font_class::ReleaseFontData()
{
LOG_SHUTDOWN("Releasing font data");
// Release the font data array.
if (m_Font)
{
LOG_SHUTDOWN("Releasing font array");
delete[] m_Font;
m_Font = 0;
LOG_SHUTDOWN("Font array released");
}
LOG_SHUTDOWN("Font data released");
return;
}
bool font_class::LoadTexture(ID3D11Device* device, ID3D11DeviceContext* deviceContext, char* filename)
{
Logger::Get().Log(("Loading font texture from %s", filename), __FILE__, __LINE__);
LOG_INFO("Loading font texture from " + std::string(filename));
bool result;
@@ -148,25 +158,30 @@ bool font_class::LoadTexture(ID3D11Device* device, ID3D11DeviceContext* deviceCo
result = m_Texture->Initialize(device, deviceContext, filename);
if (!result)
{
Logger::Get().Log("Failed to initialize font texture", __FILE__, __LINE__, Logger::LogLevel::Error);
LOG_ERROR("Failed to initialize font texture");
return false;
}
Logger::Get().Log("Font texture loaded", __FILE__, __LINE__);
LOG_INFO("Font texture loaded");
return true;
}
void font_class::ReleaseTexture()
{
LOG_SHUTDOWN("Releasing font texture");
// Release the texture object.
if (m_Texture)
{
LOG_SHUTDOWN("Releasing texture object");
m_Texture->Shutdown();
delete m_Texture;
m_Texture = 0;
LOG_SHUTDOWN("Texture object released");
}
LOG_SHUTDOWN("Font texture released");
return;
}