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