Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /**************************************************************************
  2.  *
  3.  * Copyright 2010 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. #include "util/u_simple_list.h"
  33.  
  34. #include "rbug/rbug_context.h"
  35.  
  36. #include "rbug_context.h"
  37. #include "rbug_objects.h"
  38.  
  39.  
  40. static void
  41. rbug_destroy(struct pipe_context *_pipe)
  42. {
  43.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  44.    struct pipe_context *pipe = rb_pipe->pipe;
  45.  
  46.    remove_from_list(&rb_pipe->list);
  47.    pipe_mutex_lock(rb_pipe->call_mutex);
  48.    pipe->destroy(pipe);
  49.    rb_pipe->pipe = NULL;
  50.    pipe_mutex_unlock(rb_pipe->call_mutex);
  51.  
  52.    FREE(rb_pipe);
  53. }
  54.  
  55. static void
  56. rbug_draw_block_locked(struct rbug_context *rb_pipe, int flag)
  57. {
  58.  
  59.    if (rb_pipe->draw_blocker & flag) {
  60.       rb_pipe->draw_blocked |= flag;
  61.    } else if ((rb_pipe->draw_rule.blocker & flag) &&
  62.               (rb_pipe->draw_blocker & RBUG_BLOCK_RULE)) {
  63.       unsigned k;
  64.       boolean block = FALSE;
  65.       unsigned sh;
  66.  
  67.       debug_printf("%s (%p %p) (%p %p) (%p %u) (%p %u)\n", __FUNCTION__,
  68.                    (void *) rb_pipe->draw_rule.shader[PIPE_SHADER_FRAGMENT],
  69.                    (void *) rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT],
  70.                    (void *) rb_pipe->draw_rule.shader[PIPE_SHADER_VERTEX],
  71.                    (void *) rb_pipe->curr.shader[PIPE_SHADER_VERTEX],
  72.                    (void *) rb_pipe->draw_rule.surf, 0,
  73.                    (void *) rb_pipe->draw_rule.texture, 0);
  74.       for (sh = 0; sh < PIPE_SHADER_TYPES; sh++) {
  75.          if (rb_pipe->draw_rule.shader[sh] &&
  76.              rb_pipe->draw_rule.shader[sh] == rb_pipe->curr.shader[sh])
  77.             block = TRUE;
  78.       }
  79.  
  80.       if (rb_pipe->draw_rule.surf &&
  81.           rb_pipe->draw_rule.surf == rb_pipe->curr.zsbuf)
  82.             block = TRUE;
  83.       if (rb_pipe->draw_rule.surf)
  84.          for (k = 0; k < rb_pipe->curr.nr_cbufs; k++)
  85.             if (rb_pipe->draw_rule.surf == rb_pipe->curr.cbufs[k])
  86.                block = TRUE;
  87.       if (rb_pipe->draw_rule.texture) {
  88.          for (sh = 0; sh < Elements(rb_pipe->curr.num_views); sh++) {
  89.             for (k = 0; k < rb_pipe->curr.num_views[sh]; k++) {
  90.                if (rb_pipe->draw_rule.texture == rb_pipe->curr.texs[sh][k]) {
  91.                   block = TRUE;
  92.                   sh = PIPE_SHADER_TYPES; /* to break out of both loops */
  93.                   break;
  94.                }
  95.             }
  96.          }
  97.       }
  98.  
  99.       if (block)
  100.          rb_pipe->draw_blocked |= (flag | RBUG_BLOCK_RULE);
  101.    }
  102.  
  103.    if (rb_pipe->draw_blocked)
  104.       rbug_notify_draw_blocked(rb_pipe);
  105.  
  106.    /* wait for rbug to clear the blocked flag */
  107.    while (rb_pipe->draw_blocked & flag) {
  108.       rb_pipe->draw_blocked |= flag;
  109.       pipe_condvar_wait(rb_pipe->draw_cond, rb_pipe->draw_mutex);
  110.    }
  111.  
  112. }
  113.  
  114. static void
  115. rbug_draw_vbo(struct pipe_context *_pipe, const struct pipe_draw_info *info)
  116. {
  117.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  118.    struct pipe_context *pipe = rb_pipe->pipe;
  119.  
  120.    pipe_mutex_lock(rb_pipe->draw_mutex);
  121.    rbug_draw_block_locked(rb_pipe, RBUG_BLOCK_BEFORE);
  122.  
  123.    pipe_mutex_lock(rb_pipe->call_mutex);
  124.    /* XXX loop over PIPE_SHADER_x here */
  125.    if (!(rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT] && rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT]->disabled) &&
  126.        !(rb_pipe->curr.shader[PIPE_SHADER_GEOMETRY] && rb_pipe->curr.shader[PIPE_SHADER_GEOMETRY]->disabled) &&
  127.        !(rb_pipe->curr.shader[PIPE_SHADER_VERTEX] && rb_pipe->curr.shader[PIPE_SHADER_VERTEX]->disabled))
  128.       pipe->draw_vbo(pipe, info);
  129.    pipe_mutex_unlock(rb_pipe->call_mutex);
  130.  
  131.    rbug_draw_block_locked(rb_pipe, RBUG_BLOCK_AFTER);
  132.    pipe_mutex_unlock(rb_pipe->draw_mutex);
  133. }
  134.  
  135. static struct pipe_query *
  136. rbug_create_query(struct pipe_context *_pipe,
  137.                   unsigned query_type)
  138. {
  139.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  140.    struct pipe_context *pipe = rb_pipe->pipe;
  141.  
  142.    pipe_mutex_lock(rb_pipe->call_mutex);
  143.    return pipe->create_query(pipe,
  144.                              query_type);
  145.    pipe_mutex_unlock(rb_pipe->call_mutex);
  146. }
  147.  
  148. static void
  149. rbug_destroy_query(struct pipe_context *_pipe,
  150.                    struct pipe_query *query)
  151. {
  152.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  153.    struct pipe_context *pipe = rb_pipe->pipe;
  154.  
  155.    pipe_mutex_lock(rb_pipe->call_mutex);
  156.    pipe->destroy_query(pipe,
  157.                        query);
  158.    pipe_mutex_unlock(rb_pipe->call_mutex);
  159. }
  160.  
  161. static void
  162. rbug_begin_query(struct pipe_context *_pipe,
  163.                  struct pipe_query *query)
  164. {
  165.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  166.    struct pipe_context *pipe = rb_pipe->pipe;
  167.  
  168.    pipe_mutex_lock(rb_pipe->call_mutex);
  169.    pipe->begin_query(pipe,
  170.                      query);
  171.    pipe_mutex_unlock(rb_pipe->call_mutex);
  172. }
  173.  
  174. static void
  175. rbug_end_query(struct pipe_context *_pipe,
  176.                struct pipe_query *query)
  177. {
  178.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  179.    struct pipe_context *pipe = rb_pipe->pipe;
  180.  
  181.    pipe_mutex_lock(rb_pipe->call_mutex);
  182.    pipe->end_query(pipe,
  183.                    query);
  184.    pipe_mutex_unlock(rb_pipe->call_mutex);
  185. }
  186.  
  187. static boolean
  188. rbug_get_query_result(struct pipe_context *_pipe,
  189.                       struct pipe_query *query,
  190.                       boolean wait,
  191.                       union pipe_query_result *result)
  192. {
  193.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  194.    struct pipe_context *pipe = rb_pipe->pipe;
  195.    boolean ret;
  196.  
  197.    pipe_mutex_lock(rb_pipe->call_mutex);
  198.    ret = pipe->get_query_result(pipe,
  199.                                 query,
  200.                                 wait,
  201.                                 result);
  202.    pipe_mutex_unlock(rb_pipe->call_mutex);
  203.  
  204.    return ret;
  205. }
  206.  
  207. static void *
  208. rbug_create_blend_state(struct pipe_context *_pipe,
  209.                         const struct pipe_blend_state *blend)
  210. {
  211.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  212.    struct pipe_context *pipe = rb_pipe->pipe;
  213.    void *ret;
  214.  
  215.    pipe_mutex_lock(rb_pipe->call_mutex);
  216.    ret = pipe->create_blend_state(pipe,
  217.                                   blend);
  218.    pipe_mutex_unlock(rb_pipe->call_mutex);
  219.  
  220.    return ret;
  221. }
  222.  
  223. static void
  224. rbug_bind_blend_state(struct pipe_context *_pipe,
  225.                       void *blend)
  226. {
  227.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  228.    struct pipe_context *pipe = rb_pipe->pipe;
  229.  
  230.    pipe_mutex_lock(rb_pipe->call_mutex);
  231.    pipe->bind_blend_state(pipe,
  232.                           blend);
  233.    pipe_mutex_unlock(rb_pipe->call_mutex);
  234. }
  235.  
  236. static void
  237. rbug_delete_blend_state(struct pipe_context *_pipe,
  238.                         void *blend)
  239. {
  240.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  241.    struct pipe_context *pipe = rb_pipe->pipe;
  242.  
  243.    pipe_mutex_lock(rb_pipe->call_mutex);
  244.    pipe->delete_blend_state(pipe,
  245.                             blend);
  246.    pipe_mutex_unlock(rb_pipe->call_mutex);
  247. }
  248.  
  249. static void *
  250. rbug_create_sampler_state(struct pipe_context *_pipe,
  251.                           const struct pipe_sampler_state *sampler)
  252. {
  253.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  254.    struct pipe_context *pipe = rb_pipe->pipe;
  255.    void *ret;
  256.  
  257.    pipe_mutex_lock(rb_pipe->call_mutex);
  258.    ret = pipe->create_sampler_state(pipe,
  259.                                     sampler);
  260.    pipe_mutex_unlock(rb_pipe->call_mutex);
  261.  
  262.    return ret;
  263. }
  264.  
  265. static void
  266. rbug_bind_fragment_sampler_states(struct pipe_context *_pipe,
  267.                                   unsigned num_samplers,
  268.                                   void **samplers)
  269. {
  270.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  271.    struct pipe_context *pipe = rb_pipe->pipe;
  272.  
  273.    pipe_mutex_lock(rb_pipe->call_mutex);
  274.    pipe->bind_fragment_sampler_states(pipe,
  275.                                       num_samplers,
  276.                                       samplers);
  277.    pipe_mutex_unlock(rb_pipe->call_mutex);
  278. }
  279.  
  280. static void
  281. rbug_bind_vertex_sampler_states(struct pipe_context *_pipe,
  282.                                 unsigned num_samplers,
  283.                                 void **samplers)
  284. {
  285.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  286.    struct pipe_context *pipe = rb_pipe->pipe;
  287.  
  288.    pipe_mutex_lock(rb_pipe->call_mutex);
  289.    pipe->bind_vertex_sampler_states(pipe,
  290.                                     num_samplers,
  291.                                     samplers);
  292.    pipe_mutex_unlock(rb_pipe->call_mutex);
  293. }
  294.  
  295. static void
  296. rbug_delete_sampler_state(struct pipe_context *_pipe,
  297.                           void *sampler)
  298. {
  299.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  300.    struct pipe_context *pipe = rb_pipe->pipe;
  301.  
  302.    pipe_mutex_lock(rb_pipe->call_mutex);
  303.    pipe->delete_sampler_state(pipe,
  304.                               sampler);
  305.    pipe_mutex_unlock(rb_pipe->call_mutex);
  306. }
  307.  
  308. static void *
  309. rbug_create_rasterizer_state(struct pipe_context *_pipe,
  310.                              const struct pipe_rasterizer_state *rasterizer)
  311. {
  312.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  313.    struct pipe_context *pipe = rb_pipe->pipe;
  314.    void *ret;
  315.  
  316.    pipe_mutex_lock(rb_pipe->call_mutex);
  317.    ret = pipe->create_rasterizer_state(pipe,
  318.                                        rasterizer);
  319.    pipe_mutex_unlock(rb_pipe->call_mutex);
  320.  
  321.    return ret;
  322. }
  323.  
  324. static void
  325. rbug_bind_rasterizer_state(struct pipe_context *_pipe,
  326.                            void *rasterizer)
  327. {
  328.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  329.    struct pipe_context *pipe = rb_pipe->pipe;
  330.  
  331.    pipe_mutex_lock(rb_pipe->call_mutex);
  332.    pipe->bind_rasterizer_state(pipe,
  333.                                rasterizer);
  334.    pipe_mutex_unlock(rb_pipe->call_mutex);
  335. }
  336.  
  337. static void
  338. rbug_delete_rasterizer_state(struct pipe_context *_pipe,
  339.                              void *rasterizer)
  340. {
  341.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  342.    struct pipe_context *pipe = rb_pipe->pipe;
  343.  
  344.    pipe_mutex_lock(rb_pipe->call_mutex);
  345.    pipe->delete_rasterizer_state(pipe,
  346.                                  rasterizer);
  347.    pipe_mutex_unlock(rb_pipe->call_mutex);
  348. }
  349.  
  350. static void *
  351. rbug_create_depth_stencil_alpha_state(struct pipe_context *_pipe,
  352.                                       const struct pipe_depth_stencil_alpha_state *depth_stencil_alpha)
  353. {
  354.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  355.    struct pipe_context *pipe = rb_pipe->pipe;
  356.    void *ret;
  357.  
  358.    pipe_mutex_lock(rb_pipe->call_mutex);
  359.    ret = pipe->create_depth_stencil_alpha_state(pipe,
  360.                                                 depth_stencil_alpha);
  361.    pipe_mutex_unlock(rb_pipe->call_mutex);
  362.  
  363.    return ret;
  364. }
  365.  
  366. static void
  367. rbug_bind_depth_stencil_alpha_state(struct pipe_context *_pipe,
  368.                                     void *depth_stencil_alpha)
  369. {
  370.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  371.    struct pipe_context *pipe = rb_pipe->pipe;
  372.  
  373.    pipe_mutex_lock(rb_pipe->call_mutex);
  374.    pipe->bind_depth_stencil_alpha_state(pipe,
  375.                                         depth_stencil_alpha);
  376.    pipe_mutex_unlock(rb_pipe->call_mutex);
  377. }
  378.  
  379. static void
  380. rbug_delete_depth_stencil_alpha_state(struct pipe_context *_pipe,
  381.                                       void *depth_stencil_alpha)
  382. {
  383.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  384.    struct pipe_context *pipe = rb_pipe->pipe;
  385.  
  386.    pipe_mutex_lock(rb_pipe->call_mutex);
  387.    pipe->delete_depth_stencil_alpha_state(pipe,
  388.                                           depth_stencil_alpha);
  389.    pipe_mutex_unlock(rb_pipe->call_mutex);
  390. }
  391.  
  392. static void *
  393. rbug_create_fs_state(struct pipe_context *_pipe,
  394.                      const struct pipe_shader_state *state)
  395. {
  396.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  397.    struct pipe_context *pipe = rb_pipe->pipe;
  398.    void *result;
  399.  
  400.    pipe_mutex_lock(rb_pipe->call_mutex);
  401.    result = pipe->create_fs_state(pipe, state);
  402.    pipe_mutex_unlock(rb_pipe->call_mutex);
  403.  
  404.    if (!result)
  405.       return NULL;
  406.  
  407.    return rbug_shader_create(rb_pipe, state, result, RBUG_SHADER_FRAGMENT);
  408. }
  409.  
  410. static void
  411. rbug_bind_fs_state(struct pipe_context *_pipe,
  412.                    void *_fs)
  413. {
  414.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  415.    struct pipe_context *pipe = rb_pipe->pipe;
  416.    void *fs;
  417.  
  418.    pipe_mutex_lock(rb_pipe->call_mutex);
  419.  
  420.    fs = rbug_shader_unwrap(_fs);
  421.    rb_pipe->curr.shader[PIPE_SHADER_FRAGMENT] = rbug_shader(_fs);
  422.    pipe->bind_fs_state(pipe,
  423.                        fs);
  424.  
  425.    pipe_mutex_unlock(rb_pipe->call_mutex);
  426. }
  427.  
  428. static void
  429. rbug_delete_fs_state(struct pipe_context *_pipe,
  430.                      void *_fs)
  431. {
  432.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  433.    struct rbug_shader *rb_shader = rbug_shader(_fs);
  434.  
  435.    pipe_mutex_lock(rb_pipe->call_mutex);
  436.    rbug_shader_destroy(rb_pipe, rb_shader);
  437.    pipe_mutex_unlock(rb_pipe->call_mutex);
  438. }
  439.  
  440. static void *
  441. rbug_create_vs_state(struct pipe_context *_pipe,
  442.                      const struct pipe_shader_state *state)
  443. {
  444.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  445.    struct pipe_context *pipe = rb_pipe->pipe;
  446.    void *result;
  447.  
  448.    pipe_mutex_lock(rb_pipe->call_mutex);
  449.    result = pipe->create_vs_state(pipe, state);
  450.    pipe_mutex_unlock(rb_pipe->call_mutex);
  451.  
  452.    if (!result)
  453.       return NULL;
  454.  
  455.    return rbug_shader_create(rb_pipe, state, result, RBUG_SHADER_VERTEX);
  456. }
  457.  
  458. static void
  459. rbug_bind_vs_state(struct pipe_context *_pipe,
  460.                    void *_vs)
  461. {
  462.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  463.    struct pipe_context *pipe = rb_pipe->pipe;
  464.    void *vs;
  465.  
  466.    pipe_mutex_lock(rb_pipe->call_mutex);
  467.  
  468.    vs = rbug_shader_unwrap(_vs);
  469.    rb_pipe->curr.shader[PIPE_SHADER_VERTEX] = rbug_shader(_vs);
  470.    pipe->bind_vs_state(pipe,
  471.                        vs);
  472.  
  473.    pipe_mutex_unlock(rb_pipe->call_mutex);
  474. }
  475.  
  476. static void
  477. rbug_delete_vs_state(struct pipe_context *_pipe,
  478.                      void *_vs)
  479. {
  480.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  481.    struct rbug_shader *rb_shader = rbug_shader(_vs);
  482.  
  483.    pipe_mutex_unlock(rb_pipe->call_mutex);
  484.    rbug_shader_destroy(rb_pipe, rb_shader);
  485.    pipe_mutex_unlock(rb_pipe->call_mutex);
  486. }
  487.  
  488. static void *
  489. rbug_create_gs_state(struct pipe_context *_pipe,
  490.                      const struct pipe_shader_state *state)
  491. {
  492.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  493.    struct pipe_context *pipe = rb_pipe->pipe;
  494.    void *result;
  495.  
  496.    pipe_mutex_lock(rb_pipe->call_mutex);
  497.    result = pipe->create_gs_state(pipe, state);
  498.    pipe_mutex_unlock(rb_pipe->call_mutex);
  499.  
  500.    if (!result)
  501.       return NULL;
  502.  
  503.    return rbug_shader_create(rb_pipe, state, result, RBUG_SHADER_GEOM);
  504. }
  505.  
  506. static void
  507. rbug_bind_gs_state(struct pipe_context *_pipe,
  508.                    void *_gs)
  509. {
  510.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  511.    struct pipe_context *pipe = rb_pipe->pipe;
  512.    void *gs;
  513.  
  514.    pipe_mutex_lock(rb_pipe->call_mutex);
  515.  
  516.    gs = rbug_shader_unwrap(_gs);
  517.    rb_pipe->curr.shader[PIPE_SHADER_GEOMETRY] = rbug_shader(_gs);
  518.    pipe->bind_gs_state(pipe,
  519.                        gs);
  520.  
  521.    pipe_mutex_unlock(rb_pipe->call_mutex);
  522. }
  523.  
  524. static void
  525. rbug_delete_gs_state(struct pipe_context *_pipe,
  526.                      void *_gs)
  527. {
  528.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  529.    struct rbug_shader *rb_shader = rbug_shader(_gs);
  530.  
  531.    pipe_mutex_lock(rb_pipe->call_mutex);
  532.    rbug_shader_destroy(rb_pipe, rb_shader);
  533.    pipe_mutex_unlock(rb_pipe->call_mutex);
  534. }
  535.  
  536. static void *
  537. rbug_create_vertex_elements_state(struct pipe_context *_pipe,
  538.                                   unsigned num_elements,
  539.                                   const struct pipe_vertex_element *vertex_elements)
  540. {
  541.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  542.    struct pipe_context *pipe = rb_pipe->pipe;
  543.    void *ret;
  544.  
  545.    pipe_mutex_lock(rb_pipe->call_mutex);
  546.    ret = pipe->create_vertex_elements_state(pipe,
  547.                                              num_elements,
  548.                                              vertex_elements);
  549.    pipe_mutex_unlock(rb_pipe->call_mutex);
  550.  
  551.    return ret;
  552. }
  553.  
  554. static void
  555. rbug_bind_vertex_elements_state(struct pipe_context *_pipe,
  556.                                 void *velems)
  557. {
  558.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  559.    struct pipe_context *pipe = rb_pipe->pipe;
  560.  
  561.    pipe_mutex_lock(rb_pipe->call_mutex);
  562.    pipe->bind_vertex_elements_state(pipe,
  563.                                     velems);
  564.    pipe_mutex_unlock(rb_pipe->call_mutex);
  565. }
  566.  
  567. static void
  568. rbug_delete_vertex_elements_state(struct pipe_context *_pipe,
  569.                                   void *velems)
  570. {
  571.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  572.    struct pipe_context *pipe = rb_pipe->pipe;
  573.  
  574.    pipe_mutex_lock(rb_pipe->call_mutex);
  575.    pipe->delete_vertex_elements_state(pipe,
  576.                                       velems);
  577.    pipe_mutex_unlock(rb_pipe->call_mutex);
  578. }
  579.  
  580. static void
  581. rbug_set_blend_color(struct pipe_context *_pipe,
  582.                      const struct pipe_blend_color *blend_color)
  583. {
  584.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  585.    struct pipe_context *pipe = rb_pipe->pipe;
  586.  
  587.    pipe_mutex_lock(rb_pipe->call_mutex);
  588.    pipe->set_blend_color(pipe,
  589.                          blend_color);
  590.    pipe_mutex_unlock(rb_pipe->call_mutex);
  591. }
  592.  
  593. static void
  594. rbug_set_stencil_ref(struct pipe_context *_pipe,
  595.                      const struct pipe_stencil_ref *stencil_ref)
  596. {
  597.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  598.    struct pipe_context *pipe = rb_pipe->pipe;
  599.  
  600.    pipe_mutex_lock(rb_pipe->call_mutex);
  601.    pipe->set_stencil_ref(pipe,
  602.                          stencil_ref);
  603.    pipe_mutex_unlock(rb_pipe->call_mutex);
  604. }
  605.  
  606. static void
  607. rbug_set_clip_state(struct pipe_context *_pipe,
  608.                     const struct pipe_clip_state *clip)
  609. {
  610.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  611.    struct pipe_context *pipe = rb_pipe->pipe;
  612.  
  613.    pipe_mutex_lock(rb_pipe->call_mutex);
  614.    pipe->set_clip_state(pipe,
  615.                         clip);
  616.    pipe_mutex_unlock(rb_pipe->call_mutex);
  617. }
  618.  
  619. static void
  620. rbug_set_constant_buffer(struct pipe_context *_pipe,
  621.                          uint shader,
  622.                          uint index,
  623.                          struct pipe_constant_buffer *_cb)
  624. {
  625.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  626.    struct pipe_context *pipe = rb_pipe->pipe;
  627.    struct pipe_constant_buffer cb;
  628.  
  629.    /* XXX hmm? unwrap the input state */
  630.    if (_cb) {
  631.       cb = *_cb;
  632.       cb.buffer = rbug_resource_unwrap(_cb->buffer);
  633.    }
  634.  
  635.    pipe_mutex_lock(rb_pipe->call_mutex);
  636.    pipe->set_constant_buffer(pipe,
  637.                              shader,
  638.                              index,
  639.                              _cb ? &cb : NULL);
  640.    pipe_mutex_unlock(rb_pipe->call_mutex);
  641. }
  642.  
  643. static void
  644. rbug_set_framebuffer_state(struct pipe_context *_pipe,
  645.                            const struct pipe_framebuffer_state *_state)
  646. {
  647.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  648.    struct pipe_context *pipe = rb_pipe->pipe;
  649.    struct pipe_framebuffer_state unwrapped_state;
  650.    struct pipe_framebuffer_state *state = NULL;
  651.    unsigned i;
  652.  
  653.    /* must protect curr status */
  654.    pipe_mutex_lock(rb_pipe->call_mutex);
  655.  
  656.    rb_pipe->curr.nr_cbufs = 0;
  657.    memset(rb_pipe->curr.cbufs, 0, sizeof(rb_pipe->curr.cbufs));
  658.    rb_pipe->curr.zsbuf = NULL;
  659.  
  660.    /* unwrap the input state */
  661.    if (_state) {
  662.       memcpy(&unwrapped_state, _state, sizeof(unwrapped_state));
  663.  
  664.       rb_pipe->curr.nr_cbufs = _state->nr_cbufs;
  665.       for(i = 0; i < _state->nr_cbufs; i++) {
  666.          unwrapped_state.cbufs[i] = rbug_surface_unwrap(_state->cbufs[i]);
  667.          if (_state->cbufs[i])
  668.             rb_pipe->curr.cbufs[i] = rbug_resource(_state->cbufs[i]->texture);
  669.       }
  670.       unwrapped_state.zsbuf = rbug_surface_unwrap(_state->zsbuf);
  671.       if (_state->zsbuf)
  672.          rb_pipe->curr.zsbuf = rbug_resource(_state->zsbuf->texture);
  673.       state = &unwrapped_state;
  674.    }
  675.  
  676.    pipe->set_framebuffer_state(pipe,
  677.                                state);
  678.  
  679.    pipe_mutex_unlock(rb_pipe->call_mutex);
  680. }
  681.  
  682. static void
  683. rbug_set_polygon_stipple(struct pipe_context *_pipe,
  684.                          const struct pipe_poly_stipple *poly_stipple)
  685. {
  686.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  687.    struct pipe_context *pipe = rb_pipe->pipe;
  688.  
  689.    pipe_mutex_lock(rb_pipe->call_mutex);
  690.    pipe->set_polygon_stipple(pipe,
  691.                              poly_stipple);
  692.    pipe_mutex_unlock(rb_pipe->call_mutex);
  693. }
  694.  
  695. static void
  696. rbug_set_scissor_states(struct pipe_context *_pipe,
  697.                         unsigned start_slot,
  698.                         unsigned num_scissors,
  699.                         const struct pipe_scissor_state *scissor)
  700. {
  701.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  702.    struct pipe_context *pipe = rb_pipe->pipe;
  703.  
  704.    pipe_mutex_lock(rb_pipe->call_mutex);
  705.    pipe->set_scissor_states(pipe, start_slot, num_scissors, scissor);
  706.    pipe_mutex_unlock(rb_pipe->call_mutex);
  707. }
  708.  
  709. static void
  710. rbug_set_viewport_states(struct pipe_context *_pipe,
  711.                          unsigned start_slot,
  712.                          unsigned num_viewports,
  713.                          const struct pipe_viewport_state *viewport)
  714. {
  715.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  716.    struct pipe_context *pipe = rb_pipe->pipe;
  717.  
  718.    pipe_mutex_lock(rb_pipe->call_mutex);
  719.    pipe->set_viewport_states(pipe, start_slot, num_viewports, viewport);
  720.    pipe_mutex_unlock(rb_pipe->call_mutex);
  721. }
  722.  
  723. static void
  724. rbug_set_sampler_views(struct pipe_context *_pipe,
  725.                        unsigned shader,
  726.                        unsigned start,
  727.                        unsigned num,
  728.                        struct pipe_sampler_view **_views)
  729. {
  730.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  731.    struct pipe_context *pipe = rb_pipe->pipe;
  732.    struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
  733.    struct pipe_sampler_view **views = NULL;
  734.    unsigned i;
  735.  
  736.    assert(start == 0); /* XXX fix */
  737.  
  738.    /* must protect curr status */
  739.    pipe_mutex_lock(rb_pipe->call_mutex);
  740.  
  741.    rb_pipe->curr.num_views[shader] = 0;
  742.    memset(rb_pipe->curr.views[shader], 0, sizeof(rb_pipe->curr.views[shader]));
  743.    memset(rb_pipe->curr.texs[shader], 0, sizeof(rb_pipe->curr.texs[shader]));
  744.    memset(unwrapped_views, 0, sizeof(unwrapped_views));
  745.  
  746.    if (_views) {
  747.       rb_pipe->curr.num_views[shader] = num;
  748.       for (i = 0; i < num; i++) {
  749.          rb_pipe->curr.views[shader][i] = rbug_sampler_view(_views[i]);
  750.          rb_pipe->curr.texs[shader][i] = rbug_resource(_views[i] ? _views[i]->texture : NULL);
  751.          unwrapped_views[i] = rbug_sampler_view_unwrap(_views[i]);
  752.       }
  753.       views = unwrapped_views;
  754.    }
  755.  
  756.    switch (shader) {
  757.    case PIPE_SHADER_VERTEX:
  758.       pipe->set_vertex_sampler_views(pipe, num, views);
  759.       break;
  760.    case PIPE_SHADER_FRAGMENT:
  761.       pipe->set_fragment_sampler_views(pipe, num, views);
  762.       break;
  763.    default:
  764.       assert(0);
  765.    }
  766.  
  767.    pipe_mutex_unlock(rb_pipe->call_mutex);
  768. }
  769.  
  770. static void
  771. rbug_set_vertex_sampler_views(struct pipe_context *_pipe,
  772.                               unsigned num,
  773.                               struct pipe_sampler_view **_views)
  774. {
  775.    rbug_set_sampler_views(_pipe, PIPE_SHADER_VERTEX, 0, num, _views);
  776. }
  777.  
  778. static void
  779. rbug_set_fragment_sampler_views(struct pipe_context *_pipe,
  780.                                 unsigned num,
  781.                                 struct pipe_sampler_view **_views)
  782. {
  783.    rbug_set_sampler_views(_pipe, PIPE_SHADER_FRAGMENT, 0, num, _views);
  784. }
  785.  
  786. static void
  787. rbug_set_vertex_buffers(struct pipe_context *_pipe,
  788.                         unsigned start_slot, unsigned num_buffers,
  789.                         const struct pipe_vertex_buffer *_buffers)
  790. {
  791.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  792.    struct pipe_context *pipe = rb_pipe->pipe;
  793.    struct pipe_vertex_buffer unwrapped_buffers[PIPE_MAX_SHADER_INPUTS];
  794.    struct pipe_vertex_buffer *buffers = NULL;
  795.    unsigned i;
  796.  
  797.    pipe_mutex_lock(rb_pipe->call_mutex);
  798.  
  799.    if (num_buffers) {
  800.       memcpy(unwrapped_buffers, _buffers, num_buffers * sizeof(*_buffers));
  801.       for (i = 0; i < num_buffers; i++)
  802.          unwrapped_buffers[i].buffer = rbug_resource_unwrap(_buffers[i].buffer);
  803.       buffers = unwrapped_buffers;
  804.    }
  805.  
  806.    pipe->set_vertex_buffers(pipe, start_slot,
  807.                             num_buffers,
  808.                             buffers);
  809.  
  810.    pipe_mutex_unlock(rb_pipe->call_mutex);
  811. }
  812.  
  813. static void
  814. rbug_set_index_buffer(struct pipe_context *_pipe,
  815.                       const struct pipe_index_buffer *_ib)
  816. {
  817.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  818.    struct pipe_context *pipe = rb_pipe->pipe;
  819.    struct pipe_index_buffer unwrapped_ib, *ib = NULL;
  820.  
  821.    if (_ib) {
  822.       unwrapped_ib = *_ib;
  823.       unwrapped_ib.buffer = rbug_resource_unwrap(_ib->buffer);
  824.       ib = &unwrapped_ib;
  825.    }
  826.  
  827.    pipe_mutex_lock(rb_pipe->call_mutex);
  828.    pipe->set_index_buffer(pipe, ib);
  829.    pipe_mutex_unlock(rb_pipe->call_mutex);
  830. }
  831.  
  832. static void
  833. rbug_set_sample_mask(struct pipe_context *_pipe,
  834.                      unsigned sample_mask)
  835. {
  836.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  837.    struct pipe_context *pipe = rb_pipe->pipe;
  838.  
  839.    pipe_mutex_lock(rb_pipe->call_mutex);
  840.    pipe->set_sample_mask(pipe, sample_mask);
  841.    pipe_mutex_unlock(rb_pipe->call_mutex);
  842. }
  843.  
  844. static void
  845. rbug_resource_copy_region(struct pipe_context *_pipe,
  846.                           struct pipe_resource *_dst,
  847.                           unsigned dst_level,
  848.                           unsigned dstx,
  849.                           unsigned dsty,
  850.                           unsigned dstz,
  851.                           struct pipe_resource *_src,
  852.                           unsigned src_level,
  853.                           const struct pipe_box *src_box)
  854. {
  855.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  856.    struct rbug_resource *rb_resource_dst = rbug_resource(_dst);
  857.    struct rbug_resource *rb_resource_src = rbug_resource(_src);
  858.    struct pipe_context *pipe = rb_pipe->pipe;
  859.    struct pipe_resource *dst = rb_resource_dst->resource;
  860.    struct pipe_resource *src = rb_resource_src->resource;
  861.  
  862.    pipe_mutex_lock(rb_pipe->call_mutex);
  863.    pipe->resource_copy_region(pipe,
  864.                               dst,
  865.                               dst_level,
  866.                               dstx,
  867.                               dsty,
  868.                               dstz,
  869.                               src,
  870.                               src_level,
  871.                               src_box);
  872.    pipe_mutex_unlock(rb_pipe->call_mutex);
  873. }
  874.  
  875. static void
  876. rbug_clear(struct pipe_context *_pipe,
  877.            unsigned buffers,
  878.            const union pipe_color_union *color,
  879.            double depth,
  880.            unsigned stencil)
  881. {
  882.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  883.    struct pipe_context *pipe = rb_pipe->pipe;
  884.  
  885.    pipe_mutex_lock(rb_pipe->call_mutex);
  886.    pipe->clear(pipe,
  887.                buffers,
  888.                color,
  889.                depth,
  890.                stencil);
  891.    pipe_mutex_unlock(rb_pipe->call_mutex);
  892. }
  893.  
  894. static void
  895. rbug_clear_render_target(struct pipe_context *_pipe,
  896.                          struct pipe_surface *_dst,
  897.                          const union pipe_color_union *color,
  898.                          unsigned dstx, unsigned dsty,
  899.                          unsigned width, unsigned height)
  900. {
  901.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  902.    struct rbug_surface *rb_surface_dst = rbug_surface(_dst);
  903.    struct pipe_context *pipe = rb_pipe->pipe;
  904.    struct pipe_surface *dst = rb_surface_dst->surface;
  905.  
  906.    pipe_mutex_lock(rb_pipe->call_mutex);
  907.    pipe->clear_render_target(pipe,
  908.                              dst,
  909.                              color,
  910.                              dstx,
  911.                              dsty,
  912.                              width,
  913.                              height);
  914.    pipe_mutex_unlock(rb_pipe->call_mutex);
  915. }
  916.  
  917. static void
  918. rbug_clear_depth_stencil(struct pipe_context *_pipe,
  919.                          struct pipe_surface *_dst,
  920.                          unsigned clear_flags,
  921.                          double depth,
  922.                          unsigned stencil,
  923.                          unsigned dstx, unsigned dsty,
  924.                          unsigned width, unsigned height)
  925. {
  926.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  927.    struct rbug_surface *rb_surface_dst = rbug_surface(_dst);
  928.    struct pipe_context *pipe = rb_pipe->pipe;
  929.    struct pipe_surface *dst = rb_surface_dst->surface;
  930.  
  931.    pipe_mutex_lock(rb_pipe->call_mutex);
  932.    pipe->clear_depth_stencil(pipe,
  933.                              dst,
  934.                              clear_flags,
  935.                              depth,
  936.                              stencil,
  937.                              dstx,
  938.                              dsty,
  939.                              width,
  940.                              height);
  941.    pipe_mutex_unlock(rb_pipe->call_mutex);
  942. }
  943.  
  944. static void
  945. rbug_flush(struct pipe_context *_pipe,
  946.            struct pipe_fence_handle **fence,
  947.            unsigned flags)
  948. {
  949.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  950.    struct pipe_context *pipe = rb_pipe->pipe;
  951.  
  952.    pipe_mutex_lock(rb_pipe->call_mutex);
  953.    pipe->flush(pipe, fence, flags);
  954.    pipe_mutex_unlock(rb_pipe->call_mutex);
  955. }
  956.  
  957. static struct pipe_sampler_view *
  958. rbug_context_create_sampler_view(struct pipe_context *_pipe,
  959.                                  struct pipe_resource *_resource,
  960.                                  const struct pipe_sampler_view *templ)
  961. {
  962.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  963.    struct rbug_resource *rb_resource = rbug_resource(_resource);
  964.    struct pipe_context *pipe = rb_pipe->pipe;
  965.    struct pipe_resource *resource = rb_resource->resource;
  966.    struct pipe_sampler_view *result;
  967.  
  968.    pipe_mutex_lock(rb_pipe->call_mutex);
  969.    result = pipe->create_sampler_view(pipe,
  970.                                       resource,
  971.                                       templ);
  972.    pipe_mutex_unlock(rb_pipe->call_mutex);
  973.  
  974.    if (result)
  975.       return rbug_sampler_view_create(rb_pipe, rb_resource, result);
  976.    return NULL;
  977. }
  978.  
  979. static void
  980. rbug_context_sampler_view_destroy(struct pipe_context *_pipe,
  981.                                   struct pipe_sampler_view *_view)
  982. {
  983.    rbug_sampler_view_destroy(rbug_context(_pipe),
  984.                              rbug_sampler_view(_view));
  985. }
  986.  
  987. static struct pipe_surface *
  988. rbug_context_create_surface(struct pipe_context *_pipe,
  989.                             struct pipe_resource *_resource,
  990.                             const struct pipe_surface *surf_tmpl)
  991. {
  992.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  993.    struct rbug_resource *rb_resource = rbug_resource(_resource);
  994.    struct pipe_context *pipe = rb_pipe->pipe;
  995.    struct pipe_resource *resource = rb_resource->resource;
  996.    struct pipe_surface *result;
  997.  
  998.    pipe_mutex_lock(rb_pipe->call_mutex);
  999.    result = pipe->create_surface(pipe,
  1000.                                  resource,
  1001.                                  surf_tmpl);
  1002.    pipe_mutex_unlock(rb_pipe->call_mutex);
  1003.  
  1004.    if (result)
  1005.       return rbug_surface_create(rb_pipe, rb_resource, result);
  1006.    return NULL;
  1007. }
  1008.  
  1009. static void
  1010. rbug_context_surface_destroy(struct pipe_context *_pipe,
  1011.                              struct pipe_surface *_surface)
  1012. {
  1013.    struct rbug_context *rb_pipe = rbug_context(_pipe);
  1014.    struct rbug_surface *rb_surface = rbug_surface(_surface);
  1015.  
  1016.    pipe_mutex_lock(rb_pipe->call_mutex);
  1017.    rbug_surface_destroy(rb_pipe,
  1018.                         rb_surface);
  1019.    pipe_mutex_unlock(rb_pipe->call_mutex);
  1020. }
  1021.  
  1022.  
  1023.  
  1024. static void *
  1025. rbug_context_transfer_map(struct pipe_context *_context,
  1026.                           struct pipe_resource *_resource,
  1027.                           unsigned level,
  1028.                           unsigned usage,
  1029.                           const struct pipe_box *box,
  1030.                           struct pipe_transfer **transfer)
  1031. {
  1032.    struct rbug_context *rb_pipe = rbug_context(_context);
  1033.    struct rbug_resource *rb_resource = rbug_resource(_resource);
  1034.    struct pipe_context *context = rb_pipe->pipe;
  1035.    struct pipe_resource *resource = rb_resource->resource;
  1036.    struct pipe_transfer *result;
  1037.    void *map;
  1038.  
  1039.    pipe_mutex_lock(rb_pipe->call_mutex);
  1040.    map = context->transfer_map(context,
  1041.                                resource,
  1042.                                level,
  1043.                                usage,
  1044.                                box, &result);
  1045.    pipe_mutex_unlock(rb_pipe->call_mutex);
  1046.  
  1047.    *transfer = rbug_transfer_create(rb_pipe, rb_resource, result);
  1048.    return *transfer ? map : NULL;
  1049. }
  1050.  
  1051. static void
  1052. rbug_context_transfer_flush_region(struct pipe_context *_context,
  1053.                                    struct pipe_transfer *_transfer,
  1054.                                    const struct pipe_box *box)
  1055. {
  1056.    struct rbug_context *rb_pipe = rbug_context(_context);
  1057.    struct rbug_transfer *rb_transfer = rbug_transfer(_transfer);
  1058.    struct pipe_context *context = rb_pipe->pipe;
  1059.    struct pipe_transfer *transfer = rb_transfer->transfer;
  1060.  
  1061.    pipe_mutex_lock(rb_pipe->call_mutex);
  1062.    context->transfer_flush_region(context,
  1063.                                   transfer,
  1064.                                   box);
  1065.    pipe_mutex_unlock(rb_pipe->call_mutex);
  1066. }
  1067.  
  1068.  
  1069. static void
  1070. rbug_context_transfer_unmap(struct pipe_context *_context,
  1071.                             struct pipe_transfer *_transfer)
  1072. {
  1073.    struct rbug_context *rb_pipe = rbug_context(_context);
  1074.    struct rbug_transfer *rb_transfer = rbug_transfer(_transfer);
  1075.    struct pipe_context *context = rb_pipe->pipe;
  1076.    struct pipe_transfer *transfer = rb_transfer->transfer;
  1077.  
  1078.    pipe_mutex_lock(rb_pipe->call_mutex);
  1079.    context->transfer_unmap(context,
  1080.                            transfer);
  1081.    rbug_transfer_destroy(rb_pipe,
  1082.                          rb_transfer);
  1083.    pipe_mutex_unlock(rb_pipe->call_mutex);
  1084. }
  1085.  
  1086.  
  1087. static void
  1088. rbug_context_transfer_inline_write(struct pipe_context *_context,
  1089.                                    struct pipe_resource *_resource,
  1090.                                    unsigned level,
  1091.                                    unsigned usage,
  1092.                                    const struct pipe_box *box,
  1093.                                    const void *data,
  1094.                                    unsigned stride,
  1095.                                    unsigned layer_stride)
  1096. {
  1097.    struct rbug_context *rb_pipe = rbug_context(_context);
  1098.    struct rbug_resource *rb_resource = rbug_resource(_resource);
  1099.    struct pipe_context *context = rb_pipe->pipe;
  1100.    struct pipe_resource *resource = rb_resource->resource;
  1101.  
  1102.    pipe_mutex_lock(rb_pipe->call_mutex);
  1103.    context->transfer_inline_write(context,
  1104.                                   resource,
  1105.                                   level,
  1106.                                   usage,
  1107.                                   box,
  1108.                                   data,
  1109.                                   stride,
  1110.                                   layer_stride);
  1111.    pipe_mutex_unlock(rb_pipe->call_mutex);
  1112. }
  1113.  
  1114.  
  1115. struct pipe_context *
  1116. rbug_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
  1117. {
  1118.    struct rbug_context *rb_pipe;
  1119.    struct rbug_screen *rb_screen = rbug_screen(_screen);
  1120.  
  1121.    if (!rb_screen)
  1122.       return NULL;
  1123.  
  1124.    rb_pipe = CALLOC_STRUCT(rbug_context);
  1125.    if (!rb_pipe)
  1126.       return NULL;
  1127.  
  1128.    pipe_mutex_init(rb_pipe->draw_mutex);
  1129.    pipe_condvar_init(rb_pipe->draw_cond);
  1130.    pipe_mutex_init(rb_pipe->call_mutex);
  1131.    pipe_mutex_init(rb_pipe->list_mutex);
  1132.    make_empty_list(&rb_pipe->shaders);
  1133.  
  1134.    rb_pipe->base.screen = _screen;
  1135.    rb_pipe->base.priv = pipe->priv; /* expose wrapped data */
  1136.    rb_pipe->base.draw = NULL;
  1137.  
  1138.    rb_pipe->base.destroy = rbug_destroy;
  1139.    rb_pipe->base.draw_vbo = rbug_draw_vbo;
  1140.    rb_pipe->base.create_query = rbug_create_query;
  1141.    rb_pipe->base.destroy_query = rbug_destroy_query;
  1142.    rb_pipe->base.begin_query = rbug_begin_query;
  1143.    rb_pipe->base.end_query = rbug_end_query;
  1144.    rb_pipe->base.get_query_result = rbug_get_query_result;
  1145.    rb_pipe->base.create_blend_state = rbug_create_blend_state;
  1146.    rb_pipe->base.bind_blend_state = rbug_bind_blend_state;
  1147.    rb_pipe->base.delete_blend_state = rbug_delete_blend_state;
  1148.    rb_pipe->base.create_sampler_state = rbug_create_sampler_state;
  1149.    rb_pipe->base.bind_fragment_sampler_states = rbug_bind_fragment_sampler_states;
  1150.    rb_pipe->base.bind_vertex_sampler_states = rbug_bind_vertex_sampler_states;
  1151.    rb_pipe->base.delete_sampler_state = rbug_delete_sampler_state;
  1152.    rb_pipe->base.create_rasterizer_state = rbug_create_rasterizer_state;
  1153.    rb_pipe->base.bind_rasterizer_state = rbug_bind_rasterizer_state;
  1154.    rb_pipe->base.delete_rasterizer_state = rbug_delete_rasterizer_state;
  1155.    rb_pipe->base.create_depth_stencil_alpha_state = rbug_create_depth_stencil_alpha_state;
  1156.    rb_pipe->base.bind_depth_stencil_alpha_state = rbug_bind_depth_stencil_alpha_state;
  1157.    rb_pipe->base.delete_depth_stencil_alpha_state = rbug_delete_depth_stencil_alpha_state;
  1158.    rb_pipe->base.create_fs_state = rbug_create_fs_state;
  1159.    rb_pipe->base.bind_fs_state = rbug_bind_fs_state;
  1160.    rb_pipe->base.delete_fs_state = rbug_delete_fs_state;
  1161.    rb_pipe->base.create_vs_state = rbug_create_vs_state;
  1162.    rb_pipe->base.bind_vs_state = rbug_bind_vs_state;
  1163.    rb_pipe->base.delete_vs_state = rbug_delete_vs_state;
  1164.    rb_pipe->base.create_gs_state = rbug_create_gs_state;
  1165.    rb_pipe->base.bind_gs_state = rbug_bind_gs_state;
  1166.    rb_pipe->base.delete_gs_state = rbug_delete_gs_state;
  1167.    rb_pipe->base.create_vertex_elements_state = rbug_create_vertex_elements_state;
  1168.    rb_pipe->base.bind_vertex_elements_state = rbug_bind_vertex_elements_state;
  1169.    rb_pipe->base.delete_vertex_elements_state = rbug_delete_vertex_elements_state;
  1170.    rb_pipe->base.set_blend_color = rbug_set_blend_color;
  1171.    rb_pipe->base.set_stencil_ref = rbug_set_stencil_ref;
  1172.    rb_pipe->base.set_clip_state = rbug_set_clip_state;
  1173.    rb_pipe->base.set_constant_buffer = rbug_set_constant_buffer;
  1174.    rb_pipe->base.set_framebuffer_state = rbug_set_framebuffer_state;
  1175.    rb_pipe->base.set_polygon_stipple = rbug_set_polygon_stipple;
  1176.    rb_pipe->base.set_scissor_states = rbug_set_scissor_states;
  1177.    rb_pipe->base.set_viewport_states = rbug_set_viewport_states;
  1178.    rb_pipe->base.set_fragment_sampler_views = rbug_set_fragment_sampler_views;
  1179.    rb_pipe->base.set_vertex_sampler_views = rbug_set_vertex_sampler_views;
  1180.    rb_pipe->base.set_vertex_buffers = rbug_set_vertex_buffers;
  1181.    rb_pipe->base.set_index_buffer = rbug_set_index_buffer;
  1182.    rb_pipe->base.set_sample_mask = rbug_set_sample_mask;
  1183.    rb_pipe->base.resource_copy_region = rbug_resource_copy_region;
  1184.    rb_pipe->base.clear = rbug_clear;
  1185.    rb_pipe->base.clear_render_target = rbug_clear_render_target;
  1186.    rb_pipe->base.clear_depth_stencil = rbug_clear_depth_stencil;
  1187.    rb_pipe->base.flush = rbug_flush;
  1188.    rb_pipe->base.create_sampler_view = rbug_context_create_sampler_view;
  1189.    rb_pipe->base.sampler_view_destroy = rbug_context_sampler_view_destroy;
  1190.    rb_pipe->base.create_surface = rbug_context_create_surface;
  1191.    rb_pipe->base.surface_destroy = rbug_context_surface_destroy;
  1192.    rb_pipe->base.transfer_map = rbug_context_transfer_map;
  1193.    rb_pipe->base.transfer_unmap = rbug_context_transfer_unmap;
  1194.    rb_pipe->base.transfer_flush_region = rbug_context_transfer_flush_region;
  1195.    rb_pipe->base.transfer_inline_write = rbug_context_transfer_inline_write;
  1196.  
  1197.    rb_pipe->pipe = pipe;
  1198.  
  1199.    rbug_screen_add_to_list(rb_screen, contexts, rb_pipe);
  1200.  
  1201.    if (debug_get_bool_option("GALLIUM_RBUG_START_BLOCKED", FALSE)) {
  1202.       rb_pipe->draw_blocked = RBUG_BLOCK_BEFORE;
  1203.    }
  1204.  
  1205.    return &rb_pipe->base;
  1206. }
  1207.