playcanvas/engine

This system is a 3D graphics and physics engine framework designed for building interactive web-based applications. It provides core subsystems for rendering, scene management, and physics simulation, supporting both WebGL and WebGPU backends. The engine features a component-based architecture that handles input, audio, scripting, and resource loading, while offering advanced capabilities like clustered lighting, Gaussian Splatting, and WebXR support.

76 changes.

This period focused on a comprehensive rewrite of the engine's core architecture, migrating legacy JavaScript patterns to modern ES6 classes and promise-based resource loading. It involved removing obsolete subsystems like the designer integration and legacy input APIs while introducing new modular components for UI, physics, and rendering. The work also established a new render pass architecture and unified lighting infrastructure to support modern graphics standards.

92 changes.

This period focused on implementing a comprehensive WebGPU backend alongside the existing WebGL support, introducing WGSL shader compatibility and modern graphics infrastructure. The engine underwent significant architectural refactoring, including a new animation evaluation system, a pluggable parser registry for asset loading, and a modular extras module for utilities and gizmos. Extensive unit test coverage was added across core systems, and the examples browser was rebuilt with React and Vite to demonstrate these modern capabilities.

99 changes.

This period focused on refactoring the rendering engine's shader library into a modular, chunk-based architecture for both GLSL and WGSL, enabling composable post-processing and efficient feature inclusion. It also unified the Gaussian Splatting pipeline with GPU-driven sorting, streaming LOD, and support for multiple data formats. Additionally, the work introduced a modern input system, pluggable physics backends, and expanded glTF and asset parser support.

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

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

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

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

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

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

A new interactive demo has been added to the examples library, featuring a catapult siege simulation. The example includes a control panel (catapult.controls.jsx) that allows users to adjust rendering settings such as reload time, shadows, volumetric fog, fog samples, and boulder lights. The main demo file (catapult.example.mjs) implements the game logic, including terrain generation, character animation using Vertex Animation Textures (VAT), and physics-based projectile launching.

examples/src/examples/demos · high confidence

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

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

A new example demonstrating positional audio has been added to the examples suite. This entry point configures a PlayCanvas application with a sound manager, audio listener, and a walking entity that plays looping footsteps while moving in a circle, illustrating how to manage sound slots and spatial audio properties.

examples/src/examples/sound · high confidence

Users can now load .obj model files and .spz Gaussian Splat files by registering the new ObjModelParser and SpzParser with the engine's asset loader. The OBJ parser handles vertices, normals, UVs, and groups (triangles and quads), though it has known limitations such as a 65,535 vertex mesh cap and lack of indexed geometry. The SPZ parser supports version 4 of the Niantic SPZ format, requiring the application to register a ZSTD WASM module for decompression before loading assets.

scripts/esm/parsers · high confidence

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

The examples/assets/spine directory now includes the necessary asset files for the Spine skeletal animation engine example, specifically the license.txt, the texture atlas (spineboy-pro.atlas), and the skeleton data (spineboy-pro.json).

examples/assets/spine · high confidence

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

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

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

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

A new example file has been added to demonstrate how to use the Picker to select GSplat objects in legacy (non-unified) mode. The example configures a scene with multiple rotating and fading GSplat entities, sets up a camera with orbit controls, and visualizes the picker's color and depth buffers in the corner of the viewport to aid in debugging and interaction.

examples/src/examples/gaussian-splatting-legacy · high confidence

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

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

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

The render-pass fragment shaders have been restructured into a modular, chunk-based system that composites a wide range of post-processing effects. This change introduces dedicated shader chunks for Bloom, Depth of Field (CoC and blur), Screen-Space Ambient Occlusion (SSAO), Color Grading, Color LUTs (with dual-LUT crossfading), Color Enhancement (shadows, highlights, vibrance, dehaze), Vignette, Chromatic Fringing, and Contrast Adaptive Sharpening (CAS). It also adds support for Volumetric Fog (including local omni/spot light shadows and cookies) and a robust TAA resolve that correctly handles premultiplied alpha to prevent ghosting. A new Scene Depth Reader allows reading depth data back to the CPU, and the pipeline now supports debug modes for visualizing individual effect passes.

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

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.

examples/src/app · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

