src/gallium/drivers/identity/id_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 #include "util/u_memory.h"
  31 #include "util/u_inlines.h"
  32
  33 #include "id_context.h"
  34 #include "id_objects.h"
  35
  36
  37 static void
  38 identity_destroy(struct pipe_context *_pipe)
  39 {
  40    struct identity_context *id_pipe = identity_context(_pipe);
  41    struct pipe_context *pipe = id_pipe->pipe;
  42
  43    pipe->destroy(pipe);
  44
  45    FREE(id_pipe);
  46 }
  47
  48 static void
  49 identity_draw_arrays(struct pipe_context *_pipe,
  50                      unsigned prim,
  51                      unsigned start,
  52                      unsigned count)
  53 {
  54    struct identity_context *id_pipe = identity_context(_pipe);
  55    struct pipe_context *pipe = id_pipe->pipe;
  56
  57    pipe->draw_arrays(pipe,
  58                      prim,
  59                      start,
  60                      count);
  61 }
  62
  63 static void
  64 identity_draw_elements(struct pipe_context *_pipe,
  65                        struct pipe_resource *_indexResource,
  66                        unsigned indexSize,
  67                        int indexBias,
  68                        unsigned prim,
  69                        unsigned start,
  70                        unsigned count)
  71 {
  72    struct identity_context *id_pipe = identity_context(_pipe);
  73    struct identity_resource *id_resource = identity_resource(_indexResource);
  74    struct pipe_context *pipe = id_pipe->pipe;
  75    struct pipe_resource *indexResource = id_resource->resource;
  76
  77    pipe->draw_elements(pipe,
  78                        indexResource,
  79                        indexSize,
  80                        indexBias,
  81                        prim,
  82                        start,
  83                        count);
  84 }
  85
  86 static void
  87 identity_draw_range_elements(struct pipe_context *_pipe,
  88                              struct pipe_resource *_indexResource,
  89                              unsigned indexSize,
  90                              int indexBias,
  91                              unsigned minIndex,
  92                              unsigned maxIndex,
  93                              unsigned mode,
  94                              unsigned start,
  95                              unsigned count)
  96 {
  97    struct identity_context *id_pipe = identity_context(_pipe);
  98    struct identity_resource *id_resource = identity_resource(_indexResource);
  99    struct pipe_context *pipe = id_pipe->pipe;
 100    struct pipe_resource *indexResource = id_resource->resource;
 101
 102    pipe->draw_range_elements(pipe,
 103                              indexResource,
 104                              indexSize,
 105                              indexBias,
 106                              minIndex,
 107                              maxIndex,
 108                              mode,
 109                              start,
 110                              count);
 111 }
 112
 113 static struct pipe_query *
 114 identity_create_query(struct pipe_context *_pipe,
 115                       unsigned query_type)
 116 {
 117    struct identity_context *id_pipe = identity_context(_pipe);
 118    struct pipe_context *pipe = id_pipe->pipe;
 119
 120    return pipe->create_query(pipe,
 121                              query_type);
 122 }
 123
 124 static void
 125 identity_destroy_query(struct pipe_context *_pipe,
 126                        struct pipe_query *query)
 127 {
 128    struct identity_context *id_pipe = identity_context(_pipe);
 129    struct pipe_context *pipe = id_pipe->pipe;
 130
 131    pipe->destroy_query(pipe,
 132                        query);
 133 }
 134
 135 static void
 136 identity_begin_query(struct pipe_context *_pipe,
 137                      struct pipe_query *query)
 138 {
 139    struct identity_context *id_pipe = identity_context(_pipe);
 140    struct pipe_context *pipe = id_pipe->pipe;
 141
 142    pipe->begin_query(pipe,
 143                      query);
 144 }
 145
 146 static void
 147 identity_end_query(struct pipe_context *_pipe,
 148                    struct pipe_query *query)
 149 {
 150    struct identity_context *id_pipe = identity_context(_pipe);
 151    struct pipe_context *pipe = id_pipe->pipe;
 152
 153    pipe->end_query(pipe,
 154                    query);
 155 }
 156
 157 static boolean
 158 identity_get_query_result(struct pipe_context *_pipe,
 159                           struct pipe_query *query,
 160                           boolean wait,
 161                           uint64_t *result)
 162 {
 163    struct identity_context *id_pipe = identity_context(_pipe);
 164    struct pipe_context *pipe = id_pipe->pipe;
 165
 166    return pipe->get_query_result(pipe,
 167                                  query,
 168                                  wait,
 169                                  result);
 170 }
 171
 172 static void *
 173 identity_create_blend_state(struct pipe_context *_pipe,
 174                             const struct pipe_blend_state *blend)
 175 {
 176    struct identity_context *id_pipe = identity_context(_pipe);
 177    struct pipe_context *pipe = id_pipe->pipe;
 178
 179    return pipe->create_blend_state(pipe,
 180                                    blend);
 181 }
 182
 183 static void
 184 identity_bind_blend_state(struct pipe_context *_pipe,
 185                           void *blend)
 186 {
 187    struct identity_context *id_pipe = identity_context(_pipe);
 188    struct pipe_context *pipe = id_pipe->pipe;
 189
 190    pipe->bind_blend_state(pipe,
 191                               blend);
 192 }
 193
 194 static void
 195 identity_delete_blend_state(struct pipe_context *_pipe,
 196                             void *blend)
 197 {
 198    struct identity_context *id_pipe = identity_context(_pipe);
 199    struct pipe_context *pipe = id_pipe->pipe;
 200
 201    pipe->delete_blend_state(pipe,
 202                             blend);
 203 }
 204
 205 static void *
 206 identity_create_sampler_state(struct pipe_context *_pipe,
 207                               const struct pipe_sampler_state *sampler)
 208 {
 209    struct identity_context *id_pipe = identity_context(_pipe);
 210    struct pipe_context *pipe = id_pipe->pipe;
 211
 212    return pipe->create_sampler_state(pipe,
 213                                      sampler);
 214 }
 215
 216 static void
 217 identity_bind_fragment_sampler_states(struct pipe_context *_pipe,
 218                                       unsigned num_samplers,
 219                                       void **samplers)
 220 {
 221    struct identity_context *id_pipe = identity_context(_pipe);
 222    struct pipe_context *pipe = id_pipe->pipe;
 223
 224    pipe->bind_fragment_sampler_states(pipe,
 225                                       num_samplers,
 226                                       samplers);
 227 }
 228
 229 static void
 230 identity_bind_vertex_sampler_states(struct pipe_context *_pipe,
 231                                     unsigned num_samplers,
 232                                     void **samplers)
 233 {
 234    struct identity_context *id_pipe = identity_context(_pipe);
 235    struct pipe_context *pipe = id_pipe->pipe;
 236
 237    pipe->bind_vertex_sampler_states(pipe,
 238                                     num_samplers,
 239                                     samplers);
 240 }
 241
 242 static void
 243 identity_delete_sampler_state(struct pipe_context *_pipe,
 244                               void *sampler)
 245 {
 246    struct identity_context *id_pipe = identity_context(_pipe);
 247    struct pipe_context *pipe = id_pipe->pipe;
 248
 249    pipe->delete_sampler_state(pipe,
 250                               sampler);
 251 }
 252
 253 static void *
 254 identity_create_rasterizer_state(struct pipe_context *_pipe,
 255                                  const struct pipe_rasterizer_state *rasterizer)
 256 {
 257    struct identity_context *id_pipe = identity_context(_pipe);
 258    struct pipe_context *pipe = id_pipe->pipe;
 259
 260    return pipe->create_rasterizer_state(pipe,
 261                                         rasterizer);
 262 }
 263
 264 static void
 265 identity_bind_rasterizer_state(struct pipe_context *_pipe,
 266                                void *rasterizer)
 267 {
 268    struct identity_context *id_pipe = identity_context(_pipe);
 269    struct pipe_context *pipe = id_pipe->pipe;
 270
 271    pipe->bind_rasterizer_state(pipe,
 272                                rasterizer);
 273 }
 274
 275 static void
 276 identity_delete_rasterizer_state(struct pipe_context *_pipe,
 277                                  void *rasterizer)
 278 {
 279    struct identity_context *id_pipe = identity_context(_pipe);
 280    struct pipe_context *pipe = id_pipe->pipe;
 281
 282    pipe->delete_rasterizer_state(pipe,
 283                                  rasterizer);
 284 }
 285
 286 static void *
 287 identity_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
 288                                           const struct pipe_depth_stencil_alpha_state *depth_stencil_alpha)
 289 {
 290    struct identity_context *id_pipe = identity_context(_pipe);
 291    struct pipe_context *pipe = id_pipe->pipe;
 292
 293    return pipe->create_depth_stencil_alpha_state(pipe,
 294                                                  depth_stencil_alpha);
 295 }
 296
 297 static void
 298 identity_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
 299                                         void *depth_stencil_alpha)
 300 {
 301    struct identity_context *id_pipe = identity_context(_pipe);
 302    struct pipe_context *pipe = id_pipe->pipe;
 303
 304    pipe->bind_depth_stencil_alpha_state(pipe,
 305                                         depth_stencil_alpha);
 306 }
 307
 308 static void
 309 identity_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
 310                                           void *depth_stencil_alpha)
 311 {
 312    struct identity_context *id_pipe = identity_context(_pipe);
 313    struct pipe_context *pipe = id_pipe->pipe;
 314
 315    pipe->delete_depth_stencil_alpha_state(pipe,
 316                                           depth_stencil_alpha);
 317 }
 318
 319 static void *
 320 identity_create_fs_state(struct pipe_context *_pipe,
 321                          const struct pipe_shader_state *fs)
 322 {
 323    struct identity_context *id_pipe = identity_context(_pipe);
 324    struct pipe_context *pipe = id_pipe->pipe;
 325
 326    return pipe->create_fs_state(pipe,
 327                                 fs);
 328 }
 329
 330 static void
 331 identity_bind_fs_state(struct pipe_context *_pipe,
 332                        void *fs)
 333 {
 334    struct identity_context *id_pipe = identity_context(_pipe);
 335    struct pipe_context *pipe = id_pipe->pipe;
 336
 337    pipe->bind_fs_state(pipe,
 338                        fs);
 339 }
 340
 341 static void
 342 identity_delete_fs_state(struct pipe_context *_pipe,
 343                          void *fs)
 344 {
 345    struct identity_context *id_pipe = identity_context(_pipe);
 346    struct pipe_context *pipe = id_pipe->pipe;
 347
 348    pipe->delete_fs_state(pipe,
 349                          fs);
 350 }
 351
 352 static void *
 353 identity_create_vs_state(struct pipe_context *_pipe,
 354                          const struct pipe_shader_state *vs)
 355 {
 356    struct identity_context *id_pipe = identity_context(_pipe);
 357    struct pipe_context *pipe = id_pipe->pipe;
 358
 359    return pipe->create_vs_state(pipe,
 360                                 vs);
 361 }
 362
 363 static void
 364 identity_bind_vs_state(struct pipe_context *_pipe,
 365                        void *vs)
 366 {
 367    struct identity_context *id_pipe = identity_context(_pipe);
 368    struct pipe_context *pipe = id_pipe->pipe;
 369
 370    pipe->bind_vs_state(pipe,
 371                        vs);
 372 }
 373
 374 static void
 375 identity_delete_vs_state(struct pipe_context *_pipe,
 376                          void *vs)
 377 {
 378    struct identity_context *id_pipe = identity_context(_pipe);
 379    struct pipe_context *pipe = id_pipe->pipe;
 380
 381    pipe->delete_vs_state(pipe,
 382                          vs);
 383 }
 384
 385
 386 static void *
 387 identity_create_vertex_elements_state(struct pipe_context *_pipe,
 388                                       unsigned num_elements,
 389                                       const struct pipe_vertex_element *vertex_elements)
 390 {
 391    struct identity_context *id_pipe = identity_context(_pipe);
 392    struct pipe_context *pipe = id_pipe->pipe;
 393
 394    return pipe->create_vertex_elements_state(pipe,
 395                                              num_elements,
 396                                              vertex_elements);
 397 }
 398
 399 static void
 400 identity_bind_vertex_elements_state(struct pipe_context *_pipe,
 401                                     void *velems)
 402 {
 403    struct identity_context *id_pipe = identity_context(_pipe);
 404    struct pipe_context *pipe = id_pipe->pipe;
 405
 406    pipe->bind_vertex_elements_state(pipe,
 407                                     velems);
 408 }
 409
 410 static void
 411 identity_delete_vertex_elements_state(struct pipe_context *_pipe,
 412                                       void *velems)
 413 {
 414    struct identity_context *id_pipe = identity_context(_pipe);
 415    struct pipe_context *pipe = id_pipe->pipe;
 416
 417    pipe->delete_vertex_elements_state(pipe,
 418                                       velems);
 419 }
 420
 421 static void
 422 identity_set_blend_color(struct pipe_context *_pipe,
 423                          const struct pipe_blend_color *blend_color)
 424 {
 425    struct identity_context *id_pipe = identity_context(_pipe);
 426    struct pipe_context *pipe = id_pipe->pipe;
 427
 428    pipe->set_blend_color(pipe,
 429                          blend_color);
 430 }
 431
 432 static void
 433 identity_set_stencil_ref(struct pipe_context *_pipe,
 434                          const struct pipe_stencil_ref *stencil_ref)
 435 {
 436    struct identity_context *id_pipe = identity_context(_pipe);
 437    struct pipe_context *pipe = id_pipe->pipe;
 438
 439    pipe->set_stencil_ref(pipe,
 440                          stencil_ref);
 441 }
 442
 443 static void
 444 identity_set_clip_state(struct pipe_context *_pipe,
 445                         const struct pipe_clip_state *clip)
 446 {
 447    struct identity_context *id_pipe = identity_context(_pipe);
 448    struct pipe_context *pipe = id_pipe->pipe;
 449
 450    pipe->set_clip_state(pipe,
 451                         clip);
 452 }
 453
 454 static void
 455 identity_set_sample_mask(struct pipe_context *_pipe,
 456                          unsigned sample_mask)
 457 {
 458    struct identity_context *id_pipe = identity_context(_pipe);
 459    struct pipe_context *pipe = id_pipe->pipe;
 460
 461    pipe->set_sample_mask(pipe,
 462                          sample_mask);
 463 }
 464
 465 static void
 466 identity_set_constant_buffer(struct pipe_context *_pipe,
 467                              uint shader,
 468                              uint index,
 469                              struct pipe_resource *_resource)
 470 {
 471    struct identity_context *id_pipe = identity_context(_pipe);
 472    struct pipe_context *pipe = id_pipe->pipe;
 473    struct pipe_resource *unwrapped_resource;
 474    struct pipe_resource *resource = NULL;
 475
 476    /* XXX hmm? unwrap the input state */
 477    if (_resource) {
 478       unwrapped_resource = identity_resource_unwrap(_resource);
 479       resource = unwrapped_resource;
 480    }
 481
 482    pipe->set_constant_buffer(pipe,
 483                              shader,
 484                              index,
 485                              resource);
 486 }
 487
 488 static void
 489 identity_set_framebuffer_state(struct pipe_context *_pipe,
 490                                const struct pipe_framebuffer_state *_state)
 491 {
 492    struct identity_context *id_pipe = identity_context(_pipe);
 493    struct pipe_context *pipe = id_pipe->pipe;
 494    struct pipe_framebuffer_state unwrapped_state;
 495    struct pipe_framebuffer_state *state = NULL;
 496    unsigned i;
 497
 498    /* unwrap the input state */
 499    if (_state) {
 500       memcpy(&unwrapped_state, _state, sizeof(unwrapped_state));
 501       for(i = 0; i < _state->nr_cbufs; i++)
 502          unwrapped_state.cbufs[i] = identity_surface_unwrap(_state->cbufs[i]);
 503       for (; i < PIPE_MAX_COLOR_BUFS; i++)
 504          unwrapped_state.cbufs[i] = NULL;
 505       unwrapped_state.zsbuf = identity_surface_unwrap(_state->zsbuf);
 506       state = &unwrapped_state;
 507    }
 508
 509    pipe->set_framebuffer_state(pipe,
 510                                state);
 511 }
 512
 513 static void
 514 identity_set_polygon_stipple(struct pipe_context *_pipe,
 515                              const struct pipe_poly_stipple *poly_stipple)
 516 {
 517    struct identity_context *id_pipe = identity_context(_pipe);
 518    struct pipe_context *pipe = id_pipe->pipe;
 519
 520    pipe->set_polygon_stipple(pipe,
 521                              poly_stipple);
 522 }
 523
 524 static void
 525 identity_set_scissor_state(struct pipe_context *_pipe,
 526                            const struct pipe_scissor_state *scissor)
 527 {
 528    struct identity_context *id_pipe = identity_context(_pipe);
 529    struct pipe_context *pipe = id_pipe->pipe;
 530
 531    pipe->set_scissor_state(pipe,
 532                            scissor);
 533 }
 534
 535 static void
 536 identity_set_viewport_state(struct pipe_context *_pipe,
 537                             const struct pipe_viewport_state *viewport)
 538 {
 539    struct identity_context *id_pipe = identity_context(_pipe);
 540    struct pipe_context *pipe = id_pipe->pipe;
 541
 542    pipe->set_viewport_state(pipe,
 543                             viewport);
 544 }
 545
 546 static void
 547 identity_set_fragment_sampler_views(struct pipe_context *_pipe,
 548                                     unsigned num,
 549                                     struct pipe_sampler_view **_views)
 550 {
 551    struct identity_context *id_pipe = identity_context(_pipe);
 552    struct pipe_context *pipe = id_pipe->pipe;
 553    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
 554    struct pipe_sampler_view **views = NULL;
 555    unsigned i;
 556
 557    if (_views) {
 558       for (i = 0; i < num; i++)
 559          unwrapped_views[i] = identity_sampler_view_unwrap(_views[i]);
 560       for (; i < PIPE_MAX_SAMPLERS; i++)
 561          unwrapped_views[i] = NULL;
 562
 563       views = unwrapped_views;
 564    }
 565
 566    pipe->set_fragment_sampler_views(pipe, num, views);
 567 }
 568
 569 static void
 570 identity_set_vertex_sampler_views(struct pipe_context *_pipe,
 571                                   unsigned num,
 572                                   struct pipe_sampler_view **_views)
 573 {
 574    struct identity_context *id_pipe = identity_context(_pipe);
 575    struct pipe_context *pipe = id_pipe->pipe;
 576    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
 577    struct pipe_sampler_view **views = NULL;
 578    unsigned i;
 579
 580    if (_views) {
 581       for (i = 0; i < num; i++)
 582          unwrapped_views[i] = identity_sampler_view_unwrap(_views[i]);
 583       for (; i < PIPE_MAX_VERTEX_SAMPLERS; i++)
 584          unwrapped_views[i] = NULL;
 585
 586       views = unwrapped_views;
 587    }
 588
 589    pipe->set_vertex_sampler_views(pipe, num, views);
 590 }
 591
 592 static void
 593 identity_set_vertex_buffers(struct pipe_context *_pipe,
 594                             unsigned num_buffers,
 595                             const struct pipe_vertex_buffer *_buffers)
 596 {
 597    struct identity_context *id_pipe = identity_context(_pipe);
 598    struct pipe_context *pipe = id_pipe->pipe;
 599    struct pipe_vertex_buffer unwrapped_buffers[PIPE_MAX_SHADER_INPUTS];
 600    struct pipe_vertex_buffer *buffers = NULL;
 601    unsigned i;
 602
 603    if (num_buffers) {
 604       memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers));
 605       for (i = 0; i < num_buffers; i++)
 606          unwrapped_buffers[i].buffer = identity_resource_unwrap(_buffers[i].buffer);
 607       buffers = unwrapped_buffers;
 608    }
 609
 610    pipe->set_vertex_buffers(pipe,
 611                             num_buffers,
 612                             buffers);
 613 }
 614 static void
 615 identity_resource_copy_region(struct pipe_context *_pipe,
 616                               struct pipe_resource *_dst,
 617                               struct pipe_subresource subdst,
 618                               unsigned dstx,
 619                               unsigned dsty,
 620                               unsigned dstz,
 621                               struct pipe_resource *_src,
 622                               struct pipe_subresource subsrc,
 623                               unsigned srcx,
 624                               unsigned srcy,
 625                               unsigned srcz,
 626                               unsigned width,
 627                               unsigned height)
 628 {
 629    struct identity_context *id_pipe = identity_context(_pipe);
 630    struct identity_resource *id_resource_dst = identity_resource(_dst);
 631    struct identity_resource *id_resource_src = identity_resource(_src);
 632    struct pipe_context *pipe = id_pipe->pipe;
 633    struct pipe_resource *dst = id_resource_dst->resource;
 634    struct pipe_resource *src = id_resource_src->resource;
 635
 636    pipe->resource_copy_region(pipe,
 637                               dst,
 638                               subdst,
 639                               dstx,
 640                               dsty,
 641                               dstz,
 642                               src,
 643                               subsrc,
 644                               srcx,
 645                               srcy,
 646                               srcz,
 647                               width,
 648                               height);
 649 }
 650
 651 static void
 652 identity_clear(struct pipe_context *_pipe,
 653                unsigned buffers,
 654                const float *rgba,
 655                double depth,
 656                unsigned stencil)
 657 {
 658    struct identity_context *id_pipe = identity_context(_pipe);
 659    struct pipe_context *pipe = id_pipe->pipe;
 660
 661    pipe->clear(pipe,
 662                buffers,
 663                rgba,
 664                depth,
 665                stencil);
 666 }
 667
 668 static void
 669 identity_clear_render_target(struct pipe_context *_pipe,
 670                              struct pipe_surface *_dst,
 671                              const float *rgba,
 672                              unsigned dstx, unsigned dsty,
 673                              unsigned width, unsigned height)
 674 {
 675    struct identity_context *id_pipe = identity_context(_pipe);
 676    struct identity_surface *id_surface_dst = identity_surface(_dst);
 677    struct pipe_context *pipe = id_pipe->pipe;
 678    struct pipe_surface *dst = id_surface_dst->surface;
 679
 680    pipe->clear_render_target(pipe,
 681                              dst,
 682                              rgba,
 683                              dstx,
 684                              dsty,
 685                              width,
 686                              height);
 687 }
 688 static void
 689 identity_clear_depth_stencil(struct pipe_context *_pipe,
 690                              struct pipe_surface *_dst,
 691                              unsigned clear_flags,
 692                              double depth,
 693                              unsigned stencil,
 694                              unsigned dstx, unsigned dsty,
 695                              unsigned width, unsigned height)
 696 {
 697    struct identity_context *id_pipe = identity_context(_pipe);
 698    struct identity_surface *id_surface_dst = identity_surface(_dst);
 699    struct pipe_context *pipe = id_pipe->pipe;
 700    struct pipe_surface *dst = id_surface_dst->surface;
 701
 702    pipe->clear_depth_stencil(pipe,
 703                              dst,
 704                              clear_flags,
 705                              depth,
 706                              stencil,
 707                              dstx,
 708                              dsty,
 709                              width,
 710                              height);
 711
 712 }
 713
 714 static void
 715 identity_flush(struct pipe_context *_pipe,
 716                unsigned flags,
 717                struct pipe_fence_handle **fence)
 718 {
 719    struct identity_context *id_pipe = identity_context(_pipe);
 720    struct pipe_context *pipe = id_pipe->pipe;
 721
 722    pipe->flush(pipe,
 723                flags,
 724                fence);
 725 }
 726
 727 static unsigned int
 728 identity_is_resource_referenced(struct pipe_context *_pipe,
 729                                 struct pipe_resource *_resource,
 730                                 unsigned face,
 731                                 unsigned level)
 732 {
 733    struct identity_context *id_pipe = identity_context(_pipe);
 734    struct identity_resource *id_resource = identity_resource(_resource);
 735    struct pipe_context *pipe = id_pipe->pipe;
 736    struct pipe_resource *resource = id_resource->resource;
 737
 738    return pipe->is_resource_referenced(pipe,
 739                                        resource,
 740                                        face,
 741                                        level);
 742 }
 743
 744 static struct pipe_sampler_view *
 745 identity_context_create_sampler_view(struct pipe_context *_pipe,
 746                                      struct pipe_resource *_resource,
 747                                      const struct pipe_sampler_view *templ)
 748 {
 749    struct identity_context *id_context = identity_context(_pipe);
 750    struct identity_resource *id_resource = identity_resource(_resource);
 751    struct pipe_context *pipe = id_context->pipe;
 752    struct pipe_resource *resource = id_resource->resource;
 753    struct pipe_sampler_view *result;
 754
 755    result = pipe->create_sampler_view(pipe,
 756                                       resource,
 757                                       templ);
 758
 759    if (result)
 760       return identity_sampler_view_create(id_context, id_resource, result);
 761    return NULL;
 762 }
 763
 764 static void
 765 identity_context_sampler_view_destroy(struct pipe_context *_pipe,
 766                                       struct pipe_sampler_view *_view)
 767 {
 768    identity_sampler_view_destroy(identity_context(_pipe),
 769                                  identity_sampler_view(_view));
 770 }
 771
 772 static struct pipe_transfer *
 773 identity_context_get_transfer(struct pipe_context *_context,
 774                               struct pipe_resource *_resource,
 775                               struct pipe_subresource sr,
 776                               unsigned usage,
 777                               const struct pipe_box *box)
 778 {
 779    struct identity_context *id_context = identity_context(_context);
 780    struct identity_resource *id_resource = identity_resource(_resource);
 781    struct pipe_context *context = id_context->pipe;
 782    struct pipe_resource *resource = id_resource->resource;
 783    struct pipe_transfer *result;
 784
 785    result = context->get_transfer(context,
 786                                   resource,
 787                                   sr,
 788                                   usage,
 789                                   box);
 790
 791    if (result)
 792       return identity_transfer_create(id_context, id_resource, result);
 793    return NULL;
 794 }
 795
 796 static void
 797 identity_context_transfer_destroy(struct pipe_context *_pipe,
 798                                   struct pipe_transfer *_transfer)
 799 {
 800    identity_transfer_destroy(identity_context(_pipe),
 801                              identity_transfer(_transfer));
 802 }
 803
 804 static void *
 805 identity_context_transfer_map(struct pipe_context *_context,
 806                               struct pipe_transfer *_transfer)
 807 {
 808    struct identity_context *id_context = identity_context(_context);
 809    struct identity_transfer *id_transfer = identity_transfer(_transfer);
 810    struct pipe_context *context = id_context->pipe;
 811    struct pipe_transfer *transfer = id_transfer->transfer;
 812
 813    return context->transfer_map(context,
 814                                 transfer);
 815 }
 816
 817
 818
 819 static void
 820 identity_context_transfer_flush_region(struct pipe_context *_context,
 821                                        struct pipe_transfer *_transfer,
 822                                        const struct pipe_box *box)
 823 {
 824    struct identity_context *id_context = identity_context(_context);
 825    struct identity_transfer *id_transfer = identity_transfer(_transfer);
 826    struct pipe_context *context = id_context->pipe;
 827    struct pipe_transfer *transfer = id_transfer->transfer;
 828
 829    context->transfer_flush_region(context,
 830                                   transfer,
 831                                   box);
 832 }
 833
 834
 835 static void
 836 identity_context_transfer_unmap(struct pipe_context *_context,
 837                                 struct pipe_transfer *_transfer)
 838 {
 839    struct identity_context *id_context = identity_context(_context);
 840    struct identity_transfer *id_transfer = identity_transfer(_transfer);
 841    struct pipe_context *context = id_context->pipe;
 842    struct pipe_transfer *transfer = id_transfer->transfer;
 843
 844    context->transfer_unmap(context,
 845                            transfer);
 846 }
 847
 848
 849 static void
 850 identity_context_transfer_inline_write(struct pipe_context *_context,
 851                                        struct pipe_resource *_resource,
 852                                        struct pipe_subresource sr,
 853                                        unsigned usage,
 854                                        const struct pipe_box *box,
 855                                        const void *data,
 856                                        unsigned stride,
 857                                        unsigned slice_stride)
 858 {
 859    struct identity_context *id_context = identity_context(_context);
 860    struct identity_resource *id_resource = identity_resource(_resource);
 861    struct pipe_context *context = id_context->pipe;
 862    struct pipe_resource *resource = id_resource->resource;
 863
 864    context->transfer_inline_write(context,
 865                                   resource,
 866                                   sr,
 867                                   usage,
 868                                   box,
 869                                   data,
 870                                   stride,
 871                                   slice_stride);
 872 }
 873
 874
 875 struct pipe_context *
 876 identity_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
 877 {
 878    struct identity_context *id_pipe;
 879    (void)identity_screen(_screen);
 880
 881    id_pipe = CALLOC_STRUCT(identity_context);
 882    if (!id_pipe) {
 883       return NULL;
 884    }
 885
 886    id_pipe->base.winsys = NULL;
 887    id_pipe->base.screen = _screen;
 888    id_pipe->base.priv = pipe->priv; /* expose wrapped data */
 889    id_pipe->base.draw = NULL;
 890
 891    id_pipe->base.destroy = identity_destroy;
 892    id_pipe->base.draw_arrays = identity_draw_arrays;
 893    id_pipe->base.draw_elements = identity_draw_elements;
 894    id_pipe->base.draw_range_elements = identity_draw_range_elements;
 895    id_pipe->base.create_query = identity_create_query;
 896    id_pipe->base.destroy_query = identity_destroy_query;
 897    id_pipe->base.begin_query = identity_begin_query;
 898    id_pipe->base.end_query = identity_end_query;
 899    id_pipe->base.get_query_result = identity_get_query_result;
 900    id_pipe->base.create_blend_state = identity_create_blend_state;
 901    id_pipe->base.bind_blend_state = identity_bind_blend_state;
 902    id_pipe->base.delete_blend_state = identity_delete_blend_state;
 903    id_pipe->base.create_sampler_state = identity_create_sampler_state;
 904    id_pipe->base.bind_fragment_sampler_states = identity_bind_fragment_sampler_states;
 905    id_pipe->base.bind_vertex_sampler_states = identity_bind_vertex_sampler_states;
 906    id_pipe->base.delete_sampler_state = identity_delete_sampler_state;
 907    id_pipe->base.create_rasterizer_state = identity_create_rasterizer_state;
 908    id_pipe->base.bind_rasterizer_state = identity_bind_rasterizer_state;
 909    id_pipe->base.delete_rasterizer_state = identity_delete_rasterizer_state;
 910    id_pipe->base.create_depth_stencil_alpha_state = identity_create_depth_stencil_alpha_state;
 911    id_pipe->base.bind_depth_stencil_alpha_state = identity_bind_depth_stencil_alpha_state;
 912    id_pipe->base.delete_depth_stencil_alpha_state = identity_delete_depth_stencil_alpha_state;
 913    id_pipe->base.create_fs_state = identity_create_fs_state;
 914    id_pipe->base.bind_fs_state = identity_bind_fs_state;
 915    id_pipe->base.delete_fs_state = identity_delete_fs_state;
 916    id_pipe->base.create_vs_state = identity_create_vs_state;
 917    id_pipe->base.bind_vs_state = identity_bind_vs_state;
 918    id_pipe->base.delete_vs_state = identity_delete_vs_state;
 919    id_pipe->base.create_vertex_elements_state = identity_create_vertex_elements_state;
 920    id_pipe->base.bind_vertex_elements_state = identity_bind_vertex_elements_state;
 921    id_pipe->base.delete_vertex_elements_state = identity_delete_vertex_elements_state;
 922    id_pipe->base.set_blend_color = identity_set_blend_color;
 923    id_pipe->base.set_stencil_ref = identity_set_stencil_ref;
 924    id_pipe->base.set_clip_state = identity_set_clip_state;
 925    id_pipe->base.set_sample_mask = identity_set_sample_mask;
 926    id_pipe->base.set_constant_buffer = identity_set_constant_buffer;
 927    id_pipe->base.set_framebuffer_state = identity_set_framebuffer_state;
 928    id_pipe->base.set_polygon_stipple = identity_set_polygon_stipple;
 929    id_pipe->base.set_scissor_state = identity_set_scissor_state;
 930    id_pipe->base.set_viewport_state = identity_set_viewport_state;
 931    id_pipe->base.set_fragment_sampler_views = identity_set_fragment_sampler_views;
 932    id_pipe->base.set_vertex_sampler_views = identity_set_vertex_sampler_views;
 933    id_pipe->base.set_vertex_buffers = identity_set_vertex_buffers;
 934    id_pipe->base.resource_copy_region = identity_resource_copy_region;
 935    id_pipe->base.clear = identity_clear;
 936    id_pipe->base.clear_render_target = identity_clear_render_target;
 937    id_pipe->base.clear_depth_stencil = identity_clear_depth_stencil;
 938    id_pipe->base.flush = identity_flush;
 939    id_pipe->base.is_resource_referenced = identity_is_resource_referenced;
 940    id_pipe->base.create_sampler_view = identity_context_create_sampler_view;
 941    id_pipe->base.sampler_view_destroy = identity_context_sampler_view_destroy;
 942    id_pipe->base.get_transfer = identity_context_get_transfer;
 943    id_pipe->base.transfer_destroy = identity_context_transfer_destroy;
 944    id_pipe->base.transfer_map = identity_context_transfer_map;
 945    id_pipe->base.transfer_unmap = identity_context_transfer_unmap;
 946    id_pipe->base.transfer_flush_region = identity_context_transfer_flush_region;
 947    id_pipe->base.transfer_inline_write = identity_context_transfer_inline_write;
 948
 949    id_pipe->pipe = pipe;
 950
 951    return &id_pipe->base;
 952 }