Settle on the encoding of a keyframe

Also a TODO

Author: devshgraphicsprogramming

include/nbl/builtin/glsl/format/constants.glsl

@@ -16,4 +16,18 @@
 #define nbl_glsl_RGB19E7_COMPONENT_BITOFFSETS ivec4(0,nbl_glsl_RGB19E7_MANTISSA_BITS,(2*nbl_glsl_RGB19E7_MANTISSA_BITS)&31,(3*nbl_glsl_RGB19E7_MANTISSA_BITS)&31)
 #define nbl_glsl_RGB19E7_G_COMPONENT_SPLIT (32-nbl_glsl_RGB19E7_MANTISSA_BITS)
 
+//rgb18e7s3, out custom 3 channel, shared exponent signed floating point format
+#define nbl_glsl_RGB18E7S3_MANTISSA_BITS 18
+#define nbl_glsl_RGB18E7S3_EXPONENT_BITS nbl_glsl_RGB19E7_EXPONENT_BITS
+#define nbl_glsl_RGB18E7S3_EXP_BIAS nbl_glsl_RGB19E7_EXP_BIAS
+#define nbl_glsl_MAX_RGB18E7S3_EXP (nbl_glsl_RGB18E7S3_EXP_BIAS+1)
+
+#define nbl_glsl_MAX_RGB18E7S3_MANTISSA_VALUES (0x1<<nbl_glsl_RGB18E7S3_MANTISSA_BITS)
+#define nbl_glsl_MAX_RGB18E7S3_MANTISSA (nbl_glsl_MAX_RGB18E7S3_MANTISSA_VALUES-1)
+#define nbl_glsl_MAX_RGB18E7S3 float(nbl_glsl_MAX_RGB18E7S3_MANTISSA)/float(nbl_glsl_MAX_RGB18E7S3_MANTISSA_VALUES)*exp2(float(nbl_glsl_MAX_RGB18E7S3_EXP))
+
+#define nbl_glsl_RGB18E7S3_COMPONENT_INDICES nbl_glsl_RGB19E7_COMPONENT_INDICES
+#define nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS ivec4(0,nbl_glsl_RGB18E7S3_MANTISSA_BITS,(2*nbl_glsl_RGB18E7S3_MANTISSA_BITS)&31,(3*nbl_glsl_RGB18E7S3_MANTISSA_BITS)&31)
+#define nbl_glsl_RGB18E7S3_G_COMPONENT_SPLIT (32-nbl_glsl_RGB18E7S3_MANTISSA_BITS)
+
 #endif

include/nbl/builtin/glsl/format/decode.glsl

@@ -22,6 +22,28 @@ vec3 nbl_glsl_decodeRGB19E7(in uvec2 x)
 	return v*scale;
 }
 
