← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/gallium/drivers/llvmpipe/lp_setup.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/drivers/llvmpipe/lp_setup.c
61
61
#include "draw/draw_vbuf.h"
62
62
 
63
63
 
64
 
static boolean
 
64
static bool
65
65
try_update_scene_state(struct lp_setup_context *setup);
66
66
 
67
67
 
129
129
}
130
130
 
131
131
 
132
 
static boolean
 
132
static bool
133
133
first_rectangle(struct lp_setup_context *setup,
134
134
                const float (*v0)[4],
135
135
                const float (*v1)[4],
219
219
}
220
220
 
221
221
 
222
 
static boolean
 
222
static bool
223
223
begin_binning(struct lp_setup_context *setup)
224
224
{
225
225
   struct lp_scene *scene = setup->scene;
231
231
    */
232
232
   scene->fence = lp_fence_create(MAX2(1, setup->num_threads));
233
233
   if (!scene->fence)
234
 
      return FALSE;
 
234
      return false;
235
235
 
236
236
   if (!try_update_scene_state(setup)) {
237
 
      return FALSE;
 
237
      return false;
238
238
   }
239
239
 
240
 
   boolean need_zsload = FALSE;
 
240
   bool need_zsload = false;
241
241
   if (setup->fb.zsbuf &&
242
242
       ((setup->clear.flags & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&
243
243
        util_format_is_depth_and_stencil(setup->fb.zsbuf->format)) {
244
 
      need_zsload = TRUE;
 
244
      need_zsload = true;
245
245
   }
246
246
 
247
247
   LP_DBG(DEBUG_SETUP, "%s color clear bufs: %x depth: %s\n", __func__,
258
258
                  lp_scene_alloc(scene, sizeof(struct lp_rast_clear_rb));
259
259
 
260
260
            if (!cc_scene) {
261
 
               return FALSE;
 
261
               return false;
262
262
            }
263
263
 
264
264
            cc_scene->cbuf = cbuf;
268
268
            if (!lp_scene_bin_everywhere(scene,
269
269
                                         LP_RAST_OP_CLEAR_COLOR,
270
270
                                         clearrb_arg)) {
271
 
               return FALSE;
 
271
               return false;
272
272
            }
273
273
         }
274
274
      }
281
281
                                      lp_rast_arg_clearzs(
282
282
                                         setup->clear.zsvalue,
283
283
                                         setup->clear.zsmask))) {
284
 
            return FALSE;
 
284
            return false;
285
285
         }
286
286
      }
287
287
   }
293
293
   scene->had_queries = !!setup->active_binned_queries;
294
294
 
295
295
   LP_DBG(DEBUG_SETUP, "%s done\n", __func__);
296
 
   return TRUE;
 
296
   return true;
297
297
}
298
298
 
299
299
 
302
302
 *
303
303
 * TODO: fast path for fullscreen clears and no triangles.
304
304
 */
305
 
static boolean
 
305
static bool
306
306
execute_clears(struct lp_setup_context *setup)
307
307
{
308
308
   LP_DBG(DEBUG_SETUP, "%s\n", __func__);
318
318
};
319
319
 
320
320
 
321
 
static boolean
 
321
static bool
322
322
set_scene_state(struct lp_setup_context *setup,
323
323
                enum setup_state new_state,
324
324
                const char *reason)
326
326
   const unsigned old_state = setup->state;
327
327
 
328
328
   if (old_state == new_state)
329
 
      return TRUE;
 
329
      return true;
330
330
 
