Skip to content

Commit bec3aa0

Browse files
VReaperVVReaperV
committed
Only update PushBuffer if any uniform has actually changed
1 parent 1e2423c commit bec3aa0

File tree

4 files changed

+122
-52
lines changed

4 files changed

+122
-52
lines changed

‎src/engine/renderer/gl_shader.cpp

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2453,6 +2453,8 @@ void GLShader::WriteUniformsToBuffer( uint32_t* buffer, const Mode mode, const i
24532453
bufPtr = uniform->WriteToBuffer( bufPtr );
24542454
}
24552455
}
2456+
2457+
uniformsUpdated = false;
24562458
}
24572459

24582460
GLShader_generic::GLShader_generic() :

‎src/engine/renderer/gl_shader.h

Lines changed: 110 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -196,6 +196,8 @@ class GLShader {
196196
PUSH
197197
};
198198

199+
bool uniformsUpdated = true;
200+
199201
void MarkProgramForBuilding( int deformIndex );
200202
GLuint GetProgram( int deformIndex, const bool buildOneShader );
201203
void BindProgram( int deformIndex );
@@ -543,20 +545,28 @@ class GLUniformSampler : protected GLUniform {
543545
currentValue = value;
544546
}
545547

546-
void SetValueBindless( GLint64 value ) {
547-
currentValueBindless = value;
548+
void SetValueBindless( GLuint64 value ) {
549+
if ( !glConfig2.usingBindlessTextures ) {
550+
return;
551+
}
548552

549-
if ( glConfig2.usingBindlessTextures ) {
550-
if ( _shader->UseMaterialSystem() && _updateType == TEXDATA_OR_PUSH ) {
551-
return;
553+
if ( _shader->UseMaterialSystem() && _updateType == TEXDATA_OR_PUSH ) {
554+
if ( currentValueBindless != value ) {
555+
currentValueBindless = value;
556+
_shader->uniformsUpdated = true;
552557
}
558+
return;
559+
}
553560

554-
if ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) {
555-
return;
561+
if ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) {
562+
if ( currentValueBindless != value ) {
563+
currentValueBindless = value;
564+
_shader->uniformsUpdated = true;
556565
}
557-
558-
glUniformHandleui64ARB( GetLocation(), currentValueBindless );
566+
return;
559567
}
568+
569+
glUniformHandleui64ARB( GetLocation(), value );
560570
}
561571

562572
uint32_t* WriteToBuffer( uint32_t* buffer ) override {
@@ -612,14 +622,18 @@ class GLUniform1i : protected GLUniform
612622

613623
inline void SetValue( int value )
614624
{
615-
ShaderProgramDescriptor *p = _shader->GetProgram();
616-
617625
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
618626
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
619-
currentValue = value;
627+
628+
if ( currentValue != value ) {
629+
currentValue = value;
630+
_shader->uniformsUpdated = true;
631+
}
632+
620633
return;
621634
}
622635

636+
ShaderProgramDescriptor *p = _shader->GetProgram();
623637
ASSERT_EQ( p, glState.currentProgram );
624638

625639
#if defined( USE_UNIFORM_FIREWALL )
@@ -656,14 +670,18 @@ class GLUniform1ui : protected GLUniform {
656670
}
657671

658672
inline void SetValue( uint value ) {
659-
ShaderProgramDescriptor* p = _shader->GetProgram();
660-
661673
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
662674
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
663-
currentValue = value;
675+
676+
if ( currentValue != value ) {
677+
currentValue = value;
678+
_shader->uniformsUpdated = true;
679+
}
680+
664681
return;
665682
}
666683

684+
ShaderProgramDescriptor* p = _shader->GetProgram();
667685
ASSERT_EQ( p, glState.currentProgram );
668686

669687
#if defined( USE_UNIFORM_FIREWALL )
@@ -699,14 +717,18 @@ class GLUniform1Bool : protected GLUniform {
699717
}
700718

701719
inline void SetValue( int value ) {
702-
ShaderProgramDescriptor* p = _shader->GetProgram();
703-
704720
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
705721
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
706-
currentValue = value;
722+
723+
if ( currentValue != value ) {
724+
currentValue = value;
725+
_shader->uniformsUpdated = true;
726+
}
727+
707728
return;
708729
}
709730

731+
ShaderProgramDescriptor* p = _shader->GetProgram();
710732
ASSERT_EQ( p, glState.currentProgram );
711733

712734
#if defined( USE_UNIFORM_FIREWALL )
@@ -745,14 +767,18 @@ class GLUniform1f : protected GLUniform
745767

746768
inline void SetValue( float value )
747769
{
748-
ShaderProgramDescriptor *p = _shader->GetProgram();
749-
750770
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
751771
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
752-
currentValue = value;
772+
773+
if ( currentValue != value ) {
774+
currentValue = value;
775+
_shader->uniformsUpdated = true;
776+
}
777+
753778
return;
754779
}
755780

781+
ShaderProgramDescriptor *p = _shader->GetProgram();
756782
ASSERT_EQ( p, glState.currentProgram );
757783

758784
#if defined( USE_UNIFORM_FIREWALL )
@@ -793,14 +819,18 @@ class GLUniform1fv : protected GLUniform
793819

794820
inline void SetValue( int numFloats, float *f )
795821
{
796-
ShaderProgramDescriptor *p = _shader->GetProgram();
797-
798822
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
799823
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
800-
memcpy( currentValue.data(), f, numFloats * sizeof( float ) );
824+
825+
if ( !memcmp( currentValue.data(), f, numFloats * sizeof( float ) ) ) {
826+
memcpy( currentValue.data(), f, numFloats * sizeof( float ) );
827+
_shader->uniformsUpdated = true;
828+
}
829+
801830
return;
802831
}
803832

833+
ShaderProgramDescriptor *p = _shader->GetProgram();
804834
ASSERT_EQ( p, glState.currentProgram );
805835

806836
glUniform1fv( p->uniformLocations[ _locationIndex ], numFloats, f );
@@ -827,14 +857,18 @@ class GLUniform2f : protected GLUniform
827857

828858
inline void SetValue( const vec2_t v )
829859
{
830-
ShaderProgramDescriptor *p = _shader->GetProgram();
831-
832860
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
833861
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
834-
Vector2Copy( v, currentValue );
862+
863+
if ( currentValue[0] != v[0] || currentValue[1] != v[1] ) {
864+
Vector2Copy( v, currentValue );
865+
_shader->uniformsUpdated = true;
866+
}
867+
835868
return;
836869
}
837870

871+
ShaderProgramDescriptor *p = _shader->GetProgram();
838872
ASSERT_EQ( p, glState.currentProgram );
839873

840874
#if defined( USE_UNIFORM_FIREWALL )
@@ -878,14 +912,18 @@ class GLUniform3f : protected GLUniform
878912

879913
inline void SetValue( const vec3_t v )
880914
{
881-
ShaderProgramDescriptor *p = _shader->GetProgram();
882-
883915
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
884916
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
885-
VectorCopy( v, currentValue );
917+
918+
if ( !VectorCompare( currentValue, v ) ) {
919+
VectorCopy( v, currentValue );
920+
_shader->uniformsUpdated = true;
921+
}
922+
886923
return;
887924
}
888925

926+
ShaderProgramDescriptor *p = _shader->GetProgram();
889927
ASSERT_EQ( p, glState.currentProgram );
890928

891929
#if defined( USE_UNIFORM_FIREWALL )
@@ -929,14 +967,18 @@ class GLUniform4f : protected GLUniform
929967

930968
inline void SetValue( const vec4_t v )
931969
{
932-
ShaderProgramDescriptor *p = _shader->GetProgram();
933-
934970
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
935971
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
936-
Vector4Copy( v, currentValue );
972+
973+
if ( !VectorCompare( currentValue, v ) || currentValue[3] != v[3] ) {
974+
Vector4Copy( v, currentValue );
975+
_shader->uniformsUpdated = true;
976+
}
977+
937978
return;
938979
}
939980

981+
ShaderProgramDescriptor *p = _shader->GetProgram();
940982
ASSERT_EQ( p, glState.currentProgram );
941983

942984
#if defined( USE_UNIFORM_FIREWALL )
@@ -977,14 +1019,18 @@ class GLUniform4fv : protected GLUniform
9771019

9781020
inline void SetValue( int numV, vec4_t *v )
9791021
{
980-
ShaderProgramDescriptor *p = _shader->GetProgram();
981-
9821022
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
9831023
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
984-
memcpy( currentValue.data(), v, numV * sizeof( vec4_t ) );
1024+
1025+
if ( !memcmp( currentValue.data(), v, numV * sizeof( vec4_t ) ) ) {
1026+
memcpy( currentValue.data(), v, numV * sizeof( vec4_t ) );
1027+
_shader->uniformsUpdated = true;
1028+
}
1029+
9851030
return;
9861031
}
9871032

1033+
ShaderProgramDescriptor *p = _shader->GetProgram();
9881034
ASSERT_EQ( p, glState.currentProgram );
9891035

9901036
glUniform4fv( p->uniformLocations[ _locationIndex ], numV, &v[ 0 ][ 0 ] );
@@ -1011,14 +1057,18 @@ class GLUniformMatrix4f : protected GLUniform
10111057

10121058
inline void SetValue( GLboolean transpose, const matrix_t m )
10131059
{
1014-
ShaderProgramDescriptor *p = _shader->GetProgram();
1015-
10161060
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
10171061
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
1018-
MatrixCopy( m, currentValue );
1062+
1063+
if ( !MatrixCompare( currentValue, m ) ) {
1064+
MatrixCopy( m, currentValue );
1065+
_shader->uniformsUpdated = true;
1066+
}
1067+
10191068
return;
10201069
}
10211070

1071+
ShaderProgramDescriptor *p = _shader->GetProgram();
10221072
ASSERT_EQ( p, glState.currentProgram );
10231073

10241074
#if defined( USE_UNIFORM_FIREWALL )
@@ -1055,14 +1105,18 @@ class GLUniformMatrix32f : protected GLUniform {
10551105
}
10561106

10571107
inline void SetValue( GLboolean transpose, const vec_t* m ) {
1058-
ShaderProgramDescriptor* p = _shader->GetProgram();
1059-
10601108
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
10611109
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
1062-
memcpy( currentValue, m, 6 * sizeof( float ) );
1110+
1111+
if ( !memcmp( currentValue, m, 6 * sizeof( float ) ) ) {
1112+
memcpy( currentValue, m, 6 * sizeof( float ) );
1113+
_shader->uniformsUpdated = true;
1114+
}
1115+
10631116
return;
10641117
}
10651118

1119+
ShaderProgramDescriptor* p = _shader->GetProgram();
10661120
ASSERT_EQ( p, glState.currentProgram );
10671121

10681122
glUniformMatrix3x2fv( p->uniformLocations[_locationIndex], 1, transpose, m );
@@ -1092,14 +1146,18 @@ class GLUniformMatrix4fv : protected GLUniform
10921146

10931147
inline void SetValue( int numMatrices, GLboolean transpose, const matrix_t *m )
10941148
{
1095-
ShaderProgramDescriptor *p = _shader->GetProgram();
1096-
10971149
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
10981150
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
1099-
memcpy( currentValue.data(), m, numMatrices * sizeof( matrix_t ) );
1151+
1152+
if ( !memcmp( currentValue.data(), m, numMatrices * sizeof( matrix_t ) ) ) {
1153+
memcpy( currentValue.data(), m, numMatrices * sizeof( matrix_t ) );
1154+
_shader->uniformsUpdated = true;
1155+
}
1156+
11001157
return;
11011158
}
11021159

1160+
ShaderProgramDescriptor *p = _shader->GetProgram();
11031161
ASSERT_EQ( p, glState.currentProgram );
11041162

11051163
glUniformMatrix4fv( p->uniformLocations[ _locationIndex ], numMatrices, transpose, &m[ 0 ][ 0 ] );
@@ -1125,14 +1183,18 @@ class GLUniformMatrix34fv : protected GLUniform
11251183

11261184
inline void SetValue( int numMatrices, GLboolean transpose, const float *m )
11271185
{
1128-
ShaderProgramDescriptor *p = _shader->GetProgram();
1129-
11301186
if ( ( _shader->UseMaterialSystem() && _updateType == MATERIAL_OR_PUSH )
11311187
|| ( glConfig2.pushBufferAvailable && _updateType <= FRAME ) ) {
1132-
memcpy( currentValue.data(), m, numMatrices * sizeof( matrix_t ) );
1188+
1189+
if ( !memcmp( currentValue.data(), m, numMatrices * sizeof( matrix_t ) ) ) {
1190+
memcpy( currentValue.data(), m, numMatrices * sizeof( matrix_t ) );
1191+
_shader->uniformsUpdated = true;
1192+
}
1193+
11331194
return;
11341195
}
11351196

1197+
ShaderProgramDescriptor *p = _shader->GetProgram();
11361198
ASSERT_EQ( p, glState.currentProgram );
11371199

11381200
glUniformMatrix3x4fv( p->uniformLocations[ _locationIndex ], numMatrices, transpose, m );

‎src/engine/renderer/tr_backend.cpp

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2660,8 +2660,6 @@ static void SetFrameUniforms() {
26602660

26612661
GLIMP_LOGCOMMENT( "--- SetFrameUniforms ---" );
26622662

2663-
uint32_t* data = pushBuffer.MapGlobalUniformData( GLUniform::FRAME );
2664-
26652663
globalUBOProxy->SetUniform_blurVec( backEnd.refdef.blurVec );
26662664
globalUBOProxy->SetUniform_numLights( backEnd.refdef.numLights );
26672665

@@ -2682,6 +2680,11 @@ static void SetFrameUniforms() {
26822680
materialSystem.SetFrameUniforms();
26832681
}
26842682

2683+
if ( !globalUBOProxy->uniformsUpdated ) {
2684+
return;
2685+
}
2686+
2687+
uint32_t* data = pushBuffer.MapGlobalUniformData( GLUniform::FRAME );
26852688
globalUBOProxy->WriteUniformsToBuffer( data, GLShader::PUSH, GLUniform::FRAME );
26862689

26872690
pushBuffer.PushGlobalUniforms();

‎src/engine/renderer/tr_bsp.cpp

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4468,8 +4468,6 @@ static void SetWorldLight() {
44684468
static void SetConstUniforms() {
44694469
GLIMP_LOGCOMMENT( "--- SetConstUniforms ---" );
44704470

4471-
uint32_t* data = pushBuffer.MapGlobalUniformData( GLUniform::CONST );
4472-
44734471
globalUBOProxy->SetUniform_LightGridOrigin( tr.world->lightGridGLOrigin );
44744472
globalUBOProxy->SetUniform_LightGridScale( tr.world->lightGridGLScale );
44754473

@@ -4512,6 +4510,11 @@ static void SetConstUniforms() {
45124510
materialSystem.SetConstUniforms();
45134511
}
45144512

4513+
if ( !globalUBOProxy->uniformsUpdated ) {
4514+
return;
4515+
}
4516+
4517+
uint32_t* data = pushBuffer.MapGlobalUniformData( GLUniform::CONST );
45154518
globalUBOProxy->WriteUniformsToBuffer( data, GLShader::PUSH, GLUniform::CONST );
45164519

45174520
pushBuffer.PushGlobalUniforms();

0 commit comments

Comments
 (0)