+vec3 nbl_glsl_decodeRGB18E7S3(in uvec2 x)
+{
+	int exp = int(bitfieldExtract(x[nbl_glsl_RGB18E7S3_COMPONENT_INDICES[3]], nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS[3], nbl_glsl_RGB18E7S3_EXPONENT_BITS) - nbl_glsl_RGB18E7S3_EXP_BIAS - nbl_glsl_RGB18E7S3_MANTISSA_BITS);
+	float scale = exp2(float(exp));
+	
+	vec3 v;
+	v.x = float(bitfieldExtract(x[nbl_glsl_RGB18E7S3_COMPONENT_INDICES[0]], nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS[0], nbl_glsl_RGB18E7S3_MANTISSA_BITS));
+	v.y = float(bitfieldInsert(
+		bitfieldExtract(x[nbl_glsl_RGB18E7S3_COMPONENT_INDICES[1]], nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS[1], nbl_glsl_RGB18E7S3_G_COMPONENT_SPLIT),
+		bitfieldExtract(x[nbl_glsl_RGB18E7S3_COMPONENT_INDICES[2]], 0, nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS[2]),
+		nbl_glsl_RGB18E7S3_G_COMPONENT_SPLIT,
+		nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS[2]
+	));
+	v.z = float(bitfieldExtract(x[nbl_glsl_RGB18E7S3_COMPONENT_INDICES[2]], nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS[2], nbl_glsl_RGB18E7S3_MANTISSA_BITS));
+	
+	uvec3 signs = x.yyy<<uvec3(2u,1u,0u);
+	signs &= 0x80000000u;
+	v = uintBitsToFloat(floatBitsToUint(v)^signs);
+
+	return v*scale;
+}
+
 vec4 nbl_glsl_decodeRGB10A2(in uint x)
 {
 	const uvec3 rgbMask = uvec3(0x3ffu);

include/nbl/builtin/glsl/format/encode.glsl

@@ -3,20 +3,28 @@
 
 #include <nbl/builtin/glsl/format/constants.glsl>
 
+void nbl_glsl_impl_sharedExponentEncodeCommon(in vec3 clamped, in int newExpBias, in int newMaxExp, in int mantissaBits, out int shared_exp)
+{
+	maxrgb = max(max(clamped.r,clamped.g),clamped.b);
+	// TODO: optimize this
+	const int f32_exp = ((floatBitsToInt(maxrgb)>>23) & 0xff) - 126;
+
+	shared_exp = clamp(f32_exp,-newExpBias,newMaxExp+1);
+	
+	float scale = exp2(mantissaBits-shared_exp);
+	const uint maxm = uint(maxrgb*scale + 0.5);
+	const bool need = maxm==(0x1u<<mantissaBits);
+	scale = need ? 0.5*scale:scale;
+	shared_exp = need ? (shared_exp+1):shared_exp;
+	const uvec3 mantissas = uvec3(clamped*scale + vec3(0.5));
+}
+
 uvec2 nbl_glsl_encodeRGB19E7(in vec3 col)
 {
 	const vec3 clamped = clamp(col,vec3(0.0),vec3(nbl_glsl_MAX_RGB19E7));
-	const float maxrgb = max(max(clamped.r,clamped.g),clamped.b);
 
-	const int f32_exp = ((floatBitsToInt(maxrgb)>>23) & 0xff) - 127;
-	int shared_exp = clamp(f32_exp,-nbl_glsl_RGB19E7_EXP_BIAS-1,nbl_glsl_MAX_RGB19E7_EXP) + 1;
-
-	float scale = exp2(nbl_glsl_RGB19E7_MANTISSA_BITS - shared_exp);
-	const uint maxm = uint(maxrgb*scale + 0.5);
-	const bool need = (maxm == nbl_glsl_MAX_RGB19E7_MANTISSA_VALUES);
-	scale = need ? 0.5*scale : scale;
-	shared_exp = need ? (shared_exp+1) : shared_exp;
-	const uvec3 mantissas = uvec3(clamped*scale + 0.5);
+	int shared_exp;
+	const uvec3 mantissas = nbl_glsl_impl_sharedExponentEncodeCommon(clamped,nbl_glsl_RGB19E7_EXP_BIAS,nbl_glsl_MAX_RGB19E7_EXP,nbl_glsl_RGB19E7_MANTISSA_BITS,shared_exp);
 
 	uvec2 encoded;
 	encoded.x = bitfieldInsert(mantissas.x,mantissas.y,nbl_glsl_RGB19E7_COMPONENT_BITOFFSETS[1],nbl_glsl_RGB19E7_G_COMPONENT_SPLIT);
@@ -30,6 +38,30 @@ uvec2 nbl_glsl_encodeRGB19E7(in vec3 col)
 	return encoded;
 }
 
+uvec2 nbl_glsl_encodeRGB18E7S3(in vec3 col)
+{
+	const vec3 absCol = abs(col);
+	const vec3 clamped = min(absCol,vec3(nbl_glsl_MAX_RGB18E7S3));
+
+	int shared_exp;
+	const uvec3 mantissas = nbl_glsl_impl_sharedExponentEncodeCommon(clamped,nbl_glsl_RGB18E7S3_EXP_BIAS,nbl_glsl_MAX_RGB18E7S3_EXP,nbl_glsl_RGB18E7S3_MANTISSA_BITS,shared_exp);
+
+	uvec3 signs = floatBitsToUint(col)&0x80000000u;
+	signs.xy >>= uvec2(2u,1u);
+
+	uvec2 encoded;
+	encoded.x = bitfieldInsert(mantissas.x,mantissas.y,nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS[1],nbl_glsl_RGB18E7S3_G_COMPONENT_SPLIT);
+	encoded.y = bitfieldInsert(
+		mantissas.y>>nbl_glsl_RGB18E7S3_G_COMPONENT_SPLIT,
+		mantissas.z,
+		nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS[2],
+		nbl_glsl_RGB18E7S3_MANTISSA_BITS)
+	| uint((shared_exp+nbl_glsl_RGB18E7S3_EXP_BIAS)<<nbl_glsl_RGB18E7S3_COMPONENT_BITOFFSETS[3])
+	| signs.x | signs.y | signs.z;
+
+	return encoded;
+}
+
 uint nbl_glsl_encodeRGB10A2(in vec4 col)
 {
 	const uvec3 rgbMask = uvec3(0x3ffu);

include/nbl/builtin/glsl/scene/animations.glsl

@@ -2,22 +2,38 @@
 #define _NBL_GLSL_SCENE_ANIMATIONS_INCLUDED_
 
 
-
 #include <nbl/builtin/glsl/math/keyframe.glsl>
 
 
+struct nbl_glsl_scene_Animation_t
+{
+	uint keyframeOffset; // same offset for timestamps and keyframes
+	uint keyframesCount_interpolationMode; // 2 bits for interpolation mode
+};
 
-struct nbl_glsl_scene_Animations_t
+struct nbl_glsl_scene_AnimationBlend_t
 {
-	mat4x3 poseBind;
-	uint keyframesCount;
-	uint timestampsOffset;
-	// The difference between the two is because some animation formats allow for staggered keyframes
-	// i.e. not every keyframe is a tuple of (scale,rotation,translation)
-	uint interpolatedKeyframesOffset;
-	uint nonInterpolatedKeyframesOffset;
+	uint nodeTargetID;
+	uint desiredTimestamp;
+	float weight;
+	uint animationID; // or do we stick whole animation inside?
 };
 
+/*
+
+Design Idea
+
+IAnimationLibrary
+{
+
+Packs several ranges of nbl_glsl_scene_Keyframe_t and uint-ms-timestamps into a single buffer (timestamps and keyframes go into separate buffers)
+
+The packed ranges are named and stored as `map<const char*,nbl_glsl_scene_Animation_t*>`
+
+You can retrieve animations by name or ID
+
+}
 
+*/
 
 #endif

include/nbl/builtin/glsl/scene/keyframe.glsl

@@ -9,23 +9,23 @@
 
 struct nbl_glsl_scene_Keyframe_t
 {
-	uint data[9];
+	uvec2 data[3];
 };
 
 
 vec3 nbl_glsl_scene_Keyframe_t_getScale(in nbl_glsl_scene_Keyframe_t keyframe)
 {
-	return uintBitsToFloat(uvec3(keyframe.data[0],keyframe.data[1],keyframe.data[2]));
+	return nbl_glsl_decodeRGB18E7S3(keyframe.data[3]);
 }
 
 nbl_glsl_quaternion_t nbl_glsl_scene_Keyframe_t_getRotation(in nbl_glsl_scene_Keyframe_t keyframe)
 {
-	return nbl_glsl_quaternion_t_constructFromTruncated(uintBitsToFloat(uvec3(keyframe.data[3],keyframe.data[4],keyframe.data[5])));
+	return {nbl_glsl_decode8888Quaternion(keyframe.data[1][1])};
 }
 
 vec3 nbl_glsl_scene_Keyframe_t_getTranslation(in nbl_glsl_scene_Keyframe_t keyframe)
 {
-	return uintBitsToFloat(uvec3(keyframe.data[6],keyframe.data[7],keyframe.data[8]));
+	return uintBitsToFloat(uvec3(keyframe.data[0].xy, keyframe.data[1][0]));
 }
 
 

include/nbl/core/math/floatutil.h

@@ -427,6 +427,7 @@ class Float16Compressor
 		}
 };
 
+// TODO: @Crisspl lets make the `rgb18e7s3` format and refactor some of this shared exponent magic
 inline uint64_t rgb32f_to_rgb19e7(const float _rgb[3])
 {
 	union rgb19e7 {