Skip to content

feat: Draw Sky after drawing main geometry #369

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
kirides merged 5 commits into from
Jun 9, 2026
Merged

feat: Draw Sky after drawing main geometry #369

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
5 commits
Select commit Hold shift + click to select a range
a51b82b
Draw sky after geometry, to make use of early z
kirides Jun 8, 2026
3446c40
hash when SetDirty again
kirides Jun 8, 2026
0aa8003
fix fog clear color for atmospheric scattering
kirides Jun 8, 2026
edda59c
draw sky directly onto hdr backbuffer, after lighting pass.
kirides Jun 8, 2026
7e28f45
adjust default fog color for addonworld
kirides Jun 8, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
196 changes: 134 additions & 62 deletions D3D11Engine/D3D11GraphicsEngine.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -3605,66 +3605,99 @@ XRESULT D3D11GraphicsEngine::UnbindTexture( int slot ) {

/** Recreates the renderstates */
XRESULT D3D11GraphicsEngine::UpdateRenderStates() {
if ( Engine::GAPI->GetRendererState().BlendState.StateDirty &&
Engine::GAPI->GetRendererState().BlendState.Hash != FFBlendStateHash ) {

auto& states = Engine::GAPI->GetRendererState();
auto& blendState = states.BlendState;
auto& rasterState = states.RasterizerState;
auto& depthState = states.DepthState;

/*
blendState.HashThis( reinterpret_cast<char*>(&blendState), blendState.StructSize );
rasterState.HashThis( reinterpret_cast<char*>(&rasterState), rasterState.StructSize );
depthState.HashThis( reinterpret_cast<char*>(&depthState), depthState.StructSize );
*/

if ( blendState.StateDirty &&
blendState.Hash != FFBlendStateHash ) {
D3D11BlendStateInfo* state = static_cast<D3D11BlendStateInfo*>
(GothicStateCache::s_BlendStateMap[Engine::GAPI->GetRendererState().BlendState]);
(GothicStateCache::s_BlendStateMap[blendState]);

if ( !state ) {
// Create new state
state =
new D3D11BlendStateInfo( Engine::GAPI->GetRendererState().BlendState );
new D3D11BlendStateInfo( blendState );

GothicStateCache::s_BlendStateMap[Engine::GAPI->GetRendererState().BlendState] = state;
GothicStateCache::s_BlendStateMap[blendState] = state;
}

FFBlendState = state->State.Get();
FFBlendStateHash = Engine::GAPI->GetRendererState().BlendState.Hash;
FFBlendStateHash = blendState.Hash;

Engine::GAPI->GetRendererState().BlendState.StateDirty = false;
blendState.StateDirty = false;
GetContext()->OMSetBlendState( FFBlendState.Get(), float4( 0, 0, 0, 0 ).toPtr(),
0xFFFFFFFF );
}

if ( Engine::GAPI->GetRendererState().RasterizerState.StateDirty &&
Engine::GAPI->GetRendererState().RasterizerState.Hash !=
if ( rasterState.StateDirty &&
rasterState.Hash !=
FFRasterizerStateHash ) {
D3D11RasterizerStateInfo* state = static_cast<D3D11RasterizerStateInfo*>
(GothicStateCache::s_RasterizerStateMap[Engine::GAPI->GetRendererState().RasterizerState]);
(GothicStateCache::s_RasterizerStateMap[rasterState]);

if ( !state ) {
// Create new state
state = new D3D11RasterizerStateInfo(
Engine::GAPI->GetRendererState().RasterizerState );
rasterState );

GothicStateCache::s_RasterizerStateMap[Engine::GAPI->GetRendererState().RasterizerState] = state;
GothicStateCache::s_RasterizerStateMap[rasterState] = state;
}

FFRasterizerState = state->State.Get();
FFRasterizerStateHash = Engine::GAPI->GetRendererState().RasterizerState.Hash;
FFRasterizerStateHash = rasterState.Hash;

Engine::GAPI->GetRendererState().RasterizerState.StateDirty = false;
rasterState.StateDirty = false;
GetContext()->RSSetState( FFRasterizerState.Get() );
}

if ( Engine::GAPI->GetRendererState().DepthState.StateDirty &&
Engine::GAPI->GetRendererState().DepthState.Hash !=
if ( depthState.StateDirty &&
depthState.Hash !=
FFDepthStencilStateHash ) {

D3D11DepthBufferState* state = static_cast<D3D11DepthBufferState*>
(GothicStateCache::s_DepthBufferMap[Engine::GAPI->GetRendererState().DepthState]);
(GothicStateCache::s_DepthBufferMap[depthState]);

if ( !state ) {
// Create new state
state = new D3D11DepthBufferState(
Engine::GAPI->GetRendererState().DepthState );
depthState );

GothicStateCache::s_DepthBufferMap[Engine::GAPI->GetRendererState().DepthState] = state;
GothicStateCache::s_DepthBufferMap[depthState] = state;
#ifdef DEBUG_D3D11
std::stringstream ss;
ss << (state->Values.DepthBufferEnabled ? "E1" : "E0") << "|";
ss << (state->Values.DepthWriteEnabled ? "W1" : "W0") << "|";

static const char* strs[9]{
"NONE",
"NEVER",
"LESS",
"EQUAL",
"LESS_EQUAL",
"GREATER",
"NOT_EQUAL",
"GREATER_EQUAL",
"ALWAYS",
};
ss << strs[state->Values.DepthBufferCompareFunc];

SetDebugName( state->State.Get(), ss.str() );
#endif
}

FFDepthStencilState = state->State.Get();
FFDepthStencilStateHash = Engine::GAPI->GetRendererState().DepthState.Hash;
FFDepthStencilStateHash = depthState.Hash;

Engine::GAPI->GetRendererState().DepthState.StateDirty = false;
depthState.StateDirty = false;
GetContext()->OMSetDepthStencilState( FFDepthStencilState.Get(), 0 );
}

Expand Down Expand Up @@ -3827,27 +3860,12 @@ XRESULT D3D11GraphicsEngine::OnStartWorldRendering() {
context->ClearRenderTargetView( HDRBackBuffer->GetRenderTargetView().Get(), clearColor );
context->ClearRenderTargetView( Backbuffer->GetRenderTargetView().Get(), clearColor );

float4 fogColor( rendererState.GraphicsState.FF_FogColor, 0.0f );
float4 fogColor( rendererState.RendererSettings.AtmosphericScattering
? rendererState.RendererSettings.FogColorMod
: rendererState.GraphicsState.FF_FogColor, 0.0f );
GetContext()->ClearRenderTargetView( graph.GetPhysicalTexture( colorResource )->GetRenderTargetView().Get(), reinterpret_cast<const float*>(&fogColor) );
};
});

if ( rendererState.RendererSettings.DrawSky ) {
graph.AddPass( RG_PASS_NAME("Draw Sky"), [&]( RGBuilder& builder, RenderPass& pass ) {
//// Setup / Declare
//RGTextureDesc albedoDesc{ 1920, 1080, 28 /* DXGI_FORMAT_R8G8B8A8_UNORM */, "Albedo" };
//albedoTarget = builder.CreateTexture( albedoDesc );
builder.Write( colorResource );

pass.m_executeCallback = [this, colorResource](const RenderGraph& graph)->void {
TracyD3D11ZoneCGX( "D3D11GraphicsEngine::Draw Sky" );
// Draw back of the sky if outdoor
GetContext()->OMSetRenderTargets( 1, graph.GetPhysicalTexture( colorResource )->GetRenderTargetView().GetAddressOf(), nullptr );

DrawSky();
};
});
}

RGResourceHandle normalsResource;
RGResourceHandle specularResource;
Expand Down Expand Up @@ -3893,7 +3911,7 @@ XRESULT D3D11GraphicsEngine::OnStartWorldRendering() {
DrawFrameAlphaMeshes();
};
}
);
);

