Core of the future vertex engine. Isn't built yet, nor will be for a while...

Checkpoint commit.

1 files changed, 636 insertions, 0 deletions

diff --git a/src/mesa/tnl/t_vtx_exec.c b/src/mesa/tnl/t_vtx_exec.c
new file mode 100644
index 0000000000..8470d6ab35
--- /dev/null
+++ b/src/mesa/tnl/t_vtx_exec.c
@@ -0,0 +1,636 @@
+/* $XFree86$ */
+/**************************************************************************
+
+Copyright 2002 Tungsten Graphics Inc., Cedar Park, Texas.
+
+All Rights Reserved.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+on the rights to use, copy, modify, merge, publish, distribute, sub
+license, and/or sell copies of the Software, and to permit persons to whom
+the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next
+paragraph) shall be included in all copies or substantial portions of the
+Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
+TUNGSTEN GRAPHICS AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+**************************************************************************/
+
+/*
+ * Authors:
+ *   Keith Whitwell <keith@tungstengraphics.com>
+ *
+ */
+#include "api_noop.h"
+#include "api_arrayelt.h"
+#include "context.h"
+#include "mem.h"
+#include "mmath.h"
+#include "mtypes.h"
+#include "enums.h"
+#include "glapi.h"
+#include "colormac.h"
+#include "light.h"
+#include "state.h"
+#include "vtxfmt.h"
+
+#include "tnl/tnl.h"
+#include "tnl/t_context.h"
+#include "tnl/t_array_api.h"
+
+static void _tnl_FlushVertices( GLcontext *, GLuint );
+
+
+void tnl_copy_to_current( GLcontext *ctx ) 
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+   GLuint flag = tnl->vertex_format;
+   GLint i;
+
+   assert(ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT);
+
+   for (i = 0 ; i < 16 ; i++)
+      if (flag & (1<<i))
+	 COPY_4FV( ctx->Current.Attrib[i], tnl->attribptr[i] );
+
+   if (flag & VERT_BIT_INDEX)
+      ctx->Current.Index = tnl->indexptr[0];
+
+   if (flag & VERT_BIT_EDGEFLAG)
+      ctx->Current.EdgeFlag = tnl->edgeflagptr[0];
+
+   if (flag & VERT_BIT_MATERIAL) {
+      _mesa_update_material( ctx,
+			  IM->Material[IM->LastMaterial],
+			  IM->MaterialOrMask );
+
+      tnl->Driver.NotifyMaterialChange( ctx );
+   }
+
+
+   ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT;
+}
+
+static GLboolean discreet_gl_prim[GL_POLYGON+1] = {
+   1,				/* 0 points */
+   1,				/* 1 lines */
+   0,				/* 2 line_strip */
+   0,				/* 3 line_loop */
+   1,				/* 4 tris */
+   0,				/* 5 tri_fan */
+   0,				/* 6 tri_strip */
+   1,				/* 7 quads */
+   0,				/* 8 quadstrip */
+   0,				/* 9 poly */
+};
+
+/* Optimize the primitive list:  ONLY FOR EXECUTE ATM
+ */
+static void optimize_prims( TNLcontext *tnl )
+{
+   int i, j;
+
+   if (tnl->nrprims <= 1)
+      return;
+
+   for (j = 0, i = 1 ; i < tnl->nrprims; i++) {
+      int pj = tnl->primlist[j].prim & 0xf;
+      int pi = tnl->primlist[i].prim & 0xf;
+      
+      if (pj == pi && discreet_gl_prim[pj] &&
+	  tnl->primlist[i].start == tnl->primlist[j].end) {
+	 tnl->primlist[j].end = tnl->primlist[i].end;
+      }
+      else {
+	 j++;
+	 if (j != i) tnl->primlist[j] = tnl->primlist[i];
+      }
+   }
+
+   tnl->nrprims = j+1;
+}
+
+
+/* Bind vertex buffer pointers, run pipeline:
+ */
+static void flush_prims( TNLcontext *tnl )
+{
+   int i,j;
+
+   tnl->dma.current.ptr = tnl->dma.current.start += 
+      (tnl->initial_counter - tnl->counter) * tnl->vertex_size * 4; 
+
+   tnl->tcl.vertex_format = tnl->vertex_format;
+   tnl->tcl.aos_components[0] = &tmp;
+   tnl->tcl.nr_aos_components = 1;
+   tnl->dma.flush = 0;
+
+   tnl->Driver.RunPipeline( ... );
+   
+   tnl->nrprims = 0;
+}
+
+
+static void start_prim( TNLcontext *tnl, GLuint mode )
+{
+   if (MESA_VERBOSE & DEBUG_VFMT)
+      fprintf(stderr, "%s %d\n", __FUNCTION__, 
+	      tnl->initial_counter - tnl->counter);
+
+   tnl->primlist[tnl->nrprims].start = tnl->initial_counter - tnl->counter;
+   tnl->primlist[tnl->nrprims].prim = mode;
+}
+
+static void note_last_prim( TNLcontext *tnl, GLuint flags )
+{
+   if (MESA_VERBOSE & DEBUG_VFMT)
+      fprintf(stderr, "%s %d\n", __FUNCTION__, 
+	      tnl->initial_counter - tnl->counter);
+
+   if (tnl->prim[0] != GL_POLYGON+1) {
+      tnl->primlist[tnl->nrprims].prim |= flags;
+      tnl->primlist[tnl->nrprims].end = tnl->initial_counter - tnl->counter;
+
+      if (++tnl->nrprims == TNL_MAX_PRIMS)
+	 flush_prims( tnl );
+   }
+}
+
+
+static void copy_vertex( TNLcontext *tnl, GLuint n, GLfloat *dst )
+{
+   GLuint i;
+   GLfloat *src = (GLfloat *)(tnl->dma.current.address + 
+			      tnl->dma.current.ptr + 
+			      (tnl->primlist[tnl->nrprims].start + n) * 
+			      tnl->vertex_size * 4);
+
+   if (MESA_VERBOSE & DEBUG_VFMT) 
+      fprintf(stderr, "copy_vertex %d\n", 
+	      tnl->primlist[tnl->nrprims].start + n);
+
+   for (i = 0 ; i < tnl->vertex_size; i++) {
+      dst[i] = src[i];
+   }
+}
+
+/* NOTE: This actually reads the copied vertices back from uncached
+ * memory.  Could also use the counter/notify mechanism to populate
+ * tmp on the fly as vertices are generated.  
+ */
+static GLuint copy_wrapped_verts( TNLcontext *tnl, GLfloat (*tmp)[15] )
+{
+   GLuint ovf, i;
+   GLuint nr = (tnl->initial_counter - tnl->counter) - tnl->primlist[tnl->nrprims].start;
+
+   if (MESA_VERBOSE & DEBUG_VFMT)
+      fprintf(stderr, "%s %d verts\n", __FUNCTION__, nr);
+
+   switch( tnl->prim[0] )
+   {
+   case GL_POINTS:
+      return 0;
+   case GL_LINES:
+      ovf = nr&1;
+      for (i = 0 ; i < ovf ; i++)
+	 copy_vertex( tnl, nr-ovf+i, tmp[i] );
+      return i;
+   case GL_TRIANGLES:
+      ovf = nr%3;
+      for (i = 0 ; i < ovf ; i++)
+	 copy_vertex( tnl, nr-ovf+i, tmp[i] );
+      return i;
+   case GL_QUADS:
+      ovf = nr&3;
+      for (i = 0 ; i < ovf ; i++)
+	 copy_vertex( tnl, nr-ovf+i, tmp[i] );
+      return i;
+   case GL_LINE_STRIP:
+      if (nr == 0) 
+	 return 0;
+      copy_vertex( tnl, nr-1, tmp[0] );
+      return 1;
+   case GL_LINE_LOOP:
+   case GL_TRIANGLE_FAN:
+   case GL_POLYGON:
+      if (nr == 0) 
+	 return 0;
+      else if (nr == 1) {
+	 copy_vertex( tnl, 0, tmp[0] );
+	 return 1;
+      } else {
+	 copy_vertex( tnl, 0, tmp[0] );
+	 copy_vertex( tnl, nr-1, tmp[1] );
+	 return 2;
+      }
+   case GL_TRIANGLE_STRIP:
+      ovf = MIN2( nr-1, 2 );
+      for (i = 0 ; i < ovf ; i++)
+	 copy_vertex( tnl, nr-ovf+i, tmp[i] );
+      return i;
+   case GL_QUAD_STRIP:
+      ovf = MIN2( nr-1, 2 );
+      if (nr > 2) ovf += nr&1;
+      for (i = 0 ; i < ovf ; i++)
+	 copy_vertex( tnl, nr-ovf+i, tmp[i] );
+      return i;
+   default:
+      assert(0);
+      return 0;
+   }
+}
+
+
+
+/* Extend for vertex-format changes on wrap:
+ */
+static void wrap_buffer( void )
+{
+   TNLcontext *tnl = tnl->tnl;
+   GLfloat tmp[3][15];
+   GLuint i, nrverts;
+
+   if (MESA_VERBOSE & (DEBUG_VFMT|DEBUG_PRIMS))
+      fprintf(stderr, "%s %d\n", __FUNCTION__, 
+	      tnl->initial_counter - tnl->counter);
+
+   /* Don't deal with parity.  *** WONT WORK FOR COMPILE
+    */
+   if ((((tnl->initial_counter - tnl->counter) -  
+	 tnl->primlist[tnl->nrprims].start) & 1)) {
+      tnl->counter++;
+      tnl->initial_counter++;
+      return;
+   }
+
+   /* Copy vertices out of dma:
+    */
+   nrverts = copy_dma_verts( tnl, tmp );
+
+   if (MESA_VERBOSE & DEBUG_VFMT)
+      fprintf(stderr, "%d vertices to copy\n", nrverts);
+   
+
+   /* Finish the prim at this point:
+    */
+   note_last_prim( tnl, 0 );
+   flush_prims( tnl );
+
+   /* Reset counter, dmaptr
+    */
+   tnl->dmaptr = (int *)(tnl->dma.current.ptr + tnl->dma.current.address);
+   tnl->counter = (tnl->dma.current.end - tnl->dma.current.ptr) / 
+      (tnl->vertex_size * 4);
+   tnl->counter--;
+   tnl->initial_counter = tnl->counter;
+   tnl->notify = wrap_buffer;
+
+   tnl->dma.flush = flush_prims;
+   start_prim( tnl, tnl->prim[0] );
+
+
+   /* Reemit saved vertices 
+    * *** POSSIBLY IN NEW FORMAT
+    *       --> Can't always extend at end of vertex?
+    */
+   for (i = 0 ; i < nrverts; i++) {
+      if (MESA_VERBOSE & DEBUG_VERTS) {
+	 int j;
+	 fprintf(stderr, "re-emit vertex %d to %p\n", i, tnl->dmaptr);
+	 if (MESA_VERBOSE & DEBUG_VERBOSE)
+	    for (j = 0 ; j < tnl->vertex_size; j++) 
+	       fprintf(stderr, "\t%08x/%f\n", *(int*)&tmp[i][j], tmp[i][j]);
+      }
+
+      memcpy( tnl->dmaptr, tmp[i], tnl->vertex_size * 4 );
+      tnl->dmaptr += tnl->vertex_size;
+      tnl->counter--;
+   }
+}
+
+
+
+/* Always follow data, don't try to predict what's necessary.  
+ */
+static GLboolean check_vtx_fmt( GLcontext *ctx )
+{
+   TNLcontext *tnl = TNL_CONTEXT(ctx);
+
+   if (ctx->Driver.NeedFlush & FLUSH_UPDATE_CURRENT) 
+      ctx->Driver.FlushVertices( ctx, FLUSH_UPDATE_CURRENT );
+   
+
+   TNL_NEWPRIM(tnl);
+   tnl->vertex_format = VERT_BIT_POS;
+   tnl->prim = &ctx->Driver.CurrentExecPrimitive;
+
+
+   /* Currently allow the full 4 components per attrib.  Can use the
+    * mechanism from radeon driver color handling to reduce this (and
+    * also to store ubyte colors where these are incoming).  This
+    * won't work for compile mode.
+    *
+    * Only adding components when they are first received eliminates
+    * the need for displaylist fixup, as there are no 'empty' slots
+    * at the start of buffers.  
+    */
+   for (i = 0 ; i < 16 ; i++) {
+      if (ind & (1<<i)) {
+	 tnl->attribptr[i] = &tnl->vertex[tnl->vertex_size].f;
+	 tnl->vertex_size += 4;
+	 tnl->attribptr[i][0] = ctx->Current.Attrib[i][0];
+	 tnl->attribptr[i][1] = ctx->Current.Attrib[i][1];
+	 tnl->attribptr[i][2] = ctx->Current.Attrib[i][2];
+	 tnl->attribptr[i][3] = ctx->Current.Attrib[i][3];
+      }
+      else
+	 tnl->attribptr[i] = ctx->Current.Attrib[i];
+   }
+
+   /* Edgeflag, Index:
+    */
+   for (i = 16 ; i < 18 ; i++)
+      ;
+
+   /* Materials:
+    */
+   for (i = 18 ; i < 28 ; i++)
+      ;
+
+   /* Eval:
+    */
+   for (i = 28 ; i < 29 ; i++)
+      ;
+	   
+
+   if (tnl->installed_vertex_format != tnl->vertex_format) {
+      if (MESA_VERBOSE & DEBUG_VFMT)
+	 fprintf(stderr, "reinstall on vertex_format change\n");
+      _mesa_install_exec_vtxfmt( ctx, &tnl->vtxfmt );
+      tnl->installed_vertex_format = tnl->vertex_format;
+   }
+
+   return GL_TRUE;
+}
+
+
+void _tnl_InvalidateVtxfmt( GLcontext *ctx )
+{
+   tnl->recheck = GL_TRUE;
+   tnl->fell_back = GL_FALSE;
+}
+
+
+
+
+static void _tnl_ValidateVtxfmt( GLcontext *ctx )
+{
+   if (MESA_VERBOSE & DEBUG_VFMT)
+      fprintf(stderr, "%s\n", __FUNCTION__);
+
+   if (ctx->Driver.NeedFlush)
+      ctx->Driver.FlushVertices( ctx, ctx->Driver.NeedFlush );
+
+   tnl->recheck = GL_FALSE;
+
+   if (check_vtx_fmt( ctx )) {
+      if (!tnl->installed) {
+	 if (MESA_VERBOSE & DEBUG_VFMT)
+	    fprintf(stderr, "reinstall (new install)\n");
+
+	 _mesa_install_exec_vtxfmt( ctx, &tnl->vtxfmt );
+	 ctx->Driver.FlushVertices = _tnl_FlushVertices;
+	 tnl->installed = GL_TRUE;
+      }
+      else
+	 fprintf(stderr, "%s: already installed", __FUNCTION__);
+   } 
+   else {
+      if (MESA_VERBOSE & DEBUG_VFMT)
+	 fprintf(stderr, "%s: failed\n", __FUNCTION__);
+
+      if (tnl->installed) {
+	 if (tnl->tnl->dma.flush)
+	    tnl->tnl->dma.flush( tnl->tnl );
+	 _tnl_wakeup_exec( ctx );
+	 tnl->installed = GL_FALSE;
+      }
+   }      
+}
+
+
+
+
+
+/* Begin/End
+ */
+static void _tnl_Begin( GLenum mode )
+{
+   GLcontext *ctx = tnl->context;
+   TNLcontext *tnl = tnl->tnl;
+   
+   if (MESA_VERBOSE & DEBUG_VFMT)
+      fprintf(stderr, "%s\n", __FUNCTION__);
+
+   if (mode > GL_POLYGON) {
+      _mesa_error( ctx, GL_INVALID_ENUM, "glBegin" );
+      return;
+   }
+
+   if (tnl->prim[0] != GL_POLYGON+1) {
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glBegin" );
+      return;
+   }
+   
+   if (ctx->NewState) 
+      _mesa_update_state( ctx );
+
+   if (tnl->recheck) 
+      _tnl_ValidateVtxfmt( ctx );
+
+   if (tnl->dma.flush && tnl->counter < 12) {
+      if (MESA_VERBOSE & DEBUG_VFMT)
+	 fprintf(stderr, "%s: flush almost-empty buffers\n", __FUNCTION__);
+      flush_prims( tnl );
+   }
+
+   if (!tnl->dma.flush) {
+      if (tnl->dma.current.ptr + 12*tnl->vertex_size*4 > 
+	  tnl->dma.current.end) {
+	 TNL_NEWPRIM( tnl );
+	 _tnl_RefillCurrentDmaRegion( tnl );
+      }
+
+      tnl->dmaptr = (int *)(tnl->dma.current.address + tnl->dma.current.ptr);
+      tnl->counter = (tnl->dma.current.end - tnl->dma.current.ptr) / 
+	 (tnl->vertex_size * 4);
+      tnl->counter--;
+      tnl->initial_counter = tnl->counter;
+      tnl->notify = wrap_buffer;
+      tnl->dma.flush = flush_prims;
+      tnl->context->Driver.NeedFlush |= FLUSH_STORED_VERTICES;
+   }
+   
+   
+   tnl->prim[0] = mode;
+   start_prim( tnl, mode | PRIM_BEGIN );
+}
+
+
+
+
+
+static void _tnl_End( void )
+{
+   TNLcontext *tnl = tnl->tnl;
+   GLcontext *ctx = tnl->context;
+
+   if (MESA_VERBOSE & DEBUG_VFMT)
+      fprintf(stderr, "%s\n", __FUNCTION__);
+
+   if (tnl->prim[0] == GL_POLYGON+1) {
+      _mesa_error( ctx, GL_INVALID_OPERATION, "glEnd" );
+      return;
+   }
+	  
+   note_last_prim( tnl, PRIM_END );
+   tnl->prim[0] = GL_POLYGON+1;
+}
+
+
+static void _tnl_FlushVertices( GLcontext *ctx, GLuint flags )
+{
+   if (MESA_VERBOSE & DEBUG_VFMT)
+      fprintf(stderr, "%s\n", __FUNCTION__);
+
+   assert(tnl->installed);
+
+   if (flags & FLUSH_UPDATE_CURRENT) {
+      _tnl_copy_to_current( ctx );
+      if (MESA_VERBOSE & DEBUG_VFMT)
+	 fprintf(stderr, "reinstall on update_current\n");
+      _mesa_install_exec_vtxfmt( ctx, &tnl->vtxfmt );
+      ctx->Driver.NeedFlush &= ~FLUSH_UPDATE_CURRENT;
+   }
+
+   if (flags & FLUSH_STORED_VERTICES) {
+      TNLcontext *tnl = TNL_CONTEXT( ctx );
+      assert (tnl->dma.flush == 0 ||
+	      tnl->dma.flush == flush_prims);
+      if (tnl->dma.flush == flush_prims)
+	 flush_prims( TNL_CONTEXT( ctx ) );
+      ctx->Driver.NeedFlush &= ~FLUSH_STORED_VERTICES;
+   }
+}
+
+
+
+/* At this point, don't expect very many versions of each function to
+ * be generated, so not concerned about freeing them?
+ */
+
+
+static void _tnl_InitVtxfmt( GLcontext *ctx )
+{
+   GLvertexformat *vfmt = &(tnl->vtxfmt);
+
+   MEMSET( vfmt, 0, sizeof(GLvertexformat) );
+
+   /* Hook in chooser functions for codegen, etc:
+    */
+   _tnl_InitVtxfmtChoosers( vfmt );
+
+   /* Handled fully in supported states, but no codegen:
+    */
+   vfmt->ArrayElement = _ae_loopback_array_elt;	        /* generic helper */
+   vfmt->Rectf = _mesa_noop_Rectf;			/* generic helper */
+   vfmt->Begin = _tnl_Begin;
+   vfmt->End = _tnl_End;
+   
+   tnl->context = ctx;
+   tnl->tnl = TNL_CONTEXT(ctx);
+   tnl->prim = &ctx->Driver.CurrentExecPrimitive;
+   tnl->primflags = 0;
+
+   make_empty_list( &tnl->dfn_cache.Vertex2f );
+   make_empty_list( &tnl->dfn_cache.Vertex2fv );
+   make_empty_list( &tnl->dfn_cache.Vertex3f );
+   make_empty_list( &tnl->dfn_cache.Vertex3fv );
+   make_empty_list( &tnl->dfn_cache.Color4ub );
+   make_empty_list( &tnl->dfn_cache.Color4ubv );
+   make_empty_list( &tnl->dfn_cache.Color3ub );
+   make_empty_list( &tnl->dfn_cache.Color3ubv );
+   make_empty_list( &tnl->dfn_cache.Color4f );
+   make_empty_list( &tnl->dfn_cache.Color4fv );
+   make_empty_list( &tnl->dfn_cache.Color3f );
+   make_empty_list( &tnl->dfn_cache.Color3fv );
+   make_empty_list( &tnl->dfn_cache.SecondaryColor3fEXT );
+   make_empty_list( &tnl->dfn_cache.SecondaryColor3fvEXT );
+   make_empty_list( &tnl->dfn_cache.SecondaryColor3ubEXT );
+   make_empty_list( &tnl->dfn_cache.SecondaryColor3ubvEXT );
+   make_empty_list( &tnl->dfn_cache.Normal3f );
+   make_empty_list( &tnl->dfn_cache.Normal3fv );
+   make_empty_list( &tnl->dfn_cache.TexCoord2f );
+   make_empty_list( &tnl->dfn_cache.TexCoord2fv );
+   make_empty_list( &tnl->dfn_cache.TexCoord1f );
+   make_empty_list( &tnl->dfn_cache.TexCoord1fv );
+   make_empty_list( &tnl->dfn_cache.MultiTexCoord2fARB );
+   make_empty_list( &tnl->dfn_cache.MultiTexCoord2fvARB );
+   make_empty_list( &tnl->dfn_cache.MultiTexCoord1fARB );
+   make_empty_list( &tnl->dfn_cache.MultiTexCoord1fvARB );
+
+   _tnl_InitCodegen( &tnl->codegen );
+}
+
+static void free_funcs( struct dynfn *l )
+{
+   struct dynfn *f, *tmp;
+   foreach_s (f, tmp, l) {
+      remove_from_list( f );
+      ALIGN_FREE( f->code );
+      FREE( f );
+   }
+}
+
+
+static void _tnl_DestroyVtxfmt( GLcontext *ctx )
+{
+   count_funcs();
+   free_funcs( &tnl->dfn_cache.Vertex2f );
+   free_funcs( &tnl->dfn_cache.Vertex2fv );
+   free_funcs( &tnl->dfn_cache.Vertex3f );
+   free_funcs( &tnl->dfn_cache.Vertex3fv );
+   free_funcs( &tnl->dfn_cache.Color4ub );
+   free_funcs( &tnl->dfn_cache.Color4ubv );
+   free_funcs( &tnl->dfn_cache.Color3ub );
+   free_funcs( &tnl->dfn_cache.Color3ubv );
+   free_funcs( &tnl->dfn_cache.Color4f );
+   free_funcs( &tnl->dfn_cache.Color4fv );
+   free_funcs( &tnl->dfn_cache.Color3f );
+   free_funcs( &tnl->dfn_cache.Color3fv );
+   free_funcs( &tnl->dfn_cache.SecondaryColor3ubEXT );
+   free_funcs( &tnl->dfn_cache.SecondaryColor3ubvEXT );
+   free_funcs( &tnl->dfn_cache.SecondaryColor3fEXT );
+   free_funcs( &tnl->dfn_cache.SecondaryColor3fvEXT );
+   free_funcs( &tnl->dfn_cache.Normal3f );
+   free_funcs( &tnl->dfn_cache.Normal3fv );
+   free_funcs( &tnl->dfn_cache.TexCoord2f );
+   free_funcs( &tnl->dfn_cache.TexCoord2fv );
+   free_funcs( &tnl->dfn_cache.TexCoord1f );
+   free_funcs( &tnl->dfn_cache.TexCoord1fv );
+   free_funcs( &tnl->dfn_cache.MultiTexCoord2fARB );
+   free_funcs( &tnl->dfn_cache.MultiTexCoord2fvARB );
+   free_funcs( &tnl->dfn_cache.MultiTexCoord1fARB );
+   free_funcs( &tnl->dfn_cache.MultiTexCoord1fvARB );
+}
+