vbfill.h File Reference

#include "types.h"

Include dependency graph for vbfill.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	gl_Normal3f (GLcontext *ctx, GLfloat nx, GLfloat ny, GLfloat nz)
void	gl_Normal3fv (GLcontext *ctx, const GLfloat *normal)
void	gl_Indexf (GLcontext *ctx, GLfloat c)
void	gl_Indexi (GLcontext *ctx, GLint c)
void	gl_Color3f (GLcontext *ctx, GLfloat red, GLfloat green, GLfloat blue)
void	gl_Color3fv (GLcontext *ctx, const GLfloat *c)
void	gl_Color4f (GLcontext *ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void	gl_Color4fv (GLcontext *ctx, const GLfloat *c)
void	gl_Color4ub (GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
void	gl_Color4ub8bit (GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
void	gl_Color4ubv (GLcontext *ctx, const GLubyte *c)
void	gl_Color4ubv8bit (GLcontext *ctx, const GLubyte *c)
void	gl_ColorMat3f (GLcontext *ctx, GLfloat red, GLfloat green, GLfloat blue)
void	gl_ColorMat3fv (GLcontext *ctx, const GLfloat *c)
void	gl_ColorMat3ub (GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue)
void	gl_ColorMat4f (GLcontext *ctx, GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
void	gl_ColorMat4fv (GLcontext *ctx, const GLfloat *c)
void	gl_ColorMat4ub (GLcontext *ctx, GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
void	gl_TexCoord2f (GLcontext *ctx, GLfloat s, GLfloat t)
void	gl_TexCoord4f (GLcontext *ctx, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
void	gl_EdgeFlag (GLcontext *ctx, GLboolean flag)
void	gl_vertex2f_nop (GLcontext *ctx, GLfloat x, GLfloat y)
void	gl_vertex3f_nop (GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z)
void	gl_vertex4f_nop (GLcontext *ctx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
void	gl_vertex3fv_nop (GLcontext *ctx, const GLfloat *v)
void	gl_set_vertex_function (GLcontext *ctx)
void	gl_set_color_function (GLcontext *ctx)
void	gl_eval_vertex (GLcontext *ctx, const GLfloat vertex[4], const GLfloat normal[3], const GLubyte color[4], GLuint index, const GLfloat texcoord[4])
void	gl_Begin (GLcontext *ctx, GLenum p)
void	gl_End (GLcontext *ctx)

Function Documentation

gl_Begin()

void gl_Begin	(	GLcontext *	ctx,
		GLenum	p
	)

Definition at line 1341 of file vbfill.c.

{
   struct vertex_buffer *VB = ctx->VB;
   struct pixel_buffer *PB = ctx->PB;
#ifdef PROFILE
   begin_time = gl_time();
#endif
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glBegin" );
      return;
   }
   if (ctx->NewModelViewMatrix) {
      gl_analyze_modelview_matrix(ctx);
   }
   if (ctx->NewProjectionMatrix) {
      gl_analyze_projection_matrix(ctx);
   }
   if (ctx->NewState) {
      gl_update_state(ctx);
   }
   else if (ctx->Exec.Vertex3f==gl_vertex3f_nop) {
      gl_set_vertex_function(ctx);
   }
 
   if (ctx->Driver.Begin) {
      (*ctx->Driver.Begin)( ctx, p );
   }
 
   ctx->Primitive = p;
   VB->Start = VB->Count = 0;
 
   VB->MonoColor = ctx->MonoPixels;
   VB->MonoNormal = GL_TRUE;
   if (VB->MonoColor) {
      /* All pixels generated are likely to be the same color so have
       * the device driver set the "monocolor" now.
       */
      if (ctx->Visual->RGBAflag) {
         GLubyte r = ctx->Current.ByteColor[0];
         GLubyte g = ctx->Current.ByteColor[1];
         GLubyte b = ctx->Current.ByteColor[2];
         GLubyte a = ctx->Current.ByteColor[3];
         (*ctx->Driver.Color)( ctx, r, g, b, a );
      }
      else {
         (*ctx->Driver.Index)( ctx, ctx->Current.Index );
      }
   }
 
   /* By default use front color/index.  Two-sided lighting may override. */
   VB->Color = VB->Fcolor;
   VB->Index = VB->Findex;
 
   switch (ctx->Primitive) {
      case GL_POINTS:
     ctx->LightTwoSide = GL_FALSE;
     PB_INIT( PB, GL_POINT );
     break;
      case GL_LINES:
      case GL_LINE_STRIP:
      case GL_LINE_LOOP:
     ctx->LightTwoSide = GL_FALSE;
     ctx->StippleCounter = 0;
     PB_INIT( PB, GL_LINE );
         break;
      case GL_TRIANGLES:
      case GL_TRIANGLE_STRIP:
      case GL_TRIANGLE_FAN:
      case GL_QUADS:
      case GL_QUAD_STRIP:
      case GL_POLYGON:
     ctx->LightTwoSide = ctx->Light.Enabled && ctx->Light.Model.TwoSide;
     PB_INIT( PB, GL_POLYGON );
         break;
      default:
     gl_error( ctx, GL_INVALID_ENUM, "glBegin" );
     ctx->Primitive = GL_BITMAP;
   }
}

Referenced by execute_list(), gl_DrawArrays(), gl_DrawElements(), gl_EvalMesh1(), gl_EvalMesh2(), gl_Rectf(), and init_exec_pointers().

gl_Color3f()

void gl_Color3f	(	GLcontext *	ctx,
		GLfloat	red,
		GLfloat	green,
		GLfloat	blue
	)

Definition at line 216 of file vbfill.c.

{
   ctx->Current.ByteColor[0] = FloatToInt(CLAMP(red  , 0.0F, 1.0F) * ctx->Visual->RedScale);
   ctx->Current.ByteColor[1] = FloatToInt(CLAMP(green, 0.0F, 1.0F) * ctx->Visual->GreenScale);
   ctx->Current.ByteColor[2] = FloatToInt(CLAMP(blue , 0.0F, 1.0F) * ctx->Visual->BlueScale);
   ctx->Current.ByteColor[3] = FloatToInt(ctx->Visual->AlphaScale);
   ASSERT( !ctx->Light.ColorMaterialEnabled );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function(), and init_exec_pointers().

gl_Color3fv()

void gl_Color3fv	(	GLcontext *	ctx,
		const GLfloat *	c
	)

Definition at line 246 of file vbfill.c.

{
   ctx->Current.ByteColor[0] = FloatToInt(CLAMP(c[0], 0.0F, 1.0F) * ctx->Visual->RedScale);
   ctx->Current.ByteColor[1] = FloatToInt(CLAMP(c[1], 0.0F, 1.0F) * ctx->Visual->GreenScale);
   ctx->Current.ByteColor[2] = FloatToInt(CLAMP(c[2], 0.0F, 1.0F) * ctx->Visual->BlueScale);
   ctx->Current.ByteColor[3] = FloatToInt(ctx->Visual->AlphaScale);
   ASSERT( !ctx->Light.ColorMaterialEnabled );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function(), and init_exec_pointers().

gl_Color4f()

void gl_Color4f	(	GLcontext *	ctx,
		GLfloat	red,
		GLfloat	green,
		GLfloat	blue,
		GLfloat	alpha
	)

Definition at line 277 of file vbfill.c.

{
   ctx->Current.ByteColor[0] = FloatToInt(CLAMP(red  , 0.0F, 1.0F) * ctx->Visual->RedScale);
   ctx->Current.ByteColor[1] = FloatToInt(CLAMP(green, 0.0F, 1.0F) * ctx->Visual->GreenScale);
   ctx->Current.ByteColor[2] = FloatToInt(CLAMP(blue , 0.0F, 1.0F) * ctx->Visual->BlueScale);
   ctx->Current.ByteColor[3] = FloatToInt(CLAMP(alpha, 0.0F, 1.0F) * ctx->Visual->AlphaScale);
   ASSERT( !ctx->Light.ColorMaterialEnabled );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function(), and init_exec_pointers().

gl_Color4fv()

void gl_Color4fv	(	GLcontext *	ctx,
		const GLfloat *	c
	)

Definition at line 309 of file vbfill.c.

{
   ctx->Current.ByteColor[0] = FloatToInt(CLAMP(c[0], 0.0F, 1.0F) * ctx->Visual->RedScale);
   ctx->Current.ByteColor[1] = FloatToInt(CLAMP(c[1], 0.0F, 1.0F) * ctx->Visual->GreenScale);
   ctx->Current.ByteColor[2] = FloatToInt(CLAMP(c[2], 0.0F, 1.0F) * ctx->Visual->BlueScale);
   ctx->Current.ByteColor[3] = FloatToInt(CLAMP(c[3], 0.0F, 1.0F) * ctx->Visual->AlphaScale);
   ASSERT( !ctx->Light.ColorMaterialEnabled );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function(), and init_exec_pointers().

gl_Color4ub()

void gl_Color4ub	(	GLcontext *	ctx,
		GLubyte	red,
		GLubyte	green,
		GLubyte	blue,
		GLubyte	alpha
	)

Definition at line 339 of file vbfill.c.

{
   ctx->Current.ByteColor[0] = red   * ctx->Visual->RedScale   * (1.0F/255.0F);
   ctx->Current.ByteColor[1] = green * ctx->Visual->GreenScale * (1.0F/255.0F);
   ctx->Current.ByteColor[2] = blue  * ctx->Visual->BlueScale  * (1.0F/255.0F);
   ctx->Current.ByteColor[3] = alpha * ctx->Visual->AlphaScale * (1.0F/255.0F);
   ASSERT( !ctx->Light.ColorMaterialEnabled );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function(), and init_exec_pointers().

gl_Color4ub8bit()

void gl_Color4ub8bit	(	GLcontext *	ctx,
		GLubyte	red,
		GLubyte	green,
		GLubyte	blue,
		GLubyte	alpha
	)

Definition at line 355 of file vbfill.c.

{
   ASSIGN_4V( ctx->Current.ByteColor, red, green, blue, alpha );
   ASSERT( !ctx->Light.ColorMaterialEnabled );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function().

gl_Color4ubv()

void gl_Color4ubv	(	GLcontext *	ctx,
		const GLubyte *	c
	)

Definition at line 368 of file vbfill.c.

{
   ctx->Current.ByteColor[0] = c[0] * ctx->Visual->RedScale   * (1.0F/255.0F);
   ctx->Current.ByteColor[1] = c[1] * ctx->Visual->GreenScale * (1.0F/255.0F);
   ctx->Current.ByteColor[2] = c[2] * ctx->Visual->BlueScale  * (1.0F/255.0F);
   ctx->Current.ByteColor[3] = c[3] * ctx->Visual->AlphaScale * (1.0F/255.0F);
   ASSERT( !ctx->Light.ColorMaterialEnabled );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function(), and init_exec_pointers().

gl_Color4ubv8bit()

void gl_Color4ubv8bit	(	GLcontext *	ctx,
		const GLubyte *	c
	)

Definition at line 384 of file vbfill.c.

{
   COPY_4UBV( ctx->Current.ByteColor, c );
   ASSERT( !ctx->Light.ColorMaterialEnabled );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function().

gl_ColorMat3f()

void gl_ColorMat3f	(	GLcontext *	ctx,
		GLfloat	red,
		GLfloat	green,
		GLfloat	blue
	)

Definition at line 396 of file vbfill.c.

{
   GLfloat color[4];
   ctx->Current.ByteColor[0] = FloatToInt(CLAMP(red  , 0.0F, 1.0F) * ctx->Visual->RedScale);
   ctx->Current.ByteColor[1] = FloatToInt(CLAMP(green, 0.0F, 1.0F) * ctx->Visual->GreenScale);
   ctx->Current.ByteColor[2] = FloatToInt(CLAMP(blue , 0.0F, 1.0F) * ctx->Visual->BlueScale);
   ctx->Current.ByteColor[3] = FloatToInt(ctx->Visual->AlphaScale);
   /* update material */
   ASSERT( ctx->Light.ColorMaterialEnabled );
   ASSIGN_4V( color, red, green, blue, 1.0F );
   gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function().

gl_ColorMat3fv()

void gl_ColorMat3fv	(	GLcontext *	ctx,
		const GLfloat *	c
	)

Definition at line 415 of file vbfill.c.

{
   GLfloat color[4];
   ctx->Current.ByteColor[0] = FloatToInt(CLAMP(c[0], 0.0F, 1.0F) * ctx->Visual->RedScale);
   ctx->Current.ByteColor[1] = FloatToInt(CLAMP(c[1], 0.0F, 1.0F) * ctx->Visual->GreenScale);
   ctx->Current.ByteColor[2] = FloatToInt(CLAMP(c[2], 0.0F, 1.0F) * ctx->Visual->BlueScale);
   ctx->Current.ByteColor[3] = FloatToInt(ctx->Visual->AlphaScale);
   /* update material */
   ASSERT( ctx->Light.ColorMaterialEnabled );
   ASSIGN_4V( color, c[0], c[1], c[2], 1.0F );
   gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function().

gl_ColorMat3ub()

void gl_ColorMat3ub	(	GLcontext *	ctx,
		GLubyte	red,
		GLubyte	green,
		GLubyte	blue
	)

gl_ColorMat4f()

void gl_ColorMat4f	(	GLcontext *	ctx,
		GLfloat	red,
		GLfloat	green,
		GLfloat	blue,
		GLfloat	alpha
	)

Definition at line 434 of file vbfill.c.

{
   GLfloat color[4];
   ctx->Current.ByteColor[0] = FloatToInt(CLAMP(red  , 0.0F, 1.0F) * ctx->Visual->RedScale);
   ctx->Current.ByteColor[1] = FloatToInt(CLAMP(green, 0.0F, 1.0F) * ctx->Visual->GreenScale);
   ctx->Current.ByteColor[2] = FloatToInt(CLAMP(blue , 0.0F, 1.0F) * ctx->Visual->BlueScale);
   ctx->Current.ByteColor[3] = FloatToInt(CLAMP(alpha, 0.0F, 1.0F) * ctx->Visual->AlphaScale);
   /* update material */
   ASSERT( ctx->Light.ColorMaterialEnabled );
   ASSIGN_4V( color, red, green, blue, alpha );
   gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function().

gl_ColorMat4fv()

void gl_ColorMat4fv	(	GLcontext *	ctx,
		const GLfloat *	c
	)

Definition at line 454 of file vbfill.c.

{
   GLfloat color[4];
   ctx->Current.ByteColor[0] = FloatToInt(CLAMP(c[0], 0.0F, 1.0F) * ctx->Visual->RedScale);
   ctx->Current.ByteColor[1] = FloatToInt(CLAMP(c[1], 0.0F, 1.0F) * ctx->Visual->GreenScale);
   ctx->Current.ByteColor[2] = FloatToInt(CLAMP(c[2], 0.0F, 1.0F) * ctx->Visual->BlueScale);
   ctx->Current.ByteColor[3] = FloatToInt(CLAMP(c[3], 0.0F, 1.0F) * ctx->Visual->AlphaScale);
   /* update material */
   ASSERT( ctx->Light.ColorMaterialEnabled );
   ASSIGN_4V( color, c[0], c[1], c[2], c[3] );
   gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_set_color_function().

gl_ColorMat4ub()

void gl_ColorMat4ub	(	GLcontext *	ctx,
		GLubyte	red,
		GLubyte	green,
		GLubyte	blue,
		GLubyte	alpha
	)

Definition at line 473 of file vbfill.c.

{
   GLfloat color[4];
   if (ctx->Visual->EightBitColor) {
      ASSIGN_4V( ctx->Current.ByteColor, red, green, blue, alpha );
   }
   else {
      ctx->Current.ByteColor[0] = red   * ctx->Visual->RedScale   * (1.0F/255.0F);
      ctx->Current.ByteColor[1] = green * ctx->Visual->GreenScale * (1.0F/255.0F);
      ctx->Current.ByteColor[2] = blue  * ctx->Visual->BlueScale  * (1.0F/255.0F);
      ctx->Current.ByteColor[3] = alpha * ctx->Visual->AlphaScale * (1.0F/255.0F);
   }
   /* update material */
   ASSERT( ctx->Light.ColorMaterialEnabled );
   color[0] = red   * (1.0F/255.0F);
   color[1] = green * (1.0F/255.0F);
   color[2] = blue  * (1.0F/255.0F);
   color[3] = alpha * (1.0F/255.0F);
   gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by gl_ColorMat4ubv(), and gl_set_color_function().

gl_EdgeFlag()

void gl_EdgeFlag	(	GLcontext *	ctx,
		GLboolean	flag
	)

Definition at line 515 of file vbfill.c.

{
   ctx->Current.EdgeFlag = flag;
}

Referenced by init_exec_pointers().

gl_End()

void gl_End

(

GLcontext *

ctx

)

Definition at line 1424 of file vbfill.c.

{
   struct pixel_buffer *PB = ctx->PB;
   struct vertex_buffer *VB = ctx->VB;
 
   if (ctx->Primitive==GL_BITMAP) {
      /* glEnd without glBegin */
      gl_error( ctx, GL_INVALID_OPERATION, "glEnd" );
      return;
   }
 
   if (VB->Count > VB->Start) {
      gl_transform_vb_part1( ctx, GL_TRUE );
   }
   if (PB->count>0) {
      gl_flush_pb(ctx);
   }
 
   if (ctx->Driver.End) {
      (*ctx->Driver.End)(ctx);
   }
 
   PB->primitive = ctx->Primitive = GL_BITMAP;  /* Default mode */
 
#ifdef PROFILE
   ctx->BeginEndTime += gl_time() - begin_time;
   ctx->BeginEndCount++;
#endif
}

Referenced by execute_list(), gl_DrawArrays(), gl_DrawElements(), gl_EvalMesh1(), gl_EvalMesh2(), gl_Rectf(), and init_exec_pointers().

gl_eval_vertex()

void gl_eval_vertex	(	GLcontext *	ctx,
		const GLfloat	vertex[4],
		const GLfloat	normal[3],
		const GLubyte	color[4],
		GLuint	index,
		const GLfloat	texcoord[4]
	)

Definition at line 1290 of file vbfill.c.

{
   struct vertex_buffer *VB = ctx->VB;
   GLuint count = VB->Count;  /* copy to local var to encourage optimization */
 
   VB->VertexSizeMask = VERTEX4_BIT;
   VB->MonoNormal = GL_FALSE;
   COPY_4V( VB->Obj[count], vertex );
   COPY_3V( VB->Normal[count], normal );
   COPY_4UBV( VB->Fcolor[count], color );
   
#ifdef GL_VERSION_1_1
   if (ctx->Light.ColorMaterialEnabled
       && (ctx->Eval.Map1Color4 || ctx->Eval.Map2Color4)) {
      GLfloat fcolor[4];
      fcolor[0] = color[0] * ctx->Visual->InvRedScale;
      fcolor[1] = color[1] * ctx->Visual->InvGreenScale;
      fcolor[2] = color[2] * ctx->Visual->InvBlueScale;
      fcolor[3] = color[3] * ctx->Visual->InvAlphaScale;
      gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, fcolor );
   }
#endif
   VB->Findex[count] = index;
   COPY_4V( VB->TexCoord[count], texcoord );
   VB->Edgeflag[count] = ctx->Current.EdgeFlag;
 
   count++;
   VB->Count = count;
   if (count==VB_MAX) {
      gl_transform_vb_part1( ctx, GL_FALSE );
   }
}

Referenced by gl_EvalCoord1f(), and gl_EvalCoord2f().

gl_Indexf()

void gl_Indexf	(	GLcontext *	ctx,
		GLfloat	c
	)

Definition at line 159 of file vbfill.c.

{
   ctx->Current.Index = (GLuint) (GLint) c;
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by init_exec_pointers().

gl_Indexi()

void gl_Indexi	(	GLcontext *	ctx,
		GLint	c
	)

Definition at line 169 of file vbfill.c.

{
   ctx->Current.Index = (GLuint) c;
   ctx->VB->MonoColor = GL_FALSE;
}

Referenced by init_exec_pointers().

gl_Normal3f()

void gl_Normal3f	(	GLcontext *	ctx,
		GLfloat	nx,
		GLfloat	ny,
		GLfloat	nz
	)

Definition at line 130 of file vbfill.c.

{
   ctx->Current.Normal[0] = nx;
   ctx->Current.Normal[1] = ny;
   ctx->Current.Normal[2] = nz;
   ctx->VB->MonoNormal = GL_FALSE;
}

Referenced by init_exec_pointers().

gl_Normal3fv()

void gl_Normal3fv	(	GLcontext *	ctx,
		const GLfloat *	normal
	)

Definition at line 142 of file vbfill.c.

{
   ctx->Current.Normal[0] = n[0];
   ctx->Current.Normal[1] = n[1];
   ctx->Current.Normal[2] = n[2];
   ctx->VB->MonoNormal = GL_FALSE;
}

Referenced by init_exec_pointers().

gl_set_color_function()

void gl_set_color_function

(

GLcontext *

ctx

)

Definition at line 1236 of file vbfill.c.

{
   ASSERT( !INSIDE_BEGIN_END(ctx) );
 
   if (ctx->Light.ColorMaterialEnabled) {
      ctx->Exec.Color3f = gl_ColorMat3f;
      ctx->Exec.Color3fv = gl_ColorMat3fv;
      ctx->Exec.Color4f = gl_ColorMat4f;
      ctx->Exec.Color4fv = gl_ColorMat4fv;
      ctx->Exec.Color4ub = gl_ColorMat4ub;
      ctx->Exec.Color4ubv = gl_ColorMat4ubv;
   }
   else if (ctx->Visual->EightBitColor) {
      ctx->Exec.Color3f = gl_Color3f8bit;
      ctx->Exec.Color3fv = gl_Color3fv8bit;
      ctx->Exec.Color4f = gl_Color4f8bit;
      ctx->Exec.Color4fv = gl_Color4fv8bit;
      ctx->Exec.Color4ub = gl_Color4ub8bit;
      ctx->Exec.Color4ubv = gl_Color4ubv8bit;
   }
   else {
      ctx->Exec.Color3f = gl_Color3f;
      ctx->Exec.Color3fv = gl_Color3fv;
      ctx->Exec.Color4f = gl_Color4f;
      ctx->Exec.Color4fv = gl_Color4fv;
      ctx->Exec.Color4ub = gl_Color4ub;
      ctx->Exec.Color4ubv = gl_Color4ubv;
   }
   if (!ctx->CompileFlag) {
      ctx->API.Color3f = ctx->Exec.Color3f;
      ctx->API.Color3fv = ctx->Exec.Color3fv;
      ctx->API.Color4f = ctx->Exec.Color4f;
      ctx->API.Color4fv = ctx->Exec.Color4fv;
      ctx->API.Color4ub = ctx->Exec.Color4ub;
      ctx->API.Color4ubv = ctx->Exec.Color4ubv;
   }
}

Referenced by gl_enable(), and gl_update_state().

gl_set_vertex_function()

void gl_set_vertex_function

(

GLcontext *

ctx

)

Definition at line 1154 of file vbfill.c.

{
   if (ctx->RenderMode==GL_FEEDBACK) {
      ctx->Exec.Vertex4f = vertex4f_feedback;
      ctx->Exec.Vertex3f = vertex3f_feedback;
      ctx->Exec.Vertex2f = vertex2f_feedback;
      ctx->Exec.Vertex3fv = vertex3fv_feedback;
   }
   else {
      ctx->Exec.Vertex4f = vertex4;
      if (ctx->Visual->RGBAflag) {
         if (ctx->NeedNormals) {
            /* lighting enabled, need normal vectors */
            if (ctx->Texture.Enabled) {
               if (ctx->VB->TexCoordSize==2) {
                  ctx->Exec.Vertex2f = vertex2f_normal_color_tex2;
                  ctx->Exec.Vertex3f = vertex3f_normal_color_tex2;
                  ctx->Exec.Vertex3fv = vertex3fv_normal_color_tex2;
               }
               else {
                  ctx->Exec.Vertex2f = vertex2f_normal_color_tex4;
                  ctx->Exec.Vertex3f = vertex3f_normal_color_tex4;
                  ctx->Exec.Vertex3fv = vertex3fv_normal_color_tex4;
               }
            }
            else {
               ctx->Exec.Vertex2f = vertex2f_normal;
               ctx->Exec.Vertex3f = vertex3f_normal;
               ctx->Exec.Vertex3fv = vertex3fv_normal;
            }
         }
         else {
            /* not lighting, need vertex color */
            if (ctx->Texture.Enabled) {
               if (ctx->VB->TexCoordSize==2) {
                  ctx->Exec.Vertex2f = vertex2f_color_tex2;
                  ctx->Exec.Vertex3f = vertex3f_color_tex2;
                  ctx->Exec.Vertex3fv = vertex3fv_color_tex2;
               }
               else {
                  ctx->Exec.Vertex2f = vertex2f_color_tex4;
                  ctx->Exec.Vertex3f = vertex3f_color_tex4;
                  ctx->Exec.Vertex3fv = vertex3fv_color_tex4;
               }
            }
            else {
               ctx->Exec.Vertex2f = vertex2f_color;
               ctx->Exec.Vertex3f = vertex3f_color;
               ctx->Exec.Vertex3fv = vertex3fv_color;
            }
         }
      }
      else {
         /* color index mode */
         if (ctx->Light.Enabled) {
            ctx->Exec.Vertex2f = vertex2f_normal;
            ctx->Exec.Vertex3f = vertex3f_normal;
            ctx->Exec.Vertex3fv = vertex3fv_normal;
         }
         else {
            ctx->Exec.Vertex2f = vertex2f_index;
            ctx->Exec.Vertex3f = vertex3f_index;
            ctx->Exec.Vertex3fv = vertex3fv_index;
         }
      }
   }
 
   if (!ctx->CompileFlag) {
      ctx->API.Vertex2f = ctx->Exec.Vertex2f;
      ctx->API.Vertex3f = ctx->Exec.Vertex3f;
      ctx->API.Vertex4f = ctx->Exec.Vertex4f;
      ctx->API.Vertex3fv = ctx->Exec.Vertex3fv;
   }
}

Referenced by execute_list(), gl_Begin(), gl_TexCoord4f(), and gl_update_state().

gl_TexCoord2f()

void gl_TexCoord2f	(	GLcontext *	ctx,
		GLfloat	s,
		GLfloat	t
	)

Definition at line 1109 of file vbfill.c.

{
   ctx->Current.TexCoord[0] = s;
   ctx->Current.TexCoord[1] = t;
}

Referenced by init_exec_pointers().

gl_TexCoord4f()

void gl_TexCoord4f	(	GLcontext *	ctx,
		GLfloat	s,
		GLfloat	t,
		GLfloat	r,
		GLfloat	q
	)

Definition at line 1132 of file vbfill.c.

{
   ctx->Current.TexCoord[0] = s;
   ctx->Current.TexCoord[1] = t;
   ctx->Current.TexCoord[2] = r;
   ctx->Current.TexCoord[3] = q;
   if (ctx->VB->TexCoordSize==2) {
      /* Have to switch to 4-component texture mode now */
      ctx->VB->TexCoordSize = 4;
      gl_set_vertex_function( ctx );
      ctx->Exec.TexCoord2f = ctx->API.TexCoord2f = gl_TexCoord2f4;
   }
}

Referenced by init_exec_pointers().

gl_vertex2f_nop()

void gl_vertex2f_nop	(	GLcontext *	ctx,
		GLfloat	x,
		GLfloat	y
	)

Definition at line 1089 of file vbfill.c.

{
   gl_error( ctx, GL_INVALID_OPERATION, "glVertex2" );
}

Referenced by init_exec_pointers().

gl_vertex3f_nop()

void gl_vertex3f_nop	(	GLcontext *	ctx,
		GLfloat	x,
		GLfloat	y,
		GLfloat	z
	)

Definition at line 1084 of file vbfill.c.

{
   gl_error( ctx, GL_INVALID_OPERATION, "glVertex3" );
}

Referenced by gl_Begin(), and init_exec_pointers().

gl_vertex3fv_nop()

void gl_vertex3fv_nop	(	GLcontext *	ctx,
		const GLfloat *	v
	)

gl_vertex4f_nop()

void gl_vertex4f_nop	(	GLcontext *	ctx,
		GLfloat	x,
		GLfloat	y,
		GLfloat	z,
		GLfloat	w
	)

Definition at line 1078 of file vbfill.c.

{
   gl_error( ctx, GL_INVALID_OPERATION, "glVertex4" );
}

Referenced by init_exec_pointers().