# Khaotic Engine Reborn: shader_manager_class Class Reference

Loading...
Searching...
No Matches
shader_manager_class Class Reference

## Public Member Functions

| shader_manager_class (const shader_manager_class &)
bool | initialize (ID3D11Device *, HWND)
void | shutdown ()
bool | render_texture_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *)
bool | render_normal_map_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, ID3D11ShaderResourceView *, XMFLOAT3, XMFLOAT4)
bool | render_multitexture_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, ID3D11ShaderResourceView *)
bool | render_translate_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, float)
bool | render_alpha_map_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, ID3D11ShaderResourceView *, ID3D11ShaderResourceView *)
bool | render_spec_map_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, ID3D11ShaderResourceView *, ID3D11ShaderResourceView *, XMFLOAT3, XMFLOAT4, XMFLOAT3, XMFLOAT4, float)
bool | render_transparent_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, float)
bool | renderlight_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, XMFLOAT4[], XMFLOAT4[], XMFLOAT4[])
bool | renderlight_map_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, ID3D11ShaderResourceView *)
bool | render_refraction_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, XMFLOAT3, XMFLOAT4[], XMFLOAT4[], XMFLOAT4[], XMFLOAT4)
bool | render_water_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, ID3D11ShaderResourceView *, ID3D11ShaderResourceView *, float, float)
bool | render_cel_shading_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, XMFLOAT4, XMFLOAT4, XMFLOAT3, float)
bool | render_sunlight_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, XMFLOAT4, XMFLOAT4, XMFLOAT3, float)
bool | render_skybox_shader (ID3D11DeviceContext *, int, XMMATRIX, XMMATRIX, XMMATRIX, ID3D11ShaderResourceView *, XMFLOAT4, XMFLOAT4, XMFLOAT3, float)
bool | render_depth_shader (ID3D11DeviceContext *context, int indexCount, XMMATRIX worldMatrix, XMMATRIX viewMatrix, XMMATRIX projectionMatrix, ID3D11ShaderResourceView *texture)

## Detailed Description

Definition at line 27 of file shader_manager_class.h.

## Constructor & Destructor Documentation

## shader_manager_class() [1/2]

shader_manager_class::shader_manager_class | ( |  | ) |

Definition at line 3 of file shader_manager_class.cpp.

{
texture_shader_ = 0;
normal_map_shader_ = 0;
multitexture_shader_ = 0;
translate_shader_ = 0;
alpha_map_shader_ = 0;
spec_map_shader_ = 0;
transparent_shader_ = 0;
light_shader_ = 0;
light_map_shader_ = 0;
refraction_shader_ = 0;
water_shader_ = 0;
cel_shading_shader_ = 0;
sunlight_shader_ = 0;
skybox_shader_ = 0;
refraction_shader_ = 0;
depth_shader_ = 0;
}

## shader_manager_class() [2/2]

shader_manager_class::shader_manager_class | ( | const shader_manager_class & | other | ) |

Definition at line 23 of file shader_manager_class.cpp.

{
}

## ~shader_manager_class()

shader_manager_class::~shader_manager_class | ( |  | ) |

Definition at line 27 of file shader_manager_class.cpp.

{
}

## Member Function Documentation

## initialize()

bool shader_manager_class::initialize | ( | ID3D11Device * | device,
|  | HWND | hwnd )

Definition at line 31 of file shader_manager_class.cpp.

