Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-04-28 15:57:59 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fixed postprocessing order and precompile shaders to speed-up loading

Browse source
This commit is contained in:
Lwmte 2024-12-22 20:42:06 +01:00
parent b75d14184f
commit 7249533290
17 changed files with 443 additions and 446 deletions
Download patch file Download diff file Expand all files Collapse all files

1
CHANGELOG.md
View file

@ -9,6 +9,7 @@ TombEngine releases are located in this repository (alongside with Tomb Editor):
* Significantly improved renderer performance.
* Improved engine performance around bridges.
* Improved engine performance if weather or bubble effects are active.
* Improved engine start-up time.
* Fixed silent crashes if loaded level is corrupted or in incorrect format.
* Fixed occasional crashes if there are static meshes placed within room border walls.
* Fixed climbable pushables clipping Lara under the bridges when pulled.

105
TombEngine/Renderer/Renderer.h
View file

@ -65,6 +65,7 @@
#include "Renderer/Structures/RendererRoomAmbientMap.h"
#include "Renderer/Structures/RendererObject.h"
#include "Renderer/Structures/RendererStar.h"
#include "Structures/RendererShader.h"
enum GAME_OBJECT_ID : short;
enum class SphereSpaceType;
@ -124,43 +125,31 @@ namespace TEN::Renderer
// Shaders
ComPtr<ID3D11VertexShader> _vsRooms;
ComPtr<ID3D11VertexShader> _vsRoomsAnimatedTextures;
ComPtr<ID3D11PixelShader> _psRooms;
ComPtr<ID3D11PixelShader> _psRoomsTransparent;
ComPtr<ID3D11VertexShader> _vsItems;
ComPtr<ID3D11PixelShader> _psItems;
ComPtr<ID3D11VertexShader> _vsStatics;
ComPtr<ID3D11PixelShader> _psStatics;
ComPtr<ID3D11VertexShader> _vsSky;
ComPtr<ID3D11PixelShader> _psSky;
ComPtr<ID3D11VertexShader> _vsSprites;
ComPtr<ID3D11PixelShader> _psSprites;
ComPtr<ID3D11VertexShader> _vsInstancedSprites;
ComPtr<ID3D11PixelShader> _psInstancedSprites;
ComPtr<ID3D11VertexShader> _vsInstancedStaticMeshes;
ComPtr<ID3D11PixelShader> _psInstancedStaticMeshes;
ComPtr<ID3D11VertexShader> _vsSolid;
ComPtr<ID3D11PixelShader> _psSolid;
ComPtr<ID3D11VertexShader> _vsInventory;
ComPtr<ID3D11PixelShader> _psInventory;
ComPtr<ID3D11VertexShader> _vsFullScreenQuad;
ComPtr<ID3D11PixelShader> _psFullScreenQuad;
ComPtr<ID3D11VertexShader> _vsShadowMap;
ComPtr<ID3D11PixelShader> _psShadowMap;
ComPtr<ID3D11VertexShader> _vsHUD;
ComPtr<ID3D11PixelShader> _psHUDColor;
ComPtr<ID3D11PixelShader> _psHUDTexture;
ComPtr<ID3D11PixelShader> _psHUDBarColor;
ComPtr<ID3D11VertexShader> _vsGBufferRooms;
ComPtr<ID3D11VertexShader> _vsGBufferRoomsAnimated;
ComPtr<ID3D11VertexShader> _vsGBufferItems;
ComPtr<ID3D11VertexShader> _vsGBufferStatics;
ComPtr<ID3D11VertexShader> _vsGBufferInstancedStatics;
ComPtr<ID3D11PixelShader> _psGBuffer;
ComPtr<ID3D11VertexShader> _vsRoomAmbient;
ComPtr<ID3D11VertexShader> _vsRoomAmbientSky;
ComPtr<ID3D11PixelShader> _psRoomAmbient;
RendererShader _sRooms;
RendererShader _sRoomsAnimated;
RendererShader _sRoomsTransparent;
RendererShader _sRoomAmbient;
RendererShader _sRoomAmbientSky;
RendererShader _sItems;
RendererShader _sStatics;
RendererShader _sInstancedStatics;
RendererShader _sSprites;
RendererShader _sInstancedSprites;
RendererShader _sSky;
RendererShader _sSolid;
RendererShader _sInventory;
RendererShader _sFullScreenQuad;
RendererShader _sShadowMap;
RendererShader _sHUD;
RendererShader _sHUDColor;
RendererShader _sHUDTexture;
RendererShader _sHUDBarColor;
RendererShader _sGBuffer;
RendererShader _sGBufferRooms;
RendererShader _sGBufferRoomsAnimated;
RendererShader _sGBufferItems;
RendererShader _sGBufferStatics;
RendererShader _sGBufferInstancedStatics;
// Constant buffers
@ -352,17 +341,13 @@ namespace TEN::Renderer
RenderTarget2D _SMAAEdgesRenderTarget;
RenderTarget2D _SMAABlendRenderTarget;
ComPtr<ID3D11VertexShader> _SMAAEdgeDetectionVS;
ComPtr<ID3D11PixelShader> _SMAALumaEdgeDetectionPS;
ComPtr<ID3D11PixelShader> _SMAAColorEdgeDetectionPS;
ComPtr<ID3D11PixelShader> _SMAADepthEdgeDetectionPS;
ComPtr<ID3D11VertexShader> _SMAABlendingWeightCalculationVS;
ComPtr<ID3D11PixelShader> _SMAABlendingWeightCalculationPS;
ComPtr<ID3D11VertexShader> _SMAANeighborhoodBlendingVS;
ComPtr<ID3D11PixelShader> _SMAANeighborhoodBlendingPS;
ComPtr<ID3D11VertexShader> _vsFXAA;
ComPtr<ID3D11PixelShader> _psFXAA;
RendererShader _sSMAAEdgeDetection;
RendererShader _sSMAALumaEdgeDetection;
RendererShader _sSMAAColorEdgeDetection;
RendererShader _sSMAADepthEdgeDetection;
RendererShader _sSMAABlendingWeightCalculation;
RendererShader _sSMAANeighborhoodBlending;
RendererShader _sFXAA;
// Post-process
@ -372,27 +357,27 @@ namespace TEN::Renderer
VertexBuffer<PostProcessVertex> _fullscreenTriangleVertexBuffer;
ComPtr<ID3D11InputLayout> _fullscreenTriangleInputLayout = nullptr;
ComPtr<ID3D11VertexShader> _vsPostProcess;
ComPtr<ID3D11PixelShader> _psPostProcessCopy;
ComPtr<ID3D11PixelShader> _psPostProcessMonochrome;
ComPtr<ID3D11PixelShader> _psPostProcessNegative;
ComPtr<ID3D11PixelShader> _psPostProcessExclusion;
ComPtr<ID3D11PixelShader> _psPostProcessFinalPass;
ComPtr<ID3D11PixelShader> _psPostProcessLensFlare;
RendererShader _sPostProcess;
RendererShader _sPostProcessMonochrome;
RendererShader _sPostProcessNegative;
RendererShader _sPostProcessExclusion;
RendererShader _sPostProcessFinalPass;
RendererShader _sPostProcessLensFlare;
bool _doingFullscreenPass = false;
// SSAO
ComPtr<ID3D11VertexShader> _vsSSAO;
ComPtr<ID3D11PixelShader> _psSSAO;
ComPtr<ID3D11PixelShader> _psSSAOBlur;
Texture2D _SSAONoiseTexture;
RenderTarget2D _SSAORenderTarget;
RenderTarget2D _SSAOBlurredRenderTarget;
std::vector<Vector4> _SSAOKernel;
RendererShader _sSSAO;
RendererShader _sSSAOBlur;
// New ambient light techinque
RenderTarget2D _roomAmbientMapFront;
RenderTarget2D _roomAmbientMapBack;
@ -411,11 +396,13 @@ namespace TEN::Renderer
// High framerate.
float _interpolationFactor = 0.0f;
bool _graphicsSettingsChanged = false;
// Private functions
RendererShader CompileOrLoadShader(const std::string& fileName, const std::string& funcName, ShaderType type, const D3D_SHADER_MACRO* defines = nullptr);
void BindShader(const RendererShader& shader);
void ApplySMAA(RenderTarget2D* renderTarget, RenderView& view);
void ApplyFXAA(RenderTarget2D* renderTarget, RenderView& view);
void BindTexture(TextureRegister registerType, TextureBase* texture, SamplerStateRegister samplerType);

18
TombEngine/Renderer/RendererAntialiasing.cpp
View file

