← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/gallium/auxiliary/util/u_vbuf.c

  • Committer: mmach
  • Date: 2023-11-02 21:31:35 UTC
  • Revision ID: netbit73@gmail.com-20231102213135-18d4tzh7tj0uz752
2023-11-02 22:11:57

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/auxiliary/util/u_vbuf.c
180
180
   struct cso_velems_state fallback_velems;
181
181
   /* If non-NULL, this is a vertex element state used for the translate
182
182
    * fallback and therefore used for rendering too. */
183
 
   boolean using_translate;
 
183
   bool using_translate;
184
184
   /* The vertex buffer slot index where translated vertices have been
185
185
    * stored in. */
186
186
   unsigned fallback_vbs[VB_NUM];
321
321
       screen->get_param(screen, PIPE_CAP_PRIMITIVE_RESTART_FIXED_INDEX)) {
322
322
      caps->rewrite_restart_index = screen->get_param(screen, PIPE_CAP_EMULATE_NONFIXED_PRIMITIVE_RESTART);
323
323
      caps->supported_restart_modes = screen->get_param(screen, PIPE_CAP_SUPPORTED_PRIM_MODES_WITH_RESTART);
324
 
      caps->supported_restart_modes |= BITFIELD_BIT(PIPE_PRIM_PATCHES);
325
 
      if (caps->supported_restart_modes != BITFIELD_MASK(PIPE_PRIM_MAX))
 
324
      caps->supported_restart_modes |= BITFIELD_BIT(MESA_PRIM_PATCHES);
 
325
      if (caps->supported_restart_modes != BITFIELD_MASK(MESA_PRIM_COUNT))
326
326
         caps->fallback_always = true;
327
327
      caps->fallback_always |= caps->rewrite_restart_index;
328
328
   }
329
329
   caps->supported_prim_modes = screen->get_param(screen, PIPE_CAP_SUPPORTED_PRIM_MODES);
330
 
   if (caps->supported_prim_modes != BITFIELD_MASK(PIPE_PRIM_MAX))
 
330
   if (caps->supported_prim_modes != BITFIELD_MASK(MESA_PRIM_COUNT))
331
331
      caps->fallback_always = true;
332
332
 
333
333
   if (!screen->is_format_supported(screen, PIPE_FORMAT_R8_UINT, PIPE_BUFFER, 0, 0, PIPE_BIND_INDEX_BUFFER))
356
356
   mgr->pipe = pipe;
357
357
   if (caps->rewrite_ubyte_ibs || caps->rewrite_restart_index ||
358
358
       /* require all but patches */
359
 
       ((caps->supported_prim_modes & caps->supported_restart_modes & BITFIELD_MASK(PIPE_PRIM_MAX))) !=
360
 
                                      BITFIELD_MASK(PIPE_PRIM_MAX)) {
 
359
       ((caps->supported_prim_modes & caps->supported_restart_modes & BITFIELD_MASK(MESA_PRIM_COUNT))) !=
 
360
                                      BITFIELD_MASK(MESA_PRIM_COUNT)) {
361
361
      struct primconvert_config cfg;
362
362
      cfg.fixed_prim_restart = caps->rewrite_restart_index;
363
363
      cfg.primtypes_mask = caps->supported_prim_modes;
461
461
                         const struct pipe_draw_start_count_bias *draw,
462
462
                         unsigned vb_mask, unsigned out_vb,
463
463
                         int start_vertex, unsigned num_vertices,
464
 
                         int min_index, boolean unroll_indices)
 
464
                         int min_index, bool unroll_indices)
465
465
{
466
466
   struct translate *tr;
467
467
   struct pipe_transfer *vb_transfer[PIPE_MAX_ATTRIBS] = {0};
613
613
   return PIPE_OK;
614
614
}
615
615
 
616
 
static boolean
 
616
static bool
617
617
u_vbuf_translate_find_free_vb_slots(struct u_vbuf *mgr,
618
618
                                    unsigned mask[VB_NUM])
619
619
{
624
624
      mgr->ve->incompatible_vb_mask_all | mgr->incompatible_vb_mask |
625
625
      ~mgr->enabled_vb_mask;
626
626
   uint32_t unused_vb_mask_orig;
627
 
   boolean insufficient_buffers = false;
 
627
   bool insufficient_buffers = false;
628
628
 
629
629
   /* No vertex buffers available at all */
630
630
   if (!unused_vb_mask)
631
 
      return FALSE;
 
631
      return false;
632
632
 
633
633
   memset(fallback_vbs, ~0, sizeof(fallback_vbs));
634
634
   mgr->fallback_vbs_mask = 0;
671
671
   }
