| 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 |
* 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 |
*/ |
| 95 |
enum { |
| 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 |
*/ |
| 213 |
struct tnl_prim { |
| 214 |
GLuint mode; |
| 215 |
GLuint start; |
| 216 |
GLuint count; |
| 217 |
}; |
| 218 |
|
| 219 |
|
| 220 |
|
| 221 |
struct tnl_eval1_map { |
| 222 |
struct gl_1d_map *map; |
| 223 |
GLuint sz; |
| 224 |
}; |
| 225 |
|
| 226 |
struct tnl_eval2_map { |
| 227 |
struct gl_2d_map *map; |
| 228 |
GLuint sz; |
| 229 |
}; |
| 230 |
|
| 231 |
struct 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 |
|
| 241 |
struct 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 |
|
| 249 |
typedef void (*tnl_attrfv_func)( const GLfloat * ); |
| 250 |
|
| 251 |
struct _tnl_dynfn { |
| 252 |
struct _tnl_dynfn *next, *prev; |
| 253 |
GLuint key; |
| 254 |
char *code; |
| 255 |
}; |
| 256 |
|
| 257 |
struct _tnl_dynfn_lists { |
| 258 |
struct _tnl_dynfn Vertex[4]; |
| 259 |
struct _tnl_dynfn Attribute[4]; |
| 260 |
}; |
| 261 |
|
| 262 |
struct _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 |
*/ |
| 275 |
struct 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 |
*/ |
| 317 |
struct 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 |
*/ |
| 345 |
struct tnl_vertex_store { |
| 346 |
GLfloat buffer[SAVE_BUFFER_SIZE]; |
| 347 |
GLuint used; |
| 348 |
GLuint refcount; |
| 349 |
}; |
| 350 |
|
| 351 |
struct tnl_primitive_store { |
| 352 |
struct tnl_prim buffer[SAVE_PRIM_SIZE]; |
| 353 |
GLuint used; |
| 354 |
GLuint refcount; |
| 355 |
}; |
| 356 |
|
| 357 |
|
| 358 |
struct 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 |
|
| 393 |
struct 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 |
*/ |
| 418 |
struct 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 |
*/ |
| 463 |
struct 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 |
*/ |
| 500 |
struct 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 |
|
| 511 |
struct tnl_clipspace; |
| 512 |
struct tnl_clipspace_attr; |
| 513 |
|
| 514 |
typedef void (*tnl_extract_func)( const struct tnl_clipspace_attr *a, |
| 515 |
GLfloat *out, |
| 516 |
const GLubyte *v ); |
| 517 |
|
| 518 |
typedef void (*tnl_insert_func)( const struct tnl_clipspace_attr *a, |
| 519 |
GLubyte *v, |
| 520 |
const GLfloat *in ); |
| 521 |
|
| 522 |
typedef 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 |
*/ |
| 531 |
struct 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 |
|
| 549 |
typedef void (*tnl_points_func)( GLcontext *ctx, GLuint first, GLuint last ); |
| 550 |
typedef void (*tnl_line_func)( GLcontext *ctx, GLuint v1, GLuint v2 ); |
| 551 |
typedef void (*tnl_triangle_func)( GLcontext *ctx, |
| 552 |
GLuint v1, GLuint v2, GLuint v3 ); |
| 553 |
typedef void (*tnl_quad_func)( GLcontext *ctx, GLuint v1, GLuint v2, |
| 554 |
GLuint v3, GLuint v4 ); |
| 555 |
typedef void (*tnl_render_func)( GLcontext *ctx, GLuint start, GLuint count, |
| 556 |
GLuint flags ); |
| 557 |
typedef void (*tnl_interp_func)( GLcontext *ctx, |
| 558 |
GLfloat t, GLuint dst, GLuint out, GLuint in, |
| 559 |
GLboolean force_boundary ); |
| 560 |
typedef void (*tnl_copy_pv_func)( GLcontext *ctx, GLuint dst, GLuint src ); |
| 561 |
typedef void (*tnl_setup_func)( GLcontext *ctx, |
| 562 |
GLuint start, GLuint end, |
| 563 |
GLuint new_inputs); |
| 564 |
|
| 565 |
|
| 566 |
struct 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 |
*/ |
| 586 |
struct 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 |
|
| 618 |
struct tnl_cache { |
| 619 |
GLuint hash; |
| 620 |
void *key; |
| 621 |
void *data; |
| 622 |
struct tnl_cache *next; |
| 623 |
}; |
| 624 |
|
| 625 |
|
| 626 |
struct 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 |
*/ |
| 734 |
typedef 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 |
/* If True, it means we started a glBegin/End primtive with an invalid |
| 777 |
* vertex/fragment program or incomplete framebuffer. In that case, |
| 778 |
* discard any buffered vertex data. |
| 779 |
*/ |
| 780 |
GLboolean DiscardPrimitive; |
| 781 |
|
| 782 |
GLuint render_inputs; |
| 783 |
|
| 784 |
GLvertexformat exec_vtxfmt; |
| 785 |
GLvertexformat save_vtxfmt; |
| 786 |
|
| 787 |
struct tnl_cache *vp_cache; |
| 788 |
|
| 789 |
} TNLcontext; |
| 790 |
|
| 791 |
|
| 792 |
|
| 793 |
#define TNL_CONTEXT(ctx) ((TNLcontext *)((ctx)->swtnl_context)) |
| 794 |
|
| 795 |
|
| 796 |
#define TYPE_IDX(t) ((t) & 0xf) |
| 797 |
#define MAX_TYPES TYPE_IDX(GL_DOUBLE)+1 /* 0xa + 1 */ |
| 798 |
|
| 799 |
extern void _tnl_MakeCurrent( GLcontext *ctx, |
| 800 |
GLframebuffer *drawBuffer, |
| 801 |
GLframebuffer *readBuffer ); |
| 802 |
|
| 803 |
|
| 804 |
|
| 805 |
|
| 806 |
#endif |