A new \src/extras/index.js\ entry point has been added to organize and export a collection of supplementary APIs that extend the PlayCanvas Engine. This module consolidates previously scattered or internal components into a single, accessible location, providing users with ready-to-use tools for gizmos (Transform, ViewCube), input handling (controllers for fly, orbit, focus, and various input sources like keyboard/mouse and gamepad), advanced renderers (Outline, Texture, WideLine, Wire), and post-processing effects (SSAO, Depth of Field, Bloom, TAA). It also includes exporters for USDZ and GLTF formats, as well as debugging utilities like MiniStats, effectively grouping these advanced capabilities under a unified 'Extras' namespace.

src/extras · high confidence

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

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

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

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

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

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

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

Added four new interactive examples to the Gaussian Splatting section: an annotations demo with interactive 3D hotspots on a bicycle model, a 'billions' demo that instances a streamed scene into a massive cylinder world, a clipping demo that demonstrates AABB-based splat cropping with animated bounds, and a crop demo showing precise edge clipping with adjustable parameters. Each example includes dedicated control panels for adjusting renderer selection, visual properties, and performance budgets.

examples/src/examples/gaussian-splatting · high confidence

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

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

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

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

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

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

Added a suite of new WebGPU compute examples in the examples/src/examples/compute directory, including edge detection, histogram generation, indirect dispatch, indirect draw, particle simulation, texture generation, and vertex update. These examples demonstrate advanced GPU compute capabilities such as indirect dispatch and draw calls, particle physics simulation, and real-time texture manipulation using WGSL shaders.

examples/src/examples/compute · high confidence

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

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

Three new interactive examples have been added to the graphics-advanced section. The 'Custom MSAA Resolve' example demonstrates how to manually resolve multisampled color buffers using custom shaders to handle high-contrast HDR edges better than hardware resolves. The 'MSAA Depth Fog' example illustrates the conflict between multisampled depth and depth-based effects like fog, showing how per-sample fog evaluation avoids artifacts found in resolved depth approaches. The 'Rendering Without Entities' example shows how to render instanced geometry directly through layers using MeshInstances and GraphNodes, bypassing the Entity-Component system for performance or architectural reasons.

examples/src/examples/graphics-advanced · high confidence

The examples/src/examples/user-interface directory has been completely rebuilt with new, standalone demonstration files for anchors, buttons, common widgets (sliders, toggles, radio groups), custom shaders (using ShaderMaterial for cooldown effects), drag-and-drop, image fitting, input events, and layout groups. These examples showcase the modern PlayCanvas UI API, including screen-space rendering, sliced sprites, and element input handling, replacing the previous structure.

examples/src/examples/user-interface · high confidence

The misc examples area now includes several new demonstrations: an animated 2D sprite example using SpriteComponent with keyboard controls; an HTML-in-Canvas example that renders live HTML as a GPU texture (with a fallback for unsupported browsers) and a product-configurator variant with interactive hit testing; an annotations example featuring an AnnotationManager with a React control panel for hotspot size, colors, and opacity; and an editor example showcasing a GizmoHandler that manages Translate/Rotate/Scale gizmos, a Selector for picking entities, and a ViewCube, all controlled via React UI panels. Existing examples like hello-world and esm-script are also present, providing baseline usage of the engine's core systems.

examples/src/examples/misc · high confidence

The examples in the loaders directory have been reworked to demonstrate modern PlayCanvas patterns. New examples show how to load assets from bundles (bundle.example.mjs), use Draco-compressed GLB files (draco-glb.example.mjs), and export scenes to GLTF (gltf-export.example.mjs) and USDZ (usdz-export.example.mjs) formats. Existing examples like glb.example.mjs and obj.example.mjs have been updated to use the new AppBase and AssetListLoader APIs, while loaders-gl.example.mjs now demonstrates loading point clouds via the external @loaders.gl library.

examples/src/examples/loaders · high confidence

The examples/src/examples/materials directory has been reorganized with new standalone example files for anisotropy (disc, lamp, rotation, strength), clear coat, dispersion, lit material, physical, refraction, translucent specular, and transparency. These examples demonstrate specific material properties and workflows, including anisotropic highlights, clear coat layers, dispersion effects, refraction with dynamic toggles, and various transparency and dithering modes. The refraction example now includes a React-based control panel for toggling dynamic refraction and metalness. Several examples have been updated to use correct IOR values, proper depth layer ordering for grab passes, and sRGB color textures.

examples/src/examples/materials · high confidence

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

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

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

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

