CHANGELOG-v4.NEXT.md

Phaser 4 Changelog

Version 4.NEXT

New Features

• RenderConfig#mipmapRegeneration option allows certain framebuffer-based objects to use mipmaps if the game is configured to use mipmaps. This has a cost because mipmaps must be recreated after every change. Currently it only applies to DynamicTextures; Filters cannot render mipmaps. Thanks @Flow!
• Layer is now a true GameObject. This fixes numerous small inconsistencies, and some big issues such as Filters not working. Thanks @rexrainbow for reporting the initial issue!
• The base filter Controller now has getPaddingCeil(), which returns the ceiling of the current padding. This is mostly used internally to avoid quality loss from fractional padding. If your code calls getPadding() on a filter controller (typically in a custom render node), you should replace it with getPaddingCeil().
• Experimental WEBGL3D renderer: a new minimal 3D backend targeting WebGL2. Games opt in via type: Phaser.WEBGL3D and gain access to a compact 3D pipeline. See docs/WEBGL3D.md for the full API reference and examples/vite-3d/ for a runnable demo.
• New Phaser.WEBGL3D renderer type constant (value 9). Never selected by Phaser.AUTO; must be requested explicitly. Requires WebGL2, with no fallback.
• New Phaser.Cameras.ThreeD namespace with Camera3D (base), PerspectiveCamera, OrthographicCamera and Frustum. Every camera carries a view frustum that is rebuilt every frame from its view-projection matrix and powers bounding-sphere culling in the renderer.
• New CameraManager3D Scene plugin, auto-injected as this.cameras3d in every Scene when the renderer is built in. Provides this.cameras3d.main, addPerspective, addOrthographic, addExisting, setMain and remove. Auto-resizes every registered camera on Scale Manager RESIZE.
• New Phaser.GameObjects3D namespace with Object3D (base node with transform, parent/children and world matrix), Mesh3D (drawable Object3D with geometry, material and bounding sphere), plus Cube and Plane primitives. Shared geometry is cached at module scope and GPU buffers are uploaded lazily on first draw, so instancing hundreds of the same primitive is cheap.
• New GameObjectFactory3D Scene plugin, auto-injected as this.add3D in every Scene. Provides this.add3D.material(type, config), cube(materialOrConfig), plane(materialOrConfig), gltf(key, options), object3D(), mesh(geometry, material), existing(node) and remove(node). Meshes added via the factory are automatically part of scene.displayList3D; children of a registered root are walked recursively so add3D.existing only needs the root.
• Scene graph: Object3D#parent, #children, add(child), remove(child), getLocalMatrix() and getWorldMatrix(). Mesh3D now extends Object3D and the renderer walks the tree in depth-first order, pruning whole subtrees when a node has visible = false.
• New Phaser.Renderer.WebGL3D namespace exposing WebGL3DRenderer, MaterialManager, Material and the built-in shader sources (Shaders.UnlitColor, Shaders.UnlitTextured, Shaders.LitColor, Shaders.LitTextured). The renderer implements the Texture Manager hooks (createTextureFromSource, createCanvasTexture, createVideoTexture, createUint8ArrayTexture) so the standard Loader and Texture Manager workflows work for 3D materials.
• Four built-in shaders with optional stylization controls: vertexSnap (quantises clip-space XY to a pixel grid) and affineUV (uses affine UV interpolation by cancelling perspective correction, since WebGL2 reserves but does not implement the noperspective qualifier). All shaders support optional per-vertex colours and distance fog. The new lit_* variants add Lambertian diffuse shading, a u_normalMatrix for correct lighting under non-uniform scaling, and a runtime shading toggle between smooth and flat using GLSL ES 3.00's flat qualifier.
• New Phaser.Lights3D namespace with Light3D (base), AmbientLight3D, DirectionalLight3D, PointLight3D and LightManager3D. Lights carry color, intensity and enabled; directional lights add direction; point lights add position and a range for smoothstep attenuation.
• New LightManager3D Scene plugin, auto-injected as this.lights3d in every Scene. Provides preset('studio' | 'moody' | 'none'), setAmbient(cfg), setDirectional(cfg), addPoint(cfg), remove(light) and clearPoints(). Caps point lights to four active slots to match the shader uniform arrays. Directional direction is normalised once per frame in update().
• Lit materials: Material now accepts 'lit_color' and 'lit_textured' types, plus a shading: 'smooth' | 'flat' parameter that can be toggled at runtime. Unlit materials ('unlit_color', 'unlit_textured') remain as the emissive / UI path and ignore the lighting rig entirely.
• Cube and Plane primitives now supply per-face normals alongside positions and UVs, so they light correctly under the new lit_* shaders out of the box. Custom meshes can supply geometry.normals (same layout as positions) to opt in; meshes without normals get a constant (0, 1, 0) fallback so lit materials still render.
• Material gains transparent, blendMode ('normal' / 'additive' / 'multiply'), fog, vertexColors and shading properties. Transparency is auto-detected from color[3] < 1. The renderer now runs two passes: an opaque pass (depth write on, front-to-back for early-Z) and a transparent pass (depth write off, back-to-front painter's sort).
• Distance fog on Camera3D: camera.setFog(color, near, far) + clearFog(). Shared across materials, per-material opt-out via material.fog = false. Implemented as a linear blend between u_fogNear and u_fogFar in the built-in shaders.
• Per-vertex colours: supply geometry.colors (tightly packed RGB floats) and set material.vertexColors = true. Meshes without a colour stream fall back to constant white via gl.vertexAttrib3f, so the same shader path runs regardless.
• Frustum culling: Cube and Plane ship with tight bounding spheres; the renderer rejects any mesh whose world-space bounding sphere sits outside the active camera's frustum. Opt out per camera via camera.frustumCulling = false.
• New per-frame renderer.stats object (drawCalls, meshesDrawn, meshesCulled), reset in preRender. Useful for HUDs and debugging the culler.
• New Features.webGL2 capability flag on Phaser.Device.Features, true when the browser exposes a working WebGL2RenderingContext.
• New Phaser.Loader3D namespace with GLTFParser, GLTFAsset and GLTFFile. Provides a minimal but complete glTF 2.0 loader for the 3D renderer. Supports both .glb binary containers (including embedded buffers and images) and .gltf JSON files with external .bin / image sidecars and data: URIs. Parses accessors (with de-interleaving when needed), builds tight bounding spheres from accessor min/max, converts node rotations from quaternion to Phaser's Euler YXZ convention and decomposes node.matrix into TRS when provided.
• New this.load.gltf(key, url) Loader file type, registered via FileTypesManager under the WEBGL3D_RENDERER build flag. Produces a GLTFModelAsset template cached in the new this.cache.gltf (Phaser.Cache.CacheManager#gltf). The parser emits asset.warnings[] for every PBR feature it has to drop and logs them as a single console.info when the file finishes processing, so artists can see at a glance what survived the downgrade.
• PBR metallic-roughness materials are downgraded to lit_color / lit_textured: baseColorFactor becomes color, baseColorTexture becomes texture, doubleSided: true maps to cullFace: 'none', alphaMode: 'BLEND' enables the transparent pass, and alphaMode: 'MASK' is honoured natively via shader-side alpha test (see separate changelog entry). Metallic, roughness, normal, occlusion and emissive maps, extensions like KHR_materials_* and Draco / meshopt / KTX2 are collected into the warnings array and otherwise ignored.
• Geometry support in the glTF loader: POSITION, NORMAL, TEXCOORD_0 and COLOR_0 attributes, indices accessors (UNSIGNED_BYTE auto-promoted to UNSIGNED_SHORT, UNSIGNED_INT forwarded). Triangles only — other primitive modes raise a warning and are skipped.
• New this.add3D.gltf(key, options) factory method. Clones the cached GLTFModelAsset into a live Object3D tree with Mesh3D leaves, sharing the underlying geometry and Material instances across every instance spawned from the same key (first instantiation creates the materials and uploads textures; subsequent instances reuse them). glTF textures are uploaded with flipY = false, straight alpha, and the asset's samplers[] filter / wrap state. Options include { includeLights: true } (default), { instanceName: string }, transform shorthand (x, y, z, scale, scaleX/Y/Z, rotationX/Y/Z), animation (true, index, name or false) and material ('lit', 'unlit', a replacement Material or a callback).
• KHR_lights_punctual import: directional and point lights are forwarded to LightManager3D.setDirectional / addPoint. Spot lights are currently skipped with a warning (no spot shader yet). Light colour and intensity come straight from glTF; point range maps onto the existing smoothstep attenuation.
• WebGL3DRenderer now honours the index buffer type declared by the mesh. Uint8 indices are treated as UNSIGNED_BYTE, Uint32 indices as UNSIGNED_INT (WebGL2 core, no extension required), enabling glTF meshes with more than 65535 vertices without manual splitting.
• New WEBGL3D_RENDERER webpack flag, wired into config/webpack.config.js, config/webpack-nospector.config.js and config/webpack.dist.config.js. When true the 3D namespaces (Phaser.Renderer.WebGL3D, Phaser.Cameras.ThreeD, Phaser.GameObjects3D, Phaser.Lights3D, Phaser.Loader3D, Phaser.Animation3D), Scene plugins (this.cameras3d, this.add3D, this.lights3d) and the glTF loader (this.load.gltf, this.cache.gltf) are included; when false the 3D code is tree-shaken out and requesting Phaser.WEBGL3D throws at boot.
• glTF animation playback: the loader now parses animations[] into shared GLTFAnimationClip templates (name, duration, samplers with LINEAR / STEP interpolation, channels targeting translation / rotation / scale). CUBICSPLINE interpolation is downgraded to LINEAR with a warning; weights (morph target) channels are dropped with a warning.
• New Phaser.Animation3D namespace with AnimationMixer3D. The factory (this.add3D.gltf) allocates a per-instance mixer bound to the instance's Object3D nodes and exposes it as root.mixer. The mixer supports play(clipName, opts), stop, stopAll, crossFade(clipName, duration, opts), getCurrentAction() and update(dt). Multiple simultaneous actions blend by weight (spherical interpolation for rotation, weighted sum for translation / scale). It auto-subscribes to scene.events.UPDATE unless the factory is called with autoUpdate: false.
• New animation option on this.add3D.gltf(key, opts). Pass true or 0 to start the first clip, a numeric clip index, a string to start a named clip, or false to keep the instance in bind pose. The older autoPlay option remains supported (true or clip name). autoUpdate (default true) controls the Scene UPDATE subscription.
• Linear-blend skinning: new Phaser.GameObjects3D.SkinnedMesh3D extending Mesh3D. Holds a shared joints: Object3D[] reference list, per-vertex jointIndices / jointWeights attribute arrays, inverseBindMatrices (shared with the asset template) and a per-instance jointMatrices buffer (64 matrices, uploaded each frame as u_jointMatrix[]). updateJointMatrices() multiplies joint[j].getWorldMatrix() with inverseBindMatrices[j] for every active bone and zeroes the unused tail. SkinnedMesh3D.MAX_JOINTS is 64, matching the shader uniform array size.
• Four new built-in shader variants: UnlitColorSkinned, UnlitTexturedSkinned, LitColorSkinned, LitTexturedSkinned. They add two vertex attribute inputs (a_joints: uvec4, a_weights: vec4) and a u_jointMatrix[MAX_JOINTS] uniform array, replace u_model * position with a per-vertex blended skin matrix, and (for the lit variants) derive the normal matrix from the same skin matrix so skinning works under non-uniform bone scale. MaterialManager compiles the eight programs up front and keys them by (type, skinned); Material#skinned: true selects the skinned variant.
• WebGL3DRenderer now uploads JOINTS_0 (gl.UNSIGNED_SHORT, via vertexAttribIPointer at location 4) and WEIGHTS_0 (gl.FLOAT at location 5) VBOs for every skinned mesh, skips u_model / u_normalMatrix uploads for skinned programs and writes u_jointMatrix once per skinned draw call. Skinned materials paired with non-skinned meshes fall back to the static program.
• GLTFAsset.build now parses skins[] (inverseBindMatrices, joints[] → glTF node indices) and records JOINTS_0 / WEIGHTS_0 attributes on primitives (promoted to Uint16Array and Float32Array, with a primitive.skinned boolean). asset.stats gains animationCount and skinCount; nodes carry the original rotationQuat alongside the Euler YXZ rotation so the mixer can interpolate without a round-trip through Euler.
• this.add3D.gltf(key) now instantiates a SkinnedMesh3D (instead of Mesh3D) for every skinned primitive, automatically builds a parallel skinned Material cache and wires joint references across the scene graph. Skinned meshes disable frustum culling by default (boundingSphere = null) because the bind-pose bound is invalidated once joints animate; users can assign a manual bound when their animation stays inside a known envelope.
• WebGL3DRenderer#_collect now recognises SkinnedMesh3D alongside Mesh3D when walking the display list. Previously skinned meshes were silently skipped by the opaque/transparent classifier even though their joints and animation mixer were running; they now take part in frustum-culling, sorting and both render passes.
• Vite demo (examples/vite-3d/) now focuses on the high-level Phaser-style API: this.load.gltf, this.add3D.gltf({ x, y, z, scale, animation, material }), this.add3D.material, primitive config shorthands and this.lights3d.preset(). It loads the LISA rigged character, adds a few simple primitives and keeps the previous runtime .glb helpers available as fixtures for renderer experiments.
• examples/vite-3d/ now includes a routed WEBGL3D mini-game gallery with Crystal Collector, Lane Runner and Dungeon Crawler examples. The games stay intentionally small and composable, using primitives, camera helpers, blob shadows, raycast picking, simple state machines and DOM HUDs rather than adding physics or collision systems.
• Material gains an alphaTest property (0..1, default 0) consumed by the four textured shader variants (unlit_textured, lit_textured and their :skinned counterparts). When greater than zero the fragment shader discards any pixel whose sampled alpha (multiplied by the tint alpha) falls below the cutoff - cut-out materials (foliage, chain-link, hair cards, Silent-Hill-style PS2 characters) can therefore render in the opaque pass with correct depth write and sorting, instead of being forced through the transparent pass. Colour-only materials ignore the flag (no texture to sample).
• GLTFAsset._buildMaterial now honours alphaMode: "MASK" natively: alphaCutoff is copied into the material template's new alphaTest field, transparent stays false, and the factory propagates the cutoff into the instantiated Material. Previously MASK materials were downgraded to BLEND (transparent pass, no depth write) which broke sorting against the surrounding opaque scene. When alphaCutoff is absent the glTF 2.0 default of 0.5 is used; MASK on a non-textured material records a downgrade note and the cutoff is dropped.
• New coarse WEBGL3D picking helpers: Phaser.Cameras.ThreeD.Ray3D, Camera3D#getRay(x, y, width, height), this.add3D.raycast(ray, roots?) and this.add3D.raycastFromPointer(pointer, options?). The first pass tests against world-space bounding spheres and returns nearest-first hit records with { object, root, distance, point, sphere }. SkinnedMesh3D preserves its bind-pose bound as pickSphere so rigged characters can still be selected without re-enabling frustum culling.
• New high-level Camera3D control helpers: fixed(position, target), follow(target, { offset, lookAtOffset }), orbit(target, { distance, yaw, pitch, lookAtOffset }), firstPerson(position, yaw, pitch) and clearControl(). follow and orbit recompute from an Object3D target during camera.update(), so common third-person, model-viewer and fixed-angle cameras no longer need manual Scene update code.
• New Billboard3D and BlobShadow3D game objects, exposed through this.add3D.billboard(config) and this.add3D.blobShadow(target, config). Billboards are upright camera-facing planes for pickups, labels and simple 3D UI. Blob shadows are cheap transparent planes that follow a target on X/Z to provide visual contact without shadow maps.
• glTF instances returned by this.add3D.gltf(...) now expose findNode, findNodes, findMesh and findMeshes helpers for searching the live cloned hierarchy by name or predicate. This makes it easier to attach props to sockets, inspect imported rigs and customise individual mesh materials.
• Object3D now has a lookAt(x, y, z, yawOnly?) helper (also accepts Object3D and vector-like targets) that rotates local +Z toward a target point. Small 3D games can turn enemies, pickups, props and projectiles toward a target without hand-written yaw / pitch math; pass true for yawOnly to keep the node upright.
• GLTFAsset._buildMaterial now honours KHR_materials_unlit natively: materials that declare it are routed through the unlit_* shader family, so prelit, viewer-style assets render without manual material: 'unlit' overrides. Material templates expose family ('lit' or 'unlit') and a convenience unlit boolean. The factory's _buildMaterial now respects the template's family, and the loader allowlists KHR_materials_unlit (the extension no longer surfaces as an "ignored extension" warning).
• Material gains emissive (RGB), emissiveIntensity (scalar, default 1) and emissiveTexture (only consumed by *_textured flavours). The eight built-in shaders sum the emissive contribution after lighting and before fog, so emissive surfaces pulse / glow independently of the directional / point lights. Material#setEmissive(r, g, b, intensity?) updates them in place. WebGL3DRenderer premultiplies the colour by intensity on CPU and binds the optional emissive map to texture unit 1, gated by u_useEmissiveTexture.
• GLTFAsset._buildMaterial now maps emissiveFactor and emissiveTexture onto the new Material fields. The 'emissive* -> ignored' downgrade is gone; only texCoord != 0 on emissiveTexture produces a downgrade note (the loader still samples with TEXCOORD_0).
• Material gains an explicit depthWrite flag (defaults to !transparent). WebGL3DRenderer now drives gl.depthMask per draw from material.depthWrite instead of forcing it from the opaque / transparent split, so alpha-tested cards can keep depth write while sliding into the transparent pass and overlay decals can stay transparent without occluding geometry below them. Material#setDepthWrite(bool) exposes the flag for runtime tweaks.
• New webgl3d.colorSpace Game config option ('linear' default, 'srgb' opt-in). When set to 'srgb', the eight built-in shaders treat user-supplied colours (Material#color, Material#emissive, ambient / directional / point lights, fog) and baseColor / emissiveTexture samples as sRGB, run lighting in linear space, and gamma-encode the final fragment. The active mode is exposed at runtime as game.renderer.colorSpace. 'linear' preserves the historical no-op pipeline so existing demos look the same.
• Material gains normalTexture (tangent-space normal map) and normalScale. lit_textured and lit_textured:skinned now support normal mapping using a derivative-based TBN, so meshes do not need to ship explicit TANGENT attributes. Material#setNormalMap(texture, scale?) updates them in place. WebGL3DRenderer binds the normal map to texture unit 2, gated by u_useNormalTexture so the lit_color and unlit programs are unaffected. GLTFAsset._buildMaterial now maps normalTexture and normalTexture.scale onto the new Material fields; the 'normalTexture -> ignored' downgrade is gone.
• Material gains specular (RGB, default [0,0,0]) and shininess (default 32). All four lit_* shader variants (color/textured + skinned) now sum a Blinn-Phong specular lobe per directional and point light, gated by u_useSpecular so unused materials skip the cost. Material#setSpecular(r, g, b, shininess?) is the chainable setter. The renderer uploads u_viewPos and the specular uniforms only on lit draw calls. The lobe is intentionally Phong-family, not PBR.
• Material gains occlusionTexture and occlusionStrength. lit_textured and lit_textured:skinned now multiply the diffuse lobe by mix(1.0, occlusion.r, strength) before specular and emissive are added. Material#setOcclusionMap(texture, strength?) is the chainable setter. WebGL3DRenderer binds the AO map to texture unit 3, gated by u_useOcclusionTexture so the lit_color and unlit programs are unaffected. GLTFAsset._buildMaterial now maps occlusionTexture and occlusionTexture.strength onto the new Material fields; the 'occlusionTexture -> ignored' downgrade is gone.
• Material gains textureTransform ({ offset, scale, rotation }). The four *_textured shader programs (lit/unlit + skinned) now multiply UVs by a per-material mat3 (u_uvTransform) before sampling, so the same matrix drives baseColor, emissive, normal and occlusion lookups. Material#setTextureTransform(spec) is the chainable setter (pass null to clear). WebGL3DRenderer builds the column-major T(offset) * R(rotation) * S(scale) matrix per draw and skips the upload (identity) on color-only programs. GLTFAsset._buildMaterial now reads KHR_texture_transform from pbrMetallicRoughness.baseColorTexture and forwards it; divergent transforms on emissiveTexture / normalTexture / occlusionTexture are surfaced as downgrade notes (one transform applies to every map). KHR_texture_transform is added to SUPPORTED_EXTENSIONS, so the loader no longer reports it as an "ignored extension". This implements the glTF KHR_texture_transform extension and is the recommended path for runtime UV scrolling, atlas slicing and texture rotation.
• Material gains texCoord (0 or 1). The four *_textured shader programs (lit/unlit + skinned) now declare a second UV attribute at location 6 and switch the active set per draw via the new u_useUV1 uniform; the renderer falls back to TEXCOORD_0 when the mesh does not provide a second UV channel so a partial import never samples uninitialised data. Material#setTexCoord(channel) is the chainable setter. Mesh3D exposes a new uvs2 field, mirrored on geometry.uvs2. WebGL3DRenderer._ensureMeshGPU allocates the corresponding VBO when uvs2 is present and disables attribute 6 otherwise. GLTFAsset now reads TEXCOORD_1 off mesh primitives, propagates the active channel from pbrMetallicRoughness.baseColorTexture.texCoord (only 0 and 1 are honoured; higher channels fall back with a downgrade note), and reports any divergent texCoord on emissiveTexture / normalTexture / occlusionTexture via material.downgrade[]. TEXCOORD_2 and higher are dropped at load time. metallicRoughnessTexture, metallicFactor and roughnessFactor downgrade messages are now action-oriented (they suggest using Material#specular / Material#shininess or baking the look into baseColor) instead of just saying "ignored". The "ignored extension" message also lists each unsupported extension by name and notes the WEBGL3D allowlist.
• New Phaser.GameObjects3D.InstancedMesh3D class + GPU instancing path. The mesh keeps a single shared geometry / material / VAO and draws count copies through one gl.drawElementsInstanced call. Per-instance state lives in two typed arrays exposed on the mesh: instanceMatrices (Float32Array, maxInstances * 16, column-major mat4 per slot) and the optional instanceColors (Float32Array, maxInstances * 3). Setters: setMatrixAt(i, mat), setPositionAt(i, x, y, z), setPositionScaleAt(i, x, y, z, scale), setColorAt(i, r, g, b), getMatrixAt(i, out?), commitInstances(). Four new instanced shader variants (unlit_color:instanced, unlit_textured:instanced, lit_color:instanced, lit_textured:instanced) declare mat4 a_instanceMatrix (locations 7–10) and vec3 a_instanceColor (location 11), compose world = u_model * a_instanceMatrix * a_position, and approximate per-instance normals as u_normalMatrix * mat3(a_instanceMatrix) * a_normal (exact for rotations + uniform scales). MaterialManager.getProgram now accepts an object variant { skinned, instanced } (the legacy boolean still works). WebGL3DRenderer._ensureMeshGPU allocates a dynamic-draw matrix VBO + optional colour VBO and binds them with vertexAttribDivisor(loc, 1); _drawMesh re-uploads via bufferSubData whenever instancesDirty is set, then issues drawElementsInstanced. New factories: add3D.instancedMesh(geometry, material, max), add3D.instancedCube(config), add3D.instancedPlane(config). Skinning + instancing is intentionally unsupported in this iteration; _drawable: true lets custom Mesh3D subclasses opt into the renderer's collect whitelist without registering by name.
• New Phaser.Lights3D.SpotLight3D lighting type. LightManager3D exposes a fourth slot (lights3d.spots[], capped at four entries) plus addSpot(config) / addExistingSpot(light) / clearSpots(), mirroring the point-light API. Each spot carries position, direction, range, innerCone (radians) and outerCone (radians); setCone(inner, outer?) is the chainable cone-only setter. The four lit_* shader programs (color/textured + skinned) now sum a per-spot lobe with the same 1 - smoothstep(0, range, dist) distance falloff used by point lights, multiplied by a cone gate smoothstep(cos(outerCone), cos(innerCone), dot(-L, dir)). Spot specular contribution piggybacks on Material#specular / Material#shininess. WebGL3DRenderer precomputes the cone cosines on upload and packs scratch buffers (u_spotPos, u_spotDir, u_spotColor, u_spotIntensity, u_spotRange, u_spotInnerCos, u_spotOuterCos) at the same shape as the point arrays. LightManager3D.update now also caches a normalised copy of every spot direction so the renderer skips the per-draw normalise. GLTFAsset._buildLights and GameObjectFactory3D._applyLights now honour KHR_lights_punctual type: "spot" (with innerConeAngle / outerConeAngle defaults from the spec); the previous 'spot light dropped' warning is gone.

Fixes

• Fix reversions in rounded rectangle handling. Thanks @laineus!
• Remove duplicate function definition and exposed internal code docs from RectangleCanvasRenderer.
• Fix duplicate texture name resulting from RenderTexture#saveTexture. Thanks @UnaiNeuronUp!
• Fix framebuffers (in filters and DynamicTextures) using mipmaps incorrectly. Now filters do not render with mipmaps. Thanks @Flow!
• Fix lack of default export in ESM build. Thanks @kibertoad!
• Fix lack of Class and LOG_VERSION export in ESM build. Thanks to many users including @Flow and @rex for helping investigate this!