{
Logger::Get().Log("Initializing shader_manager_class", __FILE__, __LINE__, Logger::LogLevel::Initialize);
bool result;
// Create and initialize the texture shader object.
texture_shader_ = new texture_shader_class;
result = texture_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing texture_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create and initialize the normal map shader object.
normal_map_shader_ = new normal_map_shader_class;
result = normal_map_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing normal_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create and initialize the multitexture shader object.
multitexture_shader_ = new multi_texture_shader_class;
result = multitexture_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing multi_texture_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create and initialize the translate shader object.
translate_shader_ = new translate_shader_class;
result = translate_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing translate_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create and initialize the alpha map shader object.
alpha_map_shader_ = new alpha_map_shader_class;
result = alpha_map_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing alpha_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create and initialize the specular map shader object.
spec_map_shader_ = new spec_map_shader_class;
result = spec_map_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing spec_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create and initialize the transparent shader object.
transparent_shader_ = new transparent_shader_class;
result = transparent_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing transparent_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create and initialize the light shader object.
light_shader_ = new light_shader_class;
result = light_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing light_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create and initialize the light map shader object.
light_map_shader_ = new light_map_shader_class;
result = light_map_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing light_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
// Create and initialize the refraction shader object.
refraction_shader_ = new refraction_shader_class;
result = refraction_shader_->initialize(device, hwnd);
if (!result)
{
return false;
}
// Create and initialize the water shader object.
water_shader_ = new water_shader_class;
result = water_shader_->initialize(device, hwnd);
if (!result)
{
return false;
}
cel_shading_shader_ = new celshade_class;
result = cel_shading_shader_->initialize(device, hwnd);
if (!result)
{
return false;
}
sunlight_shader_ = new sunlight_shader_class;
result = sunlight_shader_->initialize(device, hwnd);
if (!result)
{
return false;
}
skybox_shader_ = new skybox_shader_class;
result = skybox_shader_->Initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing skybox_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
depth_shader_ = new depth_shader_class;
result = depth_shader_->initialize(device, hwnd);
if (!result)
{
Logger::Get().Log("Error initializing depth_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
Logger::Get().Log("shader_manager_class initialized", __FILE__, __LINE__, Logger::LogLevel::Initialize);
return true;
}
alpha_map_shader_class
Definition alpha_map_shader_class.h:21
celshade_class
Definition celshade_class.h:12
depth_shader_class
Definition depth_shader_class.h:21
light_map_shader_class
Definition light_map_shader_class.h:22
light_shader_class
Definition light_shader_class.h:28
multi_texture_shader_class
Definition multi_texture_shader_class.h:24
normal_map_shader_class
Definition normal_map_shader_class.h:21
refraction_shader_class
Definition refraction_shader_class.h:20
skybox_shader_class
Definition skybox_shader_class.h:12
spec_map_shader_class
Definition spec_map_shader_class.h:20
sunlight_shader_class
Definition sunlight_shader_class.h:12
texture_shader_class
Definition texture_shader_class.h:21
translate_shader_class
Definition translate_shader_class.h:21
transparent_shader_class
Definition transparent_shader_class.h:21
water_shader_class
Definition water_shader_class.h:20

## render_alpha_map_shader()

bool shader_manager_class::render_alpha_map_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture1,
|  | ID3D11ShaderResourceView * | texture2,
|  | ID3D11ShaderResourceView * | texture3 )

Definition at line 353 of file shader_manager_class.cpp.

{
bool result;
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);
return false;
}
return true;
}

## render_cel_shading_shader()

bool shader_manager_class::render_cel_shading_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture,
|  | XMFLOAT4 | diffuseColor,
|  | XMFLOAT4 | ambientColor,
|  | XMFLOAT3 | sunDirection,
|  | float | sunIntensity )

Definition at line 458 of file shader_manager_class.cpp.

{
bool result;
result = cel_shading_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, ambientColor, sunDirection, sunIntensity);
if (!result)
{
return false;
}
return true;
}

## render_depth_shader()

bool shader_manager_class::render_depth_shader | ( | ID3D11DeviceContext * | context,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture )

Definition at line 500 of file shader_manager_class.cpp.

{
bool result;
result = depth_shader_->render(context, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture);
if (!result)
{
return false;
}
return true;
}

## render_multitexture_shader()

bool shader_manager_class::render_multitexture_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture1,
|  | ID3D11ShaderResourceView * | texture2 )

Definition at line 323 of file shader_manager_class.cpp.

{
bool result;
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);
return false;
}
return true;
}

