src/mesa/drivers/dri/i965/brw_metaops.c

   1 /*
   2  Copyright (C) Intel Corp.  2006.  All Rights Reserved.
   3  Intel funded Tungsten Graphics (http://www.tungstengraphics.com) to
   4  develop this 3D driver.
   5
   6  Permission is hereby granted, free of charge, to any person obtaining
   7  a 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, sublicense, 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
  16  portions of the Software.
  17
  18  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  19  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  21  IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  22  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  23  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  24  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25
  26  **********************************************************************/
  27  /*
  28   * Authors:
  29   *   Keith Whitwell <keith@tungstengraphics.com>
  30   *   frame buffer texture by Gary Wong <gtw@gnu.org>
  31   */
  32
  33
  34
  35 #include "main/glheader.h"
  36 #include "main/context.h"
  37 #include "main/macros.h"
  38
  39 #include "shader/arbprogparse.h"
  40
  41 #include "intel_screen.h"
  42 #include "intel_batchbuffer.h"
  43 #include "intel_regions.h"
  44 #include "intel_buffers.h"
  45
  46 #include "brw_context.h"
  47 #include "brw_defines.h"
  48 #include "brw_draw.h"
  49 #include "brw_fallback.h"
  50
  51 #define INIT(brw, STRUCT, ATTRIB)               \
  52 do {                                            \
  53    brw->attribs.ATTRIB = &ctx->ATTRIB;          \
  54 } while (0)
  55
  56 #define DUP(brw, STRUCT, ATTRIB)                \
  57 do {                                            \
  58    brw->metaops.attribs.ATTRIB = MALLOC_STRUCT(STRUCT); \
  59    memcpy(brw->metaops.attribs.ATTRIB,                  \
  60           brw->attribs.ATTRIB,                  \
  61           sizeof(struct STRUCT));               \
  62 } while (0)
  63
  64
  65 #define INSTALL(brw, ATTRIB, STATE)             \
  66 do {                                            \
  67    brw->attribs.ATTRIB = brw->metaops.attribs.ATTRIB;   \
  68    brw->state.dirty.mesa |= STATE;              \
  69 } while (0)
  70
  71 #define RESTORE(brw, ATTRIB, STATE)                     \
  72 do {                                                    \
  73    brw->attribs.ATTRIB = &brw->intel.ctx.ATTRIB;        \
  74    brw->state.dirty.mesa |= STATE;                      \
  75 } while (0)
  76
  77 static void init_attribs( struct brw_context *brw )
  78 {
  79    DUP(brw, gl_colorbuffer_attrib, Color);
  80    DUP(brw, gl_depthbuffer_attrib, Depth);
  81    DUP(brw, gl_fog_attrib, Fog);
  82    DUP(brw, gl_hint_attrib, Hint);
  83    DUP(brw, gl_light_attrib, Light);
  84    DUP(brw, gl_line_attrib, Line);
  85    DUP(brw, gl_point_attrib, Point);
  86    DUP(brw, gl_polygon_attrib, Polygon);
  87    DUP(brw, gl_scissor_attrib, Scissor);
  88    DUP(brw, gl_stencil_attrib, Stencil);
  89    DUP(brw, gl_texture_attrib, Texture);
  90    DUP(brw, gl_transform_attrib, Transform);
  91    DUP(brw, gl_viewport_attrib, Viewport);
  92    DUP(brw, gl_vertex_program_state, VertexProgram);
  93    DUP(brw, gl_fragment_program_state, FragmentProgram);
  94 }
  95
  96 static void install_attribs( struct brw_context *brw )
  97 {
  98    INSTALL(brw, Color, _NEW_COLOR);
  99    INSTALL(brw, Depth, _NEW_DEPTH);
 100    INSTALL(brw, Fog, _NEW_FOG);
 101    INSTALL(brw, Hint, _NEW_HINT);
 102    INSTALL(brw, Light, _NEW_LIGHT);
 103    INSTALL(brw, Line, _NEW_LINE);
 104    INSTALL(brw, Point, _NEW_POINT);
 105    INSTALL(brw, Polygon, _NEW_POLYGON);
 106    INSTALL(brw, Scissor, _NEW_SCISSOR);
 107    INSTALL(brw, Stencil, _NEW_STENCIL);
 108    INSTALL(brw, Texture, _NEW_TEXTURE);
 109    INSTALL(brw, Transform, _NEW_TRANSFORM);
 110    INSTALL(brw, Viewport, _NEW_VIEWPORT);
 111    INSTALL(brw, VertexProgram, _NEW_PROGRAM);
 112    INSTALL(brw, FragmentProgram, _NEW_PROGRAM);
 113 }
 114
 115 static void restore_attribs( struct brw_context *brw )
 116 {
 117    RESTORE(brw, Color, _NEW_COLOR);
 118    RESTORE(brw, Depth, _NEW_DEPTH);
 119    RESTORE(brw, Fog, _NEW_FOG);
 120    RESTORE(brw, Hint, _NEW_HINT);
 121    RESTORE(brw, Light, _NEW_LIGHT);
 122    RESTORE(brw, Line, _NEW_LINE);
 123    RESTORE(brw, Point, _NEW_POINT);
 124    RESTORE(brw, Polygon, _NEW_POLYGON);
 125    RESTORE(brw, Scissor, _NEW_SCISSOR);
 126    RESTORE(brw, Stencil, _NEW_STENCIL);
 127    RESTORE(brw, Texture, _NEW_TEXTURE);
 128    RESTORE(brw, Transform, _NEW_TRANSFORM);
 129    RESTORE(brw, Viewport, _NEW_VIEWPORT);
 130    RESTORE(brw, VertexProgram, _NEW_PROGRAM);
 131    RESTORE(brw, FragmentProgram, _NEW_PROGRAM);
 132 }
 133
 134
 135 static const char *vp_prog =
 136       "!!ARBvp1.0\n"
 137       "MOV  result.color, vertex.color;\n"
 138       "MOV  result.position, vertex.position;\n"
 139       "END\n";
 140
 141 static const char *fp_prog =
 142       "!!ARBfp1.0\n"
 143       "MOV result.color, fragment.color;\n"
 144       "END\n";
 145
 146 static const char *fp_tex_prog =
 147       "!!ARBfp1.0\n"
 148       "TEMP a;\n"
 149       "ADD a, fragment.position, program.local[0];\n"
 150       "MUL a, a, program.local[1];\n"
 151       "TEX result.color, a, texture[0], 2D;\n"
 152       "MOV result.depth.z, fragment.position;\n"
 153       "END\n";
 154
 155 /* Derived values of importance:
 156  *
 157  *   FragmentProgram->_Current
 158  *   VertexProgram->_Enabled
 159  *   brw->vertex_program
 160  *   DrawBuffer->_ColorDrawBufferIndexes[0]
 161  *
 162  *
 163  * More if drawpixels-through-texture is added.
 164  */
 165 static void init_metaops_state( struct brw_context *brw )
 166 {
 167    GLcontext *ctx = &brw->intel.ctx;
 168
 169    brw->metaops.vbo = ctx->Driver.NewBufferObject(ctx, 1, GL_ARRAY_BUFFER_ARB);
 170
 171    ctx->Driver.BufferData(ctx,
 172                           GL_ARRAY_BUFFER_ARB,
 173                           4096,
 174                           NULL,
 175                           GL_DYNAMIC_DRAW_ARB,
 176                           brw->metaops.vbo);
 177
 178    brw->metaops.fp = (struct gl_fragment_program *)
 179       ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 1 );
 180
 181    brw->metaops.fp_tex = (struct gl_fragment_program *)
 182       ctx->Driver.NewProgram(ctx, GL_FRAGMENT_PROGRAM_ARB, 1 );
 183
 184    brw->metaops.vp = (struct gl_vertex_program *)
 185       ctx->Driver.NewProgram(ctx, GL_VERTEX_PROGRAM_ARB, 1 );
 186
 187    _mesa_parse_arb_fragment_program(ctx, GL_FRAGMENT_PROGRAM_ARB,
 188                                     fp_prog, strlen(fp_prog),
 189                                     brw->metaops.fp);
 190
 191    _mesa_parse_arb_fragment_program(ctx, GL_FRAGMENT_PROGRAM_ARB,
 192                                     fp_tex_prog, strlen(fp_tex_prog),
 193                                     brw->metaops.fp_tex);
 194
 195    _mesa_parse_arb_vertex_program(ctx, GL_VERTEX_PROGRAM_ARB,
 196                                   vp_prog, strlen(vp_prog),
 197                                   brw->metaops.vp);
 198
 199    brw->metaops.attribs.VertexProgram->_Current = brw->metaops.vp;
 200    brw->metaops.attribs.VertexProgram->_Enabled = GL_TRUE;
 201
 202    brw->metaops.attribs.FragmentProgram->_Current = brw->metaops.fp;
 203 }
 204
 205 static void meta_flat_shade( struct intel_context *intel )
 206 {
 207    struct brw_context *brw = brw_context(&intel->ctx);
 208
 209    brw->metaops.attribs.Light->ShadeModel = GL_FLAT;
 210    brw->state.dirty.mesa |= _NEW_LIGHT;
 211 }
 212
 213
 214 static void meta_no_stencil_write( struct intel_context *intel )
 215 {
 216    struct brw_context *brw = brw_context(&intel->ctx);
 217
 218    brw->metaops.attribs.Stencil->Enabled = GL_FALSE;
 219    brw->metaops.attribs.Stencil->WriteMask[0] = GL_FALSE;
 220    brw->state.dirty.mesa |= _NEW_STENCIL;
 221 }
 222
 223 static void meta_no_depth_write( struct intel_context *intel )
 224 {
 225    struct brw_context *brw = brw_context(&intel->ctx);
 226
 227    brw->metaops.attribs.Depth->Test = GL_FALSE;
 228    brw->metaops.attribs.Depth->Mask = GL_FALSE;
 229    brw->state.dirty.mesa |= _NEW_DEPTH;
 230 }
 231
 232
 233 static void meta_depth_replace( struct intel_context *intel )
 234 {
 235    struct brw_context *brw = brw_context(&intel->ctx);
 236
 237    /* ctx->Driver.Enable( ctx, GL_DEPTH_TEST, GL_TRUE )
 238     * ctx->Driver.DepthMask( ctx, GL_TRUE )
 239     */
 240    brw->metaops.attribs.Depth->Test = GL_TRUE;
 241    brw->metaops.attribs.Depth->Mask = GL_TRUE;
 242    brw->state.dirty.mesa |= _NEW_DEPTH;
 243
 244    /* ctx->Driver.DepthFunc( ctx, GL_ALWAYS )
 245     */
 246    brw->metaops.attribs.Depth->Func = GL_ALWAYS;
 247
 248    brw->state.dirty.mesa |= _NEW_DEPTH;
 249 }
 250
 251
 252 static void meta_stencil_replace( struct intel_context *intel,
 253                                  GLuint s_mask,
 254                                  GLuint s_clear)
 255 {
 256    struct brw_context *brw = brw_context(&intel->ctx);
 257
 258    brw->metaops.attribs.Stencil->Enabled = GL_TRUE;
 259    brw->metaops.attribs.Stencil->WriteMask[0] = s_mask;
 260    brw->metaops.attribs.Stencil->ValueMask[0] = 0xff;
 261    brw->metaops.attribs.Stencil->Ref[0] = s_clear;
 262    brw->metaops.attribs.Stencil->Function[0] = GL_ALWAYS;
 263    brw->metaops.attribs.Stencil->FailFunc[0] = GL_REPLACE;
 264    brw->metaops.attribs.Stencil->ZPassFunc[0] = GL_REPLACE;
 265    brw->metaops.attribs.Stencil->ZFailFunc[0] = GL_REPLACE;
 266    brw->state.dirty.mesa |= _NEW_STENCIL;
 267 }
 268
 269
 270 static void meta_color_mask( struct intel_context *intel, GLboolean state )
 271 {
 272    struct brw_context *brw = brw_context(&intel->ctx);
 273
 274    if (state)
 275       COPY_4V(brw->metaops.attribs.Color->ColorMask,
 276               brw->intel.ctx.Color.ColorMask);
 277    else
 278       ASSIGN_4V(brw->metaops.attribs.Color->ColorMask, 0, 0, 0, 0);
 279
 280    brw->state.dirty.mesa |= _NEW_COLOR;
 281 }
 282
 283 static void meta_no_texture( struct intel_context *intel )
 284 {
 285    struct brw_context *brw = brw_context(&intel->ctx);
 286
 287    brw->metaops.attribs.FragmentProgram->_Current = brw->metaops.fp;
 288
 289    brw->metaops.attribs.Texture->CurrentUnit = 0;
 290    brw->metaops.attribs.Texture->_EnabledUnits = 0;
 291    brw->metaops.attribs.Texture->_EnabledCoordUnits = 0;
 292    brw->metaops.attribs.Texture->Unit[ 0 ].Enabled = 0;
 293    brw->metaops.attribs.Texture->Unit[ 0 ]._ReallyEnabled = 0;
 294
 295    brw->state.dirty.mesa |= _NEW_TEXTURE | _NEW_PROGRAM;
 296 }
 297
 298 static void meta_texture_blend_replace(struct intel_context *intel)
 299 {
 300    struct brw_context *brw = brw_context(&intel->ctx);
 301
 302    brw->metaops.attribs.Texture->CurrentUnit = 0;
 303    brw->metaops.attribs.Texture->_EnabledUnits = 1;
 304    brw->metaops.attribs.Texture->_EnabledCoordUnits = 1;
 305    brw->metaops.attribs.Texture->Unit[ 0 ].Enabled = TEXTURE_2D_BIT;
 306    brw->metaops.attribs.Texture->Unit[ 0 ]._ReallyEnabled = TEXTURE_2D_BIT;
 307    brw->metaops.attribs.Texture->Unit[ 0 ].Current2D =
 308       intel->frame_buffer_texobj;
 309    brw->metaops.attribs.Texture->Unit[ 0 ]._Current =
 310       intel->frame_buffer_texobj;
 311
 312    brw->state.dirty.mesa |= _NEW_TEXTURE | _NEW_PROGRAM;
 313 }
 314
 315 static void meta_import_pixel_state(struct intel_context *intel)
 316 {
 317    struct brw_context *brw = brw_context(&intel->ctx);
 318
 319    RESTORE(brw, Color, _NEW_COLOR);
 320    RESTORE(brw, Depth, _NEW_DEPTH);
 321    RESTORE(brw, Fog, _NEW_FOG);
 322    RESTORE(brw, Scissor, _NEW_SCISSOR);
 323    RESTORE(brw, Stencil, _NEW_STENCIL);
 324    RESTORE(brw, Texture, _NEW_TEXTURE);
 325    RESTORE(brw, FragmentProgram, _NEW_PROGRAM);
 326 }
 327
 328 static void meta_frame_buffer_texture( struct intel_context *intel,
 329                                        GLint xoff, GLint yoff )
 330 {
 331    struct brw_context *brw = brw_context(&intel->ctx);
 332    struct intel_region *region = intel_drawbuf_region( intel );
 333
 334    INSTALL(brw, FragmentProgram, _NEW_PROGRAM);
 335
 336    brw->metaops.attribs.FragmentProgram->_Current = brw->metaops.fp_tex;
 337    /* This is unfortunate, but seems to be necessary, since later on we
 338       will end up calling _mesa_load_state_parameters to lookup the
 339       local params (below), and that will want to look in ctx.FragmentProgram
 340       instead of brw->attribs.FragmentProgram. */
 341    intel->ctx.FragmentProgram.Current = brw->metaops.fp_tex;
 342
 343    brw->metaops.fp_tex->Base.LocalParams[ 0 ][ 0 ] = xoff;
 344    brw->metaops.fp_tex->Base.LocalParams[ 0 ][ 1 ] = yoff;
 345    brw->metaops.fp_tex->Base.LocalParams[ 0 ][ 2 ] = 0.0;
 346    brw->metaops.fp_tex->Base.LocalParams[ 0 ][ 3 ] = 0.0;
 347    brw->metaops.fp_tex->Base.LocalParams[ 1 ][ 0 ] =
 348       1.0 / region->pitch;
 349    brw->metaops.fp_tex->Base.LocalParams[ 1 ][ 1 ] =
 350       -1.0 / region->height;
 351    brw->metaops.fp_tex->Base.LocalParams[ 1 ][ 2 ] = 0.0;
 352    brw->metaops.fp_tex->Base.LocalParams[ 1 ][ 3 ] = 1.0;
 353
 354    brw->state.dirty.mesa |= _NEW_PROGRAM;
 355 }
 356
 357
 358 static void meta_draw_region( struct intel_context *intel,
 359                              struct intel_region *draw_region,
 360                              struct intel_region *depth_region )
 361 {
 362    struct brw_context *brw = brw_context(&intel->ctx);
 363
 364    if (!brw->metaops.saved_draw_region) {
 365       brw->metaops.saved_draw_region = brw->state.draw_regions[0];
 366       brw->metaops.saved_nr_draw_regions = brw->state.nr_draw_regions;
 367       brw->metaops.saved_depth_region = brw->state.depth_region;
 368    }
 369
 370    brw->state.draw_regions[0] = draw_region;
 371    brw->state.nr_draw_regions = 1;
 372    brw->state.depth_region = depth_region;
 373
 374    if (intel->frame_buffer_texobj != NULL)
 375       brw_FrameBufferTexDestroy(brw);
 376
 377    if (draw_region)
 378        brw_FrameBufferTexInit(brw, draw_region);
 379
 380    brw->state.dirty.mesa |= _NEW_BUFFERS;
 381 }
 382
 383
 384 static void meta_draw_quad(struct intel_context *intel,
 385                            GLfloat x0, GLfloat x1,
 386                            GLfloat y0, GLfloat y1,
 387                            GLfloat z,
 388                            GLuint color,
 389                            GLfloat s0, GLfloat s1,
 390                            GLfloat t0, GLfloat t1)
 391 {
 392    GLcontext *ctx = &intel->ctx;
 393    struct brw_context *brw = brw_context(&intel->ctx);
 394    struct gl_client_array pos_array;
 395    struct gl_client_array color_array;
 396    struct gl_client_array *attribs[VERT_ATTRIB_MAX];
 397    struct _mesa_prim prim[1];
 398    GLfloat pos[4][3];
 399
 400    ctx->Driver.BufferData(ctx,
 401                           GL_ARRAY_BUFFER_ARB,
 402                           sizeof(pos) + sizeof(color),
 403                           NULL,
 404                           GL_DYNAMIC_DRAW_ARB,
 405                           brw->metaops.vbo);
 406
 407    pos[0][0] = x0;
 408    pos[0][1] = y0;
 409    pos[0][2] = z;
 410
 411    pos[1][0] = x1;
 412    pos[1][1] = y0;
 413    pos[1][2] = z;
 414
 415    pos[2][0] = x1;
 416    pos[2][1] = y1;
 417    pos[2][2] = z;
 418
 419    pos[3][0] = x0;
 420    pos[3][1] = y1;
 421    pos[3][2] = z;
 422
 423    ctx->Driver.BufferSubData(ctx,
 424                              GL_ARRAY_BUFFER_ARB,
 425                              0,
 426                              sizeof(pos),
 427                              pos,
 428                              brw->metaops.vbo);
 429
 430    /* Convert incoming ARGB to required RGBA */
 431    /* Note this color is stored as GL_UNSIGNED_BYTE */
 432    color = (color & 0xff00ff00) | (((color >> 16) | (color << 16)) & 0xff00ff);
 433
 434    ctx->Driver.BufferSubData(ctx,
 435                              GL_ARRAY_BUFFER_ARB,
 436                              sizeof(pos),
 437                              sizeof(color),
 438                              &color,
 439                              brw->metaops.vbo);
 440
 441    /* Ignoring texture coords.
 442     */
 443
 444    memset(attribs, 0, VERT_ATTRIB_MAX * sizeof(*attribs));
 445
 446    attribs[VERT_ATTRIB_POS] = &pos_array;
 447    attribs[VERT_ATTRIB_POS]->Ptr = 0;
 448    attribs[VERT_ATTRIB_POS]->Type = GL_FLOAT;
 449    attribs[VERT_ATTRIB_POS]->Enabled = 1;
 450    attribs[VERT_ATTRIB_POS]->Size = 3;
 451    attribs[VERT_ATTRIB_POS]->StrideB = 3 * sizeof(GLfloat);
 452    attribs[VERT_ATTRIB_POS]->Stride = 3 * sizeof(GLfloat);
 453    attribs[VERT_ATTRIB_POS]->_MaxElement = 4;
 454    attribs[VERT_ATTRIB_POS]->Normalized = 0;
 455    attribs[VERT_ATTRIB_POS]->BufferObj = brw->metaops.vbo;
 456
 457    attribs[VERT_ATTRIB_COLOR0] = &color_array;
 458    attribs[VERT_ATTRIB_COLOR0]->Ptr = (const GLubyte *)sizeof(pos);
 459    attribs[VERT_ATTRIB_COLOR0]->Type = GL_UNSIGNED_BYTE;
 460    attribs[VERT_ATTRIB_COLOR0]->Enabled = 1;
 461    attribs[VERT_ATTRIB_COLOR0]->Size = 4;
 462    attribs[VERT_ATTRIB_COLOR0]->StrideB = 0;
 463    attribs[VERT_ATTRIB_COLOR0]->Stride = 0;
 464    attribs[VERT_ATTRIB_COLOR0]->_MaxElement = 1;
 465    attribs[VERT_ATTRIB_COLOR0]->Normalized = 1;
 466    attribs[VERT_ATTRIB_COLOR0]->BufferObj = brw->metaops.vbo;
 467
 468    /* Just ignoring texture coordinates for now.
 469     */
 470
 471    memset(prim, 0, sizeof(*prim));
 472
 473    prim[0].mode = GL_TRIANGLE_FAN;
 474    prim[0].begin = 1;
 475    prim[0].end = 1;
 476    prim[0].weak = 0;
 477    prim[0].pad = 0;
 478    prim[0].start = 0;
 479    prim[0].count = 4;
 480
 481    brw_draw_prims(&brw->intel.ctx,
 482                   (const struct gl_client_array **)attribs,
 483                   prim, 1,
 484                   NULL,
 485                   0,
 486                   3 );
 487 }
 488
 489
 490 static void install_meta_state( struct intel_context *intel )
 491 {
 492    GLcontext *ctx = &intel->ctx;
 493    struct brw_context *brw = brw_context(ctx);
 494    GLuint i;
 495
 496    if (!brw->metaops.vbo) {
 497       init_metaops_state(brw);
 498    }
 499
 500    install_attribs(brw);
 501
 502    meta_no_texture(&brw->intel);
 503    meta_flat_shade(&brw->intel);
 504    for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
 505       brw->metaops.restore_draw_buffers[i]
 506          = ctx->DrawBuffer->_ColorDrawBufferIndexes[i];
 507    }
 508    brw->metaops.restore_num_draw_buffers = ctx->DrawBuffer->_NumColorDrawBuffers;
 509
 510    brw->metaops.restore_fp = ctx->FragmentProgram.Current;
 511
 512    /* This works without adjusting refcounts.  Fix later?
 513     */
 514    brw->metaops.saved_draw_region = brw->state.draw_regions[0];
 515    brw->metaops.saved_nr_draw_regions = brw->state.nr_draw_regions;
 516    brw->metaops.saved_depth_region = brw->state.depth_region;
 517    brw->metaops.active = 1;
 518
 519    brw->state.dirty.brw |= BRW_NEW_METAOPS;
 520 }
 521
 522 static void leave_meta_state( struct intel_context *intel )
 523 {
 524    GLcontext *ctx = &intel->ctx;
 525    struct brw_context *brw = brw_context(ctx);
 526    GLuint i;
 527
 528    restore_attribs(brw);
 529
 530    for (i = 0; i < ctx->Const.MaxDrawBuffers; i++) {
 531       ctx->DrawBuffer->_ColorDrawBufferIndexes[i]
 532          = brw->metaops.restore_draw_buffers[i];
 533    }
 534    ctx->DrawBuffer->_NumColorDrawBuffers = brw->metaops.restore_num_draw_buffers;
 535
 536    ctx->FragmentProgram.Current = brw->metaops.restore_fp;
 537
 538    brw->state.draw_regions[0] = brw->metaops.saved_draw_region;
 539    brw->state.nr_draw_regions = brw->metaops.saved_nr_draw_regions;
 540    brw->state.depth_region = brw->metaops.saved_depth_region;
 541    brw->metaops.saved_draw_region = NULL;
 542    brw->metaops.saved_depth_region = NULL;
 543    brw->metaops.active = 0;
 544
 545    brw->state.dirty.mesa |= _NEW_BUFFERS;
 546    brw->state.dirty.brw |= BRW_NEW_METAOPS;
 547 }
 548
 549
 550
 551 void brw_init_metaops( struct brw_context *brw )
 552 {
 553    init_attribs(brw);
 554
 555
 556    brw->intel.vtbl.install_meta_state = install_meta_state;
 557    brw->intel.vtbl.leave_meta_state = leave_meta_state;
 558    brw->intel.vtbl.meta_no_depth_write = meta_no_depth_write;
 559    brw->intel.vtbl.meta_no_stencil_write = meta_no_stencil_write;
 560    brw->intel.vtbl.meta_stencil_replace = meta_stencil_replace;
 561    brw->intel.vtbl.meta_depth_replace = meta_depth_replace;
 562    brw->intel.vtbl.meta_color_mask = meta_color_mask;
 563    brw->intel.vtbl.meta_no_texture = meta_no_texture;
 564    brw->intel.vtbl.meta_import_pixel_state = meta_import_pixel_state;
 565    brw->intel.vtbl.meta_frame_buffer_texture = meta_frame_buffer_texture;
 566    brw->intel.vtbl.meta_draw_region = meta_draw_region;
 567    brw->intel.vtbl.meta_draw_quad = meta_draw_quad;
 568    brw->intel.vtbl.meta_texture_blend_replace = meta_texture_blend_replace;
 569 /*    brw->intel.vtbl.meta_tex_rect_source = meta_tex_rect_source; */
 570 /*    brw->intel.vtbl.meta_draw_format = set_draw_format; */
 571 }
 572
 573 void brw_destroy_metaops( struct brw_context *brw )
 574 {
 575    GLcontext *ctx = &brw->intel.ctx;
 576
 577    if (brw->metaops.vbo)
 578       ctx->Driver.DeleteBuffer( ctx, brw->metaops.vbo );
 579
 580 /*    ctx->Driver.DeleteProgram( ctx, brw->metaops.fp ); */
 581 /*    ctx->Driver.DeleteProgram( ctx, brw->metaops.fp_tex ); */
 582 /*    ctx->Driver.DeleteProgram( ctx, brw->metaops.vp ); */
 583 }