Help Request: How to Skin a Mesh, Passing Indices to Shader

[SnapperTT]

Vertex Def:

struct RiggedVertex {
	VertElements::Pos pos;            // struct { float mv[3]; }, with some setter's
	VertElements::Normal normal; // struct { uint32 mv; }, with some setter's 
	VertElements::Normal tangent; // etc
	VertElements::BoneIndicies boneIndices;
	VertElements::BoneWeights boneWeights;
	VertElements::TexCoord texCoord;
	
	inline RiggedVertex () {};
	
	RiggedVertex (const WObj_Vector & _pos, const WObj_Vector & _normal, const WObj_Vector & _tangent, const WObj_BoneInfo & bi, const WObj_TexCoord & _tc) {
		pos.set(_pos);
		normal.set(_normal);
		tangent.set(_tangent);
		boneIndices.set(bi.boneIndices[0], bi.boneIndices[1], bi.boneIndices[2], bi.boneIndices[3]);
		//boneIndices.set(5,10,15,20);
		boneWeights.set(bi.boneWeights[0], bi.boneWeights[1], bi.boneWeights[2], bi.boneWeights[3]);
		texCoord.set(_tc);
		}
		
	static void init() {
		ms_decl.begin()
			.add(bgfx::Attrib::Position,  3, bgfx::AttribType::Float)
			.add(bgfx::Attrib::Normal,    4, bgfx::AttribType::Uint8, true, true)
			.add(bgfx::Attrib::Tangent,   4, bgfx::AttribType::Uint8, true, true)
			.add(bgfx::Attrib::Indices,   4, bgfx::AttribType::Uint8, false, true)	// indicies should not be normalised!
			.add(bgfx::Attrib::Weight,    4, bgfx::AttribType::Uint8, true, true)
			.add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Int16, true, true)
		.end();
		}

	static bgfx::VertexLayout ms_decl;
	};

Varying.def:

vec2 v_texcoord0  : TEXCOORD0 = vec2(0.0, 0.0);
vec4 v_color0     : COLOR0    = vec4(1.0, 0.0, 0.0, 1.0);
vec3 v_normal     : NORMAL    = vec3(0.0, 0.0, 1.0);
vec3 v_tangent    : TANGENT   = vec3(1.0, 0.0, 0.0);
vec3 v_bitangent  : BITANGENT = vec3(0.0, 1.0, 0.0);
vec3 v_pos        : TEXCOORD1 = vec3(0.0, 0.0, 0.0);

vec3 a_position   : POSITION;
vec3 a_normal     : NORMAL;
vec3 a_tangent    : TANGENT;
vec4 a_color0     : COLOR0;
vec2 a_texcoord0  : TEXCOORD0;
ivec4 a_indices : BLENDINDICES;
vec4 a_weight   : BLENDWEIGHT;

Vertex shader:

