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
  32 #include "id_public.h"
  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 boolean
  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    return pipe->draw_arrays(pipe,
  58                             prim,
  59                             start,
  60                             count);
  61 }
  62
  63 static boolean
  64 identity_draw_elements(struct pipe_context *_pipe,
  65                        struct pipe_buffer *_indexBuffer,
  66                        unsigned indexSize,
  67                        unsigned prim,
  68                        unsigned start,
  69                        unsigned count)
  70 {
  71    struct identity_context *id_pipe = identity_context(_pipe);
  72    struct identity_buffer *id_buffer = identity_buffer(_indexBuffer);
  73    struct pipe_context *pipe = id_pipe->pipe;
  74    struct pipe_buffer *indexBuffer = id_buffer->buffer;
  75
  76    return pipe->draw_elements(pipe,
  77                               indexBuffer,
  78                               indexSize,
  79                               prim,
  80                               start,
  81                               count);
  82 }
  83
  84 static boolean
  85 identity_draw_range_elements(struct pipe_context *_pipe,
  86                              struct pipe_buffer *_indexBuffer,
  87                              unsigned indexSize,
  88                              unsigned minIndex,
  89                              unsigned maxIndex,
  90                              unsigned mode,
  91                              unsigned start,
  92                              unsigned count)
  93 {
  94    struct identity_context *id_pipe = identity_context(_pipe);
  95    struct identity_buffer *id_buffer = identity_buffer(_indexBuffer);
  96    struct pipe_context *pipe = id_pipe->pipe;
  97    struct pipe_buffer *indexBuffer = id_buffer->buffer;
  98
  99    return pipe->draw_range_elements(pipe,
 100                                     indexBuffer,
 101                                     indexSize,
 102                                     minIndex,
 103                                     maxIndex,
 104                                     mode,
 105                                     start,
 106                                     count);
 107 }
 108
 109 static struct pipe_query *
 110 identity_create_query(struct pipe_context *_pipe,
 111                       unsigned query_type)
 112 {
 113    struct identity_context *id_pipe = identity_context(_pipe);
 114    struct pipe_context *pipe = id_pipe->pipe;
 115
 116    return pipe->create_query(pipe,
 117                              query_type);
 118 }
 119
 120 static void
 121 identity_destroy_query(struct pipe_context *_pipe,
 122                        struct pipe_query *query)
 123 {
 124    struct identity_context *id_pipe = identity_context(_pipe);
 125    struct pipe_context *pipe = id_pipe->pipe;
 126
 127    pipe->destroy_query(pipe,
 128                        query);
 129 }
 130
 131 static void
 132 identity_begin_query(struct pipe_context *_pipe,
 133                      struct pipe_query *query)
 134 {
 135    struct identity_context *id_pipe = identity_context(_pipe);
 136    struct pipe_context *pipe = id_pipe->pipe;
 137
 138    pipe->begin_query(pipe,
 139                      query);
 140 }
 141
 142 static void
 143 identity_end_query(struct pipe_context *_pipe,
 144                    struct pipe_query *query)
 145 {
 146    struct identity_context *id_pipe = identity_context(_pipe);
 147    struct pipe_context *pipe = id_pipe->pipe;
 148
 149    pipe->end_query(pipe,
 150                    query);
 151 }
 152
 153 static boolean
 154 identity_get_query_result(struct pipe_context *_pipe,
 155                           struct pipe_query *query,
 156                           boolean wait,
 157                           uint64_t *result)
 158 {
 159    struct identity_context *id_pipe = identity_context(_pipe);
 160    struct pipe_context *pipe = id_pipe->pipe;
 161
 162    return pipe->get_query_result(pipe,
 163                                  query,
 164                                  wait,
 165                                  result);
 166 }
 167
 168 static void *
 169 identity_create_blend_state(struct pipe_context *_pipe,
 170                             const struct pipe_blend_state *blend)
 171 {
 172    struct identity_context *id_pipe = identity_context(_pipe);
 173    struct pipe_context *pipe = id_pipe->pipe;
 174
 175    return pipe->create_blend_state(pipe,
 176                                    blend);
 177 }
 178
 179 static void
 180 identity_bind_blend_state(struct pipe_context *_pipe,
 181                           void *blend)
 182 {
 183    struct identity_context *id_pipe = identity_context(_pipe);
 184    struct pipe_context *pipe = id_pipe->pipe;
 185
 186    pipe->bind_blend_state(pipe,
 187                               blend);
 188 }
 189
 190 static void
 191 identity_delete_blend_state(struct pipe_context *_pipe,
 192                             void *blend)
 193 {
 194    struct identity_context *id_pipe = identity_context(_pipe);
 195    struct pipe_context *pipe = id_pipe->pipe;
 196
 197    pipe->delete_blend_state(pipe,
 198                             blend);
 199 }
 200
 201 static void *
 202 identity_create_sampler_state(struct pipe_context *_pipe,
 203                               const struct pipe_sampler_state *sampler)
 204 {
 205    struct identity_context *id_pipe = identity_context(_pipe);
 206    struct pipe_context *pipe = id_pipe->pipe;
 207
 208    return pipe->create_sampler_state(pipe,
 209                                      sampler);
 210 }
 211
 212 static void
 213 identity_bind_fragment_sampler_states(struct pipe_context *_pipe,
 214                                       unsigned num_samplers,
 215                                       void **samplers)
 216 {
 217    struct identity_context *id_pipe = identity_context(_pipe);
 218    struct pipe_context *pipe = id_pipe->pipe;
 219
 220    pipe->bind_fragment_sampler_states(pipe,
 221                                       num_samplers,
 222                                       samplers);
 223 }
 224
 225 static void
 226 identity_bind_vertex_sampler_states(struct pipe_context *_pipe,
 227                                     unsigned num_samplers,
 228                                     void **samplers)
 229 {
 230    struct identity_context *id_pipe = identity_context(_pipe);
 231    struct pipe_context *pipe = id_pipe->pipe;
 232
 233    pipe->bind_vertex_sampler_states(pipe,
 234                                     num_samplers,
 235                                     samplers);
 236 }
 237
 238 static void
 239 identity_delete_sampler_state(struct pipe_context *_pipe,
 240                               void *sampler)
 241 {
 242    struct identity_context *id_pipe = identity_context(_pipe);
 243    struct pipe_context *pipe = id_pipe->pipe;
 244
 245    pipe->delete_sampler_state(pipe,
 246                               sampler);
 247 }
 248
 249 static void *
 250 identity_create_rasterizer_state(struct pipe_context *_pipe,
 251                                  const struct pipe_rasterizer_state *rasterizer)
 252 {
 253    struct identity_context *id_pipe = identity_context(_pipe);
 254    struct pipe_context *pipe = id_pipe->pipe;
 255
 256    return pipe->create_rasterizer_state(pipe,
 257                                         rasterizer);
 258 }
 259
 260 static void
 261 identity_bind_rasterizer_state(struct pipe_context *_pipe,
 262                                void *rasterizer)
 263 {
 264    struct identity_context *id_pipe = identity_context(_pipe);
 265    struct pipe_context *pipe = id_pipe->pipe;
 266
 267    pipe->bind_rasterizer_state(pipe,
 268                                rasterizer);
 269 }
 270
 271 static void
 272 identity_delete_rasterizer_state(struct pipe_context *_pipe,
 273                                  void *rasterizer)
 274 {
 275    struct identity_context *id_pipe = identity_context(_pipe);
 276    struct pipe_context *pipe = id_pipe->pipe;
 277
 278    pipe->delete_rasterizer_state(pipe,
 279                                  rasterizer);
 280 }
 281
 282 static void *
 283 identity_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
 284                                           const struct pipe_depth_stencil_alpha_state *depth_stencil_alpha)
 285 {
 286    struct identity_context *id_pipe = identity_context(_pipe);
 287    struct pipe_context *pipe = id_pipe->pipe;
 288
 289    return pipe->create_depth_stencil_alpha_state(pipe,
 290                                                  depth_stencil_alpha);
 291 }
 292
 293 static void
 294 identity_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
 295                                         void *depth_stencil_alpha)
 296 {
 297    struct identity_context *id_pipe = identity_context(_pipe);
 298    struct pipe_context *pipe = id_pipe->pipe;
 299
 300    pipe->bind_depth_stencil_alpha_state(pipe,
 301                                         depth_stencil_alpha);
 302 }
 303
 304 static void
 305 identity_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
 306                                           void *depth_stencil_alpha)
 307 {
 308    struct identity_context *id_pipe = identity_context(_pipe);
 309    struct pipe_context *pipe = id_pipe->pipe;
 310
 311    pipe->delete_depth_stencil_alpha_state(pipe,
 312                                           depth_stencil_alpha);
 313 }
 314
 315 static void *
 316 identity_create_fs_state(struct pipe_context *_pipe,
 317                          const struct pipe_shader_state *fs)
 318 {
 319    struct identity_context *id_pipe = identity_context(_pipe);
 320    struct pipe_context *pipe = id_pipe->pipe;
 321
 322    return pipe->create_fs_state(pipe,
 323                                 fs);
 324 }
 325
 326 static void
 327 identity_bind_fs_state(struct pipe_context *_pipe,
 328                        void *fs)
 329 {
 330    struct identity_context *id_pipe = identity_context(_pipe);
 331    struct pipe_context *pipe = id_pipe->pipe;
 332
 333    pipe->bind_fs_state(pipe,
 334                        fs);
 335 }
 336
 337 static void
 338 identity_delete_fs_state(struct pipe_context *_pipe,
 339                          void *fs)
 340 {
 341    struct identity_context *id_pipe = identity_context(_pipe);
 342    struct pipe_context *pipe = id_pipe->pipe;
 343
 344    pipe->delete_fs_state(pipe,
 345                          fs);
 346 }
 347
 348 static void *
 349 identity_create_vs_state(struct pipe_context *_pipe,
 350                          const struct pipe_shader_state *vs)
 351 {
 352    struct identity_context *id_pipe = identity_context(_pipe);
 353    struct pipe_context *pipe = id_pipe->pipe;
 354
 355    return pipe->create_vs_state(pipe,
 356                                 vs);
 357 }
 358
 359 static void
 360 identity_bind_vs_state(struct pipe_context *_pipe,
 361                        void *vs)
 362 {
 363    struct identity_context *id_pipe = identity_context(_pipe);
 364    struct pipe_context *pipe = id_pipe->pipe;
 365
 366    pipe->bind_vs_state(pipe,
 367                        vs);
 368 }
 369
 370 static void
 371 identity_delete_vs_state(struct pipe_context *_pipe,
 372                          void *vs)
 373 {
 374    struct identity_context *id_pipe = identity_context(_pipe);
 375    struct pipe_context *pipe = id_pipe->pipe;
 376
 377    pipe->delete_vs_state(pipe,
 378                          vs);
 379 }
 380
 381 static void
 382 identity_set_blend_color(struct pipe_context *_pipe,
 383                          const struct pipe_blend_color *blend_color)
 384 {
 385    struct identity_context *id_pipe = identity_context(_pipe);
 386    struct pipe_context *pipe = id_pipe->pipe;
 387
 388    pipe->set_blend_color(pipe,
 389                          blend_color);
 390 }
 391
 392 static void
 393 identity_set_clip_state(struct pipe_context *_pipe,
 394                         const struct pipe_clip_state *clip)
 395 {
 396    struct identity_context *id_pipe = identity_context(_pipe);
 397    struct pipe_context *pipe = id_pipe->pipe;
 398
 399    pipe->set_clip_state(pipe,
 400                         clip);
 401 }
 402
 403 static void
 404 identity_set_constant_buffer(struct pipe_context *_pipe,
 405                              uint shader,
 406                              uint index,
 407                              struct pipe_buffer *_buffer)
 408 {
 409    struct identity_context *id_pipe = identity_context(_pipe);
 410    struct pipe_context *pipe = id_pipe->pipe;
 411    struct pipe_buffer *unwrapped_buffer;
 412    struct pipe_buffer *buffer = NULL;
 413
 414    /* XXX hmm? unwrap the input state */
 415    if (_buffer) {
 416       unwrapped_buffer = identity_buffer_unwrap(_buffer);
 417       buffer = unwrapped_buffer;
 418    }
 419
 420    pipe->set_constant_buffer(pipe,
 421                              shader,
 422                              index,
 423                              buffer);
 424 }
 425
 426 static void
 427 identity_set_framebuffer_state(struct pipe_context *_pipe,
 428                                const struct pipe_framebuffer_state *_state)
 429 {
 430    struct identity_context *id_pipe = identity_context(_pipe);
 431    struct pipe_context *pipe = id_pipe->pipe;
 432    struct pipe_framebuffer_state unwrapped_state;
 433    struct pipe_framebuffer_state *state = NULL;
 434    unsigned i;
 435
 436    /* unwrap the input state */
 437    if (_state) {
 438       memcpy(&unwrapped_state, _state, sizeof(unwrapped_state));
 439       for(i = 0; i < _state->nr_cbufs; i++)
 440          unwrapped_state.cbufs[i] = identity_surface_unwrap(_state->cbufs[i]);
 441       for (; i < PIPE_MAX_COLOR_BUFS; i++)
 442          unwrapped_state.cbufs[i] = NULL;
 443       unwrapped_state.zsbuf = identity_surface_unwrap(_state->zsbuf);
 444       state = &unwrapped_state;
 445    }
 446
 447    pipe->set_framebuffer_state(pipe,
 448                                state);
 449 }
 450
 451 static void
 452 identity_set_polygon_stipple(struct pipe_context *_pipe,
 453                              const struct pipe_poly_stipple *poly_stipple)
 454 {
 455    struct identity_context *id_pipe = identity_context(_pipe);
 456    struct pipe_context *pipe = id_pipe->pipe;
 457
 458    pipe->set_polygon_stipple(pipe,
 459                              poly_stipple);
 460 }
 461
 462 static void
 463 identity_set_scissor_state(struct pipe_context *_pipe,
 464                            const struct pipe_scissor_state *scissor)
 465 {
 466    struct identity_context *id_pipe = identity_context(_pipe);
 467    struct pipe_context *pipe = id_pipe->pipe;
 468
 469    pipe->set_scissor_state(pipe,
 470                            scissor);
 471 }
 472
 473 static void
 474 identity_set_viewport_state(struct pipe_context *_pipe,
 475                             const struct pipe_viewport_state *viewport)
 476 {
 477    struct identity_context *id_pipe = identity_context(_pipe);
 478    struct pipe_context *pipe = id_pipe->pipe;
 479
 480    pipe->set_viewport_state(pipe,
 481                             viewport);
 482 }
 483
 484 static void
 485 identity_set_fragment_sampler_textures(struct pipe_context *_pipe,
 486                                        unsigned num_textures,
 487                                        struct pipe_texture **_textures)
 488 {
 489    struct identity_context *id_pipe = identity_context(_pipe);
 490    struct pipe_context *pipe = id_pipe->pipe;
 491    struct pipe_texture *unwrapped_textures[PIPE_MAX_SAMPLERS];
 492    struct pipe_texture **textures = NULL;
 493    unsigned i;
 494
 495    if (_textures) {
 496       for (i = 0; i < num_textures; i++)
 497          unwrapped_textures[i] = identity_texture_unwrap(_textures[i]);
 498       for (; i < PIPE_MAX_SAMPLERS; i++)
 499          unwrapped_textures[i] = NULL;
 500
 501       textures = unwrapped_textures;
 502    }
 503
 504    pipe->set_fragment_sampler_textures(pipe,
 505                                        num_textures,
 506                                        textures);
 507 }
 508
 509 static void
 510 identity_set_vertex_sampler_textures(struct pipe_context *_pipe,
 511                                      unsigned num_textures,
 512                                      struct pipe_texture **_textures)
 513 {
 514    struct identity_context *id_pipe = identity_context(_pipe);
 515    struct pipe_context *pipe = id_pipe->pipe;
 516    struct pipe_texture *unwrapped_textures[PIPE_MAX_VERTEX_SAMPLERS];
 517    struct pipe_texture **textures = NULL;
 518    unsigned i;
 519
 520    if (_textures) {
 521       for (i = 0; i < num_textures; i++)
 522          unwrapped_textures[i] = identity_texture_unwrap(_textures[i]);
 523       for (; i < PIPE_MAX_VERTEX_SAMPLERS; i++)
 524          unwrapped_textures[i] = NULL;
 525
 526       textures = unwrapped_textures;
 527    }
 528
 529    pipe->set_vertex_sampler_textures(pipe,
 530                                      num_textures,
 531                                      textures);
 532 }
 533
 534 static void
 535 identity_set_vertex_buffers(struct pipe_context *_pipe,
 536                             unsigned num_buffers,
 537                             const struct pipe_vertex_buffer *_buffers)
 538 {
 539    struct identity_context *id_pipe = identity_context(_pipe);
 540    struct pipe_context *pipe = id_pipe->pipe;
 541    struct pipe_vertex_buffer unwrapped_buffers[PIPE_MAX_SHADER_INPUTS];
 542    struct pipe_vertex_buffer *buffers = NULL;
 543    unsigned i;
 544
 545    if (num_buffers) {
 546       memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers));
 547       for (i = 0; i < num_buffers; i++)
 548          unwrapped_buffers[i].buffer = identity_buffer_unwrap(_buffers[i].buffer);
 549       buffers = unwrapped_buffers;
 550    }
 551
 552    pipe->set_vertex_buffers(pipe,
 553                             num_buffers,
 554                             buffers);
 555 }
 556
 557 static void
 558 identity_set_vertex_elements(struct pipe_context *_pipe,
 559                              unsigned num_elements,
 560                              const struct pipe_vertex_element *vertex_elements)
 561 {
 562    struct identity_context *id_pipe = identity_context(_pipe);
 563    struct pipe_context *pipe = id_pipe->pipe;
 564
 565    pipe->set_vertex_elements(pipe,
 566                              num_elements,
 567                              vertex_elements);
 568 }
 569
 570 static void
 571 identity_surface_copy(struct pipe_context *_pipe,
 572                       struct pipe_surface *_dst,
 573                       unsigned dstx,
 574                       unsigned dsty,
 575                       struct pipe_surface *_src,
 576                       unsigned srcx,
 577                       unsigned srcy,
 578                       unsigned width,
 579                       unsigned height)
 580 {
 581    struct identity_context *id_pipe = identity_context(_pipe);
 582    struct identity_surface *id_surface_dst = identity_surface(_dst);
 583    struct identity_surface *id_surface_src = identity_surface(_src);
 584    struct pipe_context *pipe = id_pipe->pipe;
 585    struct pipe_surface *dst = id_surface_dst->surface;
 586    struct pipe_surface *src = id_surface_src->surface;
 587
 588    pipe->surface_copy(pipe,
 589                       dst,
 590                       dstx,
 591                       dsty,
 592                       src,
 593                       srcx,
 594                       srcy,
 595                       width,
 596                       height);
 597 }
 598
 599 static void
 600 identity_surface_fill(struct pipe_context *_pipe,
 601                       struct pipe_surface *_dst,
 602                       unsigned dstx,
 603                       unsigned dsty,
 604                       unsigned width,
 605                       unsigned height,
 606                       unsigned value)
 607 {
 608    struct identity_context *id_pipe = identity_context(_pipe);
 609    struct identity_surface *id_surface_dst = identity_surface(_dst);
 610    struct pipe_context *pipe = id_pipe->pipe;
 611    struct pipe_surface *dst = id_surface_dst->surface;
 612
 613    pipe->surface_fill(pipe,
 614                       dst,
 615                       dstx,
 616                       dsty,
 617                       width,
 618                       height,
 619                       value);
 620 }
 621
 622 static void
 623 identity_clear(struct pipe_context *_pipe,
 624                unsigned buffers,
 625                const float *rgba,
 626                double depth,
 627                unsigned stencil)
 628 {
 629    struct identity_context *id_pipe = identity_context(_pipe);
 630    struct pipe_context *pipe = id_pipe->pipe;
 631
 632    pipe->clear(pipe,
 633                buffers,
 634                rgba,
 635                depth,
 636                stencil);
 637 }
 638
 639 static void
 640 identity_flush(struct pipe_context *_pipe,
 641                unsigned flags,
 642                struct pipe_fence_handle **fence)
 643 {
 644    struct identity_context *id_pipe = identity_context(_pipe);
 645    struct pipe_context *pipe = id_pipe->pipe;
 646
 647    pipe->flush(pipe,
 648                flags,
 649                fence);
 650 }
 651
 652 static unsigned int
 653 identity_is_texture_referenced(struct pipe_context *_pipe,
 654                                struct pipe_texture *_texture,
 655                                unsigned face,
 656                                unsigned level)
 657 {
 658    struct identity_context *id_pipe = identity_context(_pipe);
 659    struct identity_texture *id_texture = identity_texture(_texture);
 660    struct pipe_context *pipe = id_pipe->pipe;
 661    struct pipe_texture *texture = id_texture->texture;
 662
 663    return pipe->is_texture_referenced(pipe,
 664                                       texture,
 665                                       face,
 666                                       level);
 667 }
 668
 669 static unsigned int
 670 identity_is_buffer_referenced(struct pipe_context *_pipe,
 671                               struct pipe_buffer *_buffer)
 672 {
 673    struct identity_context *id_pipe = identity_context(_pipe);
 674    struct identity_buffer *id_buffer = identity_buffer(_buffer);
 675    struct pipe_context *pipe = id_pipe->pipe;
 676    struct pipe_buffer *buffer = id_buffer->buffer;
 677
 678    return pipe->is_buffer_referenced(pipe,
 679                                      buffer);
 680 }
 681
 682 struct pipe_context *
 683 identity_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
 684 {
 685    struct identity_context *id_pipe;
 686    (void)identity_screen(_screen);
 687
 688    id_pipe = CALLOC_STRUCT(identity_context);
 689    if (!id_pipe) {
 690       return NULL;
 691    }
 692
 693    id_pipe->base.winsys = NULL;
 694    id_pipe->base.screen = _screen;
 695    id_pipe->base.priv = pipe->priv;
 696    id_pipe->base.draw = NULL;
 697
 698    id_pipe->base.destroy = identity_destroy;
 699    id_pipe->base.draw_arrays = identity_draw_arrays;
 700    id_pipe->base.draw_elements = identity_draw_elements;
 701    id_pipe->base.draw_range_elements = identity_draw_range_elements;
 702    id_pipe->base.create_query = identity_create_query;
 703    id_pipe->base.destroy_query = identity_destroy_query;
 704    id_pipe->base.begin_query = identity_begin_query;
 705    id_pipe->base.end_query = identity_end_query;
 706    id_pipe->base.get_query_result = identity_get_query_result;
 707    id_pipe->base.create_blend_state = identity_create_blend_state;
 708    id_pipe->base.bind_blend_state = identity_bind_blend_state;
 709    id_pipe->base.delete_blend_state = identity_delete_blend_state;
 710    id_pipe->base.create_sampler_state = identity_create_sampler_state;
 711    id_pipe->base.bind_fragment_sampler_states = identity_bind_fragment_sampler_states;
 712    id_pipe->base.bind_vertex_sampler_states = identity_bind_vertex_sampler_states;
 713    id_pipe->base.delete_sampler_state = identity_delete_sampler_state;
 714    id_pipe->base.create_rasterizer_state = identity_create_rasterizer_state;
 715    id_pipe->base.bind_rasterizer_state = identity_bind_rasterizer_state;
 716    id_pipe->base.delete_rasterizer_state = identity_delete_rasterizer_state;
 717    id_pipe->base.create_depth_stencil_alpha_state = identity_create_depth_stencil_alpha_state;
 718    id_pipe->base.bind_depth_stencil_alpha_state = identity_bind_depth_stencil_alpha_state;
 719    id_pipe->base.delete_depth_stencil_alpha_state = identity_delete_depth_stencil_alpha_state;
 720    id_pipe->base.create_fs_state = identity_create_fs_state;
 721    id_pipe->base.bind_fs_state = identity_bind_fs_state;
 722    id_pipe->base.delete_fs_state = identity_delete_fs_state;
 723    id_pipe->base.create_vs_state = identity_create_vs_state;
 724    id_pipe->base.bind_vs_state = identity_bind_vs_state;
 725    id_pipe->base.delete_vs_state = identity_delete_vs_state;
 726    id_pipe->base.set_blend_color = identity_set_blend_color;
 727    id_pipe->base.set_clip_state = identity_set_clip_state;
 728    id_pipe->base.set_constant_buffer = identity_set_constant_buffer;
 729    id_pipe->base.set_framebuffer_state = identity_set_framebuffer_state;
 730    id_pipe->base.set_polygon_stipple = identity_set_polygon_stipple;
 731    id_pipe->base.set_scissor_state = identity_set_scissor_state;
 732    id_pipe->base.set_viewport_state = identity_set_viewport_state;
 733    id_pipe->base.set_fragment_sampler_textures = identity_set_fragment_sampler_textures;
 734    id_pipe->base.set_vertex_sampler_textures = identity_set_vertex_sampler_textures;
 735    id_pipe->base.set_vertex_buffers = identity_set_vertex_buffers;
 736    id_pipe->base.set_vertex_elements = identity_set_vertex_elements;
 737    id_pipe->base.surface_copy = identity_surface_copy;
 738    id_pipe->base.surface_fill = identity_surface_fill;
 739    id_pipe->base.clear = identity_clear;
 740    id_pipe->base.flush = identity_flush;
 741    id_pipe->base.is_texture_referenced = identity_is_texture_referenced;
 742    id_pipe->base.is_buffer_referenced = identity_is_buffer_referenced;
 743
 744    id_pipe->pipe = pipe;
 745
 746    return &id_pipe->base;
 747 }