GV

GeezerVison

The World Wide Web, restored to 800 pixels of glory.

Home|About|Gaming cabinet|Archives|How it works|Starter sites

On this site

  • Sign in
  • ActionsCI/CD and automation
  • CodespacesCloud development environments
  • All Features
  • Documentation
  • Training
  • Certifications
  • Build with Copilot
  • Customize Copilot
  • Integrations
  • Trending repos
  • GitHub Sponsors
  • Developer articles
  • Enterprises

This view

  • Original page
  • New address

GeezerVison is showing github.com — GitHub - steaklive/EveryRay-Rendering-Engine: Robust real-time rendering engine on DX11, DX12 with many advanced graphical features for quick prototyping

BranchesTags
Open more actions menu

Latest commit

 

History

962 Commits
962 Commits

Folders and files

NameName
Last commit message
Last commit date
bin/x64
bin/x64
 
 
content
content
 
 
doc
doc
 
 
external
external
 
 
packages/WinPixEventRuntime.1.0.220810001
packages/WinPixEventRuntime.1.0.220810001
 
 
screenshots
screenshots
 
 
source
source
 
 
.gitignore
.gitignore
 
 
CHANGE_LOG.md
CHANGE_LOG.md
 
 
EveryRay_RenderingEngine_Win64_DX11.sln
EveryRay_RenderingEngine_Win64_DX11.sln
 
 
EveryRay_RenderingEngine_Win64_DX12.sln
EveryRay_RenderingEngine_Win64_DX12.sln
 
 
LICENSE.md
LICENSE.md
 
 
README.md
README.md
 
 
graphics_config.json
graphics_config.json
 
 

Repository files navigation

EveryRay-Rendering-Engine

Ver 1.1.2 (Change Log)

Introduction

"EveryRay" is a rendering engine that is written in C++ with a focus on quick prototyping of graphical techniques and features. It is lightweight, easy to use and already contains many existing rendering solutions inside.

"EveryRay" is not a game engine. It was never made with that in mind which resulted in building the engine with a minimal amount of components/systems outside the graphics part. It is not impossible to make a proper game engine out of "EveryRay", however, there are many other projects that were architectured specifically for that instead.

"EveryRay" is not a library that can be disconnected and connected to your project either. It is not modular and was never meant to be. However, there is at least a distinction between low-level graphics code and high-level systems in the engine which you can borrow for your own needs.

Lastly, "EveryRay" was made by a graphics programmer for those who are interested in real-time rendering and who do not want to spend time setting up a bunch of engine-related things that are needed when you begin writing your personal engine of any kind. You can think of "EveryRay" as a "toy engine/tech demo on steroids" or, in other words, a simple sandbox with minimal UI for testing complex ideas with the help of various prepared functionalities.

You can read more about the architecture of "EveryRay" in the documentation:

  • Engine Overview
  • Graphics Overview

You can see a video demonstration of "EveryRay" here (scroll down for screenshots):

  • https://youtu.be/jnN1lxqrDyc?si=9-9O8PVqQM1qs06y

Rendering features

  • Deferred + Forward Rendering
  • Local illumination w/ Physically Based Rendering
  • Global illumination w/:
    • Static: Image Based Lighting from light probes:
      • diffuse (2nd order spherical harmonics)
      • specular (cubemaps)
    • Dynamic: Cascaded Voxel Cone Tracing (AO, diffuse, specular)
  • Cascaded Shadow Mapping
  • Parallax-Occlusion Mapping w/ soft self-shadowing
  • Terrain w/ GPU tessellation
  • Foliage zones
  • Volumetric clouds
  • Volumetric fog
  • Post Processing Volumes with Linear Fog, Screen Space Reflections, Separable Subsurface Scattering, Tonemapping, LUT color grading, Vignette, Anti-aliasing (FXAA)
  • Special materials: Snow, Fresnel-Outline, Fake-Transparency (reflect+refract), Fur Shell

You can read more in Graphics Overview

