static void
feedback_tri( struct draw_stage *stage, struct prim_header *prim )
{
struct feedback_stage *fs = feedback_stage(stage);
struct draw_context *draw = stage->draw;
FEEDBACK_TOKEN(fs->ctx, (GLfloat) GL_POLYGON_TOKEN);
FEEDBACK_TOKEN(fs->ctx, (GLfloat) 3); /* three vertices */
feedback_vertex(fs->ctx, draw, prim->v[0]);
feedback_vertex(fs->ctx, draw, prim->v[1]);
feedback_vertex(fs->ctx, draw, prim->v[2]);
}
void
_mesa_PassThrough( GLfloat token )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx, "glPassThrough");
if (ctx->RenderMode==GL_FEEDBACK) {
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_PASS_THROUGH_TOKEN );
FEEDBACK_TOKEN( ctx, token );
}
}
void gl_PassThrough( GLcontext *ctx, GLfloat token )
{
if (INSIDE_BEGIN_END(ctx)) {
gl_error( ctx, GL_INVALID_OPERATION, "glPassThrough" );
return;
}
if (ctx->RenderMode==GL_FEEDBACK) {
FEEDBACK_TOKEN( ctx, (GLfloat) GL_PASS_THROUGH_TOKEN );
FEEDBACK_TOKEN( ctx, token );
}
}
void GLAPIENTRY
_mesa_PassThrough( GLfloat token )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (ctx->RenderMode==GL_FEEDBACK) {
FLUSH_VERTICES(ctx, 0);
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_PASS_THROUGH_TOKEN );
FEEDBACK_TOKEN( ctx, token );
}
}
/*
* Put triangle in feedback buffer.
*/
void gl_feedback_triangle( GLcontext *ctx,
GLuint v0, GLuint v1, GLuint v2, GLuint pv )
{
if (gl_cull_triangle( ctx, v0, v1, v2, 0 )) {
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POLYGON_TOKEN );
FEEDBACK_TOKEN( ctx, (GLfloat) 3 ); /* three vertices */
feedback_vertex( ctx, v0, pv );
feedback_vertex( ctx, v1, pv );
feedback_vertex( ctx, v2, pv );
}
}
static void
feedback_line( struct draw_stage *stage, struct prim_header *prim )
{
struct feedback_stage *fs = feedback_stage(stage);
struct draw_context *draw = stage->draw;
if (fs->reset_stipple_counter) {
FEEDBACK_TOKEN(fs->ctx, (GLfloat) GL_LINE_RESET_TOKEN);
fs->reset_stipple_counter = GL_FALSE;
}
else {
FEEDBACK_TOKEN(fs->ctx, (GLfloat) GL_LINE_TOKEN);
}
feedback_vertex(fs->ctx, draw, prim->v[0]);
feedback_vertex(fs->ctx, draw, prim->v[1]);
}
/*
* Execute glDrawPixels
*/
void GLAPIENTRY
_mesa_DrawPixels( GLsizei width, GLsizei height,
GLenum format, GLenum type, const GLvoid *pixels )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (width < 0 || height < 0) {
_mesa_error( ctx, GL_INVALID_VALUE, "glDrawPixels(width or height < 0" );
return;
}
if (ctx->NewState) {
_mesa_update_state(ctx);
}
if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glDrawPixels (invalid fragment program)");
return;
}
if (error_check_format_type(ctx, format, type, GL_TRUE)) {
/* found an error */
return;
}
if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
_mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
"glDrawPixels(incomplete framebuffer)" );
return;
}
if (!ctx->Current.RasterPosValid) {
return;
}
if (ctx->RenderMode == GL_RENDER) {
/* Round, to satisfy conformance tests (matches SGI's OpenGL) */
GLint x = IROUND(ctx->Current.RasterPos[0]);
GLint y = IROUND(ctx->Current.RasterPos[1]);
ctx->Driver.DrawPixels(ctx, x, y, width, height, format, type,
&ctx->Unpack, pixels);
}
else if (ctx->RenderMode == GL_FEEDBACK) {
/* Feedback the current raster pos info */
FLUSH_CURRENT( ctx, 0 );
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
_mesa_feedback_vertex( ctx,
ctx->Current.RasterPos,
ctx->Current.RasterColor,
ctx->Current.RasterIndex,
ctx->Current.RasterTexCoords[0] );
}
else {
ASSERT(ctx->RenderMode == GL_SELECT);
/* Do nothing. See OpenGL Spec, Appendix B, Corollary 6. */
}
}
static void
feedback_point( struct draw_stage *stage, struct prim_header *prim )
{
struct feedback_stage *fs = feedback_stage(stage);
struct draw_context *draw = stage->draw;
FEEDBACK_TOKEN(fs->ctx, (GLfloat) GL_POINT_TOKEN);
feedback_vertex(fs->ctx, draw, prim->v[0]);
}
/*
* Put triangle in feedback buffer.
*/
void
_swrast_feedback_triangle(GLcontext *ctx, const SWvertex *v0,
const SWvertex *v1, const SWvertex *v2)
{
if (_swrast_culltriangle(ctx, v0, v1, v2)) {
FEEDBACK_TOKEN(ctx, (GLfloat) (GLint) GL_POLYGON_TOKEN);
FEEDBACK_TOKEN(ctx, (GLfloat) 3); /* three vertices */
if (ctx->Light.ShadeModel == GL_SMOOTH) {
feedback_vertex(ctx, v0, v0);
feedback_vertex(ctx, v1, v1);
feedback_vertex(ctx, v2, v2);
}
else {
feedback_vertex(ctx, v0, v2);
feedback_vertex(ctx, v1, v2);
feedback_vertex(ctx, v2, v2);
}
}
}
void gl_feedback_points( GLcontext *ctx, GLuint first, GLuint last )
{
const struct vertex_buffer *VB = ctx->VB;
GLuint i;
for (i=first;i<last;i++) {
if (VB->ClipMask[i]==0) {
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_POINT_TOKEN );
feedback_vertex( ctx, i, i );
}
}
}
void
_mesa_Bitmap( GLsizei width, GLsizei height,
GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
const GLubyte *bitmap )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (width < 0 || height < 0) {
_mesa_error( ctx, GL_INVALID_VALUE, "glBitmap(width or height < 0)" );
return;
}
if (ctx->Current.RasterPosValid == GL_FALSE) {
return; /* do nothing */
}
if (ctx->RenderMode==GL_RENDER) {
if (bitmap) {
/* Truncate, to satisfy conformance tests (matches SGI's OpenGL). */
GLint x = IFLOOR(ctx->Current.RasterPos[0] - xorig);
GLint y = IFLOOR(ctx->Current.RasterPos[1] - yorig);
if (ctx->NewState) {
_mesa_update_state(ctx);
}
ctx->OcclusionResult = GL_TRUE;
ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );
}
}
else if (ctx->RenderMode==GL_FEEDBACK) {
if (ctx->Current.RasterPosValid) {
FLUSH_CURRENT(ctx, 0);
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );
_mesa_feedback_vertex( ctx,
ctx->Current.RasterPos,
ctx->Current.RasterColor,
ctx->Current.RasterIndex,
ctx->Current.RasterTexCoord );
}
}
else if (ctx->RenderMode==GL_SELECT) {
/* Bitmaps don't generate selection hits. See appendix B of 1.1 spec. */
}
/* update raster position */
ctx->Current.RasterPos[0] += xmove;
ctx->Current.RasterPos[1] += ymove;
}
void gl_feedback_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv )
{
GLenum token = GL_LINE_TOKEN;
if (ctx->StippleCounter==0)
token = GL_LINE_RESET_TOKEN;
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) token );
feedback_vertex( ctx, v1, pv );
feedback_vertex( ctx, v2, pv );
ctx->StippleCounter++;
}
void
_mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
GLenum type )
{
GET_CURRENT_CONTEXT(ctx);
GLint destx, desty;
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (width < 0 || height < 0) {
_mesa_error( ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)" );
return;
}
if (ctx->NewState) {
_mesa_update_state(ctx);
}
if (ctx->RenderMode==GL_RENDER) {
/* Destination of copy: */
if (!ctx->Current.RasterPosValid) {
return;
}
/* Round, to satisfy conformance tests (matches SGI's OpenGL) */
destx = IROUND(ctx->Current.RasterPos[0]);
desty = IROUND(ctx->Current.RasterPos[1]);
ctx->OcclusionResult = GL_TRUE;
ctx->Driver.CopyPixels( ctx, srcx, srcy, width, height, destx, desty,
type );
}
else if (ctx->RenderMode == GL_FEEDBACK) {
if (ctx->Current.RasterPosValid) {
FLUSH_CURRENT(ctx, 0);
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
_mesa_feedback_vertex( ctx,
ctx->Current.RasterPos,
ctx->Current.RasterColor,
ctx->Current.RasterIndex,
ctx->Current.RasterTexCoord );
}
}
else if (ctx->RenderMode == GL_SELECT) {
_mesa_update_hitflag( ctx, ctx->Current.RasterPos[2] );
}
}
/*
* Execute glDrawPixels
*/
void
_mesa_DrawPixels( GLsizei width, GLsizei height,
GLenum format, GLenum type, const GLvoid *pixels )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (width < 0 || height < 0) {
_mesa_error( ctx, GL_INVALID_VALUE, "glDrawPixels(width or height < 0" );
return;
}
if (ctx->RenderMode==GL_RENDER) {
GLint x, y;
if (!pixels || !ctx->Current.RasterPosValid) {
return;
}
if (ctx->NewState) {
_mesa_update_state(ctx);
}
/* Round, to satisfy conformance tests (matches SGI's OpenGL) */
x = IROUND(ctx->Current.RasterPos[0]);
y = IROUND(ctx->Current.RasterPos[1]);
ctx->OcclusionResult = GL_TRUE;
ctx->Driver.DrawPixels(ctx, x, y, width, height, format, type,
&ctx->Unpack, pixels);
}
else if (ctx->RenderMode==GL_FEEDBACK) {
if (ctx->Current.RasterPosValid) {
FLUSH_CURRENT(ctx, 0);
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_DRAW_PIXEL_TOKEN );
_mesa_feedback_vertex( ctx,
ctx->Current.RasterPos,
ctx->Current.RasterColor,
ctx->Current.RasterIndex,
ctx->Current.RasterTexCoord );
}
}
else if (ctx->RenderMode==GL_SELECT) {
if (ctx->Current.RasterPosValid) {
_mesa_update_hitflag( ctx, ctx->Current.RasterPos[2] );
}
}
}
/*
* Put points in feedback buffer.
*/
static void feedback_points( GLcontext *ctx, GLuint first, GLuint last )
{
struct vertex_buffer *VB = ctx->VB;
GLuint i;
GLfloat invRedScale = ctx->Visual->InvRedScale;
GLfloat invGreenScale = ctx->Visual->InvGreenScale;
GLfloat invBlueScale = ctx->Visual->InvBlueScale;
GLfloat invAlphaScale = ctx->Visual->InvAlphaScale;
for (i=first;i<=last;i++) {
if (VB->Unclipped[i]) {
GLfloat x, y, z, w, invq;
GLfloat color[4], texcoord[4];
x = VB->Win[i][0];
y = VB->Win[i][1];
z = VB->Win[i][2] / DEPTH_SCALE;
w = VB->Clip[i][3];
/* convert color from integer back to a float in [0,1] */
if (ctx->Light.ShadeModel==GL_SMOOTH) {
/* smooth shading - colors are in fixed point */
color[0] = FixedToFloat(VB->Color[i][0]) * invRedScale;
color[1] = FixedToFloat(VB->Color[i][1]) * invGreenScale;
color[2] = FixedToFloat(VB->Color[i][2]) * invBlueScale;
color[3] = FixedToFloat(VB->Color[i][3]) * invAlphaScale;
}
else {
/* flat shading - colors are integers */
color[0] = VB->Color[i][0] * invRedScale;
color[1] = VB->Color[i][1] * invGreenScale;
color[2] = VB->Color[i][2] * invBlueScale;
color[3] = VB->Color[i][3] * invAlphaScale;
}
invq = 1.0F / VB->TexCoord[i][3];
texcoord[0] = VB->TexCoord[i][0] * invq;
texcoord[1] = VB->TexCoord[i][1] * invq;
texcoord[2] = VB->TexCoord[i][2] * invq;
texcoord[3] = VB->TexCoord[i][3];
FEEDBACK_TOKEN( ctx, (GLfloat) GL_POINT_TOKEN );
gl_feedback_vertex( ctx, x, y, z, w, color,
(GLfloat) VB->Index[i], texcoord );
}
}
}
void _swrast_feedback_line( GLcontext *ctx, const SWvertex *v0, const SWvertex *v1 )
{
GLenum token = GL_LINE_TOKEN;
SWcontext *swrast = SWRAST_CONTEXT(ctx);
if (swrast->StippleCounter==0)
token = GL_LINE_RESET_TOKEN;
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) token );
if (ctx->Light.ShadeModel == GL_SMOOTH) {
feedback_vertex( ctx, v0, v0 );
feedback_vertex( ctx, v1, v1 );
} else {
feedback_vertex( ctx, v0, v1 );
feedback_vertex( ctx, v1, v1 );
}
swrast->StippleCounter++;
}
void
_swrast_feedback_point(GLcontext *ctx, const SWvertex *v)
{
FEEDBACK_TOKEN(ctx, (GLfloat) (GLint) GL_POINT_TOKEN);
feedback_vertex(ctx, v, v);
}
void GLAPIENTRY
_mesa_Bitmap( GLsizei width, GLsizei height,
GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,
const GLubyte *bitmap )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (width < 0 || height < 0) {
_mesa_error( ctx, GL_INVALID_VALUE, "glBitmap(width or height < 0)" );
return;
}
if (!ctx->Current.RasterPosValid) {
return; /* do nothing */
}
if (ctx->NewState) {
_mesa_update_state(ctx);
}
if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glBitmap (invalid fragment program)");
return;
}
if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
_mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
"glBitmap(incomplete framebuffer)");
return;
}
if (ctx->RenderMode == GL_RENDER) {
if (bitmap) {
/* Truncate, to satisfy conformance tests (matches SGI's OpenGL). */
GLint x = IFLOOR(ctx->Current.RasterPos[0] - xorig);
GLint y = IFLOOR(ctx->Current.RasterPos[1] - yorig);
ctx->Driver.Bitmap( ctx, x, y, width, height, &ctx->Unpack, bitmap );
}
}
#if _HAVE_FULL_GL
else if (ctx->RenderMode == GL_FEEDBACK) {
FLUSH_CURRENT(ctx, 0);
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_BITMAP_TOKEN );
_mesa_feedback_vertex( ctx,
ctx->Current.RasterPos,
ctx->Current.RasterColor,
ctx->Current.RasterIndex,
ctx->Current.RasterTexCoords[0] );
}
else {
ASSERT(ctx->RenderMode == GL_SELECT);
/* Do nothing. See OpenGL Spec, Appendix B, Corollary 6. */
}
#endif
/* update raster position */
ctx->Current.RasterPos[0] += xmove;
ctx->Current.RasterPos[1] += ymove;
}
void GLAPIENTRY
_mesa_CopyPixels( GLint srcx, GLint srcy, GLsizei width, GLsizei height,
GLenum type )
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
if (ctx->NewState) {
_mesa_update_state(ctx);
}
if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glCopyPixels (invalid fragment program)");
return;
}
if (width < 0 || height < 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glCopyPixels(width or height < 0)");
return;
}
if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT ||
ctx->ReadBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
_mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
"glCopyPixels(incomplete framebuffer)" );
return;
}
if (!_mesa_source_buffer_exists(ctx, type) ||
!_mesa_dest_buffer_exists(ctx, type)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glCopyPixels(missing source or dest buffer)");
return;
}
if (!ctx->Current.RasterPosValid) {
return;
}
if (ctx->RenderMode == GL_RENDER) {
/* Round to satisfy conformance tests (matches SGI's OpenGL) */
GLint destx = IROUND(ctx->Current.RasterPos[0]);
GLint desty = IROUND(ctx->Current.RasterPos[1]);
ctx->Driver.CopyPixels( ctx, srcx, srcy, width, height, destx, desty,
type );
}
else if (ctx->RenderMode == GL_FEEDBACK) {
FLUSH_CURRENT( ctx, 0 );
FEEDBACK_TOKEN( ctx, (GLfloat) (GLint) GL_COPY_PIXEL_TOKEN );
_mesa_feedback_vertex( ctx,
ctx->Current.RasterPos,
ctx->Current.RasterColor,
ctx->Current.RasterIndex,
ctx->Current.RasterTexCoords[0] );
}
else {
ASSERT(ctx->RenderMode == GL_SELECT);
/* Do nothing. See OpenGL Spec, Appendix B, Corollary 6. */
}
}
static void feedback_line( GLcontext *ctx, GLuint v1, GLuint v2, GLuint pv )
{
struct vertex_buffer *VB = ctx->VB;
GLfloat x1, y1, z1, w1;
GLfloat x2, y2, z2, w2;
GLfloat tex1[4], tex2[4], invq;
GLfloat invRedScale = ctx->Visual->InvRedScale;
GLfloat invGreenScale = ctx->Visual->InvGreenScale;
GLfloat invBlueScale = ctx->Visual->InvBlueScale;
GLfloat invAlphaScale = ctx->Visual->InvAlphaScale;
x1 = VB->Win[v1][0];
y1 = VB->Win[v1][1];
z1 = VB->Win[v1][2] / DEPTH_SCALE;
w1 = VB->Clip[v1][3];
x2 = VB->Win[v2][0];
y2 = VB->Win[v2][1];
z2 = VB->Win[v2][2] / DEPTH_SCALE;
w2 = VB->Clip[v2][3];
invq = 1.0F / VB->TexCoord[v1][3];
tex1[0] = VB->TexCoord[v1][0] * invq;
tex1[1] = VB->TexCoord[v1][1] * invq;
tex1[2] = VB->TexCoord[v1][2] * invq;
tex1[3] = VB->TexCoord[v1][3];
invq = 1.0F / VB->TexCoord[v2][3];
tex2[0] = VB->TexCoord[v2][0] * invq;
tex2[1] = VB->TexCoord[v2][1] * invq;
tex2[2] = VB->TexCoord[v2][2] * invq;
tex2[3] = VB->TexCoord[v2][3];
if (ctx->StippleCounter==0) {
FEEDBACK_TOKEN( ctx, (GLfloat) GL_LINE_RESET_TOKEN );
}
else {
FEEDBACK_TOKEN( ctx, (GLfloat) GL_LINE_TOKEN );
}
if (ctx->Light.ShadeModel==GL_FLAT) {
GLfloat color[4];
/* convert color from integer to a float in [0,1] */
color[0] = (GLfloat) VB->Color[pv][0] * invRedScale;
color[1] = (GLfloat) VB->Color[pv][1] * invGreenScale;
color[2] = (GLfloat) VB->Color[pv][2] * invBlueScale;
color[3] = (GLfloat) VB->Color[pv][3] * invAlphaScale;
gl_feedback_vertex( ctx, x1,y1,z1,w1, color,
(GLfloat) VB->Index[pv], tex1 );
gl_feedback_vertex( ctx, x2,y2,z2,w2, color,
(GLfloat) VB->Index[pv], tex2 );
}
else {
GLfloat color[4];
/* convert color from fixed point to a float in [0,1] */
color[0] = FixedToFloat(VB->Color[v1][0]) * invRedScale;
color[1] = FixedToFloat(VB->Color[v1][1]) * invGreenScale;
color[2] = FixedToFloat(VB->Color[v1][2]) * invBlueScale;
color[3] = FixedToFloat(VB->Color[v1][3]) * invAlphaScale;
gl_feedback_vertex( ctx, x1,y1,z1,w1, color,
(GLfloat) VB->Index[v1], tex1 );
/* convert color from fixed point to a float in [0,1] */
color[0] = FixedToFloat(VB->Color[v2][0]) * invRedScale;
color[1] = FixedToFloat(VB->Color[v2][1]) * invGreenScale;
color[2] = FixedToFloat(VB->Color[v2][2]) * invBlueScale;
color[3] = FixedToFloat(VB->Color[v2][3]) * invAlphaScale;
gl_feedback_vertex( ctx, x2,y2,z2,w2, color,
(GLfloat) VB->Index[v2], tex2 );
}
ctx->StippleCounter++;
}
/*
* Put a vertex into the feedback buffer.
*/
void _mesa_feedback_vertex( GLcontext *ctx,
const GLfloat win[4],
const GLfloat color[4],
GLfloat index,
const GLfloat texcoord[4] )
{
#if 0
{
/* snap window x, y to fractional pixel position */
const GLint snapMask = ~((FIXED_ONE / (1 << SUB_PIXEL_BITS)) - 1);
GLfixed x, y;
x = FloatToFixed(win[0]) & snapMask;
y = FloatToFixed(win[1]) & snapMask;
FEEDBACK_TOKEN(ctx, FixedToFloat(x));
FEEDBACK_TOKEN(ctx, FixedToFloat(y) );
}
#else
FEEDBACK_TOKEN( ctx, win[0] );
FEEDBACK_TOKEN( ctx, win[1] );
#endif
if (ctx->Feedback._Mask & FB_3D) {
FEEDBACK_TOKEN( ctx, win[2] );
}
if (ctx->Feedback._Mask & FB_4D) {
FEEDBACK_TOKEN( ctx, win[3] );
}
if (ctx->Feedback._Mask & FB_INDEX) {
FEEDBACK_TOKEN( ctx, (GLfloat) index );
}
if (ctx->Feedback._Mask & FB_COLOR) {
FEEDBACK_TOKEN( ctx, color[0] );
FEEDBACK_TOKEN( ctx, color[1] );
FEEDBACK_TOKEN( ctx, color[2] );
FEEDBACK_TOKEN( ctx, color[3] );
}
if (ctx->Feedback._Mask & FB_TEXTURE) {
FEEDBACK_TOKEN( ctx, texcoord[0] );
FEEDBACK_TOKEN( ctx, texcoord[1] );
FEEDBACK_TOKEN( ctx, texcoord[2] );
FEEDBACK_TOKEN( ctx, texcoord[3] );
}
}
/*
* Put a vertex into the feedback buffer.
*/
void gl_feedback_vertex( GLcontext *ctx,
const GLfloat win[4],
const GLfloat color[4],
GLuint index,
const GLfloat texcoord[4] )
{
FEEDBACK_TOKEN( ctx, win[0] );
FEEDBACK_TOKEN( ctx, win[1] );
if (ctx->Feedback.Mask & FB_3D) {
FEEDBACK_TOKEN( ctx, win[2] );
}
if (ctx->Feedback.Mask & FB_4D) {
FEEDBACK_TOKEN( ctx, win[3] );
}
if (ctx->Feedback.Mask & FB_INDEX) {
FEEDBACK_TOKEN( ctx, (GLfloat) index );
}
if (ctx->Feedback.Mask & FB_COLOR) {
FEEDBACK_TOKEN( ctx, color[0] );
FEEDBACK_TOKEN( ctx, color[1] );
FEEDBACK_TOKEN( ctx, color[2] );
FEEDBACK_TOKEN( ctx, color[3] );
}
if (ctx->Feedback.Mask & FB_TEXTURE) {
FEEDBACK_TOKEN( ctx, texcoord[0] );
FEEDBACK_TOKEN( ctx, texcoord[1] );
FEEDBACK_TOKEN( ctx, texcoord[2] );
FEEDBACK_TOKEN( ctx, texcoord[3] );
}
}
/*
* Put a vertex into the feedback buffer.
*/
void gl_feedback_vertex( GLcontext *ctx,
GLfloat x, GLfloat y, GLfloat z, GLfloat w,
const GLfloat color[4], GLfloat index,
const GLfloat texcoord[4] )
{
FEEDBACK_TOKEN( ctx, x );
FEEDBACK_TOKEN( ctx, y );
if (ctx->Feedback.Mask & FB_3D) {
FEEDBACK_TOKEN( ctx, z );
}
if (ctx->Feedback.Mask & FB_4D) {
FEEDBACK_TOKEN( ctx, w );
}
if (ctx->Feedback.Mask & FB_INDEX) {
FEEDBACK_TOKEN( ctx, index );
}
if (ctx->Feedback.Mask & FB_COLOR) {
FEEDBACK_TOKEN( ctx, color[0] );
FEEDBACK_TOKEN( ctx, color[1] );
FEEDBACK_TOKEN( ctx, color[2] );
FEEDBACK_TOKEN( ctx, color[3] );
}
if (ctx->Feedback.Mask & FB_TEXTURE) {
FEEDBACK_TOKEN( ctx, texcoord[0] );
FEEDBACK_TOKEN( ctx, texcoord[1] );
FEEDBACK_TOKEN( ctx, texcoord[2] );
FEEDBACK_TOKEN( ctx, texcoord[3] );
}
}
