path: root/src/mesa/drivers/d3d/D3Dvbrender.c

/*===========================================================================*/
/*                                                                           */
/* Mesa-3.0 DirectX 6 Driver                                                 */
/*                                                                           */
/* By Leigh McRae                                                            */
/*                                                                           */
/* http://www.altsoftware.com/                                               */
/*                                                                           */
/* Copyright (c) 1999-1998  alt.software inc.  All Rights Reserved           */
/*===========================================================================*/
#include <stdio.h>
#include "clip.h"
#include "context.h"
#include "light.h"
#include "lines.h"
#include "macros.h"
#include "matrix.h"
#include "pb.h"
#include "points.h"
#include "mtypes.h"
#include "vb.h"
#include "vbrender.h"
#include "xform.h"
#include "D3DMesa.h"

static void SetRenderStates( GLcontext *ctx );
static void DebugRenderStates( GLcontext *ctx, BOOL bForce );

static void RenderPointsVB( GLcontext *ctx, GLuint start, GLuint end );
static void RenderTriangleVB( GLcontext *ctx, GLuint start, GLuint end );
static void RenderTriangleFanVB( GLcontext *ctx, GLuint start, GLuint end );
static void RenderTriangleStripVB( GLcontext *ctx, GLuint start, GLuint end );
static void RenderQuadVB( GLcontext *ctx, GLuint start, GLuint end );
static void RenderQuad( GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint v4, GLuint pv );
void		RenderOneTriangle( GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint pv );
void 	RenderOneLine( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv );

/*  I went with a D3D vertex buffer that is 6 times that of the Mesa one */
/* instead of having the D3D one flush when its full.  This way Mesa will*/
/* handle all the flushing.  I need x6 as points can use 4 vertex each.  */
D3DTLVERTEX 	D3DTLVertices[ (VB_MAX*6) ];
GLuint   		VList[VB_SIZE];
/*===========================================================================*/
/* Compute Z offsets for a polygon with plane defined by (A,B,C,D)           */
/* D is not needed. TODO: Currently we are calculating this but not using it.*/
/*===========================================================================*/
/* RETURN:                                                                   */
/*===========================================================================*/
static void OffsetPolygon( GLcontext *ctx, GLfloat a, GLfloat b, GLfloat c )
{
  GLfloat	ac,
          bc,
          m,
          offset;

  DPF(( DBG_FUNC, "OffsetPolygon();" ));

  if ( (c < 0.001F) && (c > - 0.001F) )
  {
    /* Prevents underflow problems. */
    ctx->PointZoffset   = 0.0F;
    ctx->LineZoffset    = 0.0F;
    ctx->PolygonZoffset = 0.0F;
  }
  else
  {
    ac = a / c;
    bc = b / c;
    if ( ac < 0.0F )
	 ac = -ac;
    if ( bc<0.0F )
	 bc = -bc;
    m = MAX2( ac, bc );     /* m = sqrt( ac*ac + bc*bc ); */

    offset = (m * ctx->Polygon.OffsetFactor + ctx->Polygon.OffsetUnits);
    ctx->PointZoffset   = ctx->Polygon.OffsetPoint ? offset : 0.0F;
    ctx->LineZoffset    = ctx->Polygon.OffsetLine  ? offset : 0.0F;
    ctx->PolygonZoffset = ctx->Polygon.OffsetFill  ? offset : 0.0F;
  }

  DPF(( DBG_PRIM_INFO, "OffsetPolygon: %f", offset ));
}
/*===========================================================================*/
/*  Compute signed area of the n-sided polgyon specified by vertices         */
/* vb->Win[] and vertex list vlist[].                                        */
/*  A clockwise polygon will return a negative area.  A counter-clockwise    */
/* polygon will return a positive area.  I have changed this function to     */
/* actually calculate twice the area as its faster and still gives the sign. */
/*===========================================================================*/
/* RETURN: signed area of the polgon.                                        */
/*===========================================================================*/
static GLfloat PolygonArea( const struct vertex_buffer *vb, GLuint n, const GLuint vlist[] )
{
  GLfloat	area;
  GLuint  i;

  DPF(( DBG_FUNC, "PolygonArea();" ));

#define  j0    vlist[i]
#define  j1    vlist[(i+1)%n]
#define  x0    vb->Win[j0][0]
#define  y0    vb->Win[j0][1]
#define  x1    vb->Win[j1][0]
#define  y1    vb->Win[j1][1]

  /* area = sum of trapezoids */
  for( i = 0, area = 0.0; i < n; i++ )
    area += ((x0 - x1) * (y0 + y1));  /* Note: no divide by two here! */

#undef x0
#undef y0
#undef x1
#undef y1
#undef j1
#undef j0

  // TODO: I don't see the point or * 0.5 as we just want the sign...
  return area;
}
/*===========================================================================*/
/*  Render a polygon that needs clipping on at least one vertex. The function*/
/* will first clip the polygon to any user clipping planes then clip to the  */
/* viewing volume.  The final polygon will be draw as single triangles that  */
/* first need minor proccessing (culling, offset, etc) before we draw the    */
/* polygon as a fan.  NOTE: the fan is draw as single triangles as its not   */
/* formed sequentaly in the VB but is in the vlist[].                        */
/*===========================================================================*/
/* RETURN:                                                                   */
/*===========================================================================*/
static void RenderClippedPolygon( GLcontext *ctx, GLuint n, GLuint vlist[] )
{
  struct vertex_buffer	*VB = ctx->VB;
  GLfloat 			(*win)[3] = VB->Win,
                         *proj = ctx->ProjectionMatrix,
                         ex, ey,
                         fx, fy, c,
	                    wInv;
  GLuint				index,
	                    pv,
                         facing;

  DPF(( DBG_FUNC, "RenderClippedPolygon();" ));

  DPF(( DBG_PRIM_INFO, "RenderClippedtPolygon( %d )", n ));

  /* Which vertex dictates the color when flat shading. */
  pv = (ctx->Primitive==GL_POLYGON) ? vlist[0] : vlist[n-1];

  /*  Clipping may introduce new vertices.  New vertices will be stored in */
  /* the vertex buffer arrays starting with location VB->Free.  After we've*/
  /* rendered the polygon, these extra vertices can be overwritten.        */
  VB->Free = VB_MAX;

  /* Clip against user clipping planes in eye coord space. */
  if ( ctx->Transform.AnyClip )
  {
    n = gl_userclip_polygon( ctx, n, vlist );
    if ( n < 3 )
	 return;

    /* Transform vertices from eye to clip coordinates:  clip = Proj * eye */
    for( index = 0; index < n; index++ )
    {
	 TRANSFORM_POINT( VB->Clip[vlist[index]], proj, VB->Eye[vlist[index]] );
    }
  }

  /* Clip against view volume in clip coord space */
  n = gl_viewclip_polygon( ctx, n, vlist );
  if ( n < 3 )
    return;

  /* Transform new vertices from clip to ndc to window coords.    */
  /* ndc = clip / W    window = viewport_mapping(ndc)             */
  /* Note that window Z values are scaled to the range of integer */
  /* depth buffer values.                                         */

  /* Only need to compute window coords for new vertices */
  for( index = VB_MAX; index < VB->Free; index++ )
  {
    if ( VB->Clip[index][3] != 0.0F )
    {
	 wInv = 1.0F / VB->Clip[index][3];

	 win[index][0] = VB->Clip[index][0] * wInv * ctx->Viewport.Sx + ctx->Viewport.Tx;
	 win[index][1] = VB->Clip[index][1] * wInv * ctx->Viewport.Sy + ctx->Viewport.Ty;
	 win[index][2] = VB->Clip[index][2] * wInv * ctx->Viewport.Sz + ctx->Viewport.Tz;
    }
    else
    {
	 /* Can't divide by zero, so... */
	 win[index][0] = win[index][1] = win[index][2] = 0.0F;
    }
  }

  /* Draw filled polygon as a triangle fan */
  for( index = 2; index < n; index++ )
  {
    /* Compute orientation of triangle */
    ex = win[vlist[index-1]][0] - win[vlist[0]][0];
    ey = win[vlist[index-1]][1] - win[vlist[0]][1];
    fx = win[vlist[index]][0]   - win[vlist[0]][0];
    fy = win[vlist[index]][1]   - win[vlist[0]][1];
    c = (ex * fy) - (ey * fx);

    /* polygon is perpindicular to view plane, don't draw it */
    if ( (c == 0.0F) && !ctx->Polygon.Unfilled )
	 continue;

    /* Backface culling. */
    facing = (c < 0.0F) ^ ctx->Polygon.FrontBit;
    if ( (facing + 1) & ctx->Polygon.CullBits )
	 continue;

    if ( ctx->IndirectTriangles & DD_TRI_LIGHT_TWOSIDE )
    {
	 if ( facing == 1 )
	 {
	   /* use back color */
	   VB->Color   = VB->Bcolor;
	   VB->Specular= VB->Bspec;
	 }
	 else
	 {
	   /* use front color */
	   VB->Color   = VB->Fcolor;
	   VB->Specular= VB->Fspec;
	 }
    }

    if ( ctx->IndirectTriangles & DD_TRI_OFFSET )
    {
	 /* finish computing plane equation of polygon, compute offset */
	 GLfloat fz = win[vlist[index]][2]   - win[vlist[0]][2];
	 GLfloat ez = win[vlist[index-1]][2] - win[vlist[0]][2];
	 GLfloat a = (ey * fz) - (ez * fy);
	 GLfloat b = (ez * fx) - (ex * fz);
	 OffsetPolygon( ctx, a, b, c );
    }
    RenderOneTriangle( ctx, vlist[0], vlist[index-1], vlist[index], pv );
  }
}
/*===========================================================================*/
/*  This function gets called when either the vertex buffer is full or glEnd */
/* has been called.  If the we aren't in rendering mode (FEEDBACK) then I    */
/* pass the vertex buffer back to Mesa to deal with by returning FALSE.      */
/*  If I can render the primitive types in the buffer directly then I will   */
/* return TRUE after I render the vertex buffer and reset the vertex buffer. */
/*                                                                           */
/* TODO: I don't handle the special case of when the vertex buffer is full   */
/*      and we have a primitive that bounds this buffer and the next one to  */
/*      come.  I'm not sure right now if Mesa handles this for me...         */
/*===========================================================================*/
/* RETURN: TRUE, FALSE.                                                      */
/*===========================================================================*/
GLboolean RenderVertexBuffer( GLcontext *ctx, GLboolean allDone )
{
  struct vertex_buffer	*VB = ctx->VB;
  GLuint 		    		index,
	                    vlist[VB_SIZE];

  DPF(( DBG_FUNC, "RenderVertexBuffer();" ));

  /* We only need to hook actual tri's that need rendering. */
  if ( ctx->RenderMode != GL_RENDER )
  {
	   //	   (ctx->Visual->AccumBits > 0) )
	   //	   (ctx->Visual->StencilBits > 0) )
    DPF(( DBG_PRIM_INFO, "Passing VB back to Mesa" ));
    return FALSE;
  }

  /*  I'm going to set the states here so that all functions will  */
  /* be assured to have the right states.  If Mesa's vertex bufefr */
  /* function calls one of my primitive functions (TRI,POINT,LINE) */
  /* it will need the right states.  So instead of doing it in the */
  /* primitive function I will always do it here at risk of some   */
  /* slow down to some cases...                                    */
  SetRenderStates( ctx );

  switch( ctx->Primitive )
  {
    case GL_POINTS:
	 DPF(( DBG_PRIM_INFO, "GL_POINTS( %d )", VB->Count ));
	 RenderPointsVB( ctx, 0, VB->Count );
	 break;

    case GL_LINES:
    case GL_LINE_STRIP:
    case GL_LINE_LOOP:
	 /*  Not supported functions yet so pass back that we failed to */
	 /* render the vertex buffer and Mesa will have to do it.       */
	 DPF(( DBG_PRIM_INFO, "GL_LINE_?( %d )", VB->Count ));
	 return FALSE;

    case GL_TRIANGLES:
	 if ( VB->Count < 3 )
	 {
	   DPF(( DBG_PRIM_WARN, "GL_TRIANGLES( %d )", VB->Count ));
	   return FALSE;
	 }

	 DPF(( DBG_PRIM_INFO, "GL_TRIANGLES( %d )", VB->Count ));
      RenderTriangleVB( ctx, 0, VB->Count );
	 break;

    case GL_TRIANGLE_STRIP:
	 if ( VB->Count < 3 )
	 {
	   DPF(( DBG_PRIM_WARN, "GL_TRIANGLE_STRIP( %d )", VB->Count ));
	   return FALSE;
	 }

	 DPF(( DBG_PRIM_INFO, "GL_TRIANGLE_STRIP( %d )", VB->Count ));
	 RenderTriangleStripVB( ctx, 0, VB->Count );
	 break;

    case GL_TRIANGLE_FAN:
	 if ( VB->Count < 3 )
	 {
	   DPF(( DBG_PRIM_WARN, "GL_TRIANGLE_FAN( %d )", VB->Count ));
	   return FALSE;
	 }

	 DPF(( DBG_PRIM_INFO, "GL_TRIANGLE_FAN( %d )", VB->Count ));
	 RenderTriangleFanVB( ctx, 0, VB->Count );
	 break;

    case GL_QUADS:
	 if ( VB->Count < 4 )
	 {
	   DPF(( DBG_PRIM_WARN, "GL_QUADS( %d )", VB->Count ));
	   return FALSE;
	 }

	  DPF(( DBG_PRIM_INFO, "GL_QUADS( %d )", VB->Count ));
	  RenderQuadVB( ctx, 0, VB->Count );
	  break;

    case GL_QUAD_STRIP:
	 if ( VB->Count < 4 )
	 {
	   DPF(( DBG_PRIM_WARN, "GL_QUAD_STRIP( %d )", VB->Count ));
	   return FALSE;
	 }

	 DPF(( DBG_PRIM_INFO, "GL_QUAD_STRIP( %d )", VB->Count ));

	 if ( VB->ClipOrMask )
	 {
	   for( index = 3; index < VB->Count; index += 2 )
	   {
		if ( VB->ClipMask[index-3] & VB->ClipMask[index-2] & VB->ClipMask[index-1] & VB->ClipMask[index] & CLIP_ALL_BITS )
		{
		   /* All points clipped by common plane */
		  DPF(( DBG_PRIM_WARN, "GL_QUAD_STRIP( %d )", VB->Count ));
		  continue;
		}
		else if ( VB->ClipMask[index-3] | VB->ClipMask[index-2] | VB->ClipMask[index-1] | VB->ClipMask[index] )
		{
		  vlist[0] = index - 3;
		  vlist[1] = index - 2;
		  vlist[2] = index;
		  vlist[3] = index - 1;
		  RenderClippedPolygon( ctx, 4, vlist );
		}
		else
		{
		  RenderQuad( ctx, (index-3), (index-2), index, (index-1), index );
		}	
	   }
	 }
	 else
	 {
	   /* No clipping needed */
	   for( index = 3; index < VB->Count; index += 2 )
		RenderQuad( ctx, (index-3), (index-2), index, (index-1), index );
	 }	
	 break;
	
    case GL_POLYGON:
	 if ( VB->Count < 3 )
	 {
	   DPF(( DBG_PRIM_WARN, "GL_POLYGON( %d )", VB->Count ));
	   return FALSE;
	 }

	 DPF(( DBG_PRIM_INFO, "GL_POLYGON( %d )", VB->Count ));

	 /* All points clipped by common plane, draw nothing */
	 if ( !(VB->ClipAndMask & CLIP_ALL_BITS) )
	   RenderTriangleFanVB( ctx, 0, VB->Count );
	 break;

    default:
	 /* should never get here */
	 _mesa_problem( ctx, "invalid mode in gl_render_vb" );
   }

  DPF(( DBG_PRIM_INFO, "ResetVB" ));

  /* We return TRUE to indicate we rendered the VB. */
  gl_reset_vb( ctx, allDone );
  return TRUE;
}
/*===========================================================================*/
/*  This function will render the current vertex buffer as triangles.  The   */
/* buffer has to be able to be rendered directly.  This means that we are    */
/* filled, no offsets, no culling and one sided rendering.  Also we must be  */
/* in render mode of course.                                                 */
/*  First I will fill the global D3D vertice buffer.  Next I will set all the*/
/* states for D3D based on the current OGL state.  Finally I pass the D3D VB */
/* to the wrapper that call DrawPrimitives.                                  */
/*===========================================================================*/
/* RETURN:                                                                   */
/*===========================================================================*/
static void RenderTriangleVB( GLcontext *ctx, GLuint start, GLuint end )
{
  D3DMESACONTEXT      	*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
  struct vertex_buffer 	*VB = ctx->VB;
  int                    index,
                         cVertex,
                         height = (pContext->pShared->rectW.bottom - pContext->pShared->rectW.top);
   DWORD                	dwPVColor;
   GLfloat              	ex, ey,
                         fx, fy, c;
   GLuint               	facing;

   DPF(( DBG_FUNC, "RenderTriangleVB" ));

   if ( !VB->ClipOrMask )
   {
	DPF(( DBG_PRIM_INFO, "DirectTriangles( %d )", (end-start) ));
	for( index = start, cVertex = 0; index < end; )
	{
	  dwPVColor = (VB->Color[(index+2)][3]<<24) | (VB->Color[(index+2)][0]<<16) | (VB->Color[(index+2)][1]<<8) | VB->Color[(index+2)][2];

	  /*=====================================*/
	  /* Populate the the triangle vertices. */
	  /*=====================================*/
	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[index][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[index][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[index][2] );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[index][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[index][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[index][3]) );
	  D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
	                                  dwPVColor :
                                       (VB->Color[index][3]<<24) | (VB->Color[index][0]<<16) | (VB->Color[index][1]<<8) | VB->Color[index][2];
	  index++;

	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[index][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[index][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[index][2] );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[index][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[index][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[index][3]) );
	  D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                       dwPVColor :
                                       (VB->Color[index][3]<<24) | (VB->Color[index][0]<<16) | (VB->Color[index][1]<<8) | VB->Color[index][2];
	  index++;

	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[index][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[index][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[index][2] );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[index][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[index][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[index][3]) );
	  D3DTLVertices[cVertex++].color= dwPVColor;
	  index++;
	}
   }
   else
   {
#define v1     index
#define v2     (index+1)
#define v3     (index+2)

	for( index = start, cVertex = 0; index < end; index += 3 )
	{
	  if ( VB->ClipMask[v1] & VB->ClipMask[v2] & VB->ClipMask[v3] & CLIP_ALL_BITS )
	  {
	    continue;
	  }
	  else if ( VB->ClipMask[v1] | VB->ClipMask[v2] | VB->ClipMask[v3] )
	  {
	    VList[0] = v1;
	    VList[1] = v2;
	    VList[2] = v3;
	    RenderClippedPolygon( ctx, 3, VList );
	    continue;
	  }

	  /* Compute orientation of triangle */
	  ex = VB->Win[v2][0] - VB->Win[v1][0];
	  ey = VB->Win[v2][1] - VB->Win[v1][1];
	  fx = VB->Win[v3][0] - VB->Win[v1][0];
	  fy = VB->Win[v3][1] - VB->Win[v1][1];
	  c = (ex * fy) - (ey * fx);

	  /* polygon is perpindicular to view plane, don't draw it */
	  if ( (c == 0.0F) && !ctx->Polygon.Unfilled )
	    continue;

	  /* Backface culling. */
	  facing = (c < 0.0F) ^ ctx->Polygon.FrontBit;
	  if ( (facing + 1) & ctx->Polygon.CullBits )
	    continue;

	  if ( ctx->IndirectTriangles & DD_TRI_LIGHT_TWOSIDE )
	  {
	    if ( facing == 1 )
	    {
		 /* use back color */
		 VB->Color   = VB->Bcolor;
		 VB->Specular= VB->Bspec;
	    }
	    else
	    {
		 /* use front color */
		 VB->Color   = VB->Fcolor;
		 VB->Specular= VB->Fspec;
	    }
	  }

	  if ( ctx->IndirectTriangles & DD_TRI_OFFSET )
	  {
	    /* Finish computing plane equation of polygon, compute offset */
	    GLfloat fz = VB->Win[v3][2] - VB->Win[v1][2];
	    GLfloat ez = VB->Win[v2][2] - VB->Win[v1][2];
	    GLfloat a = (ey * fz) - (ez * fy);
	    GLfloat b = (ez * fx) - (ex * fz);
	    OffsetPolygon( ctx, a, b, c );
	  }

	  /*=====================================*/
	  /* Populate the the triangle vertices. */
	  /*=====================================*/
	  /* Solve the prevoking vertex color as we need it for the 3rd triangle and flat shading. */
	  dwPVColor = (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];

	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v1][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v1][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v1][2] + ctx->PolygonZoffset) );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v1][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v1][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v1][3]) );
	  D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                       dwPVColor :
                                       (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v2][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v2][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v2][2] + ctx->PolygonZoffset) );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v2][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v2][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v2][3]) );
	  D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                       dwPVColor :
                                       (VB->Color[v2][3]<<24) | (VB->Color[v2][0]<<16) | (VB->Color[v2][1]<<8) | VB->Color[v2][2];

	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v3][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v3][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v3][2] + ctx->PolygonZoffset) );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v3][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v3][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v3][3]) );
	  D3DTLVertices[cVertex++].color= dwPVColor;
	}
