Add depthTexture to gbuffer.

examples/gbuffer-plugin/script.ts

 import {
     _testFinish,
     downloadBlob,
+    FloatType,
     GBufferPlugin,
     HalfFloatType,
     IObject3D,
 const viewer = new ThreeViewer({
     canvas: document.getElementById('mcanvas') as HTMLCanvasElement,
     msaa: true,
+    zPrepass: true,
 })
 
 async function init() {
 
-    const gbufferPlugin = viewer.addPluginSync(new GBufferPlugin(HalfFloatType))
+    const gbufferPlugin = viewer.addPluginSync(new GBufferPlugin(
+        HalfFloatType,
+        true, // isPrimaryGBuffer (used for zprepass etc)
+        true, // enabled by default
+        true, // render the flags buffer (used for eg selective tonemapping)
+        true, // render depth texture
+        FloatType)) // render depth texture as Float type. available - UnsignedShort(16 bits), UnsignedInt(24 bits) or Float(32 bits)
 
     await viewer.setEnvironmentMap('https://threejs.org/examples/textures/equirectangular/venice_sunset_1k.hdr')
     const model = await viewer.load<IObject3D>('https://threejs.org/examples/models/gltf/kira.glb', {
 
     const getNormalDepth = ()=>({texture: gbufferPlugin.normalDepthTexture})
     const getFlags = ()=>({texture: gbufferPlugin.flagsTexture})
+    const getDepthTexture = ()=>({texture: gbufferPlugin.depthTexture})
 
     const targetPreview = await viewer.addPlugin(RenderTargetPreviewPlugin)
     targetPreview.addTarget(getNormalDepth, 'normalDepth')
     targetPreview.addTarget(getFlags, 'gBufferFlags')
+    targetPreview.addTarget(getDepthTexture, 'depthTexture')
 
     const screenPass = viewer.renderManager.screenPass
 
             screenPass.overrideReadBuffer = screenPass.overrideReadBuffer?.texture === rt.texture ? null : rt
             viewer.setDirty()
         },
+        ['Toggle Depth Texture']: () => {
+            const rt = getDepthTexture()
+            screenPass.overrideReadBuffer = screenPass.overrideReadBuffer?.texture === rt.texture ? null : rt
+            viewer.setDirty()
+        },
         ['Download snapshot']: async(btn: HTMLButtonElement) => {
             btn.disabled = true
             const blob = await viewer.getScreenshotBlob({mimeType: 'image/png'})

package-lock.json

 {
   "name": "threepipe",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "threepipe",
-      "version": "0.0.21",
+      "version": "0.0.22",
       "license": "Apache-2.0",
       "dependencies": {
         "@types/three": "https://github.com/repalash/three-ts-types/releases/download/v0.152.1020/package.tgz",

package.json

 {
   "name": "threepipe",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "description": "A 3D viewer framework built on top of three.js in TypeScript with a focus on quality rendering, modularity and extensibility.",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

src/plugins/pipeline/GBufferPlugin.ts

     BufferGeometry,
     Camera,
     Color,
+    DepthTexture,
     DoubleSide,
+    FloatType,
     GLSL1,
     GLSL3,
     IUniform,
     UniformsLib,
     UniformsUtils,
     UnsignedByteType,
+    UnsignedIntType,
+    UnsignedShortType,
     Vector2,
     Vector4,
     WebGLMultipleRenderTargets,
     get flagsTexture(): ITexture|undefined {
         return this.textures[1]
     }
+
+    @uiImage(/* {readOnly: true}*/)
+    get depthTexture(): (ITexture&DepthTexture)|undefined {
+        return this.target?.depthTexture
+    }
+
     // @uiConfig() // not supported in this material yet
     material?: GBufferMaterial
 
         extraUniforms: {
             tNormalDepth: ()=>({value: this.normalDepthTexture}),
             tGBufferFlags: ()=>({value: this.flagsTexture}),
+            tGBufferDepthTexture: ()=>({value: this.depthTexture}),
         },
         extraDefines: {
             // ['GBUFFER_PACKING']: BasicDepthPacking,
             ['HAS_NORMAL_DEPTH_BUFFER']: ()=>this.normalDepthTexture ? 1 : undefined,
-            // ['HAS_FLAGS_BUFFER']: ()=>this.flagsTexture ? 1 : undefined,
+            ['GBUFFER_HAS_DEPTH_TEXTURE']: ()=>this.depthTexture ? 1 : undefined,
             ['GBUFFER_HAS_FLAGS']: ()=>this.flagsTexture ? 1 : undefined,
+            // ['HAS_FLAGS_BUFFER']: ()=>this.flagsTexture ? 1 : undefined,
             ['HAS_GBUFFER']: ()=>this.isPrimaryGBuffer && this.normalDepthTexture ? 1 : undefined,
         },
         priority: 100,
                     samples: this._viewer.renderManager.composerTarget.samples || 0,
                     type: this.bufferType,
                     textureCount: useMultiple ? 2 : 1,
+                    depthTexture: this.renderDepthTexture,
+                    depthTextureType: this.depthTextureType,
                     // magFilter: NearestFilter,
                     // minFilter: NearestFilter,
                     // generateMipmaps: false,
         bufferType: TextureDataType = UnsignedByteType,
         isPrimaryGBuffer = true,
         enabled = true,
-        public renderFlagsBuffer: boolean = true
+        public renderFlagsBuffer: boolean = true,
+        public renderDepthTexture: boolean = false,
+        public depthTextureType: typeof UnsignedShortType | typeof UnsignedIntType | typeof FloatType /* | typeof UnsignedInt248Type*/ = UnsignedIntType,
         // packing: DepthPackingStrategies = BasicDepthPacking,
     ) {
         super()

src/plugins/pipeline/shaders/GBufferPlugin.unpack.glsl

     return ivec4(1);
     #endif
 }
+
+#if defined(GBUFFER_HAS_DEPTH_TEXTURE) && GBUFFER_HAS_DEPTH_TEXTURE == 1
+// NOT TESTED
+uniform sampler2D tGBufferDepthTexture;
+// needs <packing>. Its made sure that its included in the unpackExtension
+float getDepthTexture( vec2 coord, float cameraNear, float cameraFar ) {
+    float fragCoordZ = texture2D( tGBufferDepthTexture, coord ).x;
+    float viewZ = perspectiveDepthToViewZ( fragCoordZ, cameraNear, cameraFar );
+    return viewZToOrthographicDepth( viewZ, cameraNear, cameraFar );
+}
+#endif
+
 //#if DEPTH_NORMAL_TEXTURE == 1
 //uniform sampler2D tNormalDepth;
 //#else

src/rendering/RenderTarget.ts

 import {
     ColorSpace,
+    DepthFormat,
+    DepthStencilFormat,
     EventDispatcher,
+    FloatType,
     MagnificationTextureFilter,
     MinificationTextureFilter,
     Texture,
     TextureDataType,
+    UnsignedInt248Type,
+    UnsignedIntType,
+    UnsignedShortType,
     Wrapping,
 } from 'three'
 import {Vector4} from 'three/src/math/Vector4'
     format?: number
     depthBuffer?: boolean
     depthTexture?: boolean
+    depthTextureType?: typeof UnsignedShortType | typeof UnsignedInt248Type | typeof UnsignedIntType | typeof FloatType
+    depthTextureFormat?: typeof DepthFormat | typeof DepthStencilFormat
     textureCount?: number
     wrapS?: Wrapping
     wrapT?: Wrapping

src/rendering/RenderTargetManager.ts

 import {
     BaseEvent,
     ClampToEdgeWrapping,
+    DepthFormat,
     DepthTexture,
     EventDispatcher,
     LinearFilter,
     RGBAFormat,
     Texture,
     UnsignedByteType,
+    UnsignedIntType,
     Vector2,
     WebGLCubeRenderTarget,
     WebGLMultipleRenderTargets,
         format = RGBAFormat,
         depthBuffer = true,
         depthTexture = false,
+        depthTextureType = UnsignedIntType,
+        depthTextureFormat = DepthFormat,
         size = undefined,
         textureCount = 1,
         ...op
         size = size || this.renderSize.clone().multiplyScalar(this.renderScale * (sizeMultiplier = sizeMultiplier || 1))
         size.width = Math.floor(size.width)
         size.height = Math.floor(size.height)
-        const depthTex = depthTexture ? new DepthTexture(size.width, size.height, UnsignedByteType) : undefined
+        const depthTex = depthTexture ? new DepthTexture(size.width, size.height, depthTextureType) : undefined
+        if (depthTex) depthTex.format = depthTextureFormat
         const target = this.createTargetCustom<T>(textureCount > 1 ? {
             width: size.width,
             height: size.height,

src/viewer/version.ts

-export const VERSION = '0.0.21'
+export const VERSION = '0.0.22'