[Piglit] [PATCH] primitive-restart: test primitive-restart with VBO
Jordan Justen
jljusten at gmail.com
Wed May 9 16:56:38 PDT 2012
One additional note:
This test passed with NVidia's driver, but failed with llvmpipe.
I'm not certain if the test or llvmpipe is to blame. So, feedback
either pointing out a test flaw, or known issue with llvmpipe would be
appreciated.
Thanks,
-Jordan
On Wed, May 9, 2012 at 4:46 PM, Jordan Justen <jordan.l.justen at intel.com> wrote:
> Each of the glArrayElement/glDrawElements tests are now run with
> and without enabling VBO.
>
> Signed-off-by: Jordan Justen <jordan.l.justen at intel.com>
> ---
> tests/general/primitive-restart.c | 256 ++++++++++++++++++++++++-------------
> 1 file changed, 170 insertions(+), 86 deletions(-)
>
> diff --git a/tests/general/primitive-restart.c b/tests/general/primitive-restart.c
> index 3642ffa..1fe401d 100644
> --- a/tests/general/primitive-restart.c
> +++ b/tests/general/primitive-restart.c
> @@ -45,6 +45,8 @@ static GLboolean Have_NV;
> static GLboolean Have_31;
> static GLboolean TestGL31;
>
> +#define VBO_ON GL_TRUE
> +#define VBO_OFF GL_FALSE
>
> static GLboolean
> check_rendering(void)
> @@ -184,33 +186,71 @@ disable_restart(void)
> }
>
>
> -static void draw_all_indices(GLboolean one_by_one,
> - GLenum mode, GLsizei count,
> +static GLuint type_size(GLenum type)
> +{
> + switch (type) {
> + case GL_UNSIGNED_BYTE:
> + return sizeof(GLubyte);
> + case GL_UNSIGNED_SHORT:
> + return sizeof(GLushort);
> + case GL_UNSIGNED_INT:
> + return sizeof(GLuint);
> + default:
> + assert(0);
> + return 0;
> + }
> +}
> +
> +
> +static GLuint type_array_size(GLenum type, GLuint length)
> +{
> + return length * type_size(type);
> +}
> +
> +
> +static GLuint read_index_value(const GLvoid *indices, GLenum type, GLuint index)
> +{
> + switch (type) {
> + case GL_UNSIGNED_BYTE:
> + return (GLuint)((GLubyte*)indices)[index];
> + case GL_UNSIGNED_SHORT:
> + return (GLuint)((GLushort*)indices)[index];
> + case GL_UNSIGNED_INT:
> + return ((GLuint*)indices)[index];
> + default:
> + assert(0);
> + }
> +}
> +
> +
> +static void write_index_value(const GLvoid *indices, GLenum type, GLuint index, GLuint value)
> +{
> + switch (type) {
> + case GL_UNSIGNED_BYTE:
> + ((GLubyte*)indices)[index] = (GLubyte) value;
> + break;
> + case GL_UNSIGNED_SHORT:
> + ((GLushort*)indices)[index] = (GLushort) value;
> + break;
> + case GL_UNSIGNED_INT:
> + ((GLuint*)indices)[index] = value;
> + break;
> + default:
> + assert(0);
> + }
> +}
> +
> +
> +static void do_ArrayElement(GLenum mode, GLsizei count,
> GLenum type, const GLvoid *indices)
> {
> GLuint index;
>
> - if (one_by_one) {
> - glBegin(mode);
> - for (index = 0; index < count; index++) {
> - switch (type) {
> - case GL_UNSIGNED_BYTE:
> - glArrayElement(((GLubyte*)indices)[index]);
> - break;
> - case GL_UNSIGNED_SHORT:
> - glArrayElement(((GLushort*)indices)[index]);
> - break;
> - case GL_UNSIGNED_INT:
> - glArrayElement(((GLuint*)indices)[index]);
> - break;
> - default:
> - assert(0);
> - }
> - }
> - glEnd();
> - } else {
> - glDrawElements(mode, count, type, indices);
> + glBegin(mode);
> + for (index = 0; index < count; index++) {
> + glArrayElement(read_index_value(indices, type, index));
> }
> + glEnd();
> }
>
>
> @@ -218,17 +258,22 @@ static void draw_all_indices(GLboolean one_by_one,
> * Test glDrawElements() with glPrimitiveRestartIndexNV().
> */
> static GLboolean
> -test_draw_by_index(GLboolean one_by_one, GLenum primMode, GLenum indexType)
> +test_draw_by_index(GLboolean one_by_one, GLboolean use_vbo,
> + GLenum primMode, GLenum indexType)
> {
> #define NUM_VERTS 48
> #define NUM_ELEMS (NUM_VERTS * 5 / 4)
> GLfloat verts[NUM_VERTS+2][2];
> GLuint elements[NUM_ELEMS];
> + GLubyte indicies_buf[sizeof(elements)];
> GLfloat x, dx;
> GLuint restart_index;
> GLuint num_elems;
> GLboolean pass;
> const char *typeStr = NULL, *primStr = NULL;
> + GLuint vbo;
> + uintptr_t index_offset = sizeof(verts);
> + GLuint i, j;
>
> switch (indexType) {
> case GL_UNSIGNED_BYTE:
> @@ -251,7 +296,6 @@ test_draw_by_index(GLboolean one_by_one, GLenum primMode, GLenum indexType)
> dx = 20.0;
>
> if (primMode == GL_TRIANGLE_STRIP) {
> - GLuint i, j;
> const GLfloat y = 0.5 * piglit_height - 10.0, dy = 20.0;
> for (i = 0; i < NUM_VERTS / 2; i++) {
> verts[i*2+0][0] = x;
> @@ -263,16 +307,20 @@ test_draw_by_index(GLboolean one_by_one, GLenum primMode, GLenum indexType)
>
> /* setup elements to draw series of squares w/ tri strip */
> for (i = j = 0; i < NUM_VERTS; i++) {
> - elements[j++] = i;
> - if (i > 0 && i % 4 == 3)
> - elements[j++] = restart_index;
> + elements[j] = i;
> + write_index_value(indicies_buf, indexType, j, i);
> + j++;
> + if (i > 0 && i % 4 == 3) {
> + elements[j] = restart_index;
> + write_index_value(indicies_buf, indexType, j, restart_index);
> + j++;
> + }
> }
>
> num_elems = j;
> primStr = "GL_TRIANGLE_STRIP";
> }
> else {
> - GLuint i, j;
> const GLfloat y = 0.5 * piglit_height;
>
> assert(primMode == GL_LINE_STRIP);
> @@ -287,9 +335,14 @@ test_draw_by_index(GLboolean one_by_one, GLenum primMode, GLenum indexType)
>
> /* setup elements to draw series of disjoint lines w/ line strip */
> for (i = j = 0; i < NUM_VERTS / 2; i++) {
> - elements[j++] = i;
> - if (i > 0 && i % 2 == 1)
> - elements[j++] = restart_index;
> + elements[j] = i;
> + write_index_value(indicies_buf, indexType, j, i);
> + j++;
> + if (i > 0 && i % 2 == 1) {
> + elements[j] = restart_index;
> + write_index_value(indicies_buf, indexType, j, restart_index);
> + j++;
> + }
> }
>
> num_elems = j;
> @@ -311,48 +364,55 @@ test_draw_by_index(GLboolean one_by_one, GLenum primMode, GLenum indexType)
>
> glColor4fv(green);
>
> - glVertexPointer(2, GL_FLOAT, 2*sizeof(GLfloat), verts);
> + if (use_vbo) {
> + glGenBuffers(1, &vbo);
> + glBindBuffer(GL_ARRAY_BUFFER, vbo);
> + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vbo);
> + glBufferData(GL_ARRAY_BUFFER,
> + index_offset + sizeof(elements),
> + NULL, GL_STATIC_DRAW);
> + glBufferSubData(GL_ARRAY_BUFFER,
> + 0, sizeof(verts),
> + verts);
> + glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,
> + index_offset, type_array_size(indexType, num_elems),
> + indicies_buf);
> + glVertexPointer(2, GL_FLOAT, 0, (void *)0);
> + } else {
> + glVertexPointer(2, GL_FLOAT, 0, (void *)verts);
> + }
> +
> glEnableClientState(GL_VERTEX_ARRAY);
>
> assert(glGetError()==0);
> enable_restart(restart_index);
>
> /* Draw */
> - switch (indexType) {
> - case GL_UNSIGNED_BYTE:
> - {
> - GLubyte ub_elements[NUM_ELEMS];
> - int i;
> - for (i = 0; i < num_elems; i++)
> - ub_elements[i] = (GLubyte) elements[i];
> - draw_all_indices(one_by_one, primMode, num_elems, GL_UNSIGNED_BYTE, ub_elements);
> - }
> - break;
> - case GL_UNSIGNED_SHORT:
> - {
> - GLushort us_elements[NUM_ELEMS];
> - int i;
> - for (i = 0; i < num_elems; i++)
> - us_elements[i] = (GLushort) elements[i];
> - draw_all_indices(one_by_one, primMode, num_elems, GL_UNSIGNED_SHORT, us_elements);
> - }
> - break;
> - case GL_UNSIGNED_INT:
> - draw_all_indices(one_by_one, primMode, num_elems, GL_UNSIGNED_INT, elements);
> - break;
> - default:
> - assert(0);
> + if (one_by_one) {
> + do_ArrayElement(primMode, num_elems, indexType, indicies_buf);
> + } else if (use_vbo) {
> + glDrawElements(primMode, num_elems, indexType, (void*) index_offset);
> + } else {
> + glDrawElements(primMode, num_elems, indexType, indicies_buf);
> }
>
> disable_restart();
> +
> glDisableClientState(GL_VERTEX_ARRAY);
>
> + if (use_vbo) {
> + glBindBuffer(GL_ARRAY_BUFFER, 0);
> + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
> + glDeleteBuffers(1, &vbo);
> + }
> +
> pass = check_rendering();
> if (!pass) {
> - fprintf(stderr, "%s: failure drawing with %s(%s, %s)\n",
> + fprintf(stderr, "%s: failure drawing with %s(%s, %s), VBO=%s\n",
> TestName,
> one_by_one ? "glArrayElement" : "glDrawElements",
> - primStr, typeStr);
> + primStr, typeStr,
> + use_vbo ? "on" : "off");
> }
>
> piglit_present_results();
> @@ -366,9 +426,9 @@ test_draw_by_index(GLboolean one_by_one, GLenum primMode, GLenum indexType)
> * Test glDrawElements() with glPrimitiveRestartIndexNV().
> */
> static GLboolean
> -test_draw_elements(GLenum primMode, GLenum indexType)
> +test_draw_elements(GLboolean use_vbo, GLenum primMode, GLenum indexType)
> {
> - return test_draw_by_index(GL_FALSE, primMode, indexType);
> + return test_draw_by_index(GL_FALSE, use_vbo, primMode, indexType);
> }
>
>
> @@ -376,9 +436,9 @@ test_draw_elements(GLenum primMode, GLenum indexType)
> * Test glArrayElement() with glPrimitiveRestartIndexNV().
> */
> static GLboolean
> -test_array_element(GLenum primMode, GLenum indexType)
> +test_array_element(GLboolean use_vbo, GLenum primMode, GLenum indexType)
> {
> - return test_draw_by_index(GL_TRUE, primMode, indexType);
> + return test_draw_by_index(GL_TRUE, use_vbo, primMode, indexType);
> }
>
>
> @@ -498,35 +558,59 @@ piglit_display(void)
> TestGL31 = GL_FALSE;
> pass = pass && test_begin_end(GL_TRIANGLE_STRIP);
> pass = pass && test_begin_end(GL_LINE_STRIP);
> - pass = pass && test_draw_elements(GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> - pass = pass && test_draw_elements(GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> - pass = pass && test_draw_elements(GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> - pass = pass && test_draw_elements(GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> - pass = pass && test_draw_elements(GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> - pass = pass && test_draw_elements(GL_LINE_STRIP, GL_UNSIGNED_INT);
> - pass = pass && test_array_element(GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> - pass = pass && test_array_element(GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> - pass = pass && test_array_element(GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> - pass = pass && test_array_element(GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> - pass = pass && test_array_element(GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> - pass = pass && test_array_element(GL_LINE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_draw_elements(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_draw_elements(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_draw_elements(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_draw_elements(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_draw_elements(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_draw_elements(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_array_element(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_array_element(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_array_element(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_array_element(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_array_element(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_array_element(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_draw_elements(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_draw_elements(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_draw_elements(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_draw_elements(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_draw_elements(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_draw_elements(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_array_element(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_array_element(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_array_element(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_array_element(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_array_element(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_array_element(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_INT);
> pass = pass && test_draw_arrays();
> }
>
> if (Have_31) {
> TestGL31 = GL_TRUE;
> - pass = pass && test_draw_elements(GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> - pass = pass && test_draw_elements(GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> - pass = pass && test_draw_elements(GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> - pass = pass && test_draw_elements(GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> - pass = pass && test_draw_elements(GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> - pass = pass && test_draw_elements(GL_LINE_STRIP, GL_UNSIGNED_INT);
> - pass = pass && test_array_element(GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> - pass = pass && test_array_element(GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> - pass = pass && test_array_element(GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> - pass = pass && test_array_element(GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> - pass = pass && test_array_element(GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> - pass = pass && test_array_element(GL_LINE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_draw_elements(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_draw_elements(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_draw_elements(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_draw_elements(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_draw_elements(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_draw_elements(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_array_element(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_array_element(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_array_element(VBO_OFF, GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_array_element(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_array_element(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_array_element(VBO_OFF, GL_LINE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_draw_elements(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_draw_elements(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_draw_elements(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_draw_elements(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_draw_elements(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_draw_elements(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_array_element(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_array_element(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_array_element(VBO_ON, GL_TRIANGLE_STRIP, GL_UNSIGNED_INT);
> + pass = pass && test_array_element(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_BYTE);
> + pass = pass && test_array_element(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_SHORT);
> + pass = pass && test_array_element(VBO_ON, GL_LINE_STRIP, GL_UNSIGNED_INT);
> pass = pass && test_draw_arrays();
> }
>
> --
> 1.7.10
>
> _______________________________________________
> Piglit mailing list
> Piglit at lists.freedesktop.org
> http://lists.freedesktop.org/mailman/listinfo/piglit
More information about the Piglit
mailing list