331
331
   if (LP_DEBUG & DEBUG_SCENE) {
332
332
      debug_printf("%s old %s new %s%s%s\n",
365
365
   }
366
366
 
367
367
   setup->state = new_state;
368
 
   return TRUE;
 
368
   return true;
369
369
 
370
370
fail:
371
371
   if (setup->scene) {
375
375
 
376
376
   setup->state = SETUP_FLUSHED;
377
377
   lp_setup_reset(setup);
378
 
   return FALSE;
 
378
   return false;
379
379
}
380
380
 
381
381
 
418
418
 * Try to clear one color buffer of the attached fb, either by binning a clear
419
419
 * command or queuing up the clear for later (when binning is started).
420
420
 */
421
 
static boolean
 
421
static bool
422
422
lp_setup_try_clear_color_buffer(struct lp_setup_context *setup,
423
423
                                const union pipe_color_union *color,
424
424
                                unsigned cbuf)
445
445
            lp_scene_alloc_aligned(scene, sizeof(struct lp_rast_clear_rb), 8);
446
446
 
447
447
      if (!cc_scene) {
448
 
         return FALSE;
 
448
         return false;
449
449
      }
450
450
 
451
451
      cc_scene->cbuf = cbuf;
455
455
      if (!lp_scene_bin_everywhere(scene,
456
456
                                   LP_RAST_OP_CLEAR_COLOR,
457
457
                                   clearrb_arg)) {
458
 
         return FALSE;
 
458
         return false;
459
459
      }
460
460
   } else {
461
461
      /* Put ourselves into the 'pre-clear' state, specifically to try
470
470
      setup->clear.color_val[cbuf] = uc;
471
471
   }
472
472
 
473
 
   return TRUE;
 
473
   return true;
474
474
}
475
475
 
476
476
 
477
 
static boolean
 
477
static bool
478
478
lp_setup_try_clear_zs(struct lp_setup_context *setup,
479
479
                      double depth,
480
480
                      unsigned stencil,
514
514
      if (!lp_scene_bin_everywhere(scene,
515
515
                                   LP_RAST_OP_CLEAR_ZSTENCIL,
516
516
                                   lp_rast_arg_clearzs(zsvalue, zsmask)))
517
 
         return FALSE;
 
517
         return false;
518
518
   } else {
519
519
      /* Put ourselves into the 'pre-clear' state, specifically to try
520
520
       * and accumulate multiple clears to color and depth_stencil
530
530
         (setup->clear.zsvalue & ~zsmask) | (zsvalue & zsmask);
531
531
   }
532
532
 
533
 
   return TRUE;
 
533
   return true;
534
534
}
535
535
 
536
536
 
599
599
   setup->point_size = rast->point_size;
600
600
   setup->sprite_coord_enable = rast->sprite_coord_enable;
601
601
   setup->sprite_coord_origin = rast->sprite_coord_mode;
602
 
   setup->point_tri_clip = rast->point_tri_clip;
 
602
   setup->point_line_tri_clip = rast->point_line_tri_clip;
603
603
   setup->point_size_per_vertex = rast->point_size_per_vertex;
604
604
   setup->legacy_points = !rast->point_quad_rasterization && !setup->multisample;
605
605
}
685
685
      util_copy_image_view(&setup->images[i].current, &images[i]);
686
686
 
687
687
      struct pipe_resource *res = image->resource;
688
 
      struct llvmpipe_resource *lp_res = llvmpipe_resource(res);
689
 
      struct lp_jit_image *jit_image = &setup->fs.current.jit_context.images[i];
 
688
      struct lp_jit_image *jit_image = &setup->fs.current.jit_resources.images[i];
690
689
 
691
 
      if (!lp_res)
 
690
      if (!res)
692
691
         continue;
693
692
 
694
 
      if (!lp_res->dt) {
695
 
         /* regular texture - setup array of mipmap level offsets */
696
 
         if (llvmpipe_resource_is_texture(res)) {
697
 
            jit_image->base = lp_res->tex_data;
698
 
         } else {
699
 
            jit_image->base = lp_res->data;
700
 
         }
701
 
 
702
 
         jit_image->width = res->width0;
703
 
         jit_image->height = res->height0;
704
 
         jit_image->depth = res->depth0;
705
 
         jit_image->num_samples = res->nr_samples;
706
 
 
707
 
         if (llvmpipe_resource_is_texture(res)) {
708
 
            uint32_t mip_offset = lp_res->mip_offsets[image->u.tex.level];
709
 
 
710
 
            jit_image->width = u_minify(jit_image->width, image->u.tex.level);
711
 
            jit_image->height = u_minify(jit_image->height, image->u.tex.level);
712
 
 
713
 
            if (res->target == PIPE_TEXTURE_1D_ARRAY ||
714
 
                res->target == PIPE_TEXTURE_2D_ARRAY ||
715
 
                res->target == PIPE_TEXTURE_3D ||
716
 
                res->target == PIPE_TEXTURE_CUBE ||
717
 
                res->target == PIPE_TEXTURE_CUBE_ARRAY) {
718
 
               /*
719
 
                * For array textures, we don't have first_layer, instead
720
 
                * adjust last_layer (stored as depth) plus the mip level offsets
721
 
                * (as we have mip-first layout can't just adjust base ptr).
722
 
                * XXX For mip levels, could do something similar.
723
 
                */
724
 
               jit_image->depth = image->u.tex.last_layer - image->u.tex.first_layer + 1;
725
 
               mip_offset += image->u.tex.first_layer * lp_res->img_stride[image->u.tex.level];
726
 
            } else
727
 
               jit_image->depth = u_minify(jit_image->depth, image->u.tex.level);
728
 
 
729
 
            jit_image->row_stride = lp_res->row_stride[image->u.tex.level];
730
 
            jit_image->img_stride = lp_res->img_stride[image->u.tex.level];
731
 
            jit_image->sample_stride = lp_res->sample_stride;
732
 
            jit_image->base = (uint8_t *)jit_image->base + mip_offset;
733
 
         } else {
734
 
            unsigned view_blocksize = util_format_get_blocksize(image->format);
735
 
            jit_image->width = image->u.buf.size / view_blocksize;
736
 
            jit_image->base = (uint8_t *)jit_image->base + image->u.buf.offset;
737
 
         }
738
 
      }
 