This change introduces a suite of new GLSL fragment shader chunks in the common library, providing foundational support for several rendering capabilities. These include MSDF text rendering with improved anti-aliasing and outline handling, flat shading via geometric normals, and fog effects (linear, exponential, and exponential squared). It also adds utilities for color space management (gamma/linear encoding and decoding), depth handling (linearization, screen depth retrieval, and float-to-uint packing for platforms without float textures), and scene integration (writing scene textures for post-processing and shadow casting support for custom shaders). Additionally, it provides environment map processing helpers and Bayer dithering matrices.

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

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

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

The debug examples directory now includes several new interactive demonstrations: an entity inspector example that integrates the PlayCanvas Inspector for live entity hierarchy browsing and property inspection; a frustum culling example visualizing view volumes and bounding boxes with a WireRenderer; a wire-shapes example showcasing various wireframe drawing capabilities; a texture-renderer example for single-frame color and depth texture previews; and a mini-stats example featuring a redesigned, collapsible UI for application performance statistics and user counters.

examples/src/examples/debug · high confidence

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

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.

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

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

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

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

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

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

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.

src/extras/gizmo · high confidence

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

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

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

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

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

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

Added five new interactive shader examples to the examples/shaders directory. The cloud shadows example demonstrates scrolling shadow modulation via StandardMaterial chunk overrides with GLSL and WGSL variants. The grab-pass example shows how to capture the scene color map and apply a refraction effect using a custom ShaderMaterial. The ground fog example renders a depth-aware fog plane using a ShaderMaterial and TextureRenderer. The integer textures example implements a sand simulation using unsigned-integer textures and fragmentOutputTypes for compute-like logic. The paint mesh example demonstrates applying a custom shader to a mesh with texture inputs.

examples/src/examples/shaders · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The legacy script loading mechanism has been removed. Specifically, the \src/script/script\_loader.js\ file, which handled asynchronous script loading via dynamic tag injection and queue management, and the \src/script/script\_script.js\ file, which managed script registration and execution context, have been deleted. This eliminates the old \pc.fw.ScriptLoader\ and the manual \pc.script.create\/\pc.script.main\ registration pattern, requiring users to adopt the new script resource loader and namespace structure.

src/script · high confidence

The \src/script/resources/resources\_script.js\ file, which contained the \ScriptResourceHandler\ and \ScriptRequest\ classes for dynamically loading JavaScript files via script tags, has been deleted. This removes the legacy implementation that managed script loading queues, timeouts, and the \pc.script.create()\ callback mechanism, indicating that script resource loading is now handled by a different system or module within the engine.

src/script/resources · high confidence

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

The SimpleBody component and its associated data structure have been removed from the framework. This component previously provided a simple physics simulation system for entities, handling linear and angular integration based on mass, inertia, force, and torque properties. Users relying on this component for basic rigid-body dynamics will no longer have access to these features.

src/framework/components/cubemap, src/framework/components/planereflection, src/framework/components/simplebody · high confidence

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

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

The StaticCubeMap component and its associated data structures have been removed from the engine. This deletion eliminates the ability to create static cubemaps from assigned image URLs via the component system and removes the corresponding editor links for configuring the six cubemap faces (posx, negx, posy, negy, posz, negz).

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

The shader library now exports centralized collections (compose-chunks, gsplat-chunks, particle-chunks, and shader-chunks) that aggregate all WGSL shader fragments into single, importable objects. This unifies the shader architecture, making it easier to manage and customize rendering pipelines by providing a consistent interface for accessing and overriding specific shader parts like post-processing effects, Gaussian splatting, and particle systems.

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

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

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

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

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

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

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

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

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

A change to existing behaviour in examples/assets/cubemaps — 10 commits, 6 files.

examples/assets/cubemaps, src/scene · medium confidence · unverified

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

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

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

The animation examples in this directory have been refactored to use React-based control panels (\.controls.jsx\) for interactive parameter adjustment, replacing previous inline or non-React UI approaches. The core example files (\.example.mjs\) now demonstrate updated animation capabilities, including 1D and 2D (Cartesian and Directional) blend trees, animation layer masks with additive/overwrite blending, animation events tied to bone positions, and component property animation. Several examples also integrate modern rendering features like custom render passes with bloom and specific tone mapping settings.

examples/src/examples/animation · high confidence

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

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

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

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

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

The camera examples (first-person, fly, multi, and orbit) have been updated to import their control logic from ESM modules (e.g., \playcanvas/scripts/esm/first-person-controller.mjs\ and \playcanvas/scripts/esm/camera-controls.mjs\) instead of previous formats. Additionally, each example now includes a dedicated React-based control panel component (e.g., \fly.controls.jsx\) that exposes adjustable attributes like speed, damping, and ranges via the PlayCanvas UI library, allowing users to tweak camera behavior in real-time.

