t_context.h revision b43671c8bf0ff640243c670ff98225d2a3c10632
1/* 2 * mesa 3-D graphics library 3 * Version: 6.5 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 * Note: The first attributes match the VERT_ATTRIB_* definitions 87 * in mtypes.h. However, the tnl module has additional attributes 88 * for materials, color indexes, edge flags, etc. 89 */ 90/* Although it's nice to use these as bit indexes in a DWORD flag, we 91 * could manage without if necessary. Another limit currently is the 92 * number of bits allocated for these numbers in places like vertex 93 * program instruction formats and register layouts. 94 */ 95enum { 96 _TNL_ATTRIB_POS = 0, 97 _TNL_ATTRIB_WEIGHT = 1, 98 _TNL_ATTRIB_NORMAL = 2, 99 _TNL_ATTRIB_COLOR0 = 3, 100 _TNL_ATTRIB_COLOR1 = 4, 101 _TNL_ATTRIB_FOG = 5, 102 _TNL_ATTRIB_SIX = 6, 103 _TNL_ATTRIB_SEVEN = 7, 104 _TNL_ATTRIB_TEX0 = 8, 105 _TNL_ATTRIB_TEX1 = 9, 106 _TNL_ATTRIB_TEX2 = 10, 107 _TNL_ATTRIB_TEX3 = 11, 108 _TNL_ATTRIB_TEX4 = 12, 109 _TNL_ATTRIB_TEX5 = 13, 110 _TNL_ATTRIB_TEX6 = 14, 111 _TNL_ATTRIB_TEX7 = 15, 112 _TNL_ATTRIB_MAT_FRONT_AMBIENT = 16, 113 _TNL_ATTRIB_MAT_BACK_AMBIENT = 17, 114 _TNL_ATTRIB_MAT_FRONT_DIFFUSE = 18, 115 _TNL_ATTRIB_MAT_BACK_DIFFUSE = 19, 116 _TNL_ATTRIB_MAT_FRONT_SPECULAR = 20, 117 _TNL_ATTRIB_MAT_BACK_SPECULAR = 21, 118 _TNL_ATTRIB_MAT_FRONT_EMISSION = 22, 119 _TNL_ATTRIB_MAT_BACK_EMISSION = 23, 120 _TNL_ATTRIB_MAT_FRONT_SHININESS = 24, 121 _TNL_ATTRIB_MAT_BACK_SHININESS = 25, 122 _TNL_ATTRIB_MAT_FRONT_INDEXES = 26, 123 _TNL_ATTRIB_MAT_BACK_INDEXES = 27, 124 _TNL_ATTRIB_INDEX = 28, 125 _TNL_ATTRIB_EDGEFLAG = 29, 126 _TNL_ATTRIB_POINTSIZE = 30, 127 _TNL_ATTRIB_MAX = 31 128} ; 129 130/* Will probably have to revise this scheme fairly shortly, eg. by 131 * compacting all the MAT flags down to one bit, or by using two 132 * dwords to store the flags. 133 */ 134#define _TNL_BIT_POS (1<<0) 135#define _TNL_BIT_WEIGHT (1<<1) 136#define _TNL_BIT_NORMAL (1<<2) 137#define _TNL_BIT_COLOR0 (1<<3) 138#define _TNL_BIT_COLOR1 (1<<4) 139#define _TNL_BIT_FOG (1<<5) 140#define _TNL_BIT_SIX (1<<6) 141#define _TNL_BIT_SEVEN (1<<7) 142#define _TNL_BIT_TEX0 (1<<8) 143#define _TNL_BIT_TEX1 (1<<9) 144#define _TNL_BIT_TEX2 (1<<10) 145#define _TNL_BIT_TEX3 (1<<11) 146#define _TNL_BIT_TEX4 (1<<12) 147#define _TNL_BIT_TEX5 (1<<13) 148#define _TNL_BIT_TEX6 (1<<14) 149#define _TNL_BIT_TEX7 (1<<15) 150#define _TNL_BIT_MAT_FRONT_AMBIENT (1<<16) 151#define _TNL_BIT_MAT_BACK_AMBIENT (1<<17) 152#define _TNL_BIT_MAT_FRONT_DIFFUSE (1<<18) 153#define _TNL_BIT_MAT_BACK_DIFFUSE (1<<19) 154#define _TNL_BIT_MAT_FRONT_SPECULAR (1<<20) 155#define _TNL_BIT_MAT_BACK_SPECULAR (1<<21) 156#define _TNL_BIT_MAT_FRONT_EMISSION (1<<22) 157#define _TNL_BIT_MAT_BACK_EMISSION (1<<23) 158#define _TNL_BIT_MAT_FRONT_SHININESS (1<<24) 159#define _TNL_BIT_MAT_BACK_SHININESS (1<<25) 160#define _TNL_BIT_MAT_FRONT_INDEXES (1<<26) 161#define _TNL_BIT_MAT_BACK_INDEXES (1<<27) 162#define _TNL_BIT_INDEX (1<<28) 163#define _TNL_BIT_EDGEFLAG (1<<29) 164#define _TNL_BIT_POINTSIZE (1<<30) 165 166#define _TNL_BIT_TEX(u) (1 << (_TNL_ATTRIB_TEX0 + (u))) 167 168 169 170#define _TNL_BITS_MAT_ANY (_TNL_BIT_MAT_FRONT_AMBIENT | \ 171 _TNL_BIT_MAT_BACK_AMBIENT | \ 172 _TNL_BIT_MAT_FRONT_DIFFUSE | \ 173 _TNL_BIT_MAT_BACK_DIFFUSE | \ 174 _TNL_BIT_MAT_FRONT_SPECULAR | \ 175 _TNL_BIT_MAT_BACK_SPECULAR | \ 176 _TNL_BIT_MAT_FRONT_EMISSION | \ 177 _TNL_BIT_MAT_BACK_EMISSION | \ 178 _TNL_BIT_MAT_FRONT_SHININESS | \ 179 _TNL_BIT_MAT_BACK_SHININESS | \ 180 _TNL_BIT_MAT_FRONT_INDEXES | \ 181 _TNL_BIT_MAT_BACK_INDEXES) 182 183 184#define _TNL_BITS_TEX_ANY (_TNL_BIT_TEX0 | \ 185 _TNL_BIT_TEX1 | \ 186 _TNL_BIT_TEX2 | \ 187 _TNL_BIT_TEX3 | \ 188 _TNL_BIT_TEX4 | \ 189 _TNL_BIT_TEX5 | \ 190 _TNL_BIT_TEX6 | \ 191 _TNL_BIT_TEX7) 192 193 194#define _TNL_BITS_PROG_ANY (_TNL_BIT_POS | \ 195 _TNL_BIT_WEIGHT | \ 196 _TNL_BIT_NORMAL | \ 197 _TNL_BIT_COLOR0 | \ 198 _TNL_BIT_COLOR1 | \ 199 _TNL_BIT_FOG | \ 200 _TNL_BIT_SIX | \ 201 _TNL_BIT_SEVEN | \ 202 _TNL_BITS_TEX_ANY) 203 204 205 206#define PRIM_BEGIN 0x10 207#define PRIM_END 0x20 208#define PRIM_WEAK 0x40 209#define PRIM_MODE_MASK 0x0f 210 211/* 212 */ 213struct tnl_prim { 214 GLuint mode; 215 GLuint start; 216 GLuint count; 217}; 218 219 220 221struct tnl_eval1_map { 222 struct gl_1d_map *map; 223 GLuint sz; 224}; 225 226struct tnl_eval2_map { 227 struct gl_2d_map *map; 228 GLuint sz; 229}; 230 231struct tnl_eval { 232 GLuint new_state; 233 struct tnl_eval1_map map1[_TNL_ATTRIB_INDEX + 1]; 234 struct tnl_eval2_map map2[_TNL_ATTRIB_INDEX + 1]; 235}; 236 237 238#define TNL_MAX_PRIM 16 239#define TNL_MAX_COPIED_VERTS 3 240 241struct tnl_copied_vtx { 242 GLfloat buffer[_TNL_ATTRIB_MAX * 4 * TNL_MAX_COPIED_VERTS]; 243 GLuint nr; 244}; 245 246#define VERT_BUFFER_SIZE 2048 /* 8kbytes */ 247 248 249typedef void (*tnl_attrfv_func)( const GLfloat * ); 250 251struct _tnl_dynfn { 252 struct _tnl_dynfn *next, *prev; 253 GLuint key; 254 char *code; 255}; 256 257struct _tnl_dynfn_lists { 258 struct _tnl_dynfn Vertex[4]; 259 struct _tnl_dynfn Attribute[4]; 260}; 261 262struct _tnl_dynfn_generators { 263 struct _tnl_dynfn *(*Vertex[4])( GLcontext *ctx, int key ); 264 struct _tnl_dynfn *(*Attribute[4])( GLcontext *ctx, int key ); 265}; 266 267#define _TNL_MAX_ATTR_CODEGEN 16 268 269 270/* The assembly of vertices in immediate mode is separated from 271 * display list compilation. This allows a simpler immediate mode 272 * treatment and a display list compiler better suited to 273 * hardware-acceleration. 274 */ 275struct tnl_vtx { 276 GLfloat buffer[VERT_BUFFER_SIZE]; 277 GLubyte attrsz[_TNL_ATTRIB_MAX]; 278 GLuint vertex_size; 279 struct tnl_prim prim[TNL_MAX_PRIM]; 280 GLuint prim_count; 281 GLfloat *vbptr; /* cursor, points into buffer */ 282 GLfloat vertex[_TNL_ATTRIB_MAX*4]; /* current vertex */ 283 GLfloat *attrptr[_TNL_ATTRIB_MAX]; /* points into vertex */ 284 GLfloat *current[_TNL_ATTRIB_MAX]; /* points into ctx->Current, etc */ 285 GLfloat CurrentFloatEdgeFlag; 286 GLuint counter, initial_counter; 287 struct tnl_copied_vtx copied; 288 289 tnl_attrfv_func tabfv[_TNL_MAX_ATTR_CODEGEN+1][4]; /* plus 1 for ERROR_ATTRIB */ 290 291 struct _tnl_dynfn_lists cache; 292 struct _tnl_dynfn_generators gen; 293 294 struct tnl_eval eval; 295 GLboolean *edgeflag_tmp; 296 GLboolean have_materials; 297}; 298 299 300 301 302/* For display lists, this structure holds a run of vertices of the 303 * same format, and a strictly well-formed set of begin/end pairs, 304 * starting on the first vertex and ending at the last. Vertex 305 * copying on buffer breaks is precomputed according to these 306 * primitives, though there are situations where the copying will need 307 * correction at execute-time, perhaps by replaying the list as 308 * immediate mode commands. 309 * 310 * On executing this list, the 'current' values may be updated with 311 * the values of the final vertex, and often no fixup of the start of 312 * the vertex list is required. 313 * 314 * Eval and other commands that don't fit into these vertex lists are 315 * compiled using the fallback opcode mechanism provided by dlist.c. 316 */ 317struct tnl_vertex_list { 318 GLubyte attrsz[_TNL_ATTRIB_MAX]; 319 GLuint vertex_size; 320 321 GLfloat *buffer; 322 GLuint count; 323 GLuint wrap_count; /* number of copied vertices at start */ 324 GLboolean have_materials; /* bit of a hack - quick check for materials */ 325 GLboolean dangling_attr_ref; /* current attr implicitly referenced 326 outside the list */ 327 328 GLfloat *normal_lengths; 329 struct tnl_prim *prim; 330 GLuint prim_count; 331 332 struct tnl_vertex_store *vertex_store; 333 struct tnl_primitive_store *prim_store; 334}; 335 336/* These buffers should be a reasonable size to support upload to 337 * hardware? Maybe drivers should stitch them back together, or 338 * specify a desired size? 339 */ 340#define SAVE_BUFFER_SIZE (16*1024) 341#define SAVE_PRIM_SIZE 128 342 343/* Storage to be shared among several vertex_lists. 344 */ 345struct tnl_vertex_store { 346 GLfloat buffer[SAVE_BUFFER_SIZE]; 347 GLuint used; 348 GLuint refcount; 349}; 350 351struct tnl_primitive_store { 352 struct tnl_prim buffer[SAVE_PRIM_SIZE]; 353 GLuint used; 354 GLuint refcount; 355}; 356 357 358struct tnl_save { 359 GLubyte attrsz[_TNL_ATTRIB_MAX]; 360 GLuint vertex_size; 361 362 GLfloat *buffer; 363 GLuint count; 364 GLuint wrap_count; 365 GLuint replay_flags; 366 367 struct tnl_prim *prim; 368 GLuint prim_count, prim_max; 369 370 struct tnl_vertex_store *vertex_store; 371 struct tnl_primitive_store *prim_store; 372 373 GLfloat *vbptr; /* cursor, points into buffer */ 374 GLfloat vertex[_TNL_ATTRIB_MAX*4]; /* current values */ 375 GLfloat *attrptr[_TNL_ATTRIB_MAX]; 376 GLuint counter, initial_counter; 377 GLboolean dangling_attr_ref; 378 GLboolean have_materials; 379 380 GLuint opcode_vertex_list; 381 382 struct tnl_copied_vtx copied; 383 384 GLfloat CurrentFloatEdgeFlag; 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 467 /* Private data for the pipeline stage: 468 */ 469 void *privatePtr; 470 471 /* Allocate private data 472 */ 473 GLboolean (*create)( GLcontext *ctx, struct tnl_pipeline_stage * ); 474 475 /* Free private data. 476 */ 477 void (*destroy)( struct tnl_pipeline_stage * ); 478 479 /* Called on any statechange or input array size change or 480 * input array change to/from zero stride. 481 */ 482 void (*validate)( GLcontext *ctx, struct tnl_pipeline_stage * ); 483 484 /* Called from _tnl_run_pipeline(). The stage.changed_inputs value 485 * encodes all inputs to thee struct which have changed. If 486 * non-zero, recompute all affected outputs of the stage, otherwise 487 * execute any 'sideeffects' of the stage. 488 * 489 * Return value: GL_TRUE - keep going 490 * GL_FALSE - finished pipeline 491 */ 492 GLboolean (*run)( GLcontext *ctx, struct tnl_pipeline_stage * ); 493}; 494 495 496 497/** Contains the array of all pipeline stages. 498 * The default values are defined at the end of t_pipeline.c 499 */ 500struct tnl_pipeline { 501 502 GLuint last_attrib_stride[_TNL_ATTRIB_MAX]; 503 GLuint last_attrib_size[_TNL_ATTRIB_MAX]; 504 GLuint input_changes; 505 GLuint new_state; 506 507 struct tnl_pipeline_stage stages[MAX_PIPELINE_STAGES+1]; 508 GLuint nr_stages; 509}; 510 511struct tnl_clipspace; 512struct tnl_clipspace_attr; 513 514typedef void (*tnl_extract_func)( const struct tnl_clipspace_attr *a, 515 GLfloat *out, 516 const GLubyte *v ); 517 518typedef void (*tnl_insert_func)( const struct tnl_clipspace_attr *a, 519 GLubyte *v, 520 const GLfloat *in ); 521 522typedef void (*tnl_emit_func)( GLcontext *ctx, 523 GLuint count, 524 GLubyte *dest ); 525 526 527/** 528 * Describes how to convert/move a vertex attribute from a vertex array 529 * to a vertex structure. 530 */ 531struct tnl_clipspace_attr 532{ 533 GLuint attrib; /* which vertex attrib (0=position, etc) */ 534 GLuint format; 535 GLuint vertoffset; /* position of the attrib in the vertex struct */ 536 GLuint vertattrsize; /* size of the attribute in bytes */ 537 GLubyte *inputptr; 538 GLuint inputstride; 539 GLuint inputsize; 540 const tnl_insert_func *insert; 541 tnl_insert_func emit; 542 tnl_extract_func extract; 543 const GLfloat *vp; /* NDC->Viewport mapping matrix */ 544}; 545 546 547 548 549typedef void (*tnl_points_func)( GLcontext *ctx, GLuint first, GLuint last ); 550typedef void (*tnl_line_func)( GLcontext *ctx, GLuint v1, GLuint v2 ); 551typedef void (*tnl_triangle_func)( GLcontext *ctx, 552 GLuint v1, GLuint v2, GLuint v3 ); 553typedef void (*tnl_quad_func)( GLcontext *ctx, GLuint v1, GLuint v2, 554 GLuint v3, GLuint v4 ); 555typedef void (*tnl_render_func)( GLcontext *ctx, GLuint start, GLuint count, 556 GLuint flags ); 557typedef void (*tnl_interp_func)( GLcontext *ctx, 558 GLfloat t, GLuint dst, GLuint out, GLuint in, 559 GLboolean force_boundary ); 560typedef void (*tnl_copy_pv_func)( GLcontext *ctx, GLuint dst, GLuint src ); 561typedef void (*tnl_setup_func)( GLcontext *ctx, 562 GLuint start, GLuint end, 563 GLuint new_inputs); 564 565 566struct tnl_clipspace_fastpath { 567 GLuint vertex_size; 568 GLuint attr_count; 569 GLboolean match_strides; 570 571 struct { 572 GLuint format; 573 GLuint size; 574 GLuint stride; 575 GLuint offset; 576 } *attr; 577 578 tnl_emit_func func; 579 struct tnl_clipspace_fastpath *next; 580}; 581 582/** 583 * Used to describe conversion of vertex arrays to vertex structures. 584 * I.e. Structure of arrays to arrays of structs. 585 */ 586struct tnl_clipspace 587{ 588 GLboolean need_extras; 589 590 GLuint new_inputs; 591 592 GLubyte *vertex_buf; 593 GLuint vertex_size; 594 GLuint max_vertex_size; 595 596 struct tnl_clipspace_attr attr[_TNL_ATTRIB_MAX]; 597 GLuint attr_count; 598 599 tnl_emit_func emit; 600 tnl_interp_func interp; 601 tnl_copy_pv_func copy_pv; 602 603 /* Parameters and constants for codegen: 604 */ 605 GLboolean need_viewport; 606 GLfloat vp_scale[4]; 607 GLfloat vp_xlate[4]; 608 GLfloat chan_scale[4]; 609 GLfloat identity[4]; 610 611 struct tnl_clipspace_fastpath *fastpath; 612 613 void (*codegen_emit)( GLcontext *ctx ); 614}; 615 616 617 618struct tnl_cache { 619 GLuint hash; 620 void *key; 621 void *data; 622 struct tnl_cache *next; 623}; 624 625 626struct tnl_device_driver 627{ 628 /*** 629 *** TNL Pipeline 630 ***/ 631 632 void (*RunPipeline)(GLcontext *ctx); 633 /* Replaces PipelineStart/PipelineFinish -- intended to allow 634 * drivers to wrap _tnl_run_pipeline() with code to validate state 635 * and grab/release hardware locks. 636 */ 637 638 void (*NotifyMaterialChange)(GLcontext *ctx); 639 /* Alert tnl-aware drivers of changes to material. 640 */ 641 642 GLboolean (*NotifyBegin)(GLcontext *ctx, GLenum p); 643 /* Allow drivers to hook in optimized begin/end engines. 644 * Return value: GL_TRUE - driver handled the begin 645 * GL_FALSE - driver didn't handle the begin 646 */ 647 648 /*** 649 *** Rendering -- These functions called only from t_vb_render.c 650 ***/ 651 struct 652 { 653 void (*Start)(GLcontext *ctx); 654 void (*Finish)(GLcontext *ctx); 655 /* Called before and after all rendering operations, including DrawPixels, 656 * ReadPixels, Bitmap, span functions, and CopyTexImage, etc commands. 657 * These are a suitable place for grabbing/releasing hardware locks. 658 */ 659 660 void (*PrimitiveNotify)(GLcontext *ctx, GLenum mode); 661 /* Called between RenderStart() and RenderFinish() to indicate the 662 * type of primitive we're about to draw. Mode will be one of the 663 * modes accepted by glBegin(). 664 */ 665 666 tnl_interp_func Interp; 667 /* The interp function is called by the clipping routines when we need 668 * to generate an interpolated vertex. All pertinant vertex ancilliary 669 * data should be computed by interpolating between the 'in' and 'out' 670 * vertices. 671 */ 672 673 tnl_copy_pv_func CopyPV; 674 /* The copy function is used to make a copy of a vertex. All pertinant 675 * vertex attributes should be copied. 676 */ 677 678 void (*ClippedPolygon)( GLcontext *ctx, const GLuint *elts, GLuint n ); 679 /* Render a polygon with <n> vertices whose indexes are in the <elts> 680 * array. 681 */ 682 683 void (*ClippedLine)( GLcontext *ctx, GLuint v0, GLuint v1 ); 684 /* Render a line between the two vertices given by indexes v0 and v1. */ 685 686 tnl_points_func Points; /* must now respect vb->elts */ 687 tnl_line_func Line; 688 tnl_triangle_func Triangle; 689 tnl_quad_func Quad; 690 /* These functions are called in order to render points, lines, 691 * triangles and quads. These are only called via the T&L module. 692 */ 693 694 tnl_render_func *PrimTabVerts; 695 tnl_render_func *PrimTabElts; 696 /* Render whole unclipped primitives (points, lines, linestrips, 697 * lineloops, etc). The tables are indexed by the GL enum of the 698 * primitive to be rendered. RenderTabVerts is used for non-indexed 699 * arrays of vertices. RenderTabElts is used for indexed arrays of 700 * vertices. 701 */ 702 703 void (*ResetLineStipple)( GLcontext *ctx ); 704 /* Reset the hardware's line stipple counter. 705 */ 706 707 tnl_setup_func BuildVertices; 708 /* This function is called whenever new vertices are required for 709 * rendering. The vertices in question are those n such that start 710 * <= n < end. The new_inputs parameter indicates those fields of 711 * the vertex which need to be updated, if only a partial repair of 712 * the vertex is required. 713 * 714 * This function is called only from _tnl_render_stage in tnl/t_render.c. 715 */ 716 717 718 GLboolean (*Multipass)( GLcontext *ctx, GLuint passno ); 719 /* Driver may request additional render passes by returning GL_TRUE 720 * when this function is called. This function will be called 721 * after the first pass, and passes will be made until the function 722 * returns GL_FALSE. If no function is registered, only one pass 723 * is made. 724 * 725 * This function will be first invoked with passno == 1. 726 */ 727 } Render; 728}; 729 730 731/** 732 * Context state for T&L context. 733 */ 734typedef struct 735{ 736 /* Driver interface. 737 */ 738 struct tnl_device_driver Driver; 739 740 /* Execute: 741 */ 742 struct tnl_vtx vtx; 743 744 /* Compile: 745 */ 746 struct tnl_save save; 747 748 /* Pipeline 749 */ 750 struct tnl_pipeline pipeline; 751 struct vertex_buffer vb; 752 753 /* GLvectors for binding to vb: 754 */ 755 struct tnl_vertex_arrays vtx_inputs; 756 struct tnl_vertex_arrays save_inputs; 757 struct tnl_vertex_arrays current; 758 struct tnl_vertex_arrays array_inputs; 759 760 /* Clipspace/ndc/window vertex managment: 761 */ 762 struct tnl_clipspace clipspace; 763 764 /* Probably need a better configuration mechanism: 765 */ 766 GLboolean NeedNdcCoords; 767 GLboolean LoopbackDListCassettes; 768 GLboolean CalcDListNormalLengths; 769 GLboolean IsolateMaterials; 770 GLboolean AllowVertexFog; 771 GLboolean AllowPixelFog; 772 GLboolean AllowCodegen; 773 774 GLboolean _DoVertexFog; /* eval fog function at each vertex? */ 775 776 GLuint render_inputs; 777 778 GLvertexformat exec_vtxfmt; 779 GLvertexformat save_vtxfmt; 780 781 struct tnl_cache *vp_cache; 782 783} TNLcontext; 784 785 786 787#define TNL_CONTEXT(ctx) ((TNLcontext *)((ctx)->swtnl_context)) 788 789 790#define TYPE_IDX(t) ((t) & 0xf) 791#define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1 /* 0xa + 1 */ 792 793 794#endif 795