id/doom3-bfg
0
0
Fork 0
mirror of https://github.com/id-Software/DOOM-3-BFG.git synced 2025-03-15 07:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fixed a few bugs with GPU Skinning and polygon offsets

Browse source
This commit is contained in:
Robert Beckebans 2019-01-20 13:32:22 +01:00
parent 9241db812e
commit 1e6064518f
6 changed files with 58 additions and 12 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
RELEASE-NOTES.txt
View file

@ -14,10 +14,14 @@ Thank you for downloading RBDOOM-3-BFG.
_______________________________________
TBD in 2018 - RBDOOM-3-BFG 1.2.0
TBD in 2019 - RBDOOM-3-BFG 1.2.0
_______________________________
- Refactored OpenGL renderer backend to match Dustin Land's Doom 3 BFG Vulkan port
- Vulkan renderer backend based on Dustin Land's Doom 3 BFG Vulkan port
- Refactored and simplified OpenGL renderer backend to match Vulkan backend
- Renamed the .vertex and .pixel shader files to .hlsl
- Integrated libbinkdec for video playback as a slim alternative to FFmpeg (thanks to Daniel Gibson)

35
neo/renderer/RenderBackend.cpp
View file

@ -3643,10 +3643,17 @@ int idRenderBackend::DrawShaderPasses( const drawSurf_t* const* const drawSurfs,
uint64 surfGLState = surf->extraGLState | cullMode;
// set polygon offset if necessary
if( shader->TestMaterialFlag( MF_POLYGONOFFSET ) )
{
GL_PolygonOffset( r_offsetFactor.GetFloat(), r_offsetUnits.GetFloat() * shader->GetPolygonOffset() );
surfGLState = GLS_POLYGON_OFFSET;
// RB: make sure the pipeline of the current shader has dynamic polygon offset enabled
//renderProgManager.CommitUniforms( surfGLState );
#if !defined( USE_VULKAN )
GL_PolygonOffset( r_offsetFactor.GetFloat(), r_offsetUnits.GetFloat() * shader->GetPolygonOffset() );
#endif
}
for( int stage = 0; stage < shader->GetNumStages(); stage++ )
@ -3847,16 +3854,37 @@ int idRenderBackend::DrawShaderPasses( const drawSurf_t* const* const drawSurfs,
// bind the texture
BindVariableStageImage( &pStage->texture, regs );
// set privatePolygonOffset if necessary
if( pStage->privatePolygonOffset )
{
GL_PolygonOffset( r_offsetFactor.GetFloat(), r_offsetUnits.GetFloat() * pStage->privatePolygonOffset );
stageGLState |= GLS_POLYGON_OFFSET;
}
// set the state
GL_State( stageGLState );
// set privatePolygonOffset if necessary
#if defined( USE_VULKAN )
if( shader->TestMaterialFlag( MF_POLYGONOFFSET ) || pStage->privatePolygonOffset )
{
// RB: make sure the pipeline of the current shader has dynamic polygon offset enabled
renderProgManager.CommitUniforms( stageGLState );
if( shader->TestMaterialFlag( MF_POLYGONOFFSET ) )
{
GL_PolygonOffset( r_offsetFactor.GetFloat(), r_offsetUnits.GetFloat() * shader->GetPolygonOffset() );
}
else
{
GL_PolygonOffset( r_offsetFactor.GetFloat(), r_offsetUnits.GetFloat() * pStage->privatePolygonOffset );
}
}
#else
if( pStage->privatePolygonOffset )
{
GL_PolygonOffset( r_offsetFactor.GetFloat(), r_offsetUnits.GetFloat() * pStage->privatePolygonOffset );
}
#endif
PrepareStageTexturing( pStage, surf );
// draw it
@ -3869,6 +3897,7 @@ int idRenderBackend::DrawShaderPasses( const drawSurf_t* const* const drawSurfs,
{
GL_PolygonOffset( r_offsetFactor.GetFloat(), r_offsetUnits.GetFloat() * shader->GetPolygonOffset() );
}
renderLog.CloseBlock();
}

10
neo/renderer/RenderProgs.cpp
View file

@ -201,16 +201,22 @@ void idRenderProgManager::Init()
continue;
}
uint32 shaderFeatures = builtins[i].shaderFeatures;
if( builtins[i].requireGPUSkinningSupport )
{
shaderFeatures |= BIT( USE_GPU_SKINNING );
}
int vIndex = -1;
if( builtins[ i ].stages & SHADER_STAGE_VERTEX )
{
vIndex = FindShader( builtins[ i ].name, SHADER_STAGE_VERTEX, builtins[i].nameOutSuffix, builtins[i].shaderFeatures, true );
vIndex = FindShader( builtins[ i ].name, SHADER_STAGE_VERTEX, builtins[i].nameOutSuffix, shaderFeatures, true );
}
int fIndex = -1;
if( builtins[ i ].stages & SHADER_STAGE_FRAGMENT )
{
fIndex = FindShader( builtins[ i ].name, SHADER_STAGE_FRAGMENT, builtins[i].nameOutSuffix, builtins[i].shaderFeatures, true );
fIndex = FindShader( builtins[ i ].name, SHADER_STAGE_FRAGMENT, builtins[i].nameOutSuffix, shaderFeatures, true );
}
//idLib::Printf( "Loading GLSL program %i %i %i\n", i, vIndex, fIndex );

3
neo/renderer/RenderProgs.h
View file

@ -621,6 +621,7 @@ public:
void SetUniformValue( const renderParm_t rp, const float* value );
void CommitUniforms( uint64 stateBits );
void CachePipeline( uint64 stateBits );
int FindGLSLProgram( const char* name, int vIndex, int fIndex );
void ZeroUniforms();
@ -769,7 +770,7 @@ private:
builtin( false ),
vertexShaderIndex( -1 ),
fragmentShaderIndex( -1 ),
vertexLayout( LAYOUT_UNKNOWN ),
vertexLayout( LAYOUT_DRAW_VERT ),
pipelineLayout( VK_NULL_HANDLE ),
descriptorSetLayout( VK_NULL_HANDLE ) {}

1
neo/renderer/RenderProgs_GLSL.cpp
View file

@ -1654,7 +1654,6 @@ int idRenderProgManager::FindGLSLProgram( const char* name, int vIndex, int fIn
{
if( ( renderProgs[i].vertexShaderIndex == vIndex ) && ( renderProgs[i].fragmentShaderIndex == fIndex ) )
{
LoadGLSLProgram( i, vIndex, fIndex );
return i;
}
}

13
neo/renderer/Vulkan/RenderProgs_VK.cpp
View file

@ -627,9 +627,9 @@ void idRenderProgManager::LoadShader( shader_t& shader )
// point we directly load a binary and the program source code is not available on the consoles
bool hasGPUSkinning = false;
if( idStr::Icmp( shader.name.c_str(), "heatHaze.vfp" ) == 0 ||
idStr::Icmp( shader.name.c_str(), "heatHazeWithMask.vfp" ) == 0 ||
idStr::Icmp( shader.name.c_str(), "heatHazeWithMaskAndVertex.vfp" ) == 0 ||
if( idStr::Icmp( shader.name.c_str(), "heatHaze" ) == 0 ||
idStr::Icmp( shader.name.c_str(), "heatHazeWithMask" ) == 0 ||
idStr::Icmp( shader.name.c_str(), "heatHazeWithMaskAndVertex" ) == 0 ||
( BIT( USE_GPU_SKINNING ) & shader.shaderFeatures ) )
{
hasGPUSkinning = true;
@ -1522,6 +1522,13 @@ void idRenderProgManager::CommitUniforms( uint64 stateBits )
pipeline );
}
void idRenderProgManager::CachePipeline( uint64 stateBits )
{
renderProg_t& prog = renderProgs[ current ];
VkPipeline pipeline = prog.GetPipeline( stateBits, shaders[ prog.vertexShaderIndex ].module, shaders[ prog.fragmentShaderIndex ].module );
}
void idRenderProgManager::PrintPipelines()
{