Skip to content
CAI
Software that uses CAICheck a score

playcanvas/engine

53.2

Adequate · 15 November 2026

400.5k

lines of production code

JavaScript

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add AudioListenerComponent and AudioListenerComponentSystem

Introduces the AudioListenerComponent, which allows an Entity to act as the positional hearing point for SoundComponents, and the corresponding AudioListenerComponentSystem to manage these listeners. The system registers the listener's position and orientation every frame via the sound manager, and the component handles enabling/disabling the listener state on the entity.

src/framework/components/audio-listener · high confidence

Add JointComponent for rigid body constraints

A new JointComponent is introduced to constrain the relative motion of two rigid bodies, supporting fixed, ball, hinge, slider, and 6-DOF joint types. The component allows users to define anchor points, motion limits, motors, and collision settings, with the joint entity's transform defining the constraint frame. A corresponding JointComponentSystem manages the lifecycle of these joints, handling constraint creation when bodies are ready, monitoring for breakage based on impulse thresholds, and ensuring proper cleanup during entity removal.

src/framework/components/joint · high confidence

Add Lumberjack VAT asset with attribution

A new VAT (Voxel Animation Texture) asset for a low-poly lumberjack model has been added to the examples/assets/vat directory. The change includes a lumberjack.txt file containing attribution details for the original Sketchfab model by Daz (CC BY 4.0) and notes that the corresponding lumberjack.vat file was generated using the project's converter script at 10 frames per second.

examples/assets/vat · high confidence

Add SMAA anti-aliasing as an opt-in CameraFrame effect

Subpixel Morphological Anti-Aliasing (SMAA) is now available as an optional effect that can be added to a CameraFrame to smooth jagged geometry edges within a single frame. The implementation includes GLSL and WGSL shader passes for edge detection, weight calculation, and neighborhood blending, along with the necessary lookup textures and a \SmaaEffect\ class that exposes quality presets (LOW, MEDIUM, HIGH, ULTRA) via threshold, search steps, and corner rounding parameters. The effect resolves the scene before other post-processing effects, ensuring depth of field and bloom work on the anti-aliased image, and can be combined with multisampling or TAA.

src/extras/effects/smaa · high confidence

Add Spine physics and loaders.gl integration examples

The examples now include a new 'integrations' category featuring a Spine physics demo that showcases skeletal animations with physics constraints (using the 'celestial-circus' and 'snowglobe' assets) and a loaders.gl example that demonstrates loading Draco-compressed point cloud models into the PlayCanvas engine.

examples/assets/spine · high confidence

Add VAT character crowd rendering scripts and example

New scripts have been added to the \scripts/esm/vat\ directory to support rendering crowds of characters using Vertex Animation Textures (VAT). This includes a \VatCharacters\ script component for runtime rendering, a converter (\vat-converter.mjs\) to bake skinned GLB animations into VAT containers, shader chunks (\vat-chunks.mjs\) for GLSL and WGSL, and data handling utilities (\vat-data.mjs\). This allows users to author and render large numbers of animated characters efficiently in a single instanced draw call.

scripts/esm/vat · high confidence

Add WebGPU compute-based radix sort implementations

The engine now includes GPU-accelerated sorting capabilities for WebGPU, introducing two distinct algorithmic approaches in the shader library: a portable 4-bit radix sort (using histogram, prefix-sum, and reorder passes) and the OneSweep algorithm (optimized for NVIDIA hardware). These new compute shaders enable efficient, high-performance sorting of large datasets directly on the GPU, supporting both standard and indirect dispatch modes for dynamic element counts.

src/scene/shader-lib/wgsl/chunks/radix-sort · high confidence

Add anti-aliased Grid visualizer for scene navigation

A new Grid component has been added to the extras library, providing an anti-aliased reference grid that follows the camera and fades out with distance. This tool helps users visualize scale and navigate 3D scenes, featuring configurable axis colors, line thickness, spacing, and support for both GLSL and WGSL rendering pipelines.

src/extras/grid · high confidence

Add architectural perspective correction script

A new PerspectiveCorrection script is available for camera entities to apply architectural perspective correction (shift lens), keeping vertical lines parallel when the camera looks up or down. The script works by temporarily modifying the camera's pitch during rendering and using the camera's projectionOffset to preserve the framing, ensuring that camera controls and other scripts observing the entity remain unaffected. It supports a verticalCorrection attribute (0 to 1) to control the degree of correction and a maxShiftAngle attribute (default 70 degrees) to limit the pitch converted into projection offset, preventing extreme stretching at steep angles. The feature is active only for perspective projection and is disabled in XR mode.

scripts/esm/camera · high confidence

Add lens flare effect to CameraFrame

A new LensFlareEffect is available for CameraFrames, allowing developers to add realistic lens flares to lights or specific world positions. The effect measures source visibility against scene depth to fade flares when occluded, supports customizable shape libraries with instanced sprite rendering, and includes options for light-based tinting, intensity scaling, and edge fading.

src/extras/effects/lens-flare · high confidence

Add mesh-based 3D text support

The textmesh script now supports rendering text as 3D meshes. This change introduces the Earcut triangulation library (earcut.min.js) for polygon triangulation and the OpenType font parser (opentype.min.js) for reading font data, along with their respective license files (earcut-license.txt, opentype-license.txt).

scripts/textmesh · high confidence

Add model attribution and license metadata files

Added .txt metadata files for numerous 3D models in the examples/assets/models directory. These files document the source, author, and license (primarily CC-BY-4.0) for each asset, ensuring proper attribution is recorded for third-party content used in the examples.

examples/assets/models · high confidence

Add opt-in auto-exposure effect for camera frames

Developers can now add an AutoExposureEffect to a CameraFrame to automatically adjust the scene's exposure based on its brightness, mimicking how the human eye adapts to light and dark. The effect measures a luminance histogram of the screen, averages the middle 80% of brightness values (excluding deep shadows and bright highlights), and gradually adapts the camera's exposure to display that average as middle grey. It is not registered by default; users must explicitly instantiate the effect and add it to their CameraFrame. The effect provides configurable parameters for exposure compensation, minimum/maximum exposure limits (EV), adaptation speed for light-to-dark and dark-to-light transitions, and metering weights (center weight, low/high percentiles). It supports both GLSL and WGSL shader backends and includes a debug view to visualize the histogram and exposure markers.

src/extras/effects/auto-exposure · high confidence

Added Playbot character animation assets

New animation data files for the Playbot character have been added to the examples assets, including \playbot-die.json\ and \playbot-idle.json\. These JSON files define skeletal animation keyframes for the character's 'die' and 'idle' states, providing reference assets for the engine's animation system.

examples/assets/animations · high confidence

Added UI kit texture atlas data

A new \ui-atlas.mjs\ file has been added to provide the asset data for the UI kit texture atlas (\ui-atlas.png\). This file defines the frames, pivots, and borders for various UI elements such as panels, buttons, icons, and avatars, enabling the rendering of these components at 2 pixels per screen unit.

examples/assets/ui · high confidence

Added WGSL tonemapping shader chunks

The rendering pipeline now includes a set of WGSL shader chunks for tonemapping, allowing users to apply various tonemapping curves to their scene output. This change introduces a central dispatcher (\tonemapping.js\) that selects the appropriate algorithm based on a \TONEMAP\ constant, alongside specific implementations for Filmic, Linear, Hejl, ACES, ACES2, Neutral, and None modes. These chunks provide the underlying mathematical functions (such as \toneMap\ and \getExposure\) required to process fragment colors, enabling more realistic lighting and color handling in the scene.

src/scene/shader-lib/wgsl/chunks/common/frag/tonemapping · high confidence

Added attribution metadata for new Gaussian Splat assets

New text files have been added to the examples/assets/splats directory to provide attribution and licensing information for the 'apartment' and 'knock-community-hall' Gaussian Splat assets. These files document the source URLs, authors, and CC-BY-4.0 license requirements, ensuring proper credit is given when using these specific assets in examples.

examples/assets/splats · high confidence

Added configurable tonemapping shader support

The rendering pipeline now includes a new tonemapping system that allows users to apply various tonemapping curves to scene colors. This change introduces a set of GLSL shader chunks supporting multiple tonemapping algorithms, including ACES, ACES2, Filmic, Hejl, Linear, Neutral, and None. The system also supports an exposure uniform, enabling dynamic control over brightness levels. Users can now select different tonemapping styles to achieve specific visual aesthetics or correct for high dynamic range in their scenes.

src/scene/shader-lib/glsl/chunks/common/frag/tonemapping · high confidence

Added syntax highlighting and themes for GLSL, WGSL, and JSDoc in the examples browser

The examples browser now supports syntax highlighting for GLSL and WGSL shader languages, as well as improved JSDoc tokenization in JavaScript. This is achieved by adding new language definition files (glsl.mjs, wgsl.mjs) and a JSDoc tokenizer (tokenizer-rules.mjs) to the Monaco editor configuration, alongside a new 'playcanvas' dark theme (theme.mjs) that customizes the editor's background and comment colors for better readability.

examples/src/app/monaco · high confidence

Area light LUT generation utility added

A new utility script, area-light-lut-bin-gen.js, has been added to the examples assets. This tool generates binary lookup tables (LUTs) for area lighting based on the Real-Time Polygonal-Light Shading with Linearly Transformed Cosines (LTC) algorithm, enabling more accurate and efficient rendering of area lights in the editor engine.

examples/assets/scripts/utils · high confidence

Code editor now supports autocomplete, go-to-definition, and error highlighting

The examples code editor has been upgraded to use Monaco Editor, enabling IDE-like features such as autocomplete, go-to-definition, and peek support for PlayCanvas examples. The editor now provides type definitions for the PlayCanvas API and example modules, allowing developers to get intelligent code completion and navigation. Additionally, runtime errors are highlighted directly in the code with squiggly underlines and hover messages, improving the debugging experience. The mobile view has been simplified to list example files as links to their GitHub source, while the desktop view retains full editing capabilities.

examples/src/app/components/code-editor · high confidence

Examples browser rebuilt with Vite and React

The examples browser application has been completely rewritten to use Vite as the build tool and React for the user interface. This change introduces a new modular architecture with dedicated modules for handling URL state encoding, category management, and iframe communication. It also adds the ability to download examples as standalone Vite projects, supports new device types (WebGL2 Bare, WebGPU Bare, Null), and includes a share dialog with state-encoded URLs. Also in this area: Inspector example now supports profiling from application start; Migrate examples from orbitCamera to CameraControls; Examples browser preserves shared links after category reorganization.

examples/src/app · high confidence

Expanded glTF extension support in GLB parser

The GLB parser now supports a comprehensive suite of glTF extensions, enabling richer 3D assets. This includes the KHR\_gaussian\_splatting extension for rendering Gaussian splat data, KHR\_draco\_mesh\_compression for optimized mesh loading, and KHR\_mesh\_gpu\_instancing for efficient instanced rendering. Material fidelity is improved with support for KHR\_materials\_anisotropy, clearcoat, dispersion, emissive strength, IOR, iridescence, sheen, specular, transmission, unlit, and volume effects, alongside the archived PBR-specular-glossiness model. Additionally, KHR\_lights\_punctual allows for punctual light sources, while KHR\_texture\_transform, KHR\_texture\_basisu, and KHR\_texture\_webp enhance texture handling and compression.

src/framework/parsers/glb/extensions · high confidence

Extras module merged into engine with unified API exports

The supplementary APIs previously maintained separately are now integrated into the engine's \src/extras\ directory, providing a single entry point for gizmos, file exporters, input controllers, and post-processing effects. Users can now import components like the TransformGizmo, OrbitController, and various effects (Bloom, SSAO, TAA, etc.) directly from the extras module, simplifying setup and ensuring consistent access to these advanced features.

src/extras · high confidence

Initial release of the pc.gfx WebGL graphics engine

This change introduces the foundational graphics engine (pc.gfx) for rendering. It provides the core classes and APIs required for WebGL rendering, including the GraphicsDevice for managing the WebGL context, Texture and RenderTarget for handling image data and off-screen buffers, and Shader/Program for managing GLSL shaders. It also includes the necessary data structures for geometry, such as VertexBuffer, IndexBuffer, and VertexFormat, along with supporting utilities like the ProgramLibrary for shader caching and ScopeSpace for managing shader state.

src/graphics · high confidence

Introduce Ammo.js physics backend implementation

This change adds the Ammo.js (Bullet) implementation for the physics engine, providing the concrete backend for rigid bodies, joints, shapes, and the physics world. Users gain access to specific physics capabilities such as configurable gravity scales on rigid bodies, the ability to filter raycast hits against mesh back faces, and optimized mesh collider handling that shares geometry data while supporting independent scaling. The implementation also includes fixes for mesh collider scaling issues and ensures broadphase bounds are correctly updated when bodies are teleported.

src/framework/physics/ammo · high confidence

Introduce Bundle asset type for packing multiple assets into a single archive

Users can now create 'bundle' assets that act as archives containing multiple other assets. The new Bundle class manages the downloaded archive, indexing files by URL and firing 'add' events as individual files become available, while the BundleRegistry tracks these bundles to serve their internal files directly from the loaded archive instead of making separate network requests. This allows for more efficient loading of related assets by reducing the number of HTTP requests required.

src/framework/bundle · high confidence

Introduce LayoutChild component for per-child sizing overrides

Users can now attach a LayoutChild component to entities within a LayoutGroup to control individual sizing and fitting behavior. This component exposes properties for minimum and maximum width/height, as well as fit proportions for horizontal and vertical stretching, allowing precise per-child overrides of the parent layout's calculations. Setting any of these properties triggers a resize event to update the layout.

src/framework/components/layout-child · high confidence

Introduce LayoutGroup component for automatic UI child positioning

The new LayoutGroup component allows an Entity to automatically position and scale its child ElementComponents based on configurable rules such as horizontal or vertical orientation, alignment, spacing, wrapping, and size fitting (stretch/shrink). The system handles layout recalculations (reflows) when the container or children are resized, when child elements are added or removed, or when layout properties change, ensuring predictable UI layouts without manual coordinate management.

src/framework/components/layout-group · high confidence

Introduce ScrollViewComponent for masked scrolling areas

The scroll-view component is now available, allowing entities to act as masked scrolling containers with optional horizontal and vertical scrollbars. Users can configure scroll orientation, scroll modes (clamp, bounce, infinite), and scrollbar visibility. The component supports mouse wheel navigation, configurable drag thresholds and friction, and exposes scroll position via events and properties.

src/framework/components/scroll-view · high confidence

Introduce SpriteComponent for rendering static and animated sprites

The engine now includes a new SpriteComponent that allows entities to render simple static sprites or animated sprite sequences. This component supports two modes: simple (single frame) and animated (playing SpriteAnimationClips). It provides properties for tinting (color/opacity), flipping (X/Y), sizing, and layer assignment. The component integrates with the rendering pipeline via a dedicated system that manages default materials, including support for 9-sliced rendering modes (sliced and tiled) and batching. Animation clips can be added and managed, with events for play, pause, resume, stop, end, and loop states.

src/framework/components/sprite · high confidence

Introduce null physics backend and template instantiation support

The framework now supports running without a physics engine by introducing a \NullPhysicsWorld\ class that acts as a no-op backend, allowing physics components to remain inert placeholders when no physics library is loaded. Additionally, a new \Template\ class has been added to the framework to handle template resources, enabling the creation of entity instances from raw database data via an \instantiate()\ method. A \SceneRegistryItem\ class was also introduced to manage scene registry entries, and a \script\ namespace was added to expose the \createLoadingScreen\ function for custom loading screen implementations.

src/framework · high confidence

Introduce scene compression utilities and decompression logic

Added new modules in src/scene/compress to handle compressed scene data: compress-utils.js provides helper methods to set entity position, rotation, and scale from compressed formats and to map compressed keys back to original field names, while decompress.js implements a recursive decompression process that restores original object field names in compressed scene nodes.

src/scene/compress · high confidence

Introduction of ScreenComponent for UI layout and scaling

