Orillusion/orillusion

Features

• Scene Renderers - Implements a high-performance graphics pipeline for rendering complex 3D environments in the browser.
• WebGPU Renderers - Provides a high-performance 3D rendering pipeline built specifically on the WebGPU standard for browser graphics.
• Entity Component Systems - Employs a data-oriented entity component system to decouple scene logic and optimize performance.
• Vertex Position Interpolation - Creates fluid deformations by interpolating vertex positions between base states and pre-defined target shapes.
• 3D Mesh Rendering - Renders 3D meshes by assigning specific material and geometry components to scene entities.
• Clustered Forward Rendering - Utilizes clustered forward rendering to optimize the performance of scenes with many active light sources.
• GPU Compute Frameworks - Provides a GPU compute framework for parallel mathematical operations and physics simulations via WebGPU compute shaders.
• 3D Lighting Models - Implements a comprehensive system for directional, point, and spot light sources to illuminate 3D scenes.
• Light Source Functions - Provides API-level functions to dynamically add and control point, spot, and direct lights.
• Materials & Shading - Provides a system for defining surface-light interactions using lit, unlit, and glass shading models.
• Vertex and Fragment Shading - Defines the processing of mesh geometry and pixel coloring through integrated vertex and fragment shader stages.
• Shading and Lighting Logic - Utilizes standardized variables and shared functions to implement complex shading and lighting calculations.
• Physically Based Rendering - Uses a physically based rendering pipeline to simulate realistic light interactions and surface materials.
• PBR Pipelines - Implements a physically-based rendering graphics pipeline with HDR lighting to create realistic materials and surfaces.
• Compute Shader Dispatchers - Executes custom GPU code by dispatching workgroups to process data buffers in parallel.
• Compute Shader Pipelines - Utilizes WebGPU compute pipelines to run parallel mathematical operations and physics simulations on the GPU.
• Macro-Based Variant Generation - Uses a macro-based shader generation system to create multiple shader variants by conditionally including code blocks.
• Texture Management Systems - Implements systems for mapping textures, HDR cubes, and atmospheric settings onto 3D surfaces and backgrounds.
• Skeletal Animation - Implements 3D mesh deformation using hierarchical bone structures and vertex weights for character movement.
• Rig Playback Control - Controls the playback and transformation of skeletal rigs to drive character and object animations.
• GPU-Accelerated Physics Simulations - Uses custom GPU kernels and compute shaders to simulate large-scale physics for particles, fluids, and soft bodies.
• Surface Material Definitions - Defines surface appearances by linking shaders and textures to specific rendering priorities.
• Scalable Global Illumination Solutions - Simulates indirect lighting and multi-bounce irradiance using probe-based algorithms and compute shaders.
• Web-Based 3D Animation Systems - Provides a comprehensive toolkit for skeletal rigging, vertex interpolation, and property transitions in the browser.
• GPU Computations - Runs complex mathematical operations and GPGPU tasks outside the standard graphics rendering pipeline.
• ECS Scene Architectures - Organizes 3D scene logic using an entity component system to decouple functionality and manage complex behaviors.
• Entity Composition Systems - Builds complex 3D objects by composing them from modular, reusable logic and data modules.
• GPU Buffer Allocators - Manages the allocation and association of uniform and storage buffers for GPU compute operations.
• Collision Detection - Attaches collider components to entities to identify when 3D objects touch or intersect.
• Fixture Shape Definitions - Defines geometric boundaries using boxes, spheres, and meshes to detect physical intersections.
• 3D Geometry Generators - Provides tools for creating primitive 3D shapes and custom meshes to build scene objects.
• Camera Perspective Configurations - Manages viewports and observers with support for various perspective and projection configurations.
• Custom Shader Programming - Allows the definition of unique surface appearances by implementing custom vertex and fragment shader logic.
• GPU Memory Mapping - Optimizes data exchange between CPU and GPU using memory mapping for contiguous data blocks.
• Screen Space Ambient Occlusion - Calculates light obscuration using screen-space techniques to improve depth perception and shadow realism.
• Custom Shader Programs - Registers unique shader code and entry functions to implement custom rendering behaviors.
• Post-Processing Pipelines - Provides a sequential pipeline for applying full-screen filters and enhancements like bloom and depth of field.
• Post-Processing Effects - Allows application of custom fragment shaders to the frame buffer for advanced post-render visual effects.
• Volumetric Scattering - Simulates volumetric light beams and scattering effects to create realistic god rays.
• Bloom Effects - Implements bloom effects by diffusing high-intensity pixels to simulate light bleeding.
• Depth of Field - Simulates camera lens focus by blurring objects based on their distance from the observer.
• Shader Script Management - Provides a system to store and organize reusable shader code segments using keys across various materials.
• Shader Permutation Generators - Generates specialized shader variants at build time using macro definitions to conditionally include code blocks.
• Light Probes - Simulates indirect lighting and irradiance within volumes using a system of light probes and compute shaders.
• Skeletal Animation Systems - Includes a toolkit for driving skeletal animations to create fluid 3D character movements.
• Component Lifecycle Hooks - Provides lifecycle hooks for initializing, updating, and destroying data components within the engine.
• GPU Buffer Mappings - Reduces CPU-GPU data exchange overhead by using direct memory mapping for contiguous graphics buffers.

Star history