[GL] Allocate real textures for NullTexture

This commit changes how NullTexture is handled by the GL backend.
Prior to this commit, NullTexture was simply translated to the default
texture with handle 0. This resulted to a lot of debug output warnings
when sampled from a shader (observed on NVIDIA).

Using a real (uninitialized) texture avoids these warnings.

Author: hyazinthh

RELEASE_NOTES.md

@@ -1,5 +1,6 @@
 - [GL] Added `Context.GetDebugMessages`
 - [GL] Added `Context.OnDispose`
+- [GL] Represent `NullTexture` with a proper texture object instead of a texture with handle 0.
 
 ### 5.6.5
 - Fixed support for 64-bit attributes and uniforms

src/Aardvark.Rendering.GL/Resources/Textures/Texture.fs

@@ -89,13 +89,12 @@ type Texture =
             GL.DeleteTexture x.Handle
             ResourceCounts.removeTexture x.Context x.SizeInBytes
             GL.Check "could not delete texture"
+            x.Handle <- 0
 
         member x.Dispose() =
-            if notNull x.Context then // NullTexture has no context
-                using x.Context.ResourceLock (fun _ ->
-                    x.Destroy()
-                    x.Handle <- 0
-                )
+            using x.Context.ResourceLock (fun _ ->
+                x.Destroy()
+            )
 
         interface IBackendTexture with
             member x.Runtime = x.Context.Runtime :> ITextureRuntime
@@ -148,6 +147,15 @@ type Texture =
             new Texture(ctx, handle, dimension, mipMapLevels, multisamples, size, cnt, isArray, format)
     end
 
