/*
 * Copyright 2001 by Alan Hourihane.
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Alan Hourihane not be used in
 * advertising or publicity pertaining to distribution of the software without
 * specific, written prior permission.  Alan Hourihane makes no representations
 * about the suitability of this software for any purpose.  It is provided
 * "as is" without express or implied warranty.
 *
 * ALAN HOURIHANE DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
 * EVENT SHALL ALAN HOURIHANE BE LIABLE FOR ANY SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THIS SOFTWARE.
 *
 * Authors:  Alan Hourihane, <alanh@tungstengraphics.com>
 *           Keith Whitwell, <keith@tungstengraphics.com>
 *
 * 3DLabs Gamma driver.
 */

#include "gamma_context.h"
#include "gamma_vb.h"
#include "gamma_tris.h"

#include "glheader.h"
#include "mtypes.h"
#include "macros.h"
#include "colormac.h"

#include "swrast/swrast.h"
#include "swrast_setup/swrast_setup.h"
#include "tnl/tnl.h"
#include "tnl/t_context.h"
#include "tnl/t_pipeline.h"


/***********************************************************************
 *                   Build hardware rasterization functions            *
 ***********************************************************************/

#define GAMMA_RAST_ALPHA_BIT	0x01
#define GAMMA_RAST_TEX_BIT	0x02
#define GAMMA_RAST_FLAT_BIT	0x04

static gamma_point_func gamma_point_tab[0x8];
static gamma_line_func gamma_line_tab[0x8];
static gamma_tri_func gamma_tri_tab[0x8];
static gamma_quad_func gamma_quad_tab[0x8];

#define IND (0)
#define TAG(x) x
#include "gamma_tritmp.h"

#define IND (GAMMA_RAST_ALPHA_BIT)
#define TAG(x) x##_alpha
#include "gamma_tritmp.h"

#define IND (GAMMA_RAST_TEX_BIT)
#define TAG(x) x##_tex
#include "gamma_tritmp.h"

#define IND (GAMMA_RAST_ALPHA_BIT|GAMMA_RAST_TEX_BIT)
#define TAG(x) x##_alpha_tex
#include "gamma_tritmp.h"

#define IND (GAMMA_RAST_FLAT_BIT)
#define TAG(x) x##_flat
#include "gamma_tritmp.h"

#define IND (GAMMA_RAST_ALPHA_BIT|GAMMA_RAST_FLAT_BIT)
#define TAG(x) x##_alpha_flat
#include "gamma_tritmp.h"

#define IND (GAMMA_RAST_TEX_BIT|GAMMA_RAST_FLAT_BIT)
#define TAG(x) x##_tex_flat
#include "gamma_tritmp.h"

#define IND (GAMMA_RAST_ALPHA_BIT|GAMMA_RAST_TEX_BIT|GAMMA_RAST_FLAT_BIT)
#define TAG(x) x##_alpha_tex_flat
#include "gamma_tritmp.h"


static void init_rast_tab( void )
{
   gamma_init();
   gamma_init_alpha();
   gamma_init_tex();
   gamma_init_alpha_tex();
   gamma_init_flat();
   gamma_init_alpha_flat();
   gamma_init_tex_flat();
   gamma_init_alpha_tex_flat();
}

/***********************************************************************
 *                    Rasterization fallback helpers                   *
 ***********************************************************************/


/* This code is hit only when a mix of accelerated and unaccelerated
 * primitives are being drawn, and only for the unaccelerated
 * primitives.  
 */
static void 
gamma_fallback_quad( gammaContextPtr gmesa, 
		    const gammaVertex *v0, 
		    const gammaVertex *v1, 
		    const gammaVertex *v2, 
		    const gammaVertex *v3 )
{
   GLcontext *ctx = gmesa->glCtx;
   SWvertex v[4];
   gamma_translate_vertex( ctx, v0, &v[0] );
   gamma_translate_vertex( ctx, v1, &v[1] );
   gamma_translate_vertex( ctx, v2, &v[2] );
   gamma_translate_vertex( ctx, v3, &v[3] );
   _swrast_Quad( ctx, &v[0], &v[1], &v[2], &v[3] );
}

