Bump version to 2.0.1; add matrix uniform overrides

Bump project version to 2.0.1 (VERSION and APP_VERSION). Add uniform_component_count helper in src/gl/program.cpp and use it to correctly compare and copy uniform value arrays for all scalar, vector and matrix GL types. Extend input override handling in src/runtime/sequence.cpp to accept float/double matrix types. Update compute shader and tests: add matrix and vector input uniforms to tests/shaders/input_override.comp and extend C++ and Python smoke tests to verify numeric overrides (vector and matrix cases) for prepared workflows. Overall this enables numeric overrides for matrix uniforms and adds tests to validate the behavior.

Author: ssh4net

VERSION

@@ -1 +1 @@
-2.0.0
+2.0.1

src/core/context.cpp

@@ -22,7 +22,7 @@
 
 const char* APP_NAME    = "RawGL";
 const char* APP_AUTHOR  = "Erium Vladlen";
-const int APP_VERSION[] = { 2, 0, 0 };
+const int APP_VERSION[] = { 2, 0, 1 };
 
 namespace rawgl {
 

src/gl/program.cpp

@@ -26,6 +26,52 @@ trim_glsl_array_suffix(char* name, GLsizei length)
         *split = '\0';
     }
 }
+
+GLsizei
+uniform_component_count(const GLenum type)
+{
+    switch (type) {
+    case GL_BOOL:
+    case GL_INT:
+    case GL_UNSIGNED_INT:
+    case GL_FLOAT:
+    case GL_DOUBLE: return 1;
+    case GL_BOOL_VEC2:
+    case GL_INT_VEC2:
+    case GL_UNSIGNED_INT_VEC2:
+    case GL_FLOAT_VEC2:
+    case GL_DOUBLE_VEC2: return 2;
+    case GL_BOOL_VEC3:
+    case GL_INT_VEC3:
+    case GL_UNSIGNED_INT_VEC3:
+    case GL_FLOAT_VEC3:
+    case GL_DOUBLE_VEC3: return 3;
+    case GL_BOOL_VEC4:
+    case GL_INT_VEC4:
+    case GL_UNSIGNED_INT_VEC4:
+    case GL_FLOAT_VEC4:
+    case GL_DOUBLE_VEC4:
+    case GL_FLOAT_MAT2:
+    case GL_DOUBLE_MAT2: return 4;
+    case GL_FLOAT_MAT2x3:
+    case GL_FLOAT_MAT3x2:
+    case GL_DOUBLE_MAT2x3:
+    case GL_DOUBLE_MAT3x2: return 6;
+    case GL_FLOAT_MAT2x4:
+    case GL_FLOAT_MAT4x2:
+    case GL_DOUBLE_MAT2x4:
+    case GL_DOUBLE_MAT4x2: return 8;
+    case GL_FLOAT_MAT3:
+    case GL_DOUBLE_MAT3: return 9;
+    case GL_FLOAT_MAT3x4:
+    case GL_FLOAT_MAT4x3:
+    case GL_DOUBLE_MAT3x4:
+    case GL_DOUBLE_MAT4x3: return 12;
+    case GL_FLOAT_MAT4:
+    case GL_DOUBLE_MAT4: return 16;
+    default: return 1;
+    }
+}
 }  // namespace
 
 //
