t_context.h revision 80875253ce0e166bd8f529ba9b869139ce82902a
1/* 2 * mesa 3-D graphics library 3 * Version: 6.3 4 * 5 * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a 8 * copy of this software and associated documentation files (the "Software"), 9 * to deal in the Software without restriction, including without limitation 10 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 11 * and/or sell copies of the Software, and to permit persons to whom the 12 * Software is furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included 15 * in all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25/** 26 * \file t_context.h 27 * \brief TnL module datatypes and definitions. 28 * \author Keith Whitwell 29 */ 30 31 32/** 33 * \mainpage The TNL-module 34 * 35 * TNL stands for "transform and lighting", i.e. this module implements 36 * a pipeline that receives as input a buffer of vertices and does all 37 * necessary transformations (rotations, clipping, vertex shader etc.) 38 * and passes then the output to the rasterizer. 39 * 40 * The tnl_pipeline contains the array of all stages, which should be 41 * applied. Each stage is a black-box, which is described by an 42 * tnl_pipeline_stage. The function ::_tnl_run_pipeline applies all the 43 * stages to the vertex_buffer TNLcontext::vb, where the vertex data 44 * is stored. The last stage in the pipeline is the rasterizer. 45 * 46 * The initial vertex_buffer data may either come from an ::immediate 47 * structure or client vertex_arrays or display lists: 48 * 49 * 50 * - The ::immediate structure records all the GL commands issued between 51 * glBegin and glEnd. \n 52 * The structure accumulates data, until it is either full or it is 53 * flushed (usually by a state change). Before starting then the pipeline, 54 * the collected vertex data in ::immediate has to be pushed into 55 * TNLcontext::vb. 56 * This happens in ::_tnl_vb_bind_immediate. The pipeline is then run by 57 * calling tnl_device_driver::RunPipeline = ::_tnl_run_pipeline, which 58 * is stored in TNLcontext::Driver. \n 59 * An ::immediate does (for performance reasons) usually not finish with a 60 * glEnd, and hence it also does not need to start with a glBegin. 61 * This means that the last vertices of one ::immediate may need to be 62 * saved for the next one. 63 * 64 * 65 * - NOT SURE ABOUT THIS: The vertex_arrays structure is used to handle 66 * glDrawArrays etc. \n 67 * Here, the data of the vertex_arrays is copied by ::_tnl_vb_bind_arrays 68 * into TNLcontext::vb, so that the pipeline can be started. 69 */ 70 71 72#ifndef _T_CONTEXT_H 73#define _T_CONTEXT_H 74 75#include "glheader.h" 76#include "mtypes.h" 77 78#include "math/m_matrix.h" 79#include "math/m_vector.h" 80#include "math/m_xform.h" 81 82 83#define MAX_PIPELINE_STAGES 30 84 85 86/* 87 * Note: The first attributes match the VERT_ATTRIB_* definitions 88 * in mtypes.h. However, the tnl module has additional attributes 89 * for materials, color indexes, edge flags, etc. 90 */ 91/* Note: These are currently being used to define both inputs and 92 * outputs from the tnl pipeline. A better solution (which would also 93 * releive the congestion to slightly prolong the life of the bitmask 94 * below) is to have the fixed function pipeline populate a set of 95 * arrays named after those produced by the vertex program stage, and 96 * have the rest the mesa backend work on those. 97 */ 98enum { 99 _TNL_ATTRIB_POS = 0, 100 _TNL_ATTRIB_WEIGHT = 1, 101 _TNL_ATTRIB_NORMAL = 2, 102 _TNL_ATTRIB_COLOR0 = 3, 103 _TNL_ATTRIB_COLOR1 = 4, 104 _TNL_ATTRIB_FOG = 5, 105 _TNL_ATTRIB_SIX = 6, 106 _TNL_ATTRIB_SEVEN = 7, 107 _TNL_ATTRIB_TEX0 = 8, 108 _TNL_ATTRIB_TEX1 = 9, 109 _TNL_ATTRIB_TEX2 = 10, 110 _TNL_ATTRIB_TEX3 = 11, 111 _TNL_ATTRIB_TEX4 = 12, 112 _TNL_ATTRIB_TEX5 = 13, 113 _TNL_ATTRIB_TEX6 = 14, 114 _TNL_ATTRIB_TEX7 = 15, 115 _TNL_ATTRIB_MAT_FRONT_AMBIENT = 16, 116 _TNL_ATTRIB_MAT_BACK_AMBIENT = 17, 117 _TNL_ATTRIB_MAT_FRONT_DIFFUSE = 18, 118 _TNL_ATTRIB_MAT_BACK_DIFFUSE = 19, 119 _TNL_ATTRIB_MAT_FRONT_SPECULAR = 20, 120 _TNL_ATTRIB_MAT_BACK_SPECULAR = 21, 121 _TNL_ATTRIB_MAT_FRONT_EMISSION = 22, 122 _TNL_ATTRIB_MAT_BACK_EMISSION = 23, 123 _TNL_ATTRIB_MAT_FRONT_SHININESS = 24, 124 _TNL_ATTRIB_MAT_BACK_SHININESS = 25, 125 _TNL_ATTRIB_MAT_FRONT_INDEXES = 26, 126 _TNL_ATTRIB_MAT_BACK_INDEXES = 27, 127 _TNL_ATTRIB_INDEX = 28, 128 _TNL_ATTRIB_EDGEFLAG = 29, 129 _TNL_ATTRIB_POINTSIZE = 30, 130 _TNL_ATTRIB_MAX = 31 131} ; 132 133/* Will probably have to revise this scheme fairly shortly, eg. by 134 * compacting all the MAT flags down to one bit, or by using two 135 * dwords to store the flags. 136 */ 137#define _TNL_BIT_POS (1<<0) 138#define _TNL_BIT_WEIGHT (1<<1) 139#define _TNL_BIT_NORMAL (1<<2) 140#define _TNL_BIT_COLOR0 (1<<3) 141#define _TNL_BIT_COLOR1 (1<<4) 142#define _TNL_BIT_FOG (1<<5) 143#define _TNL_BIT_SIX (1<<6) 144#define _TNL_BIT_SEVEN (1<<7) 145#define _TNL_BIT_TEX0 (1<<8) 146#define _TNL_BIT_TEX1 (1<<9) 147#define _TNL_BIT_TEX2 (1<<10) 148#define _TNL_BIT_TEX3 (1<<11) 149#define _TNL_BIT_TEX4 (1<<12) 150#define _TNL_BIT_TEX5 (1<<13) 151#define _TNL_BIT_TEX6 (1<<14) 152#define _TNL_BIT_TEX7 (1<<15) 153#define _TNL_BIT_MAT_FRONT_AMBIENT (1<<16) 154#define _TNL_BIT_MAT_BACK_AMBIENT (1<<17) 155#define _TNL_BIT_MAT_FRONT_DIFFUSE (1<<18) 156#define _TNL_BIT_MAT_BACK_DIFFUSE (1<<19) 157#define _TNL_BIT_MAT_FRONT_SPECULAR (1<<20) 158#define _TNL_BIT_MAT_BACK_SPECULAR (1<<21) 159#define _TNL_BIT_MAT_FRONT_EMISSION (1<<22) 160#define _TNL_BIT_MAT_BACK_EMISSION (1<<23) 161#define _TNL_BIT_MAT_FRONT_SHININESS (1<<24) 162#define _TNL_BIT_MAT_BACK_SHININESS (1<<25) 163#define _TNL_BIT_MAT_FRONT_INDEXES (1<<26) 164#define _TNL_BIT_MAT_BACK_INDEXES (1<<27) 165#define _TNL_BIT_INDEX (1<<28) 166#define _TNL_BIT_EDGEFLAG (1<<29) 167#define _TNL_BIT_POINTSIZE (1<<30) 168 169#define _TNL_BIT_TEX(u) (1 << (_TNL_ATTRIB_TEX0 + (u))) 170 171 172 173#define _TNL_BITS_MAT_ANY (_TNL_BIT_MAT_FRONT_AMBIENT | \ 174 _TNL_BIT_MAT_BACK_AMBIENT | \ 175 _TNL_BIT_MAT_FRONT_DIFFUSE | \ 176 _TNL_BIT_MAT_BACK_DIFFUSE | \ 177 _TNL_BIT_MAT_FRONT_SPECULAR | \ 178 _TNL_BIT_MAT_BACK_SPECULAR | \ 179 _TNL_BIT_MAT_FRONT_EMISSION | \ 180 _TNL_BIT_MAT_BACK_EMISSION | \ 181 _TNL_BIT_MAT_FRONT_SHININESS | \ 182 _TNL_BIT_MAT_BACK_SHININESS | \ 183 _TNL_BIT_MAT_FRONT_INDEXES | \ 184 _TNL_BIT_MAT_BACK_INDEXES) 185 186 187#define _TNL_BITS_TEX_ANY (_TNL_BIT_TEX0 | \ 188 _TNL_BIT_TEX1 | \ 189 _TNL_BIT_TEX2 | \ 190 _TNL_BIT_TEX3 | \ 191 _TNL_BIT_TEX4 | \ 192 _TNL_BIT_TEX5 | \ 193 _TNL_BIT_TEX6 | \ 194 _TNL_BIT_TEX7) 195 196 197#define _TNL_BITS_PROG_ANY (_TNL_BIT_POS | \ 198 _TNL_BIT_WEIGHT | \ 199 _TNL_BIT_NORMAL | \ 200 _TNL_BIT_COLOR0 | \ 201 _TNL_BIT_COLOR1 | \ 202 _TNL_BIT_FOG | \ 203 _TNL_BIT_SIX | \ 204 _TNL_BIT_SEVEN | \ 205 _TNL_BITS_TEX_ANY) 206 207 208 209#define PRIM_BEGIN 0x10 210#define PRIM_END 0x20 211#define PRIM_WEAK 0x40 212#define PRIM_MODE_MASK 0x0f 213 214/* 215 */ 216struct tnl_prim { 217 GLuint mode; 218 GLuint start; 219 GLuint count; 220}; 221 222 223 224struct tnl_eval1_map { 225 struct gl_1d_map *map; 226 GLuint sz; 227}; 228 229struct tnl_eval2_map { 230 struct gl_2d_map *map; 231 GLuint sz; 232}; 233 234struct tnl_eval { 235 GLuint new_state; 236 struct tnl_eval1_map map1[_TNL_ATTRIB_INDEX + 1]; 237 struct tnl_eval2_map map2[_TNL_ATTRIB_INDEX + 1]; 238}; 239 240 241#define TNL_MAX_PRIM 16 242#define TNL_MAX_COPIED_VERTS 3 243 244struct tnl_copied_vtx { 245 GLfloat buffer[_TNL_ATTRIB_MAX * 4 * TNL_MAX_COPIED_VERTS]; 246 GLuint nr; 247}; 248 249#define VERT_BUFFER_SIZE 2048 /* 8kbytes */ 250 251 252typedef void (*tnl_attrfv_func)( const GLfloat * ); 253 254struct _tnl_dynfn { 255 struct _tnl_dynfn *next, *prev; 256 GLuint key; 257 char *code; 258}; 259 260struct _tnl_dynfn_lists { 261 struct _tnl_dynfn Vertex[4]; 262 struct _tnl_dynfn Attribute[4]; 263}; 264 265struct _tnl_dynfn_generators { 266 struct _tnl_dynfn *(*Vertex[4])( GLcontext *ctx, int key ); 267 struct _tnl_dynfn *(*Attribute[4])( GLcontext *ctx, int key ); 268}; 269 270#define _TNL_MAX_ATTR_CODEGEN 16 271 272 273/* The assembly of vertices in immediate mode is separated from 274 * display list compilation. This allows a simpler immediate mode 275 * treatment and a display list compiler better suited to 276 * hardware-acceleration. 277 */ 278struct tnl_vtx { 279 GLfloat buffer[VERT_BUFFER_SIZE]; 280 GLubyte attrsz[_TNL_ATTRIB_MAX]; 281 GLuint vertex_size; 282 struct tnl_prim prim[TNL_MAX_PRIM]; 283 GLuint prim_count; 284 GLfloat *vbptr; /* cursor, points into buffer */ 285 GLfloat vertex[_TNL_ATTRIB_MAX*4]; /* current vertex */ 286 GLfloat *attrptr[_TNL_ATTRIB_MAX]; /* points into vertex */ 287 GLfloat *current[_TNL_ATTRIB_MAX]; /* points into ctx->Current, etc */ 288 GLuint counter, initial_counter; 289 struct tnl_copied_vtx copied; 290 291 tnl_attrfv_func tabfv[_TNL_MAX_ATTR_CODEGEN+1][4]; /* plus 1 for ERROR_ATTRIB */ 292 293 struct _tnl_dynfn_lists cache; 294 struct _tnl_dynfn_generators gen; 295 296 struct tnl_eval eval; 297 GLboolean *edgeflag_tmp; 298 GLboolean have_materials; 299}; 300 301 302 303 304/* For display lists, this structure holds a run of vertices of the 305 * same format, and a strictly well-formed set of begin/end pairs, 306 * starting on the first vertex and ending at the last. Vertex 307 * copying on buffer breaks is precomputed according to these 308 * primitives, though there are situations where the copying will need 309 * correction at execute-time, perhaps by replaying the list as 310 * immediate mode commands. 311 * 312 * On executing this list, the 'current' values may be updated with 313 * the values of the final vertex, and often no fixup of the start of 314 * the vertex list is required. 315 * 316 * Eval and other commands that don't fit into these vertex lists are 317 * compiled using the fallback opcode mechanism provided by dlist.c. 318 */ 319struct tnl_vertex_list { 320 GLubyte attrsz[_TNL_ATTRIB_MAX]; 321 GLuint vertex_size; 322 323 GLfloat *buffer; 324 GLuint count; 325 GLuint wrap_count; /* number of copied vertices at start */ 326 GLboolean have_materials; /* bit of a hack - quick check for materials */ 327 GLboolean dangling_attr_ref; /* current attr implicitly referenced 328 outside the list */ 329 330 GLfloat *normal_lengths; 331 struct tnl_prim *prim; 332 GLuint prim_count; 333 334 struct tnl_vertex_store *vertex_store; 335 struct tnl_primitive_store *prim_store; 336}; 337 338/* These buffers should be a reasonable size to support upload to 339 * hardware? Maybe drivers should stitch them back together, or 340 * specify a desired size? 341 */ 342#define SAVE_BUFFER_SIZE (16*1024) 343#define SAVE_PRIM_SIZE 128 344 345/* Storage to be shared among several vertex_lists. 346 */ 347struct tnl_vertex_store { 348 GLfloat buffer[SAVE_BUFFER_SIZE]; 349 GLuint used; 350 GLuint refcount; 351}; 352 353struct tnl_primitive_store { 354 struct tnl_prim buffer[SAVE_PRIM_SIZE]; 355 GLuint used; 356 GLuint refcount; 357}; 358 359 360struct tnl_save { 361 GLubyte attrsz[_TNL_ATTRIB_MAX]; 362 GLuint vertex_size; 363 364 GLfloat *buffer; 365 GLuint count; 366 GLuint wrap_count; 367 GLuint replay_flags; 368 369 struct tnl_prim *prim; 370 GLuint prim_count, prim_max; 371 372 struct tnl_vertex_store *vertex_store; 373 struct tnl_primitive_store *prim_store; 374 375 GLfloat *vbptr; /* cursor, points into buffer */ 376 GLfloat vertex[_TNL_ATTRIB_MAX*4]; /* current values */ 377 GLfloat *attrptr[_TNL_ATTRIB_MAX]; 378 GLuint counter, initial_counter; 379 GLboolean dangling_attr_ref; 380 GLboolean have_materials; 381 382 GLuint opcode_vertex_list; 383 384 struct tnl_copied_vtx copied; 385 386 GLfloat *current[_TNL_ATTRIB_MAX]; /* points into ctx->ListState */ 387 GLubyte *currentsz[_TNL_ATTRIB_MAX]; 388 389 void (*tabfv[_TNL_ATTRIB_MAX][4])( const GLfloat * ); 390}; 391 392 393struct tnl_vertex_arrays 394{ 395 /* Conventional vertex attribute arrays */ 396 GLvector4f Obj; 397 GLvector4f Normal; 398 GLvector4f Color; 399 GLvector4f SecondaryColor; 400 GLvector4f FogCoord; 401 GLvector4f TexCoord[MAX_TEXTURE_COORD_UNITS]; 402 GLvector4f Index; 403 404 GLubyte *EdgeFlag; 405 GLuint *Elt; 406 407 /* These attributes don't alias with the conventional attributes. 408 * The GL_NV_vertex_program extension defines 16 extra sets of vertex 409 * arrays which have precedent over the conventional arrays when enabled. 410 */ 411 GLvector4f Attribs[_TNL_ATTRIB_MAX]; 412}; 413 414 415/** 416 * Contains the current state of a running pipeline. 417 */ 418struct vertex_buffer 419{ 420 /* Constant over life of the vertex_buffer. 421 */ 422 GLuint Size; 423 424 /* Constant over the pipeline. 425 */ 426 GLuint Count; /* for everything except Elts */ 427 428 /* Pointers to current data. 429 */ 430 GLuint *Elts; 431 GLvector4f *ObjPtr; /* _TNL_BIT_POS */ 432 GLvector4f *EyePtr; /* _TNL_BIT_POS */ 433 GLvector4f *ClipPtr; /* _TNL_BIT_POS */ 434 GLvector4f *NdcPtr; /* _TNL_BIT_POS */ 435 GLubyte ClipOrMask; /* _TNL_BIT_POS */ 436 GLubyte ClipAndMask; /* _TNL_BIT_POS */ 437 GLubyte *ClipMask; /* _TNL_BIT_POS */ 438 GLvector4f *NormalPtr; /* _TNL_BIT_NORMAL */ 439 GLfloat *NormalLengthPtr; /* _TNL_BIT_NORMAL */ 440 GLboolean *EdgeFlag; /* _TNL_BIT_EDGEFLAG */ 441 GLvector4f *TexCoordPtr[MAX_TEXTURE_COORD_UNITS]; /* VERT_TEX_0..n */ 442 GLvector4f *IndexPtr[2]; /* _TNL_BIT_INDEX */ 443 GLvector4f *ColorPtr[2]; /* _TNL_BIT_COLOR0 */ 444 GLvector4f *SecondaryColorPtr[2]; /* _TNL_BIT_COLOR1 */ 445 GLvector4f *PointSizePtr; /* _TNL_BIT_POS */ 446 GLvector4f *FogCoordPtr; /* _TNL_BIT_FOG */ 447 448 struct tnl_prim *Primitive; 449 GLuint PrimitiveCount; 450 451 /* Inputs to the vertex program stage */ 452 GLvector4f *AttribPtr[_TNL_ATTRIB_MAX]; /* GL_NV_vertex_program */ 453 454 GLuint LastClipped; 455 /* Private data from _tnl_render_stage that has no business being 456 * in this struct. 457 */ 458}; 459 460 461/** Describes an individual operation on the pipeline. 462 */ 463struct tnl_pipeline_stage 464{ 465 const char *name; 466 GLuint check_state; /* All state referenced in check() -- 467 * When is the pipeline_stage struct 468 * itself invalidated? Must be 469 * constant. 470 */ 471 472 /* Usually constant or set by the 'check' callback: 473 */ 474 GLuint run_state; /* All state referenced in run() -- 475 * When is the cached output of the 476 * stage invalidated? 477 */ 478 479 GLboolean active; /* True if runnable in current state */ 480 GLuint inputs; /* VERT_* inputs to the stage */ 481 GLuint outputs; /* VERT_* outputs of the stage */ 482 483 /* Set in _tnl_run_pipeline(): 484 */ 485 GLuint changed_inputs; /* Generated value -- inputs to the 486 * stage that have changed since last 487 * call to 'run'. 488 */ 489 490 491 /* Private data for the pipeline stage: 492 */ 493 void *privatePtr; 494 495 /* Free private data. May not be null. 496 */ 497 void (*destroy)( struct tnl_pipeline_stage * ); 498 499 /* Called from _tnl_validate_pipeline(). Must update all fields in 500 * the pipeline_stage struct for the current state. 501 */ 502 void (*check)( GLcontext *ctx, struct tnl_pipeline_stage * ); 503 504 /* Called from _tnl_run_pipeline(). The stage.changed_inputs value 505 * encodes all inputs to thee struct which have changed. If 506 * non-zero, recompute all affected outputs of the stage, otherwise 507 * execute any 'sideeffects' of the stage. 508 * 509 * Return value: GL_TRUE - keep going 510 * GL_FALSE - finished pipeline 511 */ 512 GLboolean (*run)( GLcontext *ctx, struct tnl_pipeline_stage * ); 513}; 514 515/** Contains the array of all pipeline stages. 516 * The default values are defined at the end of t_pipeline.c */ 517struct tnl_pipeline { 518 GLuint build_state_trigger; /**< state changes which require build */ 519 GLuint build_state_changes; /**< state changes since last build */ 520 GLuint run_state_changes; /**< state changes since last run */ 521 GLuint run_input_changes; /**< VERT_* changes since last run */ 522 GLuint inputs; /**< VERT_* inputs to pipeline */ 523 /** This array has to end with a NULL-pointer. */ 524 struct tnl_pipeline_stage stages[MAX_PIPELINE_STAGES+1]; 525 GLuint nr_stages; 526}; 527 528struct tnl_clipspace; 529struct tnl_clipspace_attr; 530 531typedef void (*tnl_extract_func)( const struct tnl_clipspace_attr *a, 532 GLfloat *out, 533 const GLubyte *v ); 534 535typedef void (*tnl_insert_func)( const struct tnl_clipspace_attr *a, 536 GLubyte *v, 537 const GLfloat *in ); 538 539typedef void (*tnl_emit_func)( GLcontext *ctx, 540 GLuint count, 541 GLubyte *dest ); 542 543 544/** 545 * Describes how to convert/move a vertex attribute from a vertex array 546 * to a vertex structure. 547 */ 548struct tnl_clipspace_attr 549{ 550 GLuint attrib; /* which vertex attrib (0=position, etc) */ 551 GLuint format; 552 GLuint vertoffset; /* position of the attrib in the vertex struct */ 553 GLuint vertattrsize; /* size of the attribute in bytes */ 554 GLubyte *inputptr; 555 GLuint inputstride; 556 const tnl_insert_func *insert; 557 tnl_insert_func emit; 558 tnl_extract_func extract; 559 const GLfloat *vp; /* NDC->Viewport mapping matrix */ 560}; 561 562 563struct tnl_clipspace_codegen { 564 GLboolean (*emit_header)( struct tnl_clipspace_codegen *, 565 struct tnl_clipspace *); 566 GLboolean (*emit_footer)( struct tnl_clipspace_codegen * ); 567 GLboolean (*emit_attr_header)( struct tnl_clipspace_codegen *, 568 struct tnl_clipspace_attr *, 569 GLint j, GLenum out_type, 570 GLboolean need_vp ); 571 GLboolean (*emit_attr_footer)( struct tnl_clipspace_codegen * ); 572 GLboolean (*emit_mov)( struct tnl_clipspace_codegen *, 573 GLint, GLint ); 574 GLboolean (*emit_const)( struct tnl_clipspace_codegen *, 575 GLint, GLfloat ); 576 GLboolean (*emit_mad)( struct tnl_clipspace_codegen *, 577 GLint, GLint, GLint, GLint ); 578 GLboolean (*emit_float_to_chan)( struct tnl_clipspace_codegen *, 579 GLint, GLint ); 580 GLboolean (*emit_const_chan)( struct tnl_clipspace_codegen *, 581 GLint, GLchan ); 582 GLboolean (*emit_float_to_ubyte)( struct tnl_clipspace_codegen *, 583 GLint, GLint ); 584 GLboolean (*emit_const_ubyte)( struct tnl_clipspace_codegen *, 585 GLint, GLubyte ); 586 tnl_emit_func (*emit_store_func)( struct tnl_clipspace_codegen * ); 587 588 struct _tnl_dynfn codegen_list; 589 590 char *buf; 591 int buf_size; 592 int buf_used; 593 int out_offset; 594}; 595 596 597 598typedef void (*tnl_points_func)( GLcontext *ctx, GLuint first, GLuint last ); 599typedef void (*tnl_line_func)( GLcontext *ctx, GLuint v1, GLuint v2 ); 600typedef void (*tnl_triangle_func)( GLcontext *ctx, 601 GLuint v1, GLuint v2, GLuint v3 ); 602typedef void (*tnl_quad_func)( GLcontext *ctx, GLuint v1, GLuint v2, 603 GLuint v3, GLuint v4 ); 604typedef void (*tnl_render_func)( GLcontext *ctx, GLuint start, GLuint count, 605 GLuint flags ); 606typedef void (*tnl_interp_func)( GLcontext *ctx, 607 GLfloat t, GLuint dst, GLuint out, GLuint in, 608 GLboolean force_boundary ); 609typedef void (*tnl_copy_pv_func)( GLcontext *ctx, GLuint dst, GLuint src ); 610typedef void (*tnl_setup_func)( GLcontext *ctx, 611 GLuint start, GLuint end, 612 GLuint new_inputs); 613 614 615/** 616 * Used to describe conversion of vertex arrays to vertex structures. 617 * I.e. Structure of arrays to arrays of structs. 618 */ 619struct tnl_clipspace 620{ 621 GLboolean need_extras; 622 623 GLuint new_inputs; 624 625 GLubyte *vertex_buf; 626 GLuint vertex_size; 627 GLuint max_vertex_size; 628 629 struct tnl_clipspace_attr attr[_TNL_ATTRIB_MAX]; 630 GLuint attr_count; 631 632 tnl_emit_func emit; 633 tnl_interp_func interp; 634 tnl_copy_pv_func copy_pv; 635 636 struct tnl_clipspace_codegen codegen; 637}; 638 639 640struct tnl_device_driver 641{ 642 /*** 643 *** TNL Pipeline 644 ***/ 645 646 void (*RunPipeline)(GLcontext *ctx); 647 /* Replaces PipelineStart/PipelineFinish -- intended to allow 648 * drivers to wrap _tnl_run_pipeline() with code to validate state 649 * and grab/release hardware locks. 650 */ 651 652 void (*NotifyMaterialChange)(GLcontext *ctx); 653 /* Alert tnl-aware drivers of changes to material. 654 */ 655 656 GLboolean (*NotifyBegin)(GLcontext *ctx, GLenum p); 657 /* Allow drivers to hook in optimized begin/end engines. 658 * Return value: GL_TRUE - driver handled the begin 659 * GL_FALSE - driver didn't handle the begin 660 */ 661 662 /*** 663 *** Rendering -- These functions called only from t_vb_render.c 664 ***/ 665 struct 666 { 667 void (*Start)(GLcontext *ctx); 668 void (*Finish)(GLcontext *ctx); 669 /* Called before and after all rendering operations, including DrawPixels, 670 * ReadPixels, Bitmap, span functions, and CopyTexImage, etc commands. 671 * These are a suitable place for grabbing/releasing hardware locks. 672 */ 673 674 void (*PrimitiveNotify)(GLcontext *ctx, GLenum mode); 675 /* Called between RenderStart() and RenderFinish() to indicate the 676 * type of primitive we're about to draw. Mode will be one of the 677 * modes accepted by glBegin(). 678 */ 679 680 tnl_interp_func Interp; 681 /* The interp function is called by the clipping routines when we need 682 * to generate an interpolated vertex. All pertinant vertex ancilliary 683 * data should be computed by interpolating between the 'in' and 'out' 684 * vertices. 685 */ 686 687 tnl_copy_pv_func CopyPV; 688 /* The copy function is used to make a copy of a vertex. All pertinant 689 * vertex attributes should be copied. 690 */ 691 692 void (*ClippedPolygon)( GLcontext *ctx, const GLuint *elts, GLuint n ); 693 /* Render a polygon with <n> vertices whose indexes are in the <elts> 694 * array. 695 */ 696 697 void (*ClippedLine)( GLcontext *ctx, GLuint v0, GLuint v1 ); 698 /* Render a line between the two vertices given by indexes v0 and v1. */ 699 700 tnl_points_func Points; /* must now respect vb->elts */ 701 tnl_line_func Line; 702 tnl_triangle_func Triangle; 703 tnl_quad_func Quad; 704 /* These functions are called in order to render points, lines, 705 * triangles and quads. These are only called via the T&L module. 706 */ 707 708 tnl_render_func *PrimTabVerts; 709 tnl_render_func *PrimTabElts; 710 /* Render whole unclipped primitives (points, lines, linestrips, 711 * lineloops, etc). The tables are indexed by the GL enum of the 712 * primitive to be rendered. RenderTabVerts is used for non-indexed 713 * arrays of vertices. RenderTabElts is used for indexed arrays of 714 * vertices. 715 */ 716 717 void (*ResetLineStipple)( GLcontext *ctx ); 718 /* Reset the hardware's line stipple counter. 719 */ 720 721 tnl_setup_func BuildVertices; 722 /* This function is called whenever new vertices are required for 723 * rendering. The vertices in question are those n such that start 724 * <= n < end. The new_inputs parameter indicates those fields of 725 * the vertex which need to be updated, if only a partial repair of 726 * the vertex is required. 727 * 728 * This function is called only from _tnl_render_stage in tnl/t_render.c. 729 */ 730 731 732 GLboolean (*Multipass)( GLcontext *ctx, GLuint passno ); 733 /* Driver may request additional render passes by returning GL_TRUE 734 * when this function is called. This function will be called 735 * after the first pass, and passes will be made until the function 736 * returns GL_FALSE. If no function is registered, only one pass 737 * is made. 738 * 739 * This function will be first invoked with passno == 1. 740 */ 741 } Render; 742}; 743 744 745/** 746 * Context state for T&L context. 747 */ 748typedef struct 749{ 750 /* Driver interface. 751 */ 752 struct tnl_device_driver Driver; 753 754 /* Execute: 755 */ 756 struct tnl_vtx vtx; 757 758 /* Compile: 759 */ 760 struct tnl_save save; 761 762 /* Pipeline 763 */ 764 struct tnl_pipeline pipeline; 765 struct vertex_buffer vb; 766 767 /* GLvectors for binding to vb: 768 */ 769 struct tnl_vertex_arrays vtx_inputs; 770 struct tnl_vertex_arrays save_inputs; 771 struct tnl_vertex_arrays current; 772 struct tnl_vertex_arrays array_inputs; 773 774 /* Clipspace/ndc/window vertex managment: 775 */ 776 struct tnl_clipspace clipspace; 777 778 /* Probably need a better configuration mechanism: 779 */ 780 GLboolean NeedNdcCoords; 781 GLboolean LoopbackDListCassettes; 782 GLboolean CalcDListNormalLengths; 783 GLboolean IsolateMaterials; 784 GLboolean AllowVertexFog; 785 GLboolean AllowPixelFog; 786 GLboolean AllowCodegen; 787 788 GLboolean _DoVertexFog; /* eval fog function at each vertex? */ 789 790 GLuint render_inputs; 791 792 GLvertexformat exec_vtxfmt; 793 GLvertexformat save_vtxfmt; 794 795} TNLcontext; 796 797 798 799#define TNL_CONTEXT(ctx) ((TNLcontext *)((ctx)->swtnl_context)) 800 801 802#define TYPE_IDX(t) ((t) & 0xf) 803#define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1 /* 0xa + 1 */ 804 805extern void _tnl_MakeCurrent( GLcontext *ctx, 806 GLframebuffer *drawBuffer, 807 GLframebuffer *readBuffer ); 808 809 810 811 812#endif 813