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