Echo

An awesome ray traced 3D renderer build in C# from scratch!
Getting started »

Report Bug · Request Feature

Table of Contents

1. About the Project
2. Features
3. Installation
4. Contributing
5. License
6. Gallery

---

About the Project

Echo is a physically based 3D rendering software package; that is, Echo takes in a 3D scene and captures a 2D picture of it. Scenes are given to Echo as a data collection of geometric shapes, texture and material parameters (which describe physical properties of the shapes), light sources that illuminate the scene, and a camera perspective from which the picture is captured. Since Echo is a ray tracer, it captures and synthesizes a 2D picture by shooting billions of rays in the 3D scene to understand its visual features.

Echo was built from the ground up using C# without any external libraries for all its core components. All rendering features are available to be explored through a standard GUI application (see Echo.UserInterface) and/or accessed via an extensive programming library API (see Echo.Core). While Echo was only initially an exploratory project, it has now grown to become fully usable as a photorealistic renderer with many advance features. See the Gallery for renders produced by Echo, or navigate to the Getting Started page to begin using it!

Features

• Unidirectional path tracing with multiple importance sampling and next event estimation.
• Many cool physically based materials (e.g. Diffuse, Dielectric, Conductor, Emissive).
• Quad-width bounding volume hierarchy acceleration with SIMD utilization across the application.
• Light hierarchy tree to provide better per-bounce selections when importance sampling lights.
• Multithreading worker pool system supporting pause/resume and C# async keyword constructs.
• Support for auxiliary false-color data (e.g. normal, depth, albedo) through common ray tracing interface.
• Common texturing system allowing various filter modes, color types, and internal memory layouts.
• Customizable compositing stack with many enhancing post processing operators (e.g. AutoExposure, Bloom, ToneMapper, Vignette, and Intel Open Image Denoise).
• Flexible scene construction using Echo description language with image IO support from ImageMagick.
• Intuitive renderer control using a graphical user interface through Echo.UserInterface for debugging implementation and scenes.

Academic Papers & Articles Implemented:

• Physically Based Rendering: From Theory To Implementation (Link) - [Pharr, Jakob, and Humphreys 2018]
• Optimally Combining Sampling Techniques for Monte Carlo Rendering (Link) - [Veach and Guibas 1995]
• Shallow Bounding Volume Hierarchies for Fast SIMD Ray Tracing of Incoherent Rays (Link) - [Dammertz et al. 2008]
• Importance Sampling of Many Lights with Adaptive Tree Splitting (Link) - [Estevez and Kulla 2018]
• Hierarchical Geometric Models for Visible Surface Algorithms (Link) - [Clark 1976]
• Heuristics for Ray Tracing Using Space Subdivision (Link) - [MacDonald and Booth 1990]
• Fast and Tight Fitting Bounding Spheres (Link) - [Larsson 2008]
• Higher Density Uniform Floats (Link) - [Reynolds 2017]
• Average Irregularity Representation of a Rough Surface for Ray Reflection (Link) - [Trowbridge and Reitz 1975]
• A Simpler and Exact Sampling Routine for the GGX Distribution of Visible Normals (Link) - [Heitz 2017]
• Generalization of Lambert's Reflectance Model (Link) - [Oren and Nayar 1994]
• A Tiny Improvement of Oren-Nayer Reflectance Model (Link) - [Fujii]
• The Reflection Factor of a Polished Glass Surface for Diffused Light (Link) - [Walsh 1926]
• A Quantized-diffusion Model for Rendering Translucent Materials (Link) - [D'Eon and Irving 2011]
• Photographic Tone Reproduction for Digital Images (Link) - [Reinhard et al. 2002]

Installation

To get the project source code, simply clone the repository:

git clone https://github.com/GaryHuan9/Echo.git

You will need at least dotnet 6 to run the project. A good visual introduction to Echo would probably be Echo.UserInterface, and you can launch that by going into the Echo root directory and run the following command. Note that the first argument is a path to a scene to be rendered, and in this case, it will render the Stanford bunny!

dotnet run --project src/Echo.UserInterface ext/Scenes/Simple/bunny.echo

For more extensive information on how to use Echo, please see the Getting Started page!.

Contributing

Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contribution you make will be greatly welcomed and appreciated. If you have a suggestion that would make this project better, please fork the repo and create a pull request. Take a look at the contribution guide for tips and suggestions on contributing to this project. You can also simply open an issue with the tag enhancement. Thanks again for your contribution!

License

Distributed under the MIT License. See LICENSE.txt for more information.

Gallery

All the following images were completely rendered and post-processed in Echo:

Canonical Cornell Box


Rough Glass Material Ball


Lego 856 Bulldozer on a Table, model by Heinzelnisse (CC-BY-NC) and PolyHaven (CC0)


Two Blue Bugatti Chiron, model by zizian on Sketchfab (CC BY-NC 4.0)


Echo.UserInterface During a Render