Add uiConfig to DepthBufferPlugin, NormalBufferPlugin, RenderTargetPreviewPlugin, other minor UI changes.

src/plugins/base/PipelinePassPlugin.ts

 import {AViewerPluginSync, ISerializedConfig, ThreeViewer} from '../../viewer'
 import {AnyFunction, serialize} from 'ts-browser-helpers'
 import {SerializationMetaType} from '../../utils'
+import {uiConfig, uiToggle} from 'uiconfig.js'
 
 export abstract class PipelinePassPlugin<T extends IPipelinePass, TPassId extends IPassID, TEvent extends string, TViewer extends ThreeViewer=ThreeViewer> extends AViewerPluginSync<TEvent, TViewer> {
     abstract passId: TPassId
+
+    @serialize()
+    @uiToggle('Enabled')
+    get enabled(): boolean {
+        return this._pass?.enabled || this._enabledTemp
+    }
+
+    set enabled(value: boolean) {
+        if (this._pass) this._pass.enabled = value
+        this._enabledTemp = value
+    }
+
+
+    @uiConfig()
     @serialize('pass')
     protected _pass?: T
     abstract createPass(v:TViewer):T
     protected _beforeRender(): boolean {return this._pass?.enabled && this.enabled || false}
     private _enabledTemp = true // to save enabled state when pass is not yet created
 
-    @serialize()
-    get enabled(): boolean {
-        return this._pass?.enabled || this._enabledTemp
-    }
-
-    set enabled(value: boolean) {
-        if (this._pass) this._pass.enabled = value
-        this._enabledTemp = value
-    }
 
     constructor() {
         super()

src/plugins/pipeline/DepthBufferPlugin.ts

 import {ThreeViewer} from '../../viewer'
 import {IShaderPropertiesUpdater} from '../../materials'
 import {PipelinePassPlugin} from '../base/PipelinePassPlugin'
+import {uiFolderContainer, uiImage} from 'uiconfig.js'
 
 export type DepthBufferPluginEventTypes = ''
 // type DepthBufferPluginTarget = WebGLMultipleRenderTargets | WebGLRenderTarget
 export type DepthBufferPluginTarget = WebGLRenderTarget
 export type DepthBufferPluginPass = GBufferRenderPass<'depth', DepthBufferPluginTarget>
+
+@uiFolderContainer('Depth Buffer Plugin')
 export class DepthBufferPlugin
     extends PipelinePassPlugin<DepthBufferPluginPass, 'depth', DepthBufferPluginEventTypes>
     implements IShaderPropertiesUpdater {
     public static readonly PluginType = 'DepthBufferPlugin'
 
     target?: DepthBufferPluginTarget
-    texture?: Texture
+
+    @uiImage('Depth Buffer' /* {readOnly: true}*/) texture?: Texture
+
     readonly material: MeshDepthMaterial = new MeshDepthMaterial({
         depthPacking: BasicDepthPacking,
         blending: NoBlending,
                 depthBuffer: true,
                 samples: v.renderManager.composerTarget.samples || 0,
                 type: this.bufferType,
-                // magFilter: NearestFilter,
-                // minFilter: NearestFilter,
-                // generateMipmaps: false,
-                // encoding: LinearEncoding,
+            // magFilter: NearestFilter,
+            // minFilter: NearestFilter,
+            // generateMipmaps: false,
+            // encoding: LinearEncoding,
             })
         this.texture = this.target.texture
         this.texture.name = 'depthBuffer'
 
     constructor(
         public readonly bufferType: TextureDataType = UnsignedByteType,
-        public readonly isPrimaryGBuffer = false
+        public readonly isPrimaryGBuffer = false,
+        enabled = true,
     ) {
         super()
+        this.enabled = enabled
     }
 
     onRemove(viewer: ThreeViewer): void {

src/plugins/pipeline/NormalBufferPlugin.ts

 import {IShaderPropertiesUpdater} from '../../materials'
 import {PipelinePassPlugin} from '../base/PipelinePassPlugin'
 import type {IMaterial, PhysicalMaterial} from '../../core'
+import {uiFolderContainer, uiImage} from 'uiconfig.js'
 
 export type NormalBufferPluginEventTypes = ''
 // type NormalBufferPluginTarget = WebGLMultipleRenderTargets | WebGLRenderTarget
 export type NormalBufferPluginTarget = WebGLRenderTarget
 export type NormalBufferPluginPass = GBufferRenderPass<'normal', NormalBufferPluginTarget>
+@uiFolderContainer('Normal Buffer Plugin')
 export class NormalBufferPlugin
     extends PipelinePassPlugin<NormalBufferPluginPass, 'normal', NormalBufferPluginEventTypes>
     implements IShaderPropertiesUpdater {
     public static readonly PluginType = 'NormalBufferPlugin'
 
     target?: NormalBufferPluginTarget
-    texture?: Texture
+    @uiImage('Normal Buffer' /* {readOnly: true}*/) texture?: Texture
     readonly material: MeshNormalMaterial = new MeshNormalMaterial2({
         blending: NoBlending,
     })
 
     constructor(
         public readonly bufferType: TextureDataType = HalfFloatType,
+        enabled = true,
     ) {
         super()
+        this.enabled = enabled
     }
 
     onRemove(viewer: ThreeViewer): void {

src/plugins/ui/RenderTargetPreviewPlugin.ts

 import {SRGBColorSpace, Vector4, WebGLRenderTarget} from 'three'
 import styles from './RenderTargetPreviewPlugin.css'
 import {CustomContextMenu} from '../../utils'
+import {uiFolderContainer, uiToggle} from 'uiconfig.js'
 
+@uiFolderContainer('Render Target Preview Plugin')
 export class RenderTargetPreviewPlugin<TEvent extends string> extends AViewerPluginSync<TEvent> {
     static readonly PluginType = 'RenderTargetPreviewPlugin'
 
+    @uiToggle('Enabled')
     @onChange(RenderTargetPreviewPlugin.prototype.refreshUi) enabled = true
     toJSON: any = null
 
-    mainDiv: HTMLDivElement = createDiv({id: 'RenderTargetPreviewPluginContainer'})
+    mainDiv: HTMLDivElement = createDiv({id: 'RenderTargetPreviewPluginContainer', addToBody: false})
     stylesheet?: HTMLStyleElement
 
-    constructor() {
+    constructor(enabled = true) {
         super()
+        this.enabled = enabled
     }
 
     targetBlocks: {
     }
 
     addTarget(target: ValOrFunc<IRenderTarget|undefined>, name: string, transparent = false, originalColorSpace = false, visible = true): this {
+        if (!target) return this
         const div = document.createElement('div')
         const targetDef = {target, name, transparent, div, originalColorSpace, visible}
         div.classList.add('RenderTargetPreviewPluginTarget')
+        if (!targetDef.visible) div.classList.add('RenderTargetPreviewPluginCollapsed')
         const header = document.createElement('div')
         header.classList.add('RenderTargetPreviewPluginTargetHeader')
         header.innerText = name

src/plugins/ui/tweakpane/TweakpaneUiPlugin.ts

 
     private _plugins: IViewerPlugin[] = []
 
-    setupPlugins<T extends IViewerPlugin>(...plugins: Class<T>[]): void {
+    setupPlugins(...plugins: Class<IViewerPlugin>[]): void {
         plugins.forEach(plugin => this.setupPluginUi(plugin))
     }
 

src/postprocessing/GBufferRenderPass.ts

 import {RenderPass} from 'three/examples/jsm/postprocessing/RenderPass.js'
 import {IPassID, IPipelinePass} from './Pass'
 import {ICamera, IMaterial, IRenderManager, IScene, IWebGLRenderer, PhysicalMaterial} from '../core'
+import {uiFolderContainer, UiObjectConfig, uiToggle} from 'uiconfig.js'
 
-export class GBufferRenderPass<TP extends IPassID, T extends WebGLMultipleRenderTargets | WebGLRenderTarget> extends RenderPass implements IPipelinePass<TP> { // todo: extend from jittered?
+@uiFolderContainer<GBufferRenderPass>((c)=>c.passId + ' Render Pass')
+export class GBufferRenderPass<TP extends IPassID=IPassID, T extends WebGLMultipleRenderTargets | WebGLRenderTarget=WebGLMultipleRenderTargets | WebGLRenderTarget> extends RenderPass implements IPipelinePass<TP> { // todo: extend from jittered?
     readonly isGBufferRenderPass = true
+    uiConfig: UiObjectConfig
+
+    @uiToggle('Enabled') enabled = true
 
     scene?: IScene
     before?: IPassID[]

src/rendering/RenderManager.ts

     upgradeWebGLRenderer,
 } from '../core'
 import {base64ToArrayBuffer, canvasFlipY, Class, onChange2, serializable, serialize, ValOrArr} from 'ts-browser-helpers'
-import {uiConfig, uiFolderContainer, uiMonitor, uiSlider, uiToggle} from 'uiconfig.js'
+import {uiButton, uiConfig, uiFolderContainer, uiMonitor, uiSlider, uiToggle} from 'uiconfig.js'
 import {generateUUID, textureDataToImageData} from '../three'
 import {BlobExt, EXRExporter2} from '../assetmanager'
 
     @onChange2(RenderManager.prototype.rebuildPipeline)
     public autoBuildPipeline = true
 
+    @uiButton('Rebuild Pipeline')
     rebuildPipeline(setDirty = true): void {
         this._passesNeedsUpdate = true
         if (setDirty) this._updated({change: 'rebuild'})