static void 
gamma_fallback_tri( gammaContextPtr gmesa, 
		    const gammaVertex *v0, 
		    const gammaVertex *v1, 
		    const gammaVertex *v2 )
{
   GLcontext *ctx = gmesa->glCtx;
   SWvertex v[3];
   gamma_translate_vertex( ctx, v0, &v[0] );
   gamma_translate_vertex( ctx, v1, &v[1] );
   gamma_translate_vertex( ctx, v2, &v[2] );
   _swrast_Triangle( ctx, &v[0], &v[1], &v[2] );
}

static void 
gamma_fallback_line( gammaContextPtr gmesa,
		     const gammaVertex *v0,
		     const gammaVertex *v1 )
{
   GLcontext *ctx = gmesa->glCtx;
   SWvertex v[2];
   gamma_translate_vertex( ctx, v0, &v[0] );
   gamma_translate_vertex( ctx, v1, &v[1] );
   _swrast_Line( ctx, &v[0], &v[1] );
}


#if 0
static void 
gamma_fallback_point( gammaContextPtr gmesa, 
		      const gammaVertex *v0 )
{
   GLcontext *ctx = gmesa->glCtx;
   SWvertex v[1];
   gamma_translate_vertex( ctx, v0, &v[0] );
   _swrast_Point( ctx, &v[0] );
}
#endif


/***********************************************************************
 *                    Choose rasterization functions                   *
 ***********************************************************************/

#define _GAMMA_NEW_RASTER_STATE (_NEW_FOG | \
				 _NEW_TEXTURE | \
				 _DD_NEW_TRI_SMOOTH | \
				 _DD_NEW_LINE_SMOOTH | \
				 _DD_NEW_POINT_SMOOTH | \
				 _DD_NEW_TRI_STIPPLE | \
				 _DD_NEW_LINE_STIPPLE)

#define LINE_FALLBACK (0)
#define TRI_FALLBACK (0)

static void gammaChooseRasterState(GLcontext *ctx)
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   GLuint flags = ctx->_TriangleCaps;
   GLuint ind = 0;

   if ( ctx->Line.SmoothFlag || 
        ctx->Polygon.SmoothFlag || 
        ctx->Point.SmoothFlag )
      gmesa->Begin |= B_AntiAliasEnable;
   else
      gmesa->Begin &= ~B_AntiAliasEnable;

   if ( ctx->Texture.Unit[0]._ReallyEnabled ) {
      ind |= GAMMA_RAST_TEX_BIT;
      gmesa->Begin |= B_TextureEnable;
   } else
      gmesa->Begin &= ~B_TextureEnable;

   if (flags & DD_LINE_STIPPLE)
      gmesa->Begin |= B_LineStippleEnable;
   else
      gmesa->Begin &= ~B_LineStippleEnable;
   
   if (flags & DD_TRI_STIPPLE)
      gmesa->Begin |= B_AreaStippleEnable;
   else
      gmesa->Begin &= ~B_AreaStippleEnable;

   if (ctx->Fog.Enabled) 
      gmesa->Begin |= B_FogEnable;
   else
      gmesa->Begin &= ~B_FogEnable;

   if (ctx->Color.BlendEnabled || ctx->Color.AlphaEnabled)
      ind |= GAMMA_RAST_ALPHA_BIT;

   if ( flags & DD_FLATSHADE )
      ind |= GAMMA_RAST_FLAT_BIT;

   gmesa->draw_line = gamma_line_tab[ind];
   gmesa->draw_tri = gamma_tri_tab[ind];
   gmesa->draw_quad = gamma_quad_tab[ind];
   gmesa->draw_point = gamma_point_tab[ind];

   /* Hook in fallbacks for specific primitives.  CURRENTLY DISABLED
    */
   if (flags & LINE_FALLBACK) 
      gmesa->draw_line = gamma_fallback_line;
	 
   if (flags & TRI_FALLBACK) {
      gmesa->draw_tri = gamma_fallback_tri;
      gmesa->draw_quad = gamma_fallback_quad;
   }
}


