Pass index (uint16_t uint32_t) to glsl

[WdsPjm]

I wrote a visitor to get the index of the model. But there are two types of index, I'm converting both of them to uint32_t and storing them in an array, which is then given to glsl via ssbo. This results in wasted memory. I wonder if there is any other way to pass it directly to glsl without converting it to uint32_t.

[robertosfield]

The best approach depends upon hat is you end goal with this work. I don't know anything about this so I can't provide suggestion.

How does the index related to the models?

How would the shaders using this index?

[WdsPjm]

There is such a code in assimp in vsg. I read a glb model, the index has two types uint16_t and uint32_t, I want to pass these two types together to glsl via ssbo. But it is not known how these two types should be represented in a container.

[robertosfield]

Are you simply referring to the primitive indices? These aren't passed to GLSL shaders, they are simply used by the GPU to map the which vertices in the vertex arrays to pass to the vertex shaders.

Now, please take a step back and explain what you end goal is as your explanation really just isn't help us guess what on earth you are trying to do and why. It might be you have just misunderstand how Vulkan works so are heading off in the wrong direction.

[WdsPjm]

I'm sorry I didn't make myself clear.

The calculation of shadows in my ray tracing requires finding the normal for each vertex according to the index
This is my shader code

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

struct ObjectInfo
{
uint indexOffset;
uint vertexOffset;

};

layout(binding = 3, set = 0,scalar) buffer ObjectInfos { ObjectInfo objectInfos[];} objectins;
layout(binding = 4, set = 0,scalar) buffer Indices { uint16_t i[]; } indices;
layout(binding = 5, set = 0,scalar) buffer Vertices { vec3 v[]; } vertices;
layout(binding = 6, set = 0,scalar) buffer Normals { vec3 n[]; } normals;

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()
{

uint idexOffset = objectins.objectInfos[gl_InstanceID].indexOffset;
uint vertexOffset = objectins.objectInfos[gl_InstanceID].vertexOffset;

ivec3 index = ivec3(indices.i[idexOffset+ 3 * gl_PrimitiveID], indices.i[idexOffset+3 * gl_PrimitiveID + 1], indices.i[idexOffset+3 * gl_PrimitiveID + 2]);

//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+vertexOffset);
Vertex v1 = unpack(index.y+vertexOffset);
Vertex v2 = unpack(index.z+vertexOffset);





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,vertexOffset);
//hitValue = vec3(0,0, objectins.objectInfos[1].indexOffset-35);
//hitValue = normalize(index);

}