Adds the ScreenComponent and its system to define rectangular UI areas that support 2D (screen space) and 3D (world space) rendering. This change introduces screen scaling logic with 'none' and 'blend' modes, automatic draw-order synchronization for child elements to handle z-fighting and hierarchy-based rendering, and proper cleanup of screen references when components are removed.

src/framework/components/screen · high confidence

Introduction of legacy animation system classes

The animation module now exposes the core classes for the legacy animation system: \Animation\, \AnimationNode\, \AnimationKey\, and \Skeleton\. These classes define the data structures for keyframes, node transforms, and skeleton hierarchy, along with the logic for time progression and interpolation. The \Animation\ class manages a collection of nodes, while the \Skeleton\ class handles the playback state, including looping behavior and time advancement via the \addTime\ method.

src/scene/animation · high confidence

Introduction of the ButtonComponent for UI interactions

The \src/framework/components/button\ directory now contains the implementation for the ButtonComponent, enabling entities to function as interactive buttons with visual states for hover, press, and inactive conditions. This component supports two transition modes—tinting colors or swapping sprites—and exposes a comprehensive set of events including mouse, touch, and XR select interactions. It is designed to work in conjunction with an ElementComponent to define the button's visual appearance and input hit area, allowing developers to easily add button behavior to UI elements.

src/framework/components/button · high confidence

Introduction of the new RenderComponent

The engine now uses a new RenderComponent to enable entities to render 3D meshes and primitive shapes (such as box, sphere, cone, cylinder, plane, capsule, and torus). This component manages MeshInstances, supports loading assets, and exposes properties for shadow casting, receiving shadows, lightmapping, batching, and custom bounding boxes. It replaces the previous ModelComponent and is registered as the 'render' component in the component system.

src/framework/components/render · high confidence

Lit shader entry points now support depth picking in other render passes

The main shader entry points for lit materials in 'other' render passes (GLSL and WGSL) have been updated to handle depth picking. When the PICK\_PASS is active, the shaders now output standard pick colors, and if the DEPTH\_PICK\_PASS flag is also set, they additionally output depth information via a secondary color channel. This enables the picker to provide world-space pick points with depth data for objects rendered in these passes.

src/scene/shader-lib/glsl/chunks/lit/frag/pass-other, src/scene/shader-lib/wgsl/chunks/lit/frag/pass-other · high confidence

New CameraFrame post-processing effects: Auto Exposure, Bloom, CAS, and Color Enhancement

Several new post-processing effects are now available as opt-in additions to the CameraFrame pipeline. Auto Exposure automatically adapts the camera's exposure to the scene's brightness using a luminance histogram, with configurable adaptation speeds and metering ranges. Bloom adds a realistic glow to bright light sources, supporting both half-resolution and high-quality full-resolution generation. Contrast Adaptive Sharpening (CAS) is introduced to counteract TAA blur by sharpening the scene image. Additionally, a Color Enhancement effect allows for HDR-aware adjustments to shadows, highlights, midtones, vibrance, and dehaze. These effects are implemented as distinct modules under src/extras/effects, each integrating with the CameraFrame's composition stages. Also in this area: Fix lens flare occlusion timing and adjust effect processing order.

src/extras/effects/cas · high confidence

New CameraFrame render pass with integrated post-processing effects

The engine now includes a new \CameraFrame\ render pass in the extras module that consolidates camera rendering and post-processing into a single, configurable unit. This pass integrates Screen Space Ambient Occlusion (SSAO) with configurable types (lighting, combine, or none), HDR bloom with adjustable intensity and threshold, Depth of Field with high/low quality modes and optional near blur, and volumetric fog support for clustered omni and spot lights. It also provides comprehensive color grading capabilities including brightness, contrast, saturation, tint, and dual LUT crossfading, along with vignette, fringing, and color enhancement effects (shadows, highlights, vibrance, midtones, dehaze). The pass supports temporal anti-aliasing (TAA), configurable render target resolution scaling, multisampling, and stencil buffers, with all shader chunks exposed for customization.

src/extras/render-passes · high confidence

New Depth of Field effect with near-blur and high-quality modes

The Depth of Field (DOF) effect is now available as a dedicated CameraFrame effect, allowing users to simulate optical focus by blurring objects outside a specific distance range. This implementation introduces a new \nearBlur\ option to blur foreground objects in addition to the background, and a \highQuality\ mode that blurs the full-resolution scene for better visual fidelity (defaulting to true). Users can control the effect via \focusDistance\, \focusRange\, \blurRadius\, \blurRings\, and \blurRingPoints\ properties. The effect integrates into the post-resolve stage, mixing the blurred result into the scene in linear HDR space before tone mapping, and includes debug views for the circle of confusion and blur textures.

src/extras/effects/dof · high confidence

New ESM script library for controllers, rendering, and annotations

The \scripts/esm\ directory now provides a collection of ready-to-use, ES-module scripts that attach to entities via the script component. This includes camera and character controllers (CameraControls, FirstPersonController, ThirdPersonController), rendering helpers (CameraFrame for post-processing, BlurredPlanarReflection, PlanarRenderer, ShadowCatcher, Grid, and Water), and interaction tools (AnnotationManager). These scripts are imported directly from the \playcanvas\ npm package (e.g., \import { CameraControls } from 'playcanvas/scripts/esm/camera-controls.mjs'\) and are not part of the core engine bundle, allowing for modular usage of common engine features.

scripts/esm · high confidence

New ESM-based WebXR script library

The WebXR functionality has been reorganized into the \scripts/esm/xr\ directory, providing a suite of modular, ES-module scripts for building immersive experiences. This location introduces \XrSession\ for managing VR/AR session lifecycles, \XrControllers\ for automatically loading and displaying controller models based on WebXR Input Profiles, \XrNavigation\ for handling teleportation and locomotion, \XrMenu\ for hybrid hand-tracking and controller-based menus, and \XrManipulation\ for two-handed world scaling and rotation. These scripts replace previous implementations with a more robust, shared-asset architecture that handles controller model caching, pose tracking visibility, and system menu gesture conflicts.

scripts/esm/xr · high confidence

New ElementInput module for UI event handling

The input handling logic for UI elements has been consolidated into a new \src/framework/input/element-input.js\ module. This file introduces the \ElementInputEvent\ class and its subclasses (such as \ElementMouseEvent\) to represent input events fired on \ElementComponent\ instances, including support for mouse, touch, and XR input sources. It also includes internal helper functions for geometric calculations like ray-quad intersection, which are used to determine hit targets for UI interactions.

src/framework/input · high confidence

New GSplatProcessor for GPU-based Gaussian Splat manipulation

A new GSplatProcessor class has been added to the framework, enabling GPU-based processing of Gaussian Splat data. This component allows users to read from source texture streams and write results to destination streams using custom GLSL or WGSL shader code. It supports operations such as painting, selection marking, or custom data transforms by binding source and destination resources (via components or direct resource references) and passing custom uniforms like brush patterns or lookup tables. The processor automatically handles stream resolution and provides built-in functions for accessing splat attributes (center, rotation, scale, color).

src/framework/gsplat · high confidence

New Gaussian Splatting utility scripts for animation, effects, and procedural generation

Added a suite of new ESM scripts in the gsplat module to extend Gaussian Splatting capabilities. GSplatFlipbook enables flipbook-style animations by sequencing multiple splat files with reference-counted asset caching. GSplatImage and GSplatText allow rendering 2D textures and text as splats on the XZ plane. GSplatMesh converts 3D meshes into splats using scanline rasterization, while GSplatLines provides debug primitives like lines, arrows, and AABBs. GSplatRelighting applies dynamic lighting to splats via a proxy mesh and offscreen rendering. GSplatShaderEffect serves as a base class for applying custom vertex/fragment shader chunks. Finally, GSplatTrees adds wind sway effects to tree-like splat structures, and GSplatWeather creates infinite procedural particle systems for rain or snow.

scripts/esm/gsplat · high confidence

New Gooch and Hatch material examples with WGSL support

Added new example scripts for Gooch and Hatch materials in the misc folder, demonstrating custom ShaderMaterial implementations using both GLSL and WGSL shader languages. The Gooch material example showcases wrap-around diffuse lighting with cool/warm color mapping, while the Hatch material example demonstrates texture array usage and shadow pass support. Both examples utilize engine-provided shader chunks for transform and normal calculations, supporting features like skinning, morphing, and instancing.

examples/assets/scripts/misc · high confidence

New Procedural Sky script with day/night cycle

A new \procedural-sky.mjs\ ESM script has been added to \scripts/esm/sky\. This script implements a procedural skydome using the Preetham et al. analytic daylight model (ported from three.js) for realistic daytime atmosphere rendering. It also introduces original features for a night sky, including an RGBM image-based lighting bake, a day/night blend transition, and a moon, enabling dynamic day/night cycles without requiring static skybox textures.

scripts/esm/sky · high confidence

New Tween animation script component

A new \tween.js\ script has been added to the \scripts/animation\ directory, introducing a configurable animation component for entities. This script allows users to define multiple tween sequences via a JSON attribute, supporting properties such as target path, start/end values, duration, easing functions, and repetition behavior. It includes features for automatic playback, event-triggered starts, and lifecycle management (pausing/resuming when the script is disabled/enabled), enabling declarative animation control within the engine.

scripts/animation · high confidence

New WGSL fragment shader chunks for the lit rendering path

The lit fragment shader implementation has been migrated to a modular WGSL chunk system. This change introduces a collection of new JavaScript modules in src/scene/shader-lib/wgsl/chunks/lit/frag that define the core rendering logic, including Tangent-Bitangent-Normal (TBN) basis construction, ambient lighting (Spherical Harmonics and environment atlas), specular occlusion, clustered light handling (shadows, cookies, and utilities), various specular models (GGX, Blinn-Phong, Anisotropic GGX), Fresnel calculations, and iridescence. It also adds support for nine-sliced rendering, debug passes, and outline effects, replacing the previous monolithic or GLSL-based fragment shader structure with a composable WGSL architecture.

src/scene/shader-lib/wgsl/chunks/lit/frag · high confidence

New Web Audio-based sound system in src/platform/sound

The sound subsystem has been replaced with a new implementation in src/platform/sound that uses the Web Audio API for playback. This introduces a SoundManager to handle the global audio context, volume, and suspend/resume states, and a Sound class to wrap decoded AudioBuffers. Playback is managed via SoundInstance (for 2D audio) and SoundInstance3d (for positional audio), which support features like pitch, looping, start time, duration, and 3D distance models (linear, inverse, exponential). The system also includes a Listener class to track the audio listener's position and orientation for spatial audio calculations.

src/platform/sound · high confidence

New WebGPU compute-based radix sort with adaptive backends

A new \ComputeRadixSort\ facade has been added to the graphics engine, providing high-performance GPU sorting for 32-bit unsigned integer keys on WebGPU devices. The implementation automatically selects the optimal backend based on hardware capabilities: it uses the OneSweep algorithm on NVIDIA devices for superior performance, while falling back to a portable multi-pass 4-bit radix sort on all other WebGPU devices. The sort supports both direct dispatch and indirect dispatch modes, allowing dispatch arguments to be generated from compute shaders for advanced rendering workflows.

src/scene/graphics/radix-sort · high confidence

New WebXR framework modules for anchors, hand tracking, and DOM overlay

The \src/framework/xr\ directory now includes dedicated modules for persistent anchors (\XrAnchor\, \XrAnchors\), hand tracking (\XrHand\, \XrFinger\, \XrJoint\), and DOM overlay (\XrDomOverlay\). These additions provide structured APIs for anchoring virtual content to the real world, accessing detailed hand joint data, and rendering UI overlays in AR sessions, alongside updated constants and hit-test sources.

src/framework/xr · high confidence

New animation blend tree types and controller architecture

The animation framework now supports 1D, 2D Cartesian, 2D Directional, and Direct blend trees, allowing animations to be blended based on single parameters, independent 2D axes, directional vectors, or explicit weight values. This change introduces a new \AnimController\ and associated state graph classes (\AnimState\, \AnimTransition\, \AnimNode\) that manage these blend trees and handle state transitions, providing a more flexible and mathematically robust animation system.

src/framework/anim/controller · high confidence

New camera control scripts added

Added four new camera scripts to the engine: FlyCamera for first-person navigation with keyboard and mouse input, FollowCamera for smoothly tracking a target entity with configurable offset and lerp speed, OrbitCamera for rotating around a pivot point with inertia and framing capabilities, and TrackingCamera for simple look-at behavior. These scripts provide ready-to-use camera controllers for common interaction patterns.

scripts/camera · high confidence

New camera input controllers: Fly, Focus, and Orbit

The input system now includes three new camera controllers in the \src/extras/input/controllers\ directory. The FlyController enables free-flight navigation where movement follows the camera's orientation, with configurable yaw/pitch ranges and damping. The FocusController provides a non-interactive easing animation to a target pose, useful for transitioning between camera states, and reports when the target is reached. The OrbitController allows orbiting around a focus point with panning and zooming capabilities, supporting configurable ranges and damping for rotation, movement, and zoom. All controllers extend InputController and use a Pose-based system for state management.

src/extras/input/controllers · high confidence

New clustered lighting infrastructure and unified light management

The engine introduces a new clustered lighting system that organizes omni and spot lights into a 3D world-space grid for efficient GPU processing. This change consolidates light management into a new \LightList\ class that ranks and orders lights by type and mask, ensuring consistent shader generation. Light properties are now encoded into a dedicated \LightsBuffer\ texture for GPU consumption, while \LightTextureAtlas\ manages shared shadow and cookie atlases. The system exposes \LightingParams\ to allow configuration of cluster cells, maximum light counts, and shadow/cookie settings, and includes a \WorldClustersDebug\ tool for visualizing cluster occupancy.

src/scene/lighting · high confidence

New common fragment shader chunks for rendering features

This change introduces a suite of new WGSL fragment shader chunks in the common library, providing foundational rendering capabilities. These include MSDF text rendering with improved anti-aliasing and outline/shadow support, flat shading via geometric normals, and fog effects (linear, exponential, exponential squared). It also adds utilities for color space handling (gamma correction, linearization, reversible tone mapping), texture encoding/decoding (RGBM, RGBP, RGBE, float-as-uint), and scene integration (depth reading, shadow casting, picking, and environment processing). These chunks enable more advanced visual effects and data handling in custom shaders and materials.

src/scene/shader-lib/wgsl/chunks/common/frag · high confidence

New common fragment shader chunks for rendering utilities

The fragment shader library now includes a set of new reusable chunks that provide core rendering capabilities. These include MSDF text rendering with improved anti-aliasing and outline/shadow support, flat shading via geometric normals, and fog (linear, exponential, exponential squared). The library also adds support for scene textures (writing depth for post-processing), screen-space depth retrieval, and shadow casting for custom shaders. Additional utilities cover color encoding/decoding (gamma, RGBM, RGBP, RGBE), reversible tone mapping, environment atlas mapping, and procedural Bayer dithering (2x2, 4x4, 8x8, 16x16).

src/scene/shader-lib/glsl/chunks/common/frag · high confidence

New core shape primitives for geometry and intersection testing

The engine now exposes a dedicated set of shape classes in the core module to support collision detection, spatial indexing, and raycasting. This includes BoundingBox (axis-aligned), BoundingSphere, OrientedBox, Plane, Ray, and Tri. These classes provide standard operations such as intersection tests (e.g., intersectsRay, containsPoint), copying, and cloning, forming the foundational geometry types used by the rendering and physics systems.

src/core/shape · high confidence

New core utilities and data structures

The core library now includes several new utility modules: a 1D BlockAllocator for efficient memory management, an IndexedList for keyed item storage, an ObjectPool to reduce garbage collection, and helper classes for array equality checks, GUID generation, hashing, numeric ID generation, and map merging. Additionally, the platform detection logic has been updated to explicitly identify visionOS and Web Worker environments, and the debug system now supports trace channels with optional stack logging.

src/core · high confidence

New debug rendering helpers: Outline, Texture, Wire, and WideLine renderers