examples/src/examples/camera, examples/src/examples/gizmos · high confidence

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

The GSplat rendering system now supports a compact work buffer format that reduces memory usage to 20 bytes per splat by quantizing color, rotation, scale, and alpha data, alongside the existing 32-byte packed format. This change introduces new shader write functions for both GLSL and WGSL that implement the compact packing logic, enabling more efficient memory utilization for large-scale splat rendering.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The graphics examples have been restructured to use React-based control panels (e.g., \ambient-occlusion.controls.jsx\) for interactive parameter adjustment and now utilize the \CameraFrame\ component for rendering, replacing the previous direct camera setup patterns. This change provides a more consistent and user-friendly way to tweak settings like SSAO type, blur, and resolution scale, as well as HDR display formats, directly within the example interfaces.

examples/src/examples/graphics · high confidence

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

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\).

examples/utils · high confidence

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

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

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

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

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

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

The physics examples (compound-collision, falling-shapes, joints, mesh-collider-scaling, offset-collision, ragdoll, raycast, and vehicle) have been rewritten to use the new module-based runtime structure. This change replaces the previous global script loading approach with explicit ES module imports from 'playcanvas' and 'examples/context', and initializes the application using the new AppBase and AppOptions API. Users will see these examples now configure the Ammo Wasm module directly, manage component systems and resource handlers via options, and handle asset loading asynchronously, reflecting the broader engine architecture shift.

examples/src/examples/physics · high confidence

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

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

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

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

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

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

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

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

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.

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

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

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

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

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

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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The Spine animation engine integration in scripts/spine has been updated to version 3.8. This upgrade brings the latest features and bug fixes from the Spine runtime, ensuring compatibility with newer Spine animation exports and improving overall animation performance and stability within PlayCanvas projects.

scripts/spine · high confidence

The WebXR example files (such as ar-basic, vr-basic, and ar-depth-sensing) have been rewritten to use the new AppBase initialization pattern and a WebGPU-capable graphics device setup. This change ensures the examples correctly initialize the XR manager, handle device-specific rendering contexts, and support modern WebXR features like camera color, depth sensing, and anchor persistence across both WebGL and WebGPU backends.

examples/src/examples/xr · high confidence

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

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.

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

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

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

Added comprehensive test coverage for Ammo physics engine integration; Added consumer-side type tests for core engine APIs; Added hidden test examples for alpha-to-coverage, clustered lighting, contact-hardening shadows, detail maps, dual-source blending, and UI elements; Added post-build tests for ESM/UMD bundles; Added script assets for testing script lifecycle and entity manipulation; Added test asset files for unit testing; Added test assets for cube model, material, and animation; Added tests for AppOptions.physicsWorld and NullPhysicsWorld; Added tests for CanvasFont texture generation; Added tests for ComputeRadixSort buffer allocation behavior; Added tests for ElementInput event handling and XR session lifecycle; Added tests for Picker readback, world point reconstruction, and cancellation; Added tests for RenderComponent cleanup and shadow cascade mask behavior; Added tests for RigidBodyComponent and RigidBodyComponentSystem; Added tests for animation component cloning and morph target binding; Added tests for geometry utilities and procedural shapes; Added tests for glTF occlusion strength and USDZ skinned mesh export; Added tests for renderer debug draw limits, shadow culling, and light list management; Added tests for script creation and registry behavior; Added tests for sound duration and playback timing logic; Added unit tests for CameraComponent initialization, cloning, and shader pass management; Added unit tests for CollisionComponent initialization and property handling; Added unit tests for Element component behavior and rendering; Added unit tests for GLB, PLY, and Gaussian Splatting parsers; Added unit tests for GSplat component, asset loader, and system; Added unit tests for HTTP client behavior; Added unit tests for ImmediateBatch and LineWriter; Added unit tests for JointComponent initialization and property handling; Added unit tests for LayerComposition; Added unit tests for LayoutGroup component and LayoutCalculator; Added unit tests for MiniStats resource tracking and UI behavior; Added unit tests for ParticleSystemComponent initialization and configuration; Added unit tests for ScriptComponent lifecycle and initialization; Added unit tests for ScrollViewComponent initialization and property handling; Added unit tests for WebGPU graphics platform; Added unit tests for WorldClustersDebug; Added unit tests for asset handlers and parser registry; Added unit tests for component lifecycle, teardown, and registry behavior; Added unit tests for core math utilities; Added unit tests for core shape classes; Added unit tests for core utility modules; Added unit tests for debug renderer components; Added unit tests for framework core components and behaviors; Added unit tests for graphics platform core systems; Added unit tests for material property handling and uniform buffer layout; Added unit tests for particle emitter bounds and material shader generation; Added unit tests for render pass extras; Added unit tests for shader library lighting and material behaviors; Added unit tests for the AnimationComponent; Added unit tests for the BatchManager; Added unit tests for the ButtonComponent API; Added unit tests for the LightComponent; Added unit tests for the ModelComponent; Added unit tests for the ScrollbarComponent; Added unit tests for the XR framework components; Added unit tests for the animation evaluator subsystem; Added unit tests for the asset loading and localization framework; Added unit tests for the unified GSplat scene subsystem; Expanded unit test coverage for scene subsystems; Migrate SpriteComponent tests to Node.js; Migrated BundleRegistry tests from Karma to Node; Removal of legacy QUnit test infrastructure; Unit tests now run on WebGPU via Google Dawn.

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

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

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

