aodq / monte-toad Goto Github PK

CMake 4.90% C++ 95.10%

monte-toad's Introduction

Monte Toad

Ongoing WIP project animation renderer. The majority of the feature-set is plugin-based with native support for hot-reloading.

Developmental screenshots can be found at https://aodq.net/portfolio/monte-toad/

External Dependencies

current goal is to have most external dependencies be part of the build process using git submodules

ASSIMP
OpenMP

Internal Dependencies

(part of third-party, don't need to download)

bvh
cxxopts
GLM
imgui
json (nlohmann)
nanort
open-image-denoise
stb
stb_image.hpp

Support

To run the editor, OpenGL3.2 is required. Image processing can still be done without a GPU, but the stand alone application is not yet ready.

Minimum of CMake 3.0 is necessary. I've only tested with GCC 10.1 and Clang 10.0 on Linux. There is no windows support as of now.

Current Feature List

forward next-event-estimation path-tracer
real-time visualizer/editor
multiple integrator visualization
multi-threaded
cameras, integrators, ray dispatchers, emitters, denoisers/post-processing, random generators, and UI are all configurable plugins
OpenImageDenoiser support
material editor (BSDFs composable into BSDFs)

Future Feature List

Windows support
OpenImageDenoiser support
RTX support (probably through Vulkan)
layered material editor (materials composable into layers)
bidirectional path tracing
animation support

Installation (Linux)

Installation uses standard CMake procedure. Here is how to install it locally:

mkdir monte-toad
cd monte-toad
git clone https://github.com/aodq/monte-toad repo
cd repo
git submodule update --init --recursive
cd ..
mkdir build
mkdir install
cd build
cmake -DCMAKE_INSTALL_PREFIX=../install ../repo
make -j4 install

Running real-time renderer

simply run monte-toad-editor; in order to use it though plugins are necessary to be loaded. Several plugins are provided for this purpose.

Running offline renderer

this is not currently available

Development

current layout of how software/dependencies interact with each other is in software-layout.dot . Most of monte-toad should be extendable with plugins alone.

monte-toad's People

Contributors

Stargazers

Watchers

monte-toad's Issues

forward NEE integrator

forward next-event-estimation integrator plugin

framebuffer path history inspection

Depends on issue #5 (Add framebuffer fragment to inspection)

There should also be an optional path history (displays the path a fragment took, its BRDF, PDF, etc). This will definitely be memory-intensive and would be very experimental. It could be made into a separate issue

replace plugin library

replace CR with my own solution that is simpler, doesn't require temporary files, etc

real-time rasterized-based-shading integrator

multiple viewers

should be possible to have multiple integrators all rendering out to seperate viewers (with their own resolution controls, udpate controls, etc). This will just be an improved QoL for scene navigation.

framebuffer fragment inspection

This will allow images to have individual colors inspected. For real-time only one fragment can be shown, but for non-realtime then each fragment will have a history (writes, discards, etc) that should be visible.

This will mean that multiple image buffers have to be stored in order to track the history. This means that history tracking should have a limit (controllable by user) in order to not consume too much memory.

desynced camera movement

allows integrators to have a desynced camera that can be moved independent from other integrators.

plugin material system

progressive upsampling-resolution rendering

Allows faster interactive scene modification & movement without having to manually switch between buffer sizes. The idea is that you select a downsample size (say x4) and the first render will be at 1/4 resolution size, second render at 1/2 resolution size, then third render at full resolution. This allows to render a scene at 4K resolution for example and not have it be unbearably slow.

For real-time the buffer will clear every frame, for non-realtime there might be a way to preserve the rendered fragments.

sometimes plugins unload themselves when other plugins load

controllable flyout camera in UI

Basic keyboard/mouse camera controls that will allow easy scene navigation

optional imgui integration with all plugins

several plugins might have options; for example, camera might have DoF, aperture, etc settings; albedo integrator might have fog option; several integrators might have path length, etc.

Technically all the plugins can use ImGui already, however there is no formal function "DispatchGui" or something along those lines that would be called for all plugins every frame.

keep in mind that these options need to be configurable with json options in the future for offline rendering.

cross-platform file navigator

Right now I'm using Zenity as the file navigator. This is a Linux-only file navigator. This is fine for linux but for Win32 I will need a different API.

I'm not considering using ImGui as a file browser as it just wouldn't be as fully featured as native file browsers (no bookmarks, slower navigation, no file previews, no file metadata, etc).