mesa/vbo: add support for 64-bit vertex attributes. (v1)

This adds support in the vbo and array code to handle
double vertex attributes.

v0.2: merge code to handle doubles in vbo layer.
v1: don't use v0, merge api_array elt code.

Acked-by: Ilia Mirkin <imirkin@alum.mit.edu>
Reviewed-by: Ian Romanick <ian.d.romanick@intel.com>
Signed-off-by: Dave Airlie <airlied@redhat.com>

5 files changed, 199 insertions, 35 deletions

diff --git a/src/mesa/vbo/vbo_attrib_tmp.h b/src/mesa/vbo/vbo_attrib_tmp.h
index 17e057836c3..e73b8fb5ff1 100644
--- a/src/mesa/vbo/vbo_attrib_tmp.h
+++ b/src/mesa/vbo/vbo_attrib_tmp.h
@@ -31,14 +31,16 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 /* ATTR */
 #define ATTRI( A, N, V0, V1, V2, V3 ) \
-    ATTR_UNION(A, N, GL_INT, INT_AS_UNION(V0), INT_AS_UNION(V1), \
+    ATTR_UNION(A, N, GL_INT, fi_type, INT_AS_UNION(V0), INT_AS_UNION(V1), \
         INT_AS_UNION(V2), INT_AS_UNION(V3))
 #define ATTRUI( A, N, V0, V1, V2, V3 ) \
-    ATTR_UNION(A, N, GL_UNSIGNED_INT, UINT_AS_UNION(V0), UINT_AS_UNION(V1), \
+    ATTR_UNION(A, N, GL_UNSIGNED_INT, fi_type, UINT_AS_UNION(V0), UINT_AS_UNION(V1), \
         UINT_AS_UNION(V2), UINT_AS_UNION(V3))
 #define ATTRF( A, N, V0, V1, V2, V3 ) \
-    ATTR_UNION(A, N, GL_FLOAT, FLOAT_AS_UNION(V0), FLOAT_AS_UNION(V1),\
+    ATTR_UNION(A, N, GL_FLOAT, fi_type, FLOAT_AS_UNION(V0), FLOAT_AS_UNION(V1),\
         FLOAT_AS_UNION(V2), FLOAT_AS_UNION(V3))
+#define ATTRD( A, N, V0, V1, V2, V3 ) \
+    ATTR_UNION(A, N, GL_DOUBLE, double, V0, V1, V2, V3)
 
 
 /* float */
@@ -232,6 +234,19 @@ static inline float conv_i2_to_norm_float(const struct gl_context *ctx, int i2)
 	 ERROR(GL_INVALID_VALUE);					\
    } while(0)
 
+
+/* Doubles */
+#define ATTR1DV( A, V ) ATTRD( A, 1, (V)[0], 0, 0, 1 )
+#define ATTR2DV( A, V ) ATTRD( A, 2, (V)[0], (V)[1], 0, 1 )
+#define ATTR3DV( A, V ) ATTRD( A, 3, (V)[0], (V)[1], (V)[2], 1 )
+#define ATTR4DV( A, V ) ATTRD( A, 4, (V)[0], (V)[1], (V)[2], (V)[3] )
+
+#define ATTR1D( A, X )          ATTRD( A, 1, X, 0, 0, 1 )
+#define ATTR2D( A, X, Y )       ATTRD( A, 2, X, Y, 0, 1 )
+#define ATTR3D( A, X, Y, Z )    ATTRD( A, 3, X, Y, Z, 1 )
+#define ATTR4D( A, X, Y, Z, W ) ATTRD( A, 4, X, Y, Z, W )
+
+
 static void GLAPIENTRY
 TAG(Vertex2f)(GLfloat x, GLfloat y)
 {
@@ -1190,6 +1205,104 @@ TAG(VertexAttribP4uiv)(GLuint index, GLenum type, GLboolean normalized,
 }
 
 
+
+static void GLAPIENTRY
+TAG(VertexAttribL1d)(GLuint index, GLdouble x)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index == 0 && _mesa_attr_zero_aliases_vertex(ctx))
+      ATTR1D(0, x);
+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
+      ATTR1D(VBO_ATTRIB_GENERIC0 + index, x);
+   else
+      ERROR(GL_INVALID_VALUE);
+}
+
+static void GLAPIENTRY
+TAG(VertexAttribL1dv)(GLuint index, const GLdouble * v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index == 0 && _mesa_attr_zero_aliases_vertex(ctx))
+      ATTR1DV(0, v);
+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
+      ATTR1DV(VBO_ATTRIB_GENERIC0 + index, v);
+   else
+      ERROR(GL_INVALID_VALUE);
+}
+
+static void GLAPIENTRY
+TAG(VertexAttribL2d)(GLuint index, GLdouble x, GLdouble y)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index == 0 && _mesa_attr_zero_aliases_vertex(ctx))
+      ATTR2D(0, x, y);
+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
+      ATTR2D(VBO_ATTRIB_GENERIC0 + index, x, y);
+   else
+      ERROR(GL_INVALID_VALUE);
+}
+
+static void GLAPIENTRY
+TAG(VertexAttribL2dv)(GLuint index, const GLdouble * v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index == 0 && _mesa_attr_zero_aliases_vertex(ctx))
+      ATTR2DV(0, v);
+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
+      ATTR2DV(VBO_ATTRIB_GENERIC0 + index, v);
+   else
+      ERROR(GL_INVALID_VALUE);
+}
+
+static void GLAPIENTRY
+TAG(VertexAttribL3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index == 0 && _mesa_attr_zero_aliases_vertex(ctx))
+      ATTR3D(0, x, y, z);
+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
+      ATTR3D(VBO_ATTRIB_GENERIC0 + index, x, y, z);
+   else
+      ERROR(GL_INVALID_VALUE);
+}
+
+static void GLAPIENTRY
+TAG(VertexAttribL3dv)(GLuint index, const GLdouble * v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index == 0 && _mesa_attr_zero_aliases_vertex(ctx))
+      ATTR3DV(0, v);
+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
+      ATTR3DV(VBO_ATTRIB_GENERIC0 + index, v);
+   else
+      ERROR(GL_INVALID_VALUE);
+}
+
+static void GLAPIENTRY
+TAG(VertexAttribL4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index == 0 && _mesa_attr_zero_aliases_vertex(ctx))
+      ATTR4D(0, x, y, z, w);
+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
+      ATTR4D(VBO_ATTRIB_GENERIC0 + index, x, y, z, w);
+   else
+      ERROR(GL_INVALID_VALUE);
+}
+
+static void GLAPIENTRY
+TAG(VertexAttribL4dv)(GLuint index, const GLdouble * v)
+{
+   GET_CURRENT_CONTEXT(ctx);
+   if (index == 0 && _mesa_attr_zero_aliases_vertex(ctx))
+      ATTR4DV(0, v);
+   else if (index < MAX_VERTEX_GENERIC_ATTRIBS)
+      ATTR4DV(VBO_ATTRIB_GENERIC0 + index, v);
+   else
+      ERROR(GL_INVALID_VALUE);
+}
+
+
 #undef ATTR1FV
 #undef ATTR2FV
 #undef ATTR3FV
diff --git a/src/mesa/vbo/vbo_context.h b/src/mesa/vbo/vbo_context.h
index 6099b56e661..a376efe34a7 100644
--- a/src/mesa/vbo/vbo_context.h
+++ b/src/mesa/vbo/vbo_context.h
@@ -146,6 +146,7 @@ vbo_attrtype_to_integer_flag(GLenum format)
 {
    switch (format) {
    case GL_FLOAT:
+   case GL_DOUBLE:
       return GL_FALSE;
    case GL_INT:
    case GL_UNSIGNED_INT:
@@ -156,6 +157,22 @@ vbo_attrtype_to_integer_flag(GLenum format)
    }
 }
 
+static inline GLboolean
+vbo_attrtype_to_double_flag(GLenum format)
+{
+   switch (format) {
+   case GL_FLOAT:
+   case GL_INT:
+   case GL_UNSIGNED_INT:
+      return GL_FALSE;
+   case GL_DOUBLE:
+      return GL_TRUE;
+   default:
+      assert(0);
+      return GL_FALSE;
+   }
+}
+
 /**
  * Return default component values for the given format.
  * The return type is an array of fi_types, because that's how we declare
diff --git a/src/mesa/vbo/vbo_exec_api.c b/src/mesa/vbo/vbo_exec_api.c
index 48680ec8899..138cd60513d 100644
--- a/src/mesa/vbo/vbo_exec_api.c
+++ b/src/mesa/vbo/vbo_exec_api.c
@@ -159,27 +159,36 @@ static void vbo_exec_copy_to_current( struct vbo_exec_context *exec )
           * ctx->Current.Attrib and ctx->Light.Material.Attrib arrays.
           */
 	 GLfloat *current = (GLfloat *)vbo->currval[i].Ptr;
-         fi_type tmp[4];
+         fi_type tmp[8]; /* space for doubles */
+         int dmul = exec->vtx.attrtype[i] == GL_DOUBLE ? 2 : 1;
+
+         if (exec->vtx.attrtype[i] == GL_DOUBLE) {
+            memset(tmp, 0, sizeof(tmp));
+            memcpy(tmp, exec->vtx.attrptr[i], exec->vtx.attrsz[i] * sizeof(GLfloat));
+         } else {
+            COPY_CLEAN_4V_TYPE_AS_UNION(tmp,
+                                        exec->vtx.attrsz[i],
+                                        exec->vtx.attrptr[i],
+                                        exec->vtx.attrtype[i]);
+         }
 
-         COPY_CLEAN_4V_TYPE_AS_UNION(tmp,
-                                     exec->vtx.attrsz[i],
-                                     exec->vtx.attrptr[i],
-                                     exec->vtx.attrtype[i]);
-         
          if (exec->vtx.attrtype[i] != vbo->currval[i].Type ||
-             memcmp(current, tmp, sizeof(tmp)) != 0) {
-            memcpy(current, tmp, sizeof(tmp));
+             memcmp(current, tmp, 4 * sizeof(GLfloat) * dmul) != 0) {
+            memcpy(current, tmp, 4 * sizeof(GLfloat) * dmul);
 	 
             /* Given that we explicitly state size here, there is no need
              * for the COPY_CLEAN above, could just copy 16 bytes and be
              * done.  The only problem is when Mesa accesses ctx->Current
              * directly.
              */
-            vbo->currval[i].Size = exec->vtx.attrsz[i];
-            vbo->currval[i]._ElementSize = vbo->currval[i].Size * sizeof(GLfloat);
+            /* Size here is in components - not bytes */
+            vbo->currval[i].Size = exec->vtx.attrsz[i] / dmul;
+            vbo->currval[i]._ElementSize = vbo->currval[i].Size * sizeof(GLfloat) * dmul;
             vbo->currval[i].Type = exec->vtx.attrtype[i];
             vbo->currval[i].Integer =
                   vbo_attrtype_to_integer_flag(exec->vtx.attrtype[i]);
+            vbo->currval[i].Doubles =
+                  vbo_attrtype_to_double_flag(exec->vtx.attrtype[i]);
 
             /* This triggers rather too much recalculation of Mesa state
              * that doesn't get used (eg light positions).
@@ -214,13 +223,17 @@ vbo_exec_copy_from_current(struct vbo_exec_context *exec)
    GLint i;
 
    for (i = VBO_ATTRIB_POS + 1; i < VBO_ATTRIB_MAX; i++) {
-      const fi_type *current = (fi_type *) vbo->currval[i].Ptr;
-      switch (exec->vtx.attrsz[i]) {
-      case 4: exec->vtx.attrptr[i][3] = current[3];
-      case 3: exec->vtx.attrptr[i][2] = current[2];
-      case 2: exec->vtx.attrptr[i][1] = current[1];
-      case 1: exec->vtx.attrptr[i][0] = current[0];
-	 break;
+      if (exec->vtx.attrtype[i] == GL_DOUBLE) {
+         memcpy(exec->vtx.attrptr[i], vbo->currval[i].Ptr, exec->vtx.attrsz[i] * sizeof(GLfloat));
+      } else {
+         const fi_type *current = (fi_type *) vbo->currval[i].Ptr;
+         switch (exec->vtx.attrsz[i]) {
+         case 4: exec->vtx.attrptr[i][3] = current[3];
+         case 3: exec->vtx.attrptr[i][2] = current[2];
+         case 2: exec->vtx.attrptr[i][1] = current[1];
+         case 1: exec->vtx.attrptr[i][0] = current[0];
+            break;
+         }
       }
    }
 }
@@ -364,11 +377,11 @@ vbo_exec_wrap_upgrade_vertex(struct vbo_exec_context *exec,
  * glTexCoord4f() call.  We promote the array from size=2 to size=4.
  */
 static void
-vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint newSize)
+vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint newSize, GLenum newType)
 {
    struct vbo_exec_context *exec = &vbo_context(ctx)->exec;
 
-   if (newSize > exec->vtx.attrsz[attr]) {
+   if (newSize > exec->vtx.attrsz[attr] || newType != exec->vtx.attrtype[attr]) {
       /* New size is larger.  Need to flush existing vertices and get
        * an enlarged vertex format.
        */
@@ -401,18 +414,19 @@ vbo_exec_fixup_vertex(struct gl_context *ctx, GLuint attr, GLuint newSize)
  * This macro is used to implement all the glVertex, glColor, glTexCoord,
  * glVertexAttrib, etc functions.
  */
-#define ATTR_UNION( A, N, T, V0, V1, V2, V3 )				\
+#define ATTR_UNION( A, N, T, C, V0, V1, V2, V3 )                        \
 do {									\
    struct vbo_exec_context *exec = &vbo_context(ctx)->exec;		\
-									\
+   int sz = (sizeof(C) / sizeof(GLfloat));                              \
    if (unlikely(!(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT)))	\
       ctx->Driver.BeginVertices( ctx );					\
-   									\
-   if (unlikely(exec->vtx.active_sz[A] != N))				\
-      vbo_exec_fixup_vertex(ctx, A, N);					\
-   									\
+                                                                        \
+   if (unlikely(exec->vtx.active_sz[A] != N * sz) ||                    \
+       unlikely(exec->vtx.attrtype[A] != T))                            \
+      vbo_exec_fixup_vertex(ctx, A, N * sz, T);                         \
+                                                                        \
    {									\
-      fi_type *dest = exec->vtx.attrptr[A];			\
+      C *dest = (C *)exec->vtx.attrptr[A];                              \
       if (N>0) dest[0] = V0;						\
       if (N>1) dest[1] = V1;						\
       if (N>2) dest[2] = V2;						\
@@ -438,7 +452,6 @@ do {									\
    }									\
 } while (0)
 
-
 #define ERROR(err) _mesa_error( ctx, err, __func__ )
 #define TAG(x) vbo_##x
 
@@ -575,7 +588,7 @@ static void GLAPIENTRY vbo_exec_EvalCoord1f( GLfloat u )
       for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
 	 if (exec->eval.map1[i].map) 
 	    if (exec->vtx.active_sz[i] != exec->eval.map1[i].sz)
-	       vbo_exec_fixup_vertex( ctx, i, exec->eval.map1[i].sz );
+	       vbo_exec_fixup_vertex( ctx, i, exec->eval.map1[i].sz, GL_FLOAT );
       }
    }
 
@@ -602,12 +615,12 @@ static void GLAPIENTRY vbo_exec_EvalCoord2f( GLfloat u, GLfloat v )
       for (i = 0; i <= VBO_ATTRIB_TEX7; i++) {
 	 if (exec->eval.map2[i].map) 
 	    if (exec->vtx.active_sz[i] != exec->eval.map2[i].sz)
-	       vbo_exec_fixup_vertex( ctx, i, exec->eval.map2[i].sz );
+	       vbo_exec_fixup_vertex( ctx, i, exec->eval.map2[i].sz, GL_FLOAT );
       }
 
       if (ctx->Eval.AutoNormal) 
 	 if (exec->vtx.active_sz[VBO_ATTRIB_NORMAL] != 3)
-	    vbo_exec_fixup_vertex( ctx, VBO_ATTRIB_NORMAL, 3 );
+	    vbo_exec_fixup_vertex( ctx, VBO_ATTRIB_NORMAL, 3, GL_FLOAT );
    }
 
    memcpy( exec->vtx.copied.buffer, exec->vtx.vertex, 
@@ -968,6 +981,16 @@ static void vbo_exec_vtxfmt_init( struct vbo_exec_context *exec )
    vfmt->VertexAttribP3uiv = vbo_VertexAttribP3uiv;
    vfmt->VertexAttribP4ui = vbo_VertexAttribP4ui;
    vfmt->VertexAttribP4uiv = vbo_VertexAttribP4uiv;
+
+   vfmt->VertexAttribL1d = vbo_VertexAttribL1d;
+   vfmt->VertexAttribL2d = vbo_VertexAttribL2d;
+   vfmt->VertexAttribL3d = vbo_VertexAttribL3d;
+   vfmt->VertexAttribL4d = vbo_VertexAttribL4d;
+
+   vfmt->VertexAttribL1dv = vbo_VertexAttribL1dv;
+   vfmt->VertexAttribL2dv = vbo_VertexAttribL2dv;
+   vfmt->VertexAttribL3dv = vbo_VertexAttribL3dv;
+   vfmt->VertexAttribL4dv = vbo_VertexAttribL4dv;
 }
 
 
diff --git a/src/mesa/vbo/vbo_save_api.c b/src/mesa/vbo/vbo_save_api.c
index 5927beeb33d..29de3d38aaa 100644
--- a/src/mesa/vbo/vbo_save_api.c
+++ b/src/mesa/vbo/vbo_save_api.c
@@ -772,7 +772,7 @@ _save_reset_vertex(struct gl_context *ctx)
  * 3f version won't otherwise set color[3] to 1.0 -- this is the job
  * of the chooser function when switching between Color4f and Color3f.
  */
-#define ATTR_UNION(A, N, T, V0, V1, V2, V3)			\
+#define ATTR_UNION(A, N, T, C, V0, V1, V2, V3)			\
 do {								\
    struct vbo_save_context *save = &vbo_context(ctx)->save;	\
 								\
@@ -780,7 +780,7 @@ do {								\
       save_fixup_vertex(ctx, A, N);				\
 								\
    {								\
-      fi_type *dest = save->attrptr[A];		\
+      C *dest = (C *)save->attrptr[A];                          \
       if (N>0) dest[0] = V0;					\
       if (N>1) dest[1] = V1;					\
       if (N>2) dest[2] = V2;					\
@@ -1372,6 +1372,16 @@ _save_vtxfmt_init(struct gl_context *ctx)
    vfmt->VertexAttribP3uiv = _save_VertexAttribP3uiv;
    vfmt->VertexAttribP4uiv = _save_VertexAttribP4uiv;
 
+   vfmt->VertexAttribL1d = _save_VertexAttribL1d;
+   vfmt->VertexAttribL2d = _save_VertexAttribL2d;
+   vfmt->VertexAttribL3d = _save_VertexAttribL3d;
+   vfmt->VertexAttribL4d = _save_VertexAttribL4d;
+
+   vfmt->VertexAttribL1dv = _save_VertexAttribL1dv;
+   vfmt->VertexAttribL2dv = _save_VertexAttribL2dv;
+   vfmt->VertexAttribL3dv = _save_VertexAttribL3dv;
+   vfmt->VertexAttribL4dv = _save_VertexAttribL4dv;
+
    /* This will all require us to fallback to saving the list as opcodes:
     */
    vfmt->CallList = _save_CallList;
diff --git a/src/mesa/vbo/vbo_split_copy.c b/src/mesa/vbo/vbo_split_copy.c
index d1107dd8419..7b1e20b18d2 100644
--- a/src/mesa/vbo/vbo_split_copy.c
+++ b/src/mesa/vbo/vbo_split_copy.c
@@ -533,6 +533,7 @@ replay_init( struct copy_context *copy )
       dst->Enabled = GL_TRUE;
       dst->Normalized = src->Normalized; 
       dst->Integer = src->Integer;
+      dst->Doubles = src->Doubles;
       dst->BufferObj = ctx->Shared->NullBufferObj;
       dst->_ElementSize = src->_ElementSize;