void main() {
	#ifdef BONES
		ivec4 b_indices = a_indices;
		vec4 b_weight = a_weight;
		
		//vec4 b_indices = a_indices*255; // vec4 indicies
		//b_weight = vec4(1,0,0,0); // Test weight
		//b_indices = ivec4(20,20,20,20); // Test forcing index
		//b_indices = ivec4(mod(u_frametime.y/20, 22), 0,0,0); // make sure all mats are sane by iterating them
		
		if (mod(u_frametime.y, 100) < 50) {
			//b_indices = ivec4(5,10,15,20);
		}
		//b_indices = vec4(1,1,1,1);
		
		mat4 boneMat = b_weight.x * u_model[int(b_indices.x)];
		boneMat += b_weight.y * u_model[int(b_indices.y)];
		boneMat += b_weight.z * u_model[int(b_indices.z)];
		boneMat += b_weight.w * u_model[int(b_indices.w)];
		
		vec4 aPos4 = mul(boneMat, vec4(a_position, 1.0));
		gl_Position = mul(u_viewProj, aPos4);
	#else
		vec4 aPos4 = vec4(a_position, 1.0);
		gl_Position = mul(u_modelViewProj, aPos4);
	#endif

	... etc

Bone matrices are multiplied by the model matrix on the C++ side.

float uniforms[32*16];
for (int i = 0; i < tri.nBones; ++i) {
	bx::mtxMul(&uniforms[i*16], &tri.riggedUniforms[i*16], tri.bgfxModelMtx);
	}
bgfx::setTransform(uniforms, tri.nBones);

My model is a rigged man standing in a near-t pose with legs spread. I'm trying to move the legs in and arms to the side.

I believe I've isolated the problem to a_indices. Here are some tests/observations I've done:

• The model does not appear
• If I force a_indices to be a specific value in the shader, eg b_indices = ivec4(5,10,15,20);, the model renders in a believable state.
• I can iterate through all 22 bone matrices and the model is renders fine with an appropriate transform. b_indices = ivec4(mod(u_frametime.y/20, 22), 0,0,0);. So the bone matrices are well-defined.
• Now if I try to set a_indices to type vec4 (ie, float). The model renders, but is mangled (it looks like it could be over-transformed - legs are crossed as opposed to being moved in slightly).
• Now if I set boneIndices.set(5,10,15,20); on the C++ side the output matches the b_indices = ivec4(5,10,15,20);
• If I transform the verts using the bone mats manually in c++ and skip the bone transformation in the shader (glPosition = mvp*a_position) I get the desired output (so the bone transforms are known to be well-defined).

Questions:

• I would like to use uint8 to define bone indices. Am I doing this correctly?
• Are there any hints as to what on earth I'm doing incorrectly?

[pezcode]

What happens when you use uvec4 for the indices?

Is this specific to one renderer, or is it consistent across multiple backends?

[SnapperTT]

EDIT: I think I found the issue - ivec4 is broken on my discrete gpu and is possibly engaging in undefined behavior on my igpu. Using vec4 in my varying.def allows me to get consistent results with both float and int a_indices. My model is still mangled, but its consistently mangled, which I suspect means that the matrices are not being calculated correctly.

---

Original message:
I've only tested opengl as I'm on a linux machine with bumblebee gpu switching (this doesn't support vulkan).

uvec4 fails to compile shader:

Code:
---
      1: #version 120
      2: #define bgfxShadow2D     shadow2D
      3: #define bgfxShadow2DProj shader2DProj
      4: // shaderc command line:
      5: // ../tools/shadercRelease -f src/_tempvert.sc -o ./glsl/vs_forward_bones.bin --varyingdef src/_tempvarying.def.sc --type v -i . -i include/ -i ../include/ -i ../../include/ --platform linux -p 120 --define FORWARD;BONES
      6: 

      7: attribute vec4 a_color0;

>>>   8: attribute uvec4 a_indices;
>>>  11:           ^

      9: attribute vec3 a_normal;
     10: attribute vec3 a_position;
     11: attribute vec3 a_tangent;
     12: attribute vec2 a_texcoord0;
     13: attribute vec4 a_weight;
     14: varying vec3 v_bitangent;
     15: varying vec4 v_color0;
     16: varying vec3 v_normal;
     17: varying vec3 v_pos;
     18: varying vec3 v_tangent;
     19: varying vec2 v_texcoord0;
     20: vec3 instMul(vec3 _vec, mat3 _mtx) { return ( (_vec) * (_mtx) ); }
---
Error: (8,11): error: syntax error, unexpected NEW_IDENTIFIER

Interestingly renderdoc reports that a_indicies has valid values for both float and int forms. The left is float, the right is int. If you look at the gl_position column you can see most of the verts are being zero'ed out with int indices.
https://media.discordapp.net/attachments/712512073522872355/876268791905026068/shaderComparison.png

The compiled shaders look identical but only with vec4 a_indices being changed to ivec4 a_indices

#version 120
#define in attribute
#define out varying
#define lowp
#define mediump
#define highp
#define centroid
#define flat
#define noperspective
#define smooth
attribute ivec4 a_indices;
attribute vec3 a_normal;
attribute vec3 a_position;
attribute vec3 a_tangent;
attribute vec2 a_texcoord0;
attribute vec4 a_weight;
varying vec3 v_bitangent;
varying vec3 v_normal;
varying vec3 v_pos;
varying vec3 v_tangent;
varying vec2 v_texcoord0;
uniform mat4 u_view;
uniform mat4 u_viewProj;
uniform mat4 u_model[32];
uniform mat4 u_modelView;
void main ()
{
  vec3 n_1;
  vec3 t_2;
  mat4 boneMat_3;
  boneMat_3 = ((a_weight.x * u_model[a_indices.x]) + (a_weight.y * u_model[a_indices.y]));
  boneMat_3 = (boneMat_3 + (a_weight.z * u_model[a_indices.z]));
  boneMat_3 = (boneMat_3 + (a_weight.w * u_model[a_indices.w]));
  vec4 tmpvar_4;
  tmpvar_4.w = 1.0;
  tmpvar_4.xyz = a_position;
  vec4 tmpvar_5;
  tmpvar_5 = (boneMat_3 * tmpvar_4);
  gl_Position = (u_viewProj * tmpvar_5);
  v_pos = (u_modelView * tmpvar_5).xyz;
  v_texcoord0 = a_texcoord0;
  vec4 tmpvar_6;
  tmpvar_6.w = 0.0;
  tmpvar_6.xyz = ((a_tangent * 2.0) - 1.0);
  t_2 = (u_view * (boneMat_3 * tmpvar_6)).xyz;
  vec4 tmpvar_7;
  tmpvar_7.w = 0.0;
  tmpvar_7.xyz = ((a_normal * 2.0) - 1.0);
  n_1 = (u_view * (boneMat_3 * tmpvar_7)).xyz;
  v_normal = n_1;
  v_tangent = t_2;
  v_bitangent = ((n_1.yzx * t_2.zxy) - (n_1.zxy * t_2.yzx));
}

These test were run on my igpu. Running on my discrete gpu results in a shader compile error:

../../../src/renderer_gl.cpp (6496): BGFX 0x00000001: Failed to compile shader. 0: 0(11) : error C7507: OpenGL does not allow attributes of type ivec4

[bkaradzic]

Bump the profile to 130.

[SnapperTT]

For those playing at home, my problem here was that model was mangled due to the matrices needing to be transposed. Bumping the profile from 120 to 130 was not required

Here is the render with the issue corrected:
https://media.discordapp.net/attachments/712512073522872355/876706594317017128/2021-08-16-working_bones_shader.png

New Problem

Now I'm rendering this using the Vulkan backend. With the following, bone indices work correctly in OpenGL but do not work in Vulkan

Vertex Decl (same as before)

	static void init() {
		ms_decl.begin()
			.add(bgfx::Attrib::Position,  3, bgfx::AttribType::Float)
			.add(bgfx::Attrib::Normal,    4, bgfx::AttribType::Uint8, true, true)
			.add(bgfx::Attrib::Tangent,   4, bgfx::AttribType::Uint8, true, true)
			.add(bgfx::Attrib::Indices,   4, bgfx::AttribType::Uint8, false, true)	// indicies should not be normalised!
			//.add(bgfx::Attrib::Indices,   4, bgfx::AttribType::Float)
			.add(bgfx::Attrib::Weight,    4, bgfx::AttribType::Uint8, true, true)
			.add(bgfx::Attrib::TexCoord0, 2, bgfx::AttribType::Int16, true, true)
		.end();
		}

Inspecting values in RenderDoc - it looks like indices are being correctly sent, but the shader is reading nonsense values

Indices being set to non-nonsense values:

14, 15, 18, 0 are being mapped to 1.96182E-44, 2.10195E-44, 2.52234E-44, 0.00:

Replacing .add(bgfx::Attrib::Indices, 4, bgfx::AttribType::Uint8, false, true) with .add(bgfx::Attrib::Indices, 4, bgfx::AttribType::Float) makes things work correctly, but I'm trying to work out why Uint8 indices do not work with Vulkan.

EDIT: Normalising uint8's (.add(bgfx::Attrib::Indices, 4, bgfx::AttribType::Uint8, true, true)) and multiplying by 255 in the shader also works, but again I would rather use unnormalised uint8's if possible.