+type internal NullTexture(inner : Texture) =
+    inherit Texture(inner.Context, inner.Handle, inner.Dimension, inner.MipMapLevels, inner.Multisamples,
+                    V3i.Zero, inner.Count, inner.IsArray, inner.Format, inner.SizeInBytes)
+    override this.Destroy() = ()
+
+    override _.Name
+        with get() = base.Name
+        and set _ = ()
+
 type internal SharedTexture(ctx : Context, handle : int, external : IExportedBackendTexture, memory : SharedMemoryBlock) =
     inherit Texture(ctx, handle,
                     external.Dimension, external.MipMapLevels, external.Samples, external.Size,
@@ -168,10 +176,12 @@ type TextureViewHandle(ctx : Context, handle : int, dimension : TextureDimension
         GL.DeleteTexture x.Handle
         ResourceCounts.removeTextureView x.Context
         GL.Check "could not delete texture view"
+        x.Handle <- 0
 
 // Used for determining the bind target of null textures
 type internal TextureProperties =
     { Dimension      : TextureDimension
+      Format         : TextureFormat
       IsMultisampled : bool
       IsArray        : bool }
 
@@ -184,13 +194,25 @@ module internal TextureUtilitiesAndExtensions =
 
     type FShade.GLSL.GLSLSamplerType with
         member x.Properties =
+            let format =
+                if x.isShadow then TextureFormat.DepthComponent32f
+                elif x.IsInteger then TextureFormat.Rgba8i
+                else TextureFormat.Rgba8
+
             { Dimension      = x.dimension.TextureDimension
+              Format         = format
               IsMultisampled = x.isMS
               IsArray        = x.isArray }
 
     type FShade.GLSL.GLSLImageType with
         member x.Properties =
+            let format =
+                match x.format with
+                | Some fmt -> fmt.TextureFormat
+                | _ -> if x.IsInteger then TextureFormat.Rgba8i else TextureFormat.Rgba8
+
             { Dimension      = x.dimension.TextureDimension
+              Format         = format
               IsMultisampled = x.isMS
               IsArray        = x.isArray }
 
@@ -658,14 +680,36 @@ module TextureCreationExtensions =
 [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
 module Texture =
 
-    let private emptyStore = ConcurrentDictionary<TextureProperties, Texture>()
+    let internal getNull =
+        let store = ConcurrentDictionary<Context * TextureProperties, Lazy<NullTexture>>()
+
+        fun (properties : TextureProperties) (context : Context) ->
+            let texture =
+                store.GetOrAdd((context, properties), fun (context, properties as key) ->
+                    lazy (
+                        let inner =
+                            let count = if properties.IsArray then 1 else 0
+                            let samples = if properties.IsMultisampled then 2 else 1
+
+                            context.CreateTexture(
+                                V3i 8, properties.Dimension, properties.Format,
+                                slices = count, levels = 1, samples = samples
+                            )
+
+                        inner.Name <- "Null"
+                        let texture = new NullTexture(inner)
+
+                        context.OnDispose.Add(fun _ ->
+                            store.TryRemove key |> ignore
+                            inner.Dispose()
+                            texture.Handle <- 0
+                        )
+
+                        texture
+                    )
+                ).Value
 
-    let internal empty (properties : TextureProperties) =
-        emptyStore.GetOrAdd(properties, fun _ ->
-            let count = if properties.IsArray then Some 1 else None
-            let samples = if properties.IsMultisampled then 2 else 1
-            new Texture(null, 0, properties.Dimension, 1, samples, V3i.Zero, count, TextureFormat.Rgba8, 0L)
-        )
+            texture :> Texture
 
     let create1D (c : Context) (size : int) (mipLevels : int) (format : TextureFormat) =
         c.CreateTexture1D(size, mipLevels, format)

src/Aardvark.Rendering.GL/Resources/Textures/TextureUpload.fs

@@ -366,13 +366,13 @@ module ContextTextureUploadExtensions =
                     Texture.uploadPixVolume texture info.HasWantMipMaps 0 V3i.Zero data
                     texture
 
-                | :? NullTexture ->
+                | :? Aardvark.Rendering.NullTexture ->
                     let properties =
                         match properties with
                         | ValueSome p -> p
                         | _ -> failf "cannot prepare null texture without properties"
 
-                    Texture.empty properties
+                    Texture.getNull properties this
 
                 | :? Texture as o ->
                     o

src/Aardvark.Rendering/Resources/Textures/TextureExtensions.fs

@@ -300,7 +300,7 @@ type ITextureRuntimeExtensions private() =
                          [<Optional; DefaultParameterValue(0)>] slice : int,
                          [<Optional; DefaultParameterValue(V2i())>] offset : V2i,
                          [<Optional; DefaultParameterValue(V2i())>] size : V2i) =
-        this.Upload(texture.[TextureAspect.Color, level, slice], source, offset, size)
+        this.Upload(texture.[texture.Format.Aspect, level, slice], source, offset, size)
 
     // ================================================================================================================
     // Upload 3D
@@ -344,7 +344,7 @@ type ITextureRuntimeExtensions private() =
                          [<Optional; DefaultParameterValue(0)>] slice : int,
                          [<Optional; DefaultParameterValue(V3i())>] offset : V3i,
                          [<Optional; DefaultParameterValue(V3i())>] size : V3i) =
-        this.Upload(texture.[TextureAspect.Color, level, slice], source, offset, size)
+        this.Upload(texture.[texture.Format.Aspect, level, slice], source, offset, size)
 
 
     // ================================================================================================================

src/Tests/Aardvark.Rendering.Tests/Tests/Texture/Upload.fs

@@ -145,8 +145,11 @@ module TextureUpload =
             let randomBuffer = randomTask |> RenderTask.renderToColor (AVal.init <| V2i(256))
             randomBuffer.Acquire()
 
-            try randomBuffer.GetValue() |> ignore
-            finally randomBuffer.Release()
+            let random =
+                try
+                    randomBuffer.GetValue().Download().AsPixImage<uint8>()
+                finally
+                    randomBuffer.Release()
 
             use task =
                 Sg.fullScreenQuad
@@ -155,11 +158,29 @@ module TextureUpload =
                 |> Sg.compile runtime signature
 
             // Render sampling the null texture.
-            // We can't check the result since null textures are uninitialized, just make sure there are no errors.
+            // We can't check the result since null textures are uninitialized, just make sure there are no errors, and we
+            // get a different result than with the random texture.
             let buffer = task |> RenderTask.renderToColor (AVal.init <| V2i(256))
             buffer.Acquire()
-            try buffer.GetValue() |> ignore
-            finally buffer.Release()
+
+            let result =
+                try
+                    buffer.GetValue().Download().AsPixImage<uint8>()
+                finally
+                    buffer.Release()
+
+            Expect.equal result.Size random.Size "Unexpected result size"
+            Expect.notEqual result.Data random.Data "Output with null texture matches output with random texture"
+
+            // Make sure we bound a real texture by checking the GL debug output
+            match runtime with
+            | :? GL.Runtime as runtime ->
+                let messages = runtime.Context.GetDebugMessages()
+                for msg in messages do
+                    if msg.Message.Contains "The texture object (0) bound" then
+                        failtest msg.Message
+            | _ ->
+                ()
 
         let texture1DNull (runtime : IRuntime) =
             let diffuseSampler =
@@ -725,6 +746,21 @@ module TextureUpload =
 
             runtime |> renderQuadWithNullTexture shader randomTexture
 
+        let private renderRandomToTexture2D (texture: IBackendTexture) (runtime: IRuntime) =
+            use signature = runtime.CreateFramebufferSignature([DefaultSemantic.Colors, TextureFormat.Rgba8], samples = texture.Samples)
+            use framebuffer = runtime.CreateFramebuffer(signature, [DefaultSemantic.Colors, texture.GetOutputView()])
+
+            use ss = runtime.CreateTexture2D(texture.Size.XY, TextureFormat.Rgba8)
+            ss.Upload(PixImage.random8ui texture.Size.XY)
+
+            use task =
+                Sg.fullScreenQuad
+                |> Sg.diffuseTexture' ss
+                |> Sg.shader { do! DefaultSurfaces.diffuseTexture }
+                |> Sg.compile runtime signature
+
+            task.Run(framebuffer)
+
         let texture2DNullMultisampled (runtime : IRuntime) =
             let diffuseSampler =
                 sampler2dMS {
@@ -736,15 +772,21 @@ module TextureUpload =
 
             let diffuseTexture (v : Effects.Vertex) =
                 fragment {
-                    return diffuseSampler.Read(V2i.Zero, 0)
+                    let p = V2i (v.tc * V2f diffuseSampler.Size.XY)
+                    return diffuseSampler.Read(p, 0)
                 }
 
             let shader =
                 Sg.shader {
                     do! diffuseTexture
                 }
 
-            runtime |> renderQuadWithNullTexture shader nullTexture
+            use randomTexture =
+                let texture = runtime.CreateTexture2D(V2i(8, 8), TextureFormat.Rgba8, samples = 2)
+                renderRandomToTexture2D texture runtime
+                texture
+
+            runtime |> renderQuadWithNullTexture shader randomTexture
 
         let texture2DNullMultisampledArray (runtime : IRuntime) =
             let diffuseSampler =
@@ -757,15 +799,21 @@ module TextureUpload =
 
             let diffuseTexture (v : Effects.Vertex) =
                 fragment {
-                    return diffuseSampler.Read(V2i.Zero, 0, 0)
+                    let p = V2i (v.tc * V2f diffuseSampler.Size.XY)
+                    return diffuseSampler.Read(p, 0, 0)
                 }
 
             let shader =
                 Sg.shader {
                     do! diffuseTexture
                 }
 
-            runtime |> renderQuadWithNullTexture shader nullTexture
+            use randomTexture =
+                let texture = runtime.CreateTexture2DArray(V2i(8, 8), TextureFormat.Rgba8, samples = 2, count = 1)
+                renderRandomToTexture2D texture runtime
+                texture
+
+            runtime |> renderQuadWithNullTexture shader randomTexture
 
         let texture2DNullInt(runtime : IRuntime) =
             let diffuseSampler =
@@ -778,7 +826,8 @@ module TextureUpload =
 
             let diffuseTexture (v : Effects.Vertex) =
                 fragment {
-                    return V4f(diffuseSampler.Read(V2i.Zero, 0))
+                    let p = V2i (v.tc * V2f diffuseSampler.Size.XY)
+                    return V4f(diffuseSampler.Read(p, 0))
                 }
 
             let shader =
@@ -798,19 +847,23 @@ module TextureUpload =
                     filter Filter.MinMagLinear
                     addressU WrapMode.Clamp
                     addressV WrapMode.Clamp
+                    comparison ComparisonFunction.LessOrEqual
                 }
 
             let diffuseTexture (v : Effects.Vertex) =
                 fragment {
-                    return V4f(diffuseSampler.Sample(v.tc, 0.0f))
+                    return V4f(diffuseSampler.Sample(v.tc, 0.5f))
                 }
 
             let shader =
                 Sg.shader {
                     do! diffuseTexture
                 }
 
-            runtime |> renderQuadWithNullTexture shader nullTexture
+            use randomTexture = runtime.CreateTexture2D(V2i(8, 8), TextureFormat.DepthComponent32f)
+            randomTexture.Upload(PixImage.random32f' Col.Format.Gray <| V2i(8, 8))
+
+            runtime |> renderQuadWithNullTexture shader randomTexture
 
         let texture2DStreaming (runtime : IRuntime) =
             let texture = runtime.CreateStreamingTexture(false)
@@ -997,7 +1050,6 @@ module TextureUpload =
                 else
                     runtime.CreateTextureCube(size, fmt, levels)
 
-
             try
                 let target = texture.[TextureAspect.Color, level, slice]
                 target.Upload(data, regionOffset, regionSize)
@@ -1114,15 +1166,19 @@ module TextureUpload =
 
             let diffuseTexture (v : Effects.Vertex) =
                 fragment {
-                    return diffuseSampler.Sample(V3f.Zero)
+                    let tc = v.tc * 2.0f - 1.0f
+                    return diffuseSampler.Sample(V3f(tc.X, -tc.Y, 1.0f)) // +Z face (slice = 4)
                 }
 
             let shader =
                 Sg.shader {
                     do! diffuseTexture
                 }
 
-            runtime |> renderQuadWithNullTexture shader nullTexture
+            use randomTexture = runtime.CreateTextureCube(8, TextureFormat.Rgba8)
+            randomTexture.Upload(PixImage.random8ui <| V2i(8, 8), slice = 4)
+
+            runtime |> renderQuadWithNullTexture shader randomTexture
 
         let textureCubeNullArray (runtime : IRuntime) =
             let diffuseSampler =
@@ -1135,15 +1191,19 @@ module TextureUpload =
 
             let diffuseTexture (v : Effects.Vertex) =
                 fragment {
-                    return diffuseSampler.Sample(V3f.Zero, 32)
+                    let tc = v.tc * 2.0f - 1.0f
+                    return diffuseSampler.Sample(V3f(tc.X, -tc.Y, 1.0f), 0) // +Z face (slice = 4)
                 }
 
             let shader =
                 Sg.shader {
                     do! diffuseTexture
                 }
 
-            runtime |> renderQuadWithNullTexture shader nullTexture
+            use randomTexture = runtime.CreateTextureCubeArray(8, TextureFormat.Rgba8, count = 1)
+            randomTexture.Upload(PixImage.random8ui <| V2i(8, 8), slice = 4)
+
+            runtime |> renderQuadWithNullTexture shader randomTexture
 
     let tests (backend : Backend) =
         [