@ -14,7 +14,7 @@ namespace TEN::Renderer
ResetScissor();
// Common vertex shader to all fullscreen effects
_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
BindShader(_sPostProcess);
// We draw a fullscreen triangle
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@ -30,7 +30,6 @@ namespace TEN::Renderer
_context->ClearRenderTargetView(_SMAASceneRenderTarget.RenderTargetView.Get(), clearColor);
_context->OMSetRenderTargets(1, _SMAASceneRenderTarget.RenderTargetView.GetAddressOf(), nullptr);
_context->PSSetShader(_psPostProcessCopy.Get(), nullptr, 0);
BindRenderTargetAsTexture(TextureRegister::ColorMap, renderTarget, SamplerStateRegister::PointWrap);
DrawTriangles(3, 0);
@ -41,8 +40,8 @@ namespace TEN::Renderer
SetCullMode(CullMode::CounterClockwise);
_context->OMSetRenderTargets(1, _SMAAEdgesRenderTarget.RenderTargetView.GetAddressOf(), nullptr);
_context->VSSetShader(_SMAAEdgeDetectionVS.Get(), nullptr, 0);
_context->PSSetShader(_SMAAColorEdgeDetectionPS.Get(), nullptr, 0);
BindShader(_sSMAAEdgeDetection);
BindShader(_sSMAAColorEdgeDetection);
_stSMAABuffer.BlendFactor = 1.0f;
_cbSMAABuffer.UpdateData(_stSMAABuffer, _context.Get());
@ -60,8 +59,7 @@ namespace TEN::Renderer
// 2) Blend weights calculation.
_context->OMSetRenderTargets(1, _SMAABlendRenderTarget.RenderTargetView.GetAddressOf(), nullptr);
_context->VSSetShader(_SMAABlendingWeightCalculationVS.Get(), nullptr, 0);
_context->PSSetShader(_SMAABlendingWeightCalculationPS.Get(), nullptr, 0);
BindShader(_sSMAABlendingWeightCalculation);
_stSMAABuffer.SubsampleIndices = Vector4::Zero;
_cbSMAABuffer.UpdateData(_stSMAABuffer, _context.Get());
@ -78,8 +76,7 @@ namespace TEN::Renderer
// 3) Neighborhood blending.
_context->OMSetRenderTargets(1, renderTarget->RenderTargetView.GetAddressOf(), nullptr);
_context->VSSetShader(_SMAANeighborhoodBlendingVS.Get(), nullptr, 0);
_context->PSSetShader(_SMAANeighborhoodBlendingPS.Get(), nullptr, 0);
BindShader(_sSMAANeighborhoodBlending);
BindRenderTargetAsTexture(static_cast<TextureRegister>(0), &_SMAASceneRenderTarget, SamplerStateRegister::LinearClamp);
BindRenderTargetAsTexture(static_cast<TextureRegister>(1), &_SMAASceneSRGBRenderTarget, SamplerStateRegister::LinearClamp);
@ -103,7 +100,7 @@ namespace TEN::Renderer
ResetScissor();
// Common vertex shader to all fullscreen effects
_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
BindShader(_sPostProcess);
// We draw a fullscreen triangle
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@ -119,7 +116,6 @@ namespace TEN::Renderer
_context->ClearRenderTargetView(_tempRenderTarget.RenderTargetView.Get(), clearColor);
_context->OMSetRenderTargets(1, _tempRenderTarget.RenderTargetView.GetAddressOf(), nullptr);
_context->PSSetShader(_psPostProcessCopy.Get(), nullptr, 0);
BindRenderTargetAsTexture(TextureRegister::ColorMap, renderTarget, SamplerStateRegister::PointWrap);
DrawTriangles(3, 0);
@ -127,7 +123,7 @@ namespace TEN::Renderer
_context->ClearRenderTargetView(renderTarget->RenderTargetView.Get(), Colors::Black);
_context->OMSetRenderTargets(1, renderTarget->RenderTargetView.GetAddressOf(), nullptr);
_context->PSSetShader(_psFXAA.Get(), nullptr, 0);
BindShader(_sFXAA);
_stPostProcessBuffer.ViewportWidth = _screenWidth;
_stPostProcessBuffer.ViewportHeight = _screenHeight;

125
TombEngine/Renderer/RendererDraw.cpp
View file