/***********************************************************************
 *          Macros for t_dd_tritmp.h to draw basic primitives          *
 ***********************************************************************/

#define TRI( a, b, c )				\
do {						\
   gmesa->draw_tri( gmesa, a, b, c );	\
} while (0)

#define QUAD( a, b, c, d )			\
do {						\
   gmesa->draw_quad( gmesa, a, b, c, d );	\
} while (0)

#define LINE( v0, v1 )				\
do {						\
   gmesa->draw_line( gmesa, v0, v1 );	\
} while (0)

#define POINT( v0 )				\
do {						\
   gmesa->draw_point( gmesa, v0 );		\
} while (0)


/***********************************************************************
 *              Build render functions from dd templates               *
 ***********************************************************************/

#define GAMMA_OFFSET_BIT 	0x01
#define GAMMA_TWOSIDE_BIT	0x02
#define GAMMA_UNFILLED_BIT	0x04
#define GAMMA_FALLBACK_BIT	0x08
#define GAMMA_MAX_TRIFUNC	0x10


static struct {
   tnl_points_func		points;
   tnl_line_func		line;
   tnl_triangle_func	triangle;
   tnl_quad_func		quad;
} rast_tab[GAMMA_MAX_TRIFUNC];


#define DO_FALLBACK (IND & GAMMA_FALLBACK_BIT)
#define DO_OFFSET    0 /* (IND & GAMMA_OFFSET_BIT) */
#define DO_UNFILLED  0 /* (IND & GAMMA_UNFILLED_BIT) */
#define DO_TWOSIDE  (IND & GAMMA_TWOSIDE_BIT)
#define DO_FLAT      0
#define DO_TRI       1
#define DO_QUAD      1
#define DO_LINE      1
#define DO_POINTS    1
#define DO_FULL_QUAD 1

#define HAVE_RGBA         1
#define HAVE_SPEC         0
#define HAVE_BACK_COLORS  0
#define HAVE_HW_FLATSHADE 1
#define VERTEX            gammaVertex
#define TAB               rast_tab

#define DEPTH_SCALE 1.0
#define UNFILLED_TRI unfilled_tri
#define UNFILLED_QUAD unfilled_quad
#define VERT_X(_v) _v->v.x
#define VERT_Y(_v) _v->v.y
#define VERT_Z(_v) _v->v.z
#define AREA_IS_CCW( a ) (a > 0)
#define GET_VERTEX(e) (gmesa->verts + (e * gmesa->vertex_size * sizeof(int)))

#define VERT_SET_RGBA( v, c )  					\
do {								\
   UNCLAMPED_FLOAT_TO_UBYTE(v->ub4[4][0], (c)[0]);		\
   UNCLAMPED_FLOAT_TO_UBYTE(v->ub4[4][1], (c)[1]);		\
   UNCLAMPED_FLOAT_TO_UBYTE(v->ub4[4][2], (c)[2]);		\
   UNCLAMPED_FLOAT_TO_UBYTE(v->ub4[4][3], (c)[3]);		\
} while (0)
#define VERT_COPY_RGBA( v0, v1 ) v0->ui[4] = v1->ui[4]
#define VERT_SAVE_RGBA( idx )    color[idx] = v[idx]->ui[4]
#define VERT_RESTORE_RGBA( idx ) v[idx]->ui[4] = color[idx]   

#define LOCAL_VARS(n)					\
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);	\
   GLuint color[n];				\
   (void) color;


/***********************************************************************
 *                Helpers for rendering unfilled primitives            *
 ***********************************************************************/

