src/gallium/drivers/galahad/glhd_context.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2009 VMware, Inc.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28
  29 #include "pipe/p_context.h"
  30
  31 #include "util/u_format.h"
  32 #include "util/u_memory.h"
  33 #include "util/u_inlines.h"
  34
  35 #include "glhd_context.h"
  36 #include "glhd_objects.h"
  37
  38
  39 static void
  40 galahad_destroy(struct pipe_context *_pipe)
  41 {
  42    struct galahad_context *glhd_pipe = galahad_context(_pipe);
  43    struct pipe_context *pipe = glhd_pipe->pipe;
  44
  45    pipe->destroy(pipe);
  46
  47    FREE(glhd_pipe);
  48 }
  49
  50 static void
  51 galahad_draw_vbo(struct pipe_context *_pipe,
  52                  const struct pipe_draw_info *info)
  53 {
  54    struct galahad_context *glhd_pipe = galahad_context(_pipe);
  55    struct pipe_context *pipe = glhd_pipe->pipe;
  56
  57    /* XXX we should check that all bound resources are unmapped
  58     * before drawing.
  59     */
  60
  61    pipe->draw_vbo(pipe, info);
  62 }
  63
  64 static struct pipe_query *
  65 galahad_create_query(struct pipe_context *_pipe,
  66                       unsigned query_type)
  67 {
  68    struct galahad_context *glhd_pipe = galahad_context(_pipe);
  69    struct pipe_context *pipe = glhd_pipe->pipe;
  70
  71    if (query_type == PIPE_QUERY_OCCLUSION_COUNTER &&
  72       !pipe->screen->get_param(pipe->screen, PIPE_CAP_OCCLUSION_QUERY)) {
  73       glhd_error("Occlusion query requested but not supported");
  74    }
  75
  76    if (query_type == PIPE_QUERY_TIME_ELAPSED &&
  77       !pipe->screen->get_param(pipe->screen, PIPE_CAP_TIMER_QUERY)) {
  78       glhd_error("Timer query requested but not supported");
  79    }
  80
  81    return pipe->create_query(pipe,
  82                              query_type);
  83 }
  84
  85 static void
  86 galahad_destroy_query(struct pipe_context *_pipe,
  87                        struct pipe_query *query)
  88 {
  89    struct galahad_context *glhd_pipe = galahad_context(_pipe);
  90    struct pipe_context *pipe = glhd_pipe->pipe;
  91
  92    pipe->destroy_query(pipe,
  93                        query);
  94 }
  95
  96 static void
  97 galahad_begin_query(struct pipe_context *_pipe,
  98                      struct pipe_query *query)
  99 {
 100    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 101    struct pipe_context *pipe = glhd_pipe->pipe;
 102
 103    pipe->begin_query(pipe,
 104                      query);
 105 }
 106
 107 static void
 108 galahad_end_query(struct pipe_context *_pipe,
 109                    struct pipe_query *query)
 110 {
 111    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 112    struct pipe_context *pipe = glhd_pipe->pipe;
 113
 114    pipe->end_query(pipe,
 115                    query);
 116 }
 117
 118 static boolean
 119 galahad_get_query_result(struct pipe_context *_pipe,
 120                           struct pipe_query *query,
 121                           boolean wait,
 122                           void *result)
 123 {
 124    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 125    struct pipe_context *pipe = glhd_pipe->pipe;
 126
 127    return pipe->get_query_result(pipe,
 128                                  query,
 129                                  wait,
 130                                  result);
 131 }
 132
 133 static void *
 134 galahad_create_blend_state(struct pipe_context *_pipe,
 135                             const struct pipe_blend_state *blend)
 136 {
 137    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 138    struct pipe_context *pipe = glhd_pipe->pipe;
 139
 140    if (blend->logicop_enable) {
 141       if (blend->rt[0].blend_enable) {
 142          glhd_warn("Blending enabled for render target 0, but logicops "
 143             "are enabled");
 144       }
 145    }
 146
 147    return pipe->create_blend_state(pipe,
 148                                    blend);
 149 }
 150
 151 static void
 152 galahad_bind_blend_state(struct pipe_context *_pipe,
 153                           void *blend)
 154 {
 155    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 156    struct pipe_context *pipe = glhd_pipe->pipe;
 157
 158    pipe->bind_blend_state(pipe,
 159                               blend);
 160 }
 161
 162 static void
 163 galahad_delete_blend_state(struct pipe_context *_pipe,
 164                             void *blend)
 165 {
 166    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 167    struct pipe_context *pipe = glhd_pipe->pipe;
 168
 169    pipe->delete_blend_state(pipe,
 170                             blend);
 171 }
 172
 173 static void *
 174 galahad_create_sampler_state(struct pipe_context *_pipe,
 175                               const struct pipe_sampler_state *sampler)
 176 {
 177    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 178    struct pipe_context *pipe = glhd_pipe->pipe;
 179
 180    return pipe->create_sampler_state(pipe,
 181                                      sampler);
 182 }
 183
 184 static void
 185 galahad_bind_fragment_sampler_states(struct pipe_context *_pipe,
 186                                       unsigned num_samplers,
 187                                       void **samplers)
 188 {
 189    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 190    struct pipe_context *pipe = glhd_pipe->pipe;
 191
 192    if (num_samplers > PIPE_MAX_SAMPLERS) {
 193       glhd_error("%u fragment samplers requested, "
 194          "but only %u are permitted by API",
 195          num_samplers, PIPE_MAX_SAMPLERS);
 196    }
 197
 198    pipe->bind_fragment_sampler_states(pipe,
 199                                       num_samplers,
 200                                       samplers);
 201 }
 202
 203 static void
 204 galahad_bind_vertex_sampler_states(struct pipe_context *_pipe,
 205                                     unsigned num_samplers,
 206                                     void **samplers)
 207 {
 208    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 209    struct pipe_context *pipe = glhd_pipe->pipe;
 210
 211    if (num_samplers > PIPE_MAX_VERTEX_SAMPLERS) {
 212       glhd_error("%u vertex samplers requested, "
 213          "but only %u are permitted by API",
 214          num_samplers, PIPE_MAX_VERTEX_SAMPLERS);
 215    }
 216
 217    pipe->bind_vertex_sampler_states(pipe,
 218                                     num_samplers,
 219                                     samplers);
 220 }
 221
 222 static void
 223 galahad_delete_sampler_state(struct pipe_context *_pipe,
 224                               void *sampler)
 225 {
 226    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 227    struct pipe_context *pipe = glhd_pipe->pipe;
 228
 229    pipe->delete_sampler_state(pipe,
 230                               sampler);
 231 }
 232
 233 static void *
 234 galahad_create_rasterizer_state(struct pipe_context *_pipe,
 235                                  const struct pipe_rasterizer_state *rasterizer)
 236 {
 237    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 238    struct pipe_context *pipe = glhd_pipe->pipe;
 239
 240    if (rasterizer->point_quad_rasterization) {
 241        if (rasterizer->point_smooth) {
 242            glhd_warn("Point smoothing requested but ignored");
 243        }
 244    } else {
 245        if (rasterizer->sprite_coord_enable) {
 246            glhd_warn("Point sprites requested but ignored");
 247        }
 248    }
 249
 250    return pipe->create_rasterizer_state(pipe,
 251                                         rasterizer);
 252 }
 253
 254 static void
 255 galahad_bind_rasterizer_state(struct pipe_context *_pipe,
 256                                void *rasterizer)
 257 {
 258    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 259    struct pipe_context *pipe = glhd_pipe->pipe;
 260
 261    pipe->bind_rasterizer_state(pipe,
 262                                rasterizer);
 263 }
 264
 265 static void
 266 galahad_delete_rasterizer_state(struct pipe_context *_pipe,
 267                                  void *rasterizer)
 268 {
 269    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 270    struct pipe_context *pipe = glhd_pipe->pipe;
 271
 272    pipe->delete_rasterizer_state(pipe,
 273                                  rasterizer);
 274 }
 275
 276 static void *
 277 galahad_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
 278                                           const struct pipe_depth_stencil_alpha_state *depth_stencil_alpha)
 279 {
 280    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 281    struct pipe_context *pipe = glhd_pipe->pipe;
 282
 283    return pipe->create_depth_stencil_alpha_state(pipe,
 284                                                  depth_stencil_alpha);
 285 }
 286
 287 static void
 288 galahad_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
 289                                         void *depth_stencil_alpha)
 290 {
 291    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 292    struct pipe_context *pipe = glhd_pipe->pipe;
 293
 294    pipe->bind_depth_stencil_alpha_state(pipe,
 295                                         depth_stencil_alpha);
 296 }
 297
 298 static void
 299 galahad_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
 300                                           void *depth_stencil_alpha)
 301 {
 302    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 303    struct pipe_context *pipe = glhd_pipe->pipe;
 304
 305    pipe->delete_depth_stencil_alpha_state(pipe,
 306                                           depth_stencil_alpha);
 307 }
 308
 309 static void *
 310 galahad_create_fs_state(struct pipe_context *_pipe,
 311                          const struct pipe_shader_state *fs)
 312 {
 313    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 314    struct pipe_context *pipe = glhd_pipe->pipe;
 315
 316    return pipe->create_fs_state(pipe,
 317                                 fs);
 318 }
 319
 320 static void
 321 galahad_bind_fs_state(struct pipe_context *_pipe,
 322                        void *fs)
 323 {
 324    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 325    struct pipe_context *pipe = glhd_pipe->pipe;
 326
 327    pipe->bind_fs_state(pipe,
 328                        fs);
 329 }
 330
 331 static void
 332 galahad_delete_fs_state(struct pipe_context *_pipe,
 333                          void *fs)
 334 {
 335    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 336    struct pipe_context *pipe = glhd_pipe->pipe;
 337
 338    pipe->delete_fs_state(pipe,
 339                          fs);
 340 }
 341
 342 static void *
 343 galahad_create_vs_state(struct pipe_context *_pipe,
 344                          const struct pipe_shader_state *vs)
 345 {
 346    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 347    struct pipe_context *pipe = glhd_pipe->pipe;
 348
 349    return pipe->create_vs_state(pipe,
 350                                 vs);
 351 }
 352
 353 static void
 354 galahad_bind_vs_state(struct pipe_context *_pipe,
 355                        void *vs)
 356 {
 357    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 358    struct pipe_context *pipe = glhd_pipe->pipe;
 359
 360    pipe->bind_vs_state(pipe,
 361                        vs);
 362 }
 363
 364 static void
 365 galahad_delete_vs_state(struct pipe_context *_pipe,
 366                          void *vs)
 367 {
 368    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 369    struct pipe_context *pipe = glhd_pipe->pipe;
 370
 371    pipe->delete_vs_state(pipe,
 372                          vs);
 373 }
 374
 375
 376 static void *
 377 galahad_create_vertex_elements_state(struct pipe_context *_pipe,
 378                                       unsigned num_elements,
 379                                       const struct pipe_vertex_element *vertex_elements)
 380 {
 381    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 382    struct pipe_context *pipe = glhd_pipe->pipe;
 383
 384    return pipe->create_vertex_elements_state(pipe,
 385                                              num_elements,
 386                                              vertex_elements);
 387 }
 388
 389 static void
 390 galahad_bind_vertex_elements_state(struct pipe_context *_pipe,
 391                                     void *velems)
 392 {
 393    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 394    struct pipe_context *pipe = glhd_pipe->pipe;
 395
 396    pipe->bind_vertex_elements_state(pipe,
 397                                     velems);
 398 }
 399
 400 static void
 401 galahad_delete_vertex_elements_state(struct pipe_context *_pipe,
 402                                       void *velems)
 403 {
 404    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 405    struct pipe_context *pipe = glhd_pipe->pipe;
 406
 407    pipe->delete_vertex_elements_state(pipe,
 408                                       velems);
 409 }
 410
 411 static void
 412 galahad_set_blend_color(struct pipe_context *_pipe,
 413                          const struct pipe_blend_color *blend_color)
 414 {
 415    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 416    struct pipe_context *pipe = glhd_pipe->pipe;
 417
 418    pipe->set_blend_color(pipe,
 419                          blend_color);
 420 }
 421
 422 static void
 423 galahad_set_stencil_ref(struct pipe_context *_pipe,
 424                          const struct pipe_stencil_ref *stencil_ref)
 425 {
 426    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 427    struct pipe_context *pipe = glhd_pipe->pipe;
 428
 429    pipe->set_stencil_ref(pipe,
 430                          stencil_ref);
 431 }
 432
 433 static void
 434 galahad_set_clip_state(struct pipe_context *_pipe,
 435                         const struct pipe_clip_state *clip)
 436 {
 437    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 438    struct pipe_context *pipe = glhd_pipe->pipe;
 439
 440    pipe->set_clip_state(pipe,
 441                         clip);
 442 }
 443
 444 static void
 445 galahad_set_sample_mask(struct pipe_context *_pipe,
 446                          unsigned sample_mask)
 447 {
 448    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 449    struct pipe_context *pipe = glhd_pipe->pipe;
 450
 451    pipe->set_sample_mask(pipe,
 452                          sample_mask);
 453 }
 454
 455 static void
 456 galahad_set_constant_buffer(struct pipe_context *_pipe,
 457                              uint shader,
 458                              uint index,
 459                              struct pipe_resource *_resource)
 460 {
 461    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 462    struct pipe_context *pipe = glhd_pipe->pipe;
 463    struct pipe_resource *unwrapped_resource;
 464    struct pipe_resource *resource = NULL;
 465
 466    if (shader >= PIPE_SHADER_TYPES) {
 467       glhd_error("Unknown shader type %u", shader);
 468    }
 469
 470    if (index &&
 471       index >=
 472          pipe->screen->get_shader_param(pipe->screen, shader, PIPE_SHADER_CAP_MAX_CONST_BUFFERS)) {
 473       glhd_error("Access to constant buffer %u requested, "
 474          "but only %d are supported",
 475          index,
 476          pipe->screen->get_shader_param(pipe->screen, shader, PIPE_SHADER_CAP_MAX_CONST_BUFFERS));
 477    }
 478
 479    /* XXX hmm? unwrap the input state */
 480    if (_resource) {
 481       unwrapped_resource = galahad_resource_unwrap(_resource);
 482       resource = unwrapped_resource;
 483    }
 484
 485    pipe->set_constant_buffer(pipe,
 486                              shader,
 487                              index,
 488                              resource);
 489 }
 490
 491 static void
 492 galahad_set_framebuffer_state(struct pipe_context *_pipe,
 493                                const struct pipe_framebuffer_state *_state)
 494 {
 495    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 496    struct pipe_context *pipe = glhd_pipe->pipe;
 497    struct pipe_framebuffer_state unwrapped_state;
 498    struct pipe_framebuffer_state *state = NULL;
 499    unsigned i;
 500
 501    if (_state->nr_cbufs > PIPE_MAX_COLOR_BUFS) {
 502       glhd_error("%d render targets bound, but only %d are permitted by API",
 503          _state->nr_cbufs, PIPE_MAX_COLOR_BUFS);
 504    } else if (_state->nr_cbufs >
 505       pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_RENDER_TARGETS)) {
 506       glhd_warn("%d render targets bound, but only %d are supported",
 507          _state->nr_cbufs,
 508          pipe->screen->get_param(pipe->screen, PIPE_CAP_MAX_RENDER_TARGETS));
 509    }
 510
 511    /* unwrap the input state */
 512    if (_state) {
 513       memcpy(&unwrapped_state, _state, sizeof(unwrapped_state));
 514       for(i = 0; i < _state->nr_cbufs; i++)
 515          unwrapped_state.cbufs[i] = galahad_surface_unwrap(_state->cbufs[i]);
 516       for (; i < PIPE_MAX_COLOR_BUFS; i++)
 517          unwrapped_state.cbufs[i] = NULL;
 518       unwrapped_state.zsbuf = galahad_surface_unwrap(_state->zsbuf);
 519       state = &unwrapped_state;
 520    }
 521
 522    pipe->set_framebuffer_state(pipe,
 523                                state);
 524 }
 525
 526 static void
 527 galahad_set_polygon_stipple(struct pipe_context *_pipe,
 528                              const struct pipe_poly_stipple *poly_stipple)
 529 {
 530    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 531    struct pipe_context *pipe = glhd_pipe->pipe;
 532
 533    pipe->set_polygon_stipple(pipe,
 534                              poly_stipple);
 535 }
 536
 537 static void
 538 galahad_set_scissor_state(struct pipe_context *_pipe,
 539                            const struct pipe_scissor_state *scissor)
 540 {
 541    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 542    struct pipe_context *pipe = glhd_pipe->pipe;
 543
 544    pipe->set_scissor_state(pipe,
 545                            scissor);
 546 }
 547
 548 static void
 549 galahad_set_viewport_state(struct pipe_context *_pipe,
 550                             const struct pipe_viewport_state *viewport)
 551 {
 552    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 553    struct pipe_context *pipe = glhd_pipe->pipe;
 554
 555    pipe->set_viewport_state(pipe,
 556                             viewport);
 557 }
 558
 559 static void
 560 galahad_set_fragment_sampler_views(struct pipe_context *_pipe,
 561                                     unsigned num,
 562                                     struct pipe_sampler_view **_views)
 563 {
 564    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 565    struct pipe_context *pipe = glhd_pipe->pipe;
 566    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
 567    struct pipe_sampler_view **views = NULL;
 568    unsigned i;
 569
 570    if (_views) {
 571       for (i = 0; i < num; i++)
 572          unwrapped_views[i] = galahad_sampler_view_unwrap(_views[i]);
 573       for (; i < PIPE_MAX_SAMPLERS; i++)
 574          unwrapped_views[i] = NULL;
 575
 576       views = unwrapped_views;
 577    }
 578
 579    pipe->set_fragment_sampler_views(pipe, num, views);
 580 }
 581
 582 static void
 583 galahad_set_vertex_sampler_views(struct pipe_context *_pipe,
 584                                   unsigned num,
 585                                   struct pipe_sampler_view **_views)
 586 {
 587    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 588    struct pipe_context *pipe = glhd_pipe->pipe;
 589    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
 590    struct pipe_sampler_view **views = NULL;
 591    unsigned i;
 592
 593    if (_views) {
 594       for (i = 0; i < num; i++)
 595          unwrapped_views[i] = galahad_sampler_view_unwrap(_views[i]);
 596       for (; i < PIPE_MAX_VERTEX_SAMPLERS; i++)
 597          unwrapped_views[i] = NULL;
 598
 599       views = unwrapped_views;
 600    }
 601
 602    pipe->set_vertex_sampler_views(pipe, num, views);
 603 }
 604
 605 static void
 606 galahad_set_vertex_buffers(struct pipe_context *_pipe,
 607                             unsigned num_buffers,
 608                             const struct pipe_vertex_buffer *_buffers)
 609 {
 610    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 611    struct pipe_context *pipe = glhd_pipe->pipe;
 612    struct pipe_vertex_buffer unwrapped_buffers[PIPE_MAX_SHADER_INPUTS];
 613    struct pipe_vertex_buffer *buffers = NULL;
 614    unsigned i;
 615
 616    if (num_buffers) {
 617       memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers));
 618       for (i = 0; i < num_buffers; i++)
 619          unwrapped_buffers[i].buffer = galahad_resource_unwrap(_buffers[i].buffer);
 620       buffers = unwrapped_buffers;
 621    }
 622
 623    pipe->set_vertex_buffers(pipe,
 624                             num_buffers,
 625                             buffers);
 626 }
 627
 628 static void
 629 galahad_set_index_buffer(struct pipe_context *_pipe,
 630                          const struct pipe_index_buffer *_ib)
 631 {
 632    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 633    struct pipe_context *pipe = glhd_pipe->pipe;
 634    struct pipe_index_buffer unwrapped_ib, *ib = NULL;
 635
 636    if (_ib->buffer) {
 637       switch (_ib->index_size) {
 638       case 1:
 639       case 2:
 640       case 4:
 641          break;
 642       default:
 643          glhd_warn("index buffer %p has unrecognized index size %d",
 644                    (void *) _ib->buffer, _ib->index_size);
 645          break;
 646       }
 647    }
 648    else if (_ib->offset || _ib->index_size) {
 649       glhd_warn("non-indexed state with index offset %d and index size %d",
 650             _ib->offset, _ib->index_size);
 651    }
 652
 653    if (_ib) {
 654       unwrapped_ib = *_ib;
 655       unwrapped_ib.buffer = galahad_resource_unwrap(_ib->buffer);
 656       ib = &unwrapped_ib;
 657    }
 658
 659    pipe->set_index_buffer(pipe, ib);
 660 }
 661
 662 static void
 663 galahad_resource_copy_region(struct pipe_context *_pipe,
 664                               struct pipe_resource *_dst,
 665                               struct pipe_subresource subdst,
 666                               unsigned dstx,
 667                               unsigned dsty,
 668                               unsigned dstz,
 669                               struct pipe_resource *_src,
 670                               struct pipe_subresource subsrc,
 671                               unsigned srcx,
 672                               unsigned srcy,
 673                               unsigned srcz,
 674                               unsigned width,
 675                               unsigned height)
 676 {
 677    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 678    struct galahad_resource *glhd_resource_dst = galahad_resource(_dst);
 679    struct galahad_resource *glhd_resource_src = galahad_resource(_src);
 680    struct pipe_context *pipe = glhd_pipe->pipe;
 681    struct pipe_resource *dst = glhd_resource_dst->resource;
 682    struct pipe_resource *src = glhd_resource_src->resource;
 683
 684    if (_dst->format != _src->format) {
 685       glhd_warn("Format mismatch: Source is %s, destination is %s",
 686          util_format_short_name(_src->format),
 687          util_format_short_name(_dst->format));
 688    }
 689
 690    pipe->resource_copy_region(pipe,
 691                               dst,
 692                               subdst,
 693                               dstx,
 694                               dsty,
 695                               dstz,
 696                               src,
 697                               subsrc,
 698                               srcx,
 699                               srcy,
 700                               srcz,
 701                               width,
 702                               height);
 703 }
 704
 705 static void
 706 galahad_clear(struct pipe_context *_pipe,
 707                unsigned buffers,
 708                const float *rgba,
 709                double depth,
 710                unsigned stencil)
 711 {
 712    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 713    struct pipe_context *pipe = glhd_pipe->pipe;
 714
 715    pipe->clear(pipe,
 716                buffers,
 717                rgba,
 718                depth,
 719                stencil);
 720 }
 721
 722 static void
 723 galahad_clear_render_target(struct pipe_context *_pipe,
 724                              struct pipe_surface *_dst,
 725                              const float *rgba,
 726                              unsigned dstx, unsigned dsty,
 727                              unsigned width, unsigned height)
 728 {
 729    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 730    struct galahad_surface *glhd_surface_dst = galahad_surface(_dst);
 731    struct pipe_context *pipe = glhd_pipe->pipe;
 732    struct pipe_surface *dst = glhd_surface_dst->surface;
 733
 734    pipe->clear_render_target(pipe,
 735                              dst,
 736                              rgba,
 737                              dstx,
 738                              dsty,
 739                              width,
 740                              height);
 741 }
 742 static void
 743 galahad_clear_depth_stencil(struct pipe_context *_pipe,
 744                              struct pipe_surface *_dst,
 745                              unsigned clear_flags,
 746                              double depth,
 747                              unsigned stencil,
 748                              unsigned dstx, unsigned dsty,
 749                              unsigned width, unsigned height)
 750 {
 751    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 752    struct galahad_surface *glhd_surface_dst = galahad_surface(_dst);
 753    struct pipe_context *pipe = glhd_pipe->pipe;
 754    struct pipe_surface *dst = glhd_surface_dst->surface;
 755
 756    pipe->clear_depth_stencil(pipe,
 757                              dst,
 758                              clear_flags,
 759                              depth,
 760                              stencil,
 761                              dstx,
 762                              dsty,
 763                              width,
 764                              height);
 765
 766 }
 767
 768 static void
 769 galahad_flush(struct pipe_context *_pipe,
 770                unsigned flags,
 771                struct pipe_fence_handle **fence)
 772 {
 773    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 774    struct pipe_context *pipe = glhd_pipe->pipe;
 775
 776    pipe->flush(pipe,
 777                flags,
 778                fence);
 779 }
 780
 781 static unsigned int
 782 galahad_is_resource_referenced(struct pipe_context *_pipe,
 783                                 struct pipe_resource *_resource,
 784                                 unsigned face,
 785                                 unsigned level)
 786 {
 787    struct galahad_context *glhd_pipe = galahad_context(_pipe);
 788    struct galahad_resource *glhd_resource = galahad_resource(_resource);
 789    struct pipe_context *pipe = glhd_pipe->pipe;
 790    struct pipe_resource *resource = glhd_resource->resource;
 791
 792    return pipe->is_resource_referenced(pipe,
 793                                        resource,
 794                                        face,
 795                                        level);
 796 }
 797
 798 static struct pipe_sampler_view *
 799 galahad_context_create_sampler_view(struct pipe_context *_pipe,
 800                                      struct pipe_resource *_resource,
 801                                      const struct pipe_sampler_view *templ)
 802 {
 803    struct galahad_context *glhd_context = galahad_context(_pipe);
 804    struct galahad_resource *glhd_resource = galahad_resource(_resource);
 805    struct pipe_context *pipe = glhd_context->pipe;
 806    struct pipe_resource *resource = glhd_resource->resource;
 807    struct pipe_sampler_view *result;
 808
 809    result = pipe->create_sampler_view(pipe,
 810                                       resource,
 811                                       templ);
 812
 813    if (result)
 814       return galahad_sampler_view_create(glhd_context, glhd_resource, result);
 815    return NULL;
 816 }
 817
 818 static void
 819 galahad_context_sampler_view_destroy(struct pipe_context *_pipe,
 820                                       struct pipe_sampler_view *_view)
 821 {
 822    galahad_sampler_view_destroy(galahad_context(_pipe),
 823                                  galahad_sampler_view(_view));
 824 }
 825
 826 static struct pipe_transfer *
 827 galahad_context_get_transfer(struct pipe_context *_context,
 828                               struct pipe_resource *_resource,
 829                               struct pipe_subresource sr,
 830                               unsigned usage,
 831                               const struct pipe_box *box)
 832 {
 833    struct galahad_context *glhd_context = galahad_context(_context);
 834    struct galahad_resource *glhd_resource = galahad_resource(_resource);
 835    struct pipe_context *context = glhd_context->pipe;
 836    struct pipe_resource *resource = glhd_resource->resource;
 837    struct pipe_transfer *result;
 838
 839    result = context->get_transfer(context,
 840                                   resource,
 841                                   sr,
 842                                   usage,
 843                                   box);
 844
 845    if (result)
 846       return galahad_transfer_create(glhd_context, glhd_resource, result);
 847    return NULL;
 848 }
 849
 850 static void
 851 galahad_context_transfer_destroy(struct pipe_context *_pipe,
 852                                   struct pipe_transfer *_transfer)
 853 {
 854    galahad_transfer_destroy(galahad_context(_pipe),
 855                              galahad_transfer(_transfer));
 856 }
 857
 858 static void *
 859 galahad_context_transfer_map(struct pipe_context *_context,
 860                               struct pipe_transfer *_transfer)
 861 {
 862    struct galahad_context *glhd_context = galahad_context(_context);
 863    struct galahad_transfer *glhd_transfer = galahad_transfer(_transfer);
 864    struct pipe_context *context = glhd_context->pipe;
 865    struct pipe_transfer *transfer = glhd_transfer->transfer;
 866
 867    struct galahad_resource *glhd_resource = galahad_resource(_transfer->resource);
 868
 869    glhd_resource->map_count++;
 870
 871    return context->transfer_map(context,
 872                                 transfer);
 873 }
 874
 875
 876
 877 static void
 878 galahad_context_transfer_flush_region(struct pipe_context *_context,
 879                                        struct pipe_transfer *_transfer,
 880                                        const struct pipe_box *box)
 881 {
 882    struct galahad_context *glhd_context = galahad_context(_context);
 883    struct galahad_transfer *glhd_transfer = galahad_transfer(_transfer);
 884    struct pipe_context *context = glhd_context->pipe;
 885    struct pipe_transfer *transfer = glhd_transfer->transfer;
 886
 887    context->transfer_flush_region(context,
 888                                   transfer,
 889                                   box);
 890 }
 891
 892
 893 static void
 894 galahad_context_transfer_unmap(struct pipe_context *_context,
 895                                 struct pipe_transfer *_transfer)
 896 {
 897    struct galahad_context *glhd_context = galahad_context(_context);
 898    struct galahad_transfer *glhd_transfer = galahad_transfer(_transfer);
 899    struct pipe_context *context = glhd_context->pipe;
 900    struct pipe_transfer *transfer = glhd_transfer->transfer;
 901    struct galahad_resource *glhd_resource = galahad_resource(_transfer->resource);
 902
 903    if (glhd_resource->map_count < 1) {
 904       glhd_warn("context::transfer_unmap() called too many times"
 905                 " (count = %d)\n", glhd_resource->map_count);
 906    }
 907
 908    glhd_resource->map_count--;
 909
 910    context->transfer_unmap(context,
 911                            transfer);
 912 }
 913
 914
 915 static void
 916 galahad_context_transfer_inline_write(struct pipe_context *_context,
 917                                        struct pipe_resource *_resource,
 918                                        struct pipe_subresource sr,
 919                                        unsigned usage,
 920                                        const struct pipe_box *box,
 921                                        const void *data,
 922                                        unsigned stride,
 923                                        unsigned slice_stride)
 924 {
 925    struct galahad_context *glhd_context = galahad_context(_context);
 926    struct galahad_resource *glhd_resource = galahad_resource(_resource);
 927    struct pipe_context *context = glhd_context->pipe;
 928    struct pipe_resource *resource = glhd_resource->resource;
 929
 930    context->transfer_inline_write(context,
 931                                   resource,
 932                                   sr,
 933                                   usage,
 934                                   box,
 935                                   data,
 936                                   stride,
 937                                   slice_stride);
 938 }
 939
 940
 941 struct pipe_context *
 942 galahad_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
 943 {
 944    struct galahad_context *glhd_pipe;
 945    (void)galahad_screen(_screen);
 946
 947    glhd_pipe = CALLOC_STRUCT(galahad_context);
 948    if (!glhd_pipe) {
 949       return NULL;
 950    }
 951
 952    glhd_pipe->base.winsys = NULL;
 953    glhd_pipe->base.screen = _screen;
 954    glhd_pipe->base.priv = pipe->priv; /* expose wrapped data */
 955    glhd_pipe->base.draw = NULL;
 956
 957    glhd_pipe->base.destroy = galahad_destroy;
 958    glhd_pipe->base.draw_vbo = galahad_draw_vbo;
 959    glhd_pipe->base.create_query = galahad_create_query;
 960    glhd_pipe->base.destroy_query = galahad_destroy_query;
 961    glhd_pipe->base.begin_query = galahad_begin_query;
 962    glhd_pipe->base.end_query = galahad_end_query;
 963    glhd_pipe->base.get_query_result = galahad_get_query_result;
 964    glhd_pipe->base.create_blend_state = galahad_create_blend_state;
 965    glhd_pipe->base.bind_blend_state = galahad_bind_blend_state;
 966    glhd_pipe->base.delete_blend_state = galahad_delete_blend_state;
 967    glhd_pipe->base.create_sampler_state = galahad_create_sampler_state;
 968    glhd_pipe->base.bind_fragment_sampler_states = galahad_bind_fragment_sampler_states;
 969    glhd_pipe->base.bind_vertex_sampler_states = galahad_bind_vertex_sampler_states;
 970    glhd_pipe->base.delete_sampler_state = galahad_delete_sampler_state;
 971    glhd_pipe->base.create_rasterizer_state = galahad_create_rasterizer_state;
 972    glhd_pipe->base.bind_rasterizer_state = galahad_bind_rasterizer_state;
 973    glhd_pipe->base.delete_rasterizer_state = galahad_delete_rasterizer_state;
 974    glhd_pipe->base.create_depth_stencil_alpha_state = galahad_create_depth_stencil_alpha_state;
 975    glhd_pipe->base.bind_depth_stencil_alpha_state = galahad_bind_depth_stencil_alpha_state;
 976    glhd_pipe->base.delete_depth_stencil_alpha_state = galahad_delete_depth_stencil_alpha_state;
 977    glhd_pipe->base.create_fs_state = galahad_create_fs_state;
 978    glhd_pipe->base.bind_fs_state = galahad_bind_fs_state;
 979    glhd_pipe->base.delete_fs_state = galahad_delete_fs_state;
 980    glhd_pipe->base.create_vs_state = galahad_create_vs_state;
 981    glhd_pipe->base.bind_vs_state = galahad_bind_vs_state;
 982    glhd_pipe->base.delete_vs_state = galahad_delete_vs_state;
 983    glhd_pipe->base.create_vertex_elements_state = galahad_create_vertex_elements_state;
 984    glhd_pipe->base.bind_vertex_elements_state = galahad_bind_vertex_elements_state;
 985    glhd_pipe->base.delete_vertex_elements_state = galahad_delete_vertex_elements_state;
 986    glhd_pipe->base.set_blend_color = galahad_set_blend_color;
 987    glhd_pipe->base.set_stencil_ref = galahad_set_stencil_ref;
 988    glhd_pipe->base.set_clip_state = galahad_set_clip_state;
 989    glhd_pipe->base.set_sample_mask = galahad_set_sample_mask;
 990    glhd_pipe->base.set_constant_buffer = galahad_set_constant_buffer;
 991    glhd_pipe->base.set_framebuffer_state = galahad_set_framebuffer_state;
 992    glhd_pipe->base.set_polygon_stipple = galahad_set_polygon_stipple;
 993    glhd_pipe->base.set_scissor_state = galahad_set_scissor_state;
 994    glhd_pipe->base.set_viewport_state = galahad_set_viewport_state;
 995    glhd_pipe->base.set_fragment_sampler_views = galahad_set_fragment_sampler_views;
 996    glhd_pipe->base.set_vertex_sampler_views = galahad_set_vertex_sampler_views;
 997    glhd_pipe->base.set_vertex_buffers = galahad_set_vertex_buffers;
 998    glhd_pipe->base.set_index_buffer = galahad_set_index_buffer;
 999    glhd_pipe->base.resource_copy_region = galahad_resource_copy_region;
1000    glhd_pipe->base.clear = galahad_clear;
1001    glhd_pipe->base.clear_render_target = galahad_clear_render_target;
1002    glhd_pipe->base.clear_depth_stencil = galahad_clear_depth_stencil;
1003    glhd_pipe->base.flush = galahad_flush;
1004    glhd_pipe->base.is_resource_referenced = galahad_is_resource_referenced;
1005    glhd_pipe->base.create_sampler_view = galahad_context_create_sampler_view;
1006    glhd_pipe->base.sampler_view_destroy = galahad_context_sampler_view_destroy;
1007    glhd_pipe->base.get_transfer = galahad_context_get_transfer;
1008    glhd_pipe->base.transfer_destroy = galahad_context_transfer_destroy;
1009    glhd_pipe->base.transfer_map = galahad_context_transfer_map;
1010    glhd_pipe->base.transfer_unmap = galahad_context_transfer_unmap;
1011    glhd_pipe->base.transfer_flush_region = galahad_context_transfer_flush_region;
1012    glhd_pipe->base.transfer_inline_write = galahad_context_transfer_inline_write;
1013
1014    glhd_pipe->pipe = pipe;
1015
1016    glhd_warn("Created context %p", (void *) glhd_pipe);
1017
1018    return &glhd_pipe->base;
1019 }