src/gallium/drivers/swr/swr_state.cpp

   1 /****************************************************************************
   2  * Copyright (C) 2015 Intel Corporation.   All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  ***************************************************************************/
  23
  24 // llvm redefines DEBUG
  25 #pragma push_macro("DEBUG")
  26 #undef DEBUG
  27 #include "JitManager.h"
  28 #pragma pop_macro("DEBUG")
  29
  30 #include "common/os.h"
  31 #include "jit_api.h"
  32 #include "state_llvm.h"
  33
  34 #include "gallivm/lp_bld_tgsi.h"
  35 #include "util/u_format.h"
  36
  37 #include "util/u_memory.h"
  38 #include "util/u_inlines.h"
  39 #include "util/u_helpers.h"
  40 #include "util/u_framebuffer.h"
  41 #include "util/u_viewport.h"
  42
  43 #include "swr_state.h"
  44 #include "swr_context.h"
  45 #include "swr_context_llvm.h"
  46 #include "swr_screen.h"
  47 #include "swr_resource.h"
  48 #include "swr_tex_sample.h"
  49 #include "swr_scratch.h"
  50 #include "swr_shader.h"
  51 #include "swr_fence.h"
  52
  53 /* These should be pulled out into separate files as necessary
  54  * Just initializing everything here to get going. */
  55
  56 static void *
  57 swr_create_blend_state(struct pipe_context *pipe,
  58                        const struct pipe_blend_state *blend)
  59 {
  60    struct swr_blend_state *state = CALLOC_STRUCT(swr_blend_state);
  61
  62    memcpy(&state->pipe, blend, sizeof(*blend));
  63
  64    struct pipe_blend_state *pipe_blend = &state->pipe;
  65
  66    for (int target = 0;
  67         target < std::min(SWR_NUM_RENDERTARGETS, PIPE_MAX_COLOR_BUFS);
  68         target++) {
  69
  70       struct pipe_rt_blend_state *rt_blend = &pipe_blend->rt[target];
  71       SWR_RENDER_TARGET_BLEND_STATE &blendState =
  72          state->blendState.renderTarget[target];
  73       RENDER_TARGET_BLEND_COMPILE_STATE &compileState =
  74          state->compileState[target];
  75
  76       if (target != 0 && !pipe_blend->independent_blend_enable) {
  77          memcpy(&compileState,
  78                 &state->compileState[0],
  79                 sizeof(RENDER_TARGET_BLEND_COMPILE_STATE));
  80          continue;
  81       }
  82
  83       compileState.blendEnable = rt_blend->blend_enable;
  84       if (compileState.blendEnable) {
  85          compileState.sourceAlphaBlendFactor =
  86             swr_convert_blend_factor(rt_blend->alpha_src_factor);
  87          compileState.destAlphaBlendFactor =
  88             swr_convert_blend_factor(rt_blend->alpha_dst_factor);
  89          compileState.sourceBlendFactor =
  90             swr_convert_blend_factor(rt_blend->rgb_src_factor);
  91          compileState.destBlendFactor =
  92             swr_convert_blend_factor(rt_blend->rgb_dst_factor);
  93
  94          compileState.colorBlendFunc =
  95             swr_convert_blend_func(rt_blend->rgb_func);
  96          compileState.alphaBlendFunc =
  97             swr_convert_blend_func(rt_blend->alpha_func);
  98       }
  99       compileState.logicOpEnable = state->pipe.logicop_enable;
 100       if (compileState.logicOpEnable) {
 101          compileState.logicOpFunc =
 102             swr_convert_logic_op(state->pipe.logicop_func);
 103       }
 104
 105       blendState.writeDisableRed =
 106          (rt_blend->colormask & PIPE_MASK_R) ? 0 : 1;
 107       blendState.writeDisableGreen =
 108          (rt_blend->colormask & PIPE_MASK_G) ? 0 : 1;
 109       blendState.writeDisableBlue =
 110          (rt_blend->colormask & PIPE_MASK_B) ? 0 : 1;
 111       blendState.writeDisableAlpha =
 112          (rt_blend->colormask & PIPE_MASK_A) ? 0 : 1;
 113
 114       if (rt_blend->colormask == 0)
 115          compileState.blendEnable = false;
 116    }
 117
 118    return state;
 119 }
 120
 121 static void
 122 swr_bind_blend_state(struct pipe_context *pipe, void *blend)
 123 {
 124    struct swr_context *ctx = swr_context(pipe);
 125
 126    if (ctx->blend == blend)
 127       return;
 128
 129    ctx->blend = (swr_blend_state *)blend;
 130
 131    ctx->dirty |= SWR_NEW_BLEND;
 132 }
 133
 134 static void
 135 swr_delete_blend_state(struct pipe_context *pipe, void *blend)
 136 {
 137    FREE(blend);
 138 }
 139
 140 static void
 141 swr_set_blend_color(struct pipe_context *pipe,
 142                     const struct pipe_blend_color *color)
 143 {
 144    struct swr_context *ctx = swr_context(pipe);
 145
 146    ctx->blend_color = *color;
 147
 148    ctx->dirty |= SWR_NEW_BLEND;
 149 }
 150
 151 static void
 152 swr_set_stencil_ref(struct pipe_context *pipe,
 153                     const struct pipe_stencil_ref *ref)
 154 {
 155    struct swr_context *ctx = swr_context(pipe);
 156
 157    ctx->stencil_ref = *ref;
 158
 159    ctx->dirty |= SWR_NEW_DEPTH_STENCIL_ALPHA;
 160 }
 161
 162 static void *
 163 swr_create_depth_stencil_state(
 164    struct pipe_context *pipe,
 165    const struct pipe_depth_stencil_alpha_state *depth_stencil)
 166 {
 167    struct pipe_depth_stencil_alpha_state *state;
 168
 169    state = (pipe_depth_stencil_alpha_state *)mem_dup(depth_stencil,
 170                                                      sizeof *depth_stencil);
 171
 172    return state;
 173 }
 174
 175 static void
 176 swr_bind_depth_stencil_state(struct pipe_context *pipe, void *depth_stencil)
 177 {
 178    struct swr_context *ctx = swr_context(pipe);
 179
 180    if (ctx->depth_stencil == (pipe_depth_stencil_alpha_state *)depth_stencil)
 181       return;
 182
 183    ctx->depth_stencil = (pipe_depth_stencil_alpha_state *)depth_stencil;
 184
 185    ctx->dirty |= SWR_NEW_DEPTH_STENCIL_ALPHA;
 186 }
 187
 188 static void
 189 swr_delete_depth_stencil_state(struct pipe_context *pipe, void *depth)
 190 {
 191    FREE(depth);
 192 }
 193
 194
 195 static void *
 196 swr_create_rasterizer_state(struct pipe_context *pipe,
 197                             const struct pipe_rasterizer_state *rast)
 198 {
 199    struct pipe_rasterizer_state *state;
 200    state = (pipe_rasterizer_state *)mem_dup(rast, sizeof *rast);
 201
 202    return state;
 203 }
 204
 205 static void
 206 swr_bind_rasterizer_state(struct pipe_context *pipe, void *handle)
 207 {
 208    struct swr_context *ctx = swr_context(pipe);
 209    const struct pipe_rasterizer_state *rasterizer =
 210       (const struct pipe_rasterizer_state *)handle;
 211
 212    if (ctx->rasterizer == (pipe_rasterizer_state *)rasterizer)
 213       return;
 214
 215    ctx->rasterizer = (pipe_rasterizer_state *)rasterizer;
 216
 217    ctx->dirty |= SWR_NEW_RASTERIZER;
 218 }
 219
 220 static void
 221 swr_delete_rasterizer_state(struct pipe_context *pipe, void *rasterizer)
 222 {
 223    FREE(rasterizer);
 224 }
 225
 226
 227 static void *
 228 swr_create_sampler_state(struct pipe_context *pipe,
 229                          const struct pipe_sampler_state *sampler)
 230 {
 231    struct pipe_sampler_state *state =
 232       (pipe_sampler_state *)mem_dup(sampler, sizeof *sampler);
 233
 234    return state;
 235 }
 236
 237 static void
 238 swr_bind_sampler_states(struct pipe_context *pipe,
 239                         enum pipe_shader_type shader,
 240                         unsigned start,
 241                         unsigned num,
 242                         void **samplers)
 243 {
 244    struct swr_context *ctx = swr_context(pipe);
 245    unsigned i;
 246
 247    assert(shader < PIPE_SHADER_TYPES);
 248    assert(start + num <= ARRAY_SIZE(ctx->samplers[shader]));
 249
 250    /* set the new samplers */
 251    ctx->num_samplers[shader] = num;
 252    for (i = 0; i < num; i++) {
 253       ctx->samplers[shader][start + i] = (pipe_sampler_state *)samplers[i];
 254    }
 255
 256    ctx->dirty |= SWR_NEW_SAMPLER;
 257 }
 258
 259 static void
 260 swr_delete_sampler_state(struct pipe_context *pipe, void *sampler)
 261 {
 262    FREE(sampler);
 263 }
 264
 265
 266 static struct pipe_sampler_view *
 267 swr_create_sampler_view(struct pipe_context *pipe,
 268                         struct pipe_resource *texture,
 269                         const struct pipe_sampler_view *templ)
 270 {
 271    struct pipe_sampler_view *view = CALLOC_STRUCT(pipe_sampler_view);
 272
 273    if (view) {
 274       *view = *templ;
 275       view->reference.count = 1;
 276       view->texture = NULL;
 277       pipe_resource_reference(&view->texture, texture);
 278       view->context = pipe;
 279    }
 280
 281    return view;
 282 }
 283
 284 static void
 285 swr_set_sampler_views(struct pipe_context *pipe,
 286                       enum pipe_shader_type shader,
 287                       unsigned start,
 288                       unsigned num,
 289                       struct pipe_sampler_view **views)
 290 {
 291    struct swr_context *ctx = swr_context(pipe);
 292    uint i;
 293
 294    assert(num <= PIPE_MAX_SHADER_SAMPLER_VIEWS);
 295
 296    assert(shader < PIPE_SHADER_TYPES);
 297    assert(start + num <= ARRAY_SIZE(ctx->sampler_views[shader]));
 298
 299    /* set the new sampler views */
 300    ctx->num_sampler_views[shader] = num;
 301    for (i = 0; i < num; i++) {
 302       /* Note: we're using pipe_sampler_view_release() here to work around
 303        * a possible crash when the old view belongs to another context that
 304        * was already destroyed.
 305        */
 306       pipe_sampler_view_release(pipe, &ctx->sampler_views[shader][start + i]);
 307       pipe_sampler_view_reference(&ctx->sampler_views[shader][start + i],
 308                                   views[i]);
 309    }
 310
 311    ctx->dirty |= SWR_NEW_SAMPLER_VIEW;
 312 }
 313
 314 static void
 315 swr_sampler_view_destroy(struct pipe_context *pipe,
 316                          struct pipe_sampler_view *view)
 317 {
 318    pipe_resource_reference(&view->texture, NULL);
 319    FREE(view);
 320 }
 321
 322 static void *
 323 swr_create_vs_state(struct pipe_context *pipe,
 324                     const struct pipe_shader_state *vs)
 325 {
 326    struct swr_vertex_shader *swr_vs = new swr_vertex_shader;
 327    if (!swr_vs)
 328       return NULL;
 329
 330    swr_vs->pipe.tokens = tgsi_dup_tokens(vs->tokens);
 331    swr_vs->pipe.stream_output = vs->stream_output;
 332
 333    lp_build_tgsi_info(vs->tokens, &swr_vs->info);
 334
 335    swr_vs->soState = {0};
 336
 337    if (swr_vs->pipe.stream_output.num_outputs) {
 338       pipe_stream_output_info *stream_output = &swr_vs->pipe.stream_output;
 339
 340       swr_vs->soState.soEnable = true;
 341       // soState.rasterizerDisable set on state dirty
 342       // soState.streamToRasterizer not used
 343
 344       for (uint32_t i = 0; i < stream_output->num_outputs; i++) {
 345          swr_vs->soState.streamMasks[stream_output->output[i].stream] |=
 346             1 << (stream_output->output[i].register_index - 1);
 347       }
 348       for (uint32_t i = 0; i < MAX_SO_STREAMS; i++) {
 349         swr_vs->soState.streamNumEntries[i] =
 350              _mm_popcnt_u32(swr_vs->soState.streamMasks[i]);
 351        }
 352    }
 353
 354    return swr_vs;
 355 }
 356
 357 static void
 358 swr_bind_vs_state(struct pipe_context *pipe, void *vs)
 359 {
 360    struct swr_context *ctx = swr_context(pipe);
 361
 362    if (ctx->vs == vs)
 363       return;
 364
 365    ctx->vs = (swr_vertex_shader *)vs;
 366    ctx->dirty |= SWR_NEW_VS;
 367 }
 368
 369 static void
 370 swr_delete_vs_state(struct pipe_context *pipe, void *vs)
 371 {
 372    struct swr_vertex_shader *swr_vs = (swr_vertex_shader *)vs;
 373    FREE((void *)swr_vs->pipe.tokens);
 374    struct swr_screen *screen = swr_screen(pipe->screen);
 375    if (!swr_is_fence_pending(screen->flush_fence))
 376       swr_fence_submit(swr_context(pipe), screen->flush_fence);
 377    swr_fence_finish(pipe->screen, NULL, screen->flush_fence, 0);
 378    delete swr_vs;
 379 }
 380
 381 static void *
 382 swr_create_fs_state(struct pipe_context *pipe,
 383                     const struct pipe_shader_state *fs)
 384 {
 385    struct swr_fragment_shader *swr_fs = new swr_fragment_shader;
 386    if (!swr_fs)
 387       return NULL;
 388
 389    swr_fs->pipe.tokens = tgsi_dup_tokens(fs->tokens);
 390
 391    lp_build_tgsi_info(fs->tokens, &swr_fs->info);
 392
 393    return swr_fs;
 394 }
 395
 396
 397 static void
 398 swr_bind_fs_state(struct pipe_context *pipe, void *fs)
 399 {
 400    struct swr_context *ctx = swr_context(pipe);
 401
 402    if (ctx->fs == fs)
 403       return;
 404
 405    ctx->fs = (swr_fragment_shader *)fs;
 406    ctx->dirty |= SWR_NEW_FS;
 407 }
 408
 409 static void
 410 swr_delete_fs_state(struct pipe_context *pipe, void *fs)
 411 {
 412    struct swr_fragment_shader *swr_fs = (swr_fragment_shader *)fs;
 413    FREE((void *)swr_fs->pipe.tokens);
 414    struct swr_screen *screen = swr_screen(pipe->screen);
 415    if (!swr_is_fence_pending(screen->flush_fence))
 416       swr_fence_submit(swr_context(pipe), screen->flush_fence);
 417    swr_fence_finish(pipe->screen, NULL, screen->flush_fence, 0);
 418    delete swr_fs;
 419 }
 420
 421
 422 static void
 423 swr_set_constant_buffer(struct pipe_context *pipe,
 424                         uint shader,
 425                         uint index,
 426                         const struct pipe_constant_buffer *cb)
 427 {
 428    struct swr_context *ctx = swr_context(pipe);
 429    struct pipe_resource *constants = cb ? cb->buffer : NULL;
 430
 431    assert(shader < PIPE_SHADER_TYPES);
 432    assert(index < ARRAY_SIZE(ctx->constants[shader]));
 433
 434    /* note: reference counting */
 435    util_copy_constant_buffer(&ctx->constants[shader][index], cb);
 436
 437    if (shader == PIPE_SHADER_VERTEX || shader == PIPE_SHADER_GEOMETRY) {
 438       ctx->dirty |= SWR_NEW_VSCONSTANTS;
 439    } else if (shader == PIPE_SHADER_FRAGMENT) {
 440       ctx->dirty |= SWR_NEW_FSCONSTANTS;
 441    }
 442
 443    if (cb && cb->user_buffer) {
 444       pipe_resource_reference(&constants, NULL);
 445    }
 446 }
 447
 448
 449 static void *
 450 swr_create_vertex_elements_state(struct pipe_context *pipe,
 451                                  unsigned num_elements,
 452                                  const struct pipe_vertex_element *attribs)
 453 {
 454    struct swr_vertex_element_state *velems;
 455    assert(num_elements <= PIPE_MAX_ATTRIBS);
 456    velems = CALLOC_STRUCT(swr_vertex_element_state);
 457    if (velems) {
 458       velems->fsState.bVertexIDOffsetEnable = true;
 459       velems->fsState.numAttribs = num_elements;
 460       for (unsigned i = 0; i < num_elements; i++) {
 461          // XXX: we should do this keyed on the VS usage info
 462
 463          const struct util_format_description *desc =
 464             util_format_description(attribs[i].src_format);
 465
 466          velems->fsState.layout[i].AlignedByteOffset = attribs[i].src_offset;
 467          velems->fsState.layout[i].Format =
 468             mesa_to_swr_format(attribs[i].src_format);
 469          velems->fsState.layout[i].StreamIndex =
 470             attribs[i].vertex_buffer_index;
 471          velems->fsState.layout[i].InstanceEnable =
 472             attribs[i].instance_divisor != 0;
 473          velems->fsState.layout[i].ComponentControl0 =
 474             desc->channel[0].type != UTIL_FORMAT_TYPE_VOID
 475             ? ComponentControl::StoreSrc
 476             : ComponentControl::Store0;
 477          velems->fsState.layout[i].ComponentControl1 =
 478             desc->channel[1].type != UTIL_FORMAT_TYPE_VOID
 479             ? ComponentControl::StoreSrc
 480             : ComponentControl::Store0;
 481          velems->fsState.layout[i].ComponentControl2 =
 482             desc->channel[2].type != UTIL_FORMAT_TYPE_VOID
 483             ? ComponentControl::StoreSrc
 484             : ComponentControl::Store0;
 485          velems->fsState.layout[i].ComponentControl3 =
 486             desc->channel[3].type != UTIL_FORMAT_TYPE_VOID
 487             ? ComponentControl::StoreSrc
 488             : ComponentControl::Store1Fp;
 489          velems->fsState.layout[i].ComponentPacking = ComponentEnable::XYZW;
 490          velems->fsState.layout[i].InstanceDataStepRate =
 491             attribs[i].instance_divisor;
 492
 493          /* Calculate the pitch of each stream */
 494          const SWR_FORMAT_INFO &swr_desc = GetFormatInfo(
 495             mesa_to_swr_format(attribs[i].src_format));
 496          velems->stream_pitch[attribs[i].vertex_buffer_index] += swr_desc.Bpp;
 497       }
 498    }
 499
 500    return velems;
 501 }
 502
 503 static void
 504 swr_bind_vertex_elements_state(struct pipe_context *pipe, void *velems)
 505 {
 506    struct swr_context *ctx = swr_context(pipe);
 507    struct swr_vertex_element_state *swr_velems =
 508       (struct swr_vertex_element_state *)velems;
 509
 510    ctx->velems = swr_velems;
 511    ctx->dirty |= SWR_NEW_VERTEX;
 512 }
 513
 514 static void
 515 swr_delete_vertex_elements_state(struct pipe_context *pipe, void *velems)
 516 {
 517    /* XXX Need to destroy fetch shader? */
 518    FREE(velems);
 519 }
 520
 521
 522 static void
 523 swr_set_vertex_buffers(struct pipe_context *pipe,
 524                        unsigned start_slot,
 525                        unsigned num_elements,
 526                        const struct pipe_vertex_buffer *buffers)
 527 {
 528    struct swr_context *ctx = swr_context(pipe);
 529
 530    assert(num_elements <= PIPE_MAX_ATTRIBS);
 531
 532    util_set_vertex_buffers_count(ctx->vertex_buffer,
 533                                  &ctx->num_vertex_buffers,
 534                                  buffers,
 535                                  start_slot,
 536                                  num_elements);
 537
 538    ctx->dirty |= SWR_NEW_VERTEX;
 539 }
 540
 541
 542 static void
 543 swr_set_index_buffer(struct pipe_context *pipe,
 544                      const struct pipe_index_buffer *ib)
 545 {
 546    struct swr_context *ctx = swr_context(pipe);
 547
 548    if (ib)
 549       memcpy(&ctx->index_buffer, ib, sizeof(ctx->index_buffer));
 550    else
 551       memset(&ctx->index_buffer, 0, sizeof(ctx->index_buffer));
 552
 553    ctx->dirty |= SWR_NEW_VERTEX;
 554 }
 555
 556 static void
 557 swr_set_polygon_stipple(struct pipe_context *pipe,
 558                         const struct pipe_poly_stipple *stipple)
 559 {
 560    struct swr_context *ctx = swr_context(pipe);
 561
 562    ctx->poly_stipple = *stipple; /* struct copy */
 563    ctx->dirty |= SWR_NEW_STIPPLE;
 564 }
 565
 566 static void
 567 swr_set_clip_state(struct pipe_context *pipe,
 568                    const struct pipe_clip_state *clip)
 569 {
 570    struct swr_context *ctx = swr_context(pipe);
 571
 572    ctx->clip = *clip;
 573    /* XXX Unimplemented, but prevents crash */
 574
 575    ctx->dirty |= SWR_NEW_CLIP;
 576 }
 577
 578
 579 static void
 580 swr_set_scissor_states(struct pipe_context *pipe,
 581                        unsigned start_slot,
 582                        unsigned num_viewports,
 583                        const struct pipe_scissor_state *scissor)
 584 {
 585    struct swr_context *ctx = swr_context(pipe);
 586
 587    ctx->scissor = *scissor;
 588    ctx->swr_scissor.xmin = scissor->minx;
 589    ctx->swr_scissor.xmax = scissor->maxx;
 590    ctx->swr_scissor.ymin = scissor->miny;
 591    ctx->swr_scissor.ymax = scissor->maxy;
 592    ctx->dirty |= SWR_NEW_SCISSOR;
 593 }
 594
 595 static void
 596 swr_set_viewport_states(struct pipe_context *pipe,
 597                         unsigned start_slot,
 598                         unsigned num_viewports,
 599                         const struct pipe_viewport_state *vpt)
 600 {
 601    struct swr_context *ctx = swr_context(pipe);
 602
 603    ctx->viewport = *vpt;
 604    ctx->dirty |= SWR_NEW_VIEWPORT;
 605 }
 606
 607
 608 static void
 609 swr_set_framebuffer_state(struct pipe_context *pipe,
 610                           const struct pipe_framebuffer_state *fb)
 611 {
 612    struct swr_context *ctx = swr_context(pipe);
 613
 614    boolean changed = !util_framebuffer_state_equal(&ctx->framebuffer, fb);
 615
 616    assert(fb->width <= KNOB_GUARDBAND_WIDTH);
 617    assert(fb->height <= KNOB_GUARDBAND_HEIGHT);
 618
 619    if (changed) {
 620       unsigned i;
 621       for (i = 0; i < fb->nr_cbufs; ++i)
 622          pipe_surface_reference(&ctx->framebuffer.cbufs[i], fb->cbufs[i]);
 623       for (; i < ctx->framebuffer.nr_cbufs; ++i)
 624          pipe_surface_reference(&ctx->framebuffer.cbufs[i], NULL);
 625
 626       ctx->framebuffer.nr_cbufs = fb->nr_cbufs;
 627
 628       ctx->framebuffer.width = fb->width;
 629       ctx->framebuffer.height = fb->height;
 630
 631       pipe_surface_reference(&ctx->framebuffer.zsbuf, fb->zsbuf);
 632
 633       ctx->dirty |= SWR_NEW_FRAMEBUFFER;
 634    }
 635 }
 636
 637
 638 static void
 639 swr_set_sample_mask(struct pipe_context *pipe, unsigned sample_mask)
 640 {
 641    struct swr_context *ctx = swr_context(pipe);
 642
 643    if (sample_mask != ctx->sample_mask) {
 644       ctx->sample_mask = sample_mask;
 645       ctx->dirty |= SWR_NEW_RASTERIZER;
 646    }
 647 }
 648
 649 /*
 650  * Update resource in-use status
 651  * All resources bound to color or depth targets marked as WRITE resources.
 652  * VBO Vertex/index buffers and texture views marked as READ resources.
 653  */
 654 void
 655 swr_update_resource_status(struct pipe_context *pipe,
 656                            const struct pipe_draw_info *p_draw_info)
 657 {
 658    struct swr_context *ctx = swr_context(pipe);
 659    struct pipe_framebuffer_state *fb = &ctx->framebuffer;
 660
 661    /* colorbuffer targets */
 662    if (fb->nr_cbufs)
 663       for (uint32_t i = 0; i < fb->nr_cbufs; ++i)
 664          if (fb->cbufs[i])
 665             swr_resource_write(fb->cbufs[i]->texture);
 666
 667    /* depth/stencil target */
 668    if (fb->zsbuf)
 669       swr_resource_write(fb->zsbuf->texture);
 670
 671    /* VBO vertex buffers */
 672    for (uint32_t i = 0; i < ctx->num_vertex_buffers; i++) {
 673       struct pipe_vertex_buffer *vb = &ctx->vertex_buffer[i];
 674       if (!vb->user_buffer)
 675          swr_resource_read(vb->buffer);
 676    }
 677
 678    /* VBO index buffer */
 679    if (p_draw_info && p_draw_info->indexed) {
 680       struct pipe_index_buffer *ib = &ctx->index_buffer;
 681       if (!ib->user_buffer)
 682          swr_resource_read(ib->buffer);
 683    }
 684
 685    /* transform feedback buffers */
 686    for (uint32_t i = 0; i < ctx->num_so_targets; i++) {
 687       struct pipe_stream_output_target *target = ctx->so_targets[i];
 688       if (target && target->buffer)
 689          swr_resource_write(target->buffer);
 690    }
 691
 692    /* texture sampler views */
 693    for (uint32_t j : {PIPE_SHADER_VERTEX, PIPE_SHADER_FRAGMENT}) {
 694       for (uint32_t i = 0; i < ctx->num_sampler_views[j]; i++) {
 695          struct pipe_sampler_view *view = ctx->sampler_views[j][i];
 696          if (view)
 697             swr_resource_read(view->texture);
 698       }
 699    }
 700
 701    /* constant buffers */
 702    for (uint32_t j : {PIPE_SHADER_VERTEX, PIPE_SHADER_FRAGMENT}) {
 703       for (uint32_t i = 0; i < PIPE_MAX_CONSTANT_BUFFERS; i++) {
 704          struct pipe_constant_buffer *cb = &ctx->constants[j][i];
 705          if (cb->buffer)
 706             swr_resource_read(cb->buffer);
 707       }
 708    }
 709 }
 710
 711 static void
 712 swr_update_texture_state(struct swr_context *ctx,
 713                          unsigned shader_type,
 714                          unsigned num_sampler_views,
 715                          swr_jit_texture *textures)
 716 {
 717    for (unsigned i = 0; i < num_sampler_views; i++) {
 718       struct pipe_sampler_view *view =
 719          ctx->sampler_views[shader_type][i];
 720
 721       if (view) {
 722          struct pipe_resource *res = view->texture;
 723          struct swr_resource *swr_res = swr_resource(res);
 724          struct swr_jit_texture *jit_tex = &textures[i];
 725          memset(jit_tex, 0, sizeof(*jit_tex));
 726          jit_tex->width = res->width0;
 727          jit_tex->height = res->height0;
 728          jit_tex->depth = res->depth0;
 729          jit_tex->first_level = view->u.tex.first_level;
 730          jit_tex->last_level = view->u.tex.last_level;
 731          jit_tex->base_ptr = swr_res->swr.pBaseAddress;
 732
 733          for (unsigned level = jit_tex->first_level;
 734               level <= jit_tex->last_level;
 735               level++) {
 736             jit_tex->row_stride[level] = swr_res->row_stride[level];
 737             jit_tex->img_stride[level] = swr_res->img_stride[level];
 738             jit_tex->mip_offsets[level] = swr_res->mip_offsets[level];
 739          }
 740       }
 741    }
 742 }
 743
 744 static void
 745 swr_update_sampler_state(struct swr_context *ctx,
 746                          unsigned shader_type,
 747                          unsigned num_samplers,
 748                          swr_jit_sampler *samplers)
 749 {
 750    for (unsigned i = 0; i < num_samplers; i++) {
 751       const struct pipe_sampler_state *sampler =
 752          ctx->samplers[shader_type][i];
 753
 754       if (sampler) {
 755          samplers[i].min_lod = sampler->min_lod;
 756          samplers[i].max_lod = sampler->max_lod;
 757          samplers[i].lod_bias = sampler->lod_bias;
 758          COPY_4V(samplers[i].border_color, sampler->border_color.f);
 759       }
 760    }
 761 }
 762
 763 static void
 764 swr_update_constants(struct swr_context *ctx, enum pipe_shader_type shaderType)
 765 {
 766    swr_draw_context *pDC = &ctx->swrDC;
 767
 768    const float **constant;
 769    uint32_t *num_constants;
 770    struct swr_scratch_space *scratch;
 771
 772    switch (shaderType) {
 773    case PIPE_SHADER_VERTEX:
 774       constant = pDC->constantVS;
 775       num_constants = pDC->num_constantsVS;
 776       scratch = &ctx->scratch->vs_constants;
 777       break;
 778    case PIPE_SHADER_FRAGMENT:
 779       constant = pDC->constantFS;
 780       num_constants = pDC->num_constantsFS;
 781       scratch = &ctx->scratch->fs_constants;
 782       break;
 783    default:
 784       debug_printf("Unsupported shader type constants\n");
 785       return;
 786    }
 787
 788    for (UINT i = 0; i < PIPE_MAX_CONSTANT_BUFFERS; i++) {
 789       const pipe_constant_buffer *cb = &ctx->constants[shaderType][i];
 790       num_constants[i] = cb->buffer_size;
 791       if (cb->buffer) {
 792          constant[i] =
 793             (const float *)(swr_resource_data(cb->buffer) +
 794                             cb->buffer_offset);
 795       } else {
 796          /* Need to copy these constants to scratch space */
 797          if (cb->user_buffer && cb->buffer_size) {
 798             const void *ptr =
 799                ((const uint8_t *)cb->user_buffer + cb->buffer_offset);
 800             uint32_t size = AlignUp(cb->buffer_size, 4);
 801             ptr = swr_copy_to_scratch_space(ctx, scratch, ptr, size);
 802             constant[i] = (const float *)ptr;
 803          }
 804       }
 805    }
 806 }
 807
 808 void
 809 swr_update_derived(struct pipe_context *pipe,
 810                    const struct pipe_draw_info *p_draw_info)
 811 {
 812    struct swr_context *ctx = swr_context(pipe);
 813    struct swr_screen *screen = swr_screen(ctx->pipe.screen);
 814
 815    /* Update screen->pipe to current pipe context. */
 816    if (screen->pipe != pipe)
 817       screen->pipe = pipe;
 818
 819    /* Any state that requires dirty flags to be re-triggered sets this mask */
 820    /* For example, user_buffer vertex and index buffers. */
 821    unsigned post_update_dirty_flags = 0;
 822
 823    /* Render Targets */
 824    if (ctx->dirty & SWR_NEW_FRAMEBUFFER) {
 825       struct pipe_framebuffer_state *fb = &ctx->framebuffer;
 826       SWR_SURFACE_STATE *new_attachment[SWR_NUM_ATTACHMENTS] = {0};
 827       UINT i;
 828
 829       /* colorbuffer targets */
 830       if (fb->nr_cbufs)
 831          for (i = 0; i < fb->nr_cbufs; ++i)
 832             if (fb->cbufs[i]) {
 833                struct swr_resource *colorBuffer =
 834                   swr_resource(fb->cbufs[i]->texture);
 835                new_attachment[SWR_ATTACHMENT_COLOR0 + i] = &colorBuffer->swr;
 836             }
 837
 838       /* depth/stencil target */
 839       if (fb->zsbuf) {
 840          struct swr_resource *depthStencilBuffer =
 841             swr_resource(fb->zsbuf->texture);
 842          if (depthStencilBuffer->has_depth) {
 843             new_attachment[SWR_ATTACHMENT_DEPTH] = &depthStencilBuffer->swr;
 844
 845             if (depthStencilBuffer->has_stencil)
 846                new_attachment[SWR_ATTACHMENT_STENCIL] =
 847                   &depthStencilBuffer->secondary;
 848
 849          } else if (depthStencilBuffer->has_stencil)
 850             new_attachment[SWR_ATTACHMENT_STENCIL] = &depthStencilBuffer->swr;
 851       }
 852
 853       /* Make the attachment updates */
 854       swr_draw_context *pDC = &ctx->swrDC;
 855       SWR_SURFACE_STATE *renderTargets = pDC->renderTargets;
 856       unsigned need_fence = FALSE;
 857       for (i = 0; i < SWR_NUM_ATTACHMENTS; i++) {
 858          void *new_base = nullptr;
 859          if (new_attachment[i])
 860             new_base = new_attachment[i]->pBaseAddress;
 861
 862          /* StoreTile for changed target */
 863          if (renderTargets[i].pBaseAddress != new_base) {
 864             if (renderTargets[i].pBaseAddress) {
 865                /* If changing attachment to a new target, mark tiles as
 866                 * INVALID so they are reloaded from surface.
 867                 * If detaching attachment, mark tiles as RESOLVED so core
 868                 * won't try to load from non-existent target. */
 869                enum SWR_TILE_STATE post_state = (new_attachment[i]
 870                   ? SWR_TILE_INVALID : SWR_TILE_RESOLVED);
 871                swr_store_render_target(pipe, i, post_state);
 872
 873                need_fence |= TRUE;
 874             }
 875
 876             /* Make new attachment */
 877             if (new_attachment[i])
 878                renderTargets[i] = *new_attachment[i];
 879             else
 880                if (renderTargets[i].pBaseAddress)
 881                   renderTargets[i] = {0};
 882          }
 883       }
 884
 885       /* This fence ensures any attachment changes are resolved before the
 886        * next draw */
 887       if (need_fence)
 888          swr_fence_submit(ctx, screen->flush_fence);
 889    }
 890
 891    /* Raster state */
 892    if (ctx->dirty & (SWR_NEW_RASTERIZER |
 893                      SWR_NEW_VS | // clipping
 894                      SWR_NEW_FRAMEBUFFER)) {
 895       pipe_rasterizer_state *rasterizer = ctx->rasterizer;
 896       pipe_framebuffer_state *fb = &ctx->framebuffer;
 897
 898       SWR_RASTSTATE *rastState = &ctx->derived.rastState;
 899       rastState->cullMode = swr_convert_cull_mode(rasterizer->cull_face);
 900       rastState->frontWinding = rasterizer->front_ccw
 901          ? SWR_FRONTWINDING_CCW
 902          : SWR_FRONTWINDING_CW;
 903       rastState->scissorEnable = rasterizer->scissor;
 904       rastState->pointSize = rasterizer->point_size > 0.0f
 905          ? rasterizer->point_size
 906          : 1.0f;
 907       rastState->lineWidth = rasterizer->line_width > 0.0f
 908          ? rasterizer->line_width
 909          : 1.0f;
 910
 911       rastState->pointParam = rasterizer->point_size_per_vertex;
 912
 913       rastState->pointSpriteEnable = rasterizer->sprite_coord_enable;
 914       rastState->pointSpriteTopOrigin =
 915          rasterizer->sprite_coord_mode == PIPE_SPRITE_COORD_UPPER_LEFT;
 916
 917       /* XXX TODO: Add multisample */
 918       rastState->msaaRastEnable = false;
 919       rastState->rastMode = SWR_MSAA_RASTMODE_OFF_PIXEL;
 920       rastState->sampleCount = SWR_MULTISAMPLE_1X;
 921       rastState->forcedSampleCount = false;
 922
 923       bool do_offset = false;
 924       switch (rasterizer->fill_front) {
 925       case PIPE_POLYGON_MODE_FILL:
 926          do_offset = rasterizer->offset_tri;
 927          break;
 928       case PIPE_POLYGON_MODE_LINE:
 929          do_offset = rasterizer->offset_line;
 930          break;
 931       case PIPE_POLYGON_MODE_POINT:
 932          do_offset = rasterizer->offset_point;
 933          break;
 934       }
 935
 936       if (do_offset) {
 937          rastState->depthBias = rasterizer->offset_units;
 938          rastState->slopeScaledDepthBias = rasterizer->offset_scale;
 939          rastState->depthBiasClamp = rasterizer->offset_clamp;
 940       } else {
 941          rastState->depthBias = 0;
 942          rastState->slopeScaledDepthBias = 0;
 943          rastState->depthBiasClamp = 0;
 944       }
 945       struct pipe_surface *zb = fb->zsbuf;
 946       if (zb && swr_resource(zb->texture)->has_depth)
 947          rastState->depthFormat = swr_resource(zb->texture)->swr.format;
 948
 949       rastState->depthClipEnable = rasterizer->depth_clip;
 950       rastState->clipHalfZ = rasterizer->clip_halfz;
 951
 952       rastState->clipDistanceMask =
 953          ctx->vs->info.base.num_written_clipdistance ?
 954          ctx->vs->info.base.clipdist_writemask & rasterizer->clip_plane_enable :
 955          rasterizer->clip_plane_enable;
 956
 957       rastState->cullDistanceMask =
 958          ctx->vs->info.base.culldist_writemask << ctx->vs->info.base.num_written_clipdistance;
 959
 960       SwrSetRastState(ctx->swrContext, rastState);
 961    }
 962
 963    /* Scissor */
 964    if (ctx->dirty & SWR_NEW_SCISSOR) {
 965       SwrSetScissorRects(ctx->swrContext, 1, &ctx->swr_scissor);
 966    }
 967
 968    /* Viewport */
 969    if (ctx->dirty & (SWR_NEW_VIEWPORT | SWR_NEW_FRAMEBUFFER
 970                      | SWR_NEW_RASTERIZER)) {
 971       pipe_viewport_state *state = &ctx->viewport;
 972       pipe_framebuffer_state *fb = &ctx->framebuffer;
 973       pipe_rasterizer_state *rasterizer = ctx->rasterizer;
 974
 975       SWR_VIEWPORT *vp = &ctx->derived.vp;
 976       SWR_VIEWPORT_MATRICES *vpm = &ctx->derived.vpm;
 977
 978       vp->x = state->translate[0] - state->scale[0];
 979       vp->width = state->translate[0] + state->scale[0];
 980       vp->y = state->translate[1] - fabs(state->scale[1]);
 981       vp->height = state->translate[1] + fabs(state->scale[1]);
 982       util_viewport_zmin_zmax(state, rasterizer->clip_halfz,
 983                               &vp->minZ, &vp->maxZ);
 984
 985       vpm->m00[0] = state->scale[0];
 986       vpm->m11[0] = state->scale[1];
 987       vpm->m22[0] = state->scale[2];
 988       vpm->m30[0] = state->translate[0];
 989       vpm->m31[0] = state->translate[1];
 990       vpm->m32[0] = state->translate[2];
 991
 992       /* Now that the matrix is calculated, clip the view coords to screen
 993        * size.  OpenGL allows for -ve x,y in the viewport. */
 994       vp->x = std::max(vp->x, 0.0f);
 995       vp->y = std::max(vp->y, 0.0f);
 996       vp->width = std::min(vp->width, (float)fb->width);
 997       vp->height = std::min(vp->height, (float)fb->height);
 998
 999       SwrSetViewports(ctx->swrContext, 1, vp, vpm);
1000    }
1001
1002    /* Set vertex & index buffers */
1003    /* (using draw info if called by swr_draw_vbo) */
1004    if (ctx->dirty & SWR_NEW_VERTEX) {
1005       uint32_t size, pitch, max_vertex, partial_inbounds, scratch_total;
1006       const uint8_t *p_data;
1007       uint8_t *scratch = NULL;
1008
1009       /* If being called by swr_draw_vbo, copy draw details */
1010       struct pipe_draw_info info = {0};
1011       if (p_draw_info)
1012          info = *p_draw_info;
1013
1014       /* We must get all the scratch space in one go */
1015       scratch_total = 0;
1016       for (UINT i = 0; i < ctx->num_vertex_buffers; i++) {
1017          struct pipe_vertex_buffer *vb = &ctx->vertex_buffer[i];
1018
1019          if (!vb->user_buffer)
1020             continue;
1021
1022          if (vb->stride) {
1023             size = (info.max_index - info.min_index + 1) * vb->stride;
1024          } else {
1025             /* pitch = 0, means constant value
1026              * set size to 1 vertex */
1027             size = ctx->velems->stream_pitch[i];
1028          }
1029
1030          scratch_total += AlignUp(size, 4);
1031       }
1032
1033       if (scratch_total) {
1034          scratch = (uint8_t *)swr_copy_to_scratch_space(
1035                ctx, &ctx->scratch->vertex_buffer, NULL, scratch_total);
1036       }
1037
1038       /* vertex buffers */
1039       SWR_VERTEX_BUFFER_STATE swrVertexBuffers[PIPE_MAX_ATTRIBS];
1040       for (UINT i = 0; i < ctx->num_vertex_buffers; i++) {
1041          struct pipe_vertex_buffer *vb = &ctx->vertex_buffer[i];
1042
1043          pitch = vb->stride;
1044          if (!vb->user_buffer) {
1045             /* VBO
1046              * size is based on buffer->width0 rather than info.max_index
1047              * to prevent having to validate VBO on each draw */
1048             size = vb->buffer->width0;
1049             max_vertex = size / pitch;
1050             partial_inbounds = size % pitch;
1051
1052             p_data = swr_resource_data(vb->buffer) + vb->buffer_offset;
1053          } else {
1054             /* Client buffer
1055              * client memory is one-time use, re-trigger SWR_NEW_VERTEX to
1056              * revalidate on each draw */
1057             post_update_dirty_flags |= SWR_NEW_VERTEX;
1058
1059             if (pitch) {
1060                size = (info.max_index - info.min_index + 1) * pitch;
1061             } else {
1062                /* pitch = 0, means constant value
1063                 * set size to 1 vertex */
1064                size = ctx->velems->stream_pitch[i];
1065             }
1066
1067             max_vertex = info.max_index + 1;
1068             partial_inbounds = 0;
1069
1070             /* Copy only needed vertices to scratch space */
1071             size = AlignUp(size, 4);
1072             const void *ptr = (const uint8_t *) vb->user_buffer
1073                + info.min_index * pitch;
1074             memcpy(scratch, ptr, size);
1075             ptr = scratch;
1076             scratch += size;
1077             p_data = (const uint8_t *)ptr - info.min_index * pitch;
1078          }
1079
1080          swrVertexBuffers[i] = {0};
1081          swrVertexBuffers[i].index = i;
1082          swrVertexBuffers[i].pitch = pitch;
1083          swrVertexBuffers[i].pData = p_data;
1084          swrVertexBuffers[i].size = size;
1085          swrVertexBuffers[i].maxVertex = max_vertex;
1086          swrVertexBuffers[i].partialInboundsSize = partial_inbounds;
1087       }
1088
1089       SwrSetVertexBuffers(
1090          ctx->swrContext, ctx->num_vertex_buffers, swrVertexBuffers);
1091
1092       /* index buffer, if required (info passed in by swr_draw_vbo) */
1093       SWR_FORMAT index_type = R32_UINT; /* Default for non-indexed draws */
1094       if (info.indexed) {
1095          struct pipe_index_buffer *ib = &ctx->index_buffer;
1096
1097          pitch = ib->index_size ? ib->index_size : sizeof(uint32_t);
1098          index_type = swr_convert_index_type(pitch);
1099
1100          if (!ib->user_buffer) {
1101             /* VBO
1102              * size is based on buffer->width0 rather than info.count
1103              * to prevent having to validate VBO on each draw */
1104             size = ib->buffer->width0;
1105             p_data = swr_resource_data(ib->buffer) + ib->offset;
1106          } else {
1107             /* Client buffer
1108              * client memory is one-time use, re-trigger SWR_NEW_VERTEX to
1109              * revalidate on each draw */
1110             post_update_dirty_flags |= SWR_NEW_VERTEX;
1111
1112             size = info.count * pitch;
1113             size = AlignUp(size, 4);
1114
1115             /* Copy indices to scratch space */
1116             const void *ptr = ib->user_buffer;
1117             ptr = swr_copy_to_scratch_space(
1118                ctx, &ctx->scratch->index_buffer, ptr, size);
1119             p_data = (const uint8_t *)ptr;
1120          }
1121
1122          SWR_INDEX_BUFFER_STATE swrIndexBuffer;
1123          swrIndexBuffer.format = swr_convert_index_type(ib->index_size);
1124          swrIndexBuffer.pIndices = p_data;
1125          swrIndexBuffer.size = size;
1126
1127          SwrSetIndexBuffer(ctx->swrContext, &swrIndexBuffer);
1128       }
1129
1130       struct swr_vertex_element_state *velems = ctx->velems;
1131       if (velems && velems->fsState.indexType != index_type) {
1132          velems->fsFunc = NULL;
1133          velems->fsState.indexType = index_type;
1134       }
1135    }
1136
1137    /* VertexShader */
1138    if (ctx->dirty & (SWR_NEW_VS |
1139                      SWR_NEW_RASTERIZER | // for clip planes
1140                      SWR_NEW_SAMPLER |
1141                      SWR_NEW_SAMPLER_VIEW |
1142                      SWR_NEW_FRAMEBUFFER)) {
1143       swr_jit_vs_key key;
1144       swr_generate_vs_key(key, ctx, ctx->vs);
1145       auto search = ctx->vs->map.find(key);
1146       PFN_VERTEX_FUNC func;
1147       if (search != ctx->vs->map.end()) {
1148          func = search->second->shader;
1149       } else {
1150          func = swr_compile_vs(ctx, key);
1151       }
1152       SwrSetVertexFunc(ctx->swrContext, func);
1153
1154       /* JIT sampler state */
1155       if (ctx->dirty & SWR_NEW_SAMPLER) {
1156          swr_update_sampler_state(ctx,
1157                                   PIPE_SHADER_VERTEX,
1158                                   key.nr_samplers,
1159                                   ctx->swrDC.samplersVS);
1160       }
1161
1162       /* JIT sampler view state */
1163       if (ctx->dirty & (SWR_NEW_SAMPLER_VIEW | SWR_NEW_FRAMEBUFFER)) {
1164          swr_update_texture_state(ctx,
1165                                   PIPE_SHADER_VERTEX,
1166                                   key.nr_sampler_views,
1167                                   ctx->swrDC.texturesVS);
1168       }
1169    }
1170
1171    /* FragmentShader */
1172    if (ctx->dirty & (SWR_NEW_FS | SWR_NEW_SAMPLER | SWR_NEW_SAMPLER_VIEW
1173                      | SWR_NEW_RASTERIZER | SWR_NEW_FRAMEBUFFER)) {
1174       swr_jit_fs_key key;
1175       swr_generate_fs_key(key, ctx, ctx->fs);
1176       auto search = ctx->fs->map.find(key);
1177       PFN_PIXEL_KERNEL func;
1178       if (search != ctx->fs->map.end()) {
1179          func = search->second->shader;
1180       } else {
1181          func = swr_compile_fs(ctx, key);
1182       }
1183       SWR_PS_STATE psState = {0};
1184       psState.pfnPixelShader = func;
1185       psState.killsPixel = ctx->fs->info.base.uses_kill;
1186       psState.inputCoverage = SWR_INPUT_COVERAGE_NORMAL;
1187       psState.writesODepth = ctx->fs->info.base.writes_z;
1188       psState.usesSourceDepth = ctx->fs->info.base.reads_z;
1189       psState.shadingRate = SWR_SHADING_RATE_PIXEL; // XXX
1190       psState.numRenderTargets = ctx->framebuffer.nr_cbufs;
1191       psState.posOffset = SWR_PS_POSITION_SAMPLE_NONE; // XXX msaa
1192       uint32_t barycentricsMask = 0;
1193 #if 0
1194       // when we switch to mesa-master
1195       if (ctx->fs->info.base.uses_persp_center ||
1196           ctx->fs->info.base.uses_linear_center)
1197          barycentricsMask |= SWR_BARYCENTRIC_PER_PIXEL_MASK;
1198       if (ctx->fs->info.base.uses_persp_centroid ||
1199           ctx->fs->info.base.uses_linear_centroid)
1200          barycentricsMask |= SWR_BARYCENTRIC_CENTROID_MASK;
1201       if (ctx->fs->info.base.uses_persp_sample ||
1202           ctx->fs->info.base.uses_linear_sample)
1203          barycentricsMask |= SWR_BARYCENTRIC_PER_SAMPLE_MASK;
1204 #else
1205       for (unsigned i = 0; i < ctx->fs->info.base.num_inputs; i++) {
1206          switch (ctx->fs->info.base.input_interpolate_loc[i]) {
1207          case TGSI_INTERPOLATE_LOC_CENTER:
1208             barycentricsMask |= SWR_BARYCENTRIC_PER_PIXEL_MASK;
1209             break;
1210          case TGSI_INTERPOLATE_LOC_CENTROID:
1211             barycentricsMask |= SWR_BARYCENTRIC_CENTROID_MASK;
1212             break;
1213          case TGSI_INTERPOLATE_LOC_SAMPLE:
1214             barycentricsMask |= SWR_BARYCENTRIC_PER_SAMPLE_MASK;
1215             break;
1216          }
1217       }
1218 #endif
1219       psState.barycentricsMask = barycentricsMask;
1220       psState.usesUAV = false; // XXX
1221       psState.forceEarlyZ = false;
1222       SwrSetPixelShaderState(ctx->swrContext, &psState);
1223
1224       /* JIT sampler state */
1225       if (ctx->dirty & SWR_NEW_SAMPLER) {
1226          swr_update_sampler_state(ctx,
1227                                   PIPE_SHADER_FRAGMENT,
1228                                   key.nr_samplers,
1229                                   ctx->swrDC.samplersFS);
1230       }
1231
1232       /* JIT sampler view state */
1233       if (ctx->dirty & (SWR_NEW_SAMPLER_VIEW | SWR_NEW_FRAMEBUFFER)) {
1234          swr_update_texture_state(ctx,
1235                                   PIPE_SHADER_FRAGMENT,
1236                                   key.nr_sampler_views,
1237                                   ctx->swrDC.texturesFS);
1238       }
1239    }
1240
1241
1242    /* VertexShader Constants */
1243    if (ctx->dirty & SWR_NEW_VSCONSTANTS) {
1244       swr_update_constants(ctx, PIPE_SHADER_VERTEX);
1245    }
1246
1247    /* FragmentShader Constants */
1248    if (ctx->dirty & SWR_NEW_FSCONSTANTS) {
1249       swr_update_constants(ctx, PIPE_SHADER_FRAGMENT);
1250    }
1251
1252    /* Depth/stencil state */
1253    if (ctx->dirty & (SWR_NEW_DEPTH_STENCIL_ALPHA | SWR_NEW_FRAMEBUFFER)) {
1254       struct pipe_depth_state *depth = &(ctx->depth_stencil->depth);
1255       struct pipe_stencil_state *stencil = ctx->depth_stencil->stencil;
1256       SWR_DEPTH_STENCIL_STATE depthStencilState = {{0}};
1257       SWR_DEPTH_BOUNDS_STATE depthBoundsState = {0};
1258
1259       /* XXX, incomplete.  Need to flesh out stencil & alpha test state
1260       struct pipe_stencil_state *front_stencil =
1261       ctx->depth_stencil.stencil[0];
1262       struct pipe_stencil_state *back_stencil = ctx->depth_stencil.stencil[1];
1263       struct pipe_alpha_state alpha;
1264       */
1265       if (stencil[0].enabled) {
1266          depthStencilState.stencilWriteEnable = 1;
1267          depthStencilState.stencilTestEnable = 1;
1268          depthStencilState.stencilTestFunc =
1269             swr_convert_depth_func(stencil[0].func);
1270
1271          depthStencilState.stencilPassDepthPassOp =
1272             swr_convert_stencil_op(stencil[0].zpass_op);
1273          depthStencilState.stencilPassDepthFailOp =
1274             swr_convert_stencil_op(stencil[0].zfail_op);
1275          depthStencilState.stencilFailOp =
1276             swr_convert_stencil_op(stencil[0].fail_op);
1277          depthStencilState.stencilWriteMask = stencil[0].writemask;
1278          depthStencilState.stencilTestMask = stencil[0].valuemask;
1279          depthStencilState.stencilRefValue = ctx->stencil_ref.ref_value[0];
1280       }
1281       if (stencil[1].enabled) {
1282          depthStencilState.doubleSidedStencilTestEnable = 1;
1283
1284          depthStencilState.backfaceStencilTestFunc =
1285             swr_convert_depth_func(stencil[1].func);
1286
1287          depthStencilState.backfaceStencilPassDepthPassOp =
1288             swr_convert_stencil_op(stencil[1].zpass_op);
1289          depthStencilState.backfaceStencilPassDepthFailOp =
1290             swr_convert_stencil_op(stencil[1].zfail_op);
1291          depthStencilState.backfaceStencilFailOp =
1292             swr_convert_stencil_op(stencil[1].fail_op);
1293          depthStencilState.backfaceStencilWriteMask = stencil[1].writemask;
1294          depthStencilState.backfaceStencilTestMask = stencil[1].valuemask;
1295
1296          depthStencilState.backfaceStencilRefValue =
1297             ctx->stencil_ref.ref_value[1];
1298       }
1299
1300       depthStencilState.depthTestEnable = depth->enabled;
1301       depthStencilState.depthTestFunc = swr_convert_depth_func(depth->func);
1302       depthStencilState.depthWriteEnable = depth->writemask;
1303       SwrSetDepthStencilState(ctx->swrContext, &depthStencilState);
1304
1305       depthBoundsState.depthBoundsTestEnable = depth->bounds_test;
1306       depthBoundsState.depthBoundsTestMinValue = depth->bounds_min;
1307       depthBoundsState.depthBoundsTestMaxValue = depth->bounds_max;
1308       SwrSetDepthBoundsState(ctx->swrContext, &depthBoundsState);
1309    }
1310
1311    /* Blend State */
1312    if (ctx->dirty & (SWR_NEW_BLEND |
1313                      SWR_NEW_FRAMEBUFFER |
1314                      SWR_NEW_DEPTH_STENCIL_ALPHA)) {
1315       struct pipe_framebuffer_state *fb = &ctx->framebuffer;
1316
1317       SWR_BLEND_STATE blendState;
1318       memcpy(&blendState, &ctx->blend->blendState, sizeof(blendState));
1319       blendState.constantColor[0] = ctx->blend_color.color[0];
1320       blendState.constantColor[1] = ctx->blend_color.color[1];
1321       blendState.constantColor[2] = ctx->blend_color.color[2];
1322       blendState.constantColor[3] = ctx->blend_color.color[3];
1323       blendState.alphaTestReference =
1324          *((uint32_t*)&ctx->depth_stencil->alpha.ref_value);
1325
1326       // XXX MSAA
1327       blendState.sampleMask = 0;
1328       blendState.sampleCount = SWR_MULTISAMPLE_1X;
1329
1330       /* If there are no color buffers bound, disable writes on RT0
1331        * and skip loop */
1332       if (fb->nr_cbufs == 0) {
1333          blendState.renderTarget[0].writeDisableRed = 1;
1334          blendState.renderTarget[0].writeDisableGreen = 1;
1335          blendState.renderTarget[0].writeDisableBlue = 1;
1336          blendState.renderTarget[0].writeDisableAlpha = 1;
1337          SwrSetBlendFunc(ctx->swrContext, 0, NULL);
1338       }
1339       else
1340          for (int target = 0;
1341                target < std::min(SWR_NUM_RENDERTARGETS,
1342                                  PIPE_MAX_COLOR_BUFS);
1343                target++) {
1344             if (!fb->cbufs[target])
1345                continue;
1346
1347             struct swr_resource *colorBuffer =
1348                swr_resource(fb->cbufs[target]->texture);
1349
1350             BLEND_COMPILE_STATE compileState;
1351             memset(&compileState, 0, sizeof(compileState));
1352             compileState.format = colorBuffer->swr.format;
1353             memcpy(&compileState.blendState,
1354                    &ctx->blend->compileState[target],
1355                    sizeof(compileState.blendState));
1356
1357             const SWR_FORMAT_INFO& info = GetFormatInfo(compileState.format);
1358             if (compileState.blendState.logicOpEnable &&
1359                 ((info.type[0] == SWR_TYPE_FLOAT) || info.isSRGB)) {
1360                compileState.blendState.logicOpEnable = false;
1361             }
1362
1363             if (info.type[0] == SWR_TYPE_SINT || info.type[0] == SWR_TYPE_UINT)
1364                compileState.blendState.blendEnable = false;
1365
1366             if (compileState.blendState.blendEnable == false &&
1367                 compileState.blendState.logicOpEnable == false &&
1368                 ctx->depth_stencil->alpha.enabled == 0) {
1369                SwrSetBlendFunc(ctx->swrContext, target, NULL);
1370                continue;
1371             }
1372
1373             compileState.desc.alphaTestEnable =
1374                ctx->depth_stencil->alpha.enabled;
1375             compileState.desc.independentAlphaBlendEnable =
1376                (compileState.blendState.sourceBlendFactor !=
1377                 compileState.blendState.sourceAlphaBlendFactor) ||
1378                (compileState.blendState.destBlendFactor !=
1379                 compileState.blendState.destAlphaBlendFactor) ||
1380                (compileState.blendState.colorBlendFunc !=
1381                 compileState.blendState.alphaBlendFunc);
1382             compileState.desc.alphaToCoverageEnable =
1383                ctx->blend->pipe.alpha_to_coverage;
1384             compileState.desc.sampleMaskEnable = 0; // XXX
1385             compileState.desc.numSamples = 1; // XXX
1386
1387             compileState.alphaTestFunction =
1388                swr_convert_depth_func(ctx->depth_stencil->alpha.func);
1389             compileState.alphaTestFormat = ALPHA_TEST_FLOAT32; // xxx
1390
1391             compileState.Canonicalize();
1392
1393             PFN_BLEND_JIT_FUNC func = NULL;
1394             auto search = ctx->blendJIT->find(compileState);
1395             if (search != ctx->blendJIT->end()) {
1396                func = search->second;
1397             } else {
1398                HANDLE hJitMgr = screen->hJitMgr;
1399                func = JitCompileBlend(hJitMgr, compileState);
1400                debug_printf("BLEND shader %p\n", func);
1401                assert(func && "Error: BlendShader = NULL");
1402
1403                ctx->blendJIT->insert(std::make_pair(compileState, func));
1404             }
1405             SwrSetBlendFunc(ctx->swrContext, target, func);
1406          }
1407
1408       SwrSetBlendState(ctx->swrContext, &blendState);
1409    }
1410
1411    if (ctx->dirty & SWR_NEW_STIPPLE) {
1412       /* XXX What to do with this one??? SWR doesn't stipple */
1413    }
1414
1415    if (ctx->dirty & (SWR_NEW_VS | SWR_NEW_SO | SWR_NEW_RASTERIZER)) {
1416       ctx->vs->soState.rasterizerDisable =
1417          ctx->rasterizer->rasterizer_discard;
1418       SwrSetSoState(ctx->swrContext, &ctx->vs->soState);
1419
1420       pipe_stream_output_info *stream_output = &ctx->vs->pipe.stream_output;
1421
1422       for (uint32_t i = 0; i < ctx->num_so_targets; i++) {
1423          SWR_STREAMOUT_BUFFER buffer = {0};
1424          if (!ctx->so_targets[i])
1425             continue;
1426          buffer.enable = true;
1427          buffer.pBuffer =
1428             (uint32_t *)swr_resource_data(ctx->so_targets[i]->buffer);
1429          buffer.bufferSize = ctx->so_targets[i]->buffer_size >> 2;
1430          buffer.pitch = stream_output->stride[i];
1431          buffer.streamOffset = ctx->so_targets[i]->buffer_offset >> 2;
1432
1433          SwrSetSoBuffers(ctx->swrContext, &buffer, i);
1434       }
1435    }
1436
1437    if (ctx->dirty & SWR_NEW_CLIP) {
1438       // shader exporting clip distances overrides all user clip planes
1439       if (ctx->rasterizer->clip_plane_enable &&
1440           !ctx->vs->info.base.num_written_clipdistance)
1441       {
1442          swr_draw_context *pDC = &ctx->swrDC;
1443          memcpy(pDC->userClipPlanes,
1444                 ctx->clip.ucp,
1445                 sizeof(pDC->userClipPlanes));
1446       }
1447    }
1448
1449    // set up backend state
1450    SWR_BACKEND_STATE backendState = {0};
1451    backendState.numAttributes =
1452       ctx->vs->info.base.num_outputs - 1 +
1453       (ctx->rasterizer->sprite_coord_enable ? 1 : 0);
1454    for (unsigned i = 0; i < backendState.numAttributes; i++)
1455       backendState.numComponents[i] = 4;
1456    backendState.constantInterpolationMask =
1457       ctx->rasterizer->flatshade ?
1458       ctx->fs->flatConstantMask :
1459       ctx->fs->constantMask;
1460    backendState.pointSpriteTexCoordMask = ctx->fs->pointSpriteMask;
1461
1462    SwrSetBackendState(ctx->swrContext, &backendState);
1463
1464    /* Ensure that any in-progress attachment change StoreTiles finish */
1465    if (swr_is_fence_pending(screen->flush_fence))
1466       swr_fence_finish(pipe->screen, NULL, screen->flush_fence, 0);
1467
1468    /* Finally, update the in-use status of all resources involved in draw */
1469    swr_update_resource_status(pipe, p_draw_info);
1470
1471    ctx->dirty = post_update_dirty_flags;
1472 }
1473
1474
1475 static struct pipe_stream_output_target *
1476 swr_create_so_target(struct pipe_context *pipe,
1477                      struct pipe_resource *buffer,
1478                      unsigned buffer_offset,
1479                      unsigned buffer_size)
1480 {
1481    struct pipe_stream_output_target *target;
1482
1483    target = CALLOC_STRUCT(pipe_stream_output_target);
1484    if (!target)
1485       return NULL;
1486
1487    target->context = pipe;
1488    target->reference.count = 1;
1489    pipe_resource_reference(&target->buffer, buffer);
1490    target->buffer_offset = buffer_offset;
1491    target->buffer_size = buffer_size;
1492    return target;
1493 }
1494
1495 static void
1496 swr_destroy_so_target(struct pipe_context *pipe,
1497                       struct pipe_stream_output_target *target)
1498 {
1499    pipe_resource_reference(&target->buffer, NULL);
1500    FREE(target);
1501 }
1502
1503 static void
1504 swr_set_so_targets(struct pipe_context *pipe,
1505                    unsigned num_targets,
1506                    struct pipe_stream_output_target **targets,
1507                    const unsigned *offsets)
1508 {
1509    struct swr_context *swr = swr_context(pipe);
1510    uint32_t i;
1511
1512    assert(num_targets < MAX_SO_STREAMS);
1513
1514    for (i = 0; i < num_targets; i++) {
1515       pipe_so_target_reference(
1516          (struct pipe_stream_output_target **)&swr->so_targets[i],
1517          targets[i]);
1518    }
1519
1520    for (/* fall-through */; i < swr->num_so_targets; i++) {
1521       pipe_so_target_reference(
1522          (struct pipe_stream_output_target **)&swr->so_targets[i], NULL);
1523    }
1524
1525    swr->num_so_targets = num_targets;
1526
1527    swr->dirty = SWR_NEW_SO;
1528 }
1529
1530
1531 void
1532 swr_state_init(struct pipe_context *pipe)
1533 {
1534    pipe->create_blend_state = swr_create_blend_state;
1535    pipe->bind_blend_state = swr_bind_blend_state;
1536    pipe->delete_blend_state = swr_delete_blend_state;
1537
1538    pipe->create_depth_stencil_alpha_state = swr_create_depth_stencil_state;
1539    pipe->bind_depth_stencil_alpha_state = swr_bind_depth_stencil_state;
1540    pipe->delete_depth_stencil_alpha_state = swr_delete_depth_stencil_state;
1541
1542    pipe->create_rasterizer_state = swr_create_rasterizer_state;
1543    pipe->bind_rasterizer_state = swr_bind_rasterizer_state;
1544    pipe->delete_rasterizer_state = swr_delete_rasterizer_state;
1545
1546    pipe->create_sampler_state = swr_create_sampler_state;
1547    pipe->bind_sampler_states = swr_bind_sampler_states;
1548    pipe->delete_sampler_state = swr_delete_sampler_state;
1549
1550    pipe->create_sampler_view = swr_create_sampler_view;
1551    pipe->set_sampler_views = swr_set_sampler_views;
1552    pipe->sampler_view_destroy = swr_sampler_view_destroy;
1553
1554    pipe->create_vs_state = swr_create_vs_state;
1555    pipe->bind_vs_state = swr_bind_vs_state;
1556    pipe->delete_vs_state = swr_delete_vs_state;
1557
1558    pipe->create_fs_state = swr_create_fs_state;
1559    pipe->bind_fs_state = swr_bind_fs_state;
1560    pipe->delete_fs_state = swr_delete_fs_state;
1561
1562    pipe->set_constant_buffer = swr_set_constant_buffer;
1563
1564    pipe->create_vertex_elements_state = swr_create_vertex_elements_state;
1565    pipe->bind_vertex_elements_state = swr_bind_vertex_elements_state;
1566    pipe->delete_vertex_elements_state = swr_delete_vertex_elements_state;
1567
1568    pipe->set_vertex_buffers = swr_set_vertex_buffers;
1569    pipe->set_index_buffer = swr_set_index_buffer;
1570
1571    pipe->set_polygon_stipple = swr_set_polygon_stipple;
1572    pipe->set_clip_state = swr_set_clip_state;
1573    pipe->set_scissor_states = swr_set_scissor_states;
1574    pipe->set_viewport_states = swr_set_viewport_states;
1575
1576    pipe->set_framebuffer_state = swr_set_framebuffer_state;
1577
1578    pipe->set_blend_color = swr_set_blend_color;
1579    pipe->set_stencil_ref = swr_set_stencil_ref;
1580
1581    pipe->set_sample_mask = swr_set_sample_mask;
1582
1583    pipe->create_stream_output_target = swr_create_so_target;
1584    pipe->stream_output_target_destroy = swr_destroy_so_target;
1585    pipe->set_stream_output_targets = swr_set_so_targets;
1586 }