693
      lp_jit_image_from_pipe(jit_image, image);
739
694
   }
740
695
   for (; i < ARRAY_SIZE(setup->images); i++) {
741
696
      util_copy_image_view(&setup->images[i].current, NULL);
759
714
 
760
715
void
761
716
lp_setup_set_stencil_ref_values(struct lp_setup_context *setup,
762
 
                                const ubyte refs[2])
 
717
                                const uint8_t refs[2])
763
718
{
764
719
   LP_DBG(DEBUG_SETUP, "%s %d %d\n", __func__, refs[0], refs[1]);
765
720
 
819
774
 
820
775
void
821
776
lp_setup_set_rasterizer_discard(struct lp_setup_context *setup,
822
 
                                boolean rasterizer_discard)
 
777
                                bool rasterizer_discard)
823
778
{
824
779
   if (setup->rasterizer_discard != rasterizer_discard) {
825
780
      setup->rasterizer_discard = rasterizer_discard;
843
798
 
844
799
void
845
800
lp_setup_set_linear_mode(struct lp_setup_context *setup,
846
 
                         boolean mode)
 
801
                         bool mode)
847
802
{
848
803
   /* The linear rasterizer requires sse2 both at compile and runtime,
849
804
    * in particular for the code in lp_rast_linear_fallback.c.  This
854
809
   setup->permit_linear_rasterizer = (mode &&
855
810
                                      util_get_cpu_caps()->has_sse2);
856
811
#else
857
 
   setup->permit_linear_rasterizer = FALSE;
 
812
   setup->permit_linear_rasterizer = false;
858
813
#endif
859
814
}
860
815
 
938
893
 
939
894
      if (view) {
940
895
         struct pipe_resource *res = view->texture;
941
 
         struct llvmpipe_resource *lp_tex = llvmpipe_resource(res);
942
896
         struct lp_jit_texture *jit_tex;
943
 
         jit_tex = &setup->fs.current.jit_context.textures[i];
 
897
         jit_tex = &setup->fs.current.jit_resources.textures[i];
944
898
 
945
899
         /* We're referencing the texture's internal data, so save a
946
900
          * reference to it.
947
901
          */
948
902
         pipe_resource_reference(&setup->fs.current_tex[i], res);
949
903
 
950
 
         if (!lp_tex->dt) {
951
 
            /* regular texture - setup array of mipmap level offsets */
952
 
            unsigned first_level = 0;
953
 
            unsigned last_level = 0;
954
 
 
955
 
            if (llvmpipe_resource_is_texture(res)) {
956
 
               first_level = view->u.tex.first_level;
957
 
               last_level = view->u.tex.last_level;
958
 
               assert(first_level <= last_level);
959
 
               assert(last_level <= res->last_level);
960
 
               jit_tex->base = lp_tex->tex_data;
961
 
            } else {
962
 
               jit_tex->base = lp_tex->data;
963
 
            }
964
 
 
965
 
            if (LP_PERF & PERF_TEX_MEM) {
966
 
               /* use dummy tile memory */
967
 
               jit_tex->base = lp_dummy_tile;
968
 
               jit_tex->width = TILE_SIZE/8;
969
 
               jit_tex->height = TILE_SIZE/8;
970
 
               jit_tex->depth = 1;
971
 
               jit_tex->first_level = 0;
972
 
               jit_tex->last_level = 0;
973
 
               jit_tex->mip_offsets[0] = 0;
974
 
               jit_tex->row_stride[0] = 0;
975
 
               jit_tex->img_stride[0] = 0;
976
 
               jit_tex->num_samples = 0;
977
 
               jit_tex->sample_stride = 0;
978
 
            } else {
979
 
               jit_tex->width = res->width0;
980
 
               jit_tex->height = res->height0;
981
 
               jit_tex->depth = res->depth0;
982
 
               jit_tex->first_level = first_level;
983
 
               jit_tex->last_level = last_level;
984
 
               jit_tex->num_samples = res->nr_samples;
985
 
               jit_tex->sample_stride = 0;
986
 
 
987
 
               if (llvmpipe_resource_is_texture(res)) {
988
 
                  for (unsigned j = first_level; j <= last_level; j++) {
989
 
                     jit_tex->mip_offsets[j] = lp_tex->mip_offsets[j];
990
 
                     jit_tex->row_stride[j] = lp_tex->row_stride[j];
991
 
                     jit_tex->img_stride[j] = lp_tex->img_stride[j];
992
 
                  }
993
 
 
994
 
                  jit_tex->sample_stride = lp_tex->sample_stride;
995
 
 
996
 
                  if (res->target == PIPE_TEXTURE_1D_ARRAY ||
997
 
                      res->target == PIPE_TEXTURE_2D_ARRAY ||
998
 
                      res->target == PIPE_TEXTURE_CUBE ||
999
 
                      res->target == PIPE_TEXTURE_CUBE_ARRAY ||
1000
 
                      (res->target == PIPE_TEXTURE_3D && view->target == PIPE_TEXTURE_2D)) {
1001
 
                     /*
1002
 
                      * For array textures, we don't have first_layer, instead
1003
 
                      * adjust last_layer (stored as depth) plus the mip level
1004
 
                      * offsets (as we have mip-first layout can't just adjust
1005
 
                      * base ptr).  XXX For mip levels, could do something
1006
 
                      * similar.
1007
 
                      */
1008
 
                     jit_tex->depth = view->u.tex.last_layer - view->u.tex.first_layer + 1;
1009
 
                     for (unsigned j = first_level; j <= last_level; j++) {
1010
 
                        jit_tex->mip_offsets[j] += view->u.tex.first_layer *
1011
 
                                                   lp_tex->img_stride[j];
1012
 
                     }
1013
 
                     if (view->target == PIPE_TEXTURE_CUBE ||
1014
 
                         view->target == PIPE_TEXTURE_CUBE_ARRAY) {
1015
 
                        assert(jit_tex->depth % 6 == 0);
1016
 
                     }
1017
 
                     assert(view->u.tex.first_layer <= view->u.tex.last_layer);
1018
 
                     if (res->target == PIPE_TEXTURE_3D)
1019
 
                        assert(view->u.tex.last_layer < res->depth0);
1020
 
                     else
1021
 
                        assert(view->u.tex.last_layer < res->array_size);
1022
 
                  }
1023
 
               } else {
1024
 
                  /*
1025
 
                   * For buffers, we don't have "offset", instead adjust
1026
 
                   * the size (stored as width) plus the base pointer.
1027
 
                   */
1028
 
                  const unsigned view_blocksize =
1029
 
                     util_format_get_blocksize(view->format);
1030
 
                  /* probably don't really need to fill that out */
1031
 
                  jit_tex->mip_offsets[0] = 0;
1032
 
                  jit_tex->row_stride[0] = 0;
1033
 
                  jit_tex->img_stride[0] = 0;
1034
 
 
1035
 
                  /* everything specified in number of elements here. */
1036
 
                  jit_tex->width = view->u.buf.size / view_blocksize;
1037
 
                  jit_tex->base = (uint8_t *)jit_tex->base + view->u.buf.offset;
1038
 
                  /* XXX Unsure if we need to sanitize parameters? */
1039
 
                  assert(view->u.buf.offset + view->u.buf.size <= res->width0);
1040
 
               }
1041
 
            }
1042
 
         } else {
1043
 
            /* display target texture/surface */
1044
 
            jit_tex->base = llvmpipe_resource_map(res, 0, 0, LP_TEX_USAGE_READ);
1045
 
            jit_tex->row_stride[0] = lp_tex->row_stride[0];
1046
 
            jit_tex->img_stride[0] = lp_tex->img_stride[0];
1047
 
            jit_tex->mip_offsets[0] = 0;
1048
 
            jit_tex->width = res->width0;
1049
 
            jit_tex->height = res->height0;
1050
 
            jit_tex->depth = res->depth0;
1051
 
            jit_tex->first_level = jit_tex->last_level = 0;
1052
 
            jit_tex->num_samples = res->nr_samples;
1053
 
            jit_tex->sample_stride = 0;
1054
 
            assert(jit_tex->base);
1055
 
         }
 
904
         lp_jit_texture_from_pipe(jit_tex, view);
1056
905
      } else {
1057
906
         pipe_resource_reference(&setup->fs.current_tex[i], NULL);
1058
907
      }
1080
929
 
1081
930
      if (sampler) {
1082
931
         struct lp_jit_sampler *jit_sam;
1083
 
         jit_sam = &setup->fs.current.jit_context.samplers[i];
 
932
         jit_sam = &setup->fs.current.jit_resources.samplers[i];
1084
933
 
1085
 
         jit_sam->min_lod = sampler->min_lod;
1086
 
         jit_sam->max_lod = sampler->max_lod;
1087
 
         jit_sam->lod_bias = sampler->lod_bias;
1088
 
         jit_sam->max_aniso = sampler->max_anisotropy;
1089
 
         COPY_4V(jit_sam->border_color, sampler->border_color.f);
 
934
         lp_jit_sampler_from_pipe(jit_sam, sampler);
1090
935
      }
1091
936
   }