## render_normal_map_shader()

bool shader_manager_class::render_normal_map_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | colorTexture,
|  | ID3D11ShaderResourceView * | normalTexture,
|  | XMFLOAT3 | lightDirection,
|  | XMFLOAT4 | diffuseColor )

Definition at line 308 of file shader_manager_class.cpp.

{
bool result;
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);
return false;
}
return true;
}

## render_refraction_shader()

bool shader_manager_class::render_refraction_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture,
|  | XMFLOAT3 | lightDirection,
|  | XMFLOAT4 | ambientColor[],
|  | XMFLOAT4 | diffuseColor[],
|  | XMFLOAT4 | lightPosition[],
|  | XMFLOAT4 | clipPlane )

Definition at line 428 of file shader_manager_class.cpp.

{
bool result;
result = refraction_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, lightDirection, ambientColor, diffuseColor, lightPosition, clipPlane);
if (!result)
{
return false;
}
return true;
}

## render_skybox_shader()

bool shader_manager_class::render_skybox_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture,
|  | XMFLOAT4 | diffuseColor,
|  | XMFLOAT4 | ambientColor,
|  | XMFLOAT3 | sunDirection,
|  | float | sunIntensity )

Definition at line 486 of file shader_manager_class.cpp.

{
bool result;
result = skybox_shader_->Render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, ambientColor, sunDirection, sunIntensity);
if (!result)
{
return false;
}
return true;
}

## render_spec_map_shader()

bool shader_manager_class::render_spec_map_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture1,
|  | ID3D11ShaderResourceView * | texture2,
|  | ID3D11ShaderResourceView * | texture3,
|  | XMFLOAT3 | lightDirection,
|  | XMFLOAT4 | diffuseColor,
|  | XMFLOAT3 | cameraPosition,
|  | XMFLOAT4 | specularColor,
|  | float | specularPower )

Definition at line 368 of file shader_manager_class.cpp.

{
bool result;
result = spec_map_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2, texture3, lightDirection,
diffuseColor, cameraPosition, specularColor, specularPower);
if (!result)
{
Logger::Get().Log("Error rendering spec_map_shader_class", __FILE__, __LINE__, Logger::LogLevel::Error);
return false;
}
return true;
}

## render_sunlight_shader()

bool shader_manager_class::render_sunlight_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture,
|  | XMFLOAT4 | diffuseColor,
|  | XMFLOAT4 | ambientColor,
|  | XMFLOAT3 | sunDirection,
|  | float | sunIntensity )

Definition at line 472 of file shader_manager_class.cpp.

{
bool result;
result = sunlight_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, ambientColor, sunDirection, sunIntensity);
if (!result)
{
return false;
}
return true;
}

## render_texture_shader()

bool shader_manager_class::render_texture_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture )

Definition at line 293 of file shader_manager_class.cpp.

{
bool result;
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);
return false;
}
return true;
}

## render_translate_shader()

bool shader_manager_class::render_translate_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture1,
|  | float | valeur )

Definition at line 338 of file shader_manager_class.cpp.

{
bool result;
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);
return false;
}
return true;
}

## render_transparent_shader()

bool shader_manager_class::render_transparent_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture1,
|  | float | blendAmount )

Definition at line 385 of file shader_manager_class.cpp.

{
bool result;
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);
return false;
}
return true;
}

## render_water_shader()

bool shader_manager_class::render_water_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | XMMATRIX | reflectionMatrix,
|  | ID3D11ShaderResourceView * | reflectionTexture,
|  | ID3D11ShaderResourceView * | refractionTexture,
|  | ID3D11ShaderResourceView * | normalTexture,
|  | float | waterTranslation,
|  | float | reflectRefractScale )

Definition at line 442 of file shader_manager_class.cpp.

{
bool result;
result = water_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, reflectionMatrix, reflectionTexture,
refractionTexture, normalTexture, waterTranslation, reflectRefractScale);
if (!result)
{
return false;
}
return true;
}

## renderlight_map_shader()