Added four new debug rendering utilities to the extras renderers module. The OutlineRenderer draws solid color outlines around entity silhouettes for selection or hover highlighting. The TextureRenderer displays 2D color and depth textures in the viewport for debugging, supporting various encodings and channel selections. The WireRenderer draws thin wireframe shapes (spheres, boxes, frustums, etc.) for visualization. The WideLineRenderer supports thick, instanced lines with variable width, caps, joins, and dash patterns.

src/extras/renderers · high confidence

New forward-rendering shader chunks for lit materials

Added new GLSL and WGSL shader chunks for the forward rendering pass of lit materials. These files define the main entry points, variable declarations, and backend evaluation logic for lighting, reflections, refraction, and ambient occlusion, providing the core rendering implementation for both graphics APIs. Also in this area: Support for KHR\_materials\_diffuse\_transmission glTF extension; Post-processing effects are now extensible via the CameraFrameEffect system.

src/scene/shader-lib/glsl/chunks/lit/frag/pass-forward, src/scene/shader-lib/wgsl/chunks/lit/frag/pass-forward · high confidence

New fragment shader chunks for WebGPU and WebGL3 support

Added new shader chunk files in src/platform/graphics/shader-chunks/frag to support modern graphics APIs. This includes gles3.js for WebGL3 features like dual-source blending and multiple color attachments, webgpu.js for WebGPU GLSL compatibility (samplerless texture functions, combined sampler/texture passing), and dedicated WGSL chunks (webgpu-clear.js, webgpu-depth-resolve.js, webgpu-mipmap.js) for native WebGPU operations. Also added half-types.js for f16 type aliases in WGSL and shared-wgsl.js for WebGPU-specific utility functions.

src/platform/graphics/shader-chunks/frag · high confidence

New gizmo shape primitives for interaction and selection

The gizmo system now includes dedicated shape classes for rendering and intersecting UI elements: ArcShape (torus sectors), ArrowShape (cone and cylinder), BoxShape, BoxLineShape, PlaneShape, and SphereShape. These shapes provide configurable geometry parameters (such as radius, size, thickness, and gap) and expose properties for color states (default, hover, disabled) and visibility, enabling more precise and visually distinct interaction handles within the editor.

src/extras/gizmo/shape · high confidence

New graphics framework modules: Picker, RenderPassPicker, SceneDepthReader, and PrimitiveCache

This change introduces four new modules to the graphics framework. The Picker class now uses an internal RenderPassPicker to handle picking logic, supporting both standard mesh instances and GSplat components, and can optionally capture depth information to compute world positions of picked points. A new SceneDepthReader allows asynchronous reading of a camera's scene depth back to the CPU. Additionally, a PrimitiveCache module has been added to cache shape primitives (box, sphere, etc.) using the DeviceCache, improving resource management for common geometry.

src/framework/graphics · high confidence

New graphics infrastructure classes for rendering and resource management

The graphics platform introduces several new internal classes to support modern rendering features. A new \Compute\ class enables compute shader execution on WebGPU, while \DrawCommands\ provides a container for multi-draw and indirect draw parameters. Resource management is improved with \DeviceCache\ for per-device shared resources and \BuiltInTextures\ for engine-owned placeholder textures. Rendering logic is enhanced by \DepthState\ for depth testing configuration, \DynamicBuffer\ for uniform buffer handling, and \BufferUtils\ for safe typed array views of buffer storage. Additionally, \getSingleAttachmentBlendState\ in \blend-state-utils\ allows independent blending for multiple render targets, and \DebugGraphics\ manages GPU marker stacks.

src/platform/graphics · high confidence

New iframe runtime with inspector, mini-stats, and device selection

The examples iframe now uses a new runtime architecture that loads example code dynamically and provides built-in developer tools. Users can toggle the PlayCanvas Inspector and MiniStats overlay directly from the example UI, with support for examples to adopt these instances to avoid duplicates. The runtime also introduces a device type selector (WebGPU, WebGPU Bare, WebGL 2, WebGL 2 Bare, Null) that respects user preferences and example-specific flags, and includes mobile-friendly improvements like disabled text selection and zoom blocking.

examples/iframe · high confidence

New interactive 3D gizmo and view-cube extras

This change introduces a complete set of interactive 3D manipulation widgets to the engine's extras. It adds a \Gizmo\ base class and specific implementations for translation (\TranslateGizmo\), rotation (\RotateGizmo\), and scaling (\ScaleGizmo\), which provide visual handles for moving, rotating, and resizing entities in the scene. These gizmos support features like snapping, coordinate space selection (local/world), and theme customization. Additionally, a \ViewCube\ component is added, providing an SVG-based UI element that allows users to align the camera to specific axes by clicking on its faces. The implementation includes supporting modules for colors, constants, and mesh rendering. Also in this area: 2 commits (0 fixes) modifying examples, src/extras.

src/extras/gizmo · medium confidence · unverified

New internal shader chunks for cookie blitting, morphing, and lightmapper post-processing

The engine adds a set of new internal WGSL shader chunks to handle specific rendering tasks. Cookie blitting now uses dedicated fragment shaders for 2D and cube-map textures to correctly sample light cookies. Morph targets stored in textures are now processed via new vertex and fragment shaders that blend morph deltas based on texture indices and factors. Additionally, the lightmapper includes new post-processing shaders: a bilateral denoiser to smooth baked lightmaps while preserving edges, a dilate filter to expand baked areas, and updated end-shaders that handle RGBM encoding and ambient occlusion contrast/brightness adjustments during the final bake pass.

src/scene/shader-lib/wgsl/chunks/internal · high confidence

The engine now includes a set of new internal GLSL shader chunks located in src/scene/shader-lib/glsl/chunks/internal. These additions provide dedicated fragment and vertex shaders for 2D and cube cookie blitting, immediate line rendering, and a comprehensive reproject shader that supports cubemap, equirectangular, and octahedral source/target projections with configurable encoding/decoding functions. Morph target processing is now handled via dedicated texture-based vertex and fragment shaders that blend morph deltas into a final texture. Additionally, lightmapper baking is supported by new chunks for directional and diffuse lightmap end-passes, bilateral denoising, and dilation filters to clean up baked lighting artifacts.

src/scene/shader-lib/glsl/chunks/internal · high confidence

New math utilities: BitPacking, BlueNoise, and FloatPacking

The \src/core/math\ module now includes three new utility classes to support advanced rendering and data handling. \BitPacking\ provides static methods (\set\, \get\, \all\, \any\) for manipulating individual bits within numbers, useful for packing flags or indices. \BlueNoise\ introduces a seeded random number generator based on a 32x32 blue noise texture, offering \value()\ for scalar noise and \vec4()\ for vector noise, which helps reduce artifacts in dithering and sampling. \FloatPacking\ adds \float2Half\ for converting 32-bit floats to 16-bit half-floats for GPU storage, and \float2RGBA8\ for packing float bits into RGBA8 color components, facilitating efficient data transfer to the GPU.

src/core/math · high confidence

New modern input system with pose-based controllers and pen support

This location introduces the core components of a new, modern input system. It adds a \Pose\ class for managing 3D camera position, rotation, and clamping ranges, alongside \InputDelta\ and \InputFrame\ classes that accumulate and flush input changes. The system includes built-in sources for various devices and adds support for pen input in touch sources, as well as a custom wrapper for manually calculating movementX and movementY to ensure consistent input handling across different pointer types.

src/extras/input · high confidence

New modular texture parser architecture with support for Basis, DDS, HDR, KTX, and KTX2 formats

The texture loading system has been refactored into a pluggable parser architecture located in \src/framework/parsers/texture\. This change introduces dedicated parsers for various texture formats: \BasisParser\ and \Ktx2Parser\ handle Basis supercompression (including KTX2 containers), \DdsParser\ supports legacy DDS files with DXT, PVRTC, and ETC1 formats, \KtxParser\ handles standard KTX1 files, and \HdrParser\ loads Radiance HDR images with correct RGBE encoding. The existing \ImgParser\ now acts as a catch-all for standard image formats, utilizing \ImageBitmap\ where supported and falling back to \HTMLImageElement\ with cross-origin handling. This modular approach allows for format-specific parsing logic, improved error handling, and better integration with the asset pipeline.

src/framework/parsers/texture · high confidence

New physics scripts for resetting bodies, debugging collisions, and vehicle simulation

The scripts/physics area now includes three new scripts: ActionPhysicsReset, which allows dynamic rigid bodies to be reset to their initial position and orientation via a custom event; RenderPhysics, which visualizes collision shapes (boxes, spheres, capsules, cones, cylinders) in the scene with configurable opacity and shadow casting; and Vehicle, which implements a raycast-based vehicle controller with configurable suspension, steering, and braking forces.

scripts/physics · high confidence

New procedural geometry classes and refactored normal calculation

This change introduces a suite of new procedural geometry classes—BoxGeometry, CapsuleGeometry, CircleGeometry, ConeGeometry, CylinderGeometry, DomeGeometry, PlaneGeometry, SphereGeometry, and TorusGeometry—alongside a shared ConeBaseGeometry superclass and a geometry-utils module. These classes provide ready-to-use mesh data for common shapes, supporting options for segment counts, radii, and optional tangent calculation. Additionally, the underlying normal calculation logic has been updated to return zero vectors for vertices with no triangle area (degenerate triangles) instead of NaN, ensuring more stable rendering for edge cases.

src/scene/geometry · high confidence

New shared graphics utilities and frame-pass infrastructure

This change introduces a suite of new helper classes and render passes in the scene/graphics module to support advanced rendering features. It adds a FisheyeProjection class for managing camera projection distortion, an EnvLighting class for generating and prefiltering environment lighting atlases, and a LightCube class for simple particle lighting. Additionally, it introduces FramePassColorGrab and FramePassDepthGrab for capturing scene buffers, a PrefixSumKernel for GPU-based parallel scan operations, and a PostEffect base class to standardize post-processing workflows.

src/scene/graphics · high confidence

New template files for examples infrastructure

Added new template files (controls.jsx, example.html, placeholder.html, share.html) to the examples/templates directory. These templates define the structure for example pages, including import maps, script loaders, and share page metadata, supporting the examples build and sharing features.

examples/templates · high confidence

New touch, gamepad, and keyboard/mouse input sources

Added new input source classes for \src/extras/input/sources\: \DualGestureSource\ and \SingleGestureSource\ provide on-screen virtual controls (joysticks or touch areas) with double-tap detection for touchscreens; \MultiTouchSource\ handles multi-touch gestures like panning and pinching; \GamepadSource\ polls standard gamepads for stick and button states; and \KeyboardMouseSource\ manages keyboard keys, mouse buttons, movement, and wheel events, including optional pointer lock. These sources extend the existing \InputSource\ base to expose structured deltas for modern input hardware.

src/extras/input/sources · high confidence

New utility scripts for cubemap, planar reflections, texture downloading, and Mac GPU profiling

Four new utility scripts are added to the engine examples to simplify common rendering tasks. The CubemapRenderer script allows entities to generate cubemap textures by rendering six faces from a single camera's perspective, exposing attributes for resolution, mipmaps, and depth. The PlanarRenderer script enables planar reflections by mirroring a scene camera across a defined plane and updating a reflection texture. The download-texture script provides a utility to export texture data as PNG files, using a manual PNG construction method to avoid canvas API bit-loss issues with premultiplied alpha. Finally, the mac-gpu-profiling script facilitates GPU profiling on macOS via Xcode's GPU Frame Capture by creating a hidden WebGPU canvas to trigger frame-end events.

scripts/utils · high confidence

Null graphics device implementation for headless execution

The engine now supports running without a real GPU by introducing a NullGraphicsDevice and a suite of corresponding null implementations (NullBindGroup, NullDynamicBuffers, NullShader, etc.). This allows the application to execute in headless environments like Node.js, enabling use cases such as server-side rendering, testing, or background processing where actual graphics output is not required.

src/platform/graphics/null · high confidence

Portable indirect dispatch helpers for compute shaders

Added WGSL utility chunks to support indirect compute dispatches in a way that is portable across browsers. The new \dispatch-core\ chunk provides a \calcDispatch2D\ function to calculate 2D dispatch dimensions from a linear workgroup count, while \indirect-core\ defines the \DrawIndexedIndirectArgs\ and \DrawIndirectArgs\ structures for indirect draw calls. Additionally, \sort-indirect-args\ introduces a \writeSortIndirectArgs\ helper that writes indirect dispatch arguments for a compute-based sorter; this helper is specifically implemented to avoid non-portable WGSL features (like unrestricted pointer parameters) to ensure compatibility with Firefox's WebGPU implementation.

src/scene/shader-lib/wgsl/chunks/common/comp · high confidence

Skydome now supports depth writing for post-processing effects

The skydome (box and dome sky types) can now write depth values during the scene or depth prepass. This enables depth-based post-processing effects, such as Depth of Field, to correctly interact with the sky geometry. The feature is controlled via the new \depthWrite\ property on the scene's sky object, which defaults to disabled to maintain previous behavior.

src/scene/skybox · high confidence

Support for multiple UV sets and UV transforms in lit vertex shaders

The lit vertex shader chunks have been reorganized and expanded to support up to eight UV sets (UV0–UV7) and UV coordinate transforms. This change introduces new shader chunks (uvSet, uvSetAttribute, uvSetVarying, uvTransform, uvTransformUniforms) that allow additional texture coordinates beyond the standard UV0 and UV1 to be passed through the pipeline, enabling more complex material effects that rely on multiple texture layers or coordinate spaces.

src/scene/shader-lib/glsl/chunks/lit/vert · high confidence

Unified GSplat rendering engine with GPU-driven sorting and streaming LOD

The GSplat rendering system has been unified into a single, high-performance pipeline that supports both CPU and GPU-based sorting, with GPU sorting enabled by default on WebGPU. This change introduces a hybrid renderer that uses compute shaders for frustum culling, interval-based stream compaction, and radix sorting, significantly improving performance for large scenes. It also adds comprehensive streaming Level of Detail (LOD) support, allowing splats to be loaded and unloaded dynamically based on camera distance and a global scene budget. Additional features include directional shadow casting, fog support, and optimized memory management for octree-based splat files.

src/scene/gsplat-unified · high confidence

Unified GSplat shader architecture with user customization hooks

The GSplat rendering pipeline has been restructured into a unified, modular shader system that supports multiple rendering passes (forward, shadow, pick, prepass) and introduces extensibility for developers. Key additions include the \gsplatModifyPS\ hook, allowing users to customize final splat fragment colors in the forward pass, and a new user-varying stream system (via \gsplatUserVaryingsPS\ and associated cache templates) that enables passing custom data through the rendering pipeline. The implementation also adds a \GSplatProcessor\ for processing splat data streams, a work-buffer-backed geometry path for efficient color-only updates, and support for stochastic alpha rendering with dithering.

src/scene/shader-lib/wgsl/chunks/gsplat/frag · high confidence

Unified GSplat vertex shader architecture with hybrid renderer and fisheye support

The GSplat rendering pipeline has been restructured into a modular, unified shader architecture. The vertex logic is now split into reusable chunks (e.g., \gsplatCenter\, \gsplatCorner\, \gsplatModify\) that support both standard rasterization and a new hybrid GPU-driven renderer (\gsplatHybrid\) which reads pre-projected data from a compute-built cache. This update introduces support for generalized fisheye projections, 2D Gaussian Splatting (2DGS), and user-customizable shader hooks (\modifySplatCenter\, \modifySplatColor\) for runtime splat modification. It also integrates half-precision spherical harmonics evaluation, per-axis focal length handling, and overdraw visualization modes.

src/scene/shader-lib/wgsl/chunks/gsplat/vert · high confidence

Unified Gaussian Splat rendering engine with compressed and procedural support