1092
937
 
1115
960
   /* check resources referenced by active scenes */
1116
961
   for (unsigned i = 0; i < setup->num_active_scenes; i++) {
1117
962
      struct lp_scene *scene = setup->scenes[i];
1118
 
      /* check the render targets */
1119
 
      for (unsigned j = 0; j < scene->fb.nr_cbufs; j++) {
1120
 
         if (scene->fb.cbufs[j] && scene->fb.cbufs[j]->texture == texture)
1121
 
            return LP_REFERENCED_FOR_READ | LP_REFERENCED_FOR_WRITE;
1122
 
      }
1123
 
      if (scene->fb.zsbuf && scene->fb.zsbuf->texture == texture) {
1124
 
         return LP_REFERENCED_FOR_READ | LP_REFERENCED_FOR_WRITE;
1125
 
      }
1126
963
 
1127
 
      /* check resources referenced by the scene */
 
964
      mtx_lock(&scene->mutex);
1128
965
      unsigned ref = lp_scene_is_resource_referenced(scene, texture);
 
966
      mtx_unlock(&scene->mutex);
1129
967
      if (ref)
1130
968
         return ref;
1131
969
   }
1146
984
 * pointers previously allocated with lp_scene_alloc() in this function (or any
1147
985
 * function) as they may belong to a scene freed since then.
