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 buffer (+1).
 251  */
 252 #define BRW_WM_MAX_SURF (MAX_DRAW_BUFFERS + BRW_MAX_TEX_UNIT + 1)
 253
 254
 255 enum brw_cache_id {
 256    BRW_CC_VP,
 257    BRW_CC_UNIT,
 258    BRW_WM_PROG,
 259    BRW_SAMPLER_DEFAULT_COLOR,
 260    BRW_SAMPLER,
 261    BRW_WM_UNIT,
 262    BRW_SF_PROG,
 263    BRW_SF_VP,
 264    BRW_SF_UNIT,
 265    BRW_VS_UNIT,
 266    BRW_VS_PROG,
 267    BRW_GS_UNIT,
 268    BRW_GS_PROG,
 269    BRW_CLIP_VP,
 270    BRW_CLIP_UNIT,
 271    BRW_CLIP_PROG,
 272    BRW_SS_SURFACE,
 273    BRW_SS_SURF_BIND,
 274
 275    BRW_MAX_CACHE
 276 };
 277
 278 struct brw_cache_item {
 279    /**
 280     * Effectively part of the key, cache_id identifies what kind of state
 281     * buffer is involved, and also which brw->state.dirty.cache flag should
 282     * be set when this cache item is chosen.
 283     */
 284    enum brw_cache_id cache_id;
 285    /** 32-bit hash of the key data */
 286    GLuint hash;
 287    GLuint key_size;             /* for variable-sized keys */
 288    const void *key;
 289    dri_bo **reloc_bufs;
 290    GLuint nr_reloc_bufs;
 291
 292    dri_bo *bo;
 293    GLuint data_size;
 294
 295    struct brw_cache_item *next;
 296 };
 297
 298
 299
 300 struct brw_cache {
 301    struct brw_context *brw;
 302
 303    struct brw_cache_item **items;
 304    GLuint size, n_items;
 305
 306    GLuint key_size[BRW_MAX_CACHE];              /* for fixed-size keys */
 307    GLuint aux_size[BRW_MAX_CACHE];
 308    char *name[BRW_MAX_CACHE];
 309
 310    /* Record of the last BOs chosen for each cache_id.  Used to set
 311     * brw->state.dirty.cache when a new cache item is chosen.
 312     */
 313    dri_bo *last_bo[BRW_MAX_CACHE];
 314 };
 315
 316
 317 /* Considered adding a member to this struct to document which flags
 318  * an update might raise so that ordering of the state atoms can be
 319  * checked or derived at runtime.  Dropped the idea in favor of having
 320  * a debug mode where the state is monitored for flags which are
 321  * raised that have already been tested against.
 322  */
 323 struct brw_tracked_state {
 324    struct brw_state_flags dirty;
 325    void (*prepare)( struct brw_context *brw );
 326    void (*emit)( struct brw_context *brw );
 327 };
 328
 329 /* Flags for brw->state.cache.
 330  */
 331 #define CACHE_NEW_CC_VP                  (1<<BRW_CC_VP)
 332 #define CACHE_NEW_CC_UNIT                (1<<BRW_CC_UNIT)
 333 #define CACHE_NEW_WM_PROG                (1<<BRW_WM_PROG)
 334 #define CACHE_NEW_SAMPLER_DEFAULT_COLOR  (1<<BRW_SAMPLER_DEFAULT_COLOR)
 335 #define CACHE_NEW_SAMPLER                (1<<BRW_SAMPLER)
 336 #define CACHE_NEW_WM_UNIT                (1<<BRW_WM_UNIT)
 337 #define CACHE_NEW_SF_PROG                (1<<BRW_SF_PROG)
 338 #define CACHE_NEW_SF_VP                  (1<<BRW_SF_VP)
 339 #define CACHE_NEW_SF_UNIT                (1<<BRW_SF_UNIT)
 340 #define CACHE_NEW_VS_UNIT                (1<<BRW_VS_UNIT)
 341 #define CACHE_NEW_VS_PROG                (1<<BRW_VS_PROG)
 342 #define CACHE_NEW_GS_UNIT                (1<<BRW_GS_UNIT)
 343 #define CACHE_NEW_GS_PROG                (1<<BRW_GS_PROG)
 344 #define CACHE_NEW_CLIP_VP                (1<<BRW_CLIP_VP)
 345 #define CACHE_NEW_CLIP_UNIT              (1<<BRW_CLIP_UNIT)
 346 #define CACHE_NEW_CLIP_PROG              (1<<BRW_CLIP_PROG)
 347 #define CACHE_NEW_SURFACE                (1<<BRW_SS_SURFACE)
 348 #define CACHE_NEW_SURF_BIND              (1<<BRW_SS_SURF_BIND)
 349
 350 struct brw_cached_batch_item {
 351    struct header *header;
 352    GLuint sz;
 353    struct brw_cached_batch_item *next;
 354 };
 355
 356
 357
 358 /* Protect against a future where VERT_ATTRIB_MAX > 32.  Wouldn't life
 359  * be easier if C allowed arrays of packed elements?
 360  */
 361 #define ATTRIB_BIT_DWORDS  ((VERT_ATTRIB_MAX+31)/32)
 362
 363 struct brw_vertex_element {
 364    const struct gl_client_array *glarray;
 365
 366    /** Size of a complete element */
 367    GLuint element_size;
 368    /** Number of uploaded elements for this input. */
 369    GLuint count;
 370    /** Byte stride between elements in the uploaded array */
 371    GLuint stride;
 372    /** Offset of the first element within the buffer object */
 373    unsigned int offset;
 374    /** Buffer object containing the uploaded vertex data */
 375    dri_bo *bo;
 376 };
 377
 378
 379
 380 struct brw_vertex_info {
 381    GLuint varying;  /* varying:1[VERT_ATTRIB_MAX] */
 382    GLuint sizes[ATTRIB_BIT_DWORDS * 2]; /* sizes:2[VERT_ATTRIB_MAX] */
 383 };
 384
 385
 386
 387
 388 /* Cache for TNL programs.
 389  */
 390 struct brw_tnl_cache_item {
 391    GLuint hash;
 392    void *key;
 393    void *data;
 394    struct brw_tnl_cache_item *next;
 395 };
 396
 397 struct brw_tnl_cache {
 398    struct brw_tnl_cache_item **items;
 399    GLuint size, n_items;
 400 };
 401
 402 struct brw_query_object {
 403    struct gl_query_object Base;
 404
 405    /** Doubly linked list of active query objects in the context. */
 406    struct brw_query_object *prev, *next;
 407
 408    /** Last query BO associated with this query. */
 409    dri_bo *bo;
 410    /** First index in bo with query data for this object. */
 411    int first_index;
 412    /** Last index in bo with query data for this object. */
 413    int last_index;
 414
 415    /* Total count of pixels from previous BOs */
 416    unsigned int count;
 417 };
 418
 419 struct brw_context
 420 {
 421    struct intel_context intel;
 422    GLuint primitive;
 423
 424    GLboolean emit_state_always;
 425    GLboolean tmp_fallback;
 426    GLboolean no_batch_wrap;
 427
 428    struct {
 429       struct brw_state_flags dirty;
 430       struct brw_tracked_state **atoms;
 431       GLuint nr_atoms;
 432
 433       GLuint nr_color_regions;
 434       struct intel_region *color_regions[MAX_DRAW_BUFFERS];
 435       struct intel_region *depth_region;
 436
 437       /**
 438        * List of buffers accumulated in brw_validate_state to receive
 439        * dri_bo_check_aperture treatment before exec, so we can know if we
 440        * should flush the batch and try again before emitting primitives.
 441        *
 442        * This can be a fixed number as we only have a limited number of
 443        * objects referenced from the batchbuffer in a primitive emit,
 444        * consisting of the vertex buffers, pipelined state pointers,
 445        * the CURBE, the depth buffer, and a query BO.
 446        */
 447       dri_bo *validated_bos[VERT_ATTRIB_MAX + 16];
 448       int validated_bo_count;
 449    } state;
 450
 451    struct brw_cache cache;
 452    struct brw_cached_batch_item *cached_batch_items;
 453
 454    struct {
 455       struct brw_vertex_element inputs[VERT_ATTRIB_MAX];
 456
 457 #define BRW_NR_UPLOAD_BUFS 17
 458 #define BRW_UPLOAD_INIT_SIZE (128*1024)
 459
 460       struct {
 461          dri_bo *bo;
 462          GLuint offset;
 463       } upload;
 464
 465       /* Summary of size and varying of active arrays, so we can check
 466        * for changes to this state:
 467        */
 468       struct brw_vertex_info info;
 469       unsigned int min_index, max_index;
 470    } vb;
 471
 472    struct {
 473       /**
 474        * Index buffer for this draw_prims call.
 475        *
 476        * Updates are signaled by BRW_NEW_INDICES.
 477        */
 478       const struct _mesa_index_buffer *ib;
 479
 480       dri_bo *bo;
 481       unsigned int offset;
 482    } ib;
 483
 484    /* Active vertex program:
 485     */
 486    const struct gl_vertex_program *vertex_program;
 487    const struct gl_fragment_program *fragment_program;
 488
 489
 490    /* For populating the gtt:
 491     */
 492    GLuint next_free_page;
 493
 494
 495    /* BRW_NEW_URB_ALLOCATIONS:
 496     */
 497    struct {
 498       GLuint vsize;             /* vertex size plus header in urb registers */
 499       GLuint csize;             /* constant buffer size in urb registers */
 500       GLuint sfsize;            /* setup data size in urb registers */
 501
 502       GLboolean constrained;
 503
 504       GLuint nr_vs_entries;
 505       GLuint nr_gs_entries;
 506       GLuint nr_clip_entries;
 507       GLuint nr_sf_entries;
 508       GLuint nr_cs_entries;
 509
 510 /*       GLuint vs_size; */
 511 /*       GLuint gs_size; */
 512 /*       GLuint clip_size; */
 513 /*       GLuint sf_size; */
 514 /*       GLuint cs_size; */
 515
 516       GLuint vs_start;
 517       GLuint gs_start;
 518       GLuint clip_start;
 519       GLuint sf_start;
 520       GLuint cs_start;
 521    } urb;
 522
 523
 524    /* BRW_NEW_CURBE_OFFSETS:
 525     */
 526    struct {
 527       GLuint wm_start;  /**< pos of first wm const in CURBE buffer */
 528       GLuint wm_size;   /**< number of float[4] consts, multiple of 16 */
 529       GLuint clip_start;
 530       GLuint clip_size;
 531       GLuint vs_start;
 532       GLuint vs_size;
 533       GLuint total_size;
 534
 535       /* Dynamic tracker which changes to reflect the state referenced
 536        * by active fp and vp program parameters:
 537        */
 538       struct brw_tracked_state tracked_state;
 539
 540       dri_bo *curbe_bo;
 541       /** Offset within curbe_bo of space for current curbe entry */
 542       GLuint curbe_offset;
 543       /** Offset within curbe_bo of space for next curbe entry */
 544       GLuint curbe_next_offset;
 545
 546       GLfloat *last_buf;
 547       GLuint last_bufsz;
 548       /**
 549        *  Whether we should create a new bo instead of reusing the old one
 550        * (if we just dispatch the batch pointing at the old one.
 551        */
 552       GLboolean need_new_bo;
 553    } curbe;
 554
 555    struct {
 556       struct brw_vs_prog_data *prog_data;
 557
 558       dri_bo *prog_bo;
 559       dri_bo *state_bo;
 560    } vs;
 561
 562    struct {
 563       struct brw_gs_prog_data *prog_data;
 564
 565       GLboolean prog_active;
 566       dri_bo *prog_bo;
 567       dri_bo *state_bo;
 568    } gs;
 569
 570    struct {
 571       struct brw_clip_prog_data *prog_data;
 572
 573       dri_bo *prog_bo;
 574       dri_bo *state_bo;
 575       dri_bo *vp_bo;
 576    } clip;
 577
 578
 579    struct {
 580       struct brw_sf_prog_data *prog_data;
 581
 582       dri_bo *prog_bo;
 583       dri_bo *state_bo;
 584       dri_bo *vp_bo;
 585    } sf;
 586
 587    struct {
 588       struct brw_wm_prog_data *prog_data;
 589       struct brw_wm_compile *compile_data;
 590
 591       /* Input sizes, calculated from active vertex program:
 592        */
 593       GLuint input_size_masks[4];
 594
 595       /** Array of surface default colors (texture border color) */
 596       dri_bo *sdc_bo[BRW_MAX_TEX_UNIT];
 597
 598       GLuint render_surf;
 599       GLuint nr_surfaces;
 600
 601       GLuint max_threads;
 602       dri_bo *scratch_bo;
 603
 604       GLuint sampler_count;
 605       dri_bo *sampler_bo;
 606
 607       /** Binding table of pointers to surf_bo entries */
 608       dri_bo *bind_bo;
 609       dri_bo *surf_bo[BRW_WM_MAX_SURF];
 610
 611       dri_bo *prog_bo;
 612       dri_bo *state_bo;
 613    } wm;
 614
 615
 616    struct {
 617       dri_bo *prog_bo;
 618       dri_bo *state_bo;
 619       dri_bo *vp_bo;
 620    } cc;
 621
 622    struct {
 623       struct brw_query_object active_head;
 624       dri_bo *bo;
 625       int index;
 626       GLboolean active;
 627    } query;
 628    /* Used to give every program string a unique id
 629     */
 630    GLuint program_id;
 631 };
 632
 633
 634 #define BRW_PACKCOLOR8888(r,g,b,a)  ((r<<24) | (g<<16) | (b<<8) | a)
 635
 636
 637
 638 /*======================================================================
 639  * brw_vtbl.c
 640  */
 641 void brwInitVtbl( struct brw_context *brw );
 642
 643 /*======================================================================
 644  * brw_context.c
 645  */
 646 GLboolean brwCreateContext( const __GLcontextModes *mesaVis,
 647                             __DRIcontextPrivate *driContextPriv,
 648                             void *sharedContextPrivate);
 649
 650 /*======================================================================
 651  * brw_queryobj.c
 652  */
 653 void brw_init_queryobj_functions(struct dd_function_table *functions);
 654 void brw_prepare_query_begin(struct brw_context *brw);
 655 void brw_emit_query_begin(struct brw_context *brw);
 656 void brw_emit_query_end(struct brw_context *brw);
 657
 658 /*======================================================================
 659  * brw_state_dump.c
 660  */
 661 void brw_debug_batch(struct intel_context *intel);
 662
 663 /*======================================================================
 664  * brw_tex.c
 665  */
 666 void brwUpdateTextureState( struct intel_context *intel );
 667 void brw_FrameBufferTexInit( struct brw_context *brw,
 668                              struct intel_region *region );
 669 void brw_FrameBufferTexDestroy( struct brw_context *brw );
 670 void brw_validate_textures( struct brw_context *brw );
 671
 672
 673 /*======================================================================
 674  * brw_program.c
 675  */
 676 void brwInitFragProgFuncs( struct dd_function_table *functions );
 677
 678
 679 /* brw_urb.c
 680  */
 681 void brw_upload_urb_fence(struct brw_context *brw);
 682
 683 /* brw_curbe.c
 684  */
 685 void brw_upload_cs_urb_state(struct brw_context *brw);
 686
 687
 688 /*======================================================================
 689  * Inline conversion functions.  These are better-typed than the
 690  * macros used previously:
 691  */
 692 static INLINE struct brw_context *
 693 brw_context( GLcontext *ctx )
 694 {
 695    return (struct brw_context *)ctx;
 696 }
 697
 698 static INLINE struct brw_vertex_program *
 699 brw_vertex_program(struct gl_vertex_program *p)
 700 {
 701    return (struct brw_vertex_program *) p;
 702 }
 703
 704 static INLINE const struct brw_vertex_program *
 705 brw_vertex_program_const(const struct gl_vertex_program *p)
 706 {
 707    return (const struct brw_vertex_program *) p;
 708 }
 709
 710 static INLINE struct brw_fragment_program *
 711 brw_fragment_program(struct gl_fragment_program *p)
 712 {
 713    return (struct brw_fragment_program *) p;
 714 }
 715
 716 static INLINE const struct brw_fragment_program *
 717 brw_fragment_program_const(const struct gl_fragment_program *p)
 718 {
 719    return (const struct brw_fragment_program *) p;
 720 }
 721
 722
 723
 724 #define DO_SETUP_BITS ((1<<(FRAG_ATTRIB_MAX)) - 1)
 725
 726 #endif
 727