diff options
Diffstat (limited to 'src/gallium/tests/graw')
| -rw-r--r-- | src/gallium/tests/graw/SConscript | 1 | ||||
| -rw-r--r-- | src/gallium/tests/graw/tri-instanced.c | 340 |
2 files changed, 341 insertions, 0 deletions
diff --git a/src/gallium/tests/graw/SConscript b/src/gallium/tests/graw/SConscript index a40d66d4a1d..61121732e38 100644 --- a/src/gallium/tests/graw/SConscript +++ b/src/gallium/tests/graw/SConscript @@ -14,6 +14,7 @@ env.Prepend(LIBS = ['graw'] + gallium) progs = [ 'clear', 'tri', + 'tri-instanced', 'quad-tex', 'fs-test', 'vs-test', diff --git a/src/gallium/tests/graw/tri-instanced.c b/src/gallium/tests/graw/tri-instanced.c new file mode 100644 index 00000000000..30e205f1434 --- /dev/null +++ b/src/gallium/tests/graw/tri-instanced.c @@ -0,0 +1,340 @@ +/* + * Test draw instancing. + */ + +#include <stdio.h> +#include <string.h> + +#include "state_tracker/graw.h" +#include "pipe/p_screen.h" +#include "pipe/p_context.h" +#include "pipe/p_state.h" +#include "pipe/p_defines.h" + +#include "util/u_debug.h" /* debug_dump_surface_bmp() */ +#include "util/u_memory.h" /* Offset() */ + + +enum pipe_format formats[] = { + PIPE_FORMAT_R8G8B8A8_UNORM, + PIPE_FORMAT_B8G8R8A8_UNORM, + PIPE_FORMAT_NONE +}; + +static const int WIDTH = 300; +static const int HEIGHT = 300; + +static struct pipe_screen *screen = NULL; +static struct pipe_context *ctx = NULL; +static struct pipe_surface *surf = NULL; +static struct pipe_resource *indexBuffer = NULL; +static void *window = NULL; + +struct vertex { + float position[4]; + float color[4]; +}; + + +static int draw_elements = 0; + + +/** + * Vertex data. + * Each vertex has three attributes: position, color and translation. + * The translation attribute is a per-instance attribute. See + * "instance_divisor" below. + */ +static struct vertex vertices[4] = +{ + { + { 0.0f, -0.3f, 0.0f, 1.0f }, /* pos */ + { 1.0f, 0.0f, 0.0f, 1.0f } /* color */ + }, + { + { -0.2f, 0.3f, 0.0f, 1.0f }, + { 0.0f, 1.0f, 0.0f, 1.0f } + }, + { + { 0.2f, 0.3f, 0.0f, 1.0f }, + { 0.0f, 0.0f, 1.0f, 1.0f } + } +}; + + +#define NUM_INST 5 + +static float inst_data[NUM_INST][4] = +{ + { -0.50f, 0.4f, 0.0f, 0.0f }, + { -0.25f, 0.1f, 0.0f, 0.0f }, + { 0.00f, 0.2f, 0.0f, 0.0f }, + { 0.25f, 0.1f, 0.0f, 0.0f }, + { 0.50f, 0.3f, 0.0f, 0.0f } +}; + + +static ushort indices[3] = { 0, 2, 1 }; + + +static void set_viewport( float x, float y, + float width, float height, + float near, float far) +{ + float z = far; + float half_width = (float)width / 2.0f; + float half_height = (float)height / 2.0f; + float half_depth = ((float)far - (float)near) / 2.0f; + struct pipe_viewport_state vp; + + vp.scale[0] = half_width; + vp.scale[1] = half_height; + vp.scale[2] = half_depth; + vp.scale[3] = 1.0f; + + vp.translate[0] = half_width + x; + vp.translate[1] = half_height + y; + vp.translate[2] = half_depth + z; + vp.translate[3] = 0.0f; + + ctx->set_viewport_state( ctx, &vp ); +} + + +static void set_vertices( void ) +{ + struct pipe_vertex_element ve[3]; + struct pipe_vertex_buffer vbuf[2]; + void *handle; + + memset(ve, 0, sizeof ve); + + /* pos */ + ve[0].src_offset = Offset(struct vertex, position); + ve[0].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT; + ve[0].vertex_buffer_index = 0; + + /* color */ + ve[1].src_offset = Offset(struct vertex, color); + ve[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT; + ve[1].vertex_buffer_index = 0; + + /* per-instance info */ + ve[2].src_offset = 0; + ve[2].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT; + ve[2].vertex_buffer_index = 1; + ve[2].instance_divisor = 1; + + handle = ctx->create_vertex_elements_state(ctx, 3, ve); + ctx->bind_vertex_elements_state(ctx, handle); + + + /* vertex data */ + vbuf[0].stride = sizeof( struct vertex ); + vbuf[0].max_index = sizeof(vertices) / vbuf[0].stride; + vbuf[0].buffer_offset = 0; + vbuf[0].buffer = screen->user_buffer_create(screen, + vertices, + sizeof(vertices), + PIPE_BIND_VERTEX_BUFFER); + + /* instance data */ + vbuf[1].stride = sizeof( inst_data[0] ); + vbuf[1].max_index = sizeof(inst_data) / vbuf[1].stride; + vbuf[1].buffer_offset = 0; + vbuf[1].buffer = screen->user_buffer_create(screen, + inst_data, + sizeof(inst_data), + PIPE_BIND_VERTEX_BUFFER); + + + ctx->set_vertex_buffers(ctx, 2, vbuf); + + /* index data */ + indexBuffer = screen->user_buffer_create(screen, + indices, + sizeof(indices), + PIPE_BIND_VERTEX_BUFFER); + + +} + +static void set_vertex_shader( void ) +{ + void *handle; + const char *text = + "VERT\n" + "DCL IN[0]\n" + "DCL IN[1]\n" + "DCL IN[2]\n" + "DCL OUT[0], POSITION\n" + "DCL OUT[1], COLOR\n" + " 0: MOV OUT[1], IN[1]\n" + " 1: ADD OUT[0], IN[0], IN[2]\n" /* add instance pos to vertex pos */ + " 2: END\n"; + + handle = graw_parse_vertex_shader(ctx, text); + ctx->bind_vs_state(ctx, handle); +} + +static void set_fragment_shader( void ) +{ + void *handle; + const char *text = + "FRAG\n" + "DCL IN[0], COLOR, LINEAR\n" + "DCL OUT[0], COLOR\n" + " 0: MOV OUT[0], IN[0]\n" + " 1: END\n"; + + handle = graw_parse_fragment_shader(ctx, text); + ctx->bind_fs_state(ctx, handle); +} + + +static void draw( void ) +{ + float clear_color[4] = {1,0,1,1}; + + ctx->clear(ctx, PIPE_CLEAR_COLOR, clear_color, 0, 0); + + /* draw NUM_INST triangles */ + if (draw_elements) + ctx->draw_elements_instanced(ctx, indexBuffer, 2, + 0, /* indexBias */ + PIPE_PRIM_TRIANGLES, + 0, 3, /* start, count */ + 0, NUM_INST); /* startInst, instCount */ + else + ctx->draw_arrays_instanced(ctx, PIPE_PRIM_TRIANGLES, 0, 3, 0, NUM_INST); + + ctx->flush(ctx, PIPE_FLUSH_RENDER_CACHE, NULL); + +#if 0 + /* At the moment, libgraw leaks out/makes available some of the + * symbols from gallium/auxiliary, including these debug helpers. + * Will eventually want to bless some of these paths, and lock the + * others down so they aren't accessible from test programs. + * + * This currently just happens to work on debug builds - a release + * build will probably fail to link here: + */ + debug_dump_surface_bmp(ctx, "result.bmp", surf); +#endif + + screen->flush_frontbuffer(screen, surf, window); +} + + +static void init( void ) +{ + struct pipe_framebuffer_state fb; + struct pipe_resource *tex, templat; + int i; + + /* It's hard to say whether window or screen should be created + * first. Different environments would prefer one or the other. + * + * Also, no easy way of querying supported formats if the screen + * cannot be created first. + */ + for (i = 0; + window == NULL && formats[i] != PIPE_FORMAT_NONE; + i++) { + + screen = graw_create_window_and_screen(0,0,300,300, + formats[i], + &window); + } + + ctx = screen->context_create(screen, NULL); + if (ctx == NULL) + exit(3); + + templat.target = PIPE_TEXTURE_2D; + templat.format = formats[i]; + templat.width0 = WIDTH; + templat.height0 = HEIGHT; + templat.depth0 = 1; + templat.last_level = 0; + templat.nr_samples = 1; + templat.bind = (PIPE_BIND_RENDER_TARGET | + PIPE_BIND_DISPLAY_TARGET); + + tex = screen->resource_create(screen, + &templat); + if (tex == NULL) + exit(4); + + surf = screen->get_tex_surface(screen, tex, 0, 0, 0, + PIPE_BIND_RENDER_TARGET | + PIPE_BIND_DISPLAY_TARGET); + if (surf == NULL) + exit(5); + + memset(&fb, 0, sizeof fb); + fb.nr_cbufs = 1; + fb.width = WIDTH; + fb.height = HEIGHT; + fb.cbufs[0] = surf; + + ctx->set_framebuffer_state(ctx, &fb); + + { + struct pipe_blend_state blend; + void *handle; + memset(&blend, 0, sizeof blend); + blend.rt[0].colormask = PIPE_MASK_RGBA; + handle = ctx->create_blend_state(ctx, &blend); + ctx->bind_blend_state(ctx, handle); + } + + { + struct pipe_depth_stencil_alpha_state depthstencil; + void *handle; + memset(&depthstencil, 0, sizeof depthstencil); + handle = ctx->create_depth_stencil_alpha_state(ctx, &depthstencil); + ctx->bind_depth_stencil_alpha_state(ctx, handle); + } + + { + struct pipe_rasterizer_state rasterizer; + void *handle; + memset(&rasterizer, 0, sizeof rasterizer); + rasterizer.cull_face = PIPE_FACE_NONE; + rasterizer.gl_rasterization_rules = 1; + handle = ctx->create_rasterizer_state(ctx, &rasterizer); + ctx->bind_rasterizer_state(ctx, handle); + } + + set_viewport(0, 0, WIDTH, HEIGHT, 30, 1000); + set_vertices(); + set_vertex_shader(); + set_fragment_shader(); +} + + +static void options(int argc, char *argv[]) +{ + int i; + for (i = 1; i < argc; i++) { + if (strcmp(argv[i], "-e") == 0) + draw_elements = 1; + } + if (draw_elements) + printf("Using pipe_context::draw_elements_instanced()\n"); + else + printf("Using pipe_context::draw_arrays_instanced()\n"); +} + + +int main( int argc, char *argv[] ) +{ + options(argc, argv); + + init(); + + graw_set_display_func( draw ); + graw_main_loop(); + return 0; +} |