Engine features

  • Concept of an "ER_RHI" (aka "Rendering Hardware Interface"): graphics API is abstracted from the general code (systems, etc.)
    • supports DX11, DX12
  • Concept of a simplified generic game object - "ER_RenderingObject":
    • supports model loading (.obj, .fbx and etc.) with Assimp Library
    • supports multiple meshes
    • supports texture loading (.png, .jpg, .dds)
    • supports materials
    • supports GPU instancing
    • supports LOD groups
    • supports indirect GPU rendering (GBuffer, Shadow, Forward passes) w/ GPU culling
    • supports AABB (with visualization)
    • supports on-terrain procedural placement & instances distribution
    • customizable via "Object editor" (with instancing support)
  • Concept of a generic scene, which contains "ER_RenderingObject" elements + scene data (lights, terrain, GI and other info):
    • supports loading from & saving to JSON scene files
  • Concept of graphics presets for achieving performance on various hardware configurations
    • loaded from graphics_config.json file
    • impacts the quality of several systems (resolutions, shadows, textures, etc.)
  • CPU frustum culling
  • ImGUI, ImGuizmo
  • Input from mouse, keyboard and gamepad (XInput, but you can add your own)

You can read more in Engine Overview

Controls

  • "Mouse + Right Click" or "Right Thumbstick" - camera rotation
  • "W/A/S/D" or "Left Thumbstick" - camera side movement (on gamepad holding "Left Trigger"/"Right Trigger" will slow/fasten the movement)
  • "E/Q" - camera up/down movement
  • "Backspace" or "Back Gamepad Button" - enable/disable editor
  • "R/T/Y" - scale/translate/rotate object in the editor mode

Gamepad is currently not supported/tested with ImGui.

Screenshots

picture picture picture picture picture picture

Scenes

Over the years many scenes have been created for "EveryRay". However, to make things simpler, only a few are included in the public version of this repository:

Name Description Screenshot
testScene_simple Default startup scene with a few basic objects
testScene Advanced scene with various materials, post-effects volumes, foliage, lights, and light probes
terrainScene Foliage and several types of GPU indirect objects scattered on top of terrain

Learn more about levels in Engine Overview

Roadmap

Big features that require a branch/merge request and a considerable amount of time.

Engine

  • remove DX11 "Effects" library, all .fx shaders and refactor the material system (DONE) (#51)
  • remove all low-level DX11 code and put it into the abstracted RHI (DONE) (#56)
  • add support for DX12 (DONE) (#57)
  • remove DirectXMath and its usages (maybe come up with a custom math lib)
  • add cross-API shader compiler
  • add simple job-system (i.e. for Update(), CPU culling, etc.)
  • add support for multi-threaded command lists on modern APIs (after job-system)
  • add simple memory management system (for now CPU memory; at least linear, pool allocators)

Graphics

  • Order Independent Transparency (in Forward pass)
  • Atmospheric Scattering (Mie, etc.)
  • Contact hardening shadows
  • Stochastic reflections
  • Better Anti-Aliasing (SMAA, TAA, explore FSR/DLSS)
  • Hardware accelerated ray-tracing (i.e., DXR shadows, reflections, AO)
  • High-poly geometry with mesh shaders

External Dependencies

  • DirectXTK (https://github.com/Microsoft/DirectXTK)
  • ImGui (https://github.com/ocornut/imgui)
  • Assimp 5.0.1 (https://github.com/assimp/assimp)
  • JsonCpp (https://github.com/open-source-parsers/jsoncpp/)

References

  • "Real-Time 3D Rendering with DirectX and HLSL: A Practical Guide to Graphics Programming" by Paul Varcholik
  • "Real-Time Rendering" 3rd/4th ed. by Tomas Möller, Naty Hoffman, Eric Haines
  • "GPU Gems" series
  • "GPU Pro" series
  • numerous SIGGRAPH, GDC papers, and blog posts by fellow graphics geeks and vendors :)

Requirements

  • Visual Studio 2019
  • Windows 10 + SDK
  • DirectX 11 or DirectX 12 supported hardware
  • You might increase TDR time of your GPU driver (explained here https://docs.substance3d.com/spdoc/gpu-drivers-crash-with-long-computations-128745489.html).

About

Robust real-time rendering engine on DX11, DX12 with many advanced graphical features for quick prototyping

Topics

3d-graphicsdeferred-renderingdirectx-11directx-12game-engineglobal-illuminationgpu-programminggraphicslightprobesparallax-occlusion-mappingpbrrenderingrendering-enginerhishadersterrain-renderingvolumetric-cloudsvolumetric-fogvolumetric-renderingvoxel-cone-tracing

Resources

Readme
MIT license
Activity

Stars

774 stars

Watchers

5 watching

Forks

33 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

You are visitor 01402503 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.