#undef v1
#undef v2
#undef v3
   }

   /* Render the converted vertex buffer. */
   if ( cVertex > 2 )
	DrawPrimitiveHAL( pContext->pShared, D3DPT_TRIANGLELIST, &D3DTLVertices[0], cVertex );
}
/*===========================================================================*/
/*  This function will render the current vertex buffer as a triangle fan.   */
/* The buffer has to be able to be rendered directly.  This means that we are*/
/* filled, no offsets, no culling and one sided rendering.  Also we must be  */
/* in render mode of course.                                                 */
/*  First I will fill the global D3D vertice buffer.  Next I will set all the*/
/* states for D3D based on the current OGL state.  Finally I pass the D3D VB */
/* to the wrapper that call DrawPrimitives.                                  */
/*===========================================================================*/
/* RETURN:                                                                   */
/*===========================================================================*/
static void RenderTriangleFanVB( GLcontext *ctx, GLuint start, GLuint end )
{
  D3DMESACONTEXT     	*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
  struct vertex_buffer 	*VB = ctx->VB;
  int                  	index,
                         cVertex,
                         height = (pContext->pShared->rectW.bottom - pContext->pShared->rectW.top);
   GLfloat              	ex, ey,
                         fx, fy, c;
   GLuint               	facing;
   DWORD                	dwPVColor;

   DPF(( DBG_FUNC, "RenderTriangleFanVB();" ));

   /* Special case that we can blast the fan without culling, offset, etc... */
   if ( !VB->ClipOrMask && (ctx->Light.ShadeModel != GL_FLAT) )
   {
	DPF(( DBG_PRIM_INFO, "DirectTriangles( %d )", (end-start) ));

	/* Seed the the fan. */
	D3DTLVertices[0].sx   = D3DVAL( VB->Win[start][0] );
	D3DTLVertices[0].sy   = D3DVAL( (height - VB->Win[start][1]) );
	D3DTLVertices[0].sz   = D3DVAL( VB->Win[start][2] );
	D3DTLVertices[0].tu   = D3DVAL( VB->TexCoord[start][0] );
	D3DTLVertices[0].tv   = D3DVAL( VB->TexCoord[start][1] );
	D3DTLVertices[0].rhw  = D3DVAL( (1.0 / VB->Clip[start][3]) );
	D3DTLVertices[0].color= (VB->Color[start][3]<<24) | (VB->Color[start][0]<<16) | (VB->Color[start][1]<<8) | VB->Color[start][2];

	/* Seed the the fan. */
	D3DTLVertices[1].sx   = D3DVAL( VB->Win[(start+1)][0] );
	D3DTLVertices[1].sy   = D3DVAL( (height - VB->Win[(start+1)][1]) );
	D3DTLVertices[1].sz   = D3DVAL( VB->Win[(start+1)][2] );
	D3DTLVertices[1].tu   = D3DVAL( VB->TexCoord[(start+1)][0] );
	D3DTLVertices[1].tv   = D3DVAL( VB->TexCoord[(start+1)][1] );
	D3DTLVertices[1].rhw  = D3DVAL( (1.0 / VB->Clip[(start+1)][3]) );
	D3DTLVertices[1].color= (VB->Color[(start+1)][3]<<24) | (VB->Color[(start+1)][0]<<16) | (VB->Color[(start+1)][1]<<8) | VB->Color[(start+1)][2];

	for( index = (start+2), cVertex = 2; index < end; index++, cVertex++ )
	{
	  /*=================================*/
	  /* Add the next vertex to the fan. */
	  /*=================================*/
	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[index][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[index][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[index][2] );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[index][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[index][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[index][3]) );
	  D3DTLVertices[cVertex].color  = (VB->Color[index][3]<<24) | (VB->Color[index][0]<<16) | (VB->Color[index][1]<<8) | VB->Color[index][2];
      }

	/* Render the converted vertex buffer. */
	if ( cVertex )
	  DrawPrimitiveHAL( pContext->pShared, D3DPT_TRIANGLEFAN, &D3DTLVertices[0], cVertex );
   }
   else
   {
#define v1     start
#define v2     (index-1)
#define v3     index

	for( index = (start+2), cVertex = 0; index < end; index++ )
	{
	  if ( VB->ClipOrMask )
	  {
	    /* All points clipped by common plane */
	    if ( VB->ClipMask[v1] & VB->ClipMask[v2] & VB->ClipMask[v3] & CLIP_ALL_BITS )
	    {
		 continue;
	    }
	    else if ( VB->ClipMask[v1] | VB->ClipMask[v2] | VB->ClipMask[v3] )
	    {
		 VList[0] = v1;
		 VList[1] = v2;
		 VList[2] = v3;
		 RenderClippedPolygon( ctx, 3, VList );
		 continue;
	    }
	  }

	  /* Compute orientation of triangle */
	  ex = VB->Win[v2][0] - VB->Win[v1][0];
	  ey = VB->Win[v2][1] - VB->Win[v1][1];
	  fx = VB->Win[v3][0] - VB->Win[v1][0];
	  fy = VB->Win[v3][1] - VB->Win[v1][1];
	  c = (ex * fy) - (ey * fx);

	  /* polygon is perpindicular to view plane, don't draw it */
	  if ( (c == 0.0F) && !ctx->Polygon.Unfilled )
	    continue;

	  /* Backface culling. */
	  facing = (c < 0.0F) ^ ctx->Polygon.FrontBit;
	  if ( (facing + 1) & ctx->Polygon.CullBits )
	    continue;

	  if ( ctx->IndirectTriangles & DD_TRI_OFFSET )
	  {
	    /* Finish computing plane equation of polygon, compute offset */
	    GLfloat fz = VB->Win[v3][2] - VB->Win[v1][2];
	    GLfloat ez = VB->Win[v2][2] - VB->Win[v1][2];
	    GLfloat a = (ey * fz) - (ez * fy);
	    GLfloat b = (ez * fx) - (ex * fz);
	    OffsetPolygon( ctx, a, b, c );
	  }

	  /*=====================================*/
	  /* Populate the the triangle vertices. */
	  /*=====================================*/
	  dwPVColor = (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];

	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v1][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v1][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v1][2] + ctx->PolygonZoffset) );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v1][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v1][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v1][3]) );
	  D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                                         (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v2][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v2][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v2][2] + ctx->PolygonZoffset)  );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v2][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v2][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v2][3]) );
	  D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                                         (VB->Color[v2][3]<<24) | (VB->Color[v2][0]<<16) | (VB->Color[v2][1]<<8) | VB->Color[v2][2];

	  D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v3][0] );
	  D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v3][1]) );
	  D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v3][2] + ctx->PolygonZoffset) );
	  D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v3][0] );
	  D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v3][1] );
	  D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v3][3]) );
	  D3DTLVertices[cVertex++].color= dwPVColor;
	}

	/* Render the converted vertex buffer. */
	if ( cVertex )
	  DrawPrimitiveHAL( pContext->pShared, D3DPT_TRIANGLELIST, &D3DTLVertices[0], cVertex );
