src/mesa/state_tracker/st_draw.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2007 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 /*
  29  * This file implements the st_draw_vbo() function which is called from
  30  * Mesa's VBO module.  All point/line/triangle rendering is done through
  31  * this function whether the user called glBegin/End, glDrawArrays,
  32  * glDrawElements, glEvalMesh, or glCalList, etc.
  33  *
  34  * Authors:
  35  *   Keith Whitwell <keithw@vmware.com>
  36  */
  37
  38
  39 #include "main/errors.h"
  40 #include "main/imports.h"
  41 #include "main/image.h"
  42 #include "main/bufferobj.h"
  43 #include "main/macros.h"
  44 #include "main/varray.h"
  45
  46 #include "compiler/glsl/ir_uniform.h"
  47
  48 #include "vbo/vbo.h"
  49
  50 #include "st_context.h"
  51 #include "st_atom.h"
  52 #include "st_cb_bitmap.h"
  53 #include "st_cb_bufferobjects.h"
  54 #include "st_cb_xformfb.h"
  55 #include "st_debug.h"
  56 #include "st_draw.h"
  57 #include "st_program.h"
  58 #include "st_util.h"
  59
  60 #include "pipe/p_context.h"
  61 #include "pipe/p_defines.h"
  62 #include "util/u_cpu_detect.h"
  63 #include "util/u_inlines.h"
  64 #include "util/format/u_format.h"
  65 #include "util/u_prim.h"
  66 #include "util/u_draw.h"
  67 #include "util/u_upload_mgr.h"
  68 #include "draw/draw_context.h"
  69 #include "cso_cache/cso_context.h"
  70
  71 #if defined(PIPE_OS_LINUX) && !defined(ANDROID)
  72 #include <sched.h>
  73 #define HAVE_SCHED_GETCPU 1
  74 #else
  75 #define sched_getcpu() 0
  76 #define HAVE_SCHED_GETCPU 0
  77 #endif
  78
  79 /**
  80  * Set the restart index.
  81  */
  82 static void
  83 setup_primitive_restart(struct gl_context *ctx, struct pipe_draw_info *info)
  84 {
  85    if (ctx->Array._PrimitiveRestart) {
  86       unsigned index_size = info->index_size;
  87
  88       info->restart_index =
  89          _mesa_primitive_restart_index(ctx, index_size);
  90
  91       /* Enable primitive restart only when the restart index can have an
  92        * effect. This is required for correctness in radeonsi GFX8 support.
  93        * Other hardware may also benefit from taking a faster, non-restart path
  94        * when possible.
  95        */
  96       if (index_size == 4 || info->restart_index < (1 << (index_size * 8)))
  97          info->primitive_restart = true;
  98    }
  99 }
 100
 101
 102 /**
 103  * Translate OpenGL primtive type (GL_POINTS, GL_TRIANGLE_STRIP, etc) to
 104  * the corresponding Gallium type.
 105  */
 106 static unsigned
 107 translate_prim(const struct gl_context *ctx, unsigned prim)
 108 {
 109    /* GL prims should match Gallium prims, spot-check a few */
 110    STATIC_ASSERT(GL_POINTS == PIPE_PRIM_POINTS);
 111    STATIC_ASSERT(GL_QUADS == PIPE_PRIM_QUADS);
 112    STATIC_ASSERT(GL_TRIANGLE_STRIP_ADJACENCY == PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY);
 113    STATIC_ASSERT(GL_PATCHES == PIPE_PRIM_PATCHES);
 114
 115    return prim;
 116 }
 117
 118 static inline void
 119 prepare_draw(struct st_context *st, struct gl_context *ctx)
 120 {
 121    /* Mesa core state should have been validated already */
 122    assert(ctx->NewState == 0x0);
 123
 124    if (unlikely(!st->bitmap.cache.empty))
 125       st_flush_bitmap_cache(st);
 126
 127    st_invalidate_readpix_cache(st);
 128
 129    /* Validate state. */
 130    if ((st->dirty | ctx->NewDriverState) & ST_PIPELINE_RENDER_STATE_MASK ||
 131        st->gfx_shaders_may_be_dirty) {
 132       st_validate_state(st, ST_PIPELINE_RENDER);
 133    }
 134
 135    struct pipe_context *pipe = st->pipe;
 136
 137    /* Pin threads regularly to the same Zen CCX that the main thread is
 138     * running on. The main thread can move between CCXs.
 139     */
 140    if (unlikely(HAVE_SCHED_GETCPU && /* Linux */
 141                 /* AMD Zen */
 142                 util_cpu_caps.nr_cpus != util_cpu_caps.cores_per_L3 &&
 143                 /* no glthread */
 144                 ctx->CurrentClientDispatch != ctx->MarshalExec &&
 145                 /* driver support */
 146                 pipe->set_context_param &&
 147                 /* do it occasionally */
 148                 ++st->pin_thread_counter % 512 == 0)) {
 149       int cpu = sched_getcpu();
 150       if (cpu >= 0) {
 151          unsigned L3_cache = cpu / util_cpu_caps.cores_per_L3;
 152
 153          pipe->set_context_param(pipe,
 154                                  PIPE_CONTEXT_PARAM_PIN_THREADS_TO_L3_CACHE,
 155                                  L3_cache);
 156       }
 157    }
 158 }
 159
 160 /**
 161  * This function gets plugged into the VBO module and is called when
 162  * we have something to render.
 163  * Basically, translate the information into the format expected by gallium.
 164  *
 165  * Try to keep this logic in sync with st_feedback_draw_vbo.
 166  */
 167 static void
 168 st_draw_vbo(struct gl_context *ctx,
 169             const struct _mesa_prim *prims,
 170             GLuint nr_prims,
 171             const struct _mesa_index_buffer *ib,
 172             GLboolean index_bounds_valid,
 173             GLuint min_index,
 174             GLuint max_index,
 175             GLuint num_instances,
 176             GLuint base_instance,
 177             struct gl_transform_feedback_object *tfb_vertcount,
 178             unsigned stream)
 179 {
 180    struct st_context *st = st_context(ctx);
 181    struct pipe_draw_info info;
 182    unsigned i;
 183    unsigned start = 0;
 184
 185    prepare_draw(st, ctx);
 186
 187    /* Initialize pipe_draw_info. */
 188    info.primitive_restart = false;
 189    info.vertices_per_patch = ctx->TessCtrlProgram.patch_vertices;
 190    info.indirect = NULL;
 191    info.count_from_stream_output = NULL;
 192    info.restart_index = 0;
 193    info.start_instance = base_instance;
 194    info.instance_count = num_instances;
 195
 196    if (ib) {
 197       struct gl_buffer_object *bufobj = ib->obj;
 198
 199       /* Get index bounds for user buffers. */
 200       if (!index_bounds_valid && st->draw_needs_minmax_index) {
 201          vbo_get_minmax_indices(ctx, prims, ib, &min_index, &max_index,
 202                                 nr_prims);
 203       }
 204
 205       info.index_size = 1 << ib->index_size_shift;
 206       info.min_index = min_index;
 207       info.max_index = max_index;
 208
 209       if (_mesa_is_bufferobj(bufobj)) {
 210          /* indices are in a real VBO */
 211          info.has_user_indices = false;
 212          info.index.resource = st_buffer_object(bufobj)->buffer;
 213
 214          /* Return if the bound element array buffer doesn't have any backing
 215           * storage. (nothing to do)
 216           */
 217          if (!info.index.resource)
 218             return;
 219
 220          start = pointer_to_offset(ib->ptr) >> ib->index_size_shift;
 221       } else {
 222          /* indices are in user space memory */
 223          info.has_user_indices = true;
 224          info.index.user = ib->ptr;
 225       }
 226
 227       setup_primitive_restart(ctx, &info);
 228    }
 229    else {
 230       info.index_size = 0;
 231       info.has_user_indices = false;
 232
 233       /* Transform feedback drawing is always non-indexed. */
 234       /* Set info.count_from_stream_output. */
 235       if (tfb_vertcount) {
 236          if (!st_transform_feedback_draw_init(tfb_vertcount, stream, &info))
 237             return;
 238       }
 239    }
 240
 241    /* do actual drawing */
 242    for (i = 0; i < nr_prims; i++) {
 243       info.count = prims[i].count;
 244
 245       /* Skip no-op draw calls. */
 246       if (!info.count && !tfb_vertcount)
 247          continue;
 248
 249       info.mode = translate_prim(ctx, prims[i].mode);
 250       info.start = start + prims[i].start;
 251       info.index_bias = prims[i].basevertex;
 252       info.drawid = prims[i].draw_id;
 253       if (!ib) {
 254          info.min_index = info.start;
 255          info.max_index = info.start + info.count - 1;
 256       }
 257
 258       if (ST_DEBUG & DEBUG_DRAW) {
 259          debug_printf("st/draw: mode %s  start %u  count %u  index_size %d\n",
 260                       u_prim_name(info.mode),
 261                       info.start,
 262                       info.count,
 263                       info.index_size);
 264       }
 265
 266       /* Don't call u_trim_pipe_prim. Drivers should do it if they need it. */
 267       cso_draw_vbo(st->cso_context, &info);
 268    }
 269 }
 270
 271 static void
 272 st_indirect_draw_vbo(struct gl_context *ctx,
 273                      GLuint mode,
 274                      struct gl_buffer_object *indirect_data,
 275                      GLsizeiptr indirect_offset,
 276                      unsigned draw_count,
 277                      unsigned stride,
 278                      struct gl_buffer_object *indirect_draw_count,
 279                      GLsizeiptr indirect_draw_count_offset,
 280                      const struct _mesa_index_buffer *ib)
 281 {
 282    struct st_context *st = st_context(ctx);
 283    struct pipe_draw_info info;
 284    struct pipe_draw_indirect_info indirect;
 285
 286    assert(stride);
 287    prepare_draw(st, ctx);
 288
 289    memset(&indirect, 0, sizeof(indirect));
 290    util_draw_init_info(&info);
 291    info.start = 0; /* index offset / index size */
 292    info.max_index = ~0u; /* so that u_vbuf can tell that it's unknown */
 293
 294    if (ib) {
 295       struct gl_buffer_object *bufobj = ib->obj;
 296
 297       /* indices are always in a real VBO */
 298       assert(_mesa_is_bufferobj(bufobj));
 299
 300       info.index_size = 1 << ib->index_size_shift;
 301       info.index.resource = st_buffer_object(bufobj)->buffer;
 302       info.start = pointer_to_offset(ib->ptr) >> ib->index_size_shift;
 303
 304       /* Primitive restart is not handled by the VBO module in this case. */
 305       setup_primitive_restart(ctx, &info);
 306    }
 307
 308    info.mode = translate_prim(ctx, mode);
 309    info.vertices_per_patch = ctx->TessCtrlProgram.patch_vertices;
 310    info.indirect = &indirect;
 311    indirect.buffer = st_buffer_object(indirect_data)->buffer;
 312    indirect.offset = indirect_offset;
 313
 314    if (ST_DEBUG & DEBUG_DRAW) {
 315       debug_printf("st/draw indirect: mode %s drawcount %d index_size %d\n",
 316                    u_prim_name(info.mode),
 317                    draw_count,
 318                    info.index_size);
 319    }
 320
 321    if (!st->has_multi_draw_indirect) {
 322       int i;
 323
 324       assert(!indirect_draw_count);
 325       indirect.draw_count = 1;
 326       for (i = 0; i < draw_count; i++) {
 327          info.drawid = i;
 328          cso_draw_vbo(st->cso_context, &info);
 329          indirect.offset += stride;
 330       }
 331    } else {
 332       indirect.draw_count = draw_count;
 333       indirect.stride = stride;
 334       if (indirect_draw_count) {
 335          indirect.indirect_draw_count =
 336             st_buffer_object(indirect_draw_count)->buffer;
 337          indirect.indirect_draw_count_offset = indirect_draw_count_offset;
 338       }
 339       cso_draw_vbo(st->cso_context, &info);
 340    }
 341 }
 342
 343
 344 void
 345 st_init_draw_functions(struct dd_function_table *functions)
 346 {
 347    functions->Draw = st_draw_vbo;
 348    functions->DrawIndirect = st_indirect_draw_vbo;
 349 }
 350
 351
 352 void
 353 st_destroy_draw(struct st_context *st)
 354 {
 355    draw_destroy(st->draw);
 356 }
 357
 358 /**
 359  * Getter for the draw_context, so that initialization of it can happen only
 360  * when needed (the TGSI exec machines take up quite a bit of memory).
 361  */
 362 struct draw_context *
 363 st_get_draw_context(struct st_context *st)
 364 {
 365    if (!st->draw) {
 366       st->draw = draw_create(st->pipe);
 367       if (!st->draw) {
 368          _mesa_error(st->ctx, GL_OUT_OF_MEMORY, "feedback fallback allocation");
 369          return NULL;
 370       }
 371    }
 372
 373    /* Disable draw options that might convert points/lines to tris, etc.
 374     * as that would foul-up feedback/selection mode.
 375     */
 376    draw_wide_line_threshold(st->draw, 1000.0f);
 377    draw_wide_point_threshold(st->draw, 1000.0f);
 378    draw_enable_line_stipple(st->draw, FALSE);
 379    draw_enable_point_sprites(st->draw, FALSE);
 380
 381    return st->draw;
 382 }
 383
 384 /**
 385  * Draw a quad with given position, texcoords and color.
 386  */
 387 bool
 388 st_draw_quad(struct st_context *st,
 389              float x0, float y0, float x1, float y1, float z,
 390              float s0, float t0, float s1, float t1,
 391              const float *color,
 392              unsigned num_instances)
 393 {
 394    struct pipe_vertex_buffer vb = {0};
 395    struct st_util_vertex *verts;
 396
 397    vb.stride = sizeof(struct st_util_vertex);
 398
 399    u_upload_alloc(st->pipe->stream_uploader, 0,
 400                   4 * sizeof(struct st_util_vertex), 4,
 401                   &vb.buffer_offset, &vb.buffer.resource, (void **) &verts);
 402    if (!vb.buffer.resource) {
 403       return false;
 404    }
 405
 406    /* lower-left */
 407    verts[0].x = x0;
 408    verts[0].y = y1;
 409    verts[0].z = z;
 410    verts[0].r = color[0];
 411    verts[0].g = color[1];
 412    verts[0].b = color[2];
 413    verts[0].a = color[3];
 414    verts[0].s = s0;
 415    verts[0].t = t0;
 416
 417    /* lower-right */
 418    verts[1].x = x1;
 419    verts[1].y = y1;
 420    verts[1].z = z;
 421    verts[1].r = color[0];
 422    verts[1].g = color[1];
 423    verts[1].b = color[2];
 424    verts[1].a = color[3];
 425    verts[1].s = s1;
 426    verts[1].t = t0;
 427
 428    /* upper-right */
 429    verts[2].x = x1;
 430    verts[2].y = y0;
 431    verts[2].z = z;
 432    verts[2].r = color[0];
 433    verts[2].g = color[1];
 434    verts[2].b = color[2];
 435    verts[2].a = color[3];
 436    verts[2].s = s1;
 437    verts[2].t = t1;
 438
 439    /* upper-left */
 440    verts[3].x = x0;
 441    verts[3].y = y0;
 442    verts[3].z = z;
 443    verts[3].r = color[0];
 444    verts[3].g = color[1];
 445    verts[3].b = color[2];
 446    verts[3].a = color[3];
 447    verts[3].s = s0;
 448    verts[3].t = t1;
 449
 450    u_upload_unmap(st->pipe->stream_uploader);
 451
 452    cso_set_vertex_buffers(st->cso_context, 0, 1, &vb);
 453
 454    if (num_instances > 1) {
 455       cso_draw_arrays_instanced(st->cso_context, PIPE_PRIM_TRIANGLE_FAN, 0, 4,
 456                                 0, num_instances);
 457    } else {
 458       cso_draw_arrays(st->cso_context, PIPE_PRIM_TRIANGLE_FAN, 0, 4);
 459    }
 460
 461    pipe_resource_reference(&vb.buffer.resource, NULL);
 462
 463    return true;
 464 }