• CAI 55 → 61 (+5.6)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 68 → 68 (-0.2)
• Architecture 97 → 88 (-9.3)
• Maturity 66 → 66 (-0.0)
• Readiness 62 → 64 (+1.4)
• Security 42 → 58 (+15.4)
• Performance 60 (new)

• AmmoPhysicsWorld.raycastAll (cognitive 16) (src/framework/physics/ammo/ammo-physics-world.js)
• AppBase.init (cyclomatic 16) (src/framework/app-base.js)
• BindGroup.update (cognitive 21) (src/platform/graphics/bind-group.js)
• Boundary-crossing change coupling: lightmapper.js ↔ shadow-renderer-local.js (src/framework/lightmapper/lightmapper.js)
• Change coupling: container.js ↔ glb-parser.js (src/framework/handlers/container.js)
• Change coupling: gsplat-info.js ↔ gsplatCopyToWorkbuffer.js (src/scene/gsplat-unified/gsplat-info.js)
• Change coupling: gsplat-work-buffer-render-pass.js ↔ gsplatCopyToWorkbuffer.js (src/scene/gsplat-unified/gsplat-work-buffer-render-pass.js)
• Change coupling: gsplat-work-buffer-render-pass.js ↔ gsplatCopyToWorkbuffer.js (src/scene/gsplat-unified/gsplat-work-buffer-render-pass.js)
• Change coupling: standard-material.js ↔ reflectionCube.js (src/scene/materials/standard-material.js)
• Change-coupling hub: forward-renderer.js → light-texture-atlas.js, gpu-updater.js, shadow-renderer-directional.js, shadow-renderer-local.js, shadow-renderer.js, screenDepth.js (src/scene/renderer/forward-renderer.js)
• Change-coupling hub: gsplat-manager.js → compute-radix-sort-multipass.js, gsplat-info.js, gsplat-interval-compaction.js, gsplat-octree-instance.js, gsplat-projector.js, gsplat-unified-sort-worker.js, gsplat-work-buffer.js, gsplatCopyToWorkbuffer.js (src/scene/gsplat-unified/gsplat-manager.js)
• Change-coupling hub: standard-material-options-builder.js → standard-material-options.js, standard-material-parameters.js, reflectionCube.js, lit-shader-options.js (src/scene/materials/standard-material-options-builder.js)
• ClassTooLong: ForwardRenderer (src/scene/renderer/forward-renderer.js)
• CollisionComponent._updateCompound (cognitive 16) (src/framework/components/collision/component.js)
• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• DracoWorker::decodeMesh (cognitive 31) (src/framework/parsers/draco-worker.js)
• DracoWorker::decodeMesh (cyclomatic 20) (src/framework/parsers/draco-worker.js)
• FileTooLong: renderer/forward-renderer.js (src/scene/renderer/forward-renderer.js)
• …and 144 more