The gsplat rendering system has been unified into a single, high-performance pipeline that replaces the previous separate implementations. This change introduces native support for compressed PLY files (GSplatCompressedData) and procedural splat generation (GSplatContainer), allowing developers to create splat data programmatically or load optimized compressed assets. The new architecture uses a flexible GSplatFormat system to define texture streams and shader read code, supporting variable Spherical Harmonics bands and custom extra streams. Rendering is now GPU-driven with centralized texture management, deferred resource cleanup, and optimized sorting, providing a consistent API for both loaded and procedural Gaussian Splat content.

src/scene/gsplat · high confidence

Unified public API entry point via src/index.js

The engine now exposes a single, consolidated entry point at src/index.js that re-exports the entire public API. This file organizes exports into clear categories—Core, Math, Shape, Platform (Graphics, Input, Net, Sound), and Scene—making it easier for users to import specific modules or the full engine without navigating the internal folder structure.

src · high confidence

WebGPU backend implementation and shader format migration

The WebGPU graphics backend has been implemented, introducing a new rendering path that utilizes WGSL shaders instead of the previous transpiled formats. This change includes a comprehensive mapping of engine pixel formats to native WebGPU texture formats, support for compute shaders with automatic bind-group reflection, and optimized dynamic buffer management using staging buffers. The update also brings support for indirect draw calls, improved error reporting via validation scopes, and fixes for device loss recovery and resource cleanup.

src/platform/graphics/webgpu · high confidence

Removals

Bloom component removed from the engine

The Bloom component and its associated data structures have been deleted from the framework. This removes the ability to apply a bloom filter effect to render targets via the component system, meaning any entities previously using this component will no longer have the effect applied.

src/framework/components/bloom · high confidence

Primitive component removed from the framework

The primitive component and its associated data class have been deleted from the engine. This removes the ability to attach primitive shapes (such as boxes, spheres, cones, and cylinders) to entities via the legacy component system, along with the editor bindings that exposed the shape type and color properties.

src/framework/components/pack, src/framework/components/skybox · high confidence

Removal of PlayCanvas Designer engine integration code

The \src/designer\ directory has been removed, deleting all files that previously integrated the PlayCanvas Designer tool with the engine. This includes the \editor\_application.js\ (which managed the quad-view rendering, grid, and view cube), the \LinkInterface\ (used to expose component properties to the editor), and the \livelink\ module (which handled cross-window messaging for entity and component updates). As a result, the engine no longer contains the internal systems, graphics primitives, or communication protocols required to run the in-engine design view.

src/designer · high confidence

Removal of legacy Asset and Entity resource handlers

The legacy \AssetResourceHandler\ and \EntityResourceHandler\ implementations have been removed from the framework. This deletion eliminates the previous single-pass entity loading logic and the use of \Function.extendsFrom\ for inheritance, reflecting a shift toward the new pack-based loading architecture and updated component systems.

src/framework/resources · high confidence

Removal of legacy Entity and EntityLoader implementations

The legacy \pc.fw.Entity\ class and the \pc.fw.EntityLoader\ utility have been removed from the framework. This deletion eliminates the old mechanism for loading entities via the Corazon API and the \GraphManager\, as well as the previous \close\ method for entity cleanup, reflecting a shift away from the deprecated designer-centric architecture.

src/framework/entity · high confidence

Removal of legacy ModelResourceHandler

The legacy \ModelResourceHandler\ file in \src/scene/resources\ has been removed. This deletion eliminates the old code path for loading model assets, which previously handled JSON deserialization, primitive type mapping, and direct texture loading via callbacks. Users relying on this specific handler implementation will no longer have access to it, as the engine has moved to a different resource loading architecture.

src/scene/resources · high confidence

Removal of legacy animation frame shim and flycam helper

The \helpers\_animframe.js\ file, which provided a polyfill for \requestAnimationFrame\ with visibility detection, has been removed, relying instead on native browser support. Additionally, the \helpers\_flycam.js\ file containing the \FlyCam\ class for camera navigation (pan, dolly, orbit) has been deleted from the engine helpers, removing this specific camera control implementation from the codebase.

src/helpers · high confidence

Removal of legacy animation resource handler

The legacy animation resource handler file has been removed from the codebase. This change eliminates the old implementation that relied on the deprecated \extendsFrom\ method for inheritance and used callback-based loading instead of promises, effectively cleaning up the resource management layer for animations.

src/anim/resources · high confidence

Removal of legacy audio components

The \AudioListenerComponent\, \AudioListenerData\, \AudioSourceComponent\, and \AudioSourceData\ files have been deleted from the framework. This removes the legacy component-based audio system that previously handled listener positioning and source playback properties (such as URI, volume, loop, and ambient settings) via the editor link interface.

src/framework/components/audio · high confidence

Removal of legacy event system implementation

The legacy event system module (\src/events/events\_events.js\) has been removed. This module previously provided \bind\, \unbind\, and \fire\ methods for attaching and triggering events on objects via \pc.extend\. Its removal indicates a shift away from this specific event handling pattern, likely in favor of a newer or different event architecture.

src/events · high confidence

Removal of legacy input handling modules

The legacy input subsystem has been removed from the engine. Specifically, the \pc.input.Controller\, \pc.input.Keyboard\, \pc.input.Mouse\, and the \pc.input\ namespace initialization file have been deleted. This eliminates the previous API for handling keyboard and mouse events, requiring users to migrate to the newer input system.

src/input · high confidence

Removal of legacy math library files

The legacy math implementation files (math\_math.js, math\_matrix.js, math\_quaternion.js, math\_utils.js, and math\_vector.js) have been removed from the src/math directory. This cleanup eliminates the old JavaScript-based vector, matrix, and quaternion implementations, which were previously used for core engine calculations.

src/math · high confidence

Removal of legacy pc.fw.picking API

The legacy \pc.fw.picking\ module and its \Picker\ class have been removed from the framework. Users must migrate to \pc.scene.Picker\ for all entity picking operations, as the old implementation is no longer available.

src/framework/picking · high confidence

Removal of legacy pc.graph.materialplugin namespace and Phong shader implementation

The legacy \pc.graph.materialplugin\ namespace and its associated \phong\ shader implementation have been removed from the codebase. This deletion eliminates the previous mechanism for determining material transparency, generating shader state keys based on enabled light counts, and selecting shader programs based on texture presence. Users relying on this specific legacy API for custom material handling or shader generation will no longer have access to these functions, as the code has been fully deleted.

src/scene/materialplugin · high confidence

Removal of legacy pc.net.http and pc.net namespaces

The legacy \pc.net.http\ module and the \pc.net\ namespace have been removed from the codebase. This eliminates the old HTTP client implementation (including methods like \get\, \post\, \put\, and \delete\_\) and the empty \pc.net\ object, signaling that these APIs are no longer available for use.

src/net · high confidence

Removal of legacy primitive component implementation

The legacy primitive component system, including its data structure and editor bindings, has been removed from the framework. This deletion eliminates the previous implementation that rendered basic geometric shapes (box, sphere, cone, cylinder) using the older \pc.graph.procedural\ API and manual material parameter setting, indicating a shift to a different underlying architecture for primitive rendering.

src/framework/components/primitive · high confidence

Removal of legacy script loading infrastructure

The legacy script loading system has been removed, specifically deleting the \ScriptResourceHandler\, \ScriptLoader\, and core \pc.script\ module files. This eliminates the previous mechanism for dynamically injecting \\<script\>\ tags and managing script queues, indicating a shift to a new loading architecture (likely promise-based or integrated into the resource manager) that replaces these deprecated components.

src/script · high confidence

Removal of legacy shader program libraries

The legacy shader generation modules for basic rendering, particles, Phong shading, picking, and shadow mapping have been removed from the \pc.gfx.programlib\ namespace. This deletion eliminates the old code paths that generated GLSL shaders based on the previous program library architecture, indicating a shift to a different shader system or code generation strategy.

src/graphics/programlib · high confidence

Removal of the StaticCubeMap component

The StaticCubeMap component, which allowed entities to generate a static cubemap from six assigned image assets (posx, negx, posy, negy, posz, negz), has been removed from the engine. This change deletes the component implementation and its associated editor link configurations, meaning users can no longer attach this component to entities to create skyboxes or static environment maps.

(repo-wide) · high confidence

Removal of the legacy PickComponent

The legacy \PickComponent\ and its associated system (\PickComponentSystem\) and data structures (\PickComponentData\) have been removed from the framework. This component, which previously allowed entities to be picked from the scene using a specific picker object and rendered pick visualization shapes, is no longer available. Users should migrate to the \pc.scene.Picker\ API for picking functionality.

src/framework/components/pick · high confidence

Removed legacy pc.shape geometry primitives and intersection utilities

The \src/shape\ module has been removed, eliminating the legacy \pc.shape\ namespace and its associated classes (Aabb, Box, Frustum, Plane, Sphere, Torus, and the base Shape class) as well as the \pc.shape.intersection\ utility functions. This change removes the old geometric primitive API, which is replaced by the new \pc.Ray\, \pc.Plane\, \pc.BoundingSphere\, and \pc.BoundingBox\ types.

src/shape · high confidence

Architecture

Centralized GLSL shader chunk collections

Shader chunks for compositing, GSplat, particles, and standard rendering are now organized into centralized collection files (e.g., compose-chunks-glsl.js, gsplat-chunks-glsl.js). This structure groups related shader logic, making it easier to locate and manage the underlying GLSL code for these rendering features.

src/scene/shader-lib/glsl/collections · high confidence

Decouple physics engine into a backend abstraction

The physics framework has been refactored to support pluggable backends, introducing base classes for physics bodies, joints, and the world itself. This allows the engine to run with a real physics library (such as Ammo) or a null implementation, enabling physics components to function without a loaded engine. Users can now explicitly select the physics backend via AppOptions.physicsWorld, and the system handles backend-specific details like gravity scaling, mesh collider scaling, and contact normal calculations internally.

src/framework/physics · high confidence

HTTP client implementation in platform/net

The HTTP networking module has been relocated to src/platform/net/http.js, establishing the core logic for sending and receiving HTTP requests. This file defines the Http class, which manages request options such as credentials, concurrency limits, and response types, serving as the foundational network layer for asset loading and API communication within the platform.

src/platform/net · high confidence

Organize WGSL shader chunks into dedicated collection modules

The WGSL shader chunk library has been reorganized into specific collection files (compose-chunks-wgsl.js, gsplat-chunks-wgsl.js, particle-chunks-wgsl.js, and shader-chunks-wgsl.js) that group related shader parts by feature area. This structure consolidates imports for post-processing compositing, Gaussian splat rendering, particle systems, and standard lit materials, making the shader library easier to navigate and maintain.

src/scene/shader-lib/wgsl/collections · high confidence

Refactored batching system into modular classes

The batching logic in src/scene/batching has been restructured from a monolithic implementation into distinct, single-responsibility classes: BatchGroup, BatchManager, Batch, and SkinBatchInstance. This change improves code maintainability and clarity by separating the concerns of group management, batch creation, and skinning data handling, while preserving the existing batching functionality for users.

src/scene/batching · high confidence

Refactored renderer architecture to use a RenderPass-based system

The rendering pipeline in \src/scene/renderer\ has been restructured to use a modular RenderPass architecture. The previous monolithic \ForwardRenderer\ logic has been split into specialized passes: \RenderPassForward\ handles the main scene rendering, \RenderPassCookieRenderer\ manages light cookies, and dedicated passes (\RenderPassShadowDirectional\, \RenderPassShadowLocalClustered\, \RenderPassShadowLocalNonClustered\) handle shadow updates. New frame-pass wrappers like \FramePassMultiView\ and \FramePassPostprocessing\ manage XR stereo rendering and post-processing steps. This change introduces a \Culler\ class for visibility culling and a \LayerRenderStep\ class to decouple layer rendering from the main renderer, improving modularity and performance.

src/scene/renderer · high confidence

Refactored shader generation into modular, define-driven programs

The shader generation logic in the scene library has been restructured into distinct, modular programs (Lit, Standard, Particle, ShaderMaterial) that use a define-driven approach to assemble shader code from reusable chunks. This change introduces new utility classes like LitOptionsUtils and LitShaderOptions to manage shader variants and options, enabling more flexible customization of shader behavior through user-defined chunks and improved support for both GLSL and WGSL shader languages.

src/scene/shader-lib/programs · high confidence

Reorganized particle vertex shader into modular WGSL chunks

The particle system vertex shader logic has been restructured from a single monolithic file into a collection of modular, includeable WGSL chunks (e.g., \particle\_init\, \particle\_billboard\, \particle\_cpu\, \particle\_end\). This change separates concerns such as CPU vs. GPU simulation paths, billboard/mesh rendering modes, animation frame handling, and screen-space alignment, making the shader codebase easier to maintain and extend while preserving the existing particle rendering behavior.

src/scene/shader-lib/wgsl/chunks/particle/vert · high confidence

Restructured GLSL lit fragment shader into modular chunks

The lit fragment shader implementation has been reorganized from a monolithic structure into a collection of modular, reusable GLSL chunks (e.g., \TBN.js\, \ambient.js\, \clusteredLight.js\, \fresnelSchlick.js\). This change improves maintainability and allows specific rendering features—such as clustered lighting, specular occlusion, and various shading models—to be included or excluded based on material settings, without altering the core rendering behavior for end users.

src/scene/shader-lib/glsl/chunks/lit/frag · high confidence

Restructured particle shader logic into modular GLSL chunks

The particle rendering and simulation code has been reorganized from monolithic files into a collection of modular, include-based GLSL chunks (e.g., \particleInput\, \particleUpdaterStart\, \particle\_billboard\). This change improves maintainability by separating concerns such as state reading/writing, spawning logic, and visual blending, while preserving the existing particle system behavior and capabilities.

src/scene/shader-lib/glsl/chunks/particle · high confidence

Volumetric fog render passes moved to dedicated module

The volumetric fog implementation has been reorganized by moving the frame and render pass logic into the new \src/extras/effects/volumetric-fog/passes\ directory. This change extracts the raymarching, shadow sampling, and compositing passes into separate, dedicated files (\frame-pass-volumetric-fog.js\, \render-pass-volumetric-fog.js\, \render-pass-volumetric-fog-combine.js\, and \render-pass-volumetric-fog-local.js\), improving code modularity and maintainability without altering the visual behavior of the effect.

src/extras/effects/volumetric-fog/passes · high confidence

Behavioural changes

1 commit (0 fixes) modifying examples/src/examples/compute/edge-detect, examples/src/examples/compute/indirect-dispatch, examples/src/examples/gizmos