#undef v1
#undef v2
#undef v3
   }
}
/*===========================================================================*/
/*  This function will render the current vertex buffer as a triangle strip. */
/* The buffer has to be able to be rendered directly.  This means that we are*/
/* filled, no offsets, no culling and one sided rendering.  Also we must be  */
/* in render mode of course.                                                 */
/*  First I will fill the global D3D vertice buffer.  Next I will set all the*/
/* states for D3D based on the current OGL state.  Finally I pass the D3D VB */
/* to the wrapper that call DrawPrimitives.                                  */
/*===========================================================================*/
/* RETURN:                                                                   */
/*===========================================================================*/
static void RenderTriangleStripVB( GLcontext *ctx, GLuint start, GLuint end )
{
  D3DMESACONTEXT     	*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
  struct vertex_buffer 	*VB = ctx->VB;
  int                    index,
                         cVertex = 0,
	                    v1, v2, v3,
                         height = (pContext->pShared->rectW.bottom - pContext->pShared->rectW.top);
  GLfloat              	ex, ey,
                         fx, fy, c;
  GLuint               	facing;
  DWORD                	dwPVColor;

  DPF(( DBG_FUNC, "RenderTriangleStripVB();" ));

  /* Special case that we can blast the fan without culling, offset, etc... */
  if ( !VB->ClipOrMask && (ctx->Light.ShadeModel != GL_FLAT) )
  {
    DPF(( DBG_PRIM_PROFILE, "DirectTriangles" ));

    /* Seed the the strip. */
    D3DTLVertices[0].sx   = D3DVAL( VB->Win[start][0] );
    D3DTLVertices[0].sy   = D3DVAL( (height - VB->Win[start][1]) );
    D3DTLVertices[0].sz   = D3DVAL( VB->Win[start][2] );
    D3DTLVertices[0].tu   = D3DVAL( VB->TexCoord[start][0] );
    D3DTLVertices[0].tv   = D3DVAL( VB->TexCoord[start][1] );
    D3DTLVertices[0].rhw  = D3DVAL( (1.0 / VB->Clip[start][3]) );
    D3DTLVertices[0].color= (VB->Color[start][3]<<24) | (VB->Color[start][0]<<16) | (VB->Color[start][1]<<8) | VB->Color[start][2];

    /* Seed the the strip. */
    D3DTLVertices[1].sx   = D3DVAL( VB->Win[(start+1)][0] );
    D3DTLVertices[1].sy   = D3DVAL( (height - VB->Win[(start+1)][1]) );
    D3DTLVertices[1].sz   = D3DVAL( VB->Win[(start+1)][2] );
    D3DTLVertices[1].tu   = D3DVAL( VB->TexCoord[(start+1)][0] );
    D3DTLVertices[1].tv   = D3DVAL( VB->TexCoord[(start+1)][1] );
    D3DTLVertices[1].rhw  = D3DVAL( (1.0 / VB->Clip[(start+1)][3]) );
    D3DTLVertices[1].color= (VB->Color[(start+1)][3]<<24) | (VB->Color[(start+1)][0]<<16) | (VB->Color[(start+1)][1]<<8) | VB->Color[(start+1)][2];

    for( index = (start+2), cVertex = 2; index < end; index++, cVertex++ )
    {
	 /*===================================*/
	 /* Add the next vertex to the strip. */
	 /*===================================*/
	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[index][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[index][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[index][2] );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[index][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[index][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[index][3]) );
	 D3DTLVertices[cVertex].color  = (VB->Color[index][3]<<24) | (VB->Color[index][0]<<16) | (VB->Color[index][1]<<8) | VB->Color[index][2];
    }

    /* Render the converted vertex buffer. */
    if ( cVertex )
	 DrawPrimitiveHAL( pContext->pShared, D3DPT_TRIANGLESTRIP, &D3DTLVertices[0], cVertex );
  }
  else
  {
    for( index = (start+2); index < end; index++ )
    {
	 /* We need to switch order so that winding won't be a problem. */
	 if ( index & 1 )
	 {
	   v1 = index - 1;
	   v2 = index - 2;
	   v3 = index - 0;
	 }
	 else
	 {
	   v1 = index - 2;
	   v2 = index - 1;
	   v3 = index - 0;
	 }

	 /* All vertices clipped by common plane */
	 if ( VB->ClipMask[v1] & VB->ClipMask[v2] & VB->ClipMask[v3] & CLIP_ALL_BITS )
	   continue;

	 /* Check if any vertices need clipping. */
	 if ( VB->ClipMask[v1] | VB->ClipMask[v2] | VB->ClipMask[v3] )
	 {
	   VList[0] = v1;
	   VList[1] = v2;
	   VList[2] = v3;
	   RenderClippedPolygon( ctx, 3, VList );
	 }
	 else
	 {
	   /* Compute orientation of triangle */
	   ex = VB->Win[v2][0] - VB->Win[v1][0];
	   ey = VB->Win[v2][1] - VB->Win[v1][1];
	   fx = VB->Win[v3][0] - VB->Win[v1][0];
	   fy = VB->Win[v3][1] - VB->Win[v1][1];
	   c = (ex * fy) - (ey * fx);

	   /* Polygon is perpindicular to view plane, don't draw it */
	   if ( (c == 0.0F) && !ctx->Polygon.Unfilled )
		continue;

	   /* Backface culling. */
	   facing = (c < 0.0F) ^ ctx->Polygon.FrontBit;
	   if ( (facing + 1) & ctx->Polygon.CullBits )
		continue;

	   /* Need right color if we have two sided lighting. */
	   if ( ctx->IndirectTriangles & DD_TRI_LIGHT_TWOSIDE )
	   {
		if ( facing == 1 )
		{
		  /* use back color */
		  VB->Color   = VB->Bcolor;
		  VB->Specular= VB->Bspec;
		}
		else
		{
		  /* use front color */
		  VB->Color   = VB->Fcolor;
		  VB->Specular= VB->Fspec;
		}
	   }

	   if ( ctx->IndirectTriangles & DD_TRI_OFFSET )
	   {
		/* Finish computing plane equation of polygon, compute offset */
		GLfloat fz = VB->Win[v3][2] - VB->Win[v1][2];
		GLfloat ez = VB->Win[v2][2] - VB->Win[v1][2];
		GLfloat a = (ey * fz) - (ez * fy);
		GLfloat b = (ez * fx) - (ex * fz);
		OffsetPolygon( ctx, a, b, c );
	   }
	   /*=====================================*/
	   /* Populate the the triangle vertices. */
	   /*=====================================*/

	   /* Solve the prevoking vertex color as we need it for the 3rd triangle and flat shading. */
	   dwPVColor = (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];

	   D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v1][0] );
	   D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v1][1]) );
	   D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v1][2] + ctx->PolygonZoffset) );
	   D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v1][0] );
	   D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v1][1] );
	   D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v1][3]) );
	   D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                        dwPVColor :
                                        (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

	   D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v2][0] );
	   D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v2][1]) );
	   D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v2][2] + ctx->PolygonZoffset) );
	   D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v2][0] );
	   D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v2][1] );
	   D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v2][3]) );
	   D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                          dwPVColor :
                                          (VB->Color[v2][3]<<24) | (VB->Color[v2][0]<<16) | (VB->Color[v2][1]<<8) | VB->Color[v2][2];

	   D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v3][0] );
	   D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v3][1]) );
	   D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v3][2] + ctx->PolygonZoffset) );
	   D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v3][0] );
	   D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v3][1] );
	   D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v3][3]) );
	   D3DTLVertices[cVertex++].color= dwPVColor;
	 }
    }

    /* Render the converted vertex buffer. */
    if ( cVertex )	
	 DrawPrimitiveHAL( pContext->pShared, D3DPT_TRIANGLELIST, &D3DTLVertices[0], cVertex );
  }	
}
/*===========================================================================*/
/*  This function will render the current vertex buffer as Quads.  The buffer*/
/* has to be able to be rendered directly.  This means that we are filled, no*/
/* offsets, no culling and one sided rendering.  Also we must be in render   */
/* mode of cource.                                                           */
/*  First I will fill the global D3D vertice buffer.  Next I will set all the*/
/* states for D3D based on the current OGL state.  Finally I pass the D3D VB */
/* to the wrapper that call DrawPrimitives.                                  */
/*===========================================================================*/
/* RETURN:                                                                   */
/*===========================================================================*/
static void RenderQuadVB( GLcontext *ctx, GLuint start, GLuint end )
{
  D3DMESACONTEXT       	*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
  struct vertex_buffer	*VB = ctx->VB;
  int                  	index,
                         cVertex,
                         height = (pContext->pShared->rectW.bottom - pContext->pShared->rectW.top);
  DWORD                	dwPVColor;
  GLfloat             	ex, ey,
                         fx, fy, c;
  GLuint				facing;  /* 0=front, 1=back */

  DPF(( DBG_FUNC, "RenderQuadVB();" ));

#define  v1 (index)
#define  v2 (index+1)
#define  v3 (index+2)
#define  v4 (index+3)

  if ( !VB->ClipOrMask )
  {
    DPF(( DBG_PRIM_PROFILE, "DirectTriangles" ));

    for( cVertex = 0, index = start; index < end; index += 4 )
    {
	 if ( ctx->Light.ShadeModel == GL_FLAT )
	   dwPVColor = (VB->Color[v4][3]<<24) | (VB->Color[v4][0]<<16) | (VB->Color[v4][1]<<8) | VB->Color[v4][2];

	 /*=====================================*/
	 /* Populate the the triangle vertices. */
	 /*=====================================*/
	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v1][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v1][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[v1][2] );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v1][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v1][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v1][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                      dwPVColor :
	                                 (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v2][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v2][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[v2][2] );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v2][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v2][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v2][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                      dwPVColor :
                                      (VB->Color[v2][3]<<24) | (VB->Color[v2][0]<<16) | (VB->Color[v2][1]<<8) | VB->Color[v2][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v3][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v3][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[v3][2] );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v3][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v3][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v3][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
	                                 dwPVColor :
                                      (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v1][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v1][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[v1][2] );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v1][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v1][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v1][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
	                                 dwPVColor :
                                      (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v3][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v3][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[v3][2] );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v3][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v3][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v3][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                      dwPVColor :
                                      (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v4][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v4][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( VB->Win[v4][2] );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v4][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v4][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v4][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                      dwPVColor :
                                      (VB->Color[v4][3]<<24) | (VB->Color[v4][0]<<16) | (VB->Color[v4][1]<<8) | VB->Color[v4][2];
    }
  }
  else
  {
    for( cVertex = 0, index = start; index < end; index += 4 )
    {
	 if ( VB->ClipMask[v1] & VB->ClipMask[v2] & VB->ClipMask[v3]  & VB->ClipMask[v4] & CLIP_ALL_BITS )
	 {
	   continue;
	 }	
	 else if ( VB->ClipMask[v1] | VB->ClipMask[v2] | VB->ClipMask[v3] | VB->ClipMask[v4] )
	 {
	   VList[0] = v1;
	   VList[1] = v2;
	   VList[2] = v3;
	   VList[3] = v4;
	   RenderClippedPolygon( ctx, 4, VList );
	   continue;
	 }

	 /* Compute orientation of triangle */
	 ex = VB->Win[v2][0] - VB->Win[v1][0];
	 ey = VB->Win[v2][1] - VB->Win[v1][1];
	 fx = VB->Win[v3][0] - VB->Win[v1][0];
	 fy = VB->Win[v3][1] - VB->Win[v1][1];
	 c = (ex * fy) - (ey * fx);

	 /* polygon is perpindicular to view plane, don't draw it */
	 if ( (c == 0.0F) && !ctx->Polygon.Unfilled )
	   continue;

	 /* Backface culling. */
	 facing = (c < 0.0F) ^ ctx->Polygon.FrontBit;
	 if ( (facing + 1) & ctx->Polygon.CullBits )
	   continue;

	 if ( ctx->IndirectTriangles & DD_TRI_LIGHT_TWOSIDE )
	 {
	   if ( facing == 1 )
	   {
		/* use back color */
		VB->Color   = VB->Bcolor;
		VB->Specular= VB->Bspec;
	   }
	   else
	   {
		/* use front color */
		VB->Color   = VB->Fcolor;
		VB->Specular= VB->Fspec;
	   }	
	 }	

	 if ( ctx->IndirectTriangles & DD_TRI_OFFSET )
	 {
	   /* Finish computing plane equation of polygon, compute offset */
	   GLfloat fz = VB->Win[v3][2] - VB->Win[v1][2];
	   GLfloat ez = VB->Win[v2][2] - VB->Win[v1][2];
	   GLfloat a = (ey * fz) - (ez * fy);
	   GLfloat b = (ez * fx) - (ex * fz);
	   OffsetPolygon( ctx, a, b, c );
	 }

	 if ( ctx->Light.ShadeModel == GL_FLAT )
	   dwPVColor = (VB->Color[v4][3]<<24) | (VB->Color[v4][0]<<16) | (VB->Color[v4][1]<<8) | VB->Color[v4][2];

	 /*=====================================*/
	 /* Populate the the triangle vertices. */
	 /*=====================================*/
	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v1][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v1][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v1][2] + ctx->PolygonZoffset) );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v1][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v1][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v1][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                       dwPVColor :
                                       (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v2][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v2][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v2][2] + ctx->PolygonZoffset) );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v2][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v2][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v2][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                       dwPVColor :
                                       (VB->Color[v2][3]<<24) | (VB->Color[v2][0]<<16) | (VB->Color[v2][1]<<8) | VB->Color[v2][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v3][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v3][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v3][2] + ctx->PolygonZoffset) );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v3][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v3][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v3][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                       dwPVColor :
                                       (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v1][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v1][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v1][2] + ctx->PolygonZoffset) );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v1][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v1][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v1][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
	                                  dwPVColor :
                                       (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v3][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v3][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v3][2] + ctx->PolygonZoffset) );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v3][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v3][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v3][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                       dwPVColor :
                                       (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];

	 D3DTLVertices[cVertex].sx     = D3DVAL( VB->Win[v4][0] );
	 D3DTLVertices[cVertex].sy     = D3DVAL( (height - VB->Win[v4][1]) );
	 D3DTLVertices[cVertex].sz     = D3DVAL( (VB->Win[v4][2] + ctx->PolygonZoffset) );
	 D3DTLVertices[cVertex].tu     = D3DVAL( VB->TexCoord[v4][0] );
	 D3DTLVertices[cVertex].tv     = D3DVAL( VB->TexCoord[v4][1] );
	 D3DTLVertices[cVertex].rhw    = D3DVAL( (1.0 / VB->Clip[v4][3]) );
	 D3DTLVertices[cVertex++].color= (ctx->Light.ShadeModel == GL_FLAT) ?
                                       dwPVColor :
                                       (VB->Color[v4][3]<<24) | (VB->Color[v4][0]<<16) | (VB->Color[v4][1]<<8) | VB->Color[v4][2];
    }
  }