1148
986
 */
1149
 
static boolean
 
987
static bool
1150
988
try_update_scene_state(struct lp_setup_context *setup)
1151
989
{
1152
 
   static const float fake_const_buf[4];
1153
 
   boolean new_scene = (setup->fs.stored == NULL);
 
990
   bool new_scene = (setup->fs.stored == NULL);
1154
991
   struct lp_scene *scene = setup->scene;
1155
992
 
1156
993
   assert(scene);
1169
1006
 
1170
1007
      if (!stored) {
1171
1008
         assert(!new_scene);
1172
 
         return FALSE;
 
1009
         return false;
1173
1010
      }
1174
1011
 
1175
1012
      memcpy(stored, setup->viewports, sizeof setup->viewports);
1188
1025
 
1189
1026
      if (!stored) {
1190
1027
         assert(!new_scene);
1191
 
         return FALSE;
 
1028
         return false;
1192
1029
      }
1193
1030
 
1194
1031
      /* Store floating point colour (after ubyte colors (see below)) */
1219
1056
 
1220
1057
   if (setup->dirty & LP_SETUP_NEW_CONSTANTS) {
1221
1058
      for (unsigned i = 0; i < ARRAY_SIZE(setup->constants); ++i) {
1222
 
         struct pipe_resource *buffer = setup->constants[i].current.buffer;
1223
 
         const unsigned current_size = MIN2(setup->constants[i].current.buffer_size,
1224
 
                                            LP_MAX_TGSI_CONST_BUFFER_SIZE);
1225
 
         const ubyte *current_data = NULL;
1226
 
 
1227
 
         STATIC_ASSERT(DATA_BLOCK_SIZE >= LP_MAX_TGSI_CONST_BUFFER_SIZE);
1228
 
 
1229
 
         if (buffer) {
1230
 
            /* resource buffer */
1231
 
            current_data = (ubyte *) llvmpipe_resource_data(buffer);
1232
 
         } else if (setup->constants[i].current.user_buffer) {
1233
 
            /* user-space buffer */
1234
 
            current_data = (ubyte *) setup->constants[i].current.user_buffer;
1235
 
         }
1236
 
 
1237
 
         if (current_data && current_size >= sizeof(float)) {
1238
 
            current_data += setup->constants[i].current.buffer_offset;
1239
 
 
1240
 
            /* TODO: copy only the actually used constants? */
1241
 
 
1242
 
            if (setup->constants[i].stored_size != current_size ||
1243
 
               !setup->constants[i].stored_data ||
1244
 
               memcmp(setup->constants[i].stored_data,
1245
 
                      current_data,
1246
 
                      current_size) != 0) {
1247
 
 
1248
 
               void *stored = lp_scene_alloc(scene, current_size);
1249
 
               if (!stored) {
1250
 
                  assert(!new_scene);
1251
 
                  return FALSE;
1252
 
               }
1253
 
 
1254
 
               memcpy(stored,
1255
 
                      current_data,
1256
 
                      current_size);
1257
 
               setup->constants[i].stored_size = current_size;
1258
 
               setup->constants[i].stored_data = stored;
1259
 
            }
1260
 
            setup->fs.current.jit_context.constants[i].f =
1261
 
               setup->constants[i].stored_data;
1262
 
         } else {
1263
 
            setup->constants[i].stored_size = 0;
1264
 
            setup->constants[i].stored_data = NULL;
1265
 
            setup->fs.current.jit_context.constants[i].f = fake_const_buf;
1266
 
         }
1267
 
 
1268
 
         const int num_constants =
1269
 
            DIV_ROUND_UP(setup->constants[i].stored_size,
1270
 
                         lp_get_constant_buffer_stride(scene->pipe->screen));
1271
 
         setup->fs.current.jit_context.constants[i].num_elements = num_constants;
 
1059
         lp_jit_buffer_from_pipe_const(&setup->fs.current.jit_resources.constants[i],
 
1060
                                       &setup->constants[i].current, setup->pipe->screen);
 
1061
         if (setup->constants[i].current.buffer &&
 
1062
             !lp_scene_add_resource_reference(scene,
 
1063
                           setup->constants[i].current.buffer,
 
1064
                           new_scene, false)) {
 
1065
            assert(!new_scene);
 
1066
            return false;
 
1067
         }
1272
1068
         setup->dirty |= LP_SETUP_NEW_FS;
1273
1069
      }
1274
1070
   }
1275
1071
 
1276
1072
   if (setup->dirty & LP_SETUP_NEW_SSBOS) {
1277
1073
      for (unsigned i = 0; i < ARRAY_SIZE(setup->ssbos); ++i) {
1278
 
         struct pipe_resource *buffer = setup->ssbos[i].current.buffer;
1279
 
         const ubyte *current_data = NULL;
1280
 
 
1281
 
         /* resource buffer */
1282
 
         if (buffer)
1283
 
            current_data = (ubyte *) llvmpipe_resource_data(buffer);
1284
 
 
1285
 
         if (current_data) {
1286
 
            current_data += setup->ssbos[i].current.buffer_offset;
1287
 
 
1288
 
            setup->fs.current.jit_context.ssbos[i].u =
1289
 
               (const uint32_t *)current_data;
1290
 
            setup->fs.current.jit_context.ssbos[i].num_elements =
1291
 
               setup->ssbos[i].current.buffer_size;
1292
 
         } else {
1293
 
            setup->fs.current.jit_context.ssbos[i].u = NULL;
1294
 
            setup->fs.current.jit_context.ssbos[i].num_elements = 0;
1295
 
         }
 
1074
         lp_jit_buffer_from_pipe(&setup->fs.current.jit_resources.ssbos[i],
 
1075
                                 &setup->ssbos[i].current);
1296
1076
         setup->dirty |= LP_SETUP_NEW_FS;
1297
1077
      }
1298
1078
   }
1310
1090
            (struct lp_rast_state *) lp_scene_alloc(scene, sizeof *stored);
1311
1091
         if (!stored) {
1312
1092
            assert(!new_scene);
1313
 
            return FALSE;
 
1093
            return false;
1314
1094
         }
1315
1095
 
1316
1096
         memcpy(&stored->jit_context,
1317
1097
                &setup->fs.current.jit_context,
1318
1098
                sizeof setup->fs.current.jit_context);
 
1099
         memcpy(&stored->jit_resources,
 
1100
                &setup->fs.current.jit_resources,
 
1101
                sizeof setup->fs.current.jit_resources);         
1319
1102
 
1320
 
         stored->jit_context.aniso_filter_table =
 
1103
         stored->jit_resources.aniso_filter_table =
1321
1104
            lp_build_sample_aniso_filter_table();
1322
1105
         stored->variant = setup->fs.current.variant;
1323
1106
 
1324
1107
         if (!lp_scene_add_frag_shader_reference(scene,
1325
1108
                                                 setup->fs.current.variant)) {
1326
 
            return FALSE;
 
1109
            return false;
1327
1110
         }
1328
1111
 
1329
1112
         setup->fs.stored = stored;
1337
1120
                                                    setup->fs.current_tex[i],
1338
1121
                                                    new_scene, false)) {
1339
1122
                  assert(!new_scene);
1340
 
                  return FALSE;
 
1123
                  return false;
1341
1124
               }
