文章目录
前言
上篇内容介绍了光线追踪的前半部分包括两层加速结构以及着色器绑定表的创建接下来万层下半部分内容
五种shader具体的调用流程图如下（你也可以把此图看成Vulkan光追的渲染管线示意图）：
- RayGenerationShader 用来发射光线，其中会触发RayTracing()函数；
- BLAS (Bottom Level Acceleration Struct) 是一种类似BVH(Bounding Volume Tree)的场景管理树，用来加速光线碰撞检测，这个是固定管线，也就是说vulkan已经帮你实现了光线 碰撞检测那一套逻辑；
- 在遍历BVH时如果进入intersection检测环节，就可能会调用这个求交着色器；但是这个shader未必进入，因为这个只针对自定义primitive，如果用通常默认的三角形网格原语，系统已经自己实现了相交判定逻辑，则跳过这个shader，简单来说，如果你想要自定义primitive，就要自己实现这个shader. 这个shader应该是自定义实现原语的相交逻辑。
- 固定管线相交检测， 判断是不是相交，如果不相交，继续BLAS遍历，否则调用Any-Hit Shader。Any-Hit Shader的作用是光线和材质发生碰撞之后，需要做什么处理，比如说是否抛弃交点之类的。你可以根据情况把这个交点抛弃，那么就认为没有发生相交，也就是anyhit的含义之后回到BLAS遍历
- 以上3)-5)若循环干圈，直到整个BLAS遍历完毕，进入FoundHit这个是系统固定管线，会根据你的any-hit等自己算出有没有追踪hit，如果没有，则进入MissShader，这个shader就表示光线没有碰到任何东西如何处理，比如给个默认色环境色之类的。如果发生碰撞，进入Closet-Hit Shader ，这个也就是说光线和物体发生碰撞了，需要最后的处理。
- 最后，Closet-Hit Shader 除了输出结果之外还可以干一件事，就是Ray-Tracing() ，也就是发生光线，和RayGenerationShader中一样，为什么？这个就是光线追踪的光线反弹了，继续反弹，然后估计会走到BLAS那里继续循环 ，所以官方图示可能把这个箭头省略了;
一、CPP文件
1）创建光线追踪调度的描述符集
void createDescriptorSets()
{
std::vector<VkDescriptorPoolSize> poolSizes = {
{ VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, 1 },
{ VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1 },
{ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1 },
{ VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2 }
};
VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = vks::initializers::descriptorPoolCreateInfo(poolSizes, 1);
VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolCreateInfo, nullptr, &descriptorPool));
VkDescriptorSetAllocateInfo descriptorSetAllocateInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout, 1);
VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &descriptorSetAllocateInfo, &descriptorSet));
VkWriteDescriptorSetAccelerationStructureKHR descriptorAccelerationStructureInfo = vks::initializers::writeDescriptorSetAccelerationStructureKHR();
descriptorAccelerationStructureInfo.accelerationStructureCount = 1;
descriptorAccelerationStructureInfo.pAccelerationStructures = &topLevelAS.handle;
VkWriteDescriptorSet accelerationStructureWrite{};
accelerationStructureWrite.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
// The specialized acceleration structure descriptor has to be chained
accelerationStructureWrite.pNext = &descriptorAccelerationStructureInfo;
accelerationStructureWrite.dstSet = descriptorSet;
accelerationStructureWrite.dstBinding = 0;
accelerationStructureWrite.descriptorCount = 1;
accelerationStructureWrite.descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
VkDescriptorImageInfo storageImageDescriptor{ VK_NULL_HANDLE, storageImage.view, VK_IMAGE_LAYOUT_GENERAL };
VkDescriptorBufferInfo vertexBufferDescriptor{ scene.vertices.buffer, 0, VK_WHOLE_SIZE };
VkDescriptorBufferInfo indexBufferDescriptor{ scene.indices.buffer, 0, VK_WHOLE_SIZE };
std::vector<VkWriteDescriptorSet> writeDescriptorSets = {
// Binding 0: Top level acceleration structure
accelerationStructureWrite,
// Binding 1: Ray tracing result image
vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, 1, &storageImageDescriptor),
// Binding 2: Uniform data
vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2, &ubo.descriptor),
// Binding 3: Scene vertex buffer
vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 3, &vertexBufferDescriptor),
// Binding 4: Scene index buffer
vks::initializers::writeDescriptorSet(descriptorSet, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 4, &indexBufferDescriptor),
};
vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, VK_NULL_HANDLE);
}
2）创建光线追踪管线（先于描述符集的创建）用于绑定着色器要调用的缓冲数据
void createRayTracingPipeline()
{
std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings = {
// Binding 0: Acceleration structure
vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, VK_SHADER_STAGE_RAYGEN_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, 0),
// Binding 1: Storage image
vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, VK_SHADER_STAGE_RAYGEN_BIT_KHR, 1),
// Binding 2: Uniform buffer
vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, VK_SHADER_STAGE_RAYGEN_BIT_KHR | VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR | VK_SHADER_STAGE_MISS_BIT_KHR, 2),
// Binding 3: Vertex buffer
vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, 3),
// Binding 4: Index buffer
vks::initializers::descriptorSetLayoutBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, 4),
};
VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCI = vks::initializers::descriptorSetLayoutCreateInfo(setLayoutBindings);
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorSetLayoutCI, nullptr, &descriptorSetLayout));
VkPipelineLayoutCreateInfo pPipelineLayoutCI = vks::initializers::pipelineLayoutCreateInfo(&descriptorSetLayout, 1);
VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCI, nullptr, &pipelineLayout));
/*
Setup ray tracing shader groups
*/
std::vector<VkPipelineShaderStageCreateInfo> shaderStages;
// Ray generation group
{
shaderStages.push_back(loadShader(getShadersPath() + "raytracingshadows/raygen.rgen.spv", VK_SHADER_STAGE_RAYGEN_BIT_KHR));
VkRayTracingShaderGroupCreateInfoKHR shaderGroup{};
shaderGroup.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
shaderGroup.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
shaderGroup.generalShader = static_cast<uint32_t>(shaderStages.size()) - 1;
shaderGroup.closestHitShader = VK_SHADER_UNUSED_KHR;
shaderGroup.anyHitShader = VK_SHADER_UNUSED_KHR;
shaderGroup.intersectionShader = VK_SHADER_UNUSED_KHR;
shaderGroups.push_back(shaderGroup);
}
// Miss group
{
shaderStages.push_back(loadShader(getShadersPath() + "raytracingshadows/miss.rmiss.spv", VK_SHADER_STAGE_MISS_BIT_KHR));
VkRayTracingShaderGroupCreateInfoKHR shaderGroup{};
shaderGroup.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
shaderGroup.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
shaderGroup.generalShader = static_cast<uint32_t>(shaderStages.size()) - 1;
shaderGroup.closestHitShader = VK_SHADER_UNUSED_KHR;
shaderGroup.anyHitShader = VK_SHADER_UNUSED_KHR;
shaderGroup.intersectionShader = VK_SHADER_UNUSED_KHR;
shaderGroups.push_back(shaderGroup);
// Second shader for shadows
shaderStages.push_back(loadShader(getShadersPath() + "raytracingshadows/shadow.rmiss.spv", VK_SHADER_STAGE_MISS_BIT_KHR));
shaderGroup.generalShader = static_cast<uint32_t>(shaderStages.size()) - 1;
shaderGroups.push_back(shaderGroup);
}
// Closest hit group
{
shaderStages.push_back(loadShader(getShadersPath() + "raytracingshadows/closesthit.rchit.spv", VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR));
VkRayTracingShaderGroupCreateInfoKHR shaderGroup{};
shaderGroup.sType = VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR;
shaderGroup.type = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR;
shaderGroup.generalShader = VK_SHADER_UNUSED_KHR;
shaderGroup.closestHitShader = static_cast<uint32_t>(shaderStages.size()) - 1;
shaderGroup.anyHitShader = VK_SHADER_UNUSED_KHR;
shaderGroup.intersectionShader = VK_SHADER_UNUSED_KHR;
shaderGroups.push_back(shaderGroup);
}
VkRayTracingPipelineCreateInfoKHR rayTracingPipelineCI = vks::initializers::rayTracingPipelineCreateInfoKHR();
rayTracingPipelineCI.stageCount = static_cast<uint32_t>(shaderStages.size());
rayTracingPipelineCI.pStages = shaderStages.data();
rayTracingPipelineCI.groupCount = static_cast<uint32_t>(shaderGroups.size());
rayTracingPipelineCI.pGroups = shaderGroups.data();
rayTracingPipelineCI.maxPipelineRayRecursionDepth = 2;
rayTracingPipelineCI.layout = pipelineLayout;
VK_CHECK_RESULT(vkCreateRayTracingPipelinesKHR(device, VK_NULL_HANDLE, VK_NULL_HANDLE, 1, &rayTracingPipelineCI, nullptr, &pipeline));
}
3）创建用于将矩阵传递到光线追踪光线生成着色器的统一缓冲区
void createUniformBuffer()
{
VK_CHECK_RESULT(vulkanDevice->createBuffer(
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
&ubo,
sizeof(uniformData),
&uniformData));
VK_CHECK_RESULT(ubo.map());
updateUniformBuffers();
}
4）生成命令和缓冲
void buildCommandBuffers()
{
if (resized)
{
handleResize();
}
VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
VkImageSubresourceRange subresourceRange = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 };
for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
{
VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
/*
Dispatch the ray tracing commands
调度光线追踪命令
*/
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, pipeline);
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, pipelineLayout, 0, 1, &descriptorSet, 0, 0);
VkStridedDeviceAddressRegionKHR emptySbtEntry = {};
vkCmdTraceRaysKHR(
drawCmdBuffers[i],
&shaderBindingTables.raygen.stridedDeviceAddressRegion,
&shaderBindingTables.miss.stridedDeviceAddressRegion,
&shaderBindingTables.hit.stridedDeviceAddressRegion,
&emptySbtEntry,
width,
height,
1);
/*
Copy ray tracing output to swap chain image
复制光线追踪输出以交换链图像
*/
// Prepare current swap chain image as transfer destination
// 准备当前交换链映像作为传输目标
vks::tools::setImageLayout(
drawCmdBuffers[i],
swapChain.images[i],
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
subresourceRange);
// Prepare ray tracing output image as transfer source
// 准备光线追踪输出图像作为传输源
vks::tools::setImageLayout(
drawCmdBuffers[i],
storageImage.image,
VK_IMAGE_LAYOUT_GENERAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
subresourceRange);
VkImageCopy copyRegion{};
copyRegion.srcSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
copyRegion.srcOffset = { 0, 0, 0 };
copyRegion.dstSubresource = { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0, 1 };
copyRegion.dstOffset = { 0, 0, 0 };
copyRegion.extent = { width, height, 1 };
vkCmdCopyImage(drawCmdBuffers[i], storageImage.image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, swapChain.images[i], VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, ©Region);
// Transition swap chain image back for presentation
// 过渡交换链图像返回以进行演示
vks::tools::setImageLayout(
drawCmdBuffers[i],
swapChain.images[i],
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
subresourceRange);
// Transition ray tracing output image back to general layout
// 将光线追踪输出图像转换回常规布局
vks::tools::setImageLayout(
drawCmdBuffers[i],
storageImage.image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VK_IMAGE_LAYOUT_GENERAL,
subresourceRange);
drawUI(drawCmdBuffers[i], frameBuffers[i]);
VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
}
}
5）创建存储图像
void VulkanRaytracingSample::createStorageImage(VkFormat format, VkExtent3D extent)
{
// Release ressources if image is to be recreated
if (storageImage.image != VK_NULL_HANDLE) {
vkDestroyImageView(device, storageImage.view, nullptr);
vkDestroyImage(device, storageImage.image, nullptr);
vkFreeMemory(device, storageImage.memory, nullptr);
storageImage = {};
}
VkImageCreateInfo image = vks::initializers::imageCreateInfo();
image.imageType = VK_IMAGE_TYPE_2D;
image.format = format;
image.extent = extent;
image.mipLevels = 1;
image.arrayLayers = 1;
image.samples = VK_SAMPLE_COUNT_1_BIT;
image.tiling = VK_IMAGE_TILING_OPTIMAL;
image.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_STORAGE_BIT;
image.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
VK_CHECK_RESULT(vkCreateImage(vulkanDevice->logicalDevice, &image, nullptr, &storageImage.image));
VkMemoryRequirements memReqs;
vkGetImageMemoryRequirements(vulkanDevice->logicalDevice, storageImage.image, &memReqs);
VkMemoryAllocateInfo memoryAllocateInfo = vks::initializers::memoryAllocateInfo();
memoryAllocateInfo.allocationSize = memReqs.size;
memoryAllocateInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
VK_CHECK_RESULT(vkAllocateMemory(vulkanDevice->logicalDevice, &memoryAllocateInfo, nullptr, &storageImage.memory));
VK_CHECK_RESULT(vkBindImageMemory(vulkanDevice->logicalDevice, storageImage.image, storageImage.memory, 0));
VkImageViewCreateInfo colorImageView = vks::initializers::imageViewCreateInfo();
colorImageView.viewType = VK_IMAGE_VIEW_TYPE_2D;
colorImageView.format = format;
colorImageView.subresourceRange = {};
colorImageView.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
colorImageView.subresourceRange.baseMipLevel = 0;
colorImageView.subresourceRange.levelCount = 1;
colorImageView.subresourceRange.baseArrayLayer = 0;
colorImageView.subresourceRange.layerCount = 1;
colorImageView.image = storageImage.image;
VK_CHECK_RESULT(vkCreateImageView(vulkanDevice->logicalDevice, &colorImageView, nullptr, &storageImage.view));
VkCommandBuffer cmdBuffer = vulkanDevice->createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
vks::tools::setImageLayout(cmdBuffer, storageImage.image,
VK_IMAGE_LAYOUT_UNDEFINED,
VK_IMAGE_LAYOUT_GENERAL,
{ VK_IMAGE_ASPECT_COLOR_BIT, 0, 1, 0, 1 });
vulkanDevice->flushCommandBuffer(cmdBuffer, queue);
}
二、Shader文件
光线追踪管道的行为更像计算管道而不是光栅化图形管道。vk光线追踪在抽象的 3Dwidth/height/depth空间中发射光线，结果使用imageStore函数写入。 然而与计算管道不同的是，您需要分派单个着色器调用，而不是本地组。
1. 光线生成器（xxx.rgen）
光线追踪的入口点是光线生成器：
- 光线的生成着色器将对屏幕中每个像素生成光线。它通常会初始化一条从相机位置开始的光线，方向是通过在像素位置评估相机镜头模型而给定的。然后它会调用traceRayEXT()函数在场景中发射光线。traceRayEXT()会直接调用之后的几种着色器类型并且它会保证使用光线追踪中有效光路来传递结果。
- 光线追踪有效光路被声明为rayPayloadEXT或rayPayloadInEXT变量；它们一起在着色器阶段之间建立了调用者/被调用者关系。着色器的每次调用都会创建其声明的rayPayloadEXT变量的本地副本
- 当通过调用traceRayEXT()函数调用另一个着色器时，调用者可以选择它的一个有效光路载荷作为其rayPayloadInEXT变量（也称为“传入有效光路”）以对被调用的着色器可见。
- 一般我们需要合理的声明有效光路，因为过多的显存占有量使用会降低 SM（Shader便是在此单元上执行的，详细可参照GPU架构与管线总结相关知识） 占用率（并行性）。
#version 460
#extension GL_EXT_ray_tracing : require
layout(binding = 0, set = 0) uniform accelerationStructureEXT topLevelAS;
layout(binding = 1, set = 0, rgba8) uniform image2D image;
layout(binding = 2, set = 0) uniform CameraProperties
{
mat4 viewInverse;
mat4 projInverse;
vec4 lightPos;
} cam;
layout(location = 0) rayPayloadEXT vec3 hitValue;
void main()
{
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;
vec4 origin = cam.viewInverse * vec4(0,0,0,1);
vec4 target = cam.projInverse * vec4(d.x, d.y, 1, 1) ;
vec4 direction = cam.viewInverse*vec4(normalize(target.xyz / target.w), 0) ;
uint rayFlags = gl_RayFlagsOpaqueEXT;
uint cullMask = 0xff;
float tmin = 0.001;
float tmax = 10000.0;
traceRayEXT(topLevelAS, rayFlags, cullMask, 0, 0, 0, origin.xyz, tmin, direction.xyz, tmax, 0);//发射光线
imageStore(image, ivec2(gl_LaunchIDEXT.xy), vec4(hitValue, 0.0));//画面结果存储器
}
2.未命中、最近命中着色器（.rmiss、.rchit）
接下来介绍的两种着色器便是：
-
未命中着色器(.rmiss) : 是当光线与任何几何体都不相交时执行的着色器。例如，它可能对环境贴图进行采样，或通过有效光路值返回一个简单的颜色。
1)miss.rmiss#version 460 #extension GL_EXT_ray_tracing : require layout(location = 0) rayPayloadInEXT vec3 hitValue; void main() { hitValue = vec3(0.0, 0.0, 0.2); }2)shadow.rmiss
#version 460 #extension GL_EXT_ray_tracing : require layout(location = 2) rayPayloadInEXT bool shadowed; void main() { shadowed = false; } -
最近命中着色器（.rchit）: 是在命中与光线起点最近几何体实例的时候调用的着色器。例如，该着色器可以执行光照计算并通过有效光路返回结果。执行时可以根据需要存在多个命中着色器，就像光栅化时根据实例需要可以拥有多个片元着色器一样。
#version 460 #extension GL_EXT_ray_tracing : require #extension GL_EXT_nonuniform_qualifier : enable layout(location = 0) rayPayloadInEXT vec3 hitValue; layout(location = 2) rayPayloadEXT bool shadowed; hitAttributeEXT vec2 attribs; layout(binding = 0, set = 0) uniform accelerationStructureEXT topLevelAS; layout(binding = 2, set = 0) uniform UBO { mat4 viewInverse; mat4 projInverse; vec4 lightPos; int vertexSize; } ubo; layout(binding = 3, set = 0) buffer Vertices { vec4 v[]; } vertices; layout(binding = 4, set = 0) buffer Indices { uint i[]; } indices; struct Vertex { vec3 pos; vec3 normal; vec2 uv; vec4 color; vec4 _pad0; vec4 _pad1; }; Vertex unpack(uint index) { // Unpack the vertices from the SSBO using the glTF vertex structure // 使用 glTF 顶点结构从 SSBO 解包顶点 // The multiplier is the size of the vertex divided by four float components (=16 bytes) // 乘数是顶点的大小除以四个浮点分量（= 16字节） const int m = ubo.vertexSize / 16; vec4 d0 = vertices.v[m * index + 0]; vec4 d1 = vertices.v[m * index + 1]; vec4 d2 = vertices.v[m * index + 2]; Vertex v; v.pos = d0.xyz; v.normal = vec3(d0.w, d1.x, d1.y); v.color = vec4(d2.x, d2.y, d2.z, 1.0); return v; } void main() { ivec3 index = ivec3(indices.i[3 * gl_PrimitiveID], indices.i[3 * gl_PrimitiveID + 1], indices.i[3 * gl_PrimitiveID + 2]); Vertex v0 = unpack(index.x); Vertex v1 = unpack(index.y); Vertex v2 = unpack(index.z); // Interpolate normal const vec3 barycentricCoords = vec3(1.0f - attribs.x - attribs.y, attribs.x, attribs.y); vec3 normal = normalize(v0.normal * barycentricCoords.x + v1.normal * barycentricCoords.y + v2.normal * barycentricCoords.z); // Basic lighting vec3 lightVector = normalize(ubo.lightPos.xyz); float dot_product = max(dot(lightVector, normal), 0.2); hitValue = v0.color.rgb * dot_product; // Shadow casting float tmin = 0.001; float tmax = 10000.0; vec3 origin = gl_WorldRayOriginEXT + gl_WorldRayDirectionEXT * gl_HitTEXT; shadowed = true; // Trace shadow ray and offset indices to match shadow hit/miss shader group indices traceRayEXT(topLevelAS, gl_RayFlagsTerminateOnFirstHitEXT | gl_RayFlagsOpaqueEXT | gl_RayFlagsSkipClosestHitShaderEXT, 0xFF, 1, 0, 1, origin, tmin, lightVector, tmax, 2); if (shadowed) { hitValue *= 0.3; } }
3.求交、任意命中着色器（.rint、.rahit）
此外还可以选择使用另外两种可选的着色器类型：
- 求交着色器（.rint）：其允许用户自定义几何形状的求交判断。例如，在进行按需加载几何数据时可用于与几何占位符相交判断，或与程序几何相交而无需事先细分它们的时候。使用此着色器需要修改加速结构的构建方式（本案例中未涉及）。相反，我们将依赖于扩展提供的内置光线三角形相交测试，它返回 2 个浮点值，表示(u,v)三角形内命中点的重心坐标。对于由顶点v0、v1、 v2组成的三角形，重心坐标定义顶点的权重如下：
- 任意命中着色器（.rahit）：该命中着色器可能在任意一个可能与管线相交的情况下执行，在执行查找最近命中着色器时候，可能存在多个相交点（物体背面或者物体后面被遮挡的物体）。anyhit 着色器经常可以用来有效地实现 alpha 测试。
- 如果 alpha 测试失败，光线遍历可以继续而无需traceRayEXT()再次调用。内置的任意命中着色器只是将交点返回给遍历引擎的传递，后者将确定哪个光线交点最近。在有些案例中，因为我们在构建加速结构时指定了不透明标志，所以永远不会调用此类着色器。
效果如下
405
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
