Remove bindless layout declaration from compute header

src/engine/renderer/Material.cpp

@@ -1052,6 +1052,9 @@ void MaterialSystem::GenerateDepthImages( const int width, const int height, ima
 		mipmapWidth = mipmapWidth > 1 ? mipmapWidth >> 1 : 1;
 		mipmapHeight = mipmapHeight > 1 ? mipmapHeight >> 1 : 1;
 	}
+
+	depthImage->texture->GenBindlessImageHandle();
+	depthImage->texture->MakeImagesResident( GL_READ_WRITE );
 }
 
 void BindShaderNONE( Material* ) {
@@ -1596,8 +1599,12 @@ void MaterialSystem::DepthReduction() {
 	uint32_t globalWorkgroupX = ( width + 7 ) / 8;
 	uint32_t globalWorkgroupY = ( height + 7 ) / 8;
 
-	GL_Bind( tr.currentDepthImage );
-	glBindImageTexture( 2, depthImage->texnum, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32F );
+	gl_depthReductionShader->SetUniform_DepthMapBindless( GL_BindToTMU( 0, tr.currentDepthImage ) );
+	// glBindImageTexture( 2, depthImage->texnum, 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32F );
+	// glUniformHandleui64ARB( 1, depthImage->texture->bindlessImageHandles[0] 
+	GL_CheckErrors();
+	glUniform2uiv( 1, 1, ( const GLuint* ) &depthImage->texture->bindlessImageHandles[0] );
+	GL_CheckErrors();
 
 	gl_depthReductionShader->SetUniform_InitialDepthLevel( true );
 	gl_depthReductionShader->SetUniform_ViewWidth( width );
@@ -1611,8 +1618,15 @@ void MaterialSystem::DepthReduction() {
 		globalWorkgroupX = ( width + 7 ) / 8;
 		globalWorkgroupY = ( height + 7 ) / 8;
 
-		glBindImageTexture( 1, depthImage->texnum, i, GL_FALSE, 0, GL_READ_ONLY, GL_R32F );
-		glBindImageTexture( 2, depthImage->texnum, i + 1, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32F );
+		// glBindImageTexture( 1, depthImage->texnum, i, GL_FALSE, 0, GL_READ_ONLY, GL_R32F );
+		// glBindImageTexture( 2, depthImage->texnum, i + 1, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32F );
+		// glUniformHandleui64ARB( 0, depthImage->texture->bindlessImageHandles[i] );
+		// glUniformHandleui64ARB( 1, depthImage->texture->bindlessImageHandles[i + 1] );
+		GL_CheckErrors();
+		glUniform2uiv( 0, 1, ( const GLuint* ) &depthImage->texture->bindlessImageHandles[i] );
+		GL_CheckErrors();
+		glUniform2uiv( 1, 1, ( const GLuint* ) &depthImage->texture->bindlessImageHandles[i + 1] );
+		GL_CheckErrors();
 
 		gl_depthReductionShader->SetUniform_InitialDepthLevel( false );
 		gl_depthReductionShader->SetUniform_ViewWidth( width );
@@ -1661,7 +1675,7 @@ void MaterialSystem::CullSurfaces() {
 		gl_cullShader->BindProgram( 0 );
 		uint32_t globalWorkGroupX = totalDrawSurfs % MAX_COMMAND_COUNTERS == 0 ?
 			totalDrawSurfs / MAX_COMMAND_COUNTERS : totalDrawSurfs / MAX_COMMAND_COUNTERS + 1;
-		GL_Bind( depthImage );
+		gl_cullShader->SetUniform_DepthMapBindless( GL_BindToTMU( 0, depthImage ) );
 		gl_cullShader->SetUniform_Frame( nextFrame );
 		gl_cullShader->SetUniform_ViewID( view );
 		gl_cullShader->SetUniform_TotalDrawSurfs( totalDrawSurfs );
@@ -1829,6 +1843,8 @@ void MaterialSystem::Free() {
 		}
 	}
 
+	depthImage->texture->MakeImagesNonResident();
+
 	currentFrame = 0;
 	nextFrame = 1;
 	maxStages = 0;

src/engine/renderer/TextureManager.cpp

@@ -48,16 +48,34 @@ bool Texture::IsResident() const {
 	return bindlessTextureResident;
 }
 
+bool Texture::AreImagesResident() const {
+	return bindlessImagesResident;
+}
+
 void Texture::MakeResident() {
 	glMakeTextureHandleResidentARB( bindlessTextureHandle );
 	bindlessTextureResident = true;
 }
 
+void Texture::MakeImagesResident( const GLenum access ) {
+	for ( uint8_t i = 0; i < mipLevels; i++ ) {
+		glMakeImageHandleResidentARB( bindlessImageHandles[i], access );
+	}
+	bindlessImagesResident = true;
+}
+
 void Texture::MakeNonResident() {
 	glMakeTextureHandleNonResidentARB( bindlessTextureHandle );
 	bindlessTextureResident = false;
 }
 
+void Texture::MakeImagesNonResident() {
+	for ( uint8_t i = 0; i < mipLevels; i++ ) {
+		glMakeImageHandleNonResidentARB( bindlessImageHandles[i] );
+	}
+	bindlessImagesResident = false;
+}
+
 void Texture::GenBindlessHandle() {
 	bindlessTextureHandle = glGetTextureHandleARB( textureHandle );
 
@@ -68,6 +86,21 @@ void Texture::GenBindlessHandle() {
 	hasBindlessHandle = true;
 }
 
+void Texture::GenBindlessImageHandle() {
+	if ( target != GL_TEXTURE_2D ) {
+		Sys::Drop( "Bindless image handles for layered textures are currently unsupported" );
+	}
+
+	for ( uint8_t level = 0; level < mipLevels; level++ ) {
+		bindlessImageHandles[level] = glGetImageHandleARB( textureHandle, level, GL_FALSE, 0, format );
+		if ( bindlessImageHandles[level] == 0 ) {
+			Sys::Drop( "Failed to generate bindless image handle" );
+		}
+	}
+
+	hasBindlessImageHandles = true;
+}
+
 TextureManager::TextureManager() = default;
 TextureManager::~TextureManager() = default;
 

src/engine/renderer/TextureManager.h

@@ -43,18 +43,28 @@ class Texture {
 	bool hasBindlessHandle = false;
 
 	GLenum target = GL_TEXTURE_2D;
+	GLenum format = GL_RGBA8;
+
+	bool hasBindlessImageHandles = false;
+	uint8_t mipLevels = 0;
+	GLuint64 bindlessImageHandles[16]; // Enough for all mipmaps of a 32768x32768 texture, which is the current maximum
 
 	Texture();
 	~Texture();
 
 	bool IsResident() const;
+	bool AreImagesResident() const;
 	void MakeResident();
+	void MakeImagesResident( const GLenum access );
 	void MakeNonResident();
+	void MakeImagesNonResident();
 
-	void GenBindlessHandle();;
+	void GenBindlessHandle();
+	void GenBindlessImageHandle();
 
 	private:
 		bool bindlessTextureResident = false;
+		bool bindlessImagesResident = false;
 };
 
 class TextureManager {

src/engine/renderer/gl_shader.cpp

@@ -570,6 +570,7 @@ static std::string GenComputeHeader() {
 	AddDefine( str, "MAX_COMMAND_COUNTERS", MAX_COMMAND_COUNTERS );
 
 	if ( glConfig2.bindlessTexturesAvailable ) {
+		str += "layout(bindless_sampler) uniform;\n";
 		str += "layout(bindless_image) uniform;\n";
 	}
 
@@ -2937,6 +2938,7 @@ void GLShader_fxaa::SetShaderProgramUniforms( shaderProgram_t *shaderProgram )
 
 GLShader_cull::GLShader_cull( GLShaderManager* manager ) :
 	GLShader( "cull", ATTR_POSITION, manager, false, false, true ),
+	u_DepthMap( this ),
 	u_Frame( this ),
 	u_ViewID( this ),
 	u_TotalDrawSurfs( this ),
@@ -2956,15 +2958,12 @@ GLShader_cull::GLShader_cull( GLShaderManager* manager ) :
 
 GLShader_depthReduction::GLShader_depthReduction( GLShaderManager* manager ) :
 	GLShader( "depthReduction", ATTR_POSITION, manager, false, false, true ),
+	u_DepthMap( this ),
 	u_ViewWidth( this ),
 	u_ViewHeight( this ),
 	u_InitialDepthLevel( this ) {
 }
 
-void GLShader_depthReduction::SetShaderProgramUniforms( shaderProgram_t* shaderProgram ) {
-	glUniform1i( glGetUniformLocation( shaderProgram->program, "depthTextureInitial" ), 0 );
-}
-
 GLShader_clearSurfaces::GLShader_clearSurfaces( GLShaderManager* manager ) :
 	GLShader( "clearSurfaces", ATTR_POSITION, manager, false, false, true ),
 	u_Frame( this ) {

src/engine/renderer/gl_shader.h

@@ -4685,6 +4685,7 @@ class GLShader_fxaa :
 
 class GLShader_cull :
 	public GLShader,
+	public u_DepthMap,
 	public u_Frame,
 	public u_ViewID,
 	public u_TotalDrawSurfs,
@@ -4706,12 +4707,12 @@ class GLShader_cull :
 
 class GLShader_depthReduction :
 	public GLShader,
+	public u_DepthMap,
 	public u_ViewWidth,
 	public u_ViewHeight,
 	public u_InitialDepthLevel {
 	public:
 	GLShader_depthReduction( GLShaderManager* manager );
-	void SetShaderProgramUniforms( shaderProgram_t* shaderProgram ) override;
 };
 
 class GLShader_clearSurfaces :

src/engine/renderer/glsl_source/cull_cp.glsl

@@ -39,7 +39,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // Keep this to 64 because we don't want extra shared mem etc. to be allocated, and to minimize wasted lanes
 layout (local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
 
-layout(binding = 0) uniform sampler2D depthImage;
+/* layout(binding = 0) */ uniform sampler2D u_DepthMap;
 
 layout(std430, binding = 1) readonly restrict buffer surfaceDescriptorsSSBO {
 	SurfaceDescriptor surfaces[];
@@ -139,10 +139,10 @@ bool CullSurface( in BoundingSphere boundingSphere ) {
 		depthCoords.w = clamp( depthCoords.w, 0, int( ( u_ViewHeight >> level ) - 1 ) );
 
 		vec4 depthValues;
-		depthValues.x = texelFetch( depthImage, depthCoords.xy, level ).r;
-		depthValues.y = texelFetch( depthImage, depthCoords.zy, level ).r;
-		depthValues.z = texelFetch( depthImage, depthCoords.xw, level ).r;
-		depthValues.w = texelFetch( depthImage, depthCoords.zw, level ).r;
+		depthValues.x = texelFetch( u_DepthMap, depthCoords.xy, level ).r;
+		depthValues.y = texelFetch( u_DepthMap, depthCoords.zy, level ).r;
+		depthValues.z = texelFetch( u_DepthMap, depthCoords.xw, level ).r;
+		depthValues.w = texelFetch( u_DepthMap, depthCoords.zw, level ).r;
 
 		const float surfaceDepth = max( max( max( depthValues.x, depthValues.y ), depthValues.z ), depthValues.w );
 

src/engine/renderer/glsl_source/depthReduction_cp.glsl

@@ -39,9 +39,12 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // Keep this to 8x8 because we don't want extra shared mem etc. to be allocated, and to minimize wasted lanes
 layout (local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
 
-layout(binding = 0) uniform sampler2D depthTextureInitial;
-layout(r32f, binding = 1) uniform readonly image2D depthImageIn;
-layout(r32f, binding = 2) uniform writeonly image2D depthImageOut;
+/* layout(binding = 0) */ uniform sampler2D u_DepthMap;
+// layout(r32f, binding = 1) uniform readonly image2D depthImageIn;
+// layout(r32f, binding = 2) uniform writeonly image2D depthImageOut;
+
+layout(location = 0) uniform uvec2 depthInTest;
+layout(location = 1) uniform uvec2 depthOutTest;
 
 uniform uint u_ViewWidth;
 uniform uint u_ViewHeight;
@@ -55,9 +58,12 @@ void main() {
         return;
     };
 
+     layout(r32f) image2D depthImageIn = layout(r32f) image2D( depthInTest );
+     layout(r32f) image2D depthImageOut = layout(r32f) image2D( depthOutTest );
+
     // Depth buffer uses a packed D24S8 format, so we have to copy it over to an r32f image first
     if( u_InitialDepthLevel ) {
-        vec4 depthOut = texelFetch( depthTextureInitial, position, 0 );
+        vec4 depthOut = texelFetch( u_DepthMap, position, 0 );
         imageStore( depthImageOut, position, depthOut );
     } else {
         float depth[4];

src/engine/renderer/tr_image.cpp

@@ -1338,6 +1338,9 @@ void R_UploadImage( const byte **dataArray, int numLayers, int numMips, image_t
 			image->bits |= IF_ALPHA;
 	}
 
+	image->texture->format = internalFormat;
+	image->texture->mipLevels = log2f( std::max( image->uploadWidth, image->uploadHeight ) ) + 1;
+
 	GL_Unbind( image );
 }