bool shader_manager_class::renderlight_map_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture1,
|  | ID3D11ShaderResourceView * | texture2 )

Definition at line 414 of file shader_manager_class.cpp.

{
bool result;
result = light_map_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture1, texture2);
if (!result)
{
return false;
}
return true;
}

## renderlight_shader()

bool shader_manager_class::renderlight_shader | ( | ID3D11DeviceContext * | deviceContext,
|  | int | indexCount,
|  | XMMATRIX | worldMatrix,
|  | XMMATRIX | viewMatrix,
|  | XMMATRIX | projectionMatrix,
|  | ID3D11ShaderResourceView * | texture,
|  | XMFLOAT4 | diffuseColor[],
|  | XMFLOAT4 | lightPosition[],
|  | XMFLOAT4 | ambientColor[] )

Definition at line 400 of file shader_manager_class.cpp.

{
bool result;
result = light_shader_->render(deviceContext, indexCount, worldMatrix, viewMatrix, projectionMatrix, texture, diffuseColor, lightPosition, ambientColor);
if (!result)
{
return false;
}
return true;
}

## shutdown()

void shader_manager_class::shutdown | ( |  | ) |

Definition at line 169 of file shader_manager_class.cpp.

{
Logger::Get().Log("Shutting down shader_manager_class", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
// Release the normal map shader object.
if (normal_map_shader_)
{
normal_map_shader_->shutdown();
delete normal_map_shader_;
normal_map_shader_ = 0;
}
// Release the texture shader object.
if (texture_shader_)
{
texture_shader_->shutdown();
delete texture_shader_;
texture_shader_ = 0;
}
// Release the multitexture shader object.
if (multitexture_shader_)
{
multitexture_shader_->shutdown();
delete multitexture_shader_;
multitexture_shader_ = 0;
}
// Release the translate shader object.
if (translate_shader_)
{
translate_shader_->shutdown();
delete translate_shader_;
translate_shader_ = 0;
}
// Release the alpha map shader object.
if (alpha_map_shader_)
{
alpha_map_shader_->shutdown();
delete alpha_map_shader_;
alpha_map_shader_ = 0;
}
// Release the specular map shader object.
if (spec_map_shader_)
{
spec_map_shader_->shutdown();
delete spec_map_shader_;
spec_map_shader_ = 0;
}
// Release the transparent shader object.
if (transparent_shader_)
{
transparent_shader_->shutdown();
delete transparent_shader_;
transparent_shader_ = 0;
}
// Release the light shader object.
if (light_shader_)
{
light_shader_->shutdown();
delete light_shader_;
light_shader_ = 0;
}
// Release the light map shader object.
if (light_map_shader_)
{
light_map_shader_->shutdown();
delete light_map_shader_;
light_map_shader_ = 0;
}
// Release the refraction shader object.
if (refraction_shader_)
{
refraction_shader_->shutdown();
delete refraction_shader_;
refraction_shader_ = 0;
}
// Release the water shader object.
if (water_shader_)
{
water_shader_->shutdown();
delete water_shader_;
water_shader_ = 0;
}
// Release the cel shading shader object.
if (cel_shading_shader_)
{
cel_shading_shader_->shutdown();
delete cel_shading_shader_;
cel_shading_shader_ = 0;
}
if (sunlight_shader_)
{
sunlight_shader_->shutdown();
delete sunlight_shader_;
sunlight_shader_ = 0;
}
if (skybox_shader_)
{
skybox_shader_->Shutdown();
delete skybox_shader_;
skybox_shader_ = 0;
}
if (depth_shader_)
{
depth_shader_->shutdown();
delete depth_shader_;
depth_shader_ = 0;
}
Logger::Get().Log("shader_manager_class shut down", __FILE__, __LINE__, Logger::LogLevel::Shutdown);
}

The documentation for this class was generated from the following files:

- enginecustom/src/inc/shader/shader_manager_class.h
- enginecustom/src/src/shader/shader_manager_class.cpp