/**
* Draw a screen-aligned quadrilateral.
* Coords are clip coords with y=0=bottom.
*/
static void
draw_quad(struct st_context *st,
float x0, float y0, float x1, float y1, GLfloat z,
unsigned num_instances,
const union pipe_color_union *color)
{
struct cso_context *cso = st->cso_context;
struct pipe_vertex_buffer vb = {0};
GLuint i;
float (*vertices)[2][4]; /**< vertex pos + color */
vb.stride = 8 * sizeof(float);
if (u_upload_alloc(st->uploader, 0, 4 * sizeof(vertices[0]),
&vb.buffer_offset, &vb.buffer,
(void **) &vertices) != PIPE_OK) {
return;
}
/* Convert Z from [0,1] to [-1,1] range */
z = z * 2.0f - 1.0f;
/* positions */
vertices[0][0][0] = x0;
vertices[0][0][1] = y0;
vertices[1][0][0] = x1;
vertices[1][0][1] = y0;
vertices[2][0][0] = x1;
vertices[2][0][1] = y1;
vertices[3][0][0] = x0;
vertices[3][0][1] = y1;
/* same for all verts: */
for (i = 0; i < 4; i++) {
vertices[i][0][2] = z;
vertices[i][0][3] = 1.0;
vertices[i][1][0] = color->f[0];
vertices[i][1][1] = color->f[1];
vertices[i][1][2] = color->f[2];
vertices[i][1][3] = color->f[3];
}
u_upload_unmap(st->uploader);
/* draw */
cso_set_vertex_buffers(cso, cso_get_aux_vertex_buffer_slot(cso), 1, &vb);
cso_draw_arrays_instanced(cso, PIPE_PRIM_TRIANGLE_FAN, 0, 4,
0, num_instances);
pipe_resource_reference(&vb.buffer, NULL);
}
/* Setup all vertex pipeline state, rasterizer state, and fragment shader
* constants, and issue the draw call for PBO upload/download.
*
* The caller is responsible for saving and restoring state, as well as for
* setting other fragment shader state (fragment shader, samplers), and
* framebuffer/viewport/DSA/blend state.
*/
bool
st_pbo_draw(struct st_context *st, const struct st_pbo_addresses *addr,
unsigned surface_width, unsigned surface_height)
{
struct cso_context *cso = st->cso_context;
/* Setup vertex and geometry shaders */
if (!st->pbo.vs) {
st->pbo.vs = st_pbo_create_vs(st);
if (!st->pbo.vs)
return false;
}
if (addr->depth != 1 && st->pbo.use_gs && !st->pbo.gs) {
st->pbo.gs = st_pbo_create_gs(st);
if (!st->pbo.gs)
return false;
}
cso_set_vertex_shader_handle(cso, st->pbo.vs);
cso_set_geometry_shader_handle(cso, addr->depth != 1 ? st->pbo.gs : NULL);
cso_set_tessctrl_shader_handle(cso, NULL);
cso_set_tesseval_shader_handle(cso, NULL);
/* Upload vertices */
{
struct pipe_vertex_buffer vbo = {0};
struct pipe_vertex_element velem;
float x0 = (float) addr->xoffset / surface_width * 2.0f - 1.0f;
float y0 = (float) addr->yoffset / surface_height * 2.0f - 1.0f;
float x1 = (float) (addr->xoffset + addr->width) / surface_width * 2.0f - 1.0f;
float y1 = (float) (addr->yoffset + addr->height) / surface_height * 2.0f - 1.0f;
float *verts = NULL;
vbo.stride = 2 * sizeof(float);
u_upload_alloc(st->pipe->stream_uploader, 0, 8 * sizeof(float), 4,
&vbo.buffer_offset, &vbo.buffer.resource, (void **) &verts);
if (!verts)
return false;
verts[0] = x0;
verts[1] = y0;
verts[2] = x0;
verts[3] = y1;
verts[4] = x1;
verts[5] = y0;
verts[6] = x1;
verts[7] = y1;
u_upload_unmap(st->pipe->stream_uploader);
velem.src_offset = 0;
velem.instance_divisor = 0;
velem.vertex_buffer_index = 0;
velem.src_format = PIPE_FORMAT_R32G32_FLOAT;
cso_set_vertex_elements(cso, 1, &velem);
cso_set_vertex_buffers(cso, velem.vertex_buffer_index, 1, &vbo);
pipe_resource_reference(&vbo.buffer.resource, NULL);
}
/* Upload constants */
{
struct pipe_constant_buffer cb;
cb.buffer = NULL;
cb.user_buffer = &addr->constants;
cb.buffer_offset = 0;
cb.buffer_size = sizeof(addr->constants);
cso_set_constant_buffer(cso, PIPE_SHADER_FRAGMENT, 0, &cb);
pipe_resource_reference(&cb.buffer, NULL);
}
/* Rasterizer state */
cso_set_rasterizer(cso, &st->pbo.raster);
/* Disable stream output */
cso_set_stream_outputs(cso, 0, NULL, 0);
if (addr->depth == 1) {
cso_draw_arrays(cso, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
} else {
cso_draw_arrays_instanced(cso, PIPE_PRIM_TRIANGLE_STRIP,
0, 4, 0, addr->depth);
}
return true;
}
/**
* Draw a quad with given position, texcoords and color.
*/
bool
st_draw_quad(struct st_context *st,
float x0, float y0, float x1, float y1, float z,
float s0, float t0, float s1, float t1,
const float *color,
unsigned num_instances)
{
struct pipe_vertex_buffer vb = {0};
struct st_util_vertex *verts;
vb.stride = sizeof(struct st_util_vertex);
u_upload_alloc(st->uploader, 0, 4 * sizeof(struct st_util_vertex), 4,
&vb.buffer_offset, &vb.buffer, (void **) &verts);
if (!vb.buffer) {
return false;
}
/* lower-left */
verts[0].x = x0;
verts[0].y = y1;
verts[0].z = z;
verts[0].r = color[0];
verts[0].g = color[1];
verts[0].b = color[2];
verts[0].a = color[3];
verts[0].s = s0;
verts[0].t = t0;
/* lower-right */
verts[1].x = x1;
verts[1].y = y1;
verts[1].z = z;
verts[1].r = color[0];
verts[1].g = color[1];
verts[1].b = color[2];
verts[1].a = color[3];
verts[1].s = s1;
verts[1].t = t0;
/* upper-right */
verts[2].x = x1;
verts[2].y = y0;
verts[2].z = z;
verts[2].r = color[0];
verts[2].g = color[1];
verts[2].b = color[2];
verts[2].a = color[3];
verts[2].s = s1;
verts[2].t = t1;
/* upper-left */
verts[3].x = x0;
verts[3].y = y0;
verts[3].z = z;
verts[3].r = color[0];
verts[3].g = color[1];
verts[3].b = color[2];
verts[3].a = color[3];
verts[3].s = s0;
verts[3].t = t1;
u_upload_unmap(st->uploader);
/* At the time of writing, cso_get_aux_vertex_buffer_slot() always returns
* zero. If that ever changes we need to audit the calls to that function
* and make sure the slot number is used consistently everywhere.
*/
assert(cso_get_aux_vertex_buffer_slot(st->cso_context) == 0);
cso_set_vertex_buffers(st->cso_context,
cso_get_aux_vertex_buffer_slot(st->cso_context),
1, &vb);
if (num_instances > 1) {
cso_draw_arrays_instanced(st->cso_context, PIPE_PRIM_TRIANGLE_FAN, 0, 4,
0, num_instances);
} else {
cso_draw_arrays(st->cso_context, PIPE_PRIM_TRIANGLE_FAN, 0, 4);
}
pipe_resource_reference(&vb.buffer, NULL);
return true;
}
