tests: add a test that engages transform feedback

1 files changed, 247 insertions, 0 deletions

diff --git a/tests/test_virgl_cmd.c b/tests/test_virgl_cmd.c
index 86d980e..d317327 100644
--- a/tests/test_virgl_cmd.c
+++ b/tests/test_virgl_cmd.c
@@ -731,6 +731,252 @@ START_TEST(virgl_test_render_geom_simple)
 }
 END_TEST
 
+/* create a resource - clear it to a color, render something 
+ * and test transform feedback 
+ */
+START_TEST(virgl_test_render_xfb)
+{
+    struct virgl_context ctx;
+    struct virgl_resource res;
+    struct virgl_resource vbo;
+    struct virgl_resource xfb;
+    struct virgl_surface surf;
+    struct virgl_so_target so_target;
+    struct virgl_so_target *so_target_ptr;
+    struct pipe_framebuffer_state fb_state;
+    struct pipe_vertex_element ve[2];
+    struct pipe_vertex_buffer vbuf;
+    int ve_handle, vs_handle, fs_handle, xfb_handle;
+    int ctx_handle = 1;
+    union pipe_color_union color;
+    struct virgl_box box;
+    int ret;
+    int tw = 300, th = 300;
+
+    ret = testvirgl_init_ctx_cmdbuf(&ctx);
+    ck_assert_int_eq(ret, 0);
+
+    /* init and create simple 2D resource */
+    ret = testvirgl_create_backed_simple_2d_res(&res, 1, tw, th);
+    ck_assert_int_eq(ret, 0);
+
+    /* attach resource to context */
+    virgl_renderer_ctx_attach_resource(ctx.ctx_id, res.handle);
+
+    /* create a surface for the resource */
+    memset(&surf, 0, sizeof(surf));
+    surf.base.format = PIPE_FORMAT_B8G8R8X8_UNORM;
+    surf.handle = ctx_handle++;
+    surf.base.texture = &res.base;
+
+    virgl_encoder_create_surface(&ctx, surf.handle, &res, &surf.base);
+
+    /* set the framebuffer state */
+    fb_state.nr_cbufs = 1;
+    fb_state.zsbuf = NULL;
+    fb_state.cbufs[0] = &surf.base;
+    virgl_encoder_set_framebuffer_state(&ctx, &fb_state);
+
+    /* clear the resource */
+    /* clear buffer to green */
+    color.f[0] = 0.0;
+    color.f[1] = 1.0;
+    color.f[2] = 0.0;
+    color.f[3] = 1.0;
+    virgl_encode_clear(&ctx, PIPE_CLEAR_COLOR0, &color, 0.0, 0);
+
+    /* create vertex elements */
+    ve_handle = ctx_handle++;
+    memset(ve, 0, sizeof(ve));
+    ve[0].src_offset = Offset(struct vertex, position);
+    ve[0].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+    ve[1].src_offset = Offset(struct vertex, color);
+    ve[1].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
+    virgl_encoder_create_vertex_elements(&ctx, ve_handle, 2, ve);
+
+    virgl_encode_bind_object(&ctx, ve_handle, VIRGL_OBJECT_VERTEX_ELEMENTS);
+
+    /* create vbo */
+    ret = testvirgl_create_backed_simple_buffer(&vbo, 2, sizeof(vertices), PIPE_BIND_VERTEX_BUFFER);
+    ck_assert_int_eq(ret, 0);
+    virgl_renderer_ctx_attach_resource(ctx.ctx_id, vbo.handle);
+
+    /* inline write the data to it */
+    box.x = 0;
+    box.y = 0;
+    box.z = 0;
+    box.w = sizeof(vertices);
+    box.h = 1;
+    box.d = 1;
+    virgl_encoder_inline_write(&ctx, &vbo, 0, 0, (struct pipe_box *)&box, &vertices, box.w, 0);
+
+    vbuf.stride = sizeof(struct vertex);
+    vbuf.buffer_offset = 0;
+    vbuf.buffer = &vbo.base;
+    virgl_encoder_set_vertex_buffers(&ctx, 1, &vbuf);
+
+    /* create stream output buffer */
+    ret = testvirgl_create_backed_simple_buffer(&xfb, 3, 3*sizeof(vertices), PIPE_BIND_STREAM_OUTPUT);
+    ck_assert_int_eq(ret, 0);
+    virgl_renderer_ctx_attach_resource(ctx.ctx_id, xfb.handle);
+
+    /* set streamout target */
+    xfb_handle = ctx_handle++;
+    virgl_encoder_create_so_target(&ctx, xfb_handle, &xfb, 0, 3*sizeof(vertices));
+    so_target.handle = xfb_handle;
+    so_target_ptr = &so_target;
+    virgl_encoder_set_so_targets(&ctx, 1, (struct pipe_stream_output_target **)&so_target_ptr, 0);
+
+    /* create vertex shader */
+    {
+	struct pipe_shader_state vs;
+         const char *text =
+	   "VERT\n"
+	   "DCL IN[0]\n"
+	   "DCL IN[1]\n"
+	   "DCL OUT[0], POSITION\n"
+	   "DCL OUT[1], COLOR\n"
+	   "  0: MOV OUT[1], IN[1]\n"
+	   "  1: MOV OUT[0], IN[0]\n"
+	   "  2: END\n";
+	 memset(&vs, 0, sizeof(vs));
+	 vs_handle = ctx_handle++;
+	 vs.stream_output.num_outputs = 1;
+	 vs.stream_output.stride[0] = 4;
+	 vs.stream_output.output[0].num_components = 4;
+	 virgl_encode_shader_state(&ctx, vs_handle, VIRGL_OBJECT_VS,
+				   &vs, text);
+	 virgl_encode_bind_object(&ctx, vs_handle, VIRGL_OBJECT_VS);
+    }
+
+    /* create fragment shader */
+    {
+	struct pipe_shader_state fs;
+	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";
+	memset(&fs, 0, sizeof(fs));
+	fs_handle = ctx_handle++;
+	virgl_encode_shader_state(&ctx, fs_handle, VIRGL_OBJECT_FS,
+				   &fs, text);
+
+	virgl_encode_bind_object(&ctx, fs_handle, VIRGL_OBJECT_FS);
+    }
+
+    /* set blend state */
+    {
+	struct pipe_blend_state blend;
+	int blend_handle = ctx_handle++;
+	memset(&blend, 0, sizeof(blend));
+	blend.rt[0].colormask = PIPE_MASK_RGBA;
+	virgl_encode_blend_state(&ctx, blend_handle, &blend);
+	virgl_encode_bind_object(&ctx, blend_handle, VIRGL_OBJECT_BLEND);
+    }
+
+    /* set depth stencil alpha state */
+    {
+	struct pipe_depth_stencil_alpha_state dsa;
+	int dsa_handle = ctx_handle++;
+	memset(&dsa, 0, sizeof(dsa));
+	dsa.depth.writemask = 1;
+	dsa.depth.func = PIPE_FUNC_LESS;
+	virgl_encode_dsa_state(&ctx, dsa_handle, &dsa);
+	virgl_encode_bind_object(&ctx, dsa_handle, VIRGL_OBJECT_DSA);
+    }
+
+    /* set rasterizer state */
+    {
+	struct pipe_rasterizer_state rasterizer;
+	int rs_handle = ctx_handle++;
+	memset(&rasterizer, 0, sizeof(rasterizer));
+	rasterizer.cull_face = PIPE_FACE_NONE;
+	rasterizer.half_pixel_center = 1;
+	rasterizer.bottom_edge_rule = 1;
+	rasterizer.depth_clip = 1;
+	virgl_encode_rasterizer_state(&ctx, rs_handle, &rasterizer);
+	virgl_encode_bind_object(&ctx, rs_handle, VIRGL_OBJECT_RASTERIZER);
+    }
+
+    /* set viewport state */
+    {
+	struct pipe_viewport_state vp;
+	float znear = 0, zfar = 1.0;
+	float half_w = tw / 2.0f;
+	float half_h = th / 2.0f;
+	float half_d = (zfar - znear) / 2.0f;
+
+	vp.scale[0] = half_w;
+	vp.scale[1] = half_h;
+	vp.scale[2] = half_d;
+
+	vp.translate[0] = half_w + 0;
+	vp.translate[1] = half_h + 0;
+	vp.translate[2] = half_d + znear;
+	virgl_encoder_set_viewport_state(&ctx, &vp);
+    }
+
+    /* draw */
+    {
+	struct pipe_draw_info info;
+	memset(&info, 0, sizeof(info));
+	info.count = 3;
+	info.mode = PIPE_PRIM_TRIANGLES;
+	virgl_encoder_draw_vbo(&ctx, &info);
+    }
+
+    virgl_renderer_submit_cmd(ctx.cbuf->buf, ctx.ctx_id, ctx.cbuf->cdw);
+
+    /* create a fence */
+    ret = virgl_renderer_create_fence(1, ctx.ctx_id);
+    ck_assert_int_eq(ret, 0);
+
+    do {
+	int fence;
+
+	virgl_renderer_poll();
+	fence = testvirgl_get_last_fence();
+	if (fence >= 1)
+	    break;
+	nanosleep((struct timespec[]){{0, 50000}}, NULL);
+    } while(1);
+
+    /* read back the tri values in the resource */
+    box.x = 0;
+    box.y = 0;
+    box.z = 0;
+    box.w = tw;
+    box.h = th;
+    box.d = 1;
+    ret = virgl_renderer_transfer_read_iov(res.handle, ctx.ctx_id, 0, 0, 0, &box, 0, NULL, 0);
+    ck_assert_int_eq(ret, 0);
+
+    {
+	int w, h;
+	bool all_cleared = true;
+	uint32_t *ptr = res.iovs[0].iov_base;
+	for (h = 0; h < th; h++) {
+	    for (w = 0; w < tw; w++) {
+		if (ptr[h * tw + w] != 0xff00ff00)
+		    all_cleared = false;
+	    }
+	}
+	ck_assert_int_eq(all_cleared, false);
+    }
+
+    /* cleanup */
+    virgl_renderer_ctx_detach_resource(ctx.ctx_id, res.handle);
+
+    testvirgl_destroy_backed_res(&xfb);
+    testvirgl_destroy_backed_res(&vbo);
+    testvirgl_destroy_backed_res(&res);
+
+    testvirgl_fini_ctx_cmdbuf(&ctx);
+}
+END_TEST
+
 Suite *virgl_init_suite(void)
 {
   Suite *s;
@@ -743,6 +989,7 @@ Suite *virgl_init_suite(void)
   tcase_add_test(tc_core, virgl_test_overlap_obj_id);
   tcase_add_test(tc_core, virgl_test_render_simple);
   tcase_add_test(tc_core, virgl_test_render_geom_simple);
+  tcase_add_test(tc_core, virgl_test_render_xfb);
 
   suite_add_tcase(s, tc_core);
   return s;