#undef   v4
#undef   v3
#undef   v2
#undef   v1

  /* Render the converted vertex buffer. */
  if ( cVertex )
    DrawPrimitiveHAL( pContext->pShared, D3DPT_TRIANGLELIST, &D3DTLVertices[0], cVertex );
}
/*===========================================================================*/
/*                                                                           */
/*===========================================================================*/
/* RETURN: TRUE, FALSE.                                                      */
/*===========================================================================*/
static void RenderQuad( GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint v4, GLuint pv )
{
  D3DMESACONTEXT     	*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
  struct vertex_buffer 	*VB = ctx->VB;
  int                  	height = (pContext->pShared->rectW.bottom - pContext->pShared->rectW.top);
  DWORD                	dwPVColor;
  GLfloat              	ex, ey,
                         fx, fy, c;
  GLuint               	facing;  /* 0=front, 1=back */
  static D3DTLVERTEX   	TLVertices[6];

  DPF(( DBG_FUNC, "RenderQuad" ));
  DPF(( DBG_PRIM_INFO, "RenderQuad( 1 )" ));

  /* Compute orientation of triangle */
  ex = VB->Win[v2][0] - VB->Win[v1][0];
  ey = VB->Win[v2][1] - VB->Win[v1][1];
  fx = VB->Win[v3][0] - VB->Win[v1][0];
  fy = VB->Win[v3][1] - VB->Win[v1][1];
  c = (ex * fy) - (ey * fx);

  /* polygon is perpindicular to view plane, don't draw it */
  if ( (c == 0.0F) && !ctx->Polygon.Unfilled )
    return;

  /* Backface culling. */
  facing = (c < 0.0F) ^ ctx->Polygon.FrontBit;
  if ( (facing + 1) & ctx->Polygon.CullBits )
    return;

  if ( ctx->IndirectTriangles & DD_TRI_LIGHT_TWOSIDE )
  {
    if ( facing == 1 )
    {
	 /* use back color */
	 VB->Color   = VB->Bcolor;
	 VB->Specular= VB->Bspec;
    }
    else
    {
	 /* use front color */
	 VB->Color   = VB->Fcolor;
	 VB->Specular= VB->Fspec;
    }
  }

  if ( ctx->IndirectTriangles & DD_TRI_OFFSET )
  {
    /* Finish computing plane equation of polygon, compute offset */
    GLfloat fz = VB->Win[v3][2] - VB->Win[v1][2];
    GLfloat ez = VB->Win[v2][2] - VB->Win[v1][2];
    GLfloat a = (ey * fz) - (ez * fy);
    GLfloat b = (ez * fx) - (ex * fz);
    OffsetPolygon( ctx, a, b, c );
  }

  if ( ctx->Light.ShadeModel == GL_FLAT )
    dwPVColor = (VB->Color[pv][3]<<24) | (VB->Color[pv][0]<<16) | (VB->Color[pv][1]<<8) | VB->Color[pv][2];

  /*=====================================*/
  /* Populate the the triangle vertices. */
  /*=====================================*/
  TLVertices[0].sx      = D3DVAL( VB->Win[v1][0] );
  TLVertices[0].sy      = D3DVAL( (height - VB->Win[v1][1]) );
  TLVertices[0].sz      = D3DVAL( (VB->Win[v1][2] + ctx->PolygonZoffset) );
  TLVertices[0].tu      = D3DVAL( VB->TexCoord[v1][0] );
  TLVertices[0].tv      = D3DVAL( VB->TexCoord[v1][1] );
  TLVertices[0].rhw     = D3DVAL( (1.0 / VB->Clip[v1][3]) );
  TLVertices[0].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                           (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

   TLVertices[1].sx      = D3DVAL( VB->Win[v2][0] );
   TLVertices[1].sy      = D3DVAL( (height - VB->Win[v2][1]) );
   TLVertices[1].sz      = D3DVAL( (VB->Win[v2][2] + ctx->PolygonZoffset) );
   TLVertices[1].tu      = D3DVAL( VB->TexCoord[v2][0] );
   TLVertices[1].tv      = D3DVAL( VB->TexCoord[v2][1] );
   TLVertices[1].rhw     = D3DVAL( (1.0 / VB->Clip[v2][3]) );
   TLVertices[1].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                           (VB->Color[v2][3]<<24) | (VB->Color[v2][0]<<16) | (VB->Color[v2][1]<<8) | VB->Color[v2][2];

   TLVertices[2].sx      = D3DVAL( VB->Win[v3][0] );
   TLVertices[2].sy      = D3DVAL( (height - VB->Win[v3][1]) );
   TLVertices[2].sz      = D3DVAL( (VB->Win[v3][2] + ctx->PolygonZoffset) );
   TLVertices[2].tu      = D3DVAL( VB->TexCoord[v3][0] );
   TLVertices[2].tv      = D3DVAL( VB->TexCoord[v3][1] );
   TLVertices[2].rhw     = D3DVAL( (1.0 / VB->Clip[v3][3]) );
   TLVertices[2].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                           (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];

   TLVertices[3].sx      = D3DVAL( VB->Win[v3][0] );
   TLVertices[3].sy      = D3DVAL( (height - VB->Win[v3][1]) );
   TLVertices[3].sz      = D3DVAL( (VB->Win[v3][2] + ctx->PolygonZoffset) );
   TLVertices[3].tu      = D3DVAL( VB->TexCoord[v3][0] );
   TLVertices[3].tv      = D3DVAL( VB->TexCoord[v3][1] );
   TLVertices[3].rhw     = D3DVAL( (1.0 / VB->Clip[v3][3]) );
   TLVertices[3].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                           (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];

   TLVertices[4].sx      = D3DVAL( VB->Win[v4][0] );
   TLVertices[4].sy      = D3DVAL( (height - VB->Win[v4][1]) );
   TLVertices[4].sz      = D3DVAL( (VB->Win[v4][2] + ctx->PolygonZoffset) );
   TLVertices[4].tu      = D3DVAL( VB->TexCoord[v4][0] );
   TLVertices[4].tv      = D3DVAL( VB->TexCoord[v4][1] );
   TLVertices[4].rhw     = D3DVAL( (1.0 / VB->Clip[v4][3]) );
   TLVertices[4].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                           (VB->Color[v4][3]<<24) | (VB->Color[v4][0]<<16) | (VB->Color[v4][1]<<8) | VB->Color[v4][2];

   TLVertices[5].sx      = D3DVAL( VB->Win[v1][0] );
   TLVertices[5].sy      = D3DVAL( (height - VB->Win[v1][1]) );
   TLVertices[5].sz      = D3DVAL( (VB->Win[v1][2] + ctx->PolygonZoffset) );
   TLVertices[5].tu      = D3DVAL( VB->TexCoord[v1][0] );
   TLVertices[5].tv      = D3DVAL( VB->TexCoord[v1][1] );
   TLVertices[5].rhw     = D3DVAL( (1.0 / VB->Clip[v1][3]) );
   TLVertices[5].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                           (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

   /* Draw the two triangles. */
   DrawPrimitiveHAL( pContext->pShared, D3DPT_TRIANGLELIST, &TLVertices[0], 6 );
}
/*===========================================================================*/
/*                                                                           */
/*===========================================================================*/
/* RETURN: TRUE, FALSE.                                                      */
/*===========================================================================*/
void	RenderOneTriangle( GLcontext *ctx, GLuint v1, GLuint v2, GLuint v3, GLuint pv )
{
  D3DMESACONTEXT       	*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
  struct vertex_buffer 	*VB = ctx->VB;
  int                  	height = (pContext->pShared->rectW.bottom - pContext->pShared->rectW.top);
  DWORD                	dwPVColor;
  static D3DTLVERTEX   	TLVertices[3];

  DPF(( DBG_FUNC, "RenderOneTriangle" ));
  DPF(( DBG_PRIM_INFO, "RenderTriangle( 1 )" ));

  /*=====================================*/
  /* Populate the the triangle vertices. */
  /*=====================================*/
  if ( ctx->Light.ShadeModel == GL_FLAT )
    dwPVColor = (VB->Color[pv][3]<<24) | (VB->Color[pv][0]<<16) | (VB->Color[pv][1]<<8) | VB->Color[pv][2];

  TLVertices[0].sx      = D3DVAL( VB->Win[v1][0] );
  TLVertices[0].sy      = D3DVAL( (height - VB->Win[v1][1]) );
  TLVertices[0].sz      = D3DVAL( (VB->Win[v1][2] + ctx->PolygonZoffset) );
  TLVertices[0].tu      = D3DVAL( VB->TexCoord[v1][0] );
  TLVertices[0].tv      = D3DVAL( VB->TexCoord[v1][1] );
  TLVertices[0].rhw     = D3DVAL( (1.0 / VB->Clip[v1][3]) );
  TLVertices[0].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                          (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];
  DPF(( DBG_PRIM_INFO, "V1 -> x:%f y:%f z:%f c:%x",
	   TLVertices[0].sx,
	   TLVertices[0].sy,
	   TLVertices[0].sz,
	   TLVertices[0].color ));

  TLVertices[1].sx      = D3DVAL( VB->Win[v2][0] );
  TLVertices[1].sy      = D3DVAL( (height - VB->Win[v2][1]) );
  TLVertices[1].sz      = D3DVAL( (VB->Win[v2][2] + ctx->PolygonZoffset) );
  TLVertices[1].tu      = D3DVAL( VB->TexCoord[v2][0] );
  TLVertices[1].tv      = D3DVAL( VB->TexCoord[v2][1] );
  TLVertices[1].rhw     = D3DVAL( (1.0 / VB->Clip[v2][3]) );
  TLVertices[1].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                          (VB->Color[v2][3]<<24) | (VB->Color[v2][0]<<16) | (VB->Color[v2][1]<<8) | VB->Color[v2][2];
  DPF(( DBG_PRIM_INFO, "V2 -> x:%f y:%f z:%f c:%x",
	   TLVertices[1].sx,
	   TLVertices[1].sy,
	   TLVertices[1].sz,
	   TLVertices[1].color ));

  TLVertices[2].sx      = D3DVAL( VB->Win[v3][0] );
  TLVertices[2].sy      = D3DVAL( (height - VB->Win[v3][1]) );
  TLVertices[2].sz      = D3DVAL( (VB->Win[v3][2] + ctx->PolygonZoffset) );
  TLVertices[2].tu      = D3DVAL( VB->TexCoord[v3][0] );
  TLVertices[2].tv      = D3DVAL( VB->TexCoord[v3][1] );
  TLVertices[2].rhw     = D3DVAL( (1.0 / VB->Clip[v3][3]) );
  TLVertices[2].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                          (VB->Color[v3][3]<<24) | (VB->Color[v3][0]<<16) | (VB->Color[v3][1]<<8) | VB->Color[v3][2];
  DPF(( DBG_PRIM_INFO, "V3 -> x:%f y:%f z:%f c:%x",
	   TLVertices[2].sx,
	   TLVertices[2].sy,
	   TLVertices[2].sz,
	   TLVertices[2].color ));

  /* Draw the triangle. */
  DrawPrimitiveHAL( pContext->pShared, D3DPT_TRIANGLELIST, &TLVertices[0], 3 );
}
/*===========================================================================*/
/*                                                                           */
/*===========================================================================*/
/* RETURN: TRUE, FALSE.                                                      */
/*===========================================================================*/
void RenderOneLine( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv )
{
  D3DMESACONTEXT     	*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
  struct vertex_buffer 	*VB = ctx->VB;
  int                  	height = (pContext->pShared->rectW.bottom - pContext->pShared->rectW.top);
  DWORD                	dwPVColor;
  static D3DTLVERTEX	TLVertices[2];

  DPF(( DBG_FUNC, "RenderOneLine" ));
  DPF(( DBG_PRIM_INFO, "RenderLine( 1 )" ));

  if ( VB->MonoColor )
    dwPVColor = (pContext->aCurrent<<24) | (pContext->rCurrent<<16) | (pContext->gCurrent<<8) | pContext->bCurrent;
  else 	
    dwPVColor = (VB->Color[pv][3]<<24) | (VB->Color[pv][0]<<16) | (VB->Color[pv][1]<<8) | VB->Color[pv][2];

   TLVertices[0].sx      = D3DVAL( VB->Win[v1][0] );
   TLVertices[0].sy      = D3DVAL( (height - VB->Win[v1][1]) );
   TLVertices[0].sz      = D3DVAL( (VB->Win[v1][2] + ctx->LineZoffset) );
   TLVertices[0].tu      = D3DVAL( VB->TexCoord[v1][0] );
   TLVertices[0].tv      = D3DVAL( VB->TexCoord[v1][1] );
   TLVertices[0].rhw     = D3DVAL( (1.0 / VB->Clip[v1][3]) );
   TLVertices[0].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                           (VB->Color[v1][3]<<24) | (VB->Color[v1][0]<<16) | (VB->Color[v1][1]<<8) | VB->Color[v1][2];

   TLVertices[1].sx      = D3DVAL( VB->Win[v2][0] );
   TLVertices[1].sy      = D3DVAL( (height - VB->Win[v2][1]) );
   TLVertices[1].sz      = D3DVAL( (VB->Win[v2][2] + ctx->LineZoffset) );
   TLVertices[1].tu      = D3DVAL( VB->TexCoord[v2][0] );
   TLVertices[1].tv      = D3DVAL( VB->TexCoord[v2][1] );
   TLVertices[1].rhw     = D3DVAL( (1.0 / VB->Clip[v2][3]) );
   TLVertices[1].color   = (ctx->Light.ShadeModel == GL_FLAT) ? dwPVColor :
                           (VB->Color[v2][3]<<24) | (VB->Color[v2][0]<<16) | (VB->Color[v2][1]<<8) | VB->Color[v2][2];

   /* Draw line from (x0,y0) to (x1,y1) with current pixel color/index */
   DrawPrimitiveHAL( pContext->pShared, D3DPT_LINELIST, &TLVertices[0], 2 );
}
/*===========================================================================*/
/*  This function was written to convert points into triangles.  I did this  */
/* as all card accelerate triangles and most drivers do this anyway.  In hind*/
/* thought this might be a bad idea as some cards do better.                 */
/*===========================================================================*/
/* RETURN:                                                                   */
/*===========================================================================*/
static void RenderPointsVB( GLcontext *ctx, GLuint start, GLuint end )
{
  D3DMESACONTEXT 		*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
  struct vertex_buffer 	*VB = ctx->VB;
  struct pixel_buffer 	*PB = ctx->PB;
  GLuint 				index;
  GLfloat                radius, z,
                         xmin, ymin,
                         xmax, ymax;
  GLint				cVertex,
                         height = (pContext->pShared->rectW.bottom - pContext->pShared->rectW.top);
  DWORD				dwPVColor;

  DPF(( DBG_FUNC, "RenderPointsVB();" ));

  radius = CLAMP( ctx->Point.Size, MIN_POINT_SIZE, MAX_POINT_SIZE ) * 0.5F;

  for( index = start, cVertex = 0; index <= end; index++ )
  {
    if ( VB->ClipMask[index] == 0 )
    {
	 xmin = D3DVAL( VB->Win[index][0] - radius );
	 xmax = D3DVAL( VB->Win[index][0] + radius );
	 ymin = D3DVAL( height - VB->Win[index][1] - radius );
	 ymax = D3DVAL( height - VB->Win[index][1] + radius );
	 z    = D3DVAL( (VB->Win[index][2] + ctx->PointZoffset) );

	 dwPVColor = (VB->Color[index][3]<<24) |
	             (VB->Color[index][0]<<16) |
	             (VB->Color[index][1]<<8) |
                  VB->Color[index][2];

	 D3DTLVertices[cVertex].sx	  = xmin;
	 D3DTLVertices[cVertex].sy      = ymax;
	 D3DTLVertices[cVertex].sz      = z;
	 D3DTLVertices[cVertex].tu      = 0.0;
	 D3DTLVertices[cVertex].tv      = 0.0;
	 D3DTLVertices[cVertex].rhw     = D3DVAL( (1.0 / VB->Clip[index][3]) );
	 D3DTLVertices[cVertex++].color = dwPVColor;

	 D3DTLVertices[cVertex].sx      = xmin;
	 D3DTLVertices[cVertex].sy      = ymin;
	 D3DTLVertices[cVertex].sz      = z;
	 D3DTLVertices[cVertex].tu      = 0.0;
	 D3DTLVertices[cVertex].tv      = 0.0;
	 D3DTLVertices[cVertex].rhw     = D3DVAL( (1.0 / VB->Clip[index][3]) );
	 D3DTLVertices[cVertex++].color = dwPVColor;

	 D3DTLVertices[cVertex].sx      = xmax;
	 D3DTLVertices[cVertex].sy      = ymin;
	 D3DTLVertices[cVertex].sz      = z;
	 D3DTLVertices[cVertex].tu      = 0.0;
	 D3DTLVertices[cVertex].tv      = 0.0;
	 D3DTLVertices[cVertex].rhw     = D3DVAL( (1.0 / VB->Clip[index][3]) );
	 D3DTLVertices[cVertex++].color = dwPVColor;

	 D3DTLVertices[cVertex].sx      = xmax;
	 D3DTLVertices[cVertex].sy      = ymin;
	 D3DTLVertices[cVertex].sz      = z;
	 D3DTLVertices[cVertex].tu      = 0.0;
	 D3DTLVertices[cVertex].tv      = 0.0;
	 D3DTLVertices[cVertex].rhw     = D3DVAL( (1.0 / VB->Clip[index][3]) );
	 D3DTLVertices[cVertex++].color = dwPVColor;

	 D3DTLVertices[cVertex].sx	  = xmax;
	 D3DTLVertices[cVertex].sy      = ymax;
	 D3DTLVertices[cVertex].sz      = z;
	 D3DTLVertices[cVertex].tu      = 0.0;
	 D3DTLVertices[cVertex].tv      = 0.0;
	 D3DTLVertices[cVertex].rhw     = D3DVAL( (1.0 / VB->Clip[index][3]) );
	 D3DTLVertices[cVertex++].color = dwPVColor;

	 D3DTLVertices[cVertex].sx	  = xmin;
	 D3DTLVertices[cVertex].sy      = ymax;
	 D3DTLVertices[cVertex].sz      = z;
	 D3DTLVertices[cVertex].tu      = 0.0;
	 D3DTLVertices[cVertex].tv      = 0.0;
	 D3DTLVertices[cVertex].rhw     = D3DVAL( (1.0 / VB->Clip[index][3]) );
	 D3DTLVertices[cVertex++].color = dwPVColor;
    }
  }

  /* Render the converted vertex buffer. */
  if ( cVertex )
    DrawPrimitiveHAL( pContext->pShared, D3DPT_TRIANGLELIST, &D3DTLVertices[0], cVertex );
}
/*===========================================================================*/
/*  This gets call before we render any primitives so that the current OGL   */
/* states will be mapped the D3D context.  I'm still not sure how D3D works  */
/* but I'm finding that it doesn't act like a state machine as OGL is.  It   */
/* looks like the state gets set back to the defaults after a DrawPrimitives */
/* or an EndScene.  Also I set states that are the default even though this  */
/* is redundant as the defaults seem screwed up.                             */
/* TODO: make a batch call.                                                  */
/*===========================================================================*/
/* RETURN:                                                                   */
/*===========================================================================*/
static void SetRenderStates( GLcontext *ctx )
{
   D3DMESACONTEXT	*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
   DWORD          	dwFunc;
   static	BOOL		bTexture = FALSE;
   static int		texName = -1;

   DPF(( DBG_FUNC, "SetRenderStates();" ));

   if ( g_DBGMask & DBG_STATES )
	DebugRenderStates( ctx, FALSE );

   SetStateHAL( pContext->pShared, D3DRENDERSTATE_CULLMODE, D3DCULL_NONE );
   SetStateHAL( pContext->pShared, D3DRENDERSTATE_DITHERENABLE, (ctx->Color.DitherFlag) ? TRUE : FALSE );

   /*================================================*/
   /* Check too see if there are new TEXTURE states. */
   /*================================================*/
   if ( ctx->Texture._ReallyEnabled )
   {
      switch( ctx->Texture.Set[ctx->Texture.CurrentSet].EnvMode )
      {
        case GL_MODULATE:
		if ( ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Image[0]->Format == GL_RGBA )
		  dwFunc = pContext->pShared->dwTexFunc[d3dtblend_modulatealpha];
		else
		  dwFunc = pContext->pShared->dwTexFunc[d3dtblend_modulate];
		break;

	   case GL_BLEND:
		dwFunc = pContext->pShared->dwTexFunc[d3dtblend_decalalpha];
		break;

        case GL_REPLACE:
		dwFunc = pContext->pShared->dwTexFunc[d3dtblend_decal];
		break;

        case GL_DECAL:
		if ( ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Image[0]->Format == GL_RGBA )
		  dwFunc = pContext->pShared->dwTexFunc[d3dtblend_decalalpha];
		else
		  dwFunc = pContext->pShared->dwTexFunc[d3dtblend_decal];
		break;
      }
      SetStateHAL( pContext->pShared, D3DRENDERSTATE_TEXTUREMAPBLEND, dwFunc );

      switch( ctx->Texture.Set[ctx->Texture.CurrentSet].Current->MagFilter )
      {
	   case GL_NEAREST:
		dwFunc = D3DFILTER_NEAREST;
		break;
        case GL_LINEAR:
		dwFunc = D3DFILTER_LINEAR;
		break;
        case GL_NEAREST_MIPMAP_NEAREST:
		dwFunc = D3DFILTER_MIPNEAREST;
		break;
        case GL_LINEAR_MIPMAP_NEAREST:
		dwFunc = D3DFILTER_LINEARMIPNEAREST;
		break;
        case GL_NEAREST_MIPMAP_LINEAR:
		dwFunc = D3DFILTER_MIPLINEAR;
		break;
        case GL_LINEAR_MIPMAP_LINEAR:
		dwFunc = D3DFILTER_LINEARMIPLINEAR;
		break;
      }
      SetStateHAL( pContext->pShared, D3DRENDERSTATE_TEXTUREMAG, dwFunc );

      switch( ctx->Texture.Set[ctx->Texture.CurrentSet].Current->MinFilter )
      {
	   case GL_NEAREST:
		dwFunc = D3DFILTER_NEAREST;
		break;
        case GL_LINEAR:
		dwFunc = D3DFILTER_LINEAR;
		break;
        case GL_NEAREST_MIPMAP_NEAREST:
		dwFunc = D3DFILTER_MIPNEAREST;
		break;
        case GL_LINEAR_MIPMAP_NEAREST:
		dwFunc = D3DFILTER_LINEARMIPNEAREST;
		break;
        case GL_NEAREST_MIPMAP_LINEAR:
		dwFunc = D3DFILTER_MIPLINEAR;
		break;
        case GL_LINEAR_MIPMAP_LINEAR:
		dwFunc = D3DFILTER_LINEARMIPLINEAR;
		break;
      }
      SetStateHAL( pContext->pShared, D3DRENDERSTATE_TEXTUREMIN, dwFunc  );

	 /* Another hack to cut down on redundant texture binding. */
	 //	 if ( texName != ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Name )
	 //	 {
	   texName = ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Name;
	   CreateTMgrHAL( pContext->pShared,
				   texName,
				   0,
				   ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Image[0]->Format,
				   (RECT *)NULL,
				   ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Image[0]->Width,
				   ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Image[0]->Height,
				   TM_ACTION_BIND,
				   (void *)ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Image[0]->Data );
	   //	 }
	 bTexture = TRUE;
   }
   else
   {
	/* This is nasty but should cut down on the number of redundant calls. */
	if ( bTexture == TRUE )
	{
	  DisableTMgrHAL( pContext->pShared );
	  bTexture = FALSE;
	}
   }

   /*===============================================*/
   /* Check too see if there are new RASTER states. */
   /*===============================================*/

   // TODO: no concept of front & back.
   switch( ctx->Polygon.FrontMode )
   {
     case GL_POINT:
	  SetStateHAL( pContext->pShared, D3DRENDERSTATE_FILLMODE, D3DFILL_POINT );
	  break;
     case GL_LINE:
	  SetStateHAL( pContext->pShared, D3DRENDERSTATE_FILLMODE, D3DFILL_WIREFRAME );
	  break;
     case GL_FILL:
	  SetStateHAL( pContext->pShared, D3DRENDERSTATE_FILLMODE, D3DFILL_SOLID );
	  break;
   }

   /*************/
   /* Z-Buffer. */
   /*************/
   if ( ctx->Depth.Test == GL_TRUE )
   {
	switch( ctx->Depth.Func )
	{
	  case GL_NEVER:
	    dwFunc = D3DCMP_NEVER;
	    break;
	  case GL_LESS:
	    dwFunc = D3DCMP_LESS;
	    break;
  	  case GL_GEQUAL:
	    dwFunc = D3DCMP_GREATEREQUAL;
	    break;
  	  case GL_LEQUAL:
	    dwFunc = D3DCMP_LESSEQUAL;
	    break;
	  case GL_GREATER:
	    dwFunc = D3DCMP_GREATER;
	    break;
	  case GL_NOTEQUAL:
	    dwFunc = D3DCMP_NOTEQUAL;
	    break;
	  case GL_EQUAL:
	    dwFunc = D3DCMP_EQUAL;
	    break;
	  case GL_ALWAYS:
	    dwFunc = D3DCMP_ALWAYS;
	    break;
	}
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_ZFUNC, dwFunc );
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_ZENABLE, TRUE );
   }	
   else
   {
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_ZENABLE, FALSE );
   }

   /*******************/
   /* Z-Write Enable. */
   /*******************/
   SetStateHAL( pContext->pShared, D3DRENDERSTATE_ZWRITEENABLE , (ctx->Depth.Mask == GL_TRUE) ? TRUE : FALSE );

   /***************/
   /* Alpha test. */
   /***************/
   if ( ctx->Color.AlphaEnabled == GL_TRUE )
   {
	switch( ctx->Color.AlphaFunc )
     {
	  case GL_NEVER:
	    dwFunc = D3DCMP_NEVER;
	    break;
	  case GL_LESS:
	    dwFunc = D3DCMP_LESS;
	    break;
  	  case GL_GEQUAL:
	    dwFunc = D3DCMP_GREATEREQUAL;
	    break;
  	  case GL_LEQUAL:
	    dwFunc = D3DCMP_LESSEQUAL;
	    break;
	  case GL_GREATER:
	    dwFunc = D3DCMP_GREATER;
	    break;
	  case GL_NOTEQUAL:
	    dwFunc = D3DCMP_NOTEQUAL;
	    break;
	  case GL_EQUAL:
	    dwFunc = D3DCMP_EQUAL;
	    break;
	  case GL_ALWAYS:
	    dwFunc = D3DCMP_ALWAYS;
	    break;
	}
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_ALPHAFUNC , dwFunc );
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_ALPHATESTENABLE, TRUE );
   }
   else
   {
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_ALPHATESTENABLE, FALSE );
   }

   /****************/
   /* Alpha blend. */
   /****************/
   if ( ctx->Color.BlendEnabled == GL_TRUE )
   {
	switch( ctx->Color.BlendSrc )
	{
	  case GL_ZERO:	    			
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_zero];
	    break;
       case GL_ONE:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_one];
	    break;
       case GL_DST_COLOR:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_dst_color];
	    break;
       case GL_ONE_MINUS_DST_COLOR:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_one_minus_dst_color];
	    break;
       case GL_SRC_ALPHA:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_src_alpha];
	    break;
       case GL_ONE_MINUS_SRC_ALPHA:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_one_minus_src_alpha];
	    break;
       case GL_DST_ALPHA:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_dst_alpha];
	    break;
       case GL_ONE_MINUS_DST_ALPHA:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_one_minus_dst_alpha];
	    break;
       case GL_SRC_ALPHA_SATURATE:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_src_alpha_saturate];
	    break;
       case GL_CONSTANT_COLOR:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_constant_color];
	    break;
       case GL_ONE_MINUS_CONSTANT_COLOR:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_one_minus_constant_color];
	    break;
       case GL_CONSTANT_ALPHA:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_constant_alpha];
	    break;
       case GL_ONE_MINUS_CONSTANT_ALPHA:
	    dwFunc = pContext->pShared->dwSrcBlendCaps[s_one_minus_constant_alpha];
	    break;
	}
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_SRCBLEND, dwFunc );

	switch( ctx->Color.BlendDst )
	{
       case GL_ZERO:                  	
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_zero];
	    break;
       case GL_ONE:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_one];
	    break;
       case GL_SRC_COLOR:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_src_color];
	    break;
       case GL_ONE_MINUS_SRC_COLOR:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_one_minus_src_color];
	    break;
       case GL_SRC_ALPHA:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_src_alpha];
	    break;
       case GL_ONE_MINUS_SRC_ALPHA:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_one_minus_src_alpha];
	    break;
       case GL_DST_ALPHA:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_dst_alpha];
	    break;
       case GL_ONE_MINUS_DST_ALPHA:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_one_minus_dst_alpha];
	    break;
       case GL_CONSTANT_COLOR:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_constant_color];
	    break;
       case GL_ONE_MINUS_CONSTANT_COLOR:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_one_minus_constant_color];
	    break;
       case GL_CONSTANT_ALPHA:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_constant_alpha];
	    break;
       case GL_ONE_MINUS_CONSTANT_ALPHA:
	    dwFunc = pContext->pShared->dwDestBlendCaps[d_one_minus_constant_alpha];
	    break;
	}
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_DESTBLEND, dwFunc );
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_ALPHABLENDENABLE, TRUE );
   }
   else
   {
	SetStateHAL( pContext->pShared, D3DRENDERSTATE_ALPHABLENDENABLE, FALSE );
   }
}
/*===========================================================================*/
/*  If this function is called it will track the changes to the current      */
/* states that I'm setting in Direct3D.  I did this so that the DPF's would  */
/* be under control!                                                         */
/*===========================================================================*/
/* RETURN:                                                                   */
/*===========================================================================*/
static void DebugRenderStates( GLcontext *ctx, BOOL bForce )
{
   D3DMESACONTEXT	*pContext = (D3DMESACONTEXT *)ctx->DriverCtx;
   DWORD			dwFunc;
   static int		dither = -1,
	               texture = -1,
                    textName = -1,
	               textEnv = -1,
                    textMin = -1,
                    textMag = -1,
                    polyMode = -1,
	               depthTest = -1,
	               depthFunc = -1,
	               depthMask = -1,
	               alphaTest = -1,
                    alphaFunc = -1,
	               blend = -1,
                    blendSrc = -1,
                    blendDest = -1;

   /* Force a displayed update of all current states. */
   if ( bForce )
   {
	dither = texture = textName = textEnv = textMin = textMag = -1;
	polyMode = depthTest = depthFunc = depthMask = -1;
	alphaTest = alphaFunc = blend = blendSrc = blendDest = -1;
   }

   if ( dither != ctx->Color.DitherFlag )
   {
	dither = ctx->Color.DitherFlag;
	DPF(( 0, "\tDither\t\t%s", (dither) ? "ENABLED" : "--------" ));
   }
   if ( depthTest != ctx->Depth.Test )
   {
	depthTest = ctx->Depth.Test;
	DPF(( 0, "\tDepth Test\t%s", (depthTest) ? "ENABLED" : "--------" ));
   }
   if ( alphaTest != ctx->Color.AlphaEnabled )
   {	
	alphaTest = ctx->Color.AlphaEnabled;
	
	DPF(( 0, "\tAlpha Test\t%s", (alphaTest) ? "ENABLED" : "--------" ));
   }
   if ( blend != ctx->Color.BlendEnabled )
   {	
	blend = ctx->Color.BlendEnabled;
	
	DPF(( 0, "\tBlending\t%s", (blend) ? "ENABLED" : "--------" ));
   }

   /*================================================*/
   /* Check too see if there are new TEXTURE states. */
   /*================================================*/
   if ( texture != ctx->Texture._ReallyEnabled )
   {
	texture = ctx->Texture._ReallyEnabled;
	DPF(( 0, "\tTexture\t\t%s", (texture) ? "ENABLED" : "--------" ));
   }	

   if ( ctx->Texture.Set[ctx->Texture.CurrentSet].Current )
   {
	if ( ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Name != textName )
	{
	  textName = ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Name;
	  DPF(( 0, "\tTexture Name:\t%d", textName ));
	  DPF(( 0, "\tTexture Format:\t%s",
		   (ctx->Texture.Set[ctx->Texture.CurrentSet].Current->Image[0]->Format == GL_RGBA) ?
		   "GL_RGBA" : "GLRGB" ));
	}

	if ( textEnv != ctx->Texture.Set[ctx->Texture.CurrentSet].EnvMode )
	{
	  textEnv = ctx->Texture.Set[ctx->Texture.CurrentSet].EnvMode;

	  switch( textEnv )
	  {
       case GL_MODULATE:
	    DPF(( 0, "\tTexture\tMode\tGL_MODULATE" ));
	    break;
       case GL_BLEND:
	    DPF(( 0, "\tTexture\tMode\tGL_BLEND" ));
	    break;
       case GL_REPLACE:
	    DPF(( 0, "\tTexture\tMode\tGL_REPLACE" ));
	    break;
       case GL_DECAL:
	    DPF(( 0, "\tTexture\tMode\tGL_DECAL" ));
	    break;
	  }
	}

	if ( textMag != ctx->Texture.Set[ctx->Texture.CurrentSet].Current->MagFilter )
	{
	  textMag = ctx->Texture.Set[ctx->Texture.CurrentSet].Current->MagFilter;
	
	  switch( textMag )
	  {
       case GL_NEAREST:
	    DPF(( 0, "\tTexture MAG\tGL_NEAREST" ));
	    break;
       case GL_LINEAR:
	    DPF(( 0, "\tTexture MAG\tGL_LINEAR" ));
	    break;
       case GL_NEAREST_MIPMAP_NEAREST:
	    DPF(( 0, "\tTexture MAG\tGL_NEAREST_MIPMAP_NEAREST" ));
	    break;
       case GL_LINEAR_MIPMAP_NEAREST:
	    DPF(( 0, "\tTexture MAG\tGL_LINEAR_MIPMAP_NEAREST" ));
	    break;
       case GL_NEAREST_MIPMAP_LINEAR:
	    DPF(( 0, "\tTexture MAG\tGL_NEAREST_MIPMAP_LINEAR" ));
	    break;
       case GL_LINEAR_MIPMAP_LINEAR:
	    DPF(( 0, "\tTexture MAG\tGL_LINEAR_MIPMAP_LINEAR" ));
	    break;
	  }
	}

	if ( textMin != ctx->Texture.Set[ctx->Texture.CurrentSet].Current->MinFilter )
	{
	  textMin = ctx->Texture.Set[ctx->Texture.CurrentSet].Current->MinFilter;

	  switch( textMin )
	  {
       case GL_NEAREST:
	    DPF(( 0, "\tTexture MIN\tGL_NEAREST" ));
	    break;
       case GL_LINEAR:
	    DPF(( 0, "\tTexture MIN\tGL_LINEAR" ));
	    break;
       case GL_NEAREST_MIPMAP_NEAREST:
	    DPF(( 0, "\tTexture MIN\tGL_NEAREST_MIPMAP_NEAREST" ));
	    break;
       case GL_LINEAR_MIPMAP_NEAREST:
	    DPF(( 0, "\tTexture MIN\tGL_LINEAR_MIPMAP_NEAREST" ));
	    break;
       case GL_NEAREST_MIPMAP_LINEAR:
	    DPF(( 0, "\tTexture MIN\tGL_LINEAR_MIPMAP_LINEAR" ));
	    break;
       case GL_LINEAR_MIPMAP_LINEAR:
	    DPF(( 0, "\tTexture MIN\tGL_LINEAR_MIPMAP_LINEAR" ));
	    break;
	  }
	}	
   }

   if ( ctx->Polygon.FrontMode != polyMode )
   {
	polyMode = ctx->Polygon.FrontMode;

	switch( polyMode )
	{
       case GL_POINT:
	    DPF(( 0, "\tMode\t\tGL_POINT" ));
	    break;
       case GL_LINE:
	    DPF(( 0, "\tMode\t\tGL_LINE" ));
	    break;
       case GL_FILL:
	    DPF(( 0, "\tMode\t\tGL_FILL" ));
	    break;
	}
   }

   if ( depthFunc != ctx->Depth.Func )
   {
	depthFunc = ctx->Depth.Func;

	switch( depthFunc )
	{
       case GL_NEVER:
	    DPF(( 0, "\tDepth Func\tGL_NEVER" ));
	    break;
       case GL_LESS:
	    DPF(( 0, "\tDepth Func\tGL_LESS" ));
	    break;
       case GL_GEQUAL:
	    DPF(( 0, "\tDepth Func\tGL_GEQUAL" ));
	    break;
       case GL_LEQUAL:
	    DPF(( 0, "\tDepth Func\tGL_LEQUAL" ));
	    break;
       case GL_GREATER:
	    DPF(( 0, "\tDepth Func\tGL_GREATER" ));
	    break;
       case GL_NOTEQUAL:
 	    DPF(( 0, "\tDepth Func\tGL_NOTEQUAL" ));
	    break;
       case GL_EQUAL:
	    DPF(( 0, "\tDepth Func\tGL_EQUAL" ));
	    break;
       case GL_ALWAYS:
	    DPF(( 0, "\tDepth Func\tGL_ALWAYS" ));
	    break;
	}
   }	

   if ( depthMask != ctx->Depth.Mask )
   {
	depthMask = ctx->Depth.Mask;
	DPF(( 0, "\tZWrite\t\t%s", (depthMask) ? "ENABLED" : "--------" ));
   }

   if ( alphaFunc != ctx->Color.AlphaFunc )
   {
	alphaFunc = ctx->Color.AlphaFunc;

	switch( alphaFunc )
     {
	  case GL_NEVER:
	    DPF(( 0, "\tAlpha Func\tGL_NEVER" ));
	    break;
	  case GL_LESS:
	    DPF(( 0, "\tAlpha Func\tGL_LESS" ));
	    break;
  	  case GL_GEQUAL:
	    DPF(( 0, "\tAlpha Func\tGL_GEQUAL" ));
	    break;
  	  case GL_LEQUAL:
	    DPF(( 0, "\tAlpha Func\tGL_LEQUAL" ));
	    break;
	  case GL_GREATER:
	    DPF(( 0, "\tAlpha Func\tGL_GREATER" ));
	    break;
	  case GL_NOTEQUAL:
	    DPF(( 0, "\tAlpha Func\tGL_NOTEQUAL" ));
	    break;
	  case GL_EQUAL:
	    DPF(( 0, "\tAlpha Func\tGL_EQUAL" ));
	    break;
	  case GL_ALWAYS:
	    DPF(( 0, "\tAlpha Func\tGL_ALWAYS" ));
	    break;
	}
   }

   if ( blendSrc != ctx->Color.BlendSrc )
   {
	blendSrc = ctx->Color.BlendSrc;

	switch( blendSrc )
	{
	  case GL_ZERO:	    			
	    DPF(( 0, "\tSRC Blend\tGL_ZERO" ));
	    break;
       case GL_ONE:
	    DPF(( 0, "\tSRC Blend\tGL_ONE" ));
	    break;
       case GL_DST_COLOR:
	    DPF(( 0, "\tSRC Blend\tGL_DST_COLOR" ));
	    break;
       case GL_ONE_MINUS_DST_COLOR:
	    DPF(( 0, "\tSRC Blend\tGL_ONE_MINUS_DST_COLOR" ));
	    break;
       case GL_SRC_ALPHA:
	    DPF(( 0, "\tSRC Blend\tGL_SRC_ALPHA" ));
	    break;
       case GL_ONE_MINUS_SRC_ALPHA:
	    DPF(( 0, "\tSRC Blend\tGL_MINUS_SRC_ALPHA" ));
	    break;
       case GL_DST_ALPHA:
	    DPF(( 0, "\tSRC Blend\tGL_DST_ALPHA" ));
	    break;
       case GL_ONE_MINUS_DST_ALPHA:
	    DPF(( 0, "\tSRC Blend\tGL_ONE_MINUS_DST_ALPHA" ));
	    break;
       case GL_SRC_ALPHA_SATURATE:
	    DPF(( 0, "\tSRC Blend\tGL_SRC_ALPHA_SATURATE" ));
	    break;
       case GL_CONSTANT_COLOR:
	    DPF(( 0, "\tSRC Blend\tGL_CONSTANT_COLOR" ));
	    break;
       case GL_ONE_MINUS_CONSTANT_COLOR:
	    DPF(( 0, "\tSRC Blend\tGL_ONE_MINUS_CONSTANT_COLOR" ));
	    break;
       case GL_CONSTANT_ALPHA:
	    DPF(( 0, "\tSRC Blend\tGL_CONSTANT_ALPHA" ));
	    break;
       case GL_ONE_MINUS_CONSTANT_ALPHA:
	    DPF(( 0, "\tSRC Blend\tGL_ONE_MINUS_CONSTANT_ALPHA" ));
	    break;
	}
   }

   if ( blendDest != ctx->Color.BlendDst )
   {
	blendDest = ctx->Color.BlendDst;

	switch( blendDest )
	{
       case GL_ZERO:                  	
	    DPF(( 0, "\tDST Blend\tGL_ZERO" ));
	    break;
       case GL_ONE:
	    DPF(( 0, "\tDST Blend\tGL_ONE" ));
	    break;
       case GL_SRC_COLOR:
	    DPF(( 0, "\tDST Blend\tGL_SRC_COLOR" ));
	    break;
       case GL_ONE_MINUS_SRC_COLOR:
	    DPF(( 0, "\tDST Blend\tGL_ONE_MINUS_SRC_COLOR" ));
	    break;
       case GL_SRC_ALPHA:
	    DPF(( 0, "\tDST Blend\tGL_SRC_ALPHA" ));
	    break;
       case GL_ONE_MINUS_SRC_ALPHA:
	    DPF(( 0, "\tDST Blend\tGL_ONE_MINUS_SRC_ALPHA" ));
	    break;
       case GL_DST_ALPHA:
	    DPF(( 0, "\tDST Blend\tGL_DST_ALPHA" ));
	    break;
       case GL_ONE_MINUS_DST_ALPHA:
	    DPF(( 0, "\tDST Blend\tGL_ONE_MINUS_DST_ALPHA" ));
	    break;
       case GL_CONSTANT_COLOR:
	    DPF(( 0, "\tDST Blend\tGL_CONSTANT_COLOR" ));
	    break;
       case GL_ONE_MINUS_CONSTANT_COLOR:
	    DPF(( 0, "\tDST Blend\tGL_ONE_MINUS_CONSTANT_COLOR" ));
	    break;
       case GL_CONSTANT_ALPHA:
	    DPF(( 0, "\tDST Blend\tGL_CONSTANT_ALPHA" ));
	    break;
       case GL_ONE_MINUS_CONSTANT_ALPHA:
	    DPF(( 0, "\tDST Blend\tGL_ONE_MINUS_CONSTANT_ALPHA" ));
	    break;
	}
   }	
}