src/mesa/drivers/dri/i965/brw_context.h

   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   */
  31
  32
  33 #ifndef BRWCONTEXT_INC
  34 #define BRWCONTEXT_INC
  35
  36 #include "intel_context.h"
  37 #include "brw_structs.h"
  38 #include "main/imports.h"
  39
  40
  41 /* Glossary:
  42  *
  43  * URB - uniform resource buffer.  A mid-sized buffer which is
  44  * partitioned between the fixed function units and used for passing
  45  * values (vertices, primitives, constants) between them.
  46  *
  47  * CURBE - constant URB entry.  An urb region (entry) used to hold
  48  * constant values which the fixed function units can be instructed to
  49  * preload into the GRF when spawning a thread.
  50  *
  51  * VUE - vertex URB entry.  An urb entry holding a vertex and usually
  52  * a vertex header.  The header contains control information and
  53  * things like primitive type, Begin/end flags and clip codes.
  54  *
  55  * PUE - primitive URB entry.  An urb entry produced by the setup (SF)
  56  * unit holding rasterization and interpolation parameters.
  57  *
  58  * GRF - general register file.  One of several register files
  59  * addressable by programmed threads.  The inputs (r0, payload, curbe,
  60  * urb) of the thread are preloaded to this area before the thread is
  61  * spawned.  The registers are individually 8 dwords wide and suitable
  62  * for general usage.  Registers holding thread input values are not
  63  * special and may be overwritten.
  64  *
  65  * MRF - message register file.  Threads communicate (and terminate)
  66  * by sending messages.  Message parameters are placed in contiguous
  67  * MRF registers.  All program output is via these messages.  URB
  68  * entries are populated by sending a message to the shared URB
  69  * function containing the new data, together with a control word,
  70  * often an unmodified copy of R0.
  71  *
  72  * R0 - GRF register 0.  Typically holds control information used when
  73  * sending messages to other threads.
  74  *
  75  * EU or GEN4 EU: The name of the programmable subsystem of the
  76  * i965 hardware.  Threads are executed by the EU, the registers
  77  * described above are part of the EU architecture.
  78  *
  79  * Fixed function units:
  80  *
  81  * CS - Command streamer.  Notional first unit, little software
  82  * interaction.  Holds the URB entries used for constant data, ie the
  83  * CURBEs.
  84  *
  85  * VF/VS - Vertex Fetch / Vertex Shader.  The fixed function part of
  86  * this unit is responsible for pulling vertices out of vertex buffers
  87  * in vram and injecting them into the processing pipe as VUEs.  If
  88  * enabled, it first passes them to a VS thread which is a good place
  89  * for the driver to implement any active vertex shader.
  90  *
  91  * GS - Geometry Shader.  This corresponds to a new DX10 concept.  If
  92  * enabled, incoming strips etc are passed to GS threads in individual
  93  * line/triangle/point units.  The GS thread may perform arbitary
  94  * computation and emit whatever primtives with whatever vertices it
  95  * chooses.  This makes GS an excellent place to implement GL's
  96  * unfilled polygon modes, though of course it is capable of much
  97  * more.  Additionally, GS is used to translate away primitives not
  98  * handled by latter units, including Quads and Lineloops.
  99  *
 100  * CS - Clipper.  Mesa's clipping algorithms are imported to run on
 101  * this unit.  The fixed function part performs cliptesting against
 102  * the 6 fixed clipplanes and makes descisions on whether or not the
 103  * incoming primitive needs to be passed to a thread for clipping.
 104  * User clip planes are handled via cooperation with the VS thread.
 105  *
 106  * SF - Strips Fans or Setup: Triangles are prepared for
 107  * rasterization.  Interpolation coefficients are calculated.
 108  * Flatshading and two-side lighting usually performed here.
 109  *
 110  * WM - Windower.  Interpolation of vertex attributes performed here.
 111  * Fragment shader implemented here.  SIMD aspects of EU taken full
 112  * advantage of, as pixels are processed in blocks of 16.
 113  *
 114  * CC - Color Calculator.  No EU threads associated with this unit.
 115  * Handles blending and (presumably) depth and stencil testing.
 116  */
 117
 118 #define BRW_FALLBACK_TEXTURE             0x1
 119 #define BRW_MAX_CURBE                    (32*16)
 120
 121 struct brw_context;
 122
 123 #define BRW_NEW_URB_FENCE               0x1
 124 #define BRW_NEW_FRAGMENT_PROGRAM        0x2
 125 #define BRW_NEW_VERTEX_PROGRAM          0x4
 126 #define BRW_NEW_INPUT_DIMENSIONS        0x8
 127 #define BRW_NEW_CURBE_OFFSETS           0x10
 128 #define BRW_NEW_REDUCED_PRIMITIVE       0x20
 129 #define BRW_NEW_PRIMITIVE               0x40
 130 #define BRW_NEW_CONTEXT                 0x80
 131 #define BRW_NEW_WM_INPUT_DIMENSIONS     0x100
 132 #define BRW_NEW_INPUT_VARYING           0x200
 133 #define BRW_NEW_PSP                     0x800
 134 #define BRW_NEW_FENCE                   0x2000
 135 #define BRW_NEW_INDICES                 0x4000
 136 #define BRW_NEW_VERTICES                0x8000
 137 /**
 138  * Used for any batch entry with a relocated pointer that will be used
 139  * by any 3D rendering.
 140  */
 141 #define BRW_NEW_BATCH                   0x10000
 142 /** brw->depth_region updated */
 143 #define BRW_NEW_DEPTH_BUFFER            0x20000
 144 #define BRW_NEW_NR_SURFACES             0x40000
 145
 146 struct brw_state_flags {
 147    /** State update flags signalled by mesa internals */
 148    GLuint mesa;
 149    /**
 150     * State update flags signalled as the result of brw_tracked_state updates
 151     */
 152    GLuint brw;
 153    /** State update flags signalled by brw_state_cache.c searches */
 154    GLuint cache;
 155 };
 156
 157
 158 /** Subclass of Mesa vertex program */
 159 struct brw_vertex_program {
 160    struct gl_vertex_program program;
 161    GLuint id;
 162 };
 163
 164
 165 /** Subclass of Mesa fragment program */
 166 struct brw_fragment_program {
 167    struct gl_fragment_program program;
 168    GLuint id;  /**< serial no. to identify frag progs, never re-used */
 169    GLboolean isGLSL;  /**< really, any IF/LOOP/CONT/BREAK instructions */
 170
 171    /** Program constant buffer/surface */
 172    dri_bo *const_buffer;
 173 };
 174
 175
 176 /* Data about a particular attempt to compile a program.  Note that
 177  * there can be many of these, each in a different GL state
 178  * corresponding to a different brw_wm_prog_key struct, with different
 179  * compiled programs:
 180  */
 181 struct brw_wm_prog_data {
 182    GLuint curb_read_length;
 183    GLuint urb_read_length;
 184
 185    GLuint first_curbe_grf;
 186    GLuint total_grf;
 187    GLuint total_scratch;
 188
 189    GLuint nr_params;
 190    GLboolean error;
 191
 192    /* Pointer to tracked values (only valid once
 193     * _mesa_load_state_parameters has been called at runtime).
 194     */
 195    const GLfloat *param[BRW_MAX_CURBE];
 196 };
 197
 198 struct brw_sf_prog_data {
 199    GLuint urb_read_length;
 200    GLuint total_grf;
 201
 202    /* Each vertex may have upto 12 attributes, 4 components each,
 203     * except WPOS which requires only 2.  (11*4 + 2) == 44 ==> 11
 204     * rows.
 205     *
 206     * Actually we use 4 for each, so call it 12 rows.
 207     */
 208    GLuint urb_entry_size;
 209 };
 210
 211 struct brw_clip_prog_data {
 212    GLuint curb_read_length;     /* user planes? */
 213    GLuint clip_mode;
 214    GLuint urb_read_length;
 215    GLuint total_grf;
 216 };
 217
 218 struct brw_gs_prog_data {
 219    GLuint urb_read_length;
 220    GLuint total_grf;
 221 };
 222
 223 struct brw_vs_prog_data {
 224    GLuint curb_read_length;
 225    GLuint urb_read_length;
 226    GLuint total_grf;
 227    GLuint outputs_written;
 228
 229    GLuint inputs_read;
 230
 231    /* Used for calculating urb partitions:
 232     */
 233    GLuint urb_entry_size;
 234 };
 235
 236
 237 /* Size == 0 if output either not written, or always [0,0,0,1]
 238  */
 239 struct brw_vs_ouput_sizes {
 240    GLubyte output_size[VERT_RESULT_MAX];
 241 };
 242
 243
 244 /** Number of texture sampler units */
 245 #define BRW_MAX_TEX_UNIT 16
 246
 247 /**
 248  * Size of our surface binding table.
 249  * This contains pointers to the drawing surfaces and current texture
 250  * objects and shader constant buffers (+2).
 251  */
 252 #define BRW_WM_MAX_SURF (MAX_DRAW_BUFFERS + BRW_MAX_TEX_UNIT + 2)
 253
 254 /**
 255  * Helpers to convert drawing buffers, textures and constant buffers
 256  * to surface binding table indexes.
 257  */
 258 #define SURF_INDEX_DRAW(d)           (d)
 259 #define SURF_INDEX_FRAG_CONST_BUFFER (MAX_DRAW_BUFFERS + 0)
 260 #define SURF_INDEX_VERT_CONST_BUFFER (MAX_DRAW_BUFFERS + 1)
 261 #define SURF_INDEX_TEXTURE(t)        (MAX_DRAW_BUFFERS + 2 + t)
 262
 263
 264 enum brw_cache_id {
 265    BRW_CC_VP,
 266    BRW_CC_UNIT,
 267    BRW_WM_PROG,
 268    BRW_SAMPLER_DEFAULT_COLOR,
 269    BRW_SAMPLER,
 270    BRW_WM_UNIT,
 271    BRW_SF_PROG,
 272    BRW_SF_VP,
 273    BRW_SF_UNIT,
 274    BRW_VS_UNIT,
 275    BRW_VS_PROG,
 276    BRW_GS_UNIT,
 277    BRW_GS_PROG,
 278    BRW_CLIP_VP,
 279    BRW_CLIP_UNIT,
 280    BRW_CLIP_PROG,
 281    BRW_SS_SURFACE,
 282    BRW_SS_SURF_BIND,
 283
 284    BRW_MAX_CACHE
 285 };
 286
 287 struct brw_cache_item {
 288    /**
 289     * Effectively part of the key, cache_id identifies what kind of state
 290     * buffer is involved, and also which brw->state.dirty.cache flag should
 291     * be set when this cache item is chosen.
 292     */
 293    enum brw_cache_id cache_id;
 294    /** 32-bit hash of the key data */
 295    GLuint hash;
 296    GLuint key_size;             /* for variable-sized keys */
 297    const void *key;
 298    dri_bo **reloc_bufs;
 299    GLuint nr_reloc_bufs;
 300
 301    dri_bo *bo;
 302    GLuint data_size;
 303
 304    struct brw_cache_item *next;
 305 };
 306
 307
 308
 309 struct brw_cache {
 310    struct brw_context *brw;
 311
 312    struct brw_cache_item **items;
 313    GLuint size, n_items;
 314
 315    GLuint key_size[BRW_MAX_CACHE];              /* for fixed-size keys */
 316    GLuint aux_size[BRW_MAX_CACHE];
 317    char *name[BRW_MAX_CACHE];
 318
 319    /* Record of the last BOs chosen for each cache_id.  Used to set
 320     * brw->state.dirty.cache when a new cache item is chosen.
 321     */
 322    dri_bo *last_bo[BRW_MAX_CACHE];
 323 };
 324
 325
 326 /* Considered adding a member to this struct to document which flags
 327  * an update might raise so that ordering of the state atoms can be
 328  * checked or derived at runtime.  Dropped the idea in favor of having
 329  * a debug mode where the state is monitored for flags which are
 330  * raised that have already been tested against.
 331  */
 332 struct brw_tracked_state {
 333    struct brw_state_flags dirty;
 334    void (*prepare)( struct brw_context *brw );
 335    void (*emit)( struct brw_context *brw );
 336 };
 337
 338 /* Flags for brw->state.cache.
 339  */
 340 #define CACHE_NEW_CC_VP                  (1<<BRW_CC_VP)
 341 #define CACHE_NEW_CC_UNIT                (1<<BRW_CC_UNIT)
 342 #define CACHE_NEW_WM_PROG                (1<<BRW_WM_PROG)
 343 #define CACHE_NEW_SAMPLER_DEFAULT_COLOR  (1<<BRW_SAMPLER_DEFAULT_COLOR)
 344 #define CACHE_NEW_SAMPLER                (1<<BRW_SAMPLER)
 345 #define CACHE_NEW_WM_UNIT                (1<<BRW_WM_UNIT)
 346 #define CACHE_NEW_SF_PROG                (1<<BRW_SF_PROG)
 347 #define CACHE_NEW_SF_VP                  (1<<BRW_SF_VP)
 348 #define CACHE_NEW_SF_UNIT                (1<<BRW_SF_UNIT)
 349 #define CACHE_NEW_VS_UNIT                (1<<BRW_VS_UNIT)
 350 #define CACHE_NEW_VS_PROG                (1<<BRW_VS_PROG)
 351 #define CACHE_NEW_GS_UNIT                (1<<BRW_GS_UNIT)
 352 #define CACHE_NEW_GS_PROG                (1<<BRW_GS_PROG)
 353 #define CACHE_NEW_CLIP_VP                (1<<BRW_CLIP_VP)
 354 #define CACHE_NEW_CLIP_UNIT              (1<<BRW_CLIP_UNIT)
 355 #define CACHE_NEW_CLIP_PROG              (1<<BRW_CLIP_PROG)
 356 #define CACHE_NEW_SURFACE                (1<<BRW_SS_SURFACE)
 357 #define CACHE_NEW_SURF_BIND              (1<<BRW_SS_SURF_BIND)
 358
 359 struct brw_cached_batch_item {
 360    struct header *header;
 361    GLuint sz;
 362    struct brw_cached_batch_item *next;
 363 };
 364
 365
 366
 367 /* Protect against a future where VERT_ATTRIB_MAX > 32.  Wouldn't life
 368  * be easier if C allowed arrays of packed elements?
 369  */
 370 #define ATTRIB_BIT_DWORDS  ((VERT_ATTRIB_MAX+31)/32)
 371
 372 struct brw_vertex_element {
 373    const struct gl_client_array *glarray;
 374
 375    /** Size of a complete element */
 376    GLuint element_size;
 377    /** Number of uploaded elements for this input. */
 378    GLuint count;
 379    /** Byte stride between elements in the uploaded array */
 380    GLuint stride;
 381    /** Offset of the first element within the buffer object */
 382    unsigned int offset;
 383    /** Buffer object containing the uploaded vertex data */
 384    dri_bo *bo;
 385 };
 386
 387
 388
 389 struct brw_vertex_info {
 390    GLuint varying;  /* varying:1[VERT_ATTRIB_MAX] */
 391    GLuint sizes[ATTRIB_BIT_DWORDS * 2]; /* sizes:2[VERT_ATTRIB_MAX] */
 392 };
 393
 394
 395
 396
 397 /* Cache for TNL programs.
 398  */
 399 struct brw_tnl_cache_item {
 400    GLuint hash;
 401    void *key;
 402    void *data;
 403    struct brw_tnl_cache_item *next;
 404 };
 405
 406 struct brw_tnl_cache {
 407    struct brw_tnl_cache_item **items;
 408    GLuint size, n_items;
 409 };
 410
 411 struct brw_query_object {
 412    struct gl_query_object Base;
 413
 414    /** Doubly linked list of active query objects in the context. */
 415    struct brw_query_object *prev, *next;
 416
 417    /** Last query BO associated with this query. */
 418    dri_bo *bo;
 419    /** First index in bo with query data for this object. */
 420    int first_index;
 421    /** Last index in bo with query data for this object. */
 422    int last_index;
 423
 424    /* Total count of pixels from previous BOs */
 425    unsigned int count;
 426 };
 427
 428 struct brw_context
 429 {
 430    struct intel_context intel;
 431    GLuint primitive;
 432
 433    GLboolean emit_state_always;
 434    GLboolean tmp_fallback;
 435    GLboolean no_batch_wrap;
 436
 437    struct {
 438       struct brw_state_flags dirty;
 439       struct brw_tracked_state **atoms;
 440       GLuint nr_atoms;
 441
 442       GLuint nr_color_regions;
 443       struct intel_region *color_regions[MAX_DRAW_BUFFERS];
 444       struct intel_region *depth_region;
 445
 446       /**
 447        * List of buffers accumulated in brw_validate_state to receive
 448        * dri_bo_check_aperture treatment before exec, so we can know if we
 449        * should flush the batch and try again before emitting primitives.
 450        *
 451        * This can be a fixed number as we only have a limited number of
 452        * objects referenced from the batchbuffer in a primitive emit,
 453        * consisting of the vertex buffers, pipelined state pointers,
 454        * the CURBE, the depth buffer, and a query BO.
 455        */
 456       dri_bo *validated_bos[VERT_ATTRIB_MAX + 16];
 457       int validated_bo_count;
 458    } state;
 459
 460    struct brw_cache cache;
 461    struct brw_cached_batch_item *cached_batch_items;
 462
 463    struct {
 464       struct brw_vertex_element inputs[VERT_ATTRIB_MAX];
 465
 466 #define BRW_NR_UPLOAD_BUFS 17
 467 #define BRW_UPLOAD_INIT_SIZE (128*1024)
 468
 469       struct {
 470          dri_bo *bo;
 471          GLuint offset;
 472       } upload;
 473
 474       /* Summary of size and varying of active arrays, so we can check
 475        * for changes to this state:
 476        */
 477       struct brw_vertex_info info;
 478       unsigned int min_index, max_index;
 479    } vb;
 480
 481    struct {
 482       /**
 483        * Index buffer for this draw_prims call.
 484        *
 485        * Updates are signaled by BRW_NEW_INDICES.
 486        */
 487       const struct _mesa_index_buffer *ib;
 488
 489       dri_bo *bo;
 490       unsigned int offset;
 491    } ib;
 492
 493    /* Active vertex program:
 494     */
 495    const struct gl_vertex_program *vertex_program;
 496    const struct gl_fragment_program *fragment_program;
 497
 498
 499    /* For populating the gtt:
 500     */
 501    GLuint next_free_page;
 502
 503
 504    /* BRW_NEW_URB_ALLOCATIONS:
 505     */
 506    struct {
 507       GLuint vsize;             /* vertex size plus header in urb registers */
 508       GLuint csize;             /* constant buffer size in urb registers */
 509       GLuint sfsize;            /* setup data size in urb registers */
 510
 511       GLboolean constrained;
 512
 513       GLuint nr_vs_entries;
 514       GLuint nr_gs_entries;
 515       GLuint nr_clip_entries;
 516       GLuint nr_sf_entries;
 517       GLuint nr_cs_entries;
 518
 519 /*       GLuint vs_size; */
 520 /*       GLuint gs_size; */
 521 /*       GLuint clip_size; */
 522 /*       GLuint sf_size; */
 523 /*       GLuint cs_size; */
 524
 525       GLuint vs_start;
 526       GLuint gs_start;
 527       GLuint clip_start;
 528       GLuint sf_start;
 529       GLuint cs_start;
 530    } urb;
 531
 532
 533    /* BRW_NEW_CURBE_OFFSETS:
 534     */
 535    struct {
 536       GLuint wm_start;  /**< pos of first wm const in CURBE buffer */
 537       GLuint wm_size;   /**< number of float[4] consts, multiple of 16 */
 538       GLuint clip_start;
 539       GLuint clip_size;
 540       GLuint vs_start;
 541       GLuint vs_size;
 542       GLuint total_size;
 543
 544       /* Dynamic tracker which changes to reflect the state referenced
 545        * by active fp and vp program parameters:
 546        */
 547       struct brw_tracked_state tracked_state;
 548
 549       dri_bo *curbe_bo;
 550       /** Offset within curbe_bo of space for current curbe entry */
 551       GLuint curbe_offset;
 552       /** Offset within curbe_bo of space for next curbe entry */
 553       GLuint curbe_next_offset;
 554
 555       GLfloat *last_buf;
 556       GLuint last_bufsz;
 557       /**
 558        *  Whether we should create a new bo instead of reusing the old one
 559        * (if we just dispatch the batch pointing at the old one.
 560        */
 561       GLboolean need_new_bo;
 562    } curbe;
 563
 564    struct {
 565       struct brw_vs_prog_data *prog_data;
 566
 567       dri_bo *prog_bo;
 568       dri_bo *state_bo;
 569    } vs;
 570
 571    struct {
 572       struct brw_gs_prog_data *prog_data;
 573
 574       GLboolean prog_active;
 575       dri_bo *prog_bo;
 576       dri_bo *state_bo;
 577    } gs;
 578
 579    struct {
 580       struct brw_clip_prog_data *prog_data;
 581
 582       dri_bo *prog_bo;
 583       dri_bo *state_bo;
 584       dri_bo *vp_bo;
 585    } clip;
 586
 587
 588    struct {
 589       struct brw_sf_prog_data *prog_data;
 590
 591       dri_bo *prog_bo;
 592       dri_bo *state_bo;
 593       dri_bo *vp_bo;
 594    } sf;
 595
 596    struct {
 597       struct brw_wm_prog_data *prog_data;
 598       struct brw_wm_compile *compile_data;
 599
 600       /* Input sizes, calculated from active vertex program:
 601        */
 602       GLuint input_size_masks[4];
 603
 604       /** Array of surface default colors (texture border color) */
 605       dri_bo *sdc_bo[BRW_MAX_TEX_UNIT];
 606
 607       GLuint render_surf;
 608       GLuint nr_surfaces;
 609
 610       GLuint max_threads;
 611       dri_bo *scratch_bo;
 612
 613       GLuint sampler_count;
 614       dri_bo *sampler_bo;
 615
 616       /** Binding table of pointers to surf_bo entries */
 617       dri_bo *bind_bo;
 618       dri_bo *surf_bo[BRW_WM_MAX_SURF];
 619
 620       dri_bo *prog_bo;
 621       dri_bo *state_bo;
 622    } wm;
 623
 624
 625    struct {
 626       dri_bo *prog_bo;
 627       dri_bo *state_bo;
 628       dri_bo *vp_bo;
 629    } cc;
 630
 631    struct {
 632       struct brw_query_object active_head;
 633       dri_bo *bo;
 634       int index;
 635       GLboolean active;
 636    } query;
 637    /* Used to give every program string a unique id
 638     */
 639    GLuint program_id;
 640 };
 641
 642
 643 #define BRW_PACKCOLOR8888(r,g,b,a)  ((r<<24) | (g<<16) | (b<<8) | a)
 644
 645
 646
 647 /*======================================================================
 648  * brw_vtbl.c
 649  */
 650 void brwInitVtbl( struct brw_context *brw );
 651
 652 /*======================================================================
 653  * brw_context.c
 654  */
 655 GLboolean brwCreateContext( const __GLcontextModes *mesaVis,
 656                             __DRIcontextPrivate *driContextPriv,
 657                             void *sharedContextPrivate);
 658
 659 /*======================================================================
 660  * brw_queryobj.c
 661  */
 662 void brw_init_queryobj_functions(struct dd_function_table *functions);
 663 void brw_prepare_query_begin(struct brw_context *brw);
 664 void brw_emit_query_begin(struct brw_context *brw);
 665 void brw_emit_query_end(struct brw_context *brw);
 666
 667 /*======================================================================
 668  * brw_state_dump.c
 669  */
 670 void brw_debug_batch(struct intel_context *intel);
 671
 672 /*======================================================================
 673  * brw_tex.c
 674  */
 675 void brwUpdateTextureState( struct intel_context *intel );
 676 void brw_FrameBufferTexInit( struct brw_context *brw,
 677                              struct intel_region *region );
 678 void brw_FrameBufferTexDestroy( struct brw_context *brw );
 679 void brw_validate_textures( struct brw_context *brw );
 680
 681
 682 /*======================================================================
 683  * brw_program.c
 684  */
 685 void brwInitFragProgFuncs( struct dd_function_table *functions );
 686
 687
 688 /* brw_urb.c
 689  */
 690 void brw_upload_urb_fence(struct brw_context *brw);
 691
 692 /* brw_curbe.c
 693  */
 694 void brw_upload_cs_urb_state(struct brw_context *brw);
 695
 696
 697 /*======================================================================
 698  * Inline conversion functions.  These are better-typed than the
 699  * macros used previously:
 700  */
 701 static INLINE struct brw_context *
 702 brw_context( GLcontext *ctx )
 703 {
 704    return (struct brw_context *)ctx;
 705 }
 706
 707 static INLINE struct brw_vertex_program *
 708 brw_vertex_program(struct gl_vertex_program *p)
 709 {
 710    return (struct brw_vertex_program *) p;
 711 }
 712
 713 static INLINE const struct brw_vertex_program *
 714 brw_vertex_program_const(const struct gl_vertex_program *p)
 715 {
 716    return (const struct brw_vertex_program *) p;
 717 }
 718
 719 static INLINE struct brw_fragment_program *
 720 brw_fragment_program(struct gl_fragment_program *p)
 721 {
 722    return (struct brw_fragment_program *) p;
 723 }
 724
 725 static INLINE const struct brw_fragment_program *
 726 brw_fragment_program_const(const struct gl_fragment_program *p)
 727 {
 728    return (const struct brw_fragment_program *) p;
 729 }
 730
 731
 732
 733 #define DO_SETUP_BITS ((1<<(FRAG_ATTRIB_MAX)) - 1)
 734
 735 #endif
 736