[Mesa-dev] [PATCH 04/16] mesa: create copy uniform to storage helpers

Timothy Arceri tarceri at itsqueeze.com
Tue Jun 20 01:50:33 UTC 2017


These will be used in the following patch to allow copying directly
to the param list when packing is enabled.
---
 src/mesa/main/uniform_query.cpp | 154 ++++++++++++++++++++++++----------------
 1 file changed, 91 insertions(+), 63 deletions(-)

diff --git a/src/mesa/main/uniform_query.cpp b/src/mesa/main/uniform_query.cpp
index eea5db5..75d9df4 100644
--- a/src/mesa/main/uniform_query.cpp
+++ b/src/mesa/main/uniform_query.cpp
@@ -998,20 +998,56 @@ validate_uniform(GLint location, GLsizei count, const GLvoid *values,
                         location);
             return NULL;
          }
       }
    }
 
    return uni;
 }
 
 
+static void
+copy_uniforms_to_storage(struct gl_uniform_storage *uni,
+                         struct gl_context *ctx, GLsizei count,
+                         const GLvoid *values, const int size_mul,
+                         const unsigned offset, const unsigned components,
+                         enum glsl_base_type basicType)
+{
+   if (!uni->type->is_boolean() && !uni->is_bindless) {
+      memcpy(&uni->storage[size_mul * components * offset], values,
+             sizeof(uni->storage[0]) * components * count * size_mul);
+   } else if (uni->is_bindless) {
+      const union gl_constant_value *src =
+         (const union gl_constant_value *) values;
+      GLuint64 *dst = (GLuint64 *)&uni->storage[components * offset].i;
+      const unsigned elems = components * count;
+
+      for (unsigned i = 0; i < elems; i++) {
+         dst[i] = src[i].i;
+      }
+   } else {
+      const union gl_constant_value *src =
+         (const union gl_constant_value *) values;
+      union gl_constant_value *dst = &uni->storage[components * offset];
+      const unsigned elems = components * count;
+
+      for (unsigned i = 0; i < elems; i++) {
+         if (basicType == GLSL_TYPE_FLOAT) {
+            dst[i].i = src[i].f != 0.0f ? ctx->Const.UniformBooleanTrue : 0;
+         } else {
+            dst[i].i = src[i].i != 0    ? ctx->Const.UniformBooleanTrue : 0;
+         }
+      }
+   }
+}
+
+
 /**
  * Called via glUniform*() functions.
  */
 extern "C" void
 _mesa_uniform(GLint location, GLsizei count, const GLvoid *values,
               struct gl_context *ctx, struct gl_shader_program *shProg,
               enum glsl_base_type basicType, unsigned src_components)
 {
    unsigned offset;
    int size_mul = glsl_base_type_is_64bit(basicType) ? 2 : 1;
@@ -1059,46 +1095,22 @@ _mesa_uniform(GLint location, GLsizei count, const GLvoid *values,
    }
 
    FLUSH_VERTICES(ctx, 0);
 
    if (uni->is_bindless || !uni->type->contains_opaque()) {
       ctx->NewState |= _NEW_PROGRAM_CONSTANTS;
    }
 
    /* Store the data in the "actual type" backing storage for the uniform.
     */
-   if (!uni->type->is_boolean() && !uni->is_bindless) {
-      memcpy(&uni->storage[size_mul * components * offset], values,
-             sizeof(uni->storage[0]) * components * count * size_mul);
-   } else if (uni->is_bindless) {
-      const union gl_constant_value *src =
-         (const union gl_constant_value *) values;
-      GLuint64 *dst = (GLuint64 *)&uni->storage[components * offset].i;
-      const unsigned elems = components * count;
-
-      for (unsigned i = 0; i < elems; i++) {
-         dst[i] = src[i].i;
-      }
-   } else {
-      const union gl_constant_value *src =
-         (const union gl_constant_value *) values;
-      union gl_constant_value *dst = &uni->storage[components * offset];
-      const unsigned elems = components * count;
-
-      for (unsigned i = 0; i < elems; i++) {
-         if (basicType == GLSL_TYPE_FLOAT) {
-            dst[i].i = src[i].f != 0.0f ? ctx->Const.UniformBooleanTrue : 0;
-         } else {
-            dst[i].i = src[i].i != 0    ? ctx->Const.UniformBooleanTrue : 0;
-         }
-      }
-   }
+   copy_uniforms_to_storage(uni, ctx, count, values, size_mul, offset,
+                            components, basicType);
 
    _mesa_propagate_uniforms_to_driver_storage(uni, offset, count);
 
    /* If the uniform is a sampler, do the extra magic necessary to propagate
     * the changes through.
     */
    if (uni->type->is_sampler()) {
       bool flushed = false;
 
       shProg->SamplersValidated = GL_TRUE;
@@ -1176,20 +1188,70 @@ _mesa_uniform(GLint location, GLsizei count, const GLvoid *values,
             } else {
                sh->Program->sh.ImageUnits[unit] = value;
             }
          }
       }
 
       ctx->NewDriverState |= ctx->DriverFlags.NewImageUnits;
    }
 }
 