• Atlas.upload (cognitive 22) (src/framework/font/canvas-font.js)
• BindGroup._revalidate (cognitive 20) (src/platform/graphics/bind-group.js)
• Boundary-crossing change coupling: deprecated.js ↔ blend-state.js (src/deprecated/deprecated.js)
• Change coupling: blend-state.js ↔ webgpu-graphics-device.js (src/platform/graphics/blend-state.js)
• Change coupling: gsplat-work-buffer-render-pass.js ↔ gsplatCopyToWorkbuffer.js (src/scene/gsplat-unified/gsplat-work-buffer-render-pass.js)
• Change coupling: gsplat-work-buffer-render-pass.js ↔ gsplatCopyToWorkbuffer.js (src/scene/gsplat-unified/gsplat-work-buffer-render-pass.js)
• Change coupling: stdDeclaration.js ↔ stdDeclaration.js (src/scene/shader-lib/glsl/chunks/standard/frag/stdDeclaration.js)
• Change-coupling hub: forward-renderer.js → gpu-updater.js, shadow-renderer-directional.js, shadow-renderer-local.js, shadow-renderer.js, screenDepth.js (src/scene/renderer/forward-renderer.js)
• Change-coupling hub: gsplat-manager.js → compute-radix-sort-multipass.js, gsplat-info.js, gsplat-interval-compaction.js, gsplat-octree-instance.js, gsplat-projector.js, gsplat-unified-sort-worker.js, gsplat-work-buffer.js (src/scene/gsplat-unified/gsplat-manager.js)
• Change-coupling hub: standard-material-options-builder.js → standard-material-options.js, standard-material-parameters.js, lit-shader-options.js (src/scene/materials/standard-material-options-builder.js)
• ClassTooLong: GSplatHybridRenderer (src/scene/gsplat-unified/gsplat-hybrid-renderer.js)
• ClassTooLong: Material (src/scene/materials/material.js)
• Documentation: no contributor guidance (README.md)
• End-of-life runtime: Node.js 18
• FileTooLong: batching/batch-manager.js (src/scene/batching/batch-manager.js)
• GSplatBudgetBalancer._accumulate (cognitive 37) (src/scene/gsplat-unified/gsplat-budget-balancer.js)
• GSplatBudgetBalancer._accumulate (cyclomatic 17) (src/scene/gsplat-unified/gsplat-budget-balancer.js)
• GSplatDirector.update (cognitive 64) (src/scene/gsplat-unified/gsplat-director.js)
• GSplatLodTable.constructor (cognitive 38) (src/scene/gsplat-unified/gsplat-lod-table.js)
• GSplatOctree.flushRequests (cognitive 17) (src/scene/gsplat-unified/gsplat-octree.js)
• …and 107 more

• 218 commits — 136 feature/other, 82 fixes

• src/scene — 60 commits
• src/framework — 49 commits
• src/platform — 27 commits
• (root) — 22 commits
• examples/src — 16 commits
• src/extras — 9 commits
• test/framework — 9 commits
• src/core — 5 commits
• examples/thumbnails — 4 commits
• scripts/esm — 4 commits
• test/scene — 4 commits
• examples/assets — 3 commits
• examples/package-lock.json — 2 commits
• test/platform — 2 commits
• examples/iframe — 1 commit
• test/extras — 1 commit

• fix: Add Ammo regression tests for a body moved and enabled before the first frame (#9444)
• fix: Fix CameraComponent#setShaderPass() throwing when resetting the pass (#9451)
• fix: Fix Debug.assert and Texture levels JSDoc types (#9491)
• fix: Fix JSDoc types that disagree with runtime values, salvaged from #5817 (#9469)
• fix: Fix Picker readback rectangle in the top-left to bottom-left flip (#9441)
• fix: Fix a markup parser crash when a tag name shadows hasOwnProperty (#9468)
• fix: Fix bundle asset load retrying and error-response handling (#9460)
• fix: Fix fisheye gsplats and sky in flipped render targets (#9495)
• fix: Fix the WebGL multi-draw fallback submitting no draws (#9461)
• fix: fix(examples): Apply settings once the initial values are set (#9640)
• fix: fix(examples): Resolve the inspector's engine peer to the linked engine (#9641)
• fix: fix(examples): Restore the depth prepass in the gaussian splat depth-of-field example (#9639)
• fix: fix(examples): Serve iframe/inspector.mjs as is in the dev server (#9638)
• fix: fix: Accept mesh instances without a material in Layer#addMeshInstances (#9579)
• fix: fix: Accept status 0 responses from non-http schemes (#9508)
• fix: fix: Announce apps to the devtools hook from every build (#9646)
• fix: fix: Apply area-picker example material changes via update() (#9497)
• fix: fix: Apply camera clip plane changes to a running XR session (#9624)
• fix: fix: Apply the stencil read mask and share pipelines across stencil references on WebGPU (#9611)
• fix: fix: Blur the TAA output in the camera frame's bloom and depth of field (#9591)
• …and 198 more

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

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.