Clean up EventListener2 types

package-lock.json

       "version": "0.0.39",
       "license": "Apache-2.0",
       "dependencies": {
-        "@types/three": "https://github.com/repalash/three-ts-types/releases/download/v0.157.1003/package.tgz",
+        "@types/three": "https://github.com/repalash/three-ts-types/releases/download/v0.157.1004/package.tgz",
         "@types/webxr": "^0.5.1",
         "@types/wicg-file-system-access": "^2020.9.5",
         "popmotion": "^11.0.5",
       "license": "MIT"
     },
     "node_modules/@types/three": {
-      "version": "0.157.1003",
-      "resolved": "https://github.com/repalash/three-ts-types/releases/download/v0.157.1003/package.tgz",
-      "integrity": "sha512-zE6QGPd9EgQZ6n4toKKTbBHrNdwo+bDiWadKFBWAxu3pStzqKLSylDGe0RGuDwzjz5bUMVrKihZcsz69E0pWUg==",
+      "version": "0.157.1004",
+      "resolved": "https://github.com/repalash/three-ts-types/releases/download/v0.157.1004/package.tgz",
+      "integrity": "sha512-J5sdEce4YMYU7uYsL0b+St12VNpaQIDIrmzaiMGl/tunMtzCJBCpVFwBln7vewtCws6MopHGw2H0huAQIeEBxQ==",
       "dependencies": {
         "fflate": "~0.6.10",
         "meshoptimizer": "~0.18.1"

package.json

     "vitepress-plugin-nprogress": "^0.0.4"
   },
   "dependencies": {
-    "@types/three": "https://github.com/repalash/three-ts-types/releases/download/v0.157.1003/package.tgz",
+    "@types/three": "https://github.com/repalash/three-ts-types/releases/download/v0.157.1004/package.tgz",
     "@types/webxr": "^0.5.1",
     "@types/wicg-file-system-access": "^2020.9.5",
     "stats.js": "^0.17.0",
       "uiconfig.js": "^0.1.3",
       "ts-browser-helpers": "^0.16.2",
       "three": "https://github.com/repalash/three.js-modded/releases/download/v0.157.1004/package.tgz",
-      "three-f": "https://github.com/repalash/three.js-modded/archive/refs/tags/v0.157.1003.tar.gz",
-      "@types/three": "https://github.com/repalash/three-ts-types/releases/download/v0.157.1003/package.tgz",
-      "@types/three-f": "https://github.com/repalash/three-ts-types/archive/refs/tags/v0.157.1003.tar.gz",
+      "three-f": "https://github.com/repalash/three.js-modded/archive/refs/tags/v0.157.1004.tar.gz",
+      "@types/three": "https://github.com/repalash/three-ts-types/releases/download/v0.157.1004/package.tgz",
+      "@types/three-f": "https://github.com/repalash/three-ts-types/archive/refs/tags/v0.157.1004.tar.gz",
       "@types/three-pkg": "https://gitpkg.now.sh/repalash/three-ts-types/types/three?modded_three"
     },
     "local_dependencies": {

plugins/gaussian-splatting/src/three-gaussian-splat/ThreeGaussianSplatPlugin.ts

 import {
+    AnyOptions,
     AViewerPluginSync,
     createStyles,
-    EventListener,
+    EventListener2,
     ILoader,
     Importer,
     ISceneEventMap,
 } from 'threepipe'
 import styles from './ThreeGaussianSplatPlugin.css?inline'
 import {GaussianSplatMesh} from './index'
-import {AnyOptions} from 'ts-browser-helpers'
 import {SplatLoader} from './loaders/SplatLoader'
 import {SortWorkerManager} from './cpp-sorter/SortWorkerManager'
 import {GaussianSplatGeometry} from './geometry/GaussianSplatGeometry'
         this.splats.forEach(async splat=>splat.update(this._viewer!.scene.mainCamera, this._viewer!.renderManager.webglRenderer))
     }
 
-    private _geometryUpdate: EventListener<ISceneEventMap['geometryUpdate'], 'geometryUpdate', Scene> = (event) => {
+    private _geometryUpdate: EventListener2<'geometryUpdate', ISceneEventMap, Scene> = (event) => {
         if (!this._ready || this.isDisabled() || !(event.geometry as GaussianSplatGeometry)?.isGaussianSplatGeometry) return
         event.geometry!.appliedMeshes.forEach(async(splat: GaussianSplatMesh)=>splat.update ? splat.update(this._viewer!.scene.mainCamera, this._viewer!.renderManager.webglRenderer) : undefined)
     }

src/assetmanager/MaterialManager.ts

-import {ColorManagement, Event, EventDispatcher, EventListener, Material, Texture} from 'three'
+import {ColorManagement, Event, EventDispatcher, EventListener2, Material, Texture} from 'three'
 import {
     IMaterial,
     iMaterialCommons,
 
     private _materialMaps = new Map<string, Set<ITexture>>()
 
-    protected _materialUpdate: EventListener<IMaterialEventMap['materialUpdate'], 'materialUpdate', IMaterial> = (e)=>{
+    protected _materialUpdate: EventListener2<'materialUpdate', IMaterialEventMap, IMaterial> = (e)=>{
         const mat = e.material || e.target
         if (!mat || mat.assetType !== 'material') return
         this._refreshTextureRefs(mat)

src/core/IObject.ts

 import {IMaterial, IMaterialEventMap} from './IMaterial'
-import {EventListener, Object3D, Object3DEventMap, Vector3} from 'three'
+import {EventListener2, Object3D, Object3DEventMap, Vector3} from 'three'
 import {ChangeEvent, IUiConfigContainer, UiObjectConfig} from 'uiconfig.js'
 import {IGeometry, IGeometryEventMap} from './IGeometry'
 import {IImportResultUserData} from '../assetmanager'
 
 
     // eslint-disable-next-line @typescript-eslint/naming-convention
-    _onGeometryUpdate?: EventListener<IGeometryEventMap['geometryUpdate'], 'geometryUpdate', IGeometry>
+    _onGeometryUpdate?: EventListener2<'geometryUpdate', IGeometryEventMap, IGeometry>
 
 
     objectProcessor?: IObjectProcessor

src/core/object/RootScene.ts

     BufferGeometry,
     Color,
     EquirectangularReflectionMapping,
-    EventListener,
+    EventListener, EventListener2,
     IUniform,
     Object3D,
     Scene,
     }
 
 
-    private _mainCameraUpdate: EventListener<IObject3DEventMap['cameraUpdate'], 'cameraUpdate', ICamera> = (e) => {
+    private _mainCameraUpdate: EventListener2<'cameraUpdate', IObject3DEventMap, ICamera> = (e) => {
         this.setDirty({refreshScene: false})
         this.refreshActiveCameraNearFar()
         if (e.key === 'fov') this.dollyActiveCameraFov()

src/plugins/interaction/PickingPlugin.ts

-import {EventListener, Object3D} from 'three'
+import {EventListener2, Object3D} from 'three'
 import {Class, onChange, serialize} from 'ts-browser-helpers'
 import {AViewerPluginEventMap, AViewerPluginSync, ThreeViewer} from '../../viewer'
 import {BoxSelectionWidget, ObjectPicker, SelectionWidget} from '../../three'
         if (!this._picker || !this._viewer) return
         this._picker.camera = this._viewer.scene.mainCamera
     }
-    private _onSceneUpdate: EventListener<ISceneEventMap['sceneUpdate'], 'sceneUpdate', IScene> = (e)=>{
+    private _onSceneUpdate: EventListener2<'sceneUpdate', ISceneEventMap, IScene> = (e)=>{
         if (!e.hierarchyChanged) return
         const s = this.getSelectedObject()
         let inScene = false
         if (!inScene) this.setSelectedObject(undefined)
     }
 
-    private _onObjectSelectEvent: EventListener<ISceneEventMap['select'], 'select', IScene> = (e)=>{
+    private _onObjectSelectEvent: EventListener2<'select', ISceneEventMap, IScene> = (e)=>{
         if (e.source === PickingPlugin.PluginType) return
         if (e.object === undefined && e.value === undefined) console.error('e.object or e.value must be set for picking, can be null to unselect')
         else this.setSelectedObject(e.object || e.value, this.autoFocus || e.focusCamera)
     }
 
-    private _selectedObjectChanged: EventListener<ObjectPickerEventMap['selectedObjectChanged'], 'selectedObjectChanged', ObjectPicker> = (e: any) => {
+    private _selectedObjectChanged: EventListener2<'selectedObjectChanged', ObjectPickerEventMap, ObjectPicker> = (e: any) => {
         if (!this._viewer) return
         this.dispatchEvent(e)
 

src/postprocessing/ExtendedRenderPass.ts

     LinearFilter,
     Material,
     NoColorSpace,
-    RGBAFormat, Texture,
+    RGBAFormat,
+    Texture,
     UnsignedByteType,
-    WebGLMultipleRenderTargets,
     WebGLRenderTarget,
 } from 'three'
 import {generateUiConfig, UiObjectConfig, uiToggle} from 'uiconfig.js'
     }
 
     // names are incorrect. We read from `writeBuffer` and write to `readBuffer`. same in super class
-    render(renderer: IWebGLRenderer, writeBuffer?: WebGLRenderTarget<Texture|Texture[]>|null, readBuffer?: WebGLMultipleRenderTargets|WebGLRenderTarget, deltaTime?: number, maskActive?: boolean) {
+    render(renderer: IWebGLRenderer, writeBuffer?: WebGLRenderTarget<Texture|Texture[]>|null, readBuffer?: WebGLRenderTarget<Texture|Texture[]>, deltaTime?: number, maskActive?: boolean) {
         if (!this.enabled) return
         let needsSwap = false
 
         renderer.userData.mainRenderPass = true
         if (!this._doTransmissionFix && !this.renderManager.rgbm) {
-            // @ts-expect-error todo fix render target ts?
             super.render(renderer, writeBuffer || null, readBuffer, deltaTime, maskActive)
             this.needsSwap = needsSwap
             renderer.userData.mainRenderPass = undefined
         //     console.error('ExtendedRenderPass - readBuffer and gbuffer samples are not same', readBuffer?.samples, gbuffer?.samples)
 
         let renderFn = ()=> {
-            // @ts-expect-error todo fix render target ts?
             super.render(renderer, null, readBuffer, deltaTime, maskActive, depthRenderBuffer) // read is write in super.render (RenderPass)
         }
 

src/postprocessing/GBufferRenderPass.ts

-import {Color, Material, WebGLMultipleRenderTargets, WebGLRenderTarget} from 'three'
+import {Color, Material, Texture, WebGLMultipleRenderTargets, WebGLRenderTarget} from 'three'
 import {RenderPass} from 'three/examples/jsm/postprocessing/RenderPass.js'
 import {IPassID, IPipelinePass} from './Pass'
 import {ICamera, IMaterial, IRenderManager, IScene, IWebGLRenderer, PhysicalMaterial} from '../core'
      * @param deltaTime
      * @param maskActive
      */
-    render(renderer: IWebGLRenderer, _?: WebGLRenderTarget|WebGLMultipleRenderTargets|null, _1?: WebGLRenderTarget|WebGLMultipleRenderTargets, deltaTime?: number, maskActive?: boolean) {
+    render(renderer: IWebGLRenderer, _?: WebGLRenderTarget<Texture|Texture[]>|null, _1?: WebGLRenderTarget<Texture|Texture[]>, deltaTime?: number, maskActive?: boolean) {
         if (!this.scene || !this.camera) return
 
         const t = renderer.getRenderTarget()
             transparentRender: false,
             transmissionRender: false,
             mainRenderPass: false,
-            // @ts-expect-error todo fix render target ts?
         }, ()=> super.render(renderer, null, getOrCall(this.target), deltaTime as any, maskActive as any)) // here this.target is the write-buffer, variable writeBuffer is ignored
 
         this._transparentMats.forEach(m => m.transparent = !m.transparent)

src/three/Threejs.ts

 
 export {OrbitControls} from 'three/examples/jsm/controls/OrbitControls.js'
 export * from 'three/examples/jsm/utils/BufferGeometryUtils.js'
-export type {Event, EventListener} from 'three'
-import type {Event} from 'three'
-
-// todo export from three
-export type EventListener2<TEventType extends string, TEventMap extends Record<TEventType, any>, TTarget> = (
-    event: TEventMap[TEventType] & Event<TEventType, TTarget>,
-) => void
+export type {Event, EventListener, EventListener2} from 'three'

src/viewer/ThreeViewer.ts

     Scene,
     Vector2,
     Vector3,
+    EventListener2,
 } from 'three'
 import {Class, createCanvasElement, downloadBlob, onChange, serialize, ValOrArr} from 'ts-browser-helpers'
 import {TViewerScreenShader} from '../postprocessing'
 import {TonemapPlugin} from '../plugins/postprocessing/TonemapPlugin'
 import {VERSION} from './version'
 import {OrbitControls3} from '../three'
-import {EventListener2} from '../three/Threejs'
 
 // todo make proper event map
 export interface IViewerEvent extends BaseEvent, Partial<IAnimationLoopEvent> {