672
672
 
673
673
   memcpy(mgr->fallback_vbs, fallback_vbs, sizeof(fallback_vbs));
674
 
   return TRUE;
 
674
   return true;
675
675
}
676
676
 
677
 
static boolean
 
677
static bool
678
678
u_vbuf_translate_begin(struct u_vbuf *mgr,
679
679
                       const struct pipe_draw_info *info,
680
680
                       const struct pipe_draw_start_count_bias *draw,
681
681
                       int start_vertex, unsigned num_vertices,
682
 
                       int min_index, boolean unroll_indices,
 
682
                       int min_index, bool unroll_indices,
683
683
                       uint32_t misaligned)
684
684
{
685
685
   unsigned mask[VB_NUM] = {0};
735
735
 
736
736
   /* Find free vertex buffer slots. */
737
737
   if (!u_vbuf_translate_find_free_vb_slots(mgr, mask)) {
738
 
      return FALSE;
 
738
      return false;
739
739
   }
740
740
 
741
741
   unsigned min_alignment[VB_NUM] = {0};
801
801
                                        start[type], num[type], min_index,
802
802
                                        unroll_indices && type == VB_VERTEX);
803
803
         if (err != PIPE_OK)
804
 
            return FALSE;
 
804
            return false;
805
805
 
806
806
         /* Fixup the stride for constant attribs. */
807
807
         if (type == VB_CONST) {
836
836
   mgr->fallback_velems.count = mgr->ve->count;
837
837
 
838
838
   u_vbuf_set_vertex_elements_internal(mgr, &mgr->fallback_velems);
839
 
   mgr->using_translate = TRUE;
840
 
   return TRUE;
 
839
   mgr->using_translate = true;
 
840
   return true;
841
841
}
842
842
 
843
843
static void u_vbuf_translate_end(struct u_vbuf *mgr)
846
846
 
847
847
   /* Restore vertex elements. */
848
848
   mgr->pipe->bind_vertex_elements_state(mgr->pipe, mgr->ve->driver_cso);
849
 
   mgr->using_translate = FALSE;
 
849
   mgr->using_translate = false;
850
850
 
851
851
   /* Unreference the now-unused VBOs. */
852
852
   for (i = 0; i < VB_NUM; i++) {
1257
1257
   return PIPE_OK;
1258
1258
}
1259
1259
 
1260
 
static boolean u_vbuf_need_minmax_index(const struct u_vbuf *mgr, uint32_t misaligned)
 
1260
static bool u_vbuf_need_minmax_index(const struct u_vbuf *mgr, uint32_t misaligned)
1261
1261
{
1262
1262
   /* See if there are any per-vertex attribs which will be uploaded or
1263
1263
    * translated. Use bitmasks to get the info instead of looping over vertex
1271
1271
            mgr->nonzero_stride_vb_mask)) != 0;
1272
1272
}
1273
1273
 
1274
 
static boolean u_vbuf_mapping_vertex_buffer_blocks(const struct u_vbuf *mgr, uint32_t misaligned)
 
1274
static bool u_vbuf_mapping_vertex_buffer_blocks(const struct u_vbuf *mgr, uint32_t misaligned)
1275
1275
{
1276
1276
   /* Return true if there are hw buffers which don't need to be translated.
1277
1277
    *
1464
1464
   int start_vertex;
1465
1465
   unsigned min_index;
1466
1466
   unsigned num_vertices;
1467
 
   boolean unroll_indices = FALSE;
 
1467
   bool unroll_indices = false;
1468
1468
   const uint32_t used_vb_mask = mgr->ve->used_vb_mask;
1469
1469
   uint32_t user_vb_mask = mgr->user_vb_mask & used_vb_mask;
1470
1470
   unsigned fixed_restart_index = info->index_size ? util_prim_restart_index_from_size(info->index_size) : 0;
1701
1701
                !new_info.primitive_restart &&
1702
1702
                util_is_vbo_upload_ratio_too_large(new_draw.count, num_vertices) &&
1703
1703
                !u_vbuf_mapping_vertex_buffer_blocks(mgr, misaligned)) {
1704
 
               unroll_indices = TRUE;
 
1704
               unroll_indices = true;
1705
1705
               user_vb_mask &= ~(mgr->nonzero_stride_vb_mask &
1706
1706
                                 mgr->ve->noninstance_vb_mask_any);
1707
1707
            }