}
static void
-v3d_predraw_check_textures(struct pipe_context *pctx,
- struct v3d_texture_stateobj *stage_tex)
+v3d_predraw_check_stage_inputs(struct pipe_context *pctx,
+ enum pipe_shader_type s)
{
struct v3d_context *v3d = v3d_context(pctx);
- for (int i = 0; i < stage_tex->num_textures; i++) {
- struct pipe_sampler_view *view = stage_tex->textures[i];
- if (!view)
+ /* XXX perf: If we're reading from the output of TF in this job, we
+ * should instead be using the wait for transform feedback
+ * functionality.
+ */
+
+ /* Flush writes to textures we're sampling. */
+ for (int i = 0; i < v3d->tex[s].num_textures; i++) {
+ struct pipe_sampler_view *pview = v3d->tex[s].textures[i];
+ if (!pview)
continue;
+ struct v3d_sampler_view *view = v3d_sampler_view(pview);
+
+ if (view->texture != view->base.texture)
+ v3d_update_shadow_texture(pctx, &view->base);
v3d_flush_jobs_writing_resource(v3d, view->texture);
}
+
+ /* Flush writes to UBOs. */
+ foreach_bit(i, v3d->constbuf[s].enabled_mask) {
+ struct pipe_constant_buffer *cb = &v3d->constbuf[s].cb[i];
+ if (cb->buffer)
+ v3d_flush_jobs_writing_resource(v3d, cb->buffer);
+ }
+
+ /* Flush writes to our image views */
+ foreach_bit(i, v3d->shaderimg[s].enabled_mask) {
+ struct v3d_image_view *view = &v3d->shaderimg[s].si[i];
+
+ v3d_flush_jobs_writing_resource(v3d, view->base.resource);
+ }
}
static void
/* Upload the uniforms to the indirect CL first */
struct v3d_cl_reloc fs_uniforms =
v3d_write_uniforms(v3d, v3d->prog.fs,
- &v3d->constbuf[PIPE_SHADER_FRAGMENT],
- &v3d->fragtex);
+ PIPE_SHADER_FRAGMENT);
struct v3d_cl_reloc vs_uniforms =
v3d_write_uniforms(v3d, v3d->prog.vs,
- &v3d->constbuf[PIPE_SHADER_VERTEX],
- &v3d->verttex);
+ PIPE_SHADER_VERTEX);
struct v3d_cl_reloc cs_uniforms =
v3d_write_uniforms(v3d, v3d->prog.cs,
- &v3d->constbuf[PIPE_SHADER_VERTEX],
- &v3d->verttex);
+ PIPE_SHADER_VERTEX);
/* See GFXH-930 workaround below */
uint32_t num_elements_to_emit = MAX2(vtx->num_elements, 1);
cl_packet_length(GL_SHADER_STATE_ATTRIBUTE_RECORD),
32);
+ /* XXX perf: We should move most of the SHADER_STATE_RECORD setup to
+ * compile time, so that we mostly just have to OR the VS and FS
+ * records together at draw time.
+ */
cl_emit(&job->indirect, GL_SHADER_STATE_RECORD, shader) {
shader.enable_clipping = true;
/* VC5_DIRTY_PRIM_MODE | VC5_DIRTY_RASTERIZER */
* shader needs to write the Z value (even just discards).
*/
shader.fragment_shader_does_z_writes =
- (v3d->prog.fs->prog_data.fs->writes_z ||
- v3d->prog.fs->prog_data.fs->discard);
+ v3d->prog.fs->prog_data.fs->writes_z;
+ /* Set if the EZ test must be disabled (due to shader side
+ * effects and the early_z flag not being present in the
+ * shader).
+ */
+ shader.turn_off_early_z_test =
+ v3d->prog.fs->prog_data.fs->disable_ez;
shader.fragment_shader_uses_real_pixel_centre_w_in_addition_to_centroid_w2 =
v3d->prog.fs->prog_data.fs->uses_center_w;
shader.number_of_varyings_in_fragment_shader =
- v3d->prog.fs->prog_data.base->num_inputs;
+ v3d->prog.fs->prog_data.fs->num_inputs;
shader.coordinate_shader_propagate_nans = true;
shader.vertex_shader_propagate_nans = true;
attr.maximum_index = 0xffffff;
#endif
}
- STATIC_ASSERT(sizeof(vtx->attrs) >= VC5_MAX_ATTRIBUTES * size);
+ STATIC_ASSERT(sizeof(vtx->attrs) >= V3D_MAX_VS_INPUTS / 4 * size);
}
if (vtx->num_elements == 0) {
/* Before setting up the draw, flush anything writing to the textures
* that we read from.
*/
- v3d_predraw_check_textures(pctx, &v3d->verttex);
- v3d_predraw_check_textures(pctx, &v3d->fragtex);
+ for (int s = 0; s < PIPE_SHADER_TYPES; s++)
+ v3d_predraw_check_stage_inputs(pctx, s);
+
+ if (info->indirect)
+ v3d_flush_jobs_writing_resource(v3d, info->indirect->buffer);
struct v3d_job *job = v3d_get_job_for_fbo(v3d);
* on the last submitted render, rather than tracking the last
* rendering to each texture's BO.
*/
- if (v3d->verttex.num_textures) {
+ if (v3d->tex[PIPE_SHADER_VERTEX].num_textures || info->indirect) {
perf_debug("Blocking binner on last render "
- "due to vertex texturing.\n");
+ "due to vertex texturing or indirect drawing.\n");
job->submit.in_sync_bcl = v3d->out_sync;
}
+ /* Mark SSBOs as being written. We don't actually know which ones are
+ * read vs written, so just assume the worst
+ */
+ for (int s = 0; s < PIPE_SHADER_TYPES; s++) {
+ foreach_bit(i, v3d->ssbo[s].enabled_mask) {
+ v3d_job_add_write_resource(job,
+ v3d->ssbo[s].sb[i].buffer);
+ job->tmu_dirty_rcl = true;
+ }
+
+ foreach_bit(i, v3d->shaderimg[s].enabled_mask) {
+ v3d_job_add_write_resource(job,
+ v3d->shaderimg[s].si[i].base.resource);
+ job->tmu_dirty_rcl = true;
+ }
+ }
+
/* Get space to emit our draw call into the BCL, using a branch to
* jump to a new BO if necessary.
*/
}
#endif
- if (info->instance_count > 1) {
+ if (info->indirect) {
+ cl_emit(&job->bcl, INDIRECT_INDEXED_INSTANCED_PRIM_LIST, prim) {
+ prim.index_type = ffs(info->index_size) - 1;
+#if V3D_VERSION < 40
+ prim.address_of_indices_list =
+ cl_address(rsc->bo, offset);
+#endif /* V3D_VERSION < 40 */
+ prim.mode = info->mode | prim_tf_enable;
+ prim.enable_primitive_restarts = info->primitive_restart;
+
+ prim.number_of_draw_indirect_indexed_records = info->indirect->draw_count;
+
+ prim.stride_in_multiples_of_4_bytes = info->indirect->stride >> 2;
+ prim.address = cl_address(v3d_resource(info->indirect->buffer)->bo,
+ info->indirect->offset);
+ }
+ } else if (info->instance_count > 1) {
cl_emit(&job->bcl, INDEXED_INSTANCED_PRIM_LIST, prim) {
prim.index_type = ffs(info->index_size) - 1;
#if V3D_VERSION >= 40
if (info->has_user_indices)
pipe_resource_reference(&prsc, NULL);
} else {
- if (info->instance_count > 1) {
+ if (info->indirect) {
+ cl_emit(&job->bcl, INDIRECT_VERTEX_ARRAY_INSTANCED_PRIMS, prim) {
+ prim.mode = info->mode | prim_tf_enable;
+ prim.number_of_draw_indirect_array_records = info->indirect->draw_count;
+
+ prim.stride_in_multiples_of_4_bytes = info->indirect->stride >> 2;
+ prim.address = cl_address(v3d_resource(info->indirect->buffer)->bo,
+ info->indirect->offset);
+ }
+ } else if (info->instance_count > 1) {
cl_emit(&job->bcl, VERTEX_ARRAY_INSTANCED_PRIMS, prim) {
prim.mode = info->mode | prim_tf_enable;
prim.index_of_first_vertex = info->start;
rsc->initialized_buffers |= PIPE_CLEAR_STENCIL;
}
- for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) {
+ for (int i = 0; i < V3D_MAX_DRAW_BUFFERS; i++) {
uint32_t bit = PIPE_CLEAR_COLOR0 << i;
int blend_rt = v3d->blend->base.independent_blend_enable ? i : 0;
buffers &= ~PIPE_CLEAR_DEPTHSTENCIL;
}
- for (int i = 0; i < VC5_MAX_DRAW_BUFFERS; i++) {
+ for (int i = 0; i < V3D_MAX_DRAW_BUFFERS; i++) {
uint32_t bit = PIPE_CLEAR_COLOR0 << i;
if (!(buffers & bit))
continue;