@ -167,8 +167,7 @@ namespace TEN::Renderer
UINT offset = 0;
// Set shaders
_context->VSSetShader(_vsShadowMap.Get(), nullptr, 0);
_context->PSSetShader(_psShadowMap.Get(), nullptr, 0);
BindShader(_sShadowMap);
_context->IASetVertexBuffers(0, 1, _moveablesVertexBuffer.Buffer.GetAddressOf(), &stride, &offset);
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@ -285,8 +284,7 @@ namespace TEN::Renderer
{
auto& moveableObject = *_moveableObjects[objectID];
_context->VSSetShader(_vsInstancedStaticMeshes.Get(), nullptr, 0);
_context->PSSetShader(_psInstancedStaticMeshes.Get(), nullptr, 0);
BindShader(_sInstancedStatics);
unsigned int stride = sizeof(Vertex);
unsigned int offset = 0;
@ -363,8 +361,7 @@ namespace TEN::Renderer
SetDepthState(DepthState::Read);
SetCullMode(CullMode::None);
_context->VSSetShader(_vsSolid.Get(), nullptr, 0);
_context->PSSetShader(_psSolid.Get(), nullptr, 0);
BindShader(_sSolid);
auto worldMatrix = Matrix::CreateOrthographicOffCenter(0, _screenWidth, _screenHeight, 0, _viewport.MinDepth, _viewport.MaxDepth);
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
@ -534,13 +531,12 @@ namespace TEN::Renderer
{
if (rendererPass == RendererPass::GBuffer)
{
_context->VSSetShader(_vsGBufferStatics.Get(), nullptr, 0);
_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
BindShader(_sGBuffer);
BindShader(_sGBufferStatics);
}
else
{
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
BindShader(_sStatics);
}
UINT stride = sizeof(Vertex);
@ -660,13 +656,12 @@ namespace TEN::Renderer
{
if (rendererPass == RendererPass::GBuffer)
{
_context->VSSetShader(_vsGBufferStatics.Get(), nullptr, 0);
_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
BindShader(_sGBuffer);
BindShader(_sGBufferStatics);
}
else
{
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
BindShader(_sStatics);
}
unsigned int stride = sizeof(Vertex);
@ -797,13 +792,12 @@ namespace TEN::Renderer
{
if (rendererPass == RendererPass::GBuffer)
{
_context->VSSetShader(_vsGBufferInstancedStatics.Get(), nullptr, 0);
_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
BindShader(_sGBuffer);
BindShader(_sGBufferInstancedStatics);
}
else
{
_context->VSSetShader(_vsInstancedStaticMeshes.Get(), nullptr, 0);
_context->PSSetShader(_psInstancedStaticMeshes.Get(), nullptr, 0);
BindShader(_sInstancedStatics);
}
unsigned int stride = sizeof(Vertex);
@ -925,13 +919,12 @@ namespace TEN::Renderer
{
if (rendererPass == RendererPass::GBuffer)
{
_context->VSSetShader(_vsGBufferInstancedStatics.Get(), nullptr, 0);
_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
BindShader(_sGBuffer);
BindShader(_sGBufferInstancedStatics);
}
else
{
_context->VSSetShader(_vsInstancedStaticMeshes.Get(), nullptr, 0);
_context->PSSetShader(_psInstancedStaticMeshes.Get(), nullptr, 0);
BindShader(_sInstancedStatics);
}
unsigned int stride = sizeof(Vertex);
@ -1033,13 +1026,12 @@ namespace TEN::Renderer
{
if (rendererPass == RendererPass::GBuffer)
{
_context->VSSetShader(_vsGBufferStatics.Get(), nullptr, 0);
_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
BindShader(_sGBuffer);
BindShader(_sGBufferStatics);
}
else
{
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
BindShader(_sStatics);
}
unsigned int stride = sizeof(Vertex);
@ -1097,8 +1089,7 @@ namespace TEN::Renderer
SetBlendMode(BlendMode::Additive);
SetCullMode(CullMode::None);
_context->VSSetShader(_vsSolid.Get(), nullptr, 0);
_context->PSSetShader(_psSolid.Get(), nullptr, 0);
BindShader(_sSolid);
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
@ -1131,8 +1122,7 @@ namespace TEN::Renderer
SetBlendMode(BlendMode::Additive);
SetCullMode(CullMode::None);
_context->VSSetShader(_vsSolid.Get(), nullptr, 0);
_context->PSSetShader(_psSolid.Get(), nullptr, 0);
BindShader(_sSolid);
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_context->IASetInputLayout(_inputLayout.Get());
@ -1936,7 +1926,7 @@ namespace TEN::Renderer
SetBlendMode(BlendMode::Opaque);
SetCullMode(CullMode::CounterClockwise);
_context->PSSetShader(_psRoomAmbient.Get(), nullptr, 0);
BindShader(_sRoomAmbient);
// Bind and clear render target
_context->ClearRenderTargetView(renderTarget->RenderTargetView.Get(), Colors::Black);
@ -1986,7 +1976,7 @@ namespace TEN::Renderer
if (levelPtr->Horizon)
{
_context->VSSetShader(_vsRoomAmbientSky.Get(), nullptr, 0);
BindShader(_sRoomAmbientSky);
if (Lara.Control.Look.OpticRange != 0)
AlterFOV(ANGLE(DEFAULT_FOV) - Lara.Control.Look.OpticRange, false);
@ -2068,7 +2058,7 @@ namespace TEN::Renderer
_context->ClearDepthStencilView(renderTarget->DepthStencilView.Get(), D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
}
_context->VSSetShader(_vsRoomAmbient.Get(), nullptr, 0);
BindShader(_sRoomAmbient);
// Draw rooms
UINT stride = sizeof(Vertex);
@ -2274,13 +2264,12 @@ namespace TEN::Renderer
// Set shaders.
if (rendererPass == RendererPass::GBuffer)
{
_context->VSSetShader(_vsGBufferItems.Get(), nullptr, 0);
_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
BindShader(_sGBuffer);
BindShader(_sGBufferItems);
}
else
{
_context->VSSetShader(_vsItems.Get(), nullptr, 0);
_context->PSSetShader(_psItems.Get(), nullptr, 0);
BindShader(_sItems);
}
BindRenderTargetAsTexture(TextureRegister::SSAO, &_SSAOBlurredRenderTarget, SamplerStateRegister::PointWrap);
@ -2417,13 +2406,12 @@ namespace TEN::Renderer
#ifdef DISABLE_INSTANCING
if (rendererPass == RendererPass::GBuffer)
{
_context->VSSetShader(_vsGBufferStatics.Get(), NULL, 0);
_context->PSSetShader(_psGBuffer.Get(), NULL, 0);
BindShader(_sGBuffer);
BindShader(_sGBufferStatics);
}
else
{
_context->VSSetShader(_vsStatics.Get(), NULL, 0);
_context->PSSetShader(_psStatics.Get(), NULL, 0);
BindShader(_sStatics);
}
// Bind vertex and index buffer
@ -2499,13 +2487,12 @@ namespace TEN::Renderer
#else
if (rendererPass == RendererPass::GBuffer)
{
_context->VSSetShader(_vsGBufferInstancedStatics.Get(), NULL, 0);
_context->PSSetShader(_psGBuffer.Get(), NULL, 0);
BindShader(_sGBuffer);
BindShader(_sGBufferInstancedStatics);
}
else
{
_context->VSSetShader(_vsInstancedStaticMeshes.Get(), NULL, 0);
_context->PSSetShader(_psInstancedStaticMeshes.Get(), NULL, 0);
BindShader(_sInstancedStatics);
}
// Bind vertex and index buffer
@ -2695,11 +2682,11 @@ namespace TEN::Renderer
{
if (rendererPass == RendererPass::GBuffer)
{
_context->PSSetShader(_psGBuffer.Get(), nullptr, 0);
BindShader(_sGBuffer);
}
else
{
_context->PSSetShader(_psRooms.Get(), nullptr, 0);
BindShader(_sRooms);
}
UINT stride = sizeof(Vertex);
@ -2763,11 +2750,11 @@ namespace TEN::Renderer
{
if (rendererPass != RendererPass::GBuffer)
{
_context->VSSetShader((animated == 0) ? _vsRooms.Get() : _vsRoomsAnimatedTextures.Get(), nullptr, 0);
if (animated == 0) BindShader(_sRooms); else BindShader(_sRoomsAnimated);
}
else
{
_context->VSSetShader((animated == 0) ? _vsGBufferRooms.Get() : _vsGBufferRoomsAnimated.Get(), nullptr, 0);
if (animated == 0) BindShader(_sGBufferRooms); else BindShader(_sGBufferRoomsAnimated);
}
for (const auto& bucket : room.Buckets)
@ -2866,9 +2853,7 @@ namespace TEN::Renderer
// Draw sky.
auto rotation = Matrix::CreateRotationX(PI);
_context->VSSetShader(_vsSky.Get(), nullptr, 0);
_context->PSSetShader(_psSky.Get(), nullptr, 0);
BindShader(_sSky);
BindTexture(TextureRegister::ColorMap, &_skyTexture, SamplerStateRegister::AnisotropicClamp);
_context->IASetVertexBuffers(0, 1, _skyVertexBuffer.Buffer.GetAddressOf(), &stride, &offset);
@ -2909,8 +2894,7 @@ namespace TEN::Renderer
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
_context->VSSetShader(_vsInstancedSprites.Get(), nullptr, 0);
_context->PSSetShader(_psInstancedSprites.Get(), nullptr, 0);
BindShader(_sInstancedSprites);
// Set up vertex buffer and parameters.
UINT stride = sizeof(Vertex);
@ -3049,8 +3033,7 @@ namespace TEN::Renderer
_context->IASetVertexBuffers(0, 1, _moveablesVertexBuffer.Buffer.GetAddressOf(), &stride, &offset);
_context->IASetIndexBuffer(_moveablesIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
_context->VSSetShader(_vsSky.Get(), nullptr, 0);
_context->PSSetShader(_psSky.Get(), nullptr, 0);
BindShader(_sSky);
auto& moveableObj = *_moveableObjects[ID_HORIZON];
@ -3094,8 +3077,7 @@ namespace TEN::Renderer
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
_context->VSSetShader(_vsInstancedSprites.Get(), nullptr, 0);
_context->PSSetShader(_psInstancedSprites.Get(), nullptr, 0);
BindShader(_sInstancedSprites);
// Set up vertex buffer and parameters.
unsigned int stride = sizeof(Vertex);
@ -3522,7 +3504,7 @@ namespace TEN::Renderer
ROOM_INFO* nativeRoom = &g_Level.Rooms[objectInfo->Room->RoomNumber];
_context->PSSetShader(_psRooms.Get(), nullptr, 0);
BindShader(_sRooms);
UINT stride = sizeof(Vertex);
UINT offset = 0;
@ -3538,14 +3520,8 @@ namespace TEN::Renderer
SetScissor(objectInfo->Room->ClipBounds);
if (objectInfo->Bucket->Animated == 0)
{
_context->VSSetShader(_vsRooms.Get(), nullptr, 0);
}
else
{
_context->VSSetShader(_vsRoomsAnimatedTextures.Get(), nullptr, 0);
}
if (objectInfo->Bucket->Animated != 0)
BindShader(_sRoomsAnimated);
SetBlendMode(objectInfo->Bucket->BlendMode);
SetAlphaTest(AlphaTestMode::None, ALPHA_TEST_THRESHOLD);
@ -3611,8 +3587,7 @@ namespace TEN::Renderer
SetBlendMode(objectInfo->Bucket->BlendMode);
SetAlphaTest(AlphaTestMode::None, ALPHA_TEST_THRESHOLD);
_context->VSSetShader(_vsItems.Get(), nullptr, 0);
_context->PSSetShader(_psItems.Get(), nullptr, 0);
BindShader(_sItems);
// Bind main item properties.
Matrix world = objectInfo->Item->InterpolatedWorld;
@ -3652,8 +3627,7 @@ namespace TEN::Renderer
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_context->IASetInputLayout(_inputLayout.Get());
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
BindShader(_sStatics);
Matrix world = objectInfo->Static->World;
_stStatic.World = world;
@ -3691,8 +3665,7 @@ namespace TEN::Renderer
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_context->IASetInputLayout(_inputLayout.Get());
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
BindShader(_sStatics);
Matrix world = objectInfo->World;
_stStatic.World = world;
@ -3731,10 +3704,10 @@ namespace TEN::Renderer
SetDepthState(DepthState::Write);
// Common vertex shader to all full screen effects
_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
BindShader(_sPostProcess);
// SSAO pixel shader
_context->PSSetShader(_psSSAO.Get(), nullptr, 0);
BindShader(_sSSAO);
_context->ClearRenderTargetView(_SSAORenderTarget.RenderTargetView.Get(), Colors::White);
_context->OMSetRenderTargets(1, _SSAORenderTarget.RenderTargetView.GetAddressOf(), nullptr);
@ -3778,7 +3751,7 @@ namespace TEN::Renderer
DrawTriangles(3, 0);
// Blur step
_context->PSSetShader(_psSSAOBlur.Get(), nullptr, 0);
BindShader(_sSSAOBlur);
_context->ClearRenderTargetView(_SSAOBlurredRenderTarget.RenderTargetView.Get(), Colors::Black);
_context->OMSetRenderTargets(1, _SSAOBlurredRenderTarget.RenderTargetView.GetAddressOf(), nullptr);

28
TombEngine/Renderer/RendererDraw2D.cpp
View file

@ -132,8 +132,8 @@ namespace TEN::Renderer
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_context->IASetIndexBuffer(bar.IndexBufferBorder.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
_context->VSSetShader(_vsHUD.Get(), nullptr, 0);
_context->PSSetShader(_psHUDTexture.Get(), nullptr, 0);
BindShader(_sHUD);
BindShader(_sHUDTexture);
SetBlendMode(BlendMode::Opaque);
SetDepthState(DepthState::None);
@ -161,8 +161,8 @@ namespace TEN::Renderer
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_context->IASetIndexBuffer(bar.InnerIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
_context->VSSetShader(_vsHUD.Get(), nullptr, 0);
_context->PSSetShader(_psHUDBarColor.Get(), nullptr, 0);
BindShader(_sHUD);
BindShader(_sHUDBarColor);
_stHUDBar.Percent = percent;
_stHUDBar.Poisoned = isPoisoned;
@ -195,8 +195,8 @@ namespace TEN::Renderer
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_context->IASetIndexBuffer(g_LoadingBar->IndexBufferBorder.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
_context->VSSetShader(_vsHUD.Get(), NULL, 0);
_context->PSSetShader(_psHUDTexture.Get(), NULL, 0);
BindShader(_sHUD);
BindShader(_sHUDTexture);
SetBlendMode(BlendMode::Opaque);
SetDepthState(DepthState::None);
@ -220,8 +220,8 @@ namespace TEN::Renderer
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_context->IASetIndexBuffer(g_LoadingBar->InnerIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
_context->VSSetShader(_vsHUD.Get(), nullptr, 0);
_context->PSSetShader(_psHUDBarColor.Get(), nullptr, 0);
BindShader(_sHUD);
BindShader(_sHUDBarColor);
_stHUDBar.Percent = percentage / 100.0f;
_stHUDBar.Poisoned = false;
@ -305,8 +305,7 @@ namespace TEN::Renderer
vertices[3].UV.y = 1.0f;
vertices[3].Color = Vector4(1.0f, 0.0f, 0.0f, 1.0f);
_context->VSSetShader(_vsFullScreenQuad.Get(), nullptr, 0);
_context->PSSetShader(_psFullScreenQuad.Get(), nullptr, 0);
BindShader(_sFullScreenQuad);
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_context->IASetInputLayout(_inputLayout.Get());
@ -342,8 +341,7 @@ namespace TEN::Renderer
if (renderView.DisplaySpritesToDraw.empty())
return;
_context->VSSetShader(_vsFullScreenQuad.Get(), nullptr, 0);
_context->PSSetShader(_psFullScreenQuad.Get(), nullptr, 0);
BindShader(_sFullScreenQuad);
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
_context->IASetInputLayout(_inputLayout.Get());
@ -465,8 +463,7 @@ namespace TEN::Renderer
vertices[3].UV.y = uvEnd.y;
vertices[3].Color = colorVec4;
_context->VSSetShader(_vsFullScreenQuad.Get(), nullptr, 0);
_context->PSSetShader(_psFullScreenQuad.Get(), nullptr, 0);
BindShader(_sFullScreenQuad);
_context->PSSetShaderResources(0, 1, &texture);
@ -543,8 +540,7 @@ namespace TEN::Renderer
vertices[3].UV.y = uvEnd.y;
vertices[3].Color = Vector4(color.x, color.y, color.z, 1.0f);
_context->VSSetShader(_vsFullScreenQuad.Get(), nullptr, 0);
_context->PSSetShader(_psFullScreenQuad.Get(), nullptr, 0);
BindShader(_sFullScreenQuad);
_context->PSSetShaderResources(0, 1, &texture);
auto* sampler = _renderStates->AnisotropicClamp();

12
TombEngine/Renderer/RendererDrawEffect.cpp
View file

@ -1022,8 +1022,7 @@ namespace TEN::Renderer
if (!settings.MuzzleFlash)
return false;
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
BindShader(_sStatics);
unsigned int stride = sizeof(Vertex);
unsigned int offset = 0;
@ -1144,8 +1143,7 @@ namespace TEN::Renderer
void Renderer::DrawBaddyGunflashes(RenderView& view)
{
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
BindShader(_sStatics);
unsigned int stride = sizeof(Vertex);
unsigned int offset = 0;
@ -1371,8 +1369,7 @@ namespace TEN::Renderer
void Renderer::DrawEffects(RenderView& view, RendererPass rendererPass)
{
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
BindShader(_sStatics);
unsigned int stride = sizeof(Vertex);
unsigned int offset = 0;
@ -1413,8 +1410,7 @@ namespace TEN::Renderer
if (activeDebrisExist)
{
_context->VSSetShader(_vsStatics.Get(), nullptr, 0);
_context->PSSetShader(_psStatics.Get(), nullptr, 0);
BindShader(_sStatics);
SetCullMode(CullMode::None);

8
TombEngine/Renderer/RendererDrawMenu.cpp
View file

@ -816,8 +816,7 @@ namespace TEN::Renderer
_context->IASetIndexBuffer(_moveablesIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
// Set shaders.
_context->VSSetShader(_vsInventory.Get(), nullptr, 0);
_context->PSSetShader(_psInventory.Get(), nullptr, 0);
BindShader(_sInventory);
// Set matrices.
CCameraMatrixBuffer hudCamera;
@ -889,7 +888,7 @@ namespace TEN::Renderer
if (!texture.Texture)
return;
int timeout = 20;
int timeout = 10;
float currentFade = FADE_FACTOR;
while (timeout || currentFade > 0.0f)
@ -1010,8 +1009,7 @@ namespace TEN::Renderer
_context->IASetIndexBuffer(_moveablesIndexBuffer.Buffer.Get(), DXGI_FORMAT_R32_UINT, 0);
// Set shaders
_context->VSSetShader(_vsInventory.Get(), nullptr, 0);
_context->PSSetShader(_psInventory.Get(), nullptr, 0);
BindShader(_sInventory);
if (CurrentLevel == 0)
{

272
TombEngine/Renderer/RendererInit.cpp
View file

@ -2,18 +2,23 @@
#include <string>
#include <memory>
#include <filesystem>
#include <random>
#include <d3dcompiler.h>
#include "Renderer/Renderer.h"
#include "Renderer/RendererUtils.h"
#include "Renderer/SMAA/AreaTex.h"
#include "Renderer/SMAA/SearchTex.h"
#include "Scripting/Include/Flow/ScriptInterfaceFlowHandler.h"
#include "Specific/configuration.h"
#include "Specific/memory/Vector.h"
#include "Specific/trutils.h"
#include "Specific/winmain.h"
#include "Renderer/SMAA/AreaTex.h"
#include "Renderer/SMAA/SearchTex.h"
#include <random>
extern GameConfiguration g_Configuration;
using namespace TEN::Renderer::Utils;
static std::wstring GetAssetPath(const wchar_t* fileName)
{
return TEN::Utils::ToWString(g_GameFlow->GetGameDir()) + fileName;
@ -35,12 +40,9 @@ namespace TEN::Renderer
_renderStates = std::make_unique<CommonStates>(_device.Get());
// Load shaders
ComPtr<ID3D10Blob> blob;
const D3D_SHADER_MACRO roomDefinesAnimated[] = { "ANIMATED", "", nullptr, nullptr };
const D3D_SHADER_MACRO roomDefinesShadowMap[] = { "SHADOW_MAP", "", nullptr, nullptr };
_vsRooms = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Rooms.fx"), "VS", "vs_5_0", nullptr, blob);
// Initialize input layout using first vertex shader.
D3D11_INPUT_ELEMENT_DESC inputLayoutItems[] =
{
@ -57,50 +59,41 @@ namespace TEN::Renderer
{ "DRAWINDEX", 0, DXGI_FORMAT_R32_UINT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "HASH", 0, DXGI_FORMAT_R32_SINT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
Utils::throwIfFailed(_device->CreateInputLayout(inputLayoutItems, 12, blob->GetBufferPointer(), blob->GetBufferSize(), &_inputLayout));
_vsRoomsAnimatedTextures = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Rooms.fx"), "VS", "vs_5_0", &roomDefinesAnimated[0], blob);
_psRooms = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Rooms.fx"), "PS", "ps_5_0", nullptr, blob);
_vsItems = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Items.fx"), "VS", "vs_5_0", nullptr, blob);
_psItems = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Items.fx"), "PS", "ps_5_0", nullptr, blob);
_vsStatics = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Statics.fx"), "VS", "vs_5_0", nullptr, blob);
_psStatics = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Statics.fx"), "PS", "ps_5_0", nullptr, blob);
_vsSky = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Sky.fx"), "VS", "vs_5_0", nullptr, blob);
_psSky = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Sky.fx"), "PS", "ps_5_0", nullptr, blob);
_vsSprites = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Sprites.fx"), "VS", "vs_5_0", nullptr, blob);
_psSprites = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Sprites.fx"), "PS", "ps_5_0", nullptr, blob);
_vsSolid = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Solid.fx"), "VS", "vs_5_0", nullptr, blob);
_psSolid = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Solid.fx"), "PS", "ps_5_0", nullptr, blob);
_vsInventory = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\Inventory.fx"), "VS", "vs_5_0", nullptr, blob);
_psInventory = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Inventory.fx"), "PS", "ps_5_0", nullptr, blob);
_vsFullScreenQuad = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\FullScreenQuad.fx"), "VS", "vs_5_0", nullptr, blob);
_psFullScreenQuad = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\FullScreenQuad.fx"), "PS", "ps_5_0", nullptr, blob);
_vsShadowMap = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\ShadowMap.fx"), "VS", "vs_5_0", nullptr, blob);
_psShadowMap = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\ShadowMap.fx"), "PS", "ps_5_0", nullptr, blob);
_vsHUD = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\HUD.hlsl"), "VS", "vs_5_0", nullptr, blob);
_psHUDColor = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\HUD.hlsl"), "PSColoredHUD", "ps_5_0", nullptr, blob);
_psHUDTexture = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\HUD.hlsl"), "PSTexturedHUD", "ps_5_0", nullptr, blob);
_psHUDBarColor = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\HUD.hlsl"), "PSTexturedHUDBar", "ps_5_0", nullptr, blob);
_vsInstancedStaticMeshes = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\InstancedStatics.fx"), "VS", "vs_5_0", nullptr, blob);
_psInstancedStaticMeshes = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\InstancedStatics.fx"), "PS", "ps_5_0", nullptr, blob);
_vsInstancedSprites = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\InstancedSprites.fx"), "VS", "vs_5_0", nullptr, blob);
_psInstancedSprites = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\InstancedSprites.fx"), "PS", "ps_5_0", nullptr, blob);
_vsGBufferRooms = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSRooms", "vs_5_0", nullptr, blob);
_vsGBufferRoomsAnimated = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSRooms", "vs_5_0", &roomDefinesAnimated[0], blob);
_vsGBufferItems = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSItems", "vs_5_0", nullptr, blob);
_vsGBufferStatics = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSStatics", "vs_5_0", nullptr, blob);
_vsGBufferInstancedStatics = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "VSInstancedStatics", "vs_5_0", nullptr, blob);
_psGBuffer = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\GBuffer.fx"), "PS", "ps_5_0", nullptr, blob);
_vsRoomAmbient = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\RoomAmbient.fx"), "VS", "vs_5_0", nullptr, blob);
_vsRoomAmbientSky = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\RoomAmbient.fx"), "VSSky", "vs_5_0", nullptr, blob);
_psRoomAmbient = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\RoomAmbient.fx"), "PS", "ps_5_0", nullptr, blob);
_vsFXAA = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\FXAA.fx"), "VS", "vs_5_0", nullptr, blob);
_psFXAA = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\FXAA.fx"), "PS", "ps_5_0", nullptr, blob);
_psSSAO = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SSAO.fx"), "PS", "ps_5_0", nullptr, blob);
_psSSAOBlur = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SSAO.fx"), "PSBlur", "ps_5_0", nullptr, blob);
_sRooms = CompileOrLoadShader("Rooms", "", ShaderType::PixelAndVertex);
Utils::throwIfFailed(_device->CreateInputLayout(inputLayoutItems, 12, _sRooms.Vertex.Blob->GetBufferPointer(), _sRooms.Vertex.Blob->GetBufferSize(), &_inputLayout));
_sRoomsAnimated = CompileOrLoadShader("Rooms", "", ShaderType::Vertex, &roomDefinesAnimated[0]);
_sItems = CompileOrLoadShader("Items", "", ShaderType::PixelAndVertex);
_sStatics = CompileOrLoadShader("Statics", "", ShaderType::PixelAndVertex);
_sSky = CompileOrLoadShader("Sky", "", ShaderType::PixelAndVertex);
_sSprites = CompileOrLoadShader("Sprites", "", ShaderType::PixelAndVertex);
_sSolid = CompileOrLoadShader("Solid", "", ShaderType::PixelAndVertex);
_sInventory = CompileOrLoadShader("Inventory", "", ShaderType::PixelAndVertex);
_sFullScreenQuad = CompileOrLoadShader("FullScreenQuad", "", ShaderType::PixelAndVertex);
_sShadowMap = CompileOrLoadShader("ShadowMap", "", ShaderType::PixelAndVertex, &roomDefinesShadowMap[0]);
_sHUD = CompileOrLoadShader("HUD", "", ShaderType::Vertex);
_sHUDColor = CompileOrLoadShader("HUD", "ColoredHUD", ShaderType::Pixel);
_sHUDTexture = CompileOrLoadShader("HUD", "TexturedHUD", ShaderType::Pixel);
_sHUDBarColor = CompileOrLoadShader("HUD", "TexturedHUDBar", ShaderType::Pixel);
_sInstancedStatics = CompileOrLoadShader("InstancedStatics", "", ShaderType::PixelAndVertex);
_sInstancedSprites = CompileOrLoadShader("InstancedSprites", "", ShaderType::PixelAndVertex);
_sGBuffer = CompileOrLoadShader("GBuffer", "", ShaderType::Pixel);
_sGBufferRooms = CompileOrLoadShader("GBuffer", "Rooms", ShaderType::Vertex);
_sGBufferRoomsAnimated = CompileOrLoadShader("GBuffer", "Rooms", ShaderType::Vertex, &roomDefinesAnimated[0]);
_sGBufferItems = CompileOrLoadShader("GBuffer", "Items", ShaderType::Vertex);
_sGBufferStatics = CompileOrLoadShader("GBuffer", "Statics", ShaderType::Vertex);
_sGBufferInstancedStatics = CompileOrLoadShader("GBuffer", "InstancedStatics", ShaderType::Vertex);
_sRoomAmbient = CompileOrLoadShader("RoomAmbient", "", ShaderType::PixelAndVertex);
_sRoomAmbientSky = CompileOrLoadShader("RoomAmbient", "Sky", ShaderType::Vertex);
_sFXAA = CompileOrLoadShader("FXAA", "", ShaderType::Pixel);
_sSSAO = CompileOrLoadShader("SSAO", "", ShaderType::Pixel);
_sSSAOBlur = CompileOrLoadShader("SSAO", "Blur", ShaderType::Pixel);
const D3D_SHADER_MACRO transparentDefines[] = { "TRANSPARENT", "", nullptr, nullptr };
_psRoomsTransparent = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\Rooms.fx"), "PS", "ps_5_0", &transparentDefines[0], blob);
_sRoomsTransparent = CompileOrLoadShader("Rooms", "", ShaderType::Pixel, &transparentDefines[0]);
// Initialize constant buffers
_cbCameraMatrices = CreateConstantBuffer<CCameraMatrixBuffer>();
@ -292,9 +285,7 @@ namespace TEN::Renderer
_fullscreenTriangleVertexBuffer = VertexBuffer<PostProcessVertex>(_device.Get(), 3, &vertices[0]);
ComPtr<ID3D10Blob> blob;
_vsPostProcess = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "VS", "vs_5_0", nullptr, blob);
_sPostProcess = CompileOrLoadShader("PostProcess", "", ShaderType::PixelAndVertex);
D3D11_INPUT_ELEMENT_DESC postProcessInputLayoutItems[] =
{
@ -302,14 +293,15 @@ namespace TEN::Renderer
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, D3D11_APPEND_ALIGNED_ELEMENT, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
Utils::throwIfFailed(_device->CreateInputLayout(postProcessInputLayoutItems, 3, blob->GetBufferPointer(), blob->GetBufferSize(), &_fullscreenTriangleInputLayout));
_psPostProcessCopy = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSCopy", "ps_5_0", nullptr, blob);
_psPostProcessMonochrome = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSMonochrome", "ps_5_0", nullptr, blob);
_psPostProcessNegative = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSNegative", "ps_5_0", nullptr, blob);
_psPostProcessExclusion = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSExclusion", "ps_5_0", nullptr, blob);
_psPostProcessFinalPass = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSFinalPass", "ps_5_0", nullptr, blob);
_psPostProcessLensFlare = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\PostProcess.fx"), "PSLensFlare", "ps_5_0", nullptr, blob);
Utils::throwIfFailed(_device->CreateInputLayout(postProcessInputLayoutItems, 3,
_sPostProcess.Vertex.Blob->GetBufferPointer(), _sPostProcess.Vertex.Blob->GetBufferSize(), &_fullscreenTriangleInputLayout));
_sPostProcessMonochrome = CompileOrLoadShader("PostProcess", "Monochrome", ShaderType::Pixel);
_sPostProcessNegative = CompileOrLoadShader("PostProcess", "Negative", ShaderType::Pixel);
_sPostProcessExclusion = CompileOrLoadShader("PostProcess", "Exclusion", ShaderType::Pixel);
_sPostProcessFinalPass = CompileOrLoadShader("PostProcess", "FinalPass", ShaderType::Pixel);
_sPostProcessLensFlare = CompileOrLoadShader("PostProcess", "LensFlare", ShaderType::Pixel);
}
void Renderer::CreateSSAONoiseTexture()
@ -597,16 +589,12 @@ namespace TEN::Renderer
auto null = D3D10_SHADER_MACRO{ nullptr, nullptr };
defines.push_back(null);
auto blob = ComPtr<ID3D10Blob>{};
_SMAALumaEdgeDetectionPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAALumaEdgeDetectionPS", "ps_5_0", defines.data(), blob);
_SMAAColorEdgeDetectionPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAAColorEdgeDetectionPS", "ps_5_0", defines.data(), blob);
_SMAADepthEdgeDetectionPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAADepthEdgeDetectionPS", "ps_5_0", defines.data(), blob);
_SMAABlendingWeightCalculationPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAABlendingWeightCalculationPS", "ps_5_0", defines.data(), blob);
_SMAANeighborhoodBlendingPS = Utils::compilePixelShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAANeighborhoodBlendingPS", "ps_5_0", defines.data(), blob);
_SMAAEdgeDetectionVS = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAAEdgeDetectionVS", "vs_5_0", defines.data(), blob);
_SMAABlendingWeightCalculationVS = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAABlendingWeightCalculationVS", "vs_5_0", defines.data(), blob);
_SMAANeighborhoodBlendingVS = Utils::compileVertexShader(_device.Get(), GetAssetPath(L"Shaders\\SMAA.fx"), "DX11_SMAANeighborhoodBlendingVS", "vs_5_0", defines.data(), blob);
_sSMAALumaEdgeDetection = CompileOrLoadShader("SMAA", "LumaEdgeDetection", ShaderType::Pixel, defines.data());
_sSMAAColorEdgeDetection = CompileOrLoadShader("SMAA", "ColorEdgeDetection", ShaderType::Pixel, defines.data());
_sSMAADepthEdgeDetection = CompileOrLoadShader("SMAA", "DepthEdgeDetection", ShaderType::Pixel, defines.data());
_sSMAABlendingWeightCalculation = CompileOrLoadShader("SMAA", "BlendingWeightCalculation", ShaderType::PixelAndVertex, defines.data());
_sSMAANeighborhoodBlending = CompileOrLoadShader("SMAA", "NeighborhoodBlending", ShaderType::PixelAndVertex, defines.data());
_sSMAAEdgeDetection = CompileOrLoadShader("SMAA", "EdgeDetection", ShaderType::Vertex, defines.data());
}
void Renderer::InitializeCommonTextures()
@ -688,4 +676,152 @@ namespace TEN::Renderer
UpdateWindow(WindowsHandle);
}
void Renderer::BindShader(const RendererShader& shader)
{
if (shader.Vertex.Shader != nullptr) _context->VSSetShader(shader.Vertex.Shader.Get(), nullptr, 0);
if (shader.Pixel.Shader != nullptr) _context->PSSetShader(shader.Pixel.Shader.Get(), nullptr, 0);
if (shader.Compute.Shader != nullptr) _context->CSSetShader(shader.Compute.Shader.Get(), nullptr, 0);
}
RendererShader Renderer::CompileOrLoadShader(const std::string& fileName, const std::string& funcName, ShaderType type, const D3D_SHADER_MACRO* defines)
{
RendererShader result = {};
// We need to increment the counter to avoid overwriting compiled shaders with the same source file name.
static int compileCounter = 0;
// Define paths for native (uncompiled) shaders and compiled shaders.
std::wstring shaderPath = GetAssetPath(L"Shaders\\");
std::wstring compiledShaderPath = shaderPath + L"Bin\\";
std::wstring wideFileName = TEN::Utils::ToWString(fileName);
// Ensure the /Bin subdirectory exists.
std::filesystem::create_directories(compiledShaderPath);
// Helper function to load or compile a shader.
auto loadOrCompileShader = [this, type, defines, shaderPath, compiledShaderPath]
(const std::wstring& baseFileName, const std::string& shaderType, const std::string& functionName, const char* model, ComPtr<ID3D10Blob>& bytecode)
{
// Construct the full paths using GetAssetPath.
auto prefix = ((compileCounter < 10) ? L"0" : L"") + std::to_wstring(compileCounter) + L"_";
auto csoFileName = compiledShaderPath + prefix + baseFileName + L"." + std::wstring(shaderType.begin(), shaderType.end()) + L".cso";
auto srcFileName = shaderPath + baseFileName;
// Try both .hlsl and .fx extensions for the source shader.
auto srcFileNameWithExtension = srcFileName + L".hlsl";
if (!std::filesystem::exists(srcFileNameWithExtension))
{
srcFileNameWithExtension = srcFileName + L".fx";
if (!std::filesystem::exists(srcFileNameWithExtension))
{
TENLog("Shader source file not found: " + TEN::Utils::ToString(srcFileNameWithExtension), LogLevel::Error);
throw std::runtime_error("Shader source file not found");
}
}
// Check modification dates of the source and compiled files.
bool shouldRecompile = false;
if (std::filesystem::exists(csoFileName))
{
auto csoTime = std::filesystem::last_write_time(csoFileName);
auto srcTime = std::filesystem::last_write_time(srcFileNameWithExtension);
shouldRecompile = srcTime > csoTime; // Recompile if the source is newer.
}
// Load compiled shader if it exists and is up to date.
if (!shouldRecompile)
{
std::ifstream csoFile(csoFileName, std::ios::binary);
if (csoFile.is_open())
{
// Load compiled shader.
csoFile.seekg(0, std::ios::end);
size_t fileSize = csoFile.tellg();
csoFile.seekg(0, std::ios::beg);
std::vector<char> buffer(fileSize);
csoFile.read(buffer.data(), fileSize);
csoFile.close();
D3DCreateBlob(fileSize, &bytecode);
memcpy(bytecode->GetBufferPointer(), buffer.data(), fileSize);
return;
}
}
// Set up compilation flags according to the build configuration.
unsigned int flags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR;
if constexpr (DebugBuild)
flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
else
flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3 | D3DCOMPILE_IEEE_STRICTNESS;
auto trimmedFileName = std::filesystem::path(srcFileNameWithExtension).filename().string();
TENLog("Compiling shader: " + trimmedFileName, LogLevel::Info);
// Compile shader.
ComPtr<ID3D10Blob> errors;
HRESULT res = D3DCompileFromFile(srcFileNameWithExtension.c_str(), defines, D3D_COMPILE_STANDARD_FILE_INCLUDE,
(shaderType + functionName).c_str(), model, flags, 0, bytecode.GetAddressOf(), errors.GetAddressOf());
if (FAILED(res))
{
if (errors)
{
auto error = std::string(static_cast<const char*>(errors->GetBufferPointer()));
TENLog(error, LogLevel::Error);
throw std::runtime_error(error);
}
else
{
TENLog("Error while compiling shader: " + trimmedFileName, LogLevel::Error);
throwIfFailed(res);
}
}
// Save compiled shader to .cso file.
std::ofstream outCsoFile(csoFileName, std::ios::binary);
if (outCsoFile.is_open())
{
outCsoFile.write(reinterpret_cast<const char*>(bytecode->GetBufferPointer()), bytecode->GetBufferSize());
outCsoFile.close();
}
};
// Load or compile and create pixel shader.
if (type == ShaderType::Pixel || type == ShaderType::PixelAndVertex)
{
loadOrCompileShader(wideFileName, "PS", funcName, "ps_5_0", result.Pixel.Blob);
throwIfFailed(_device->CreatePixelShader(result.Pixel.Blob->GetBufferPointer(), result.Pixel.Blob->GetBufferSize(),
nullptr, result.Pixel.Shader.GetAddressOf()
));
}
// Load or compile and create vertex shader.
if (type == ShaderType::Vertex || type == ShaderType::PixelAndVertex)
{
loadOrCompileShader(wideFileName, "VS", funcName, "vs_5_0", result.Vertex.Blob);
throwIfFailed(_device->CreateVertexShader(result.Vertex.Blob->GetBufferPointer(), result.Vertex.Blob->GetBufferSize(),
nullptr, result.Vertex.Shader.GetAddressOf()
));
}
// Load or compile and create compute shader.
if (type == ShaderType::Compute)
{
loadOrCompileShader(wideFileName, "CS", funcName, "cs_5_0", result.Compute.Blob);
throwIfFailed(_device->CreateComputeShader(result.Compute.Blob->GetBufferPointer(), result.Compute.Blob->GetBufferSize(),
nullptr, result.Compute.Shader.GetAddressOf()
));
}
// Increment the compile counter.
compileCounter++;
return result;
}
}

72
TombEngine/Renderer/RendererPostProcess.cpp
View file

@ -42,7 +42,7 @@ namespace TEN::Renderer
_cbPostProcessBuffer.UpdateData(_stPostProcessBuffer, _context.Get());
// Common vertex shader to all fullscreen effects.
_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
BindShader(_sPostProcess);
// Draw fullscreen triangle.
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@ -58,7 +58,6 @@ namespace TEN::Renderer
_context->ClearRenderTargetView(_postProcessRenderTarget[0].RenderTargetView.Get(), clearColor);
_context->OMSetRenderTargets(1, _postProcessRenderTarget[0].RenderTargetView.GetAddressOf(), nullptr);
_context->PSSetShader(_psPostProcessCopy.Get(), nullptr, 0);
BindRenderTargetAsTexture(TextureRegister::ColorMap, &_renderTarget, SamplerStateRegister::PointWrap);
DrawTriangles(3, 0);
@ -66,44 +65,13 @@ namespace TEN::Renderer
int currentRenderTarget = 0;
int destRenderTarget = 1;
// Apply color scheme.
if (_postProcessMode != PostProcessMode::None && _postProcessStrength > EPSILON)
{
_context->ClearRenderTargetView(_postProcessRenderTarget[destRenderTarget].RenderTargetView.Get(), clearColor);
_context->OMSetRenderTargets(1, _postProcessRenderTarget[destRenderTarget].RenderTargetView.GetAddressOf(), nullptr);
switch (_postProcessMode)
{
case PostProcessMode::Monochrome:
_context->PSSetShader(_psPostProcessMonochrome.Get(), nullptr, 0);
break;
case PostProcessMode::Negative:
_context->PSSetShader(_psPostProcessNegative.Get(), nullptr, 0);
break;
case PostProcessMode::Exclusion:
_context->PSSetShader(_psPostProcessExclusion.Get(), nullptr, 0);
break;
default:
return;
}
BindRenderTargetAsTexture(TextureRegister::ColorMap, &_postProcessRenderTarget[currentRenderTarget], SamplerStateRegister::PointWrap);
DrawTriangles(3, 0);
destRenderTarget = (destRenderTarget == 1) ? 0 : 1;
currentRenderTarget = (currentRenderTarget == 1) ? 0 : 1;
}
// Lens flares.
if (!view.LensFlaresToDraw.empty())
{
_context->ClearRenderTargetView(_postProcessRenderTarget[destRenderTarget].RenderTargetView.Get(), clearColor);
_context->OMSetRenderTargets(1, _postProcessRenderTarget[destRenderTarget].RenderTargetView.GetAddressOf(), nullptr);
_context->PSSetShader(_psPostProcessLensFlare.Get(), nullptr, 0);
BindShader(_sPostProcessLensFlare);
for (int i = 0; i < view.LensFlaresToDraw.size(); i++)
{
@ -120,8 +88,39 @@ namespace TEN::Renderer
currentRenderTarget = (currentRenderTarget == 1) ? 0 : 1;
}
// Apply color scheme.
if (_postProcessMode != PostProcessMode::None && _postProcessStrength > EPSILON)
{
_context->ClearRenderTargetView(_postProcessRenderTarget[destRenderTarget].RenderTargetView.Get(), clearColor);
_context->OMSetRenderTargets(1, _postProcessRenderTarget[destRenderTarget].RenderTargetView.GetAddressOf(), nullptr);
switch (_postProcessMode)
{
case PostProcessMode::Monochrome:
BindShader(_sPostProcessMonochrome);
break;
case PostProcessMode::Negative:
BindShader(_sPostProcessNegative);
break;
case PostProcessMode::Exclusion:
BindShader(_sPostProcessExclusion);
break;
default:
return;
}
BindRenderTargetAsTexture(TextureRegister::ColorMap, &_postProcessRenderTarget[currentRenderTarget], SamplerStateRegister::PointWrap);
DrawTriangles(3, 0);
destRenderTarget = (destRenderTarget == 1) ? 0 : 1;
currentRenderTarget = (currentRenderTarget == 1) ? 0 : 1;
}
// Do final pass.
_context->PSSetShader(_psPostProcessFinalPass.Get(), nullptr, 0);
BindShader(_sPostProcessFinalPass);
_context->ClearRenderTargetView(renderTarget->RenderTargetView.Get(), Colors::Black);
_context->OMSetRenderTargets(1, renderTarget->RenderTargetView.GetAddressOf(), nullptr);
@ -173,7 +172,7 @@ namespace TEN::Renderer
ResetScissor();
// Common vertex shader to all fullscreen effects
_context->VSSetShader(_vsPostProcess.Get(), nullptr, 0);
BindShader(_sPostProcess);
// We draw a fullscreen triangle
_context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
@ -188,7 +187,6 @@ namespace TEN::Renderer
_context->ClearRenderTargetView(dest->RenderTargetView.Get(), clearColor);
_context->OMSetRenderTargets(1, dest->RenderTargetView.GetAddressOf(), nullptr);
_context->PSSetShader(_psPostProcessCopy.Get(), nullptr, 0);
BindRenderTargetAsTexture(TextureRegister::ColorMap, source, SamplerStateRegister::PointWrap);
DrawTriangles(3, 0);
}

15
TombEngine/Renderer/RendererSprites.cpp
View file

@ -279,8 +279,7 @@ namespace TEN::Renderer
SetDepthState(DepthState::Read);
SetCullMode(CullMode::None);
_context->VSSetShader(_vsInstancedSprites.Get(), nullptr, 0);
_context->PSSetShader(_psInstancedSprites.Get(), nullptr, 0);
BindShader(_sInstancedSprites);
// Set up vertex buffer and parameters.
unsigned int stride = sizeof(Vertex);
@ -341,8 +340,7 @@ namespace TEN::Renderer
SetDepthState(DepthState::Read);
SetCullMode(CullMode::None);
_context->VSSetShader(_vsSprites.Get(), nullptr, 0);
_context->PSSetShader(_psSprites.Get(), nullptr, 0);
BindShader(_sSprites);
wasGPUSet = true;
}
@ -413,8 +411,7 @@ namespace TEN::Renderer
SetBlendMode(object->Sprite->BlendMode);
SetAlphaTest(AlphaTestMode::GreatherThan, ALPHA_TEST_THRESHOLD);
_context->VSSetShader(_vsInstancedSprites.Get(), nullptr, 0);
_context->PSSetShader(_psInstancedSprites.Get(), nullptr, 0);
BindShader(_sInstancedSprites);
// Set up vertex buffer and parameters.
UINT stride = sizeof(Vertex);
@ -459,8 +456,7 @@ namespace TEN::Renderer
SetBlendMode(object->Sprite->BlendMode);
SetAlphaTest(AlphaTestMode::GreatherThan, ALPHA_TEST_THRESHOLD);
_context->VSSetShader(_vsSprites.Get(), nullptr, 0);
_context->PSSetShader(_psSprites.Get(), nullptr, 0);
BindShader(_sSprites);
_stSprite.IsSoftParticle = object->Sprite->SoftParticle ? 1 : 0;
_stSprite.RenderType = (int)object->Sprite->renderType;
@ -505,8 +501,7 @@ namespace TEN::Renderer
UINT stride = sizeof(Vertex);
UINT offset = 0;
_context->VSSetShader(_vsSprites.Get(), nullptr, 0);
_context->PSSetShader(_psSprites.Get(), nullptr, 0);
BindShader(_sSprites);
_sortedPolygonsVertexBuffer.Update(_context.Get(), _sortedPolygonsVertices.data(), 0, (int)_sortedPolygonsVertices.size());

123
TombEngine/Renderer/RendererUtils.cpp
View file

@ -1,20 +1,18 @@
#include "framework.h"
#include <codecvt>
#include <d3dcompiler.h>
#include <locale>
#include <iostream>
#include <winerror.h>
#include <wrl/client.h>
#include "Renderer/Renderer.h"
#include "Specific/trutils.h"
#include "Structures/RendererShader.h"
namespace TEN::Renderer::Utils
{
using std::wstring;
using std::string;
using Microsoft::WRL::ComPtr;
using std::vector;
void throwIfFailed(const HRESULT& res)
{
if (FAILED(res))
@ -44,119 +42,4 @@ namespace TEN::Renderer::Utils
throw std::runtime_error("An error occured!");
}
}
ComPtr<ID3D11VertexShader> compileVertexShader(ID3D11Device* device, const std::wstring& fileName, const std::string& function, const std::string& model, const D3D_SHADER_MACRO * defines, ComPtr<ID3D10Blob>& bytecode)
{
ComPtr<ID3D10Blob> errors;
HRESULT res = (D3DCompileFromFile(fileName.c_str(), defines, D3D_COMPILE_STANDARD_FILE_INCLUDE, function.c_str(), model.c_str(), GetShaderFlags(), 0, bytecode.GetAddressOf(),errors.GetAddressOf()));
if (FAILED(res))
{
ID3D10Blob* errorObj = errors.Get();
if (errorObj != nullptr)
{
auto error = std::string((char*)errorObj->GetBufferPointer());
TENLog(error, LogLevel::Error);
throw std::runtime_error(error);
}
else
{
TENLog("Error while compiling VS shader: " + TEN::Utils::ToString(fileName.c_str()), LogLevel::Error);
throwIfFailed(res);
}
}
ComPtr<ID3D11VertexShader> shader;
throwIfFailed(device->CreateVertexShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), nullptr, shader.GetAddressOf()));
if constexpr (DebugBuild)
{
char buffer[100];
unsigned int size = (unsigned int)std::wcstombs(buffer, fileName.c_str(), 100);
shader->SetPrivateData(WKPDID_D3DDebugObjectName, size, buffer);
}
return shader;
}
ComPtr<ID3D11PixelShader> compilePixelShader(ID3D11Device* device, const wstring& fileName, const string& function, const string& model, const D3D_SHADER_MACRO* defines, ComPtr<ID3D10Blob>& bytecode)
{
ComPtr<ID3D10Blob> errors;
HRESULT res = (D3DCompileFromFile(fileName.c_str(), defines, D3D_COMPILE_STANDARD_FILE_INCLUDE, function.c_str(), model.c_str(), GetShaderFlags(), 0, bytecode.GetAddressOf(), errors.GetAddressOf()));
if (FAILED(res))
{
ID3D10Blob* errorObj = errors.Get();
if (errorObj != nullptr)
{
auto error = std::string((char*)errorObj->GetBufferPointer());
TENLog(error, LogLevel::Error);
throw std::runtime_error(error);
}
else
{
TENLog("Error while compiling PS shader: " + TEN::Utils::ToString(fileName.c_str()), LogLevel::Error);
throwIfFailed(res);
}
}
ComPtr<ID3D11PixelShader> shader;
throwIfFailed(device->CreatePixelShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), nullptr, shader.GetAddressOf()));
if constexpr (DebugBuild)
{
char buffer[100];
unsigned int size = (unsigned int)std::wcstombs(buffer, fileName.c_str(), 100);
shader->SetPrivateData(WKPDID_D3DDebugObjectName, size, buffer);
}
return shader;
}
ComPtr<ID3D11ComputeShader> compileComputeShader(ID3D11Device* device, const wstring& fileName, const string& function, const string& model, const D3D_SHADER_MACRO* defines, ComPtr<ID3D10Blob>& bytecode)
{
auto errors = ComPtr<ID3D10Blob>{};
auto res = D3DCompileFromFile(fileName.c_str(), defines, D3D_COMPILE_STANDARD_FILE_INCLUDE, function.c_str(), model.c_str(), GetShaderFlags(), 0, bytecode.GetAddressOf(), errors.GetAddressOf());
if (FAILED(res))
{
auto* errorObj = errors.Get();
if (errorObj != nullptr)
{
auto error = std::string((char*)errorObj->GetBufferPointer());
TENLog(error, LogLevel::Error);
throw std::runtime_error(error);
}
else
{
TENLog("Error while compiling CS shader: " + TEN::Utils::ToString(fileName.c_str()), LogLevel::Error);
throwIfFailed(res);
}
}
auto shader = ComPtr<ID3D11ComputeShader>{};
throwIfFailed(device->CreateComputeShader(bytecode->GetBufferPointer(), bytecode->GetBufferSize(), nullptr, shader.GetAddressOf()));
if constexpr (DebugBuild)
{
char buffer[100];
unsigned int size = (unsigned int)std::wcstombs(buffer, fileName.c_str(), 100);
shader->SetPrivateData(WKPDID_D3DDebugObjectName, size, buffer);
}
return shader;
}
constexpr unsigned int Utils::GetShaderFlags()
{
unsigned int flags = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_PACK_MATRIX_ROW_MAJOR;
if constexpr (DebugBuild)
{
flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
}
else
{
flags |= D3DCOMPILE_OPTIMIZATION_LEVEL3 | D3DCOMPILE_IEEE_STRICTNESS;
}
return flags;
}
}

5
TombEngine/Renderer/RendererUtils.h
View file

@ -9,9 +9,4 @@ namespace TEN::Renderer::Utils
void throwIfFailed(const HRESULT& res);
void throwIfFailed(const HRESULT& res, const std::string& info);
void throwIfFailed(const HRESULT& res, const std::wstring& info);
[[nodiscard]] Microsoft::WRL::ComPtr<ID3D11VertexShader> compileVertexShader(ID3D11Device* device, const std::wstring& fileName, const std::string& function, const std::string& model, const D3D_SHADER_MACRO* defines, Microsoft::WRL::ComPtr<ID3D10Blob>& bytecode);
constexpr [[nodiscard]] unsigned int GetShaderFlags();
[[nodiscard]] Microsoft::WRL::ComPtr<ID3D11PixelShader> compilePixelShader(ID3D11Device* device, const std::wstring& fileName, const std::string& function, const std::string& model, const D3D_SHADER_MACRO* defines, Microsoft::WRL::ComPtr<ID3D10Blob>& bytecode);
[[nodiscard]] Microsoft::WRL::ComPtr<ID3D11ComputeShader> compileComputeShader(ID3D11Device* device, const std::wstring& fileName, const std::string& function, const std::string& model, const D3D_SHADER_MACRO* defines, Microsoft::WRL::ComPtr<ID3D10Blob>& bytecode);
}

42
TombEngine/Renderer/Structures/RendererShader.h Normal file
View file

@ -0,0 +1,42 @@
#pragma once
#include <wrl/client.h>
#include <d3d11.h>
#include <utility>
using Microsoft::WRL::ComPtr;
namespace TEN::Renderer::Structures
{
enum class ShaderType
{
Pixel,
Vertex,
PixelAndVertex,
Compute
};
struct RendererPixelShaderAndBlob
{
ComPtr<ID3D11PixelShader> Shader = nullptr;
ComPtr<ID3D10Blob> Blob;
};
struct RendererVertexShaderAndBlob
{
ComPtr<ID3D11VertexShader> Shader = nullptr;
ComPtr<ID3D10Blob> Blob;
};
struct RendererComputeShaderAndBlob
{
ComPtr<ID3D11ComputeShader> Shader = nullptr;
ComPtr<ID3D10Blob> Blob;
};
struct RendererShader
{
RendererPixelShaderAndBlob Pixel;
RendererVertexShaderAndBlob Vertex;
RendererComputeShaderAndBlob Compute;
};
}

0
TombEngine/Shaders/HUD.hlsl → TombEngine/Shaders/HUD.fx
View file

2
TombEngine/Shaders/PostProcess.fx
View file

@ -32,7 +32,7 @@ PixelShaderInput VS(VertexShaderInput input)
return output;
}
float4 PSCopy(PixelShaderInput input) : SV_Target
float4 PS(PixelShaderInput input) : SV_Target
{
return ColorTexture.Sample(ColorSampler, input.UV);
}

52
TombEngine/Shaders/SMAA.fx
View file

@ -139,7 +139,7 @@ Texture2D searchTex : register(t8);
/**
* Function wrappers
*/
void DX11_SMAAEdgeDetectionVS(float3 position : POSITION,
void VSEdgeDetection(float3 position : POSITION,
out float4 svPosition : SV_POSITION,
inout float2 texcoord : TEXCOORD0,
out float4 offset[3] : TEXCOORD1) {
@ -147,7 +147,7 @@ void DX11_SMAAEdgeDetectionVS(float3 position : POSITION,
SMAAEdgeDetectionVS(texcoord, offset);
}
void DX11_SMAABlendingWeightCalculationVS(float3 position : POSITION,
void VSBlendingWeightCalculation(float3 position : POSITION,
out float4 svPosition : SV_POSITION,
inout float2 texcoord : TEXCOORD0,
out float2 pixcoord : TEXCOORD1,
@ -156,7 +156,7 @@ void DX11_SMAABlendingWeightCalculationVS(float3 position : POSITION,
SMAABlendingWeightCalculationVS(texcoord, pixcoord, offset);
}
void DX11_SMAANeighborhoodBlendingVS(float3 position : POSITION,
void VSNeighborhoodBlending(float3 position : POSITION,
out float4 svPosition : SV_POSITION,
inout float2 texcoord : TEXCOORD0,
out float4 offset : TEXCOORD1) {
@ -164,19 +164,19 @@ void DX11_SMAANeighborhoodBlendingVS(float3 position : POSITION,
SMAANeighborhoodBlendingVS(texcoord, offset);
}
void DX11_SMAAResolveVS(float3 position : POSITION,
void VSResolve(float3 position : POSITION,
out float4 svPosition : SV_POSITION,
inout float2 texcoord : TEXCOORD0) {
svPosition = float4(position, 1.0f);
}
void DX11_SMAASeparateVS(float3 position : POSITION,
void VSSeparate(float3 position : POSITION,
out float4 svPosition : SV_POSITION,
inout float2 texcoord : TEXCOORD0) {
svPosition = float4(position, 1.0f);
}
float2 DX11_SMAALumaEdgeDetectionPS(float4 position : SV_POSITION,
float2 PSLumaEdgeDetection(float4 position : SV_POSITION,
float2 texcoord : TEXCOORD0,
float4 offset[3] : TEXCOORD1) : SV_TARGET{
#if SMAA_PREDICATION
@ -186,7 +186,7 @@ return SMAALumaEdgeDetectionPS(texcoord, offset, colorTexGamma);
#endif
}
float2 DX11_SMAAColorEdgeDetectionPS(float4 position : SV_POSITION,
float2 PSColorEdgeDetection(float4 position : SV_POSITION,
float2 texcoord : TEXCOORD0,
float4 offset[3] : TEXCOORD1) : SV_TARGET{
#if SMAA_PREDICATION
@ -196,20 +196,20 @@ return SMAAColorEdgeDetectionPS(texcoord, offset, colorTexGamma);
#endif
}
float2 DX11_SMAADepthEdgeDetectionPS(float4 position : SV_POSITION,
float2 PSDepthEdgeDetection(float4 position : SV_POSITION,
float2 texcoord : TEXCOORD0,
float4 offset[3] : TEXCOORD1) : SV_TARGET{
return SMAADepthEdgeDetectionPS(texcoord, offset, depthTex);
}
float4 DX11_SMAABlendingWeightCalculationPS(float4 position : SV_POSITION,
float4 PSBlendingWeightCalculation(float4 position : SV_POSITION,
float2 texcoord : TEXCOORD0,
float2 pixcoord : TEXCOORD1,
float4 offset[3] : TEXCOORD2) : SV_TARGET{
return SMAABlendingWeightCalculationPS(texcoord, pixcoord, offset, edgesTex, areaTex, searchTex, subsampleIndices);
}
float4 DX11_SMAANeighborhoodBlendingPS(float4 position : SV_POSITION,
float4 PSNeighborhoodBlending(float4 position : SV_POSITION,
float2 texcoord : TEXCOORD0,
float4 offset : TEXCOORD1) : SV_TARGET{
#if SMAA_REPROJECTION
@ -219,7 +219,7 @@ return SMAANeighborhoodBlendingPS(texcoord, offset, colorTex, blendTex);
#endif
}
float4 DX11_SMAAResolvePS(float4 position : SV_POSITION,
float4 PSResolve(float4 position : SV_POSITION,
float2 texcoord : TEXCOORD0) : SV_TARGET{
#if SMAA_REPROJECTION
return SMAAResolvePS(texcoord, colorTex, colorTexPrev, velocityTex);
@ -228,7 +228,7 @@ return SMAAResolvePS(texcoord, colorTex, colorTexPrev);
#endif
}
void DX11_SMAASeparatePS(float4 position : SV_POSITION,
void PSSeparate(float4 position : SV_POSITION,
float2 texcoord : TEXCOORD0,
out float4 target0 : SV_TARGET0,
out float4 target1 : SV_TARGET1) {
@ -240,9 +240,9 @@ void DX11_SMAASeparatePS(float4 position : SV_POSITION,
*/
technique10 LumaEdgeDetection {
pass LumaEdgeDetection {
SetVertexShader(CompileShader(vs_4_0, DX11_SMAAEdgeDetectionVS()));
SetVertexShader(CompileShader(vs_4_0, VSEdgeDetection()));
SetGeometryShader(NULL);
SetPixelShader(CompileShader(PS_VERSION, DX11_SMAALumaEdgeDetectionPS()));
SetPixelShader(CompileShader(PS_VERSION, PSLumaEdgeDetection()));
SetDepthStencilState(DisableDepthReplaceStencil, 1);
SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@ -251,9 +251,9 @@ technique10 LumaEdgeDetection {
technique10 ColorEdgeDetection {
pass ColorEdgeDetection {
SetVertexShader(CompileShader(vs_4_0, DX11_SMAAEdgeDetectionVS()));
SetVertexShader(CompileShader(vs_4_0, VSEdgeDetection()));
SetGeometryShader(NULL);
SetPixelShader(CompileShader(PS_VERSION, DX11_SMAAColorEdgeDetectionPS()));
SetPixelShader(CompileShader(PS_VERSION, PSColorEdgeDetection()));
SetDepthStencilState(DisableDepthReplaceStencil, 1);
SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@ -262,9 +262,9 @@ technique10 ColorEdgeDetection {
technique10 DepthEdgeDetection {
pass DepthEdgeDetection {
SetVertexShader(CompileShader(vs_4_0, DX11_SMAAEdgeDetectionVS()));
SetVertexShader(CompileShader(vs_4_0, VSEdgeDetection()));
SetGeometryShader(NULL);
SetPixelShader(CompileShader(PS_VERSION, DX11_SMAADepthEdgeDetectionPS()));
SetPixelShader(CompileShader(PS_VERSION, PSDepthEdgeDetection()));
SetDepthStencilState(DisableDepthReplaceStencil, 1);
SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@ -276,9 +276,9 @@ technique10 DepthEdgeDetection {
*/
technique10 BlendingWeightCalculation {
pass BlendingWeightCalculation {
SetVertexShader(CompileShader(vs_4_0, DX11_SMAABlendingWeightCalculationVS()));
SetVertexShader(CompileShader(vs_4_0, VSBlendingWeightCalculation()));
SetGeometryShader(NULL);
SetPixelShader(CompileShader(PS_VERSION, DX11_SMAABlendingWeightCalculationPS()));
SetPixelShader(CompileShader(PS_VERSION, PSBlendingWeightCalculation()));
SetDepthStencilState(DisableDepthUseStencil, 1);
SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@ -290,9 +290,9 @@ technique10 BlendingWeightCalculation {
*/
technique10 NeighborhoodBlending {
pass NeighborhoodBlending {
SetVertexShader(CompileShader(vs_4_0, DX11_SMAANeighborhoodBlendingVS()));
SetVertexShader(CompileShader(vs_4_0, VSNeighborhoodBlending()));
SetGeometryShader(NULL);
SetPixelShader(CompileShader(PS_VERSION, DX11_SMAANeighborhoodBlendingPS()));
SetPixelShader(CompileShader(PS_VERSION, PSNeighborhoodBlending()));
SetDepthStencilState(DisableDepthStencil, 0);
SetBlendState(Blend, float4(blendFactor, blendFactor, blendFactor, blendFactor), 0xFFFFFFFF);
@ -305,9 +305,9 @@ technique10 NeighborhoodBlending {
*/
technique10 Resolve {
pass Resolve {
SetVertexShader(CompileShader(vs_4_0, DX11_SMAAResolveVS()));
SetVertexShader(CompileShader(vs_4_0, VSResolve()));
SetGeometryShader(NULL);
SetPixelShader(CompileShader(PS_VERSION, DX11_SMAAResolvePS()));
SetPixelShader(CompileShader(PS_VERSION, PSResolve()));
SetDepthStencilState(DisableDepthStencil, 0);
SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);
@ -319,9 +319,9 @@ technique10 Resolve {
*/
technique10 Separate {
pass Separate {
SetVertexShader(CompileShader(vs_4_0, DX11_SMAASeparateVS()));
SetVertexShader(CompileShader(vs_4_0, VSSeparate()));
SetGeometryShader(NULL);
SetPixelShader(CompileShader(PS_VERSION, DX11_SMAASeparatePS()));
SetPixelShader(CompileShader(PS_VERSION, PSSeparate()));
SetDepthStencilState(DisableDepthStencil, 0);
SetBlendState(NoBlending, float4(0.0f, 0.0f, 0.0f, 0.0f), 0xFFFFFFFF);

9
TombEngine/TombEngine.vcxproj
View file

@ -88,7 +88,7 @@
<IntDir>$(Configuration)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>true</LinkIncremental>
<LinkIncremental>false</LinkIncremental>
<OutDir>$(SolutionDir)Build\$(Configuration)\Bin\x86\</OutDir>
<ExecutablePath>$(ExecutablePath);$(DXSDK_DIR)Utilities\bin\x86</ExecutablePath>
<IncludePath>$(SolutionDir)Libs;$(SolutionDir)Libs\lua;$(SolutionDir)Libs\sol;$(SolutionDir)Libs\zlib;$(SolutionDir)Libs\spdlog;$(SolutionDir)Libs\ois;$(SolutionDir)Libs\bass;$(SolutionDir)Libs\srtparser;$(IncludePath)</IncludePath>
@ -100,7 +100,7 @@
<IncludePath>$(SolutionDir)Libs;$(SolutionDir)Libs\lua;$(SolutionDir)Libs\sol;$(SolutionDir)Libs\zlib;$(SolutionDir)Libs\spdlog;$(SolutionDir)Libs\ois;$(SolutionDir)Libs\bass;$(SolutionDir)Libs\srtparser;$(IncludePath)</IncludePath>
<LibraryPath>$(LibraryPath);$(DXSDK_DIR)Lib\x64;$(SolutionDir)Libs\spdlog\x64;$(SolutionDir)Libs\lua\x64;$(SolutionDir)Libs\zlib\x64;$(SolutionDir)Libs\bass\x64;$(SolutionDir)Libs\ois\x64</LibraryPath>
<TargetExt>.exe</TargetExt>
<LinkIncremental>true</LinkIncremental>
<LinkIncremental>false</LinkIncremental>
<OutDir>$(SolutionDir)Build\$(Configuration)\Bin\x64\</OutDir>
<IntDir>$(Configuration)\</IntDir>
<TargetName>$(ProjectName)</TargetName>
@ -321,7 +321,7 @@ if not exist "%ScriptsDir%\Strings.lua" xcopy /Y "$(SolutionDir)Scripts\Strings.
<ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
<LargeAddressAware>true</LargeAddressAware>
<TargetMachine>MachineX86</TargetMachine>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
</Link>
<PostBuildEvent>
<Command>del "$(TargetDir)*.pdb" /q
@ -400,7 +400,7 @@ if not exist "%ScriptsDir%\Strings.lua" xcopy /Y "$(SolutionDir)Scripts\Strings.
<AdditionalDependencies>comctl32.lib;lua53.lib;bass.lib;bassmix.lib;bass_fx.lib;D3DCompiler.lib;dxgi.lib;dxguid.lib;d3d11.lib;version.lib;zlib.lib;spdlog.lib;OIS.lib;%(AdditionalDependencies)</AdditionalDependencies>
<ImageHasSafeExceptionHandlers>false</ImageHasSafeExceptionHandlers>
<LargeAddressAware>true</LargeAddressAware>
<LinkTimeCodeGeneration>Default</LinkTimeCodeGeneration>
<LinkTimeCodeGeneration>UseLinkTimeCodeGeneration</LinkTimeCodeGeneration>
</Link>
<PostBuildEvent>
<Command>del "$(TargetDir)*.pdb" /q
@ -854,6 +854,7 @@ if not exist "%ScriptsDir%\Strings.lua" xcopy /Y "$(SolutionDir)Scripts\Strings.
<ClInclude Include="Renderer\Structures\RendererRoom.h" />
<ClInclude Include="Renderer\Structures\RendererRoomAmbientMap.h" />
<ClInclude Include="Renderer\Structures\RendererRoomNode.h" />
<ClInclude Include="Renderer\Structures\RendererShader.h" />
<ClInclude Include="Renderer\Structures\RendererSortableObject.h" />
<ClInclude Include="Renderer\Structures\RendererSprite.h" />
<ClInclude Include="Renderer\Structures\RendererSprite2D.h" />