static const GLuint hw_prim[GL_POLYGON+1] = {
   B_PrimType_Points,
   B_PrimType_Lines,
   B_PrimType_Lines,
   B_PrimType_Lines,
   B_PrimType_Triangles,
   B_PrimType_Triangles,
   B_PrimType_Triangles,
   B_PrimType_Triangles,
   B_PrimType_Triangles,
   B_PrimType_Triangles
};

static void gammaResetLineStipple( GLcontext *ctx );
static void gammaRasterPrimitive( GLcontext *ctx, GLuint hwprim );
static void gammaRenderPrimitive( GLcontext *ctx, GLenum prim );

#define RASTERIZE(x) if (gmesa->hw_primitive != hw_prim[x]) \
                        gammaRasterPrimitive( ctx, hw_prim[x] )
#define RENDER_PRIMITIVE gmesa->render_primitive
#define TAG(x) x
#define IND GAMMA_FALLBACK_BIT
#include "tnl_dd/t_dd_unfilled.h"
#undef IND

/***********************************************************************
 *                      Generate GL render functions                   *
 ***********************************************************************/

#define IND (0)
#define TAG(x) x
#include "tnl_dd/t_dd_tritmp.h"

#define IND (GAMMA_OFFSET_BIT)
#define TAG(x) x##_offset
#include "tnl_dd/t_dd_tritmp.h"

#define IND (GAMMA_TWOSIDE_BIT)
#define TAG(x) x##_twoside
#include "tnl_dd/t_dd_tritmp.h"

#define IND (GAMMA_TWOSIDE_BIT|GAMMA_OFFSET_BIT)
#define TAG(x) x##_twoside_offset
#include "tnl_dd/t_dd_tritmp.h"

#define IND (GAMMA_UNFILLED_BIT)
#define TAG(x) x##_unfilled
#include "tnl_dd/t_dd_tritmp.h"

#define IND (GAMMA_OFFSET_BIT|GAMMA_UNFILLED_BIT)
#define TAG(x) x##_offset_unfilled
#include "tnl_dd/t_dd_tritmp.h"

#define IND (GAMMA_TWOSIDE_BIT|GAMMA_UNFILLED_BIT)
#define TAG(x) x##_twoside_unfilled
#include "tnl_dd/t_dd_tritmp.h"

#define IND (GAMMA_TWOSIDE_BIT|GAMMA_OFFSET_BIT|GAMMA_UNFILLED_BIT)
#define TAG(x) x##_twoside_offset_unfilled
#include "tnl_dd/t_dd_tritmp.h"


static void init_render_tab( void )
{
   init();
   init_offset();
   init_twoside();
   init_twoside_offset();
   init_unfilled();
   init_offset_unfilled();
   init_twoside_unfilled();
   init_twoside_offset_unfilled();
}


/**********************************************************************/
/*               Render unclipped begin/end objects                   */
/**********************************************************************/

#define VERT(x) (gammaVertex *)(gammaverts + (x * size * sizeof(int)))
#define RENDER_POINTS( start, count )		\
   for ( ; start < count ; start++) 		\
      gmesa->draw_point( gmesa, VERT(start) )
#define RENDER_LINE( v0, v1 ) \
   gmesa->draw_line( gmesa, VERT(v0), VERT(v1) )
#define RENDER_TRI( v0, v1, v2 )  \
   gmesa->draw_tri( gmesa, VERT(v0), VERT(v1), VERT(v2) )
#define RENDER_QUAD( v0, v1, v2, v3 ) \
   gmesa->draw_quad( gmesa, VERT(v0), VERT(v1), VERT(v2), VERT(v3) )
#define INIT(x) gammaRenderPrimitive( ctx, x );
#undef LOCAL_VARS
#define LOCAL_VARS						\
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);		\
   const GLuint size = gmesa->vertex_size;		\
   const char *gammaverts = (char *)gmesa->verts;		\
   const GLboolean stipple = ctx->Line.StippleFlag;		\
   (void) stipple;