1342
1125
            }
1343
1126
         }
1348
1131
                               setup->ssbos[i].current.buffer,
1349
1132
                               new_scene, setup->ssbo_write_mask & (1 << i))) {
1350
1133
                  assert(!new_scene);
1351
 
                  return FALSE;
 
1134
                  return false;
1352
1135
               }
1353
1136
            }
1354
1137
         }
1360
1143
                                                    new_scene,
1361
1144
                                                    setup->images[i].current.shader_access & PIPE_IMAGE_ACCESS_WRITE)) {
1362
1145
                  assert(!new_scene);
1363
 
                  return FALSE;
 
1146
                  return false;
1364
1147
               }
1365
1148
            }
1366
1149
         }
1377
1160
      }
1378
1161
      if (setup->permit_linear_rasterizer) {
1379
1162
         /* NOTE: this only takes first vp into account. */
1380
 
         boolean need_vp_scissoring =
 
1163
         bool need_vp_scissoring =
1381
1164
            !!memcmp(&setup->vpwh, &setup->framebuffer,
1382
1165
                     sizeof(setup->framebuffer));
1383
1166
 
1386
1169
            u_rect_possible_intersection(&setup->vpwh,
1387
1170
                                         &setup->draw_regions[0]);
1388
1171
         }
1389
 
      } else if (setup->point_tri_clip) {
 
1172
      } else if (setup->point_line_tri_clip) {
1390
1173
         /*
1391
1174
          * for d3d-style point clipping, we're going to need
1392
1175
          * the fake vp scissor too. Hence do the intersection with vp,
1396
1179
          * points are always single pixel).
1397
1180
          * (Also note that if we have permit_linear_rasterizer this will
1398
1181
          * cause large points to always get vp scissored, regardless the
1399
 
          * point_tri_clip setting.)
 
1182
          * point_line_tri_clip setting.)
1400
1183
          */
1401
 
         boolean need_vp_scissoring =
 
1184
         bool need_vp_scissoring =
1402
1185
            !!memcmp(&setup->vpwh, &setup->framebuffer,
1403
1186
                     sizeof(setup->framebuffer));
1404
1187
         if (need_vp_scissoring) {
1411
1194
   setup->dirty = 0;
1412
1195
 
1413
1196
   assert(setup->fs.stored);
1414
 
   return TRUE;
 
1197
   return true;
1415
1198
}
1416
1199
 
1417
1200
 
1418
 
boolean
 
1201
bool
1419
1202
lp_setup_update_state(struct lp_setup_context *setup,
1420
 
                      boolean update_scene)
 
1203
                      bool update_scene)
