Raytracing APIs

-
Raytracing is a most powerful technique for making photorealistic 3D images. It's based on literal tracing light's rays path, and requires a lot of computtional resources.

See theory of raytracing in a sample chapter of the book Real-Time Rendering, Fourth Edition.

Currently NVidia RTX videocards are dedicated to work with raytracing in realtime, and so realtime raytracing becomes the main tool for 3D graphics.

There are two main directions for raytracing API: using NVidia RTX cards and Intel CPU.

Withoud such special API, raytracing (and reymarching and raycasting) can be implemented directly, for example, in fragment shader, for example, see such shaders on Shadertoy site.

NVidia RTX 

NVidia RTX videocards allows to work with NVidia's OptiX or Microsoft DirectX: https://developer.nvidia.com/rtx

Intel Embree 

it's a "collection of high-performance ray tracing kernels" for making raytracing on CPU:
https://embree.github.io/

Addon for using in openFrameworks: https://github.com/cyrildiagne/ofxEmbree



Not raytracing, but related to raytracing:
 

Comments

Post a Comment

Popular posts from this blog

Computing ray origin and direction from Model View Projection matrices for raymarching

-
When performing raymarching (as well a raycasting and raytracing) using fragment shaders in OpenGL, it's required to compute ray's origin and direction. Here we will give solution for finding it from the Model View Projection matrices in OpenGL, implemented in openFrameworks. Using it, you can combine raymarching/raycasting/raytracing with forward OpenGL rendering, so obtain hybrid rendering modes. Also, you can use it for creating VE applications based on raymarching or hybrid rendering. (Actually, we checked what this approach is corrent by creating VR rendering app in HTC Vive). The algorithm can be used on any OpenGL platform with any language supporting matrix inversion computation (in our case it's C++ with GLM library, included in openFrameworks 0.10.1). The approach is based on this hint by  GClements in this discussion on the topic: https://community.khronos.org/t/ray-origin-through-view-and-projection-matrices/7257...
Read more

Create Blueprint Library, print to log and using windows.h in a Unreal Engine C++ project

-
When you need to use some specific Windows API functions, such as LoadLibrary for loading DLL, or CreateFileMapping for using shared memory, you need to use #include <windows.h> in your project's C++ code. To be sure all building successfully, please insert this with "WIN32_LEAN_AND_MEAN" define, and use it as early as possible (I use it as the second #include in CPP code): #include "MyBlueprintFunctionLibrary.h" #define WIN32_LEAN_AND_MEAN #include <windows.h> For advanced capabilites, such as using GEngine class, it's required to include "Engine.h" . It's required to do before including <windows.h> : #include "MyBlueprintFunctionLibrary.h" #include "Engine.h" #define WIN32_LEAN_AND_MEAN #include <windows.h> Here is example how to load DLL using Windows API in Blueprint Function Library C++ class. Also, it demonstrates print to screen and to log in Unreal Engine C+...
Read more

Forward, Deferred and Raytracing rendering in openFrameworks and web

-
Image
Currently, there are three basic approaches for rendering computer graphics scenes: forward rendering, deferred rendering, raytracing. 1. Forward rendering It's that OpenGL does, you create vertices, then make faces, and rasterize them, all passing via shaders. The rendering process is straightworward and fast, but rendering shadows, making degree-of-field effect and drawing clouds is hard here. Most of openFrameworks examples use forward rendering. 2. Deferred rendering It's the same as forward rendering, but additionally some extra data is rendered for computing shadows. The lighting pass is performed after the scene geometry is drawn. See detailed explanation here: https://learnopengl.com/Advanced-Lighting/Deferred-Shading Shadows, degree-of-field effect and some kind of reflections are possible with deferred rendering. Unreal Engine 4 and Unity currently (2019) are based on deferred rendering. openFrameworks: https://github.com/perevalovds...
Read more