@@ -60,19 +106,20 @@ void
 GLProgramUniform::set(const GLint* values)
 {
     int i;
+    const GLsizei valueCount = uniform_component_count(type);
 
     if (isSet) {
-        for (i = 0; i < size; i++) {
+        for (i = 0; i < valueCount; i++) {
             if (ints[i] != values[i])
                 break;
         }
 
-        if (i == size)
+        if (i == valueCount)
             return;
     } else
         isSet = true;
 
-    for (i = 0; i < size; i++)
+    for (i = 0; i < valueCount; i++)
         ints[i] = values[i];
 
     switch (type) {
@@ -115,19 +162,20 @@ void
 GLProgramUniform::set(const GLuint* values)
 {
     int i;
+    const GLsizei valueCount = uniform_component_count(type);
 
     if (isSet) {
-        for (i = 0; i < size; i++) {
+        for (i = 0; i < valueCount; i++) {
             if (uints[i] != values[i])
                 break;
         }
 
-        if (i == size)
+        if (i == valueCount)
             return;
     } else
         isSet = true;
 
-    for (i = 0; i < size; i++)
+    for (i = 0; i < valueCount; i++)
         uints[i] = values[i];
 
     switch (type) {
@@ -157,19 +205,20 @@ void
 GLProgramUniform::set(const GLfloat* values)
 {
     int i;
+    const GLsizei valueCount = uniform_component_count(type);
 
     if (isSet) {
-        for (i = 0; i < size; i++) {
+        for (i = 0; i < valueCount; i++) {
             if (floats[i] != values[i])
                 break;
         }
 
-        if (i == size)
+        if (i == valueCount)
             return;
     } else
         isSet = true;
 
-    for (i = 0; i < size; i++)
+    for (i = 0; i < valueCount; i++)
         floats[i] = values[i];
 
     // setting uniform variables in current program
@@ -209,19 +258,20 @@ void
 GLProgramUniform::set(const GLdouble* values)
 {
     int i;
+    const GLsizei valueCount = uniform_component_count(type);
 
     if (isSet) {
-        for (i = 0; i < size; i++) {
+        for (i = 0; i < valueCount; i++) {
             if (doubles[i] != values[i])
                 break;
         }
 
-        if (i == size)
+        if (i == valueCount)
             return;
     } else
         isSet = true;
 
-    for (i = 0; i < size; i++)
+    for (i = 0; i < valueCount; i++)
         doubles[i] = values[i];
 
     // setting uniform variables in current program

src/runtime/sequence.cpp

@@ -1045,6 +1045,15 @@ Sequence::bindPassInputs(const PassExecutionPlan& plan,
         case GL_FLOAT_VEC2:
         case GL_FLOAT_VEC3:
         case GL_FLOAT_VEC4:
+        case GL_FLOAT_MAT2:
+        case GL_FLOAT_MAT2x3:
+        case GL_FLOAT_MAT2x4:
+        case GL_FLOAT_MAT3:
+        case GL_FLOAT_MAT3x2:
+        case GL_FLOAT_MAT3x4:
+        case GL_FLOAT_MAT4:
+        case GL_FLOAT_MAT4x2:
+        case GL_FLOAT_MAT4x3:
             if (inputOverride && inputOverride->kind == SequenceExecutionInputOverrideKind::floatValues) {
                 if (input.usesArrayElement) {
                     set_addressed_float_uniform(input, inputOverride->floatValues.data());
@@ -1063,6 +1072,15 @@ Sequence::bindPassInputs(const PassExecutionPlan& plan,
         case GL_DOUBLE_VEC2:
         case GL_DOUBLE_VEC3:
         case GL_DOUBLE_VEC4:
+        case GL_DOUBLE_MAT2:
+        case GL_DOUBLE_MAT2x3:
+        case GL_DOUBLE_MAT2x4:
+        case GL_DOUBLE_MAT3:
+        case GL_DOUBLE_MAT3x2:
+        case GL_DOUBLE_MAT3x4:
+        case GL_DOUBLE_MAT4:
+        case GL_DOUBLE_MAT4x2:
+        case GL_DOUBLE_MAT4x3:
             if (inputOverride && inputOverride->kind == SequenceExecutionInputOverrideKind::doubleValues) {
                 if (input.usesArrayElement) {
                     set_addressed_double_uniform(input, inputOverride->doubleValues.data());

tests/python/rawgl_python_import_smoke.py

@@ -13,7 +13,7 @@ def fail(message: str) -> int:
 
 
 def main() -> int:
-    if rawgl.__version__ != "2.0.0":
+    if rawgl.__version__ != "2.0.1":
         return fail(f"unexpected rawgl.__version__: {rawgl.__version__}")
 
     status = rawgl.status()

tests/python/rawgl_python_workflow_smoke.py

@@ -106,6 +106,23 @@ def verify_inline_lut(session: rawgl.Session) -> int:
 }
 """
 
+
+INLINE_PREPARED_OVERRIDE_COMPUTE = """#version 450 core
+layout(local_size_x = 1, local_size_y = 1) in;
+layout(binding = 0, rgba32f) uniform writeonly image2D o_out0;
+
+uniform float gain;
+uniform vec3 bias;
+uniform mat3 transform;
+
+void main()
+{
+    vec3 value = transform * vec3(gain, gain, gain) + bias;
+    imageStore(o_out0, ivec2(0, 0), vec4(value, 1.0));
+}
+"""
+
+
 def verify_inline_host_counter(session: rawgl.Session) -> int:
     source_input = rawgl.make_rgba32f_host_image(1, 1, [0.25, 0.5, 0.75, 1.0])
     if np is not None:
@@ -149,6 +166,78 @@ def verify_inline_host_counter(session: rawgl.Session) -> int:
     return 0
 
 
+def verify_prepared_numeric_overrides(session: rawgl.Session) -> int:
+    prepared = rawgl.prepare_compute(
+        INLINE_PREPARED_OVERRIDE_COMPUTE,
+        session=session,
+        size=(1, 1),
+        workgroup_size=(1, 1),
+        verbosity=0,
+        inputs={
+            "gain": 0.25,
+            "bias": [0.0, 0.0, 0.0],
+            "transform": [
+                1.0, 0.0, 0.0,
+                0.0, 1.0, 0.0,
+                0.0, 0.0, 1.0,
+            ],
+        },
+        outputs={
+            "o_out0": {
+                "format": "rgba32f",
+                "channels": 4,
+                "alpha_channel": 3,
+                "bits": 16,
+                "capture_to_host": True,
+            },
+        },
+    )
+
+    def check(label: str, result: rawgl.RunResultView, expected: list[float]) -> int:
+        if not result.success:
+            return fail(f"{label} prepared override workflow failed: {result.error_message}")
+        image = result.captured_outputs.get("o_out0::0")
+        if image is None:
+            return fail(f"{label} prepared override workflow did not capture o_out0::0")
+        values = rawgl.host_image_to_rgba32f(image)
+        if len(values) != 4 or any(
+            not math.isclose(values[i], expected[i], rel_tol=0.0, abs_tol=1e-6)
+            for i in range(4)
+        ):
+            return fail(f"{label} prepared override output mismatch: {values}")
+        return 0
+
+    status = check("default", prepared.run(), [0.25, 0.25, 0.25, 1.0])
+    if status != 0:
+        return status
+
+    status = check(
+        "vector",
+        prepared.run(inputs={"bias": [0.0, 0.125, 0.25]}),
+        [0.25, 0.375, 0.5, 1.0],
+    )
+    if status != 0:
+        return status
+
+    status = check(
+        "matrix",
+        prepared.run(
+            inputs={
+                "transform": [
+                    1.0, 0.0, 0.0,
+                    0.0, 2.0, 0.0,
+                    0.0, 0.0, 3.0,
+                ],
+            }
+        ),
+        [0.25, 0.5, 0.75, 1.0],
+    )
+    if status != 0:
+        return status
+
+    return 0
+
+
 def verify_system_uniform_mapping(session: rawgl.Session) -> int:
     result = rawgl.compute(
         "tests/shaders/system_uniforms.comp",
@@ -227,6 +316,10 @@ def main() -> int:
     if status != 0:
         return status
 
+    status = verify_prepared_numeric_overrides(session)
+    if status != 0:
+        return status
+
     status = verify_system_uniform_mapping(session)
     if status != 0:
         return status