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