A change to existing behaviour in examples/src/examples/compute/edge-detect, examples/src/examples/compute/indirect-dispatch, examples/src/examples/gizmos — 1 commit, 42 files: “Move each example into its own folder, with its thumbnails (\#9886)” (refs \#9886).

examples/src/examples/compute/edge-detect, examples/src/examples/compute/indirect-dispatch, examples/src/examples/gizmos · medium confidence · unverified

1 commit (0 fixes) modifying examples/src/examples/demos/villa-sales

A change to existing behaviour in examples/src/examples/demos/villa-sales — 1 commit, 4 files: “Add a villa sales demo on a gaussian splat capture (\#9965)” (refs \#9965).

examples/src/examples/demos/villa-sales · medium confidence · unverified

12 commits (1 fix) modifying examples/src/examples/compute/texture-gen

A change to existing behaviour in examples/src/examples/compute/texture-gen — 12 commits (1 fix), 5 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Examples mobile fixes (\#6335)”; “Dispatch multiple compute shaders in a single compute pass (\#6187)”; and 9 more (refs \#9886, \#6335, \#6187, \#9926, \#6186, …).

examples/src/examples/compute/texture-gen · medium confidence · unverified

14 commits (0 fixes) modifying examples/assets/cubemaps

A change to existing behaviour in examples/assets/cubemaps — 14 commits, 10 files: “\[ImgBot\] Optimize images (\#5190)”; “Multiple Examples updated to work on WebGPU (\#4869)”; “feat: Add a car showcase configurator example (\#9938)”; and 11 more (refs \#5190, \#4869, \#9938, \#6991, \#7225, …).

examples/assets/cubemaps · medium confidence · unverified

2 commits (0 fixes) modifying examples/src/examples/compute/scene-maps

A change to existing behaviour in examples/src/examples/compute/scene-maps — 2 commits, 5 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “refactor: Rename inconsistent public API names behind deprecated aliases (\#9937)” (refs \#9886, \#9937).

examples/src/examples/compute/scene-maps · medium confidence · unverified

2 commits (0 fixes) modifying examples/src/examples/debug

A change to existing behaviour in examples/src/examples/debug — 2 commits, 27 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “refactor: Move the grid example to the debug category (\#9950)” (refs \#9886, \#9950).

examples/src/examples/debug · medium confidence · unverified

2 commits (0 fixes) modifying examples/src/examples/demos/catapult

A change to existing behaviour in examples/src/examples/demos/catapult — 2 commits, 4 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Add haze to DynamicSkyEffect (\#9897)” (refs \#9886, \#9897).

examples/src/examples/demos/catapult · medium confidence · unverified

2 commits (0 fixes) modifying examples/src/examples/demos/splash-one

A change to existing behaviour in examples/src/examples/demos/splash-one — 2 commits, 9 files: “feat: Add a sky rendering test example (\#9903)”; “docs: Use American spelling across the engine, scripts, tests and examples (\#9940)” (refs \#9903, \#9940).

examples/src/examples/demos/splash-one · medium confidence · unverified

2 commits (0 fixes) modifying examples/src/examples/demos/welcome

A change to existing behaviour in examples/src/examples/demos/welcome — 2 commits, 3 files: “feat: Add a welcome demo as the default example (\#9914)”; “perf: Compile clustered area light code once per shader, and only for enabled shapes (\#9974)” (refs \#9914, \#9974).

examples/src/examples/demos/welcome · medium confidence · unverified

2 commits (0 fixes) modifying examples/src/examples/materials

A change to existing behaviour in examples/src/examples/materials — 2 commits, 57 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “feat: Use Gaussian scene color mipmaps in transmission-roughness example (\#9968)” (refs \#9886, \#9968).

examples/src/examples/materials · medium confidence · unverified

2 commits (0 fixes) modifying examples/src/examples/render-targets

A change to existing behaviour in examples/src/examples/render-targets — 2 commits, 71 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “feat: Rebuild the render to texture example in the area lights room (\#9900)” (refs \#9886, \#9900).

examples/src/examples/render-targets · medium confidence · unverified

2 commits (0 fixes) modifying examples/src/examples/shaders

A change to existing behaviour in examples/src/examples/shaders — 2 commits, 83 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “feat: Add a Gaussian mipmap filter, and smoother planar reflections (\#9932)” (refs \#9886, \#9932).

examples/src/examples/shaders · medium confidence · unverified

2 commits (0 fixes) modifying src/extras/effects/color-enhance, src/extras/effects/vignette

A change to existing behaviour in src/extras/effects/color-enhance, src/extras/effects/vignette — 2 commits, 6 files: “refactor: Move each CameraFrame effect into its own folder under src/extras/effects (\#9736)”; “docs: Use American spelling across the engine, scripts, tests and examples (\#9940)” (refs \#9736, \#9940).

src/extras/effects/color-enhance, src/extras/effects/vignette · medium confidence · unverified

2 commits (0 fixes) modifying src/extras/gizmo/transform

A change to existing behaviour in src/extras/gizmo/transform — 2 commits, 4 files: “refactor: Rename inconsistent public API names behind deprecated aliases (\#9937)”; “feat: Add camera, light, shape and icon gizmos with snapping handles (\#9809)” (refs \#9937, \#9809).

src/extras/gizmo/transform · medium confidence · unverified

2 commits (0 fixes) modifying src/scene/shader-lib/glsl/chunks/render-pass/frag, src/scene/shader-lib/wgsl/chunks/render-pass/frag

A change to existing behaviour in src/scene/shader-lib/glsl/chunks/render-pass/frag, src/scene/shader-lib/wgsl/chunks/render-pass/frag — 2 commits, 2 files: “Add SceneDepthReader, reading a camera's scene depth back to the CPU (\#9274)”; “docs: Use American spelling across the engine, scripts, tests and examples (\#9940)” (refs \#9274, \#9940).

src/scene/shader-lib/glsl/chunks/render-pass/frag, src/scene/shader-lib/wgsl/chunks/render-pass/frag · medium confidence · unverified

2 commits (1 fix) modifying src/extras/effects/color-lut

A change to existing behaviour in src/extras/effects/color-lut — 2 commits (1 fix), 3 files: “refactor: Move each CameraFrame effect into its own folder under src/extras/effects (\#9736)”; “fix: Convert colors with the exact sRGB transfer function (\#9892)” (refs \#9736, \#9892).

src/extras/effects/color-lut · medium confidence · unverified

24 commits (2 fixes) modifying examples/src/examples/graphics

A change to existing behaviour in examples/src/examples/graphics — 24 commits (2 fixs), 196 files: “Extras merged into engine (\#6228)”; “Move each example into its own folder, with its thumbnails (\#9886)”; “feat: Redesign the video texture example (\#9913)”; and 21 more (refs \#6228, \#9886, \#9913, \#9981, \#6280, …).

examples/src/examples/graphics · medium confidence · unverified

3 commits (0 fixes) modifying examples/src/examples/graphics-advanced

A change to existing behaviour in examples/src/examples/graphics-advanced — 3 commits, 34 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “refactor: Move seven examples to the graphics-advanced category (\#9952)”; “refactor: Rename inconsistent public API names behind deprecated aliases (\#9937)” (refs \#9886, \#9952, \#9937).

examples/src/examples/graphics-advanced · medium confidence · unverified

3 commits (0 fixes) modifying src/extras/effects/grading

A change to existing behaviour in src/extras/effects/grading — 3 commits, 3 files: “feat: Add a channel mixer to the color grading of CameraFrame (\#9939)”; “refactor: Move each CameraFrame effect into its own folder under src/extras/effects (\#9736)”; “docs: Use American spelling across the engine, scripts, tests and examples (\#9940)” (refs \#9939, \#9736, \#9940).

src/extras/effects/grading · medium confidence · unverified

3 commits (1 fix) modifying examples/src/examples/camera, examples/src/examples/input, examples/src/examples/sound

A change to existing behaviour in examples/src/examples/camera, examples/src/examples/input, examples/src/examples/sound — 3 commits (1 fix), 27 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Examples mobile fixes (\#6335)”; “Examples Overhaul (\#6060)” (refs \#9886, \#6335, \#6060).

examples/src/examples/camera, examples/src/examples/input, examples/src/examples/sound · medium confidence · unverified

3 commits (1 fix) modifying src/platform/graphics/shader-chunks/compute

A change to existing behaviour in src/platform/graphics/shader-chunks/compute — 3 commits (1 fix), 3 files: “feat: Add scene depth and color map access to compute shaders (\#9680)”; “Add Compute\#setupDispatchThreads to dispatch for a number of threads (\#9733)”; “fix: Convert colors with the exact sRGB transfer function (\#9892)” (refs \#9680, \#9733, \#9892).

src/platform/graphics/shader-chunks/compute · medium confidence · unverified

4 commits (0 fixes) modifying examples/src/examples/gaussian-splatting-fx

A change to existing behaviour in examples/src/examples/gaussian-splatting-fx — 4 commits, 114 files: “feat: Show the raw blind fields in the blind-data example (\#9963)”; “Add a glyph rain gaussian splat shader effect and example (\#9982)”; “refactor: Split Gaussian splatting examples into a new gaussian-splatting-fx category (\#9959)”; and 1 more (refs \#9963, \#9982, \#9959, \#9960).

examples/src/examples/gaussian-splatting-fx · medium confidence · unverified

4 commits (0 fixes) modifying examples/src/examples/particles

A change to existing behaviour in examples/src/examples/particles — 4 commits, 24 files: “refactor: Move the particle system examples to a particles category (\#9955)”; “feat: Restyle the mesh particles example (\#9956)”; “feat: Reskin the snow example (\#9969)”; and 1 more (refs \#9955, \#9956, \#9969, \#9958).

examples/src/examples/particles · medium confidence · unverified

4 commits (0 fixes) modifying src/scene/shader-lib/glsl/chunks/gsplat/frag/formats, src/scene/shader-lib/wgsl/chunks/gsplat/frag/formats

A change to existing behaviour in src/scene/shader-lib/glsl/chunks/gsplat/frag/formats, src/scene/shader-lib/wgsl/chunks/gsplat/frag/formats — 4 commits, 4 files: “Add SOG v3 loading and over-unity opacity rendering (\#9873)”; “Apply gsplat anti-aliasing per splat, detected from the file (\#9921)”; “Compact GSplat work buffer format (\#8480)”; and 1 more (refs \#9873, \#9921, \#8480, \#8547).

src/scene/shader-lib/glsl/chunks/gsplat/frag/formats, src/scene/shader-lib/wgsl/chunks/gsplat/frag/formats · medium confidence · unverified

4 commits (1 fix) modifying examples/src/examples/compute/particles

A change to existing behaviour in examples/src/examples/compute/particles — 4 commits (1 fix), 7 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Examples mobile fixes (\#6335)”; “Compute shader JSDocs + small API changes (\#6258)”; and 1 more (refs \#9886, \#6335, \#6258, \#6233).

examples/src/examples/compute/particles · medium confidence · unverified

5 commits (0 fixes) modifying scripts/esm/parsers

A change to existing behaviour in scripts/esm/parsers — 5 commits, 2 files: “Apply gsplat anti-aliasing per splat, detected from the file (\#9921)”; “Add SPZ gaussian splat format support via external parser (\#9018)”; “Convert the obj model parser to an ES module in scripts/esm/parsers (\#9019)”; and 2 more (refs \#9921, \#9018, \#9019, \#9076, \#9980).

scripts/esm/parsers · medium confidence · unverified

5 commits (1 fix) modifying examples/src/examples/integrations

A change to existing behaviour in examples/src/examples/integrations — 5 commits (1 fix), 21 files: “Set touch-action on elements the engine reads touch input from (\#10015)”; “Move each example into its own folder, with its thumbnails (\#9886)”; “Add a Mars 3D Tiles example using 3DTilesRendererJS (\#9942)”; and 2 more (refs \#10015, \#9886, \#9942, \#9948, \#9985).

examples/src/examples/integrations · medium confidence · unverified

5 commits (2 fixes) modifying examples/src/examples/physics

A change to existing behaviour in examples/src/examples/physics — 5 commits (2 fixs), 24 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Examples mobile fixes (\#6335)”; “feat: Add touch controls and a new look to the vehicle example (\#9991)”; and 2 more (refs \#9886, \#6335, \#9991, \#6192, \#6060).

examples/src/examples/physics · medium confidence · unverified

6 commits (0 fixes) modifying examples/src/examples/camera-frame

A change to existing behaviour in examples/src/examples/camera-frame — 6 commits, 56 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “feat: Add a channel mixer to the color grading of CameraFrame (\#9939)”; “Add haze to DynamicSkyEffect (\#9897)”; and 3 more (refs \#9886, \#9939, \#9897, \#9905, \#9896, …).

examples/src/examples/camera-frame · medium confidence · unverified

6 commits (0 fixes) modifying examples/src/examples/lights-and-shadows

A change to existing behaviour in examples/src/examples/lights-and-shadows — 6 commits, 59 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Rebuild the area lights example with a modelled room and controls (\#9894)”; “feat: Reskin the light-physical-units example (\#9970)”; and 3 more (refs \#9886, \#9894, \#9970, \#10018, \#9898, …).

examples/src/examples/lights-and-shadows · medium confidence · unverified

6 commits (1 fix) modifying examples/src/examples/loaders

A change to existing behaviour in examples/src/examples/loaders — 6 commits (1 fix), 20 files: “Extras merged into engine (\#6228)”; “Move each example into its own folder, with its thumbnails (\#9886)”; “Procedural geometry refactoring, createMesh and similar deprecation (\#6261)”; and 3 more (refs \#6228, \#9886, \#6261, \#6335, \#5675, …).

examples/src/examples/loaders · medium confidence · unverified

6 commits (1 fix) modifying examples/src/examples/misc

A change to existing behaviour in examples/src/examples/misc — 6 commits (1 fix), 36 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Examples mobile fixes (\#6335)”; “WebGL device ignores WebGL1 request and always creates WebGL2 device (\#6297)”; and 3 more (refs \#9886, \#6335, \#6297, \#9923, \#6307, …).

examples/src/examples/misc · medium confidence · unverified

7 commits (0 fixes) modifying examples/src/examples/gaussian-splatting

A change to existing behaviour in examples/src/examples/gaussian-splatting — 7 commits, 104 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Apply gsplat anti-aliasing per splat, detected from the file (\#9921)”; “refactor: Rename inconsistent public API names behind deprecated aliases (\#9937)”; and 4 more (refs \#9886, \#9921, \#9937, \#9928, \#9959, …).

examples/src/examples/gaussian-splatting · medium confidence · unverified

7 commits (1 fix) modifying examples/src/examples/compute/histogram

A change to existing behaviour in examples/src/examples/compute/histogram — 7 commits (1 fix), 12 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Examples mobile fixes (\#6335)”; “feat: Redesign four of the compute examples (\#9926)”; and 4 more (refs \#9886, \#6335, \#9926, \#6258, \#6221, …).

examples/src/examples/compute/histogram · medium confidence · unverified

7 commits (1 fix) modifying examples/src/examples/compute/vertex-update

A change to existing behaviour in examples/src/examples/compute/vertex-update — 7 commits (1 fix), 5 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “Procedural geometry refactoring, createMesh and similar deprecation (\#6261)”; “Examples mobile fixes (\#6335)”; and 4 more (refs \#9886, \#6261, \#6335, \#9926, \#6258, …).

examples/src/examples/compute/vertex-update · medium confidence · unverified

7 commits (1 fix) modifying examples/src/examples/demos/car-showcase

A change to existing behaviour in examples/src/examples/demos/car-showcase — 7 commits (1 fix), 6 files: “fix: Declare the shader chunk API version of the car showcase sweeps (\#9954)”; “perf: Share one shader across the car-showcase paints (\#9976)”; “feat: Add a car showcase configurator example (\#9938)”; and 4 more (refs \#9954, \#9976, \#9938, \#9997, \#9953, …).

examples/src/examples/demos/car-showcase · medium confidence · unverified

8 commits (1 fix) modifying src/extras/effects/dynamic-sky

A change to existing behaviour in src/extras/effects/dynamic-sky — 8 commits (1 fix), 20 files: “feat: Replace DynamicSkyEffect clouds and cloudTechnique with cloudType (\#9772)”; “docs: Describe the DynamicSkyEffect in XR (\#9857)”; “Add haze to DynamicSkyEffect (\#9897)”; and 5 more (refs \#9772, \#9857, \#9897, \#9889, \#9892, …).

src/extras/effects/dynamic-sky · medium confidence · unverified

9 commits (2 fixes) modifying examples/src/examples/animation

A change to existing behaviour in examples/src/examples/animation — 9 commits (2 fixs), 38 files: “Set touch-action on elements the engine reads touch input from (\#10015)”; “Move each example into its own folder, with its thumbnails (\#9886)”; “Examples mobile fixes (\#6335)”; and 6 more (refs \#10015, \#9886, \#6335, \#6192, \#10010, …).

examples/src/examples/animation · medium confidence · unverified

9 commits (4 fixes) modifying examples/src/examples/xr

A change to existing behaviour in examples/src/examples/xr — 9 commits (4 fixs), 58 files: “Move each example into its own folder, with its thumbnails (\#9886)”; “fix webxr-picking example (\#6248)”; “Examples mobile fixes (\#6335)”; and 6 more (refs \#9886, \#6248, \#6335, \#6192, \#6181, …).

examples/src/examples/xr · medium confidence · unverified

Added attribution files for HDRI assets

New text files have been added to the examples/assets/hdri directory to provide attribution and licensing information for specific HDRI images (empty-room, st-peters-square, and wide-street). These files document the source URLs from Polyhaven and confirm that the assets are distributed under the CC BY 4.0 license, ensuring proper credit is given for third-party content used in examples.

examples/assets/hdri · high confidence

Animation component refactored into modular binder and layer classes

The animation system has been restructured to improve maintainability and support dynamic layer management. The previous monolithic implementation is now split into distinct classes: \AnimComponentBinder\ handles the resolution and caching of animation targets (such as entity properties, other components, and graph nodes), \AnimComponentLayer\ encapsulates the state machine logic, weight blending, and mask application for individual animation layers, and \AnimComponentSystem\ manages the lifecycle, including re-binding targets when mesh instances change and correctly cloning layer masks and dynamic layers. This change ensures that dynamically added layers are properly initialized and that animation bindings remain valid across entity cloning and mesh updates.

src/framework/components/anim · high confidence

Animation component refactored to modern ES6 class structure

The legacy animation component implementation has been replaced with a modern ES6 class-based architecture. The old \animation\_component.js\ and \animation\_data.js\ files, which relied on the deprecated \pc.extend\ pattern and separate data classes, have been removed. They are replaced by new \component.js\ and \system.js\ files that use standard ES6 classes, native property definitions, and modern event handling. This change improves code maintainability and aligns the animation component with the engine's current component system standards.

src/framework/components/animation · high confidence

Animation interpolation constants now include category metadata

The constants for animation interpolation schemes (step, linear, and cubic) in the framework now include JSDoc @category tags. This change improves the organization and discoverability of these constants in API documentation, categorizing them under 'Animation' for better reference structure.

src/framework/anim · high confidence

Animation system refactoring and bug fixes

The animation engine in src/anim has been refactored to improve performance and fix several behavioral issues. Key changes include optimizing the addTime function by caching current keyframe indices, ensuring skeleton graphs update immediately when time is explicitly set to prevent visual glitches, and fixing support for negative animation speeds and zero-speed time setting. Additionally, the system now correctly handles skeletons with single keyframes and allows querying whether an animation is currently playing.

src/anim · high confidence

Animation, audio, and model parsers migrated to the pluggable parser registry

The animation clip, animation state graph, audio, and model parsers in src/framework/parsers have been refactored to integrate with the new pluggable parser registry. This change replaces the previous handler-based loading mechanism with a standardized registry interface, allowing these parsers to be discovered and invoked consistently alongside other resource types. For users, this ensures that animation clips, state graphs, audio files, and model assets (including GLB containers and JSON models) are loaded through a unified, extensible system that supports future parser additions without requiring handler-specific wiring.

src/framework/parsers · high confidence

Bloom effect restructured as a CameraFrame effect with improved resource management

The bloom post-processing effect has been refactored to extend CameraFrameEffect, moving its implementation into a dedicated folder structure (src/extras/effects/bloom). This change introduces a new 'postResolve' stage for the bloom pass and adds a 'highQuality' mode that generates bloom from the full-resolution scene for sharper results at a higher performance cost. Additionally, the implementation now correctly destroys the bloom render target when the effect is disabled and destroyed, preventing resource leaks.

src/extras/effects/bloom · high confidence

Bloom post-processing effect converted from component to class

The bloom post-processing effect is no longer available as a component; it has been removed from the post-processing pipeline and converted into a standalone class. This change simplifies the API by decoupling the bloom effect from the component system, requiring users to integrate the effect directly via the new class interface rather than adding a component.

src/graphics/post · high confidence

Camera component refactored to modern ES6 architecture with expanded post-processing support

The camera component has been completely rewritten from legacy JavaScript classes to modern ES6 modules, replacing the old \CameraComponentData\ and \camera\_component.js\ files with a new \component.js\, \system.js\, and \post-effect-queue.js\. This refactor introduces a \PostEffectQueue\ that allows multiple post-processing effects to be managed and chained per camera, replacing the previous single-effect limitation. The component system now maintains an array of active cameras sorted by priority rather than a single 'current' camera, enabling simultaneous rendering for split-screen or offscreen use cases. Additionally, the component now exposes more granular control over rendering, including per-attachment clear colors, stencil clearing, and support for custom shader passes, while removing legacy properties like \offscreen\ and \activate\ in favor of standard component enablement and render target assignment.

src/framework/components/camera · high confidence

Collision component restructured with dedicated trigger handling and signed scale support

The collision component implementation has been refactored to improve stability and accuracy. A dedicated Trigger class now manages trigger volumes, ensuring that trigger bodies are correctly destroyed and preventing crashes when triggers are enabled or disabled. Additionally, mesh colliders now correctly mirror with negative scale factors by tracking signed scale changes across the entity hierarchy, fixing issues where mirrored meshes would render incorrectly in the physics world.

src/framework/components/collision · high confidence

Component framework refactored to ES6 classes with simplified schema and direct event handling

The component system in src/framework/components has been rewritten from legacy JavaScript patterns (pc.extend, var, ComponentData classes) to modern ES6 classes (Component, ComponentSystem, ComponentSystemRegistry). Component schemas are now simplified to plain string arrays of property names, and ComponentSystems no longer fire events to subscribers; instead, they call subscriber methods directly for better performance. The ComponentSystemRegistry now manages ComponentSystem instances directly, and the Component class handles enable/disable state changes by calling onEnable/onDisable methods rather than relying on entity-level state propagation.

src/framework/components · high confidence

Examples browser UI overhaul with new components and mobile layout

The examples browser has been redesigned with a new mobile-first layout, a share dialog for social platforms, and improved category filtering. The \MainLayout\ component now manages a responsive mobile/desktop view with draggable panels, while the \Sidebar\ supports \category:\ and \example:\ tags for filtering. A new \ShareDialog\ allows users to share examples via social links or copy a URL. The \DeviceSelector\ now includes 'Bare' device types for testing, and \OverlaySelectInput\ fixes dropdown clipping by rendering to the body. Error handling is centralized in \ErrorBoundary\, and \CategoryPanel\ adds share/expand controls.

examples/src/app/components · high confidence

Examples browser development workflow overhauled with Vite and HTTPS support

The examples browser has been migrated to a Vite-based build system, replacing the previous setup. This change introduces native HTTPS development mode for mobile and XR device testing, utilizing mkcert for local certificate generation and management. The new workflow includes a dedicated build script for metadata and thumbnails, updated ESLint and Prettier configurations for source validation, and TypeScript configuration files to support the modernized project structure.

examples · high confidence

Exporters moved to extras and core texture extraction updated for WebGPU

The GLTF and USDZ exporters have been relocated from the core engine to the \src/extras/exporters\ directory, making them optional additions rather than built-in engine components. Additionally, the new \CoreExporter\ base class now uses a WebGPU shader-based blit to extract compressed textures to a canvas, replacing previous methods and ensuring correct handling of compressed formats during export.

src/extras/exporters · high confidence

Font system refactoring and canvas font transparency fix

The font framework has been reorganized into a dedicated /framework/font directory, introducing new constants for font types (MSDF and bitmap) and restructuring the core Font and CanvasFont classes. A key behavioral fix ensures that CanvasFont glyph cells are rendered fully transparent when their alpha is zero, preventing black artifacts caused by premultiplied color blending during texture upload. Additionally, the Font class now includes logic to migrate legacy font data (version \< 2) to the new map-based structure and properly destroys GPU textures when a font asset is unloaded.

src/framework/font · high confidence

GSplat component now uses unified rendering by default

The GSplat component has been updated to use the unified rendering architecture by default, replacing the legacy rendering path. This change improves performance and enables new features like shadow casting and unified picking. Existing projects using the legacy rendering mode must explicitly set \unified=false\ when adding the component to maintain previous behavior, as the legacy mode will be removed in a future release.

src/framework/components/gsplat · high confidence

Immediate line rendering now uses typed arrays and native WGSL shaders

The immediate line rendering system has been rewritten to improve performance and support WebGPU. Line data is now stored in retained typed arrays (Float32Array) with a cursor-based allocation strategy to avoid intermediate array allocations and garbage collection overhead. Additionally, the line rendering now uses native WGSL shaders alongside GLSL, ensuring compatibility with WebGPU backends.

src/scene/immediate · high confidence

Input system relocated to platform/input with improved state management

The input handling code has been moved into the src/platform/input directory, introducing a new modular structure with dedicated files for constants, controllers, and device-specific handlers (keyboard, mouse, gamepad, touch). This change includes a fix for mouse and keyboard state management: states are now explicitly cleared when the input controller is detached or when the window loses focus, preventing stale input data from persisting across session changes. Additionally, the gamepad implementation has been extended to support XR controllers and includes optimized polling that avoids memory allocation per frame.

src/platform/input · high confidence

Introduce interval-based GPU compaction and hybrid compute projector for GSplat rendering

The GSplat rendering pipeline now uses an interval-based approach for GPU-driven sorting and frustum culling, replacing the previous raster GPU sort path. This change introduces a new compute-based hybrid renderer that projects splats via a dedicated compute shader, supporting advanced features such as fisheye projection, stereo XR visibility, directional shadow culling, and stochastic alpha rendering. The new architecture improves scalability by processing splats in intervals, reducing atomic contention and enabling efficient culling for large splat counts.

src/scene/shader-lib/wgsl/chunks/gsplat · high confidence

Lightmapper refactored into modular classes and render passes

The lightmapper implementation in src/framework/lightmapper has been restructured to improve maintainability and support for WebGPU. The core baking logic is now split into dedicated classes: BakeLight (base), BakeLightSimple (for directional/omni/spot lights), and BakeLightAmbient (for ambient cubemap/constant lighting). Mesh node state is managed via BakeMeshNode, and post-processing filters (dilate/denoise) are handled by LightmapFilters. The main Lightmapper class now utilizes RenderPassLightmapper for receiver rendering and integrates with the new render pass infrastructure for shadow culling, replacing the previous monolithic structure.

src/framework/lightmapper · high confidence

Lit vertex shader refactored into modular chunks with expanded UV support

The lit vertex shader logic in the WGSL shader library has been reorganized into individual, reusable chunks (such as \litMain\, \normal\, and various UV handling modules). This structural change enables support for up to eight UV sets (UV0–UV7) via dynamic attribute and varying declarations, and introduces a mechanism for applying arbitrary UV transforms through uniform matrices. Additionally, the shader now passes the model scale to the fragment shader to support dynamic refraction effects and includes specific logic for nine-sliced scaling and MSDF text rendering.

src/scene/shader-lib/wgsl/chunks/lit/vert · high confidence

Material parser migration and legacy property handling

The material parsing logic in \src/framework/parsers/material/json-standard-material.js\ has been updated to handle legacy data formats more robustly. The parser now automatically migrates deprecated property names (such as \bumpMapFactor\ to \bumpiness\ and various \\*MapVertexColor\ properties) to their current equivalents when loading old material assets, ensuring backward compatibility. It also strips out ignored deprecated properties like \fresnelFactor\ and \shadowSampleType\. Additionally, the parser now correctly handles texture assignments by preserving existing placeholder textures if a new asset reference is provided, preventing unnecessary shader recompilations and ensuring smooth transitions when assets load.

src/framework/parsers/material · high confidence

MiniStats overlay rewritten with collapsible sections and GPU timing support

The MiniStats debug overlay has been redesigned to feature collapsible sections for CPU, GPU, VRAM, and resource counts, allowing users to toggle detailed sub-counters. It now includes dedicated CPU and GPU timers to display frame timing breakdowns (such as script, animation, physics, and render times) alongside draw call counts and VRAM usage. The rendering engine has been updated to support both GLSL and WGSL shaders, ensuring compatibility with WebGPU, and the overlay now properly cleans up its DOM element and event listeners upon destruction.

src/extras/mini-stats · high confidence

Model component refactored to ES6 class with shadow and lightmap support

The model component has been rewritten from the legacy pc.fw system into a modern ES6 class-based component. This change introduces support for casting and receiving shadows via the castShadows and receiveShadows properties, as well as lightmapping controls (castShadowsLightmap, lightmapped, lightmapSizeMultiplier). The component now manages multiple mesh instances through a unified model asset, replacing the previous single-asset limitation, and includes improved event handling for asset changes and material updates.

src/framework/components/model · high confidence

Modularized compose shader with slot-based effect pipeline

The compose shader logic has been restructured into a modular chunk-based system that supports a slot-based effect pipeline. This change introduces distinct processing stages (Scene, HDR, LDR, and Output) allowing effects to be registered and executed at specific points in the rendering chain, such as before or after tone mapping and gamma correction. It also centralizes debug output handling and conditionally includes scene depth data only when required, improving both customization flexibility and rendering correctness.

src/scene/shader-lib/glsl/chunks/render-pass/frag/compose, src/scene/shader-lib/wgsl/chunks/render-pass/frag/compose · high confidence

New animation evaluation engine with layer blending and event support

The animation system has been replaced with a new evaluation architecture located in src/framework/anim/evaluator. This update introduces a modular engine featuring AnimBlend for quaternion and vector interpolation, AnimCache for efficient curve evaluation, and AnimClip for managing playback state and events. A key behavioral change is the introduction of layer-based blending via AnimTargetValue, allowing multiple animation layers to be mixed with configurable weights and additive/overwrite modes. The system also now fully supports animation events, including correct handling during reverse playback, and provides a new AnimStateGraph class for loading and managing state-based animation logic.

src/framework/anim/evaluator · high confidence

New build and development tooling for examples

The examples build system has been migrated to Vite, introducing a suite of new utility scripts in \examples/utils\ to manage the build lifecycle. This includes \build-examples.mjs\ and \build-prod.mjs\ for generating example HTML, handling engine builds, and managing static assets, alongside \vite-dev-server.mjs\ for the local development environment. Supporting tooling has been added to parse example metadata and configuration comments (\example-source.mjs\, \metadata.mjs\), generate UI asset atlases (\generate-ui-atlas.mjs\), create thumbnails via Puppeteer (\thumbnails.mjs\), and handle HTTPS development certificates (\certificates.mjs\). Also in this area: Migrate examples from orbitCamera to CameraControls; Examples browser preserves shared links after category reorganization.

examples/utils · high confidence

New i18n framework with locale fallbacks and pluralization

The localization system has been replaced with a new implementation in src/framework/i18n. This update introduces a structured locale fallback mechanism (defined in constants.js) that maps language codes to specific regional variants (e.g., 'es' falls back to 'es-ES') and ensures the default locale is 'en-US'. The new I18n class handles asset-based translation loading, emits a 'change' event when the locale switches, and includes a built-in pluralization engine (utils.js) that supports complex CLDR rules for languages like Russian, Polish, and Arabic, as well as simpler rules for English, French, and others.

src/framework/i18n · high confidence

New material architecture with typed properties and uniform buffers

The material system has been refactored to use a typed property model backed by material uniform buffers. New classes like MaterialProperty and MaterialUniformBufferLayout define and cache the layout of material data, while StandardMaterialMapTransforms handles texture transform tracking. This replaces the previous approach, introducing a more structured way to manage material parameters and optimize shader generation by grouping related data.

src/scene/materials · high confidence

New render-action-based composition architecture

The layer composition system has been refactored to use a new \RenderAction\ class, which explicitly defines the rendering sequence for cameras and layers. This change introduces granular control over rendering steps, including clear flags (color, depth, stencil) and post-processing triggers per action, replacing the previous implicit composition logic. Users benefit from more predictable rendering order and the ability to customize how layers and cameras interact during the render pass.

src/scene/composition · high confidence

New vertex shader chunks for WebGL2 and WebGPU backends

Added new vertex shader chunk files (gles3.js, webgpu.js, webgpu-wgsl.js) that define backend-specific preprocessor macros and extensions. The WebGL2 chunk enables ANGLE multi-draw and maps legacy GLSL keywords to modern equivalents, while the WebGPU chunk provides GLSL-to-WGSL compatibility shims for texture sampling (using GL\_EXT\_samplerless\_texture\_functions) and maps vertex/instance IDs to their WebGPU counterparts, ensuring consistent shader behavior across rendering APIs.

src/platform/graphics/shader-chunks/vert · high confidence

Particle system simulation and rendering refactored into dedicated updater modules

The particle system's internal logic has been restructured to improve maintainability and performance. Simulation and state updates are now handled by dedicated \ParticleCPUUpdater\ and \ParticleGPUUpdater\ classes, separating the concerns of CPU-based particle calculation from GPU-based render state management. The \ParticleEmitter\ now orchestrates these updaters, and the \ParticleMaterial\ has been updated to correctly integrate with the new shader generation pipeline, ensuring proper handling of fog, tonemapping, and view textures for particle rendering.

src/scene/particle-system · high confidence

ParticleSystemComponent initialization now accepts flexible data types and migrates legacy properties

The ParticleSystemComponent now automatically converts array inputs for vector properties (emitterExtents, particleNormal, wrapBounds) into Vec3 instances, and plain object inputs for curve properties (alphaGraph, colorGraph, etc.) into Curve or CurveSet instances during initialization. Additionally, legacy property 'noFog' is automatically migrated to 'useFog' (with explicit 'useFog' taking precedence), and 'mesh' asset references are migrated to 'meshAsset'.

src/framework/components/particle-system · high confidence

Redesigned examples browser with mobile-first layout and PWA support

The examples browser has been restyled to support a modern, mobile-first experience. The static assets now include a web app manifest and PWA icons, allowing the browser to be installed and run as a standalone app. The layout has been updated with a new dark theme, and the sidebar is now constrained to the left half of the screen on mobile devices with a fixed, floating panel design. CSS variables define the new color palette and spacing, ensuring consistent styling across desktop and mobile views.

examples/src/static · high confidence

Refactor UI element system into ElementComponent with Image and Text sub-elements

The UI element system has been refactored to consolidate image and text rendering into a single \ElementComponent\. This component now exposes \image\ and \text\ properties to access the underlying \ImageElement\ and \TextElement\ implementations, replacing the previous separate component types. The change introduces a new \constants.js\ file defining element types (\group\, \image\, \text\) and fit modes (\stretch\, \contain\, \cover\), and adds an \ElementDragHelper\ to simplify creating draggable UI elements via mouse, touch, or XR input.

src/framework/components/element · high confidence

Refactor WebGL backend to use BindGroup and DynamicBuffer abstractions

The WebGL graphics backend has been refactored to align with the engine's unified graphics architecture. New \WebglBindGroup\ and \WebglBindGroupFormat\ classes now manage uniform buffer bindings, capturing buffer handles at update time to ensure correct binding during multi-eye rendering. A new \WebglDynamicBuffers\ system replaces the previous dynamic buffer handling by pooling whole buffers per allocation and using orphaning (\bufferData\) to prevent pipeline stalls. Additionally, \WebglDrawCommands\ now supports multi-draw operations by storing counts, offsets, and instance counts in Structure-of-Arrays (SoA) format, and a \WebglGpuProfiler\ implementation provides GPU timing data using the \EXT\_disjoint\_timer\_query\ extension.

src/platform/graphics/webgl · high confidence

Refactored WGSL vertex shader chunks for WebGPU storage buffers and texture sampling

The vertex shader logic in the common chunks has been reorganized into dedicated modules (e.g., \meshInstanceStorage\, \normalCore\, \transformCore\) to support WebGPU-specific optimizations. Mesh instance matrices are now retrieved from a persistent storage buffer via \getStoredModelMatrix\ and \getStoredNormalMatrix\ instead of relying solely on uniform buffers, improving performance for instanced and skinned meshes. Additionally, normal matrix calculation now correctly derives the normal from the model matrix for skinned, batched, and instanced meshes, while using a dedicated uniform for standard cases. The implementation also switches from \textureSample\ to \textureLoad\ for data textures (morph targets, pose maps) to ensure correct integer-coordinate access, and introduces a new \fullscreenQuad\ chunk for full-screen rendering passes.

src/scene/shader-lib/wgsl/chunks/common/vert · high confidence

Refactored asset system with new registry and loading classes

The asset management system in src/framework/asset has been completely rewritten. The legacy asset loader and asset classes have been removed and replaced with a new architecture featuring a comprehensive AssetRegistry, a dedicated AssetListLoader for batch operations, and new classes like AssetFile, AssetReference, and LocalizedAsset to handle asset tracking, referencing, and localization. This change introduces a more explicit and robust way to manage asset lifecycles, loading, and dependencies.

src/framework/asset · high confidence

Refactored lighting and shadowing into modular shader chunks

The lighting and shadowing logic in the fragment shader has been reorganized into distinct, reusable modules (lightDeclaration, lightEvaluation, lightFunctionLight, lightFunctionShadow, shadowCascades, shadowEVSM, shadowPCF1/3/5, and shadowSoft). This change introduces world-space PCSS penumbra for directional shadows, adds support for shadow cascade blending with dithering to reduce hard edges, and implements early-out optimizations to skip shadow sampling beyond the far distance. It also adds support for area light shapes (RECT, DISK, SPHERE) and cookie attenuation for spot and omni lights, while maintaining existing PCF and VSM shadow techniques.

src/scene/shader-lib/wgsl/chunks/lit/frag/lighting · high confidence

Refactored post-effects to use modern rendering patterns

The post-effects in the \scripts/posteffects\ directory have been rewritten to use \drawQuad\ for rendering and ES6 classes for effect definitions, replacing the legacy script-based approach. This change standardizes how effects like Bloom, Bokeh, and SSAO are implemented, ensuring consistent resource management and better integration with the engine's rendering pipeline.

scripts/posteffects · high confidence

Refactored shader library with new caching and chunk management

The shader library has been restructured to improve performance and maintainability. Shader chunks are now managed via a dedicated \ShaderChunks\ class that supports both GLSL and WGSL, with validation hooks for deprecation warnings. Shader programs are cached using a \DeviceCache\ tied to the graphics device, and the \ProgramLibrary\ now handles a two-level cache for shader definitions and processed shaders. A new \ChunkUtils\ class centralizes texture encoding/decoding logic, and \ShaderUtils\ provides a higher-level API for shader creation with automatic GLSL/WGSL selection and include resolution.

src/scene/shader-lib · high confidence

Refactored shadow depth handling and fixed PCSS uniform reference

The shadow rendering logic for lit materials has been updated to correctly reference camera parameters as a uniform in the PCSS shadow pass, ensuring accurate depth linearization for spot and omni lights. Additionally, the implementation now discards fragments with out-of-range depth values (outside 0-1 or NaN) for VSM shadow casters to prevent visual artifacts caused by degenerate triangles, and explicitly writes modified depth to gl\_FragDepth when required. Also in this area: New AgX tonemapping options and VSM shadow exponent consistency.

src/scene/shader-lib/wgsl/chunks/lit/frag/pass-shadow · high confidence

Refactored sound system to support overlapping instances and improved event propagation

The sound component architecture has been restructured to allow multiple sound instances to play simultaneously within the same slot when the \overlap\ option is enabled, preventing new sounds from cutting off previous ones. The \SoundSlot\ now acts as an intermediary that forwards playback events (play, pause, resume, stop, end) from individual \SoundInstance\s up to the \SoundComponent\, allowing listeners on the component to react to specific slot activity. Additionally, the system now correctly removes stopped sound instances from the slot's instance list to reduce memory allocations, and positional sound components update their positions consistently during the update loop.

src/framework/components/sound · high confidence

Refactored vertex shader chunks for normal, transform, and skinning logic

The vertex shader library in \src/scene/shader-lib/glsl/chunks/common/vert\ has been reorganized into modular, reusable chunks. New files introduce specific logic for handling normal matrices (deriving them from the model matrix for skinned, batched, and instanced meshes, as well as the shadow pass), screen-space transformations with pixel-snapping support, and skeletal skinning (including both standard and batched skinning implementations). Additionally, utility chunks for MSDF parameter unpacking, quad rendering, and fullscreen quads have been added to standardize how these common vertex operations are composed.

src/scene/shader-lib/glsl/chunks/common/vert · high confidence

Relocated deprecated API shims to support tree-shaking

The deprecated compatibility shims have been consolidated into a single, side-effect-free module (\src/deprecated/deprecated.js\) that exports plain aliases and helper functions. This structural change allows bundlers to drop the entire file when unused, significantly reducing the final bundle size for applications that do not rely on legacy APIs. The module provides backward-compatible wrappers for procedural geometry creation (e.g., \createSphere\), global shader chunk access, and various constant aliases, ensuring existing code continues to function while guiding users toward modern alternatives via deprecation warnings.

src/deprecated · high confidence

Removal of legacy resource loading infrastructure

The legacy resource loading system, including the callback-based ResourceLoader, ResourceRequest, and specific handlers like ImageResourceHandler, has been removed from the engine. This change eliminates the old EntityRequest and AssetRequest classes, replacing them with a new promise-based resource loader that utilizes an AssetCache for managing loaded assets and supports loading from TOC files. Users will no longer interact with the deprecated callback-style loading APIs in this module.

src/resources · high confidence

Reorganized lighting shader chunks and added world-space PCSS shadow support

The lighting shader logic in this directory has been reorganized into modular chunks (declarations, evaluation, shadowing, and specific shadow algorithms like PCF, VSM, and PCSS). This change introduces world-space PCSS (Percentage Closer Soft Shadows) for directional lights, which calculates penumbra size based on world units to ensure softness is invariant to shadow camera tightness. It also adds logic to fade directional shadows at the far distance to avoid sampling beyond the cascade range, and includes fixes for shadow normal offset scaling and cascade culling. Also in this area: New AgX tonemapping options and VSM shadow exponent consistency; Support for KHR\_materials\_diffuse\_transmission glTF extension.

src/scene/shader-lib/glsl/chunks/lit/frag/lighting · high confidence

Repository configuration and documentation updates

The repository now enforces consistent line endings via a new .gitattributes file and updates .gitignore to exclude modern editor artifacts (Cursor, Codex, Claude) and build outputs. The LICENSE copyright year has been updated to 2026, and the .nvmrc file now specifies Node.js 18 as the required runtime. Documentation has been refreshed with new Japanese, Korean, and Chinese README files, and a context7.json file has been added to index usage documentation and agent rules for AI assistants.

(repo-wide) · high confidence

Resource handlers refactored to use a pluggable parser registry

The resource handlers in the framework have been refactored to use a pluggable parser registry instead of implementing their own loading logic. Each handler now extends a base ResourceHandler class and registers specific parsers (e.g., AnimClipParser, JsonAnimationParser) via addParser(). This allows for more flexible format handling and easier extension of supported asset types.

src/framework/handlers · high confidence

Rigid body physics component and system restructured with new data classes

The rigid body physics implementation has been refactored into a modular structure. The core logic is now split between \RigidBodyComponent\ (handling entity-level properties like mass, friction, and type) and \RigidBodyComponentSystem\ (managing the physics world, simulation stepping, and global settings like gravity and time scale). New dedicated classes have been introduced to represent physics data: \ContactPoint\ and \ContactResult\ for detailed collision information, \RaycastResult\ for raycast intersections, and \SingleContactResult\ for global contact events. Constants for body types (static, dynamic, kinematic) and groups/masks are now exported from a separate \constants.js\ module, and the system supports explicit physics backend selection via \AppOptions.physicsWorld\.

src/framework/components/rigid-body · high confidence

SSAO effect refactored with depth-aware blur and optimized uniform handling

The Screen-Space Ambient Occlusion (SSAO) effect has been restructured to improve visual quality and performance. The implementation now includes a depth-aware bilateral blur pass (applied horizontally and vertically) to smooth the occlusion results, reducing noise and artifacts. Additionally, render pass uniforms are resolved once during initialization rather than every frame, reducing GPU overhead. The effect supports both GLSL and WGSL shader languages and offers controls for intensity, radius, samples, and randomization (useful with TAA).

src/extras/effects/ssao · high confidence

Script component system refactored to ES6 classes with improved lifecycle and cloning

The script component system has been rewritten from legacy JavaScript prototypes to modern ES6 classes, replacing the old \script\_component.js\ and \script\_data.js\ files with new \component.js\ and \system.js\ implementations. This change introduces a more robust lifecycle management where \initialize\ and \postInitialize\ are correctly called when script instances become enabled, and fixes issues with cloning where script attributes and declaration order were previously lost. The system now uses \SortedLoopArray\ for efficient execution order management and ensures that script instances are properly initialized even when entities are disabled or when scripts are loaded asynchronously.

src/framework/components/script · high confidence

Scripting system refactored to ES6 classes with reserved name guards

The script framework has been restructured to support modern ES6 class-based scripts (extending the new \Script\ base class) while maintaining backward compatibility with the legacy \createScript\ API. A new \constants.js\ file defines a strict set of reserved script names (including 'worker', 'system', 'entity', etc.) that cannot be used to prevent collisions with \ScriptComponent\ and \EventHandler\ members. The \ScriptRegistry\ now uses a \Map\ for safer storage and lookup of script classes, and the \createScript\ and \registerScript\ functions enforce these reserved name constraints. Additionally, the \ScriptType\ class is marked as deprecated in favor of the new \Script\ class, and the system now properly handles script name resolution via static \scriptName\ properties or verbatim class names.

src/framework/script · high confidence

Scrollbar component now supports orientation switching

The ScrollbarComponent now allows users to dynamically change the scrollbar's orientation between horizontal and vertical at runtime. Setting the \orientation\ property triggers a rebuild of the internal drag helper and updates the handle position and size to ensure the dragging behavior remains synchronized with the new axis.

src/framework/components/scrollbar · high confidence

Skydome depth output and fisheye projection support

The skybox shader chunks now support writing depth data during the prepass and scene passes, enabling depth-of-field effects to correctly interact with mesh-based skydomes. Additionally, fisheye projection is now supported for non-mesh skyboxes, allowing for wider field-of-view rendering by bypassing standard projection matrices at extreme FOVs. These changes ensure that depth-based post-processing effects work accurately with both traditional cubemap/atlas skyboxes and custom skydome meshes.

src/scene/shader-lib/glsl/chunks/skybox, src/scene/shader-lib/wgsl/chunks/skybox · high confidence

Standard shader chunks reorganized into modular, composable fragments

The standard shader's fragment logic has been restructured from a monolithic implementation into a set of distinct, includeable GLSL chunks (e.g., \diffuse.js\, \normalMap.js\, \parallax.js\, \opacity-dither.js\). This modularization allows the rendering engine to assemble only the specific material features required for a given mesh—such as parallax occlusion mapping, clearcoat layers, or anisotropy—rather than compiling unused code paths. Users benefit from more efficient shader generation and the ability to enable advanced visual effects like height-based parallax and independent opacity dithering without incurring the performance cost of the full standard shader feature set.

src/scene/shader-lib/glsl/chunks/standard · high confidence

Standard shader restructured into modular WGSL chunks

The standard shader's fragment logic has been reorganized from a monolithic structure into a set of modular, includeable WGSL chunks (e.g., \diffuse.js\, \normalMap.js\, \parallax.js\, \opacity.js\). This change introduces a new \litShaderArgs\ system to pass computed surface properties (albedo, normal, opacity, etc.) between the frontend evaluation and the core lighting logic. It also adds support for new material features including parallax occlusion mapping with self-shadowing, anisotropic reflections, iridescence, and configurable opacity dithering modes (Bayer 2/4/8/16 and Blue Noise).

src/scene/shader-lib/wgsl/chunks/standard · high confidence

Support for animating multiple morph instances on a single node

The animation system now correctly handles nodes that have multiple morph instances attached. When animating a morph weight, the binder iterates through all mesh instances associated with the node and applies the weight value to every morph instance, ensuring consistent deformation across all meshes sharing that node. This prevents issues where only the first morph instance was being updated, allowing for more complex character or object animations involving multiple mesh layers.

src/framework/anim/binder · high confidence

TAA effect refactored to use a new resolve stage with improved motion handling and upscaling

The Temporal Anti-Aliasing (TAA) effect has been restructured as a CameraFrame effect that resolves the scene at a dedicated resolve stage, ensuring that downstream effects like depth of field and bloom receive the anti-aliased image. The implementation now supports upscaling, allowing TAA to accumulate jittered frames rendered at a lower resolution into a full-resolution history buffer. To improve visual quality, the resolve shader blends the current frame and history in premultiplied alpha space and uses reversible tone mapping to prevent bright edges from appearing aliased. Additionally, motion-based blending is introduced to reduce ghosting during camera movement, and Catmull-Rom filtering is added for higher-quality history sampling.

src/extras/effects/taa · high confidence

Unified GLSL Gaussian Splat vertex shader architecture with fisheye and 2DGS support

The Gaussian Splat rendering pipeline has been refactored into a modular, unified GLSL shader system. This change introduces a new vertex shader structure that supports both 3D and 2D Gaussian Splatting (2DGS), with 2DGS rendering enabled via the \GSPLAT\_2DGS\ define. A key behavioral addition is native support for fisheye projections, allowing splats to be correctly rendered and projected under fisheye camera models, including proper handling of the projection matrix flip for flipped render targets. The shader now features a customizable API via \gsplatModifyVS\ and user-varying streams, allowing developers to modify splat centers, rotation, scale, and color at runtime. Additionally, the system integrates fog and tonemapping directly into the vertex output preparation, ensuring consistent visual processing across different rendering passes.

src/scene/shader-lib/glsl/chunks/gsplat/vert · high confidence

Unified GSplat format shader architecture with new compressed and container formats

The GSplat rendering system now supports a unified shader architecture that introduces dedicated read functions for multiple data formats, including a new compressed format, a compact work buffer format, and a container format, in addition to existing uncompressed and SOG (Source of Geometry) formats. This change allows users to render Gaussian Splat models stored in various optimized memory layouts (such as 20-byte compact or large 32-byte buffers) with correct dequantization of positions, rotations, scales, and colors, while also adding support for Spherical Harmonics in the compressed and SOG formats for improved lighting accuracy.

src/scene/shader-lib/glsl/chunks/gsplat/vert/formats · high confidence

Unified GSplat fragment shader architecture with user customization hooks

The GSplat rendering pipeline now uses a unified fragment shader structure that standardizes how splats are rendered across different passes (forward, shadow, pick, prepass). This change introduces a \gsplatModifyPS\ hook, allowing users to customize the final fragment color of splats in the forward pass. It also adds support for user-defined varying streams via \gsplatUserVaryingsPS\, enabling custom data to be passed through the shader. The implementation includes new chunks for packing/unpacking data (\gsplatPacking\), processing splat streams (\gsplatProcess\), and handling work buffer geometry (\gsplatWorkBufferGeometry\), ensuring consistent behavior for depth writing, alpha clipping, and picking across all GSplat formats.

src/scene/shader-lib/glsl/chunks/gsplat/frag · high confidence

Unified GSplat shader format architecture with half-precision support

The GSplat rendering pipeline now uses a unified, modular shader architecture in the WGSL vertex format chunks, introducing dedicated modules for compressed, container, SOG (Splatting on GPU), and uncompressed formats. This change centralizes how geometry, color, rotation, and scale data are read from various texture layouts (including 20-byte compact work buffers and 32-byte large buffers) and implements half-precision (f16) support for spherical harmonics evaluation on WebGPU, improving memory efficiency and rendering performance for Gaussian Splatting scenes.

src/scene/shader-lib/wgsl/chunks/gsplat/vert/formats · high confidence

Unified LightComponent replaces type-specific light components

The framework now uses a single, unified LightComponent for all light types (directional, omni/point, and spot), replacing the previous separate DirectionalLightComponent and PointLightComponent classes and their associated data files. This consolidation simplifies the API by managing all light properties—such as color, intensity, shadow settings, and cookie transforms—within one component, while the system handles initialization, cloning, and property overrides (like accepting array inputs for color and cookie vectors) centrally.

src/framework/components/light · high confidence

Updated Ammo.js physics module with dynamic heap and scaled mesh support

The precompiled Ammo.js WebAssembly module has been updated to start with a 16MB heap that grows on demand, replacing the previous fixed 64MB allocation to improve performance on low-end devices. This build also includes the btScaledBvhTriangleMeshShape binding, which allows mesh colliders to correctly follow entity scale changes.

examples/assets/wasm · high confidence

Updated Spine 4.3 runtime plugin

The Spine 4.3 integration script (playcanvas-spine.4.3.js) has been updated to the latest playcanvas-spine release. This change ensures that projects using the Spine 4.3 runtime benefit from the most recent bug fixes and improvements provided by the Spine plugin library.

scripts/spine · high confidence

Volumetric fog now supports VSM shadow maps and AgX tonemapping

The volumetric fog effect now correctly samples shadows from Variance Shadow Maps (VSM) using a Chebyshev test on exponentially warped depth moments, ensuring consistent shadowing with the rest of the scene. This change updates the shader variants and pass logic to handle VSM-specific parameters and exponents. Additionally, the system now exposes AgX and AgX Punchy tonemapping options for color grading. Also in this area: New CameraFrame post-processing effects: Auto Exposure, Bloom, CAS, and Color Enhancement.

src/extras/effects/volumetric-fog/glsl, src/extras/effects/volumetric-fog/wgsl · high confidence

Warn and block Entity transform when Dynamic Rigid Body present

The engine now detects and prevents transformations on entities that have an active dynamic rigid body component. This change protects the physics simulation from becoming inconsistent by blocking manual position or rotation updates that would otherwise conflict with the physics solver's control over the entity's transform.

src/scene · high confidence

Zone component now fires enable/disable/state events and uses onBeforeRemove

The Zone component now explicitly fires 'enable', 'disable', and 'state' events when its enabled status changes, allowing applications to react to zone activation or deactivation. Additionally, the component now fires a 'remove' event when it is removed from an entity, and the system uses the standardized onBeforeRemove lifecycle method for cleanup, replacing previous implicit behavior.

src/framework/components/zone · high confidence

Fixes

3 commits (2 fixes) fixing src/extras/gizmo/handle, src/extras/gizmo/overlay

A fix in src/extras/gizmo/handle, src/extras/gizmo/overlay — 3 commits (2 fixs), 16 files: “fix: Gizmo fixes for far icons, picking, frustum fill, flat box corners, lines and handle redraws (\#9818)”; “fix: Gizmo fixes for editor integration: disabled components, centered icons and flat boxes (\#9817)”; “feat: Add camera, light, shape and icon gizmos with snapping handles (\#9809)” (refs \#9818, \#9817, \#9809).

src/extras/gizmo/handle, src/extras/gizmo/overlay · medium confidence · unverified

Fix VSM shadow artifacts from degenerate triangles

Shadow rendering for Variance Shadow Maps (VSM) now discards fragments with depth values outside the valid \[0, 1\] range. This prevents visual artifacts caused by degenerate triangles in animated meshes, which previously generated out-of-range or NaN depth values that corrupted the VSM blur pass. Also in this area: New AgX tonemapping options and VSM shadow exponent consistency.

src/scene/shader-lib/glsl/chunks/lit/frag/pass-shadow · high confidence

New WGSL particle shader implementation

The particle system fragment shaders have been rewritten in WGSL, introducing a modular chunk-based architecture for rendering and simulation. This update implements data texture reading via \textureLoad\ instead of sampling, adds support for normal maps and soft particles, and refactors particle spawning logic to use lossless RGBA32U textures for improved precision.

src/scene/shader-lib/wgsl/chunks/particle/frag · high confidence

Shader chunk version validation and deprecation warnings

A new validation mechanism has been added to the shader library to ensure user-defined shader chunks remain compatible with the engine. The system now tracks specific version numbers for all built-in chunks and explicitly lists deprecated or removed chunks (such as \gsplatCustomizeVS\). If a user attempts to use a removed chunk or an outdated version, the engine will issue a warning directing them to the shader migration documentation, helping to prevent rendering errors caused by API mismatches.

src/scene/shader-lib/glsl/chunks · high confidence

Test coverage

4 commits adding/updating tests in examples/src/examples/test; Migrate unit tests to Node.js with Mocha and Chai; Removal of legacy QUnit test infrastructure.

Dependencies

Update NPM dependencies and add examples iframe package

The engine and examples-browser packages have updated their NPM dependencies to their latest versions, including React 19.3.0, Vite 8.3.0, ESLint 9.39.5, and TypeScript 5.9.3. Additionally, a new \examples/iframe\ package has been introduced to support the examples browser's context module.

(dependencies) · high confidence

Housekeeping

Added attribution files for example textures; New build and documentation utility scripts.

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 55 → 53 (-2.2)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 58 → 56 (-2.0)
  • Architecture 87 → 99 (+12.1)
  • Maturity 66 → 68 (+2.4)
  • Readiness 59 → 61 (+1.8)
  • Security 49 → 44 (-4.9)
  • Performance 60 → 60 (+0.0)

Resolved (158)

  • AnimController._findTransition (cyclomatic 19) (src/framework/anim/controller/anim-controller.js)
  • AnnotationManager.initialize (cognitive 19) (scripts/esm/annotations.mjs)
  • AnnotationManager.initialize (cyclomatic 17) (scripts/esm/annotations.mjs)
  • CameraFrame.postUpdate (cyclomatic 16) (scripts/esm/camera-frame.mjs)
  • Change coupling: gsplat-params.js ↔ gsplat-placement.js (src/scene/gsplat-unified/gsplat-params.js)
  • Change coupling: gsplat-params.js ↔ gsplat-quad-renderer.js (src/scene/gsplat-unified/gsplat-params.js)
  • Change coupling: gsplat.js ↔ gsplatCommon.js (src/scene/shader-lib/glsl/chunks/gsplat/vert/gsplat.js)
  • Change-coupling hub: gsplatCommon.js → gsplat.js, gsplatCommon.js, gsplat.js (src/scene/shader-lib/wgsl/chunks/gsplat/vert/gsplatCommon.js)
  • ClassTooLong: AnnotationManager (scripts/esm/annotations.mjs)
  • ClassTooLong: XrMenu (scripts/esm/xr/xr-menu.mjs)
  • FileTooLong: esm/water.mjs (scripts/esm/water.mjs)
  • FileTooLong: xr/xr-menu.mjs (scripts/esm/xr/xr-menu.mjs)
  • FunctionTooLong: vat-converter.sampleAnimations (scripts/esm/vat/vat-converter.mjs)
  • GSplatBudgetBalancer._accumulate (cognitive 37) (src/scene/gsplat-unified/gsplat-budget-balancer.js)
  • GSplatBudgetBalancer._accumulate (cyclomatic 17) (src/scene/gsplat-unified/gsplat-budget-balancer.js)
  • GSplatBudgetBalancer.balance (cognitive 73) (src/scene/gsplat-unified/gsplat-budget-balancer.js)
  • GSplatBudgetBalancer.balance (cyclomatic 35) (src/scene/gsplat-unified/gsplat-budget-balancer.js)
  • GSplatFlipbook.getNextFrameNumberFromLast (cognitive 21) (scripts/esm/gsplat/gsplat-flipbook.mjs)
  • GSplatImage._rebuildFromImage (cognitive 18) (scripts/esm/gsplat/gsplat-image.mjs)
  • GSplatLines.postUpdate (cognitive 18) (scripts/esm/gsplat/gsplat-lines.mjs)
  • …and 138 more

New (280)

  • AnimEvaluator.update (cyclomatic 23) (src/framework/anim/evaluator/anim-evaluator.js)
  • AnimTargetValue.updateValue (cognitive 16) (src/framework/anim/evaluator/anim-target-value.js)
  • Boundary-crossing change coupling: sog.js ↔ sog.js (src/framework/parsers/sog.js)
  • Boundary-crossing change coupling: webgpu-graphics-device.js ↔ quad-render-utils.js (src/platform/graphics/webgpu/webgpu-graphics-device.js)
  • Change coupling: anim-evaluator.js ↔ component-layer.js (src/framework/anim/evaluator/anim-evaluator.js)
  • Change coupling: gsplat-sog-data.js ↔ sog.js (src/scene/gsplat/gsplat-sog-data.js)
  • Change-coupling hub: gsplat-params.js → gsplat-octree.js, gsplat-placement.js, gsplat-quad-renderer.js (src/scene/gsplat-unified/gsplat-params.js)
  • ClassTooLong: GSplatOctreeInstance (src/scene/gsplat-unified/gsplat-octree-instance.js)
  • ClassTooLong: ShadowRenderer (src/scene/renderer/shadow-renderer.js)
  • CubemapHandler.update (cognitive 54) (src/framework/handlers/cubemap.js)
  • CubemapHandler.update (cyclomatic 31) (src/framework/handlers/cubemap.js)
  • FileTooLong: gsplat-unified/gsplat-octree-instance.js (src/scene/gsplat-unified/gsplat-octree-instance.js)
  • GSplatOctreeInstance._applyTreeCut (cognitive 85) (src/scene/gsplat-unified/gsplat-octree-instance.js)
  • GSplatOctreeInstance._applyTreeCut (cyclomatic 39) (src/scene/gsplat-unified/gsplat-octree-instance.js)
  • GSplatSogIterator.constructor (cyclomatic 30) (src/scene/gsplat/gsplat-sog-data.js)
  • High CVE: [GHSA redacted] (examples/package-lock.json)
  • High CVE: [GHSA redacted] (examples/package-lock.json)
  • High CVE: [GHSA redacted] (examples/package-lock.json)
  • High CVE: [GHSA redacted] (examples/package-lock.json)
  • High CVE: [GHSA redacted] (package-lock.json)
  • …and 260 more

Changes since last survey

  • 140 commits — 116 feature/other, 24 fixes

By area

  • examples/src — 47 commits
  • src/scene — 26 commits
  • (root) — 22 commits
  • src/framework — 16 commits
  • src/platform — 6 commits
  • .github/workflows — 5 commits
  • examples/assets — 5 commits
  • src/core — 4 commits
  • src/extras — 3 commits
  • (repo) — 1 commit
  • examples/iframe — 1 commit
  • examples/package-lock.json — 1 commit
  • scripts/esm — 1 commit
  • test/scene — 1 commit
  • utils/api-surface.mjs — 1 commit

Notable commits

  • fix: fix: Apply the clear coat strength with area lights (#9975)
  • fix: fix: Clear all color attachments of a multiple render target in WebGPU viewport clears (#9998)
  • fix: fix: Convert colors with the exact sRGB transfer function (#9892)
  • fix: fix: Declare the shader chunk API version of the car showcase sweeps (#9954)
  • fix: fix: Default a missing glTF sheen color factor to black (#9852)
  • fix: fix: Default a new sprite component's type to SPRITETYPE_SIMPLE when none is given (#9890)
  • fix: fix: Dispose the 3D Tiles renderers when the tiles examples are destroyed (#9985)
  • fix: fix: Enable the scene color map on both BlurredPlanarReflection cameras (#9951)
  • fix: fix: Hot reload edited ESM scripts (#9989)
  • fix: fix: Ignore exit times on anim transitions out of START and END (#9935)
  • fix: fix: Keep the particle blast buttons from sticking after a release outside the window (#9909)
  • fix: fix: Only cancel cancelable touchmove events and set touch-action on the touch element (#10012)
  • fix: fix: Read SOG v3 rotations from quats.webp (#10007)
  • fix: fix: Report rays starting inside a box when a hit point is requested (#9915)
  • fix: fix: Restore gsplat shadows after graphics context loss (#10021)
  • fix: fix: Return only the file's bytes for binary assets loaded from a bundle (#10020)
  • fix: fix: Return the exit point for rays starting inside a BoundingSphere (#9930)
  • fix: fix: Show the start of the example's category when opening the examples browser (#9922)
  • fix: fix: Skip a screen's touch in XrControllers, which has no model to draw (#9881)
  • fix: fix: Sort union members in the API report (#9933)
  • …and 120 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

playcanvas/engine was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 15 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 9b2191916ff8607166e6e92fe0a952eb3aa31412 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-3c33c1882dc1.