1421
1204
{
1422
1205
   /* Some of the 'draw' pipeline stages may have changed some driver state.
1423
1206
    * Make sure we've processed those state changes before anything else.
1457
1240
 
1458
1241
   if (update_scene && setup->state != SETUP_ACTIVE) {
1459
1242
      if (!set_scene_state(setup, SETUP_ACTIVE, __func__))
1460
 
         return FALSE;
 
1243
         return false;
1461
1244
   }
1462
1245
 
1463
1246
   /* Only call into update_scene_state() if we already have a
1467
1250
      assert(setup->state == SETUP_ACTIVE);
1468
1251
 
1469
1252
      if (try_update_scene_state(setup))
1470
 
         return TRUE;
 
1253
         return true;
1471
1254
 
1472
1255
      /* Update failed, try to restart the scene.
1473
1256
       *
1475
1258
       * because of potential recursion.
1476
1259
       */
1477
1260
      if (!set_scene_state(setup, SETUP_FLUSHED, __func__))
1478
 
         return FALSE;
 
1261
         return false;
1479
1262
 
1480
1263
      if (!set_scene_state(setup, SETUP_ACTIVE, __func__))
1481
 
         return FALSE;
 
1264
         return false;
1482
1265
 
1483
1266
      if (!setup->scene)
1484
 
         return FALSE;
 
1267
         return false;
1485
1268
 
1486
1269
      return try_update_scene_state(setup);
1487
1270
   }
