pass vertexbuffer and indexbuffer into the ssbo

[WdsPjm]

The ray-tracing code, like this model's vertexbuffer and indexbuffer, is passed into the ssbo as shown in the figure below. How do I pass vertexbuffer and indexbuffer into the ssbo using vsg。

[robertosfield]

I have attempted the combination of usage you are trying, the closest example I can think of is vsgcomputevertex that uses VK_DESCRIPTOR_TYPE_STORAGE_BUFFER for passing data from a compute shader to the vertex shader, do a search for all the instances of VK_DESCRIPTOR_TYPE_STORAGE_BUFFER to see it how the DescriptorBuffer is setup and used:

https://github.com/vsg-dev/vsgExamples/blob/master/examples/state/vsgcomputevertex/vsgcomputevertex.cpp#L77

[Tetane]

Hi I'm also trying to create a buffer to read in the closest hit shader.
I think I managed to create a buffer to store the triangle color data but in the shader it seems that I can access only the first vec3 of the array and I don't understand why.

auto colors = vsg::vec3Array::create(
                {{1.0f, 0.0f, 1.0f},
                 {0.0f, 1.0f, 1.0f},
                 {1.0f, 1.0f, 0.0f}});

VkDeviceSize bufferSize = sizeof(vsg::vec3) * 3;
auto buffer = vsg::createBufferAndMemory(device, bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT, VK_SHARING_MODE_EXCLUSIVE, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
auto bufferInfo = vsg::BufferInfo::create();
bufferInfo->buffer = buffer;
bufferInfo->offset = 0;
bufferInfo->range = bufferSize;
bufferInfo->data = colors;
bufferInfo->copyDataToBuffer(device->deviceID);

vsg::DescriptorSetLayoutBindings descriptorBindings{ [...], {3, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, nullptr}};

auto storageBufferDescriptor = vsg::DescriptorBuffer::create(vsg::BufferInfoList{bufferInfo}, 3, 0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);

And in the closest hit shader I can read the first color with cols.v[0]. But cols.v[1] or cols.v[2] don't give me the right color.

layout(binding = 3, set = 0) buffer Colors { vec3 v[]; } cols;
void main()
{
	hitValue = cols.v[0];
}

And also I have a completely different issue, if I read a GLTF model I don't know how to get vertices and indices and other data from the scene after it is loaded with auto loaded_scene = vsg::read_cast<vsg::Node>(filename, options);.

[WdsPjm]

By default, glsl reads in vec4 format. You want to turn on reading in vec3 format, like the following

#version 460
#extension GL_EXT_ray_tracing : require
#extension GL_EXT_nonuniform_qualifier : enable

#extension GL_EXT_shader_16bit_storage : enable
// For layout qualifier "scalar", which aligns vec3 as vec3, not as vec4
#extension GL_EXT_scalar_block_layout : 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,scalar) buffer Normals { vec3 n[]; } normals;
layout(binding = 4, set = 0,scalar) buffer Vertices { vec3 v[]; } vertices;
layout(binding = 5, set = 0,scalar) buffer Indices { uint16_t i[]; } indices;

struct Vertex
{
vec3 pos;
vec3 normal;
// vec4 color;
};

Vertex unpack(uint index)
{
// Unpack the vertices from the SSBO using the glTF vertex structure
// The multiplier is the size of the vertex divided by four float components (=16 bytes)
//const int m = ubo.vertexSize / 16;
Vertex v;

vec3 d0 = vertices.v[ index ].xyz;
vec3 n0 = normals.n[ index ].xyz;
    v.pos = vec3(d0.x,d0.y,d0.z);
v.normal = vec3(n0.x,n0.y,n0.z);

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);


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;
hitValue = vec3(1,1,1) * 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, 0, 0, 1, origin, tmin, lightVector, tmax, 2);
if (shadowed) {
	hitValue *= 0.3;
}

//vec3 index3 = ivec3(indices.i[0], indices.i[1], indices.i[2]);
//uint idx0 = uint(indices.i[2]);
//hitValue = vec3(0,0,(idx0-2));
//hitValue = vec3(0,0, v0.pos.y);

}

[Tetane]

@WdsPjm Thank you for your answer. This was very helpful!
In the C++ code, did you use VSG to read a glTF file? How did you extract the vertex position, normal and color from the scene?

[robertosfield]

To find the vertex, normal, color data etc. you can write a visitor that finds all the vsg::VertexDraw, VertexIndexDraw and Geometry node. Have a look at the vsg::ComputeBounds visitor for example.

I would also recommend just writing the file out to .vsgt and inspecting it in an editor so you can see all the nodes that have been created.

[WdsPjm]

The author's answer is quite correct. I am currently only in the testing phase, modifying the code of vsg's acceleration structure. From the acceleration structure. This is only for temporary use. The author's way is right. Here's how I do it,