+
+static void
+copy_uniform_matrix_to_storage(struct gl_uniform_storage *const uni,
+                               GLsizei count, const void *values,
+                               const unsigned size_mul, const unsigned offset,
+                               const unsigned components,
+                               const unsigned vectors, bool transpose,
+                               unsigned cols, unsigned rows,
+                               enum glsl_base_type basicType)
+{
+   const unsigned elements = components * vectors;
+
+   if (!transpose) {
+      memcpy(&uni->storage[size_mul * elements * offset], values,
+             sizeof(uni->storage[0]) * elements * count * size_mul);
+   } else if (basicType == GLSL_TYPE_FLOAT) {
+      /* Copy and transpose the matrix.
+       */
+      const float *src = (const float *)values;
+      float *dst = &uni->storage[elements * offset].f;
+
+      for (int i = 0; i < count; i++) {
+         for (unsigned r = 0; r < rows; r++) {
+            for (unsigned c = 0; c < cols; c++) {
+               dst[(c * components) + r] = src[c + (r * vectors)];
+            }
+         }
+
+         dst += elements;
+         src += elements;
+      }
+   } else {
+      assert(basicType == GLSL_TYPE_DOUBLE);
+      const double *src = (const double *)values;
+      double *dst = (double *)&uni->storage[elements * offset].f;
+
+      for (int i = 0; i < count; i++) {
+         for (unsigned r = 0; r < rows; r++) {
+            for (unsigned c = 0; c < cols; c++) {
+               dst[(c * components) + r] = src[c + (r * vectors)];
+            }
+         }
+
+         dst += elements;
+         src += elements;
+      }
+   }
+}
+
+
 /**
  * Called by glUniformMatrix*() functions.
  * Note: cols=2, rows=4  ==>  array[2] of vec4
  */
 extern "C" void
 _mesa_uniform_matrix(GLint location, GLsizei count,
                      GLboolean transpose, const void *values,
                      struct gl_context *ctx, struct gl_shader_program *shProg,
                      GLuint cols, GLuint rows, enum glsl_base_type basicType)
 {
@@ -1275,57 +1337,23 @@ _mesa_uniform_matrix(GLint location, GLsizei count,
     * will have already generated an error.
     */
    if (uni->array_elements != 0) {
       count = MIN2(count, (int) (uni->array_elements - offset));
    }
 
    FLUSH_VERTICES(ctx, _NEW_PROGRAM_CONSTANTS);
 
    /* Store the data in the "actual type" backing storage for the uniform.
     */
-   const unsigned elements = components * vectors;
-
-   if (!transpose) {
-      memcpy(&uni->storage[size_mul * elements * offset], values,
-	     sizeof(uni->storage[0]) * elements * count * size_mul);
-   } else if (basicType == GLSL_TYPE_FLOAT) {
-      /* Copy and transpose the matrix.
-       */
-      const float *src = (const float *)values;
-      float *dst = &uni->storage[elements * offset].f;
-
-      for (int i = 0; i < count; i++) {
-	 for (unsigned r = 0; r < rows; r++) {
-	    for (unsigned c = 0; c < cols; c++) {
-	       dst[(c * components) + r] = src[c + (r * vectors)];
-	    }
-	 }
-
-	 dst += elements;
-	 src += elements;
-      }
-   } else {
-      assert(basicType == GLSL_TYPE_DOUBLE);
-      const double *src = (const double *)values;
-      double *dst = (double *)&uni->storage[elements * offset].f;
-
-      for (int i = 0; i < count; i++) {
-	 for (unsigned r = 0; r < rows; r++) {
-	    for (unsigned c = 0; c < cols; c++) {
-	       dst[(c * components) + r] = src[c + (r * vectors)];
-	    }
-	 }
-
-	 dst += elements;
-	 src += elements;
-      }
-   }
+   copy_uniform_matrix_to_storage(uni, count, values, size_mul, offset,
+                                  components, vectors, transpose, cols, rows,
+                                  basicType);
 
    _mesa_propagate_uniforms_to_driver_storage(uni, offset, count);
 }
 
 static void
 update_bound_bindless_sampler_flag(struct gl_program *prog)
 {
    unsigned i;
 
    if (likely(!prog->sh.HasBoundBindlessSampler))
-- 
2.9.4



More information about the mesa-dev mailing list