// Draw Ambient Occlusion
// Shared state for PostFX composition pass
Expand Down Expand Up @@ -3955,6 +3973,23 @@ XRESULT D3D11GraphicsEngine::OnStartWorldRendering() {
};
});
}

if ( rendererState.RendererSettings.DrawSky ) {
graph.AddPass( RG_PASS_NAME( "Draw Sky" ), [&]( RGBuilder& builder, RenderPass& pass ) {
//// Setup / Declare
//RGTextureDesc albedoDesc{ 1920, 1080, 28 /* DXGI_FORMAT_R8G8B8A8_UNORM */, "Albedo" };
//albedoTarget = builder.CreateTexture( albedoDesc );
builder.Write( backBufferHandle );

pass.m_executeCallback = [this, backBufferHandle]( const RenderGraph& graph )->void {
TracyD3D11ZoneCGX( "D3D11GraphicsEngine::Draw Sky" );
// Draw back of the sky if outdoor
GetContext()->OMSetRenderTargets( 1, graph.GetPhysicalTexture( backBufferHandle )->GetRenderTargetView().GetAddressOf(), GetDepthBuffer()->GetDepthStencilView().Get() );

DrawSky();
};
} );
}

graph.AddPass( RG_PASS_NAME("DrawWaterSurfaces"), [&]( RGBuilder& builder, RenderPass& pass ) {
builder.Read( backBufferHandle );
Expand Down Expand Up @@ -4629,11 +4664,29 @@ XRESULT D3D11GraphicsEngine::DrawMeshInfoListAlphablended(

// Check for alphablending on world mesh
if ( lastAlphaFunc != alphaFunc ) {
if ( alphaFunc == zMAT_ALPHA_FUNC_BLEND )
switch ( alphaFunc ) {
case zMAT_ALPHA_FUNC_BLEND:
case zMAT_ALPHA_FUNC_BLEND_TEST:
Engine::GAPI->GetRendererState().BlendState.SetAlphaBlending();
break;

if ( alphaFunc == zMAT_ALPHA_FUNC_ADD )
case zMAT_ALPHA_FUNC_ADD:
Engine::GAPI->GetRendererState().BlendState.SetAdditiveBlending();
break;

case zMAT_ALPHA_FUNC_MUL:
Engine::GAPI->GetRendererState().BlendState.SetModulateBlending();
break;

case zMAT_ALPHA_FUNC_MUL2:
Engine::GAPI->GetRendererState().BlendState.SetModulate2Blending();
break;

default:
auto _wtf = 1;
break;
// continue;
}

Engine::GAPI->GetRendererState().BlendState.SetDirty();

Expand Down Expand Up @@ -7581,9 +7634,23 @@ XRESULT D3D11GraphicsEngine::DrawSky() {
GSky* sky = Engine::GAPI->GetSky();
sky->RenderSky();

if ( !Engine::GAPI->GetRendererState().RendererSettings.AtmosphericScattering ) {
Engine::GAPI->GetRendererState().DepthState.DepthWriteEnabled = false;
Engine::GAPI->GetRendererState().DepthState.SetDirty();
auto& rendererState = Engine::GAPI->GetRendererState();
if ( !rendererState.RendererSettings.AtmosphericScattering ) {
// for engine sky to work with z-buffer after Geometry, we need to override Z-buffer usage and set custom TransformXYZRHW to always set max Z
auto oldStage = rendererState.RendererInfo.RenderStage;
rendererState.RendererInfo.RenderStage = STAGE_DRAW_SKY;

rendererState.DepthState.DepthBufferEnabled = true;

// Disable depth-writes so the sky always stays at max distance in the
rendererState.DepthState.DepthWriteEnabled = false;
rendererState.DepthState.DepthBufferCompareFunc = GothicDepthBufferStateInfo::CF_COMPARISON_GREATER_EQUAL;
rendererState.DepthState.SetDirty();


rendererState.RasterizerState.SetDefault();
rendererState.RasterizerState.CullMode = GothicRasterizerStateInfo::CM_CULL_BACK;
rendererState.RasterizerState.SetDirty();
UpdateRenderStates();

#if defined(BUILD_GOTHIC_1_08k) && !defined(BUILD_1_12F)
Expand All @@ -7598,8 +7665,10 @@ XRESULT D3D11GraphicsEngine::DrawSky() {
->RenderSkyPre();
#endif
Engine::GAPI->SetFarPlane(
Engine::GAPI->GetRendererState().RendererSettings.SectionDrawRadius *
rendererState.RendererSettings.SectionDrawRadius *
WORLD_SECTION_SIZE );

rendererState.RendererInfo.RenderStage = oldStage;
return XR_SUCCESS;
}
// Create a rotaion only view-matrix
Expand Down Expand Up @@ -7638,52 +7707,55 @@ XRESULT D3D11GraphicsEngine::DrawSky() {
.Update(&cbi)
.Bind();

Engine::GAPI->GetRendererState().BlendState.SetDefault();
Engine::GAPI->GetRendererState().BlendState.BlendEnabled = true;
rendererState.BlendState.SetDefault();
rendererState.BlendState.BlendEnabled = true;

Engine::GAPI->GetRendererState().DepthState.SetDefault();
rendererState.DepthState.SetDefault();

// Allow z-testing
Engine::GAPI->GetRendererState().DepthState.DepthBufferEnabled = true;
rendererState.DepthState.DepthBufferEnabled = true;

// Disable depth-writes so the sky always stays at max distance in the
// DepthBuffer
Engine::GAPI->GetRendererState().DepthState.DepthWriteEnabled = false;
rendererState.DepthState.DepthWriteEnabled = false;
rendererState.DepthState.DepthBufferCompareFunc = GothicDepthBufferStateInfo::CF_COMPARISON_GREATER_EQUAL;

Engine::GAPI->GetRendererState().RasterizerState.SetDefault();
Engine::GAPI->GetRendererState().DepthState.SetDirty();
Engine::GAPI->GetRendererState().BlendState.SetDirty();
rendererState.RasterizerState.SetDefault();
rendererState.DepthState.SetDirty();
rendererState.BlendState.SetDirty();

Engine::GAPI->GetRendererState().RasterizerState.CullMode = GothicRasterizerStateInfo::CM_CULL_BACK;
Engine::GAPI->GetRendererState().RasterizerState.SetDirty();
rendererState.RasterizerState.CullMode = GothicRasterizerStateInfo::CM_CULL_BACK;
rendererState.RasterizerState.SetDirty();

SetupVS_ExMeshDrawCall();
SetupVS_ExConstantBuffer();

ID3D11ShaderResourceView* srvs[2]{};
// Apply sky texture
D3D11Texture* cloudsTex = Engine::GAPI->GetSky()->GetCloudTexture();
if ( cloudsTex ) {
cloudsTex->BindToPixelShader( 0 );
srvs[0] = cloudsTex->GetShaderResourceView().Get();
}

D3D11Texture* nightTex = Engine::GAPI->GetSky()->GetNightTexture();
if ( nightTex ) {
nightTex->BindToPixelShader( 1 );
srvs[1] = nightTex->GetShaderResourceView().Get();
}
GetContext()->PSSetShaderResources( 0, std::size( srvs ), srvs);

if ( sky->GetSkyDome() ) sky->GetSkyDome()->DrawMesh();

#if defined(BUILD_GOTHIC_1_08k) && !defined(BUILD_1_12F)
{
SetDefaultStates();
Engine::GAPI->GetRendererState().DepthState.DepthWriteEnabled = false;
Engine::GAPI->GetRendererState().DepthState.SetDirty();
rendererState.DepthState.DepthWriteEnabled = false;
rendererState.DepthState.SetDirty();
UpdateRenderStates();

// Draw barrier after sky
reinterpret_cast<void( __fastcall* )( zCSkyController_Outdoor* )>( 0x632140 )( Engine::GAPI->GetLoadedWorldInfo()->MainWorld->GetSkyControllerOutdoor() );
reinterpret_cast<void( __fastcall* )(zCSkyController_Outdoor*)>(0x632140)(Engine::GAPI->GetLoadedWorldInfo()->MainWorld->GetSkyControllerOutdoor());
Engine::GAPI->SetFarPlane(
Engine::GAPI->GetRendererState().RendererSettings.SectionDrawRadius *
rendererState.RendererSettings.SectionDrawRadius *
WORLD_SECTION_SIZE );
}
#endif
Expand Down
8 changes: 8 additions & 0 deletions D3D11Engine/D3D11ShaderManager.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -157,13 +157,21 @@ XRESULT D3D11ShaderManager::Init() {

Shaders.push_back( ShaderInfo::make<VShaderID::VS_TransformedEx>( "VS_TransformedEx.hlsl" )
.with_layout( VERTEX_INPUT_LAYOUT_1 ) );

Shaders.push_back( ShaderInfo::make<VShaderID::VS_TransformedEx_MAX_Z>( "VS_TransformedEx.hlsl" )
.with_layout( VERTEX_INPUT_LAYOUT_1 )
.with_macros( { {"OVERRIDE_MAX_Z", "1"} } ) );

Shaders.push_back( ShaderInfo::make<VShaderID::VS_ExPointLight>( "VS_ExPointLight.hlsl" )
.with_layout( VERTEX_INPUT_LAYOUT_1 ) );

Shaders.push_back( ShaderInfo::make<VShaderID::VS_XYZRHW_DIF_T1>( "VS_XYZRHW_DIF_T1.hlsl" )
.with_layout( VERTEX_INPUT_LAYOUT_7_VS_XYZRHW_DIF_T1 ) );

Shaders.push_back( ShaderInfo::make<VShaderID::VS_XYZRHW_DIF_T1_MAX_Z>( "VS_XYZRHW_DIF_T1.hlsl" )
.with_layout( VERTEX_INPUT_LAYOUT_7_VS_XYZRHW_DIF_T1 )
.with_macros( { {"OVERRIDE_MAX_Z", "1"} }));

Shaders.push_back( ShaderInfo::make<VShaderID::VS_ExInstancedObj>( "VS_ExInstancedObj.hlsl" )
.with_layout( VERTEX_INPUT_LAYOUT_10_VS_ExInstancedObj )
.with_macros( [](std::vector<D3D_SHADER_MACRO>& list) {
Expand Down
Loading
Loading