Fixing many links issues.
Corrected shaders
This commit is contained in:
mklefrancois
parent
b6402f0c09
commit
95912b873b
32 changed files with 135 additions and 123 deletions
|
|
@ -4,7 +4,7 @@
|
|||
|
||||
The focus of this project and the provided code is to showcase a basic integration of
|
||||
ray tracing within an existing Vulkan sample, using the
|
||||
[`VK_NV_ray_tracing`](https://www.khronos.org/registry/vulkan/specs/1.1-extensions/html/vkspec.html#VK_NV_ray_tracing) extension.
|
||||
[`VK_KHR_ray_tracing`](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#VK_KHR_ray_tracing) extension.
|
||||
The following tutorials starts from a the end of the previous ray tracing tutorial and provides step-by-step instructions to modify and add methods and functions.
|
||||
The sections are organized by components, with subsections identifying the modified functions.
|
||||
|
||||
|
|
@ -16,7 +16,7 @@ Instead of having examples fully functional, those tutorial starts from a progra
|
|||
|
||||
The first tutorial is starting from a Vulkan code example, which can load multiple OBJ and render them using the rasterizer, and adds step-by-step what is require to do ray tracing.
|
||||
|
||||
### [**Start Ray Tracing Tutorial**](https://nvpro-samples.github.io/vk_raytracing_tutorial/)
|
||||
### [**Start Ray Tracing Tutorial**](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/)
|
||||
|
||||
|
||||
|
||||
|
|
@ -24,4 +24,4 @@ The first tutorial is starting from a Vulkan code example, which can load multip
|
|||
|
||||
From this point on, you can continue creating your own ray types and shaders, and experiment with more advanced ray tracing based algorithms.
|
||||
|
||||
### [**All Extra Tutorials**](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_further.md.html)
|
||||
### [**All Extra Tutorials**](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_further.md.html)
|
||||
|
|
|
|||
File diff suppressed because one or more lines are too long
|
Before Width: | Height: | Size: 13 KiB After Width: | Height: | Size: 13 KiB |
|
|
@ -1,2 +1,2 @@
|
|||
|
||||
# Start [Ray Tracing Tutorial](https://nvpro-samples.github.io/vk_raytracing_tutorial/)
|
||||
# Start [Ray Tracing Tutorial](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/)
|
||||
|
|
|
|||
|
|
@ -2,8 +2,8 @@
|
|||
|
||||
# Environment Setup
|
||||
|
||||
To get support for `VK_NV_ray_tracing`, please install an [NVIDIA driver](http://www.nvidia.com/Download/index.aspx?lang=en-us)
|
||||
with version 440.97 or later, and the [Vulkan SDK](http://vulkan.lunarg.com/sdk/home) version 1.1.126.0 or later.
|
||||
To get support for `VK_KHR_ray_tracing`, please install an [Vulkan NVIDIA driver](https://developer.nvidia.com/vulkan-driver)
|
||||
with version 442.81 or later, and the [Vulkan SDK](http://vulkan.lunarg.com/sdk/home) version 1.2.136.0 or later.
|
||||
|
||||
This tutorial is a modification of [`ray_tracing__simple`](https://github.com/nvpro-samples/vk_raytracing_tutorial/tree/master/ray_tracing__simple), which is the result of the ray tracing tutorial.
|
||||
All following instructions are based on the modification of this project.
|
||||
|
|
@ -33,9 +33,21 @@ The directory structure should be looking like:
|
|||
**********************************************************
|
||||
|
||||
|
||||
|
||||
!!! Warning
|
||||
**Run CMake** in vk_raytracing_tutorial.
|
||||
|
||||
## Beta Installation
|
||||
|
||||
If you are in the Beta period
|
||||
|
||||
* Latest driver: https://developer.nvidia.com/vulkan-driver
|
||||
* Latest Vulkan headers: https://github.com/KhronosGroup/Vulkan-Headers
|
||||
* When running CMake, modify VULKAN > VULKAN_HEADERS_OVERRIDE_INCLUDE_DIR to the path to beta vulkan headers.
|
||||
Ex. under C:\Vulkan\Beta, copy the folder vulkan\ which contains all headers.
|
||||
VULKAN_HEADERS_OVERRIDE_INCLUDE_DIR should point to C:\Vulkan\Beta
|
||||
|
||||
|
||||
<!-- Markdeep: -->
|
||||
<link rel="stylesheet" href="vkrt_tutorial.css?">
|
||||
<script> window.markdeepOptions = { tocStyle: "medium" };</script>
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ Create a new shader file `raytrace.rahit` and rerun CMake to have it added to th
|
|||
This shader starts like `raytrace.chit`, but uses less information.
|
||||
~~~~ C++
|
||||
#version 460
|
||||
#extension GL_NV_ray_tracing : require
|
||||
#extension GL_EXT_ray_tracing : require
|
||||
#extension GL_EXT_nonuniform_qualifier : enable
|
||||
#extension GL_EXT_scalar_block_layout : enable
|
||||
#extension GL_GOOGLE_include_directive : enable
|
||||
|
|
@ -41,7 +41,7 @@ This shader starts like `raytrace.chit`, but uses less information.
|
|||
#include "wavefront.glsl"
|
||||
|
||||
// clang-format off
|
||||
layout(location = 0) rayPayloadInNV hitPayload prd;
|
||||
layout(location = 0) rayPayloadInEXT hitPayload prd;
|
||||
|
||||
layout(binding = 2, set = 1, scalar) buffer ScnDesc { sceneDesc i[]; } scnDesc;
|
||||
layout(binding = 4, set = 1) buffer MatIndexColorBuffer { int i[]; } matIndex[];
|
||||
|
|
@ -80,9 +80,9 @@ Now we will apply transparency:
|
|||
|
||||
~~~~ C++
|
||||
if (mat.dissolve == 0.0)
|
||||
ignoreIntersectionNV();
|
||||
ignoreIntersectionEXT();
|
||||
else if(rnd(prd.seed) > mat.dissolve)
|
||||
ignoreIntersectionNV();
|
||||
ignoreIntersectionEXT();
|
||||
}
|
||||
~~~~
|
||||
|
||||
|
|
@ -183,23 +183,23 @@ First, `seed` will need to be available in the any hit shader, which is the reas
|
|||
Change the local `seed` to `prd.seed` everywhere.
|
||||
|
||||
~~~~ C++
|
||||
prd.seed = tea(gl_LaunchIDNV.y * gl_LaunchSizeNV.x + gl_LaunchIDNV.x, pushC.frame);
|
||||
prd.seed = tea(gl_LaunchIDEXT.y * gl_LaunchSizeEXT.x + gl_LaunchIDEXT.x, pushC.frame);
|
||||
~~~~
|
||||
|
||||
For optimization, the `TraceNV` call was using the `gl_RayFlagsOpaqueNV` flag. But
|
||||
For optimization, the `TraceRayEXT` call was using the `gl_RayFlagsOpaqueEXT` flag. But
|
||||
this will skip the any hit shader, so change it to
|
||||
|
||||
~~~~ C++
|
||||
uint rayFlags = gl_RayFlagsNoneNV;
|
||||
uint rayFlags = gl_RayFlagsNoneEXT;
|
||||
~~~~
|
||||
|
||||
## `raytrace.rchit`
|
||||
|
||||
Similarly, in the closest hit shader, change the flag to `gl_RayFlagsSkipClosestHitShaderNV`, as we want to enable the any hit and miss shaders, but we still don't care
|
||||
Similarly, in the closest hit shader, change the flag to `gl_RayFlagsSkipClosestHitShaderEXT`, as we want to enable the any hit and miss shaders, but we still don't care
|
||||
about the closest hit shader for shadow rays. This will enable transparent shadows.
|
||||
|
||||
~~~~ C++
|
||||
uint flags = gl_RayFlagsSkipClosestHitShaderNV;
|
||||
uint flags = gl_RayFlagsSkipClosestHitShaderEXT;
|
||||
~~~~
|
||||
|
||||
# Scene and Model
|
||||
|
|
|
|||
|
|
@ -20,10 +20,10 @@ It is similar to an indirect function call, whitout having to link those shaders
|
|||
|
||||
Data can only access data passed in to the callable from parent stage. There will be only one structure pass at a time and should be declared like for payload.
|
||||
|
||||
In the parent stage, using the `callableDataNV` storage qualifier, it could be declared like:
|
||||
In the parent stage, using the `callableDataEXT` storage qualifier, it could be declared like:
|
||||
|
||||
~~~~ C++
|
||||
layout(location = 0) callableDataNV rayLight cLight;
|
||||
layout(location = 0) callableDataEXT rayLight cLight;
|
||||
~~~~
|
||||
|
||||
where `rayLight` struct is defined in a shared file.
|
||||
|
|
@ -38,22 +38,22 @@ struct rayLight
|
|||
};
|
||||
~~~~
|
||||
|
||||
And in the incoming callable shader, you must use the `callableDataInNV` storage qualifier.
|
||||
And in the incoming callable shader, you must use the `callableDataInEXT` storage qualifier.
|
||||
|
||||
~~~~ C++
|
||||
layout(location = 0) callableDataInNV rayLight cLight;
|
||||
layout(location = 0) callableDataInEXT rayLight cLight;
|
||||
~~~~
|
||||
|
||||
# Execution
|
||||
|
||||
To execute one of the callable shader, the parent stage need to call `executeCallableNV`.
|
||||
To execute one of the callable shader, the parent stage need to call `executeCallableEXT`.
|
||||
|
||||
The first parameter is the SBT record index, the second one correspond to the 'location' index.
|
||||
|
||||
Example of how it is called.
|
||||
|
||||
~~~~ C++
|
||||
executeCallableNV(pushC.lightType, 0);
|
||||
executeCallableEXT(pushC.lightType, 0);
|
||||
~~~~
|
||||
|
||||
|
||||
|
|
@ -181,7 +181,7 @@ cLight.inHitPosition = worldPos;
|
|||
cLight.outLightDistance = 10000000;
|
||||
}
|
||||
#else
|
||||
executeCallableNV(pushC.lightType, 0);
|
||||
executeCallableEXT(pushC.lightType, 0);
|
||||
#endif
|
||||
~~~~
|
||||
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ information to discard hits over time.
|
|||
Reflections can be implemented by shooting new rays from the closest hit shader, or by iteratively shooting them from
|
||||
the raygen shader. This example shows the limitations and differences of these implementations.
|
||||
|
||||
* Calling traceNV() from the closest hit shader (recursive)
|
||||
* Calling traceRayEXT() from the closest hit shader (recursive)
|
||||
* Adding more data to the ray payload to continue the ray from the raygen shader.
|
||||
|
||||
|
||||
|
|
@ -82,7 +82,7 @@ explains what is needed to get procedural hit group working.
|
|||
Replacing if/else by callable shaders. The code to execute the lighting is done in separate callable shaders instead of been part of the code.
|
||||
|
||||
* Adding multiple callable shaders
|
||||
* Calling ExecuteCallableNV from the closest hit shader
|
||||
* Calling ExecuteCallableEXT from the closest hit shader
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -62,7 +62,7 @@ All the information will need to be hold in buffers, which will be available to
|
|||
nvvkBuffer m_spheresMatIndexBuffer; // Define which sphere uses which material
|
||||
~~~~
|
||||
|
||||
Finally, there are two functions, one to create the spheres, and one that will create the `VkGeometryNV` for the BLAS.
|
||||
Finally, there are two functions, one to create the spheres, and one that will create the intermediate structure for the BLAS.
|
||||
|
||||
~~~~ C++
|
||||
void createSpheres();
|
||||
|
|
@ -382,7 +382,7 @@ We first declare the extensions and include common files.
|
|||
|
||||
~~~~ C++
|
||||
#version 460
|
||||
#extension GL_NV_ray_tracing : require
|
||||
#extension GL_EXT_ray_tracing : require
|
||||
#extension GL_EXT_nonuniform_qualifier : enable
|
||||
#extension GL_EXT_scalar_block_layout : enable
|
||||
#extension GL_GOOGLE_include_directive : enable
|
||||
|
|
@ -393,7 +393,7 @@ We first declare the extensions and include common files.
|
|||
Then we **must** add the following, otherwise the intersection shader will not report any hit.
|
||||
|
||||
~~~~ C++
|
||||
hitAttributeNV vec3 HitAttribute;
|
||||
hitAttributeEXT vec3 HitAttribute;
|
||||
~~~~
|
||||
|
||||
The following is the topology of all spheres, which we will be able to retrieve using `gl_PrimitiveID`.
|
||||
|
|
@ -464,8 +464,8 @@ Retrieving the ray is straight forward
|
|||
void main()
|
||||
{
|
||||
Ray ray;
|
||||
ray.origin = gl_WorldRayOriginNV;
|
||||
ray.direction = gl_WorldRayDirectionNV;
|
||||
ray.origin = gl_WorldRayOriginEXT;
|
||||
ray.direction = gl_WorldRayDirectionEXT;
|
||||
~~~~
|
||||
|
||||
And getting the information about the geometry enclosed in the Aabb can be done like this.
|
||||
|
|
@ -495,13 +495,13 @@ Now we just need to know if we will hit a sphere or a cube.
|
|||
}
|
||||
~~~~
|
||||
|
||||
Intersection information is reported using `reportIntersectionNV`, with a distance from the origin and a second argument (hitKind) that can be used to differentiate the primitive type.
|
||||
Intersection information is reported using `reportIntersectionEXT`, with a distance from the origin and a second argument (hitKind) that can be used to differentiate the primitive type.
|
||||
|
||||
~~~~ C++
|
||||
|
||||
// Report hit point
|
||||
if(tHit > 0)
|
||||
reportIntersectionNV(tHit, hitKind);
|
||||
reportIntersectionEXT(tHit, hitKind);
|
||||
}
|
||||
~~~~
|
||||
|
||||
|
|
@ -513,10 +513,10 @@ The new closest hit can be found [here](shaders/raytrace2.rchit)
|
|||
|
||||
This shader is almost identical to original `raytrace.rchit`, but since the primitive is implicit, we will only need to compute the normal for the primitive that was hit.
|
||||
|
||||
We retrieve the world position from the ray and the `gl_HitTNV` which was set in the intersection shader.
|
||||
We retrieve the world position from the ray and the `gl_HitTEXT` which was set in the intersection shader.
|
||||
|
||||
~~~~ C++
|
||||
vec3 worldPos = gl_WorldRayOriginNV + gl_WorldRayDirectionNV * gl_HitTNV;
|
||||
vec3 worldPos = gl_WorldRayOriginEXT + gl_WorldRayDirectionEXT * gl_HitTEXT;
|
||||
~~~~
|
||||
|
||||
The sphere information is retrieved the same way as in the `raytrace.rint` shader.
|
||||
|
|
@ -532,13 +532,13 @@ Then we compute the normal, as for a sphere.
|
|||
vec3 normal = normalize(worldPos - instance.center);
|
||||
~~~~
|
||||
|
||||
To know if we have intersect a cube rather than a sphere, we are using `gl_HitKindNV`, which was set in the second argument of `reportIntersectionNV`.
|
||||
To know if we have intersect a cube rather than a sphere, we are using `gl_HitKindEXT`, which was set in the second argument of `reportIntersectionEXT`.
|
||||
|
||||
So when this is a cube, we set the normal to the major axis.
|
||||
|
||||
~~~~ C++
|
||||
// Computing the normal for a cube if the hit intersection was reported as 1
|
||||
if(gl_HitKindNV == KIND_CUBE) // Aabb
|
||||
if(gl_HitKindEXT == KIND_CUBE) // Aabb
|
||||
{
|
||||
vec3 absN = abs(normal);
|
||||
float maxC = max(max(absN.x, absN.y), absN.z);
|
||||
|
|
|
|||
|
|
@ -96,7 +96,7 @@ In `raytrace.rgen`, at the beginning of `main()`, initialize the random seed:
|
|||
|
||||
~~~~ C++
|
||||
// Initialize the random number
|
||||
uint seed = tea(gl_LaunchIDNV.y * gl_LaunchSizeNV.x + gl_LaunchIDNV.x, pushC.frame);
|
||||
uint seed = tea(gl_LaunchIDEXT.y * gl_LaunchSizeEXT.x + gl_LaunchIDEXT.x, pushC.frame);
|
||||
~~~~
|
||||
|
||||
Then we need two random numbers to vary the X and Y inside the pixel, except for frame 0, where we always shoot
|
||||
|
|
@ -113,7 +113,7 @@ vec2 subpixel_jitter = pushC.frame == 0 ? vec2(0.5f, 0.5f) : vec2(r1, r2);
|
|||
Now we only need to change how we compute the pixel center:
|
||||
|
||||
~~~~ C++
|
||||
const vec2 pixelCenter = vec2(gl_LaunchIDNV.xy) + subpixel_jitter;
|
||||
const vec2 pixelCenter = vec2(gl_LaunchIDEXT.xy) + subpixel_jitter;
|
||||
~~~~
|
||||
|
||||
## Storing or Updating
|
||||
|
|
@ -126,13 +126,13 @@ Otherwise, we combine the new image with the previous `frame` frames.
|
|||
if(pushC.frame > 0)
|
||||
{
|
||||
float a = 1.0f / float(pushC.frame + 1);
|
||||
vec3 old_color = imageLoad(image, ivec2(gl_LaunchIDNV.xy)).xyz;
|
||||
imageStore(image, ivec2(gl_LaunchIDNV.xy), vec4(mix(old_color, prd.hitValue, a), 1.f));
|
||||
vec3 old_color = imageLoad(image, ivec2(gl_LaunchIDEXT.xy)).xyz;
|
||||
imageStore(image, ivec2(gl_LaunchIDEXT.xy), vec4(mix(old_color, prd.hitValue, a), 1.f));
|
||||
}
|
||||
else
|
||||
{
|
||||
// First frame, replace the value in the buffer
|
||||
imageStore(image, ivec2(gl_LaunchIDNV.xy), vec4(prd.hitValue, 1.f));
|
||||
imageStore(image, ivec2(gl_LaunchIDEXT.xy), vec4(prd.hitValue, 1.f));
|
||||
}
|
||||
~~~~
|
||||
|
||||
|
|
@ -263,7 +263,7 @@ To do this, add a constant to `raytrace.rgen` (this could alternatively be added
|
|||
const int NBSAMPLES = 10;
|
||||
~~~~
|
||||
|
||||
In `main()`, after initializing the random number seed, create a loop that encloses the lines from the generation of `r1` and `r2` to the `traceNV` call, and accumulates the colors returned by `traceNV`. At the end of the loop, divide by the number of samples that were taken.
|
||||
In `main()`, after initializing the random number seed, create a loop that encloses the lines from the generation of `r1` and `r2` to the `traceRayEXT` call, and accumulates the colors returned by `traceRayEXT`. At the end of the loop, divide by the number of samples that were taken.
|
||||
|
||||
~~~~ C++
|
||||
vec3 hitValues = vec3(0);
|
||||
|
|
@ -273,7 +273,7 @@ In `main()`, after initializing the random number seed, create a loop that enclo
|
|||
float r1 = rnd(seed);
|
||||
float r2 = rnd(seed);
|
||||
// ...
|
||||
// TraceNV( ... );
|
||||
// TraceRayEXT( ... );
|
||||
hitValues += prd.hitValue;
|
||||
}
|
||||
prd.hitValue = hitValues / NBSAMPLES;
|
||||
|
|
|
|||
|
|
@ -41,12 +41,12 @@ As an example, create a new file called `raytrace2.rchit`, and add it to Visual
|
|||
|
||||
~~~~ C++
|
||||
#version 460
|
||||
#extension GL_NV_ray_tracing : require
|
||||
#extension GL_EXT_ray_tracing : require
|
||||
#extension GL_GOOGLE_include_directive : enable
|
||||
|
||||
#include "raycommon.glsl"
|
||||
|
||||
layout(location = 0) rayPayloadInNV hitPayload prd;
|
||||
layout(location = 0) rayPayloadInEXT hitPayload prd;
|
||||
|
||||
void main()
|
||||
{
|
||||
|
|
@ -75,7 +75,7 @@ Then add a new hit group group immediately after adding the first hit group:
|
|||
|
||||
## `raytrace.rgen`
|
||||
|
||||
As a test, you can try changing the `sbtRecordOffset` parameter of the `traceNV` call in `raytrace.rgen`.
|
||||
As a test, you can try changing the `sbtRecordOffset` parameter of the `traceRayEXT` call in `raytrace.rgen`.
|
||||
If you set the offset to `1`, then all ray hits will use the new CHIT, and the raytraced output should look like the image below:
|
||||
|
||||
|
||||
|
|
@ -170,10 +170,10 @@ In the HelloVulkan class, we will add a structure to hold the hit group data.
|
|||
|
||||
## `raytrace2.rchit`
|
||||
|
||||
In the closest hit shader, we can retrieve the shader record using the `layout(shaderRecordNV)` descriptor
|
||||
In the closest hit shader, we can retrieve the shader record using the `layout(shaderRecordEXT)` descriptor
|
||||
|
||||
~~~~ C++
|
||||
layout(shaderRecordNV) buffer sr_ { vec4 c; } shaderRec;
|
||||
layout(shaderRecordEXT) buffer sr_ { vec4 c; } shaderRec;
|
||||
~~~~
|
||||
|
||||
and use this information to return the color:
|
||||
|
|
@ -199,7 +199,7 @@ In `main`, after we set which hit group an instance will use, we can add the dat
|
|||
Since we are no longer compacting all handles in a continuous buffer, we need to fill the SBT as described above.
|
||||
|
||||
After retrieving the handles of all 5 groups (raygen, miss, miss shadow, hit0, and hit1)
|
||||
using `getRayTracingShaderGroupHandlesNV`, store the pointers to easily retrieve them.
|
||||
using `getRayTracingShaderGroupHandlesKHR`, store the pointers to easily retrieve them.
|
||||
|
||||
~~~~ C++
|
||||
// Retrieve the handle pointers
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ Ks 0.95 0.95 0.95
|
|||
|
||||
# Recursive Reflections
|
||||
|
||||
Vulkan ray tracing allows recursive calls to traceNV, up to a limit defined by `VkPhysicalDeviceRayTracingPropertiesKHR`.
|
||||
Vulkan ray tracing allows recursive calls to traceRayEXT, up to a limit defined by `VkPhysicalDeviceRayTracingPropertiesKHR`.
|
||||
|
||||
In `createRtPipeline()` in `hello_vulkan.cpp`, bring the maximum recursion depth up to 10, making sure not to exceed the physical device's maximum recursion limit:
|
||||
|
||||
|
|
@ -63,7 +63,7 @@ In the `hitPayload` struct in `raycommon.glsl`, add the following:
|
|||
|
||||
## `raytrace.rgen`
|
||||
|
||||
In the ray generation shader, we will initialize all payload values before calling `traceNV`.
|
||||
In the ray generation shader, we will initialize all payload values before calling `traceRayEXT`.
|
||||
|
||||
~~~~ C++
|
||||
prd.depth = 0;
|
||||
|
|
@ -80,12 +80,12 @@ At the end of the closest hit shader, before setting `prd.hitValue`, we need to
|
|||
if(mat.illum == 3 && prd.depth < 10)
|
||||
{
|
||||
vec3 origin = worldPos;
|
||||
vec3 rayDir = reflect(gl_WorldRayDirectionNV, normal);
|
||||
vec3 rayDir = reflect(gl_WorldRayDirectionEXT, normal);
|
||||
prd.attenuation *= mat.specular;
|
||||
|
||||
prd.depth++;
|
||||
traceNV(topLevelAS, // acceleration structure
|
||||
gl_RayFlagsNoneNV, // rayFlags
|
||||
traceRayEXT(topLevelAS, // acceleration structure
|
||||
gl_RayFlagsNoneEXT, // rayFlags
|
||||
0xFF, // cullMask
|
||||
0, // sbtRecordOffset
|
||||
0, // sbtRecordStride
|
||||
|
|
@ -143,7 +143,7 @@ Initialize the new members of the payload:
|
|||
prd.rayDir = direction.xyz;
|
||||
~~~~
|
||||
|
||||
Instead of calling traceNV only once, we will call it in a loop until we are done.
|
||||
Instead of calling traceRayEXT only once, we will call it in a loop until we are done.
|
||||
|
||||
Wrap the trace call in `raytrace.rgen` like this:
|
||||
|
||||
|
|
@ -151,7 +151,7 @@ Wrap the trace call in `raytrace.rgen` like this:
|
|||
vec3 hitValue = vec3(0);
|
||||
for(;;)
|
||||
{
|
||||
traceNV( /*.. */);
|
||||
traceRayEXT( /*.. */);
|
||||
|
||||
hitValue += prd.hitValue * prd.attenuation;
|
||||
|
||||
|
|
@ -168,7 +168,7 @@ Wrap the trace call in `raytrace.rgen` like this:
|
|||
And make sure to write the correct value
|
||||
|
||||
~~~~ C++
|
||||
imageStore(image, ivec2(gl_LaunchIDNV.xy), vec4(hitValue, 1.0));
|
||||
imageStore(image, ivec2(gl_LaunchIDEXT.xy), vec4(hitValue, 1.0));
|
||||
~~~~
|
||||
|
||||
## `raytrace.rchit`
|
||||
|
|
@ -179,7 +179,7 @@ We no longer need to shoot rays from the closest hit shader, so we can replace t
|
|||
if(mat.illum == 3)
|
||||
{
|
||||
vec3 origin = worldPos;
|
||||
vec3 rayDir = reflect(gl_WorldRayDirectionNV, normal);
|
||||
vec3 rayDir = reflect(gl_WorldRayDirectionEXT, normal);
|
||||
prd.attenuation *= mat.specular;
|
||||
prd.done = 0;
|
||||
prd.rayOrigin = origin;
|
||||
|
|
|
|||
|
|
@ -273,7 +273,7 @@ In the `HelloVulkan` class declaration, we can now add the `createBottomLevelAS(
|
|||
void createBottomLevelAS();
|
||||
````
|
||||
|
||||
The implementation loops over all the loaded models and fills in an array of `vk::GeometryNV` before
|
||||
The implementation loops over all the loaded models and fills in an array of `nvvkpp::RaytracingBuilderKHR::Blas` before
|
||||
triggering a build of all BLAS's in a batch. The resulting acceleration structures will be stored
|
||||
within the helper in the order of construction, so that they can be directly referenced by index later.
|
||||
|
||||
|
|
@ -475,8 +475,8 @@ builds or better performance.
|
|||
|
||||
```` C
|
||||
void buildTlas(const std::vector<Instance>& instances,
|
||||
vk::BuildAccelerationStructureFlagsNV flags =
|
||||
vk::BuildAccelerationStructureFlagBitsNV::ePreferFastTrace)
|
||||
vk::BuildAccelerationStructureFlagsKHR flags =
|
||||
vk::BuildAccelerationStructureFlagBitsKHR::ePreferFastTrace)
|
||||
{
|
||||
m_tlas.flags = flags;
|
||||
|
||||
|
|
@ -633,7 +633,7 @@ In the header, we declare the objects related to this additional descriptor set:
|
|||
vk::DescriptorSet m_rtDescSet;
|
||||
````
|
||||
|
||||
The acceleration structure will be accessible by the Ray Generation shader, as we want to call `TraceNV()` from this
|
||||
The acceleration structure will be accessible by the Ray Generation shader, as we want to call `TraceRayEXT()` from this
|
||||
shader. Later in this document, we will also make it accessible from the Closest Hit shader, in order to send rays from
|
||||
there as well. The output image is the offscreen buffer used by the rasterization, and will be written only by the
|
||||
RayGen shader.
|
||||
|
|
@ -805,7 +805,7 @@ ray trace some geometry, the Vulkan ray tracing extension typically uses at leas
|
|||
|
||||
* The **ray generation** shader will be the starting point for ray tracing, and will be called for each pixel. It will
|
||||
typically initialize a ray starting at the location of the camera, in a direction given by evaluating the camera lens
|
||||
model at the pixel location. It will then invoke `traceNV()`, that will shoot the ray in the scene. Other shaders below
|
||||
model at the pixel location. It will then invoke `traceRayEXT()`, that will shoot the ray in the scene. Other shaders below
|
||||
will process further events, and return their result to the ray generation shader through the ray payload.
|
||||
|
||||
* The **miss** shader is executed when a ray does not intersect any geometry. For instance, it might sample an
|
||||
|
|
@ -839,7 +839,7 @@ Two more shader types can optionally be used:
|
|||
|
||||
* The **any hit** shader is executed on each potential intersection: when searching for the hit point closest to the ray
|
||||
origin, several candidates may be found on the way. The any hit shader can frequently be used to efficiently implement
|
||||
alpha-testing. If the alpha test fails, the ray traversal can continue without having to call `traceNV()` again. The
|
||||
alpha-testing. If the alpha test fails, the ray traversal can continue without having to call `traceRayEXT()` again. The
|
||||
built-in any hit shader is simply a pass-through returning the intersection to the traversal engine, which will
|
||||
determine which ray intersection is the closest.
|
||||
|
||||
|
|
@ -864,12 +864,12 @@ The `shaders` folder now contains 3 more files:
|
|||
shader program simply writes a constant color into the output buffer.
|
||||
|
||||
* `raytrace.rmiss` defines the miss shader. This shader will be executed when no geometry is hit, and will write a
|
||||
constant color into the ray payload `rayPayloadInNV`, which is provided automatically. Since our current ray generation
|
||||
constant color into the ray payload `rayPayloadInEXT`, which is provided automatically. Since our current ray generation
|
||||
program does not trace any rays for now, this shader will not be called.
|
||||
|
||||
* `raytrace.rchit` contains a very simple closest hit shader. It will be executed upon hitting the geometry (our
|
||||
triangles). As the miss shader, it takes the ray payload `rayPayloadInNV`. It also has a second input defining the
|
||||
intersection attributes `hitAttributeNV` as provided by the intersection shader, i.e. the barycentric coordinates. This
|
||||
triangles). As the miss shader, it takes the ray payload `rayPayloadInEXT`. It also has a second input defining the
|
||||
intersection attributes `hitAttributeEXT` as provided by the intersection shader, i.e. the barycentric coordinates. This
|
||||
shader simply writes a constant color to the payload.
|
||||
|
||||
In the header file, let's add the definition of the ray tracing pipeline building method, and the storage members of the
|
||||
|
|
@ -1028,7 +1028,7 @@ itself, but hit groups can comprise up to 3 shaders (intersection, any hit, clos
|
|||
The ray generation and closest hit shaders can trace rays, making the ray tracing a potentially recursive process. To
|
||||
allow the underlying RTX layer to optimize the pipeline we indicate the maximum recursion depth used by our shaders. For
|
||||
the simplistic shaders we currently have, we set this depth to 1, meaning that even if the shaders would trigger
|
||||
recursion (ie. a hit shader calling `TraceNV()`), this recursion would be prevented by setting the result of this trace
|
||||
recursion (ie. a hit shader calling `TraceRayEXT()`), this recursion would be prevented by setting the result of this trace
|
||||
call as a miss. Note that it is preferable to keep the recursion level as low as possible, replacing it by a loop
|
||||
formulation instead.
|
||||
|
||||
|
|
@ -1329,7 +1329,7 @@ cam;
|
|||
`set = 1` comes from the fact that it is the second descriptor set in `raytrace()`.
|
||||
|
||||
When tracing a ray, the hit or miss shaders need to be able to return some information to the shader program that
|
||||
invoked the ray tracing. This is done through the use of a payload, identified by the `rayPayloadNV` qualifier.
|
||||
invoked the ray tracing. This is done through the use of a payload, identified by the `rayPayloadEXT` qualifier.
|
||||
|
||||
Since the payload struct will be reused in several shaders, we create a new shader file `raycommon.glsl` and add it to
|
||||
the Visual Studio folder.
|
||||
|
|
@ -1351,25 +1351,25 @@ we also enable:
|
|||
#include "raycommon.glsl"
|
||||
~~~~
|
||||
|
||||
The payload, identified with `rayPayloadNV` is then our `hitPayload` structure.
|
||||
The payload, identified with `rayPayloadEXT` is then our `hitPayload` structure.
|
||||
|
||||
```` C
|
||||
layout(location = 0) rayPayloadNV hitPayload prd;
|
||||
layout(location = 0) rayPayloadEXT hitPayload prd;
|
||||
````
|
||||
|
||||
### Note
|
||||
|
||||
> In incoming shaders, like miss and closest hit, the payload will be `rayPayloadInNV`.
|
||||
> In incoming shaders, like miss and closest hit, the payload will be `rayPayloadInEXT`.
|
||||
|
||||
The `main` function of the shader then starts by computing the floating-point pixel coordinates, normalized between 0
|
||||
and 1. The `gl_LaunchIDNV` contains the integer coordinates of the pixel being rendered, while `gl_LaunchSizeNV`
|
||||
corresponds to the image size provided when calling `traceRaysNV`.
|
||||
and 1. The `gl_LaunchIDEXT` contains the integer coordinates of the pixel being rendered, while `gl_LaunchSizeEXT`
|
||||
corresponds to the image size provided when calling `traceRayEXT`.
|
||||
|
||||
```` C
|
||||
void main()
|
||||
{
|
||||
const vec2 pixelCenter = vec2(gl_LaunchIDNV.xy) + vec2(0.5);
|
||||
const vec2 inUV = pixelCenter/vec2(gl_LaunchSizeNV.xy);
|
||||
const vec2 pixelCenter = vec2(gl_LaunchIDEXT.xy) + vec2(0.5);
|
||||
const vec2 inUV = pixelCenter/vec2(gl_LaunchSizeEXT.xy);
|
||||
vec2 d = inUV * 2.0 - 1.0;
|
||||
````
|
||||
|
||||
|
|
@ -1388,12 +1388,12 @@ potential intersections along the ray. Those distances can be useful to reduce t
|
|||
before or after a given point do not matter. A typical use case is for computing ambient occlusion.
|
||||
|
||||
```` C
|
||||
uint rayFlags = gl_RayFlagsOpaqueNV;
|
||||
uint rayFlags = gl_RayFlagsOpaqueEXT;
|
||||
float tMin = 0.001;
|
||||
float tMax = 10000.0;
|
||||
````
|
||||
|
||||
We now trace the ray itself, by first providing `traceNV` with the top-level acceleration structure and the ray masks.
|
||||
We now trace the ray itself, by first providing `traceRayEXT` with the top-level acceleration structure and the ray masks.
|
||||
The `cullMask` value is a mask that will be binary AND-ed with the mask of the geometry instances. Since all instances
|
||||
have a `0xFF` flag as well, they will all be visible. The next 3 parameters indicate which hit group would be called
|
||||
when hitting a surface. For example, a single object may be associated to 2 hit groups representing the behavior when
|
||||
|
|
@ -1405,10 +1405,10 @@ groups for a single instance. This is particularly useful if the instance offset
|
|||
in the acceleration structure. A stride of 0 indicates that all hit groups are packed together, and the instance offset
|
||||
can be used directly to find them in the SBT. The index of the miss shader comes next, followed by the ray origin,
|
||||
direction and extents. The last parameter identifies the payload that will be carried by the ray, by giving its location
|
||||
index. The last `0` corresponds to the location of our payload, `layout(location = 0) rayPayloadNV hitPayload prd;`.
|
||||
index. The last `0` corresponds to the location of our payload, `layout(location = 0) rayPayloadEXT hitPayload prd;`.
|
||||
|
||||
```` C
|
||||
traceNV(topLevelAS, // acceleration structure
|
||||
traceRayEXT(topLevelAS, // acceleration structure
|
||||
rayFlags, // rayFlags
|
||||
0xFF, // cullMask
|
||||
0, // sbtRecordOffset
|
||||
|
|
@ -1425,7 +1425,7 @@ index. The last `0` corresponds to the location of our payload, `layout(location
|
|||
Finally, we write the resulting payload into the output buffer.
|
||||
|
||||
```` C
|
||||
imageStore(image, ivec2(gl_LaunchIDNV.xy), vec4(prd.hitValue, 1.0));
|
||||
imageStore(image, ivec2(gl_LaunchIDEXT.xy), vec4(prd.hitValue, 1.0));
|
||||
}
|
||||
````
|
||||
|
||||
|
|
@ -1443,7 +1443,7 @@ fact that `clearColor` is the first member in the struct, and do not even declar
|
|||
#extension GL_GOOGLE_include_directive : enable
|
||||
#include "raycommon.glsl"
|
||||
|
||||
layout(location = 0) rayPayloadInNV hitPayload prd;
|
||||
layout(location = 0) rayPayloadInEXT hitPayload prd;
|
||||
|
||||
layout(push_constant) uniform Constants
|
||||
{
|
||||
|
|
@ -1486,7 +1486,7 @@ We first include the payload definition and the OBJ-Wavefront structures
|
|||
Then we describe the resources according to the descriptor set layout
|
||||
|
||||
```` C
|
||||
layout(location = 0) rayPayloadInNV hitPayload prd;
|
||||
layout(location = 0) rayPayloadInEXT hitPayload prd;
|
||||
|
||||
layout(binding = 2, set = 1, scalar) buffer ScnDesc { sceneDesc i[]; } scnDesc;
|
||||
layout(binding = 5, set = 1, scalar) buffer Vertices { Vertex v[]; } vertices[];
|
||||
|
|
@ -1539,7 +1539,7 @@ The world-space position could be calculated in two ways, the first one being to
|
|||
shader. But this could have precision issues if the hit point is very far.
|
||||
|
||||
```` C
|
||||
vec3 worldPos = gl_WorldRayOriginNV + gl_WorldRayDirectionNV * gl_HitTNV;
|
||||
vec3 worldPos = gl_WorldRayOriginEXT + gl_WorldRayDirectionEXT * gl_HitTEXT;
|
||||
````
|
||||
|
||||
Another solution, more precise, consists in computing the position by interpolation, as for the normal
|
||||
|
|
@ -1636,7 +1636,7 @@ supports textures to modulate the surface albedo.
|
|||
}
|
||||
|
||||
// Specular
|
||||
vec3 specular = computeSpecular(mat, gl_WorldRayDirectionNV, L, normal);
|
||||
vec3 specular = computeSpecular(mat, gl_WorldRayDirectionEXT, L, normal);
|
||||
````
|
||||
|
||||
The final lighting is then computed as
|
||||
|
|
@ -1764,7 +1764,7 @@ rays will be traced from the closest hit shader, we add `vkSS::eClosestHitKHR` t
|
|||
The closest hit shader now needs to be aware of the acceleration structure to be able to shoot rays:
|
||||
|
||||
```` C
|
||||
layout(binding = 0, set = 0) uniform accelerationStructureNV topLevelAS;
|
||||
layout(binding = 0, set = 0) uniform accelerationStructureEXT topLevelAS;
|
||||
````
|
||||
|
||||
Those rays will also carry a payload, which will need to be defined at a different location from the payload of the
|
||||
|
|
@ -1772,12 +1772,12 @@ current ray. In this case, the payload will be a simple Boolean value indicating
|
|||
not:
|
||||
|
||||
```` C
|
||||
layout(location = 1) rayPayloadNV bool isShadowed;
|
||||
layout(location = 1) rayPayloadEXT bool isShadowed;
|
||||
````
|
||||
|
||||
In the `main` function, instead of simply setting our payload to `prd.hitValue = c;`, we will initiate a new ray. Note that
|
||||
the index of the miss shader is now 1, since the SBT has 2 miss shaders. The payload location is defined to match
|
||||
the declaration `layout(location = 1)` above. Note, when invoking `traceNV()` we are setting
|
||||
the declaration `layout(location = 1)` above. Note, when invoking `traceRayEXT()` we are setting
|
||||
the flags with
|
||||
|
||||
* `gl_RayFlagsSkipClosestHitShaderKHR`: Will not invoke the hit shader, only the miss shader
|
||||
|
|
@ -1803,12 +1803,12 @@ the specular term will then look like this:
|
|||
{
|
||||
float tMin = 0.001;
|
||||
float tMax = lightDistance;
|
||||
vec3 origin = gl_WorldRayOriginNV + gl_WorldRayDirectionNV * gl_HitTNV;
|
||||
vec3 origin = gl_WorldRayOriginEXT + gl_WorldRayDirectionEXT * gl_HitTEXT;
|
||||
vec3 rayDir = L;
|
||||
uint flags =
|
||||
gl_RayFlagsTerminateOnFirstHitNV | gl_RayFlagsOpaqueNV | gl_RayFlagsSkipClosestHitShaderNV;
|
||||
gl_RayFlagsTerminateOnFirstHitEXT | gl_RayFlagsOpaqueEXT | gl_RayFlagsSkipClosestHitShaderEXT;
|
||||
isShadowed = true;
|
||||
traceNV(topLevelAS, // acceleration structure
|
||||
traceRayEXT(topLevelAS, // acceleration structure
|
||||
flags, // rayFlags
|
||||
0xFF, // cullMask
|
||||
0, // sbtRecordOffset
|
||||
|
|
@ -1828,7 +1828,7 @@ the specular term will then look like this:
|
|||
else
|
||||
{
|
||||
// Specular
|
||||
specular = computeSpecular(mat, gl_WorldRayDirectionNV, L, normal);
|
||||
specular = computeSpecular(mat, gl_WorldRayDirectionEXT, L, normal);
|
||||
}
|
||||
}
|
||||
````
|
||||
|
|
|
|||
|
|
@ -2,6 +2,6 @@
|
|||
|
||||
This example is the combination of all tutorials.
|
||||
|
||||
If you haven't done the tutorials, you can start [here](https://nvpro-samples.github.io/vk_raytracing_tutorial)
|
||||
If you haven't done the tutorials, you can start [here](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#version 460 core
|
||||
#extension GL_NV_ray_tracing : enable
|
||||
#extension GL_EXT_ray_tracing : enable
|
||||
#extension GL_GOOGLE_include_directive : enable
|
||||
#include "raycommon.glsl"
|
||||
|
||||
layout(location = 0) callableDataInNV rayLight cLight;
|
||||
layout(location = 0) callableDataInEXT rayLight cLight;
|
||||
|
||||
layout(push_constant) uniform Constants
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#version 460 core
|
||||
#extension GL_NV_ray_tracing : enable
|
||||
#extension GL_EXT_ray_tracing : enable
|
||||
#extension GL_GOOGLE_include_directive : enable
|
||||
#include "raycommon.glsl"
|
||||
|
||||
layout(location = 0) callableDataInNV rayLight cLight;
|
||||
layout(location = 0) callableDataInEXT rayLight cLight;
|
||||
|
||||
layout(push_constant) uniform Constants
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#version 460 core
|
||||
#extension GL_NV_ray_tracing : enable
|
||||
#extension GL_EXT_ray_tracing : enable
|
||||
#extension GL_GOOGLE_include_directive : enable
|
||||
#include "raycommon.glsl"
|
||||
|
||||
layout(location = 0) callableDataInNV rayLight cLight;
|
||||
layout(location = 0) callableDataInEXT rayLight cLight;
|
||||
|
||||
layout(push_constant) uniform Constants
|
||||
{
|
||||
|
|
|
|||
|
|
@ -3,6 +3,6 @@
|
|||
This example is a simple OBJ viewer in Vulkan, without any ray tracing functionality.
|
||||
It is the starting point of the ray tracing tutorial, the source of the application in which ray tracing will be added.
|
||||
|
||||
## [**Start Ray Tracing Tutorial**](https://nvpro-samples.github.io/vk_raytracing_tutorial/)
|
||||
## [**Start Ray Tracing Tutorial**](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -3,7 +3,7 @@
|
|||
This example is the result of the ray tracing tutorial.
|
||||
The tutorial is adding ray tracing capability to an OBJ rasterizer in Vulkan
|
||||
|
||||
If you haven't done it, [**Start Ray Tracing Tutorial**](https://nvpro-samples.github.io/vk_raytracing_tutorial/).
|
||||
If you haven't done it, [**Start Ray Tracing Tutorial**](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/).
|
||||
|
||||
|
||||
|
||||
|
|
@ -11,4 +11,4 @@ If you haven't done it, [**Start Ray Tracing Tutorial**](https://nvpro-samples.g
|
|||
|
||||
Once the tutorial completed and the basics of ray tracing are in place, other tuturials are going further from this code base.
|
||||
|
||||
See all other [additional ray tracing tutorials](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_further.md.html)
|
||||
See all other [additional ray tracing tutorials](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_further.md.html)
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
# NVIDIA Vulkan Ray Tracing Tutorial
|
||||
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_animation.md.htm)
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_animation.md.htm)
|
||||
|
||||
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
# NVIDIA Vulkan Ray Tracing Tutorial
|
||||
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_anyhit.md.htm)
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_anyhit.md.htm)
|
||||
|
||||
|
||||
|
|
@ -1,7 +1,7 @@
|
|||
#version 460
|
||||
#extension GL_NV_ray_tracing : require
|
||||
#extension GL_EXT_ray_tracing : require
|
||||
|
||||
layout(location = 1) rayPayloadInNV bool isShadowed;
|
||||
layout(location = 1) rayPayloadInEXT bool isShadowed;
|
||||
|
||||
void main()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
# NVIDIA Vulkan Ray Tracing Tutorial
|
||||
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_callable.md.html)
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_callable.md.html)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -804,13 +804,13 @@ void HelloVulkan::createRtPipeline()
|
|||
nvvkpp::util::createShaderModule(m_device,
|
||||
nvh::loadFile("shaders/light_inf.rcall.spv", true, paths));
|
||||
|
||||
stages.push_back({{}, vk::ShaderStageFlagBits::eCallableNV, call0, "main"});
|
||||
stages.push_back({{}, vk::ShaderStageFlagBits::eCallableKHR, call0, "main"});
|
||||
callGroup.setGeneralShader(static_cast<uint32_t>(stages.size() - 1));
|
||||
m_rtShaderGroups.push_back(callGroup);
|
||||
stages.push_back({{}, vk::ShaderStageFlagBits::eCallableNV, call1, "main"});
|
||||
stages.push_back({{}, vk::ShaderStageFlagBits::eCallableKHR, call1, "main"});
|
||||
callGroup.setGeneralShader(static_cast<uint32_t>(stages.size() - 1));
|
||||
m_rtShaderGroups.push_back(callGroup);
|
||||
stages.push_back({{}, vk::ShaderStageFlagBits::eCallableNV, call2, "main"});
|
||||
stages.push_back({{}, vk::ShaderStageFlagBits::eCallableKHR, call2, "main"});
|
||||
callGroup.setGeneralShader(static_cast<uint32_t>(stages.size() - 1));
|
||||
m_rtShaderGroups.push_back(callGroup);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#version 460 core
|
||||
#extension GL_NV_ray_tracing : enable
|
||||
#extension GL_EXT_ray_tracing : enable
|
||||
#extension GL_GOOGLE_include_directive : enable
|
||||
#include "raycommon.glsl"
|
||||
|
||||
layout(location = 0) callableDataInNV rayLight cLight;
|
||||
layout(location = 0) callableDataInEXT rayLight cLight;
|
||||
|
||||
layout(push_constant) uniform Constants
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#version 460 core
|
||||
#extension GL_NV_ray_tracing : enable
|
||||
#extension GL_EXT_ray_tracing : enable
|
||||
#extension GL_GOOGLE_include_directive : enable
|
||||
#include "raycommon.glsl"
|
||||
|
||||
layout(location = 0) callableDataInNV rayLight cLight;
|
||||
layout(location = 0) callableDataInEXT rayLight cLight;
|
||||
|
||||
layout(push_constant) uniform Constants
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#version 460 core
|
||||
#extension GL_NV_ray_tracing : enable
|
||||
#extension GL_EXT_ray_tracing : enable
|
||||
#extension GL_GOOGLE_include_directive : enable
|
||||
#include "raycommon.glsl"
|
||||
|
||||
layout(location = 0) callableDataInNV rayLight cLight;
|
||||
layout(location = 0) callableDataInEXT rayLight cLight;
|
||||
|
||||
layout(push_constant) uniform Constants
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
# NVIDIA Vulkan Ray Tracing Tutorial
|
||||
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_instances.md.htm)
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_instances.md.htm)
|
||||
|
||||
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
# NVIDIA Vulkan Ray Tracing Tutorial
|
||||
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_intersection.md.htm)
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_intersection.md.htm)
|
||||
|
||||
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
# NVIDIA Vulkan Ray Tracing Tutorial
|
||||
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_antialiasing.md.htm)
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_antialiasing.md.htm)
|
||||
|
||||
|
||||
|
|
@ -1,5 +1,5 @@
|
|||
# NVIDIA Vulkan Ray Tracing Tutorial
|
||||
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_manyhits.md.htm)
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_manyhits.md.htm)
|
||||
|
||||
|
||||
|
|
@ -1,8 +1,8 @@
|
|||
# NVIDIA Vulkan Ray Tracing Tutorial
|
||||
|
||||
This example is part of the the ray tracing tutorial.
|
||||
If you haven't done it, [**Start Ray Tracing Tutorial**](https://nvpro-samples.github.io/vk_raytracing_tutorial/).
|
||||
If you haven't done it, [**Start Ray Tracing Tutorial**](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/).
|
||||
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_rayquery.md.htm)
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_rayquery.md.htm)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
# NVIDIA Vulkan Ray Tracing Tutorial
|
||||
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial/vkrt_tuto_reflection.md.htm)
|
||||
[Start the tutorial of this project](https://nvpro-samples.github.io/vk_raytracing_tutorial_KHR/vkrt_tuto_reflection.md.htm)
|
||||
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue