gl-1.5-vertex-buffer-offsets: test unusual vertex offsets/strides

Submitted by Brian Paul on June 19, 2015, 2:39 p.m.

Details

Message ID 1434724752-32293-1-git-send-email-brianp@vmware.com
State New, archived
Headers show

Not browsing as part of any series.

Commit Message

Brian Paul June 19, 2015, 2:39 p.m.
The draw-vertices tests exercises unusual vertex sizes and strides,
but not with interleaved arrays.

This test creates a VBO with interleaved vertex positions and colors.
The colors are positioned at offsets like 9, 10 and 11 bytes from the
start of the vertex.  Unusual strides between vertices are tested too.

Exercises a bug in Gallium's u_vbuf code where the driver was passed
pipe_vertex_element::src_offset values which weren't a multiple of
four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
returned 1.
---
 tests/all.py                              |   1 +
 tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
 tests/spec/gl-1.5/vertex-buffer-offsets.c | 124 ++++++++++++++++++++++++++++++
 3 files changed, 126 insertions(+)
 create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c

Patch hide | download patch | download mbox

diff --git a/tests/all.py b/tests/all.py
index ad4c494..ee11be6 100755
--- a/tests/all.py
+++ b/tests/all.py
@@ -1042,6 +1042,7 @@  with profile.group_manager(
       'normal3b3s-invariance-byte', run_concurrent=False)
     g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
       'normal3b3s-invariance-short', run_concurrent=False)
+    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
 
 with profile.group_manager(
         PiglitGLTest,
diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt b/tests/spec/gl-1.5/CMakeLists.gl.txt
index 8dcd95d..f10c6cb 100644
--- a/tests/spec/gl-1.5/CMakeLists.gl.txt
+++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
@@ -10,5 +10,6 @@  link_libraries (
 )
 
 piglit_add_executable (gl-1.5-normal3b3s-invariance normal3b3s-invariance.c)
+piglit_add_executable (gl-1.5-vertex-buffer-offsets vertex-buffer-offsets.c)
 
 # vim: ft=cmake:
diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c b/tests/spec/gl-1.5/vertex-buffer-offsets.c
new file mode 100644
index 0000000..6d58331
--- /dev/null
+++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
@@ -0,0 +1,124 @@ 
+/*
+ * Copyright 2015  VMware, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/*
+ * Test interleaved vertex arrays with unusual element offsets and strides.
+ * Brian Paul
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+	config.supports_gl_compat_version = 15;
+	config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
+PIGLIT_GL_TEST_CONFIG_END
+
+
+void
+piglit_init(int argc, char **argv)
+{
+	/* nothing */
+}
+
+
+static bool
+test_offset_stride(int color_offset, int stride)
+{
+	static const GLfloat vertex[4][2] = {
+		{ -1, -1 },
+		{  1, -1 },
+		{  1,  1 },
+		{ -1,  1 }
+	};
+	static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
+	GLubyte buffer[1000];
+	GLuint buf;
+	int i, pos;
+	bool p;
+
+	assert(color_offset >= sizeof(vertex[0]));
+	assert(stride >= color_offset + sizeof(color));
+
+	pos = 0;
+	for (i = 0; i < 4; i++) {
+		/* copy vertex position into buffer */
+		memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
+
+		/* copy vertex color into buffer at unusual offset */
+		memcpy(buffer + pos + color_offset, color, sizeof(color));
+
+		pos += stride;
+	}
+	assert(pos <= sizeof(buffer));
+
+	glGenBuffers(1, &buf);
+	glBindBuffer(GL_ARRAY_BUFFER, buf);
+	glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
+					 buffer, GL_STATIC_DRAW);
+
+	glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
+	glColorPointer(4, GL_FLOAT, stride, (void *) (size_t) color_offset);
+	glEnable(GL_VERTEX_ARRAY);
+	glEnable(GL_COLOR_ARRAY);
+
+	glClear(GL_COLOR_BUFFER_BIT);
+	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+
+	p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, color);
+
+	if (!p) {
+		printf("failure for color_offset %d, stride %d\n",
+		       color_offset, stride);
+	}
+
+	piglit_present_results();
+
+	glDeleteBuffers(1, &buf);
+
+	return p;
+}
+
+
+enum piglit_result
+piglit_display(void)
+{
+	bool pass = true;
+
+	/* test nice values */
+	pass = test_offset_stride(8, 24) && pass;
+	pass = test_offset_stride(12, 28) && pass;
+
+	/* test unual offset */
+	pass = test_offset_stride(9, 32) && pass;
+
+	/* test unual stride */
+	pass = test_offset_stride(8, 27) && pass;
+
+	/* test unusual offset, unusual stride */
+	pass = test_offset_stride(9, 25) && pass;
+	pass = test_offset_stride(10, 26) && pass;
+	pass = test_offset_stride(11, 27) && pass;
+
+	return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+

Comments

On Fri, Jun 19, 2015 at 10:39 AM, Brian Paul <brianp@vmware.com> wrote:
> The draw-vertices tests exercises unusual vertex sizes and strides,
> but not with interleaved arrays.
>
> This test creates a VBO with interleaved vertex positions and colors.
> The colors are positioned at offsets like 9, 10 and 11 bytes from the
> start of the vertex.  Unusual strides between vertices are tested too.
>
> Exercises a bug in Gallium's u_vbuf code where the driver was passed
> pipe_vertex_element::src_offset values which weren't a multiple of
> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
> returned 1.
> ---
>  tests/all.py                              |   1 +
>  tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>  tests/spec/gl-1.5/vertex-buffer-offsets.c | 124 ++++++++++++++++++++++++++++++
>  3 files changed, 126 insertions(+)
>  create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>
> diff --git a/tests/all.py b/tests/all.py
> index ad4c494..ee11be6 100755
> --- a/tests/all.py
> +++ b/tests/all.py
> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>        'normal3b3s-invariance-byte', run_concurrent=False)
>      g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>        'normal3b3s-invariance-short', run_concurrent=False)
> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>
>  with profile.group_manager(
>          PiglitGLTest,
> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt b/tests/spec/gl-1.5/CMakeLists.gl.txt
> index 8dcd95d..f10c6cb 100644
> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
> @@ -10,5 +10,6 @@ link_libraries (
>  )
>
>  piglit_add_executable (gl-1.5-normal3b3s-invariance normal3b3s-invariance.c)
> +piglit_add_executable (gl-1.5-vertex-buffer-offsets vertex-buffer-offsets.c)
>
>  # vim: ft=cmake:
> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c b/tests/spec/gl-1.5/vertex-buffer-offsets.c
> new file mode 100644
> index 0000000..6d58331
> --- /dev/null
> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
> @@ -0,0 +1,124 @@
> +/*
> + * Copyright 2015  VMware, Inc.
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> + * DEALINGS IN THE SOFTWARE.
> + */
> +
> +/*
> + * Test interleaved vertex arrays with unusual element offsets and strides.
> + * Brian Paul
> + */
> +
> +#include "piglit-util-gl.h"
> +
> +PIGLIT_GL_TEST_CONFIG_BEGIN
> +       config.supports_gl_compat_version = 15;
> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
> +PIGLIT_GL_TEST_CONFIG_END
> +
> +
> +void
> +piglit_init(int argc, char **argv)
> +{
> +       /* nothing */
> +}
> +
> +
> +static bool
> +test_offset_stride(int color_offset, int stride)
> +{
> +       static const GLfloat vertex[4][2] = {
> +               { -1, -1 },
> +               {  1, -1 },
> +               {  1,  1 },
> +               { -1,  1 }
> +       };
> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
> +       GLubyte buffer[1000];
> +       GLuint buf;
> +       int i, pos;
> +       bool p;
> +
> +       assert(color_offset >= sizeof(vertex[0]));
> +       assert(stride >= color_offset + sizeof(color));
> +
> +       pos = 0;
> +       for (i = 0; i < 4; i++) {
> +               /* copy vertex position into buffer */
> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
> +
> +               /* copy vertex color into buffer at unusual offset */
> +               memcpy(buffer + pos + color_offset, color, sizeof(color));
> +
> +               pos += stride;
> +       }
> +       assert(pos <= sizeof(buffer));
> +
> +       glGenBuffers(1, &buf);
> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
> +                                        buffer, GL_STATIC_DRAW);
> +
> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t) color_offset);
> +       glEnable(GL_VERTEX_ARRAY);
> +       glEnable(GL_COLOR_ARRAY);
> +
> +       glClear(GL_COLOR_BUFFER_BIT);
> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
> +
> +       p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, color);
> +
> +       if (!p) {
> +               printf("failure for color_offset %d, stride %d\n",
> +                      color_offset, stride);
> +       }
> +
> +       piglit_present_results();
> +
> +       glDeleteBuffers(1, &buf);
> +
> +       return p;
> +}
> +
> +
> +enum piglit_result
> +piglit_display(void)
> +{
> +       bool pass = true;
> +
> +       /* test nice values */
> +       pass = test_offset_stride(8, 24) && pass;
> +       pass = test_offset_stride(12, 28) && pass;
> +
> +       /* test unual offset */

unusual is the usual spelling

> +       pass = test_offset_stride(9, 32) && pass;
> +
> +       /* test unual stride */

unusual

> +       pass = test_offset_stride(8, 27) && pass;
> +
> +       /* test unusual offset, unusual stride */
> +       pass = test_offset_stride(9, 25) && pass;
> +       pass = test_offset_stride(10, 26) && pass;
> +       pass = test_offset_stride(11, 27) && pass;
> +
> +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> +}
> +
> --
> 1.9.1
>
> _______________________________________________
> Piglit mailing list
> Piglit@lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
On Fri, Jun 19, 2015 at 10:47 AM, Ilia Mirkin <imirkin@alum.mit.edu> wrote:
> On Fri, Jun 19, 2015 at 10:39 AM, Brian Paul <brianp@vmware.com> wrote:
>> The draw-vertices tests exercises unusual vertex sizes and strides,
>> but not with interleaved arrays.
>>
>> This test creates a VBO with interleaved vertex positions and colors.
>> The colors are positioned at offsets like 9, 10 and 11 bytes from the
>> start of the vertex.  Unusual strides between vertices are tested too.
>>
>> Exercises a bug in Gallium's u_vbuf code where the driver was passed
>> pipe_vertex_element::src_offset values which weren't a multiple of
>> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
>> returned 1.
>> ---
>>  tests/all.py                              |   1 +
>>  tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>>  tests/spec/gl-1.5/vertex-buffer-offsets.c | 124 ++++++++++++++++++++++++++++++
>>  3 files changed, 126 insertions(+)
>>  create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>>
>> diff --git a/tests/all.py b/tests/all.py
>> index ad4c494..ee11be6 100755
>> --- a/tests/all.py
>> +++ b/tests/all.py
>> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>>        'normal3b3s-invariance-byte', run_concurrent=False)
>>      g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>>        'normal3b3s-invariance-short', run_concurrent=False)
>> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>>
>>  with profile.group_manager(
>>          PiglitGLTest,
>> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt b/tests/spec/gl-1.5/CMakeLists.gl.txt
>> index 8dcd95d..f10c6cb 100644
>> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
>> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
>> @@ -10,5 +10,6 @@ link_libraries (
>>  )
>>
>>  piglit_add_executable (gl-1.5-normal3b3s-invariance normal3b3s-invariance.c)
>> +piglit_add_executable (gl-1.5-vertex-buffer-offsets vertex-buffer-offsets.c)
>>
>>  # vim: ft=cmake:
>> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>> new file mode 100644
>> index 0000000..6d58331
>> --- /dev/null
>> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>> @@ -0,0 +1,124 @@
>> +/*
>> + * Copyright 2015  VMware, Inc.
>> + *
>> + * Permission is hereby granted, free of charge, to any person obtaining a
>> + * copy of this software and associated documentation files (the "Software"),
>> + * to deal in the Software without restriction, including without limitation
>> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
>> + * and/or sell copies of the Software, and to permit persons to whom the
>> + * Software is furnished to do so, subject to the following conditions:
>> + *
>> + * The above copyright notice and this permission notice (including the next
>> + * paragraph) shall be included in all copies or substantial portions of the
>> + * Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
>> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>> + * DEALINGS IN THE SOFTWARE.
>> + */
>> +
>> +/*
>> + * Test interleaved vertex arrays with unusual element offsets and strides.
>> + * Brian Paul
>> + */
>> +
>> +#include "piglit-util-gl.h"
>> +
>> +PIGLIT_GL_TEST_CONFIG_BEGIN
>> +       config.supports_gl_compat_version = 15;
>> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
>> +PIGLIT_GL_TEST_CONFIG_END
>> +
>> +
>> +void
>> +piglit_init(int argc, char **argv)
>> +{
>> +       /* nothing */
>> +}
>> +
>> +
>> +static bool
>> +test_offset_stride(int color_offset, int stride)
>> +{
>> +       static const GLfloat vertex[4][2] = {
>> +               { -1, -1 },
>> +               {  1, -1 },
>> +               {  1,  1 },
>> +               { -1,  1 }
>> +       };
>> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
>> +       GLubyte buffer[1000];
>> +       GLuint buf;
>> +       int i, pos;
>> +       bool p;
>> +
>> +       assert(color_offset >= sizeof(vertex[0]));
>> +       assert(stride >= color_offset + sizeof(color));
>> +
>> +       pos = 0;
>> +       for (i = 0; i < 4; i++) {
>> +               /* copy vertex position into buffer */
>> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
>> +
>> +               /* copy vertex color into buffer at unusual offset */
>> +               memcpy(buffer + pos + color_offset, color, sizeof(color));
>> +
>> +               pos += stride;
>> +       }
>> +       assert(pos <= sizeof(buffer));
>> +
>> +       glGenBuffers(1, &buf);
>> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
>> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
>> +                                        buffer, GL_STATIC_DRAW);
>> +
>> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
>> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t) color_offset);
>> +       glEnable(GL_VERTEX_ARRAY);
>> +       glEnable(GL_COLOR_ARRAY);
>> +
>> +       glClear(GL_COLOR_BUFFER_BIT);
>> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
>> +
>> +       p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, color);
>> +
>> +       if (!p) {
>> +               printf("failure for color_offset %d, stride %d\n",
>> +                      color_offset, stride);
>> +       }
>> +
>> +       piglit_present_results();
>> +
>> +       glDeleteBuffers(1, &buf);
>> +
>> +       return p;
>> +}
>> +
>> +
>> +enum piglit_result
>> +piglit_display(void)
>> +{
>> +       bool pass = true;
>> +
>> +       /* test nice values */
>> +       pass = test_offset_stride(8, 24) && pass;
>> +       pass = test_offset_stride(12, 28) && pass;
>> +
>> +       /* test unual offset */
>
> unusual is the usual spelling
>
>> +       pass = test_offset_stride(9, 32) && pass;
>> +
>> +       /* test unual stride */
>
> unusual
>
>> +       pass = test_offset_stride(8, 27) && pass;
>> +
>> +       /* test unusual offset, unusual stride */
>> +       pass = test_offset_stride(9, 25) && pass;
>> +       pass = test_offset_stride(10, 26) && pass;
>> +       pass = test_offset_stride(11, 27) && pass;
>> +
>> +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
>> +}
>> +

Also git am complains about the extra empty line at the end:

Applying: gl-1.5-vertex-buffer-offsets: test unusual vertex offsets/strides
.git/rebase-apply/patch:160: new blank line at EOF.
+
warning: 1 line adds whitespace errors.
On 06/19/2015 08:47 AM, Ilia Mirkin wrote:
> On Fri, Jun 19, 2015 at 10:39 AM, Brian Paul <brianp@vmware.com> wrote:
>> The draw-vertices tests exercises unusual vertex sizes and strides,
>> but not with interleaved arrays.
>>
>> This test creates a VBO with interleaved vertex positions and colors.
>> The colors are positioned at offsets like 9, 10 and 11 bytes from the
>> start of the vertex.  Unusual strides between vertices are tested too.
>>
>> Exercises a bug in Gallium's u_vbuf code where the driver was passed
>> pipe_vertex_element::src_offset values which weren't a multiple of
>> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
>> returned 1.
>> ---
>>   tests/all.py                              |   1 +
>>   tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>>   tests/spec/gl-1.5/vertex-buffer-offsets.c | 124 ++++++++++++++++++++++++++++++
>>   3 files changed, 126 insertions(+)
>>   create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>>
>> diff --git a/tests/all.py b/tests/all.py
>> index ad4c494..ee11be6 100755
>> --- a/tests/all.py
>> +++ b/tests/all.py
>> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>>         'normal3b3s-invariance-byte', run_concurrent=False)
>>       g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>>         'normal3b3s-invariance-short', run_concurrent=False)
>> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>>
>>   with profile.group_manager(
>>           PiglitGLTest,
>> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt b/tests/spec/gl-1.5/CMakeLists.gl.txt
>> index 8dcd95d..f10c6cb 100644
>> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
>> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
>> @@ -10,5 +10,6 @@ link_libraries (
>>   )
>>
>>   piglit_add_executable (gl-1.5-normal3b3s-invariance normal3b3s-invariance.c)
>> +piglit_add_executable (gl-1.5-vertex-buffer-offsets vertex-buffer-offsets.c)
>>
>>   # vim: ft=cmake:
>> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>> new file mode 100644
>> index 0000000..6d58331
>> --- /dev/null
>> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>> @@ -0,0 +1,124 @@
>> +/*
>> + * Copyright 2015  VMware, Inc.
>> + *
>> + * Permission is hereby granted, free of charge, to any person obtaining a
>> + * copy of this software and associated documentation files (the "Software"),
>> + * to deal in the Software without restriction, including without limitation
>> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
>> + * and/or sell copies of the Software, and to permit persons to whom the
>> + * Software is furnished to do so, subject to the following conditions:
>> + *
>> + * The above copyright notice and this permission notice (including the next
>> + * paragraph) shall be included in all copies or substantial portions of the
>> + * Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
>> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>> + * DEALINGS IN THE SOFTWARE.
>> + */
>> +
>> +/*
>> + * Test interleaved vertex arrays with unusual element offsets and strides.
>> + * Brian Paul
>> + */
>> +
>> +#include "piglit-util-gl.h"
>> +
>> +PIGLIT_GL_TEST_CONFIG_BEGIN
>> +       config.supports_gl_compat_version = 15;
>> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
>> +PIGLIT_GL_TEST_CONFIG_END
>> +
>> +
>> +void
>> +piglit_init(int argc, char **argv)
>> +{
>> +       /* nothing */
>> +}
>> +
>> +
>> +static bool
>> +test_offset_stride(int color_offset, int stride)
>> +{
>> +       static const GLfloat vertex[4][2] = {
>> +               { -1, -1 },
>> +               {  1, -1 },
>> +               {  1,  1 },
>> +               { -1,  1 }
>> +       };
>> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
>> +       GLubyte buffer[1000];
>> +       GLuint buf;
>> +       int i, pos;
>> +       bool p;
>> +
>> +       assert(color_offset >= sizeof(vertex[0]));
>> +       assert(stride >= color_offset + sizeof(color));
>> +
>> +       pos = 0;
>> +       for (i = 0; i < 4; i++) {
>> +               /* copy vertex position into buffer */
>> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
>> +
>> +               /* copy vertex color into buffer at unusual offset */
>> +               memcpy(buffer + pos + color_offset, color, sizeof(color));
>> +
>> +               pos += stride;
>> +       }
>> +       assert(pos <= sizeof(buffer));
>> +
>> +       glGenBuffers(1, &buf);
>> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
>> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
>> +                                        buffer, GL_STATIC_DRAW);
>> +
>> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
>> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t) color_offset);
>> +       glEnable(GL_VERTEX_ARRAY);
>> +       glEnable(GL_COLOR_ARRAY);
>> +
>> +       glClear(GL_COLOR_BUFFER_BIT);
>> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
>> +
>> +       p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, color);
>> +
>> +       if (!p) {
>> +               printf("failure for color_offset %d, stride %d\n",
>> +                      color_offset, stride);
>> +       }
>> +
>> +       piglit_present_results();
>> +
>> +       glDeleteBuffers(1, &buf);
>> +
>> +       return p;
>> +}
>> +
>> +
>> +enum piglit_result
>> +piglit_display(void)
>> +{
>> +       bool pass = true;
>> +
>> +       /* test nice values */
>> +       pass = test_offset_stride(8, 24) && pass;
>> +       pass = test_offset_stride(12, 28) && pass;
>> +
>> +       /* test unual offset */
>
> unusual is the usual spelling

Fixed.  R-b?

-Brian
On Fri, Jun 19, 2015 at 10:48 AM, Brian Paul <brianp@vmware.com> wrote:
> On 06/19/2015 08:47 AM, Ilia Mirkin wrote:
>>
>> On Fri, Jun 19, 2015 at 10:39 AM, Brian Paul <brianp@vmware.com> wrote:
>>>
>>> The draw-vertices tests exercises unusual vertex sizes and strides,
>>> but not with interleaved arrays.
>>>
>>> This test creates a VBO with interleaved vertex positions and colors.
>>> The colors are positioned at offsets like 9, 10 and 11 bytes from the
>>> start of the vertex.  Unusual strides between vertices are tested too.
>>>
>>> Exercises a bug in Gallium's u_vbuf code where the driver was passed
>>> pipe_vertex_element::src_offset values which weren't a multiple of
>>> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
>>> returned 1.
>>> ---
>>>   tests/all.py                              |   1 +
>>>   tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>>>   tests/spec/gl-1.5/vertex-buffer-offsets.c | 124
>>> ++++++++++++++++++++++++++++++
>>>   3 files changed, 126 insertions(+)
>>>   create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>>>
>>> diff --git a/tests/all.py b/tests/all.py
>>> index ad4c494..ee11be6 100755
>>> --- a/tests/all.py
>>> +++ b/tests/all.py
>>> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>>>         'normal3b3s-invariance-byte', run_concurrent=False)
>>>       g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>>>         'normal3b3s-invariance-short', run_concurrent=False)
>>> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>>>
>>>   with profile.group_manager(
>>>           PiglitGLTest,
>>> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt
>>> b/tests/spec/gl-1.5/CMakeLists.gl.txt
>>> index 8dcd95d..f10c6cb 100644
>>> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
>>> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
>>> @@ -10,5 +10,6 @@ link_libraries (
>>>   )
>>>
>>>   piglit_add_executable (gl-1.5-normal3b3s-invariance
>>> normal3b3s-invariance.c)
>>> +piglit_add_executable (gl-1.5-vertex-buffer-offsets
>>> vertex-buffer-offsets.c)
>>>
>>>   # vim: ft=cmake:
>>> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c
>>> b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>>> new file mode 100644
>>> index 0000000..6d58331
>>> --- /dev/null
>>> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>>> @@ -0,0 +1,124 @@
>>> +/*
>>> + * Copyright 2015  VMware, Inc.
>>> + *
>>> + * Permission is hereby granted, free of charge, to any person obtaining
>>> a
>>> + * copy of this software and associated documentation files (the
>>> "Software"),
>>> + * to deal in the Software without restriction, including without
>>> limitation
>>> + * the rights to use, copy, modify, merge, publish, distribute,
>>> sublicense,
>>> + * and/or sell copies of the Software, and to permit persons to whom the
>>> + * Software is furnished to do so, subject to the following conditions:
>>> + *
>>> + * The above copyright notice and this permission notice (including the
>>> next
>>> + * paragraph) shall be included in all copies or substantial portions of
>>> the
>>> + * Software.
>>> + *
>>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
>>> EXPRESS OR
>>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
>>> MERCHANTABILITY,
>>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT
>>> SHALL
>>> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
>>> OTHER
>>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
>>> ARISING
>>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>>> + * DEALINGS IN THE SOFTWARE.
>>> + */
>>> +
>>> +/*
>>> + * Test interleaved vertex arrays with unusual element offsets and
>>> strides.
>>> + * Brian Paul
>>> + */
>>> +
>>> +#include "piglit-util-gl.h"
>>> +
>>> +PIGLIT_GL_TEST_CONFIG_BEGIN
>>> +       config.supports_gl_compat_version = 15;
>>> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA |
>>> PIGLIT_GL_VISUAL_DOUBLE;
>>> +PIGLIT_GL_TEST_CONFIG_END
>>> +
>>> +
>>> +void
>>> +piglit_init(int argc, char **argv)
>>> +{
>>> +       /* nothing */
>>> +}
>>> +
>>> +
>>> +static bool
>>> +test_offset_stride(int color_offset, int stride)
>>> +{
>>> +       static const GLfloat vertex[4][2] = {
>>> +               { -1, -1 },
>>> +               {  1, -1 },
>>> +               {  1,  1 },
>>> +               { -1,  1 }
>>> +       };
>>> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
>>> +       GLubyte buffer[1000];
>>> +       GLuint buf;
>>> +       int i, pos;
>>> +       bool p;
>>> +
>>> +       assert(color_offset >= sizeof(vertex[0]));
>>> +       assert(stride >= color_offset + sizeof(color));
>>> +
>>> +       pos = 0;
>>> +       for (i = 0; i < 4; i++) {
>>> +               /* copy vertex position into buffer */
>>> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
>>> +
>>> +               /* copy vertex color into buffer at unusual offset */
>>> +               memcpy(buffer + pos + color_offset, color,
>>> sizeof(color));
>>> +
>>> +               pos += stride;
>>> +       }
>>> +       assert(pos <= sizeof(buffer));
>>> +
>>> +       glGenBuffers(1, &buf);
>>> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
>>> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
>>> +                                        buffer, GL_STATIC_DRAW);
>>> +
>>> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
>>> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t)
>>> color_offset);
>>> +       glEnable(GL_VERTEX_ARRAY);
>>> +       glEnable(GL_COLOR_ARRAY);
>>> +
>>> +       glClear(GL_COLOR_BUFFER_BIT);
>>> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
>>> +
>>> +       p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height,
>>> color);
>>> +
>>> +       if (!p) {
>>> +               printf("failure for color_offset %d, stride %d\n",
>>> +                      color_offset, stride);
>>> +       }
>>> +
>>> +       piglit_present_results();
>>> +
>>> +       glDeleteBuffers(1, &buf);
>>> +
>>> +       return p;
>>> +}
>>> +
>>> +
>>> +enum piglit_result
>>> +piglit_display(void)
>>> +{
>>> +       bool pass = true;
>>> +
>>> +       /* test nice values */
>>> +       pass = test_offset_stride(8, 24) && pass;
>>> +       pass = test_offset_stride(12, 28) && pass;
>>> +
>>> +       /* test unual offset */
>>
>>
>> unusual is the usual spelling
>
>
> Fixed.  R-b?

Sorry, don't know enough about vertex buffers =/ The test does seem to
pass on nouveau (which doesn't use u_vbuf) and llvmpipe/softpipe,
which I'm guessing both have 1-byte alignment requirement.

  -ilia
I don't see a point in calling piglit_present_results(). Other than that:

Reviewed-by: Marek Olšák <marek.olsak@amd.com>

Marek

On Fri, Jun 19, 2015 at 4:39 PM, Brian Paul <brianp@vmware.com> wrote:
> The draw-vertices tests exercises unusual vertex sizes and strides,
> but not with interleaved arrays.
>
> This test creates a VBO with interleaved vertex positions and colors.
> The colors are positioned at offsets like 9, 10 and 11 bytes from the
> start of the vertex.  Unusual strides between vertices are tested too.
>
> Exercises a bug in Gallium's u_vbuf code where the driver was passed
> pipe_vertex_element::src_offset values which weren't a multiple of
> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
> returned 1.
> ---
>  tests/all.py                              |   1 +
>  tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>  tests/spec/gl-1.5/vertex-buffer-offsets.c | 124 ++++++++++++++++++++++++++++++
>  3 files changed, 126 insertions(+)
>  create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>
> diff --git a/tests/all.py b/tests/all.py
> index ad4c494..ee11be6 100755
> --- a/tests/all.py
> +++ b/tests/all.py
> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>        'normal3b3s-invariance-byte', run_concurrent=False)
>      g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>        'normal3b3s-invariance-short', run_concurrent=False)
> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>
>  with profile.group_manager(
>          PiglitGLTest,
> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt b/tests/spec/gl-1.5/CMakeLists.gl.txt
> index 8dcd95d..f10c6cb 100644
> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
> @@ -10,5 +10,6 @@ link_libraries (
>  )
>
>  piglit_add_executable (gl-1.5-normal3b3s-invariance normal3b3s-invariance.c)
> +piglit_add_executable (gl-1.5-vertex-buffer-offsets vertex-buffer-offsets.c)
>
>  # vim: ft=cmake:
> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c b/tests/spec/gl-1.5/vertex-buffer-offsets.c
> new file mode 100644
> index 0000000..6d58331
> --- /dev/null
> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
> @@ -0,0 +1,124 @@
> +/*
> + * Copyright 2015  VMware, Inc.
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> + * DEALINGS IN THE SOFTWARE.
> + */
> +
> +/*
> + * Test interleaved vertex arrays with unusual element offsets and strides.
> + * Brian Paul
> + */
> +
> +#include "piglit-util-gl.h"
> +
> +PIGLIT_GL_TEST_CONFIG_BEGIN
> +       config.supports_gl_compat_version = 15;
> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
> +PIGLIT_GL_TEST_CONFIG_END
> +
> +
> +void
> +piglit_init(int argc, char **argv)
> +{
> +       /* nothing */
> +}
> +
> +
> +static bool
> +test_offset_stride(int color_offset, int stride)
> +{
> +       static const GLfloat vertex[4][2] = {
> +               { -1, -1 },
> +               {  1, -1 },
> +               {  1,  1 },
> +               { -1,  1 }
> +       };
> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
> +       GLubyte buffer[1000];
> +       GLuint buf;
> +       int i, pos;
> +       bool p;
> +
> +       assert(color_offset >= sizeof(vertex[0]));
> +       assert(stride >= color_offset + sizeof(color));
> +
> +       pos = 0;
> +       for (i = 0; i < 4; i++) {
> +               /* copy vertex position into buffer */
> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
> +
> +               /* copy vertex color into buffer at unusual offset */
> +               memcpy(buffer + pos + color_offset, color, sizeof(color));
> +
> +               pos += stride;
> +       }
> +       assert(pos <= sizeof(buffer));
> +
> +       glGenBuffers(1, &buf);
> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
> +                                        buffer, GL_STATIC_DRAW);
> +
> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t) color_offset);
> +       glEnable(GL_VERTEX_ARRAY);
> +       glEnable(GL_COLOR_ARRAY);
> +
> +       glClear(GL_COLOR_BUFFER_BIT);
> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
> +
> +       p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, color);
> +
> +       if (!p) {
> +               printf("failure for color_offset %d, stride %d\n",
> +                      color_offset, stride);
> +       }
> +
> +       piglit_present_results();
> +
> +       glDeleteBuffers(1, &buf);
> +
> +       return p;
> +}
> +
> +
> +enum piglit_result
> +piglit_display(void)
> +{
> +       bool pass = true;
> +
> +       /* test nice values */
> +       pass = test_offset_stride(8, 24) && pass;
> +       pass = test_offset_stride(12, 28) && pass;
> +
> +       /* test unual offset */
> +       pass = test_offset_stride(9, 32) && pass;
> +
> +       /* test unual stride */
> +       pass = test_offset_stride(8, 27) && pass;
> +
> +       /* test unusual offset, unusual stride */
> +       pass = test_offset_stride(9, 25) && pass;
> +       pass = test_offset_stride(10, 26) && pass;
> +       pass = test_offset_stride(11, 27) && pass;
> +
> +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> +}
> +
> --
> 1.9.1
>
> _______________________________________________
> Piglit mailing list
> Piglit@lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
I guess I like to see something in the window.

Thanks.

-Brian

On 06/19/2015 10:16 AM, Marek Olšák wrote:
> I don't see a point in calling piglit_present_results(). Other than that:
>
> Reviewed-by: Marek Olšák <marek.olsak@amd.com>
>
> Marek
>
> On Fri, Jun 19, 2015 at 4:39 PM, Brian Paul <brianp@vmware.com> wrote:
>> The draw-vertices tests exercises unusual vertex sizes and strides,
>> but not with interleaved arrays.
>>
>> This test creates a VBO with interleaved vertex positions and colors.
>> The colors are positioned at offsets like 9, 10 and 11 bytes from the
>> start of the vertex.  Unusual strides between vertices are tested too.
>>
>> Exercises a bug in Gallium's u_vbuf code where the driver was passed
>> pipe_vertex_element::src_offset values which weren't a multiple of
>> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
>> returned 1.
>> ---
>>   tests/all.py                              |   1 +
>>   tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>>   tests/spec/gl-1.5/vertex-buffer-offsets.c | 124 ++++++++++++++++++++++++++++++
>>   3 files changed, 126 insertions(+)
>>   create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>>
>> diff --git a/tests/all.py b/tests/all.py
>> index ad4c494..ee11be6 100755
>> --- a/tests/all.py
>> +++ b/tests/all.py
>> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>>         'normal3b3s-invariance-byte', run_concurrent=False)
>>       g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>>         'normal3b3s-invariance-short', run_concurrent=False)
>> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>>
>>   with profile.group_manager(
>>           PiglitGLTest,
>> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt b/tests/spec/gl-1.5/CMakeLists.gl.txt
>> index 8dcd95d..f10c6cb 100644
>> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
>> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
>> @@ -10,5 +10,6 @@ link_libraries (
>>   )
>>
>>   piglit_add_executable (gl-1.5-normal3b3s-invariance normal3b3s-invariance.c)
>> +piglit_add_executable (gl-1.5-vertex-buffer-offsets vertex-buffer-offsets.c)
>>
>>   # vim: ft=cmake:
>> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>> new file mode 100644
>> index 0000000..6d58331
>> --- /dev/null
>> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>> @@ -0,0 +1,124 @@
>> +/*
>> + * Copyright 2015  VMware, Inc.
>> + *
>> + * Permission is hereby granted, free of charge, to any person obtaining a
>> + * copy of this software and associated documentation files (the "Software"),
>> + * to deal in the Software without restriction, including without limitation
>> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
>> + * and/or sell copies of the Software, and to permit persons to whom the
>> + * Software is furnished to do so, subject to the following conditions:
>> + *
>> + * The above copyright notice and this permission notice (including the next
>> + * paragraph) shall be included in all copies or substantial portions of the
>> + * Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
>> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>> + * DEALINGS IN THE SOFTWARE.
>> + */
>> +
>> +/*
>> + * Test interleaved vertex arrays with unusual element offsets and strides.
>> + * Brian Paul
>> + */
>> +
>> +#include "piglit-util-gl.h"
>> +
>> +PIGLIT_GL_TEST_CONFIG_BEGIN
>> +       config.supports_gl_compat_version = 15;
>> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
>> +PIGLIT_GL_TEST_CONFIG_END
>> +
>> +
>> +void
>> +piglit_init(int argc, char **argv)
>> +{
>> +       /* nothing */
>> +}
>> +
>> +
>> +static bool
>> +test_offset_stride(int color_offset, int stride)
>> +{
>> +       static const GLfloat vertex[4][2] = {
>> +               { -1, -1 },
>> +               {  1, -1 },
>> +               {  1,  1 },
>> +               { -1,  1 }
>> +       };
>> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
>> +       GLubyte buffer[1000];
>> +       GLuint buf;
>> +       int i, pos;
>> +       bool p;
>> +
>> +       assert(color_offset >= sizeof(vertex[0]));
>> +       assert(stride >= color_offset + sizeof(color));
>> +
>> +       pos = 0;
>> +       for (i = 0; i < 4; i++) {
>> +               /* copy vertex position into buffer */
>> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
>> +
>> +               /* copy vertex color into buffer at unusual offset */
>> +               memcpy(buffer + pos + color_offset, color, sizeof(color));
>> +
>> +               pos += stride;
>> +       }
>> +       assert(pos <= sizeof(buffer));
>> +
>> +       glGenBuffers(1, &buf);
>> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
>> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
>> +                                        buffer, GL_STATIC_DRAW);
>> +
>> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
>> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t) color_offset);
>> +       glEnable(GL_VERTEX_ARRAY);
>> +       glEnable(GL_COLOR_ARRAY);
>> +
>> +       glClear(GL_COLOR_BUFFER_BIT);
>> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
>> +
>> +       p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, color);
>> +
>> +       if (!p) {
>> +               printf("failure for color_offset %d, stride %d\n",
>> +                      color_offset, stride);
>> +       }
>> +
>> +       piglit_present_results();
>> +
>> +       glDeleteBuffers(1, &buf);
>> +
>> +       return p;
>> +}
>> +
>> +
>> +enum piglit_result
>> +piglit_display(void)
>> +{
>> +       bool pass = true;
>> +
>> +       /* test nice values */
>> +       pass = test_offset_stride(8, 24) && pass;
>> +       pass = test_offset_stride(12, 28) && pass;
>> +
>> +       /* test unual offset */
>> +       pass = test_offset_stride(9, 32) && pass;
>> +
>> +       /* test unual stride */
>> +       pass = test_offset_stride(8, 27) && pass;
>> +
>> +       /* test unusual offset, unusual stride */
>> +       pass = test_offset_stride(9, 25) && pass;
>> +       pass = test_offset_stride(10, 26) && pass;
>> +       pass = test_offset_stride(11, 27) && pass;
>> +
>> +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
>> +}
>> +
>> --
>> 1.9.1
>>
>> _______________________________________________
>> Piglit mailing list
>> Piglit@lists.freedesktop.org
>> https://urldefense.proofpoint.com/v2/url?u=http-3A__lists.freedesktop.org_mailman_listinfo_piglit&d=BQIFaQ&c=Sqcl0Ez6M0X8aeM67LKIiDJAXVeAw-YihVMNtXt-uEs&r=T0t4QG7chq2ZwJo6wilkFznRSFy-8uDKartPGbomVj8&m=GsYHAjfyXzQor4C9aShuDFG9eIbC97TCXuO1cCHEii0&s=zOtSuYSSWldW5NDpQIQ8kBCNkGUBOf-TCzDYT4ejpfI&e=
Brian,

Doesn't this test run afoul of the alignment requirements?

The OpenGL 1.5 specification, page 33 [first version in which this is
introduced;
equivalent language exists in later spec versions] says:

  "Clients must align data elements consistent with the requirements of the
  client platform, with an additional base-level requirement that an
offset within
  a buffer to a datum comprising N basic machine units be a multiple of N."

Non-naturally-aligned float attributes sourced from a buffer object would appear
to violate this rule - or have I misunderstood?

- Chris




On Sat, Jun 20, 2015 at 2:39 AM, Brian Paul <brianp@vmware.com> wrote:
> The draw-vertices tests exercises unusual vertex sizes and strides,
> but not with interleaved arrays.
>
> This test creates a VBO with interleaved vertex positions and colors.
> The colors are positioned at offsets like 9, 10 and 11 bytes from the
> start of the vertex.  Unusual strides between vertices are tested too.
>
> Exercises a bug in Gallium's u_vbuf code where the driver was passed
> pipe_vertex_element::src_offset values which weren't a multiple of
> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
> returned 1.
> ---
>  tests/all.py                              |   1 +
>  tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>  tests/spec/gl-1.5/vertex-buffer-offsets.c | 124 ++++++++++++++++++++++++++++++
>  3 files changed, 126 insertions(+)
>  create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>
> diff --git a/tests/all.py b/tests/all.py
> index ad4c494..ee11be6 100755
> --- a/tests/all.py
> +++ b/tests/all.py
> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>        'normal3b3s-invariance-byte', run_concurrent=False)
>      g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>        'normal3b3s-invariance-short', run_concurrent=False)
> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>
>  with profile.group_manager(
>          PiglitGLTest,
> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt b/tests/spec/gl-1.5/CMakeLists.gl.txt
> index 8dcd95d..f10c6cb 100644
> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
> @@ -10,5 +10,6 @@ link_libraries (
>  )
>
>  piglit_add_executable (gl-1.5-normal3b3s-invariance normal3b3s-invariance.c)
> +piglit_add_executable (gl-1.5-vertex-buffer-offsets vertex-buffer-offsets.c)
>
>  # vim: ft=cmake:
> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c b/tests/spec/gl-1.5/vertex-buffer-offsets.c
> new file mode 100644
> index 0000000..6d58331
> --- /dev/null
> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
> @@ -0,0 +1,124 @@
> +/*
> + * Copyright 2015  VMware, Inc.
> + *
> + * Permission is hereby granted, free of charge, to any person obtaining a
> + * copy of this software and associated documentation files (the "Software"),
> + * to deal in the Software without restriction, including without limitation
> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
> + * and/or sell copies of the Software, and to permit persons to whom the
> + * Software is furnished to do so, subject to the following conditions:
> + *
> + * The above copyright notice and this permission notice (including the next
> + * paragraph) shall be included in all copies or substantial portions of the
> + * Software.
> + *
> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> + * DEALINGS IN THE SOFTWARE.
> + */
> +
> +/*
> + * Test interleaved vertex arrays with unusual element offsets and strides.
> + * Brian Paul
> + */
> +
> +#include "piglit-util-gl.h"
> +
> +PIGLIT_GL_TEST_CONFIG_BEGIN
> +       config.supports_gl_compat_version = 15;
> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
> +PIGLIT_GL_TEST_CONFIG_END
> +
> +
> +void
> +piglit_init(int argc, char **argv)
> +{
> +       /* nothing */
> +}
> +
> +
> +static bool
> +test_offset_stride(int color_offset, int stride)
> +{
> +       static const GLfloat vertex[4][2] = {
> +               { -1, -1 },
> +               {  1, -1 },
> +               {  1,  1 },
> +               { -1,  1 }
> +       };
> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
> +       GLubyte buffer[1000];
> +       GLuint buf;
> +       int i, pos;
> +       bool p;
> +
> +       assert(color_offset >= sizeof(vertex[0]));
> +       assert(stride >= color_offset + sizeof(color));
> +
> +       pos = 0;
> +       for (i = 0; i < 4; i++) {
> +               /* copy vertex position into buffer */
> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
> +
> +               /* copy vertex color into buffer at unusual offset */
> +               memcpy(buffer + pos + color_offset, color, sizeof(color));
> +
> +               pos += stride;
> +       }
> +       assert(pos <= sizeof(buffer));
> +
> +       glGenBuffers(1, &buf);
> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
> +                                        buffer, GL_STATIC_DRAW);
> +
> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t) color_offset);
> +       glEnable(GL_VERTEX_ARRAY);
> +       glEnable(GL_COLOR_ARRAY);
> +
> +       glClear(GL_COLOR_BUFFER_BIT);
> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
> +
> +       p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, color);
> +
> +       if (!p) {
> +               printf("failure for color_offset %d, stride %d\n",
> +                      color_offset, stride);
> +       }
> +
> +       piglit_present_results();
> +
> +       glDeleteBuffers(1, &buf);
> +
> +       return p;
> +}
> +
> +
> +enum piglit_result
> +piglit_display(void)
> +{
> +       bool pass = true;
> +
> +       /* test nice values */
> +       pass = test_offset_stride(8, 24) && pass;
> +       pass = test_offset_stride(12, 28) && pass;
> +
> +       /* test unual offset */
> +       pass = test_offset_stride(9, 32) && pass;
> +
> +       /* test unual stride */
> +       pass = test_offset_stride(8, 27) && pass;
> +
> +       /* test unusual offset, unusual stride */
> +       pass = test_offset_stride(9, 25) && pass;
> +       pass = test_offset_stride(10, 26) && pass;
> +       pass = test_offset_stride(11, 27) && pass;
> +
> +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> +}
> +
> --
> 1.9.1
>
> _______________________________________________
> Piglit mailing list
> Piglit@lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
It depends on the platform.  But x86 doesn't require floats to be 4-byte aligned. https://en.wikipedia.org/wiki/Data_structure_alignment#x86

I don't know about other platforms though -- it might be indeed necessary to skip or be less strict on non-x86 platforms.

I'm having trouble interpreting the "additional base-level requirement" means. Is it saying that a an offset to a float (4bytes), must be 4bytes aligned, regardless the platform can deal with non- 4-byte aligned floats? 

Jose
Jose,

I believe that's exactly what it's saying, yes.

- Chris

On Sun, Jun 21, 2015 at 8:00 PM, Jose Fonseca <jfonseca@vmware.com> wrote:
> It depends on the platform.  But x86 doesn't require floats to be 4-byte aligned. https://en.wikipedia.org/wiki/Data_structure_alignment#x86
>
> I don't know about other platforms though -- it might be indeed necessary to skip or be less strict on non-x86 platforms.
>
> I'm having trouble interpreting the "additional base-level requirement" means. Is it saying that a an offset to a float (4bytes), must be 4bytes aligned, regardless the platform can deal with non- 4-byte aligned floats?
>
> Jose
>
> ________________________________________
> From: Piglit <piglit-bounces@lists.freedesktop.org> on behalf of Chris Forbes <chrisf@ijw.co.nz>
> Sent: 20 June 2015 11:32
> To: Brian Paul
> Cc: piglit@lists.freedesktop.org
> Subject: Re: [Piglit] [PATCH] gl-1.5-vertex-buffer-offsets: test unusual vertex offsets/strides
>
> Brian,
>
> Doesn't this test run afoul of the alignment requirements?
>
> The OpenGL 1.5 specification, page 33 [first version in which this is
> introduced;
> equivalent language exists in later spec versions] says:
>
>   "Clients must align data elements consistent with the requirements of the
>   client platform, with an additional base-level requirement that an
> offset within
>   a buffer to a datum comprising N basic machine units be a multiple of N."
>
> Non-naturally-aligned float attributes sourced from a buffer object would appear
> to violate this rule - or have I misunderstood?
>
> - Chris
>
>
>
>
> On Sat, Jun 20, 2015 at 2:39 AM, Brian Paul <brianp@vmware.com> wrote:
>> The draw-vertices tests exercises unusual vertex sizes and strides,
>> but not with interleaved arrays.
>>
>> This test creates a VBO with interleaved vertex positions and colors.
>> The colors are positioned at offsets like 9, 10 and 11 bytes from the
>> start of the vertex.  Unusual strides between vertices are tested too.
>>
>> Exercises a bug in Gallium's u_vbuf code where the driver was passed
>> pipe_vertex_element::src_offset values which weren't a multiple of
>> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
>> returned 1.
>> ---
>>  tests/all.py                              |   1 +
>>  tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>>  tests/spec/gl-1.5/vertex-buffer-offsets.c | 124 ++++++++++++++++++++++++++++++
>>  3 files changed, 126 insertions(+)
>>  create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>>
>> diff --git a/tests/all.py b/tests/all.py
>> index ad4c494..ee11be6 100755
>> --- a/tests/all.py
>> +++ b/tests/all.py
>> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>>        'normal3b3s-invariance-byte', run_concurrent=False)
>>      g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>>        'normal3b3s-invariance-short', run_concurrent=False)
>> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>>
>>  with profile.group_manager(
>>          PiglitGLTest,
>> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt b/tests/spec/gl-1.5/CMakeLists.gl.txt
>> index 8dcd95d..f10c6cb 100644
>> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
>> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
>> @@ -10,5 +10,6 @@ link_libraries (
>>  )
>>
>>  piglit_add_executable (gl-1.5-normal3b3s-invariance normal3b3s-invariance.c)
>> +piglit_add_executable (gl-1.5-vertex-buffer-offsets vertex-buffer-offsets.c)
>>
>>  # vim: ft=cmake:
>> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>> new file mode 100644
>> index 0000000..6d58331
>> --- /dev/null
>> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>> @@ -0,0 +1,124 @@
>> +/*
>> + * Copyright 2015  VMware, Inc.
>> + *
>> + * Permission is hereby granted, free of charge, to any person obtaining a
>> + * copy of this software and associated documentation files (the "Software"),
>> + * to deal in the Software without restriction, including without limitation
>> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
>> + * and/or sell copies of the Software, and to permit persons to whom the
>> + * Software is furnished to do so, subject to the following conditions:
>> + *
>> + * The above copyright notice and this permission notice (including the next
>> + * paragraph) shall be included in all copies or substantial portions of the
>> + * Software.
>> + *
>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
>> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>> + * DEALINGS IN THE SOFTWARE.
>> + */
>> +
>> +/*
>> + * Test interleaved vertex arrays with unusual element offsets and strides.
>> + * Brian Paul
>> + */
>> +
>> +#include "piglit-util-gl.h"
>> +
>> +PIGLIT_GL_TEST_CONFIG_BEGIN
>> +       config.supports_gl_compat_version = 15;
>> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
>> +PIGLIT_GL_TEST_CONFIG_END
>> +
>> +
>> +void
>> +piglit_init(int argc, char **argv)
>> +{
>> +       /* nothing */
>> +}
>> +
>> +
>> +static bool
>> +test_offset_stride(int color_offset, int stride)
>> +{
>> +       static const GLfloat vertex[4][2] = {
>> +               { -1, -1 },
>> +               {  1, -1 },
>> +               {  1,  1 },
>> +               { -1,  1 }
>> +       };
>> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
>> +       GLubyte buffer[1000];
>> +       GLuint buf;
>> +       int i, pos;
>> +       bool p;
>> +
>> +       assert(color_offset >= sizeof(vertex[0]));
>> +       assert(stride >= color_offset + sizeof(color));
>> +
>> +       pos = 0;
>> +       for (i = 0; i < 4; i++) {
>> +               /* copy vertex position into buffer */
>> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
>> +
>> +               /* copy vertex color into buffer at unusual offset */
>> +               memcpy(buffer + pos + color_offset, color, sizeof(color));
>> +
>> +               pos += stride;
>> +       }
>> +       assert(pos <= sizeof(buffer));
>> +
>> +       glGenBuffers(1, &buf);
>> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
>> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
>> +                                        buffer, GL_STATIC_DRAW);
>> +
>> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
>> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t) color_offset);
>> +       glEnable(GL_VERTEX_ARRAY);
>> +       glEnable(GL_COLOR_ARRAY);
>> +
>> +       glClear(GL_COLOR_BUFFER_BIT);
>> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
>> +
>> +       p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, color);
>> +
>> +       if (!p) {
>> +               printf("failure for color_offset %d, stride %d\n",
>> +                      color_offset, stride);
>> +       }
>> +
>> +       piglit_present_results();
>> +
>> +       glDeleteBuffers(1, &buf);
>> +
>> +       return p;
>> +}
>> +
>> +
>> +enum piglit_result
>> +piglit_display(void)
>> +{
>> +       bool pass = true;
>> +
>> +       /* test nice values */
>> +       pass = test_offset_stride(8, 24) && pass;
>> +       pass = test_offset_stride(12, 28) && pass;
>> +
>> +       /* test unual offset */
>> +       pass = test_offset_stride(9, 32) && pass;
>> +
>> +       /* test unual stride */
>> +       pass = test_offset_stride(8, 27) && pass;
>> +
>> +       /* test unusual offset, unusual stride */
>> +       pass = test_offset_stride(9, 25) && pass;
>> +       pass = test_offset_stride(10, 26) && pass;
>> +       pass = test_offset_stride(11, 27) && pass;
>> +
>> +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
>> +}
>> +
>> --
>> 1.9.1
>>
>> _______________________________________________
>> Piglit mailing list
>> Piglit@lists.freedesktop.org
>> http://lists.freedesktop.org/mailman/listinfo/piglit
> _______________________________________________
> Piglit mailing list
> Piglit@lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
Thanks for pointing that out, Chris.  I had forgotten about that language.

This test came about after fixing a bug in our driver when running the 
game Flockers, from Steam.  It has a few vertex arrays with unusual 
layout.  I'll have to go back and double-check the data type.  Maybe it 
was ubyte instead of float...

-Brian

On 06/21/2015 03:41 AM, Chris Forbes wrote:
> Jose,
>
> I believe that's exactly what it's saying, yes.
>
> - Chris
>
> On Sun, Jun 21, 2015 at 8:00 PM, Jose Fonseca <jfonseca@vmware.com> wrote:
>> It depends on the platform.  But x86 doesn't require floats to be 4-byte aligned. https://urldefense.proofpoint.com/v2/url?u=https-3A__en.wikipedia.org_wiki_Data-5Fstructure-5Falignment-23x86&d=BQIBaQ&c=Sqcl0Ez6M0X8aeM67LKIiDJAXVeAw-YihVMNtXt-uEs&r=T0t4QG7chq2ZwJo6wilkFznRSFy-8uDKartPGbomVj8&m=hoZapaHEiAtCP0Hl8wUx6-p35QL0Xat2wQTeFYWssvk&s=udFG-s3z0zheKxzbzEgjB4bmtZ0DLIn3FVJLIpf8L2E&e=
>>
>> I don't know about other platforms though -- it might be indeed necessary to skip or be less strict on non-x86 platforms.
>>
>> I'm having trouble interpreting the "additional base-level requirement" means. Is it saying that a an offset to a float (4bytes), must be 4bytes aligned, regardless the platform can deal with non- 4-byte aligned floats?
>>
>> Jose
>>
>> ________________________________________
>> From: Piglit <piglit-bounces@lists.freedesktop.org> on behalf of Chris Forbes <chrisf@ijw.co.nz>
>> Sent: 20 June 2015 11:32
>> To: Brian Paul
>> Cc: piglit@lists.freedesktop.org
>> Subject: Re: [Piglit] [PATCH] gl-1.5-vertex-buffer-offsets: test unusual vertex offsets/strides
>>
>> Brian,
>>
>> Doesn't this test run afoul of the alignment requirements?
>>
>> The OpenGL 1.5 specification, page 33 [first version in which this is
>> introduced;
>> equivalent language exists in later spec versions] says:
>>
>>    "Clients must align data elements consistent with the requirements of the
>>    client platform, with an additional base-level requirement that an
>> offset within
>>    a buffer to a datum comprising N basic machine units be a multiple of N."
>>
>> Non-naturally-aligned float attributes sourced from a buffer object would appear
>> to violate this rule - or have I misunderstood?
>>
>> - Chris
>>
>>
>>
>>
>> On Sat, Jun 20, 2015 at 2:39 AM, Brian Paul <brianp@vmware.com> wrote:
>>> The draw-vertices tests exercises unusual vertex sizes and strides,
>>> but not with interleaved arrays.
>>>
>>> This test creates a VBO with interleaved vertex positions and colors.
>>> The colors are positioned at offsets like 9, 10 and 11 bytes from the
>>> start of the vertex.  Unusual strides between vertices are tested too.
>>>
>>> Exercises a bug in Gallium's u_vbuf code where the driver was passed
>>> pipe_vertex_element::src_offset values which weren't a multiple of
>>> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
>>> returned 1.
>>> ---
>>>   tests/all.py                              |   1 +
>>>   tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>>>   tests/spec/gl-1.5/vertex-buffer-offsets.c | 124 ++++++++++++++++++++++++++++++
>>>   3 files changed, 126 insertions(+)
>>>   create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>>>
>>> diff --git a/tests/all.py b/tests/all.py
>>> index ad4c494..ee11be6 100755
>>> --- a/tests/all.py
>>> +++ b/tests/all.py
>>> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>>>         'normal3b3s-invariance-byte', run_concurrent=False)
>>>       g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>>>         'normal3b3s-invariance-short', run_concurrent=False)
>>> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>>>
>>>   with profile.group_manager(
>>>           PiglitGLTest,
>>> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt b/tests/spec/gl-1.5/CMakeLists.gl.txt
>>> index 8dcd95d..f10c6cb 100644
>>> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
>>> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
>>> @@ -10,5 +10,6 @@ link_libraries (
>>>   )
>>>
>>>   piglit_add_executable (gl-1.5-normal3b3s-invariance normal3b3s-invariance.c)
>>> +piglit_add_executable (gl-1.5-vertex-buffer-offsets vertex-buffer-offsets.c)
>>>
>>>   # vim: ft=cmake:
>>> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>>> new file mode 100644
>>> index 0000000..6d58331
>>> --- /dev/null
>>> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>>> @@ -0,0 +1,124 @@
>>> +/*
>>> + * Copyright 2015  VMware, Inc.
>>> + *
>>> + * Permission is hereby granted, free of charge, to any person obtaining a
>>> + * copy of this software and associated documentation files (the "Software"),
>>> + * to deal in the Software without restriction, including without limitation
>>> + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
>>> + * and/or sell copies of the Software, and to permit persons to whom the
>>> + * Software is furnished to do so, subject to the following conditions:
>>> + *
>>> + * The above copyright notice and this permission notice (including the next
>>> + * paragraph) shall be included in all copies or substantial portions of the
>>> + * Software.
>>> + *
>>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
>>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
>>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
>>> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
>>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
>>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>>> + * DEALINGS IN THE SOFTWARE.
>>> + */
>>> +
>>> +/*
>>> + * Test interleaved vertex arrays with unusual element offsets and strides.
>>> + * Brian Paul
>>> + */
>>> +
>>> +#include "piglit-util-gl.h"
>>> +
>>> +PIGLIT_GL_TEST_CONFIG_BEGIN
>>> +       config.supports_gl_compat_version = 15;
>>> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA | PIGLIT_GL_VISUAL_DOUBLE;
>>> +PIGLIT_GL_TEST_CONFIG_END
>>> +
>>> +
>>> +void
>>> +piglit_init(int argc, char **argv)
>>> +{
>>> +       /* nothing */
>>> +}
>>> +
>>> +
>>> +static bool
>>> +test_offset_stride(int color_offset, int stride)
>>> +{
>>> +       static const GLfloat vertex[4][2] = {
>>> +               { -1, -1 },
>>> +               {  1, -1 },
>>> +               {  1,  1 },
>>> +               { -1,  1 }
>>> +       };
>>> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
>>> +       GLubyte buffer[1000];
>>> +       GLuint buf;
>>> +       int i, pos;
>>> +       bool p;
>>> +
>>> +       assert(color_offset >= sizeof(vertex[0]));
>>> +       assert(stride >= color_offset + sizeof(color));
>>> +
>>> +       pos = 0;
>>> +       for (i = 0; i < 4; i++) {
>>> +               /* copy vertex position into buffer */
>>> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
>>> +
>>> +               /* copy vertex color into buffer at unusual offset */
>>> +               memcpy(buffer + pos + color_offset, color, sizeof(color));
>>> +
>>> +               pos += stride;
>>> +       }
>>> +       assert(pos <= sizeof(buffer));
>>> +
>>> +       glGenBuffers(1, &buf);
>>> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
>>> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
>>> +                                        buffer, GL_STATIC_DRAW);
>>> +
>>> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
>>> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t) color_offset);
>>> +       glEnable(GL_VERTEX_ARRAY);
>>> +       glEnable(GL_COLOR_ARRAY);
>>> +
>>> +       glClear(GL_COLOR_BUFFER_BIT);
>>> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
>>> +
>>> +       p = piglit_probe_rect_rgba(0, 0, piglit_width, piglit_height, color);
>>> +
>>> +       if (!p) {
>>> +               printf("failure for color_offset %d, stride %d\n",
>>> +                      color_offset, stride);
>>> +       }
>>> +
>>> +       piglit_present_results();
>>> +
>>> +       glDeleteBuffers(1, &buf);
>>> +
>>> +       return p;
>>> +}
>>> +
>>> +
>>> +enum piglit_result
>>> +piglit_display(void)
>>> +{
>>> +       bool pass = true;
>>> +
>>> +       /* test nice values */
>>> +       pass = test_offset_stride(8, 24) && pass;
>>> +       pass = test_offset_stride(12, 28) && pass;
>>> +
>>> +       /* test unual offset */
>>> +       pass = test_offset_stride(9, 32) && pass;
>>> +
>>> +       /* test unual stride */
>>> +       pass = test_offset_stride(8, 27) && pass;
>>> +
>>> +       /* test unusual offset, unusual stride */
>>> +       pass = test_offset_stride(9, 25) && pass;
>>> +       pass = test_offset_stride(10, 26) && pass;
>>> +       pass = test_offset_stride(11, 27) && pass;
>>> +
>>> +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
>>> +}
>>> +
>>> --
>>> 1.9.1
>>>
>>> _______________________________________________
>>> Piglit mailing list
>>> Piglit@lists.freedesktop.org
>>> https://urldefense.proofpoint.com/v2/url?u=http-3A__lists.freedesktop.org_mailman_listinfo_piglit&d=BQIBaQ&c=Sqcl0Ez6M0X8aeM67LKIiDJAXVeAw-YihVMNtXt-uEs&r=T0t4QG7chq2ZwJo6wilkFznRSFy-8uDKartPGbomVj8&m=hoZapaHEiAtCP0Hl8wUx6-p35QL0Xat2wQTeFYWssvk&s=uSgoC10Qu989rrrVkIE8_v6OFO5H-_8JffnukAqgkIs&e=
>> _______________________________________________
>> Piglit mailing list
>> Piglit@lists.freedesktop.org
>> https://urldefense.proofpoint.com/v2/url?u=http-3A__lists.freedesktop.org_mailman_listinfo_piglit&d=BQIBaQ&c=Sqcl0Ez6M0X8aeM67LKIiDJAXVeAw-YihVMNtXt-uEs&r=T0t4QG7chq2ZwJo6wilkFznRSFy-8uDKartPGbomVj8&m=hoZapaHEiAtCP0Hl8wUx6-p35QL0Xat2wQTeFYWssvk&s=uSgoC10Qu989rrrVkIE8_v6OFO5H-_8JffnukAqgkIs&e=
OK, my piglit test does test what Flockers is doing.  At the failure 
point there are 8 vertex arrays in use.

Using _mesa_print_arrays():

   Vertex: Ptr=00000000, Type=GL_FLOAT, Size=3, ElemSize=12, Stride=87, 
Buffer=1041(Size 21489)
   Normal: Ptr=0000000C, Type=GL_FLOAT, Size=3, ElemSize=12, Stride=87, 
Buffer=1041(Size 21489)
   Color: Ptr=00000030, Type=GL_FLOAT, Size=4, ElemSize=16, Stride=87, 
Buffer=1041(Size 21489)
   TexCoord[0]: Ptr=00000040, Type=GL_FLOAT, Size=2, ElemSize=8, 
Stride=87, Buffer=1041(Size 21489)
   Attrib[1]: Ptr=0000004B, Type=GL_FLOAT, Size=3, ElemSize=12, 
Stride=87, Buffer=1041(Size 21489)
   Attrib[4]: Ptr=00000048, Type=GL_UNSIGNED_BYTE, Size=3, ElemSize=3, 
Stride=87, Buffer=1041(Size 21489)
   Attrib[14]: Ptr=00000024, Type=GL_FLOAT, Size=3, ElemSize=12, 
Stride=87, Buffer=1041(Size 21489)
   Attrib[15]: Ptr=00000018, Type=GL_FLOAT, Size=3, ElemSize=12, 
Stride=87, Buffer=1041(Size 21489)

The Attrib[1] array is float[3] at offset(Ptr) 75 (0x4B) bytes.  Also 
note that the stride between vertices is 87 bytes so clearly there's no 
regard to 4-byte float alignment.

I kind of wish the spec had language saying glVertexPointer, etc. 
generated GL_INVALID_OPERATION if the stride or offset didn't meet 
alignment restrictions.  Too late now.

We could add some debug code in Mesa to warn on unaligned arrays too.

How about this: I could modify the piglit test to generate PIGLIT_WARN 
instead of FAIL if there's a rendering failure.  I can also mention this 
Flockers issue in the comments in the piglit test for future reference.

NVIDIA's driver handles all the cases in the piglit test (and it renders 
Flockers correctly).

-Brian



On 06/22/2015 07:26 AM, Brian Paul wrote:
> Thanks for pointing that out, Chris.  I had forgotten about that language.
>
> This test came about after fixing a bug in our driver when running the
> game Flockers, from Steam.  It has a few vertex arrays with unusual
> layout.  I'll have to go back and double-check the data type.  Maybe it
> was ubyte instead of float...
>
> -Brian
>
> On 06/21/2015 03:41 AM, Chris Forbes wrote:
>> Jose,
>>
>> I believe that's exactly what it's saying, yes.
>>
>> - Chris
>>
>> On Sun, Jun 21, 2015 at 8:00 PM, Jose Fonseca <jfonseca@vmware.com>
>> wrote:
>>> It depends on the platform.  But x86 doesn't require floats to be
>>> 4-byte aligned.
>>> https://urldefense.proofpoint.com/v2/url?u=https-3A__en.wikipedia.org_wiki_Data-5Fstructure-5Falignment-23x86&d=BQIBaQ&c=Sqcl0Ez6M0X8aeM67LKIiDJAXVeAw-YihVMNtXt-uEs&r=T0t4QG7chq2ZwJo6wilkFznRSFy-8uDKartPGbomVj8&m=hoZapaHEiAtCP0Hl8wUx6-p35QL0Xat2wQTeFYWssvk&s=udFG-s3z0zheKxzbzEgjB4bmtZ0DLIn3FVJLIpf8L2E&e=
>>>
>>>
>>> I don't know about other platforms though -- it might be indeed
>>> necessary to skip or be less strict on non-x86 platforms.
>>>
>>> I'm having trouble interpreting the "additional base-level
>>> requirement" means. Is it saying that a an offset to a float
>>> (4bytes), must be 4bytes aligned, regardless the platform can deal
>>> with non- 4-byte aligned floats?
>>>
>>> Jose
>>>
>>> ________________________________________
>>> From: Piglit <piglit-bounces@lists.freedesktop.org> on behalf of
>>> Chris Forbes <chrisf@ijw.co.nz>
>>> Sent: 20 June 2015 11:32
>>> To: Brian Paul
>>> Cc: piglit@lists.freedesktop.org
>>> Subject: Re: [Piglit] [PATCH] gl-1.5-vertex-buffer-offsets: test
>>> unusual vertex offsets/strides
>>>
>>> Brian,
>>>
>>> Doesn't this test run afoul of the alignment requirements?
>>>
>>> The OpenGL 1.5 specification, page 33 [first version in which this is
>>> introduced;
>>> equivalent language exists in later spec versions] says:
>>>
>>>    "Clients must align data elements consistent with the requirements
>>> of the
>>>    client platform, with an additional base-level requirement that an
>>> offset within
>>>    a buffer to a datum comprising N basic machine units be a multiple
>>> of N."
>>>
>>> Non-naturally-aligned float attributes sourced from a buffer object
>>> would appear
>>> to violate this rule - or have I misunderstood?
>>>
>>> - Chris
>>>
>>>
>>>
>>>
>>> On Sat, Jun 20, 2015 at 2:39 AM, Brian Paul <brianp@vmware.com> wrote:
>>>> The draw-vertices tests exercises unusual vertex sizes and strides,
>>>> but not with interleaved arrays.
>>>>
>>>> This test creates a VBO with interleaved vertex positions and colors.
>>>> The colors are positioned at offsets like 9, 10 and 11 bytes from the
>>>> start of the vertex.  Unusual strides between vertices are tested too.
>>>>
>>>> Exercises a bug in Gallium's u_vbuf code where the driver was passed
>>>> pipe_vertex_element::src_offset values which weren't a multiple of
>>>> four, even when PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY
>>>> returned 1.
>>>> ---
>>>>   tests/all.py                              |   1 +
>>>>   tests/spec/gl-1.5/CMakeLists.gl.txt       |   1 +
>>>>   tests/spec/gl-1.5/vertex-buffer-offsets.c | 124
>>>> ++++++++++++++++++++++++++++++
>>>>   3 files changed, 126 insertions(+)
>>>>   create mode 100644 tests/spec/gl-1.5/vertex-buffer-offsets.c
>>>>
>>>> diff --git a/tests/all.py b/tests/all.py
>>>> index ad4c494..ee11be6 100755
>>>> --- a/tests/all.py
>>>> +++ b/tests/all.py
>>>> @@ -1042,6 +1042,7 @@ with profile.group_manager(
>>>>         'normal3b3s-invariance-byte', run_concurrent=False)
>>>>       g(['gl-1.5-normal3b3s-invariance', 'GL_SHORT'],
>>>>         'normal3b3s-invariance-short', run_concurrent=False)
>>>> +    g(['gl-1.5-vertex-buffer-offsets'], 'vertex-buffer-offsets')
>>>>
>>>>   with profile.group_manager(
>>>>           PiglitGLTest,
>>>> diff --git a/tests/spec/gl-1.5/CMakeLists.gl.txt
>>>> b/tests/spec/gl-1.5/CMakeLists.gl.txt
>>>> index 8dcd95d..f10c6cb 100644
>>>> --- a/tests/spec/gl-1.5/CMakeLists.gl.txt
>>>> +++ b/tests/spec/gl-1.5/CMakeLists.gl.txt
>>>> @@ -10,5 +10,6 @@ link_libraries (
>>>>   )
>>>>
>>>>   piglit_add_executable (gl-1.5-normal3b3s-invariance
>>>> normal3b3s-invariance.c)
>>>> +piglit_add_executable (gl-1.5-vertex-buffer-offsets
>>>> vertex-buffer-offsets.c)
>>>>
>>>>   # vim: ft=cmake:
>>>> diff --git a/tests/spec/gl-1.5/vertex-buffer-offsets.c
>>>> b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>>>> new file mode 100644
>>>> index 0000000..6d58331
>>>> --- /dev/null
>>>> +++ b/tests/spec/gl-1.5/vertex-buffer-offsets.c
>>>> @@ -0,0 +1,124 @@
>>>> +/*
>>>> + * Copyright 2015  VMware, Inc.
>>>> + *
>>>> + * Permission is hereby granted, free of charge, to any person
>>>> obtaining a
>>>> + * copy of this software and associated documentation files (the
>>>> "Software"),
>>>> + * to deal in the Software without restriction, including without
>>>> limitation
>>>> + * the rights to use, copy, modify, merge, publish, distribute,
>>>> sublicense,
>>>> + * and/or sell copies of the Software, and to permit persons to
>>>> whom the
>>>> + * Software is furnished to do so, subject to the following
>>>> conditions:
>>>> + *
>>>> + * The above copyright notice and this permission notice (including
>>>> the next
>>>> + * paragraph) shall be included in all copies or substantial
>>>> portions of the
>>>> + * Software.
>>>> + *
>>>> + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
>>>> EXPRESS OR
>>>> + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
>>>> MERCHANTABILITY,
>>>> + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO
>>>> EVENT SHALL
>>>> + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
>>>> DAMAGES OR OTHER
>>>> + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
>>>> ARISING
>>>> + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
>>>> + * DEALINGS IN THE SOFTWARE.
>>>> + */
>>>> +
>>>> +/*
>>>> + * Test interleaved vertex arrays with unusual element offsets and
>>>> strides.
>>>> + * Brian Paul
>>>> + */
>>>> +
>>>> +#include "piglit-util-gl.h"
>>>> +
>>>> +PIGLIT_GL_TEST_CONFIG_BEGIN
>>>> +       config.supports_gl_compat_version = 15;
>>>> +       config.window_visual = PIGLIT_GL_VISUAL_RGBA |
>>>> PIGLIT_GL_VISUAL_DOUBLE;
>>>> +PIGLIT_GL_TEST_CONFIG_END
>>>> +
>>>> +
>>>> +void
>>>> +piglit_init(int argc, char **argv)
>>>> +{
>>>> +       /* nothing */
>>>> +}
>>>> +
>>>> +
>>>> +static bool
>>>> +test_offset_stride(int color_offset, int stride)
>>>> +{
>>>> +       static const GLfloat vertex[4][2] = {
>>>> +               { -1, -1 },
>>>> +               {  1, -1 },
>>>> +               {  1,  1 },
>>>> +               { -1,  1 }
>>>> +       };
>>>> +       static const GLfloat color[4] = { 0.0, 1.0, 0.5, 1.0 };
>>>> +       GLubyte buffer[1000];
>>>> +       GLuint buf;
>>>> +       int i, pos;
>>>> +       bool p;
>>>> +
>>>> +       assert(color_offset >= sizeof(vertex[0]));
>>>> +       assert(stride >= color_offset + sizeof(color));
>>>> +
>>>> +       pos = 0;
>>>> +       for (i = 0; i < 4; i++) {
>>>> +               /* copy vertex position into buffer */
>>>> +               memcpy(buffer + pos, vertex[i], sizeof(vertex[i]));
>>>> +
>>>> +               /* copy vertex color into buffer at unusual offset */
>>>> +               memcpy(buffer + pos + color_offset, color,
>>>> sizeof(color));
>>>> +
>>>> +               pos += stride;
>>>> +       }
>>>> +       assert(pos <= sizeof(buffer));
>>>> +
>>>> +       glGenBuffers(1, &buf);
>>>> +       glBindBuffer(GL_ARRAY_BUFFER, buf);
>>>> +       glBufferData(GL_ARRAY_BUFFER, sizeof(buffer),
>>>> +                                        buffer, GL_STATIC_DRAW);
>>>> +
>>>> +       glVertexPointer(2, GL_FLOAT, stride, (void *) 0);
>>>> +       glColorPointer(4, GL_FLOAT, stride, (void *) (size_t)
>>>> color_offset);
>>>> +       glEnable(GL_VERTEX_ARRAY);
>>>> +       glEnable(GL_COLOR_ARRAY);
>>>> +
>>>> +       glClear(GL_COLOR_BUFFER_BIT);
>>>> +       glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
>>>> +
>>>> +       p = piglit_probe_rect_rgba(0, 0, piglit_width,
>>>> piglit_height, color);
>>>> +
>>>> +       if (!p) {
>>>> +               printf("failure for color_offset %d, stride %d\n",
>>>> +                      color_offset, stride);
>>>> +       }
>>>> +
>>>> +       piglit_present_results();
>>>> +
>>>> +       glDeleteBuffers(1, &buf);
>>>> +
>>>> +       return p;
>>>> +}
>>>> +
>>>> +
>>>> +enum piglit_result
>>>> +piglit_display(void)
>>>> +{
>>>> +       bool pass = true;
>>>> +
>>>> +       /* test nice values */
>>>> +       pass = test_offset_stride(8, 24) && pass;
>>>> +       pass = test_offset_stride(12, 28) && pass;
>>>> +
>>>> +       /* test unual offset */
>>>> +       pass = test_offset_stride(9, 32) && pass;
>>>> +
>>>> +       /* test unual stride */
>>>> +       pass = test_offset_stride(8, 27) && pass;
>>>> +
>>>> +       /* test unusual offset, unusual stride */
>>>> +       pass = test_offset_stride(9, 25) && pass;
>>>> +       pass = test_offset_stride(10, 26) && pass;
>>>> +       pass = test_offset_stride(11, 27) && pass;
>>>> +
>>>> +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
>>>> +}
>>>> +
>>>> --
>>>> 1.9.1
>>>>
>>>> _______________________________________________
>>>> Piglit mailing list
>>>> Piglit@lists.freedesktop.org
>>>> https://urldefense.proofpoint.com/v2/url?u=http-3A__lists.freedesktop.org_mailman_listinfo_piglit&d=BQIBaQ&c=Sqcl0Ez6M0X8aeM67LKIiDJAXVeAw-YihVMNtXt-uEs&r=T0t4QG7chq2ZwJo6wilkFznRSFy-8uDKartPGbomVj8&m=hoZapaHEiAtCP0Hl8wUx6-p35QL0Xat2wQTeFYWssvk&s=uSgoC10Qu989rrrVkIE8_v6OFO5H-_8JffnukAqgkIs&e=
>>>>
>>> _______________________________________________
>>> Piglit mailing list
>>> Piglit@lists.freedesktop.org
>>> https://urldefense.proofpoint.com/v2/url?u=http-3A__lists.freedesktop.org_mailman_listinfo_piglit&d=BQIBaQ&c=Sqcl0Ez6M0X8aeM67LKIiDJAXVeAw-YihVMNtXt-uEs&r=T0t4QG7chq2ZwJo6wilkFznRSFy-8uDKartPGbomVj8&m=hoZapaHEiAtCP0Hl8wUx6-p35QL0Xat2wQTeFYWssvk&s=uSgoC10Qu989rrrVkIE8_v6OFO5H-_8JffnukAqgkIs&e=
>>>
>