1488
1271
 
1489
 
   return TRUE;
 
1272
   return true;
1490
1273
}
1491
1274
 
1492
1275
 
1644
1427
            return;
1645
1428
         }
1646
1429
      }
1647
 
      setup->scene->had_queries |= TRUE;
 
1430
      setup->scene->had_queries |= true;
1648
1431
   }
1649
1432
}
1650
1433
 
1691
1474
               goto fail;
1692
1475
            }
1693
1476
         }
1694
 
         setup->scene->had_queries |= TRUE;
 
1477
         setup->scene->had_queries |= true;
1695
1478
      }
1696
1479
   } else {
1697
1480
      struct llvmpipe_screen *screen = llvmpipe_screen(setup->pipe->screen);
1726
1509
}
1727
1510
 
1728
1511
 
1729
 
boolean
 
1512
bool
1730
1513
lp_setup_flush_and_restart(struct lp_setup_context *setup)
1731
1514
{
1732
1515
   if (0) debug_printf("%s\n", __func__);
1734
1517
   assert(setup->state == SETUP_ACTIVE);
1735
1518
 
1736
1519
   if (!set_scene_state(setup, SETUP_FLUSHED, __func__))
1737
 
      return FALSE;
1738
 
 
1739
 
   if (!lp_setup_update_state(setup, TRUE))
1740
 
      return FALSE;
1741
 
 
1742
 
   return TRUE;
 
1520
      return false;
 
1521
 
 
1522
   if (!lp_setup_update_state(setup, true))
 
1523
      return false;
 
1524
 
 
1525
   return true;
1743
1526
}
1744
1527
 
1745
1528
 
1746
1529
void
1747
1530
lp_setup_add_scissor_planes(const struct u_rect *scissor,
1748
1531
                            struct lp_rast_plane *plane_s,
1749
 
                            boolean s_planes[4], bool multisample)
 
1532
                            bool s_planes[4], bool multisample)
1750
1533
{
1751
1534
   /*
1752
1535
    * When rasterizing scissored tris, use the intersection of the