#define RESET_STIPPLE	if ( stipple ) gammaResetLineStipple( ctx );
#define RESET_OCCLUSION
#define PRESERVE_VB_DEFS
#define ELT(x) (x)
#define TAG(x) gamma_##x##_verts
#include "tnl/t_vb_rendertmp.h"


/**********************************************************************/
/*                   Render clipped primitives                        */
/**********************************************************************/

static void gammaRenderClippedPoly( GLcontext *ctx, const GLuint *elts, 
				   GLuint n )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   struct vertex_buffer *VB = &TNL_CONTEXT(ctx)->vb;
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   GLuint prim = gmesa->render_primitive;

   /* Render the new vertices as an unclipped polygon. 
    */
   {
      GLuint *tmp = VB->Elts;
      VB->Elts = (GLuint *)elts;
      tnl->Driver.Render.PrimTabElts[GL_POLYGON]( ctx, 0, n, PRIM_BEGIN|PRIM_END );
      VB->Elts = tmp;
   }

   /* Restore the render primitive
    */
   if (prim != GL_POLYGON)
      tnl->Driver.Render.PrimitiveNotify( ctx, prim );
}

static void gammaRenderClippedLine( GLcontext *ctx, GLuint ii, GLuint jj )
{
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   tnl->Driver.Render.Line( ctx, ii, jj );
}


/**********************************************************************/
/*                    Choose render functions                         */
/**********************************************************************/


#define _GAMMA_NEW_RENDERSTATE (_DD_NEW_TRI_UNFILLED |		\
			       _DD_NEW_TRI_LIGHT_TWOSIDE |	\
			       _DD_NEW_TRI_OFFSET)

#define ANY_RASTER_FLAGS (DD_TRI_LIGHT_TWOSIDE|DD_TRI_OFFSET|DD_TRI_UNFILLED)

static void gammaChooseRenderState(GLcontext *ctx)
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   GLuint flags = ctx->_TriangleCaps;
   GLuint index = 0;

   if (flags & ANY_RASTER_FLAGS) {
      if (flags & DD_TRI_LIGHT_TWOSIDE)       index |= GAMMA_TWOSIDE_BIT;
      if (flags & DD_TRI_OFFSET)	      index |= GAMMA_OFFSET_BIT;
      if (flags & DD_TRI_UNFILLED)	      index |= GAMMA_UNFILLED_BIT;
   }

   if (gmesa->RenderIndex != index) {
      gmesa->RenderIndex = index;

      tnl->Driver.Render.Points = rast_tab[index].points;
      tnl->Driver.Render.Line = rast_tab[index].line;
      tnl->Driver.Render.Triangle = rast_tab[index].triangle;
      tnl->Driver.Render.Quad = rast_tab[index].quad;
         
      if (gmesa->RenderIndex == 0)
         tnl->Driver.Render.PrimTabVerts = gamma_render_tab_verts;
      else
         tnl->Driver.Render.PrimTabVerts = _tnl_render_tab_verts;
      tnl->Driver.Render.PrimTabElts = _tnl_render_tab_elts;
      tnl->Driver.Render.ClippedLine = gammaRenderClippedLine;
      tnl->Driver.Render.ClippedPolygon = gammaRenderClippedPoly;
   }
}


/**********************************************************************/
/*                 High level hooks for t_vb_render.c                 */
/**********************************************************************/


/* Determine the rasterized primitive when not drawing unfilled 
 * polygons.
 *
 * Used only for the default render stage which always decomposes
 * primitives to trianges/lines/points.  For the accelerated stage,
 * which renders strips as strips, the equivalent calculations are
 * performed in gammarender.c.
 */

static void gammaRasterPrimitive( GLcontext *ctx, GLuint hwprim )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   if (gmesa->hw_primitive != hwprim)
      gmesa->hw_primitive = hwprim;
}

static void gammaRenderPrimitive( GLcontext *ctx, GLenum prim )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   gmesa->render_primitive = prim;
}

static void gammaRunPipeline( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   if ( gmesa->new_state )
      gammaDDUpdateHWState( ctx );

   if (gmesa->new_gl_state) {
      if (gmesa->new_gl_state & _NEW_TEXTURE)
	 gammaUpdateTextureState( ctx );

   if (!gmesa->Fallback) {
      if (gmesa->new_gl_state & _GAMMA_NEW_VERTEX)
	 gammaChooseVertexState( ctx );
      
      if (gmesa->new_gl_state & _GAMMA_NEW_RASTER_STATE)
	 gammaChooseRasterState( ctx );
      
      if (gmesa->new_gl_state & _GAMMA_NEW_RENDERSTATE)
	 gammaChooseRenderState( ctx );
   }
      
      gmesa->new_gl_state = 0;
   }

   _tnl_run_pipeline( ctx );
}

static void gammaRenderStart( GLcontext *ctx )
{
   /* Check for projective texturing.  Make sure all texcoord
    * pointers point to something.  (fix in mesa?)  
    */
   gammaCheckTexSizes( ctx );
}

static void gammaRenderFinish( GLcontext *ctx )
{
   if (0)
      _swrast_flush( ctx );	/* never needed */
}

static void gammaResetLineStipple( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);

   /* Reset the hardware stipple counter.
    */
   CHECK_DMA_BUFFER(gmesa, 1);
   WRITE(gmesa->buf, UpdateLineStippleCounters, 0);
}


/**********************************************************************/
/*           Transition to/from hardware rasterization.               */
/**********************************************************************/


void gammaFallback( gammaContextPtr gmesa, GLuint bit, GLboolean mode )
{
   GLcontext *ctx = gmesa->glCtx;
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   GLuint oldfallback = gmesa->Fallback;

   if (mode) {
      gmesa->Fallback |= bit;
      if (oldfallback == 0) {
	 _swsetup_Wakeup( ctx );
	 _tnl_need_projected_coords( ctx, GL_TRUE );
	 gmesa->RenderIndex = ~0;
      }
   }
   else {
      gmesa->Fallback &= ~bit;
      if (oldfallback == bit) {
	 _swrast_flush( ctx );
	 tnl->Driver.Render.Start = gammaRenderStart;
	 tnl->Driver.Render.PrimitiveNotify = gammaRenderPrimitive;
	 tnl->Driver.Render.Finish = gammaRenderFinish;
	 tnl->Driver.Render.BuildVertices = gammaBuildVertices;
         tnl->Driver.Render.ResetLineStipple = gammaResetLineStipple;
	 gmesa->new_gl_state |= (_GAMMA_NEW_RENDERSTATE|
				 _GAMMA_NEW_RASTER_STATE|
				 _GAMMA_NEW_VERTEX);
      }
   }
}


/**********************************************************************/
/*                            Initialization.                         */
/**********************************************************************/


void gammaDDInitTriFuncs( GLcontext *ctx )
{
   gammaContextPtr gmesa = GAMMA_CONTEXT(ctx);
   TNLcontext *tnl = TNL_CONTEXT(ctx);
   static int firsttime = 1;

   if (firsttime) {
      init_rast_tab();
      init_render_tab();
      firsttime = 0;
   }
   
   gmesa->RenderIndex = ~0;

   tnl->Driver.RunPipeline = gammaRunPipeline;
   tnl->Driver.Render.Start = gammaRenderStart;
   tnl->Driver.Render.Finish = gammaRenderFinish; 
   tnl->Driver.Render.PrimitiveNotify = gammaRenderPrimitive;
   tnl->Driver.Render.ResetLineStipple = gammaResetLineStipple;
   tnl->Driver.Render.BuildVertices = gammaBuildVertices;
}