ange-yaghi / manta-ray Goto Github PK

• Current approach results in many repeated calculations that aren't needed

• Demonstrate a complete working example of GPU collision detection

• Add test cases for ray-collision detection
• Implement vicinity resolution checking

Add a feature (for developers primarily, though it could potentially serve a function later for users) to run the program for a single pixel with minimal code changes.

• Anti-aliasing is currently achieved using a regular grid

Ray batching is required for effective use of GPU resources. Especially for diffuse sampling, it's important that each emitter emit multiple rays (rather than one as per the current implementation) and that all of these are traced in parallel.

• Currently all demos exist in the main project are under the main() function
• They should all be moved to their own directory and project

• Some scattering code has already been written
• Look into improving it and making it give good results

Current Functionality

• Ray paths are processed (for the most part) one at a time in a sequential pattern

Desired Functionality

• Rays should be grouped by degree and then processed in batches
• This will allow multiple rays to be processed simultaneously by the GPU

• Current octree traversal implementation is naive
• Better approach should be implemented

• Currently there are issues with octree building causing infinite loops
• This is likely due to a robustness issue

• Collision engine is currently operating sub-optimally
• Reduce 1 sample - 1 sample width teapot-lamp demo from 13.1499 s
• General code cleanup

• All math functions are currently defined in a separate cpp file which may hurt performance since the compiler can't inline

Current Functionality

• Only flat color materials are supported

Desired Functionality

• Support for 2D texture mapping onto surfaces

• Camera appears to be skewed along its horizontal axis
• This should be corrected such that all rays come from the correct eye point

• Add GGX surface scattering distribution

• Create a stack memory allocation class
• This will improve performance by avoiding dynamic allocation for each ray creation

• Currently renders are outputted directly as bitmaps
• This leaves no room for flexible editing of the brightness (exposure)
• Ideally renders should be saved as raw double arrays which can then be post-processed into an image

• Add support for dynamically looking up materials that appear in object files

There is currently a logic error in the octree intersection test code that must be fixed.

• Currently the non-simd implementation of scalars is inefficient
• Dedicated support for scalar types should be added

• Look into "shrink-wrapping" octree containers to geometry

Currently all lens simulations are in place but there is no camera emitter capable of using it. One is needed for depth of field simulations.

• Possibly implement this as a linear combination of diffuse and pure specular reflection

• Currently a single ray emitter group creates all emitters before tracing occurs
• This results in a large memory footprint
• A possible solution is create separate emitter groups for each job

Benchmark:

Teapot Lamp Demo (100 samples): 50.1641 s
Complex Room Demo (18 samples): 78.7318 s

Overview

• Coarse collisions are generated using a bleed on the outer edges of polygons
• A better approach would be to use a thick ray or an approximation thereof

• Add basic template for simulating lenses
• By extension this will add support for depth of field

Current State

• Spatial partitioning is achieved only through separation into different objects

Desired State

• Spatial partitioning is achieved through an octree or other explicit partitioning scheme

• The testing project is currently out of date and not working
• Changes need to be made to make it compatible with the current code

• Octree currently uses too much memory and creates too many duplicates

• Added memory usage tracking to stack allocator
• Create abstraction for C++ new function

Add Beckmann distribution for surface scattering

• Determine and/or fix the cause of poor performance in the room demo