clip.c File Reference

#include <string.h>
#include "clip.h"
#include "context.h"
#include "dlist.h"
#include "macros.h"
#include "matrix.h"
#include "types.h"
#include "vb.h"
#include "xform.h"

Include dependency graph for clip.c:

Go to the source code of this file.

Macros
#define	LINTERP(T, A, B)   ( (A) + (T) * ( (B) - (A) ) )
#define	EYE_SPACE   1
#define	CLIP_SPACE   2
#define	GENERAL_CLIP
#define	X(I)   coord[I][0]
#define	Y(I)   coord[I][1]
#define	Z(I)   coord[I][2]
#define	W(I)   coord[I][3]
#define	OUTSIDE(K)   (X(K) > W(K))
#define	COMPUTE_INTERSECTION(new, in, out)
#define	OUTSIDE(K)   (X(K) < -W(K))
#define	COMPUTE_INTERSECTION(new, in, out)
#define	OUTSIDE(K)   (Y(K) > W(K))
#define	COMPUTE_INTERSECTION(new, in, out)
#define	OUTSIDE(K)   (Y(K) < -W(K))
#define	COMPUTE_INTERSECTION(new, in, out)
#define	OUTSIDE(K)   (Z(K) > W(K))
#define	COMPUTE_INTERSECTION(new, in, out)
#define	OUTSIDE(K)   (Z(K) < -W(K))
#define	COMPUTE_INTERSECTION(new, in, out)
#define	GENERAL_CLIP
#define	X(I)   coord[I][0]
#define	Y(I)   coord[I][1]
#define	Z(I)   coord[I][2]
#define	W(I)   coord[I][3]
#define	INCOUNT   n
#define	OUTCOUNT   n2
#define	INLIST   vlist
#define	OUTLIST   vlist2
#define	INSIDE(K)   (X(K) <= W(K))
#define	COMPUTE_INTERSECTION(in, out, new)
#define	INCOUNT   n2
#define	OUTCOUNT   n
#define	INLIST   vlist2
#define	OUTLIST   vlist
#define	INSIDE(K)   (X(K) >= -W(K))
#define	COMPUTE_INTERSECTION(in, out, new)
#define	INCOUNT   n
#define	OUTCOUNT   n2
#define	INLIST   vlist
#define	OUTLIST   vlist2
#define	INSIDE(K)   (Y(K) <= W(K))
#define	COMPUTE_INTERSECTION(in, out, new)
#define	INCOUNT   n2
#define	OUTCOUNT   n
#define	INLIST   vlist2
#define	OUTLIST   vlist
#define	INSIDE(K)   (Y(K) >= -W(K))
#define	COMPUTE_INTERSECTION(in, out, new)
#define	INCOUNT   n
#define	OUTCOUNT   n2
#define	INLIST   vlist
#define	OUTLIST   vlist2
#define	INSIDE(K)   (Z(K) <= W(K))
#define	COMPUTE_INTERSECTION(in, out, new)
#define	INCOUNT   n2
#define	OUTCOUNT   n
#define	INLIST   vlist2
#define	OUTLIST   vlist
#define	INSIDE(K)   (Z(K) >= -W(K))
#define	COMPUTE_INTERSECTION(in, out, new)
#define	MAGIC_NUMBER   -0.8e-03F
#define	INSIDE(J, A, B, C, D)
#define	OUTSIDE(J, A, B, C, D)

Functions
void	interpolate_aux (GLcontext *ctx, GLuint space, GLuint dst, GLfloat t, GLuint in, GLuint out)
void	interpolate_aux_color_tex2 (GLcontext *ctx, GLuint space, GLuint dst, GLfloat t, GLuint in, GLuint out)
void	interpolate_aux_tex2 (GLcontext *ctx, GLuint space, GLuint dst, GLfloat t, GLuint in, GLuint out)
void	interpolate_aux_color (GLcontext *ctx, GLuint space, GLuint dst, GLfloat t, GLuint in, GLuint out)
void	gl_ClipPlane (GLcontext *ctx, GLenum plane, const GLfloat *equation)
void	gl_GetClipPlane (GLcontext *ctx, GLenum plane, GLdouble *equation)
GLuint	gl_viewclip_point (const GLfloat v[])
GLuint	gl_viewclip_line (GLcontext *ctx, GLuint *i, GLuint *j)
GLuint	gl_viewclip_polygon (GLcontext *ctx, GLuint n, GLuint vlist[])
GLuint	gl_userclip_point (GLcontext *ctx, const GLfloat v[])
GLuint	gl_userclip_line (GLcontext *ctx, GLuint *i, GLuint *j)
GLuint	gl_userclip_polygon (GLcontext *ctx, GLuint n, GLuint vlist[])

Macro Definition Documentation

CLIP_SPACE

#define CLIP_SPACE   2

Definition at line 101 of file clip.c.

COMPUTE_INTERSECTION [1/12]

#define COMPUTE_INTERSECTION	(		in,
			out,
			new
	)

Value:

        dx = X(out) - X(in);                \
        dw = W(out) - W(in);                \
        t = (X(in)-W(in)) / (dw-dx);            \
    neww = W(in) + t * dw;              \
    X(new) = neww;                  \
    Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = neww;

COMPUTE_INTERSECTION [2/12]

#define COMPUTE_INTERSECTION	(		in,
			out,
			new
	)

Value:

        dx = X(out)-X(in);                          \
        dw = W(out)-W(in);                          \
        t = -(X(in)+W(in)) / (dw+dx);               \
    neww = W(in) + t * dw;              \
        X(new) = -neww;                 \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
        Z(new) = Z(in) + t * (Z(out) - Z(in));      \
        W(new) = neww;

COMPUTE_INTERSECTION [3/12]

#define COMPUTE_INTERSECTION	(		in,
			out,
			new
	)

Value:

        dy = Y(out)-Y(in);                          \
        dw = W(out)-W(in);                          \
        t = (Y(in)-W(in)) / (dw-dy);                \
    neww = W(in) + t * dw;              \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = neww;                  \
        Z(new) = Z(in) + t * (Z(out) - Z(in));      \
        W(new) = neww;

COMPUTE_INTERSECTION [4/12]

#define COMPUTE_INTERSECTION	(		in,
			out,
			new
	)

Value:

        dy = Y(out)-Y(in);                          \
        dw = W(out)-W(in);                          \
        t = -(Y(in)+W(in)) / (dw+dy);               \
    neww = W(in) + t * dw;              \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = -neww;                 \
        Z(new) = Z(in) + t * (Z(out) - Z(in));      \
        W(new) = neww;

COMPUTE_INTERSECTION [5/12]

#define COMPUTE_INTERSECTION	(		in,
			out,
			new
	)

Value:

        dz = Z(out)-Z(in);                          \
        dw = W(out)-W(in);                          \
        t = (Z(in)-W(in)) / (dw-dz);                \
    neww = W(in) + t * dw;              \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
        Z(new) = neww;                  \
        W(new) = neww;

COMPUTE_INTERSECTION [6/12]

#define COMPUTE_INTERSECTION	(		in,
			out,
			new
	)

Value:

        dz = Z(out)-Z(in);                          \
        dw = W(out)-W(in);                          \
        t = -(Z(in)+W(in)) / (dw+dz);               \
    neww = W(in) + t * dw;              \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
        Z(new) = -neww;                 \
        W(new) = neww;

COMPUTE_INTERSECTION [7/12]

#define COMPUTE_INTERSECTION	(		new,
			in,
			out
	)

Value:

    dx = X(out) - X(in);                \
    dw = W(out) - W(in);                \
    t = (X(in) - W(in)) / (dw-dx);          \
    X(new) = X(in) + t * dx;            \
    Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = W(in) + t * dw;

COMPUTE_INTERSECTION [8/12]

#define COMPUTE_INTERSECTION	(		new,
			in,
			out
	)

Value:

    dx = X(out) - X(in);                \
    dw = W(out) - W(in);                \
        t = -(X(in) + W(in)) / (dw+dx);         \
    X(new) = X(in) + t * dx;            \
    Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = W(in) + t * dw;

COMPUTE_INTERSECTION [9/12]

#define COMPUTE_INTERSECTION	(		new,
			in,
			out
	)

Value:

    dy = Y(out) - Y(in);                \
    dw = W(out) - W(in);                \
        t = (Y(in) - W(in)) / (dw-dy);          \
    X(new) = X(in) + t * (X(out) - X(in));      \
    Y(new) = Y(in) + t * dy;            \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = W(in) + t * dw;

COMPUTE_INTERSECTION [10/12]

#define COMPUTE_INTERSECTION	(		new,
			in,
			out
	)

Value:

        dy = Y(out) - Y(in);                \
        dw = W(out) - W(in);                \
        t = -(Y(in) + W(in)) / (dw+dy);         \
        X(new) = X(in) + t * (X(out) - X(in));      \
    Y(new) = Y(in) + t * dy;            \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = W(in) + t * dw;

COMPUTE_INTERSECTION [11/12]

#define COMPUTE_INTERSECTION	(		new,
			in,
			out
	)

Value:

        dz = Z(out) - Z(in);                \
        dw = W(out) - W(in);                \
        t = (Z(in) - W(in)) / (dw-dz);          \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * dz;            \
    W(new) = W(in) + t * dw;

COMPUTE_INTERSECTION [12/12]

#define COMPUTE_INTERSECTION	(		new,
			in,
			out
	)

Value:

        dz = Z(out) - Z(in);                \
        dw = W(out) - W(in);                \
        t = -(Z(in) + W(in)) / (dw+dz);         \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * dz;            \
    W(new) = W(in) + t * dw;

EYE_SPACE

#define EYE_SPACE   1

Definition at line 100 of file clip.c.

GENERAL_CLIP [1/2]

#define GENERAL_CLIP

Value:

   if (OUTSIDE(ii)) {                                           \
      if (OUTSIDE(jj)) {                                        \
         /* both verts are outside ==> return 0 */          \
         return 0;                                              \
      }                                                         \
      else {                                                    \
         /* ii is outside, jj is inside ==> clip */             \
     /* new vertex put in position VB->Free */          \
         COMPUTE_INTERSECTION( VB->Free, jj, ii )                   \
     if (ctx->ClipMask)                     \
            ctx->ClipInterpAuxFunc( ctx, CLIP_SPACE, VB->Free, t, jj, ii );\
     ii = VB->Free;                         \
     VB->Free++;                            \
     if (VB->Free==VB_SIZE)  VB->Free = 1;              \
      }                                                         \
   }                                                            \
   else {                                                       \
      if (OUTSIDE(jj)) {                                        \
         /* ii is inside, jj is outside ==> clip */             \
     /* new vertex put in position VB->Free */          \
         COMPUTE_INTERSECTION( VB->Free, ii, jj );                  \
     if (ctx->ClipMask)                     \
        ctx->ClipInterpAuxFunc( ctx, CLIP_SPACE, VB->Free, t, ii, jj );\
     jj = VB->Free;                         \
     VB->Free++;                            \
     if (VB->Free==VB_SIZE)  VB->Free = 1;              \
      }                                                         \
      /* else both verts are inside ==> do nothing */           \
   }

GENERAL_CLIP [2/2]

#define GENERAL_CLIP

INCOUNT [1/6]

#define INCOUNT   n

INCOUNT [2/6]

#define INCOUNT   n2

INCOUNT [3/6]

#define INCOUNT   n

INCOUNT [4/6]

#define INCOUNT   n2

INCOUNT [5/6]

#define INCOUNT   n

INCOUNT [6/6]

#define INCOUNT   n2

INLIST [1/6]

#define INLIST   vlist

INLIST [2/6]

#define INLIST   vlist2

INLIST [3/6]

#define INLIST   vlist

INLIST [4/6]

#define INLIST   vlist2

INLIST [5/6]

#define INLIST   vlist

INLIST [6/6]

#define INLIST   vlist2

INSIDE [1/7]

#define INSIDE	(		J,
			A,
			B,
			C,
			D
	)

Value:

   ( (VB->Eye[J][0] * A + VB->Eye[J][1] * B         \
    + VB->Eye[J][2] * C + VB->Eye[J][3] * D) >= MAGIC_NUMBER )

Definition at line 780 of file clip.c.

INSIDE [2/7]

#define INSIDE

(

K

)

(X(K) <= W(K))

Definition at line 780 of file clip.c.

INSIDE [3/7]

#define INSIDE

(

K

)

(X(K) >= -W(K))

Definition at line 780 of file clip.c.

INSIDE [4/7]

#define INSIDE

(

K

)

(Y(K) <= W(K))

Definition at line 780 of file clip.c.

INSIDE [5/7]

#define INSIDE

(

K

)

(Y(K) >= -W(K))

Definition at line 780 of file clip.c.

INSIDE [6/7]

#define INSIDE

(

K

)

(Z(K) <= W(K))

Definition at line 780 of file clip.c.

INSIDE [7/7]

#define INSIDE

(

K

)

(Z(K) >= -W(K))

Definition at line 780 of file clip.c.

LINTERP

#define LINTERP	(		T,
			A,
			B
	)		( (A) + (T) * ( (B) - (A) ) )

Definition at line 96 of file clip.c.

MAGIC_NUMBER

#define MAGIC_NUMBER   -0.8e-03F

Definition at line 776 of file clip.c.

OUTCOUNT [1/6]

#define OUTCOUNT   n2

OUTCOUNT [2/6]

#define OUTCOUNT   n

OUTCOUNT [3/6]

#define OUTCOUNT   n2

OUTCOUNT [4/6]

#define OUTCOUNT   n

OUTCOUNT [5/6]

#define OUTCOUNT   n2

OUTCOUNT [6/6]

#define OUTCOUNT   n

OUTLIST [1/6]

#define OUTLIST   vlist2

OUTLIST [2/6]

#define OUTLIST   vlist

OUTLIST [3/6]

#define OUTLIST   vlist2

OUTLIST [4/6]

#define OUTLIST   vlist

OUTLIST [5/6]

#define OUTLIST   vlist2

OUTLIST [6/6]

#define OUTLIST   vlist

OUTSIDE [1/7]

#define OUTSIDE	(		J,
			A,
			B,
			C,
			D
	)

Value:

   ( (VB->Eye[J][0] * A + VB->Eye[J][1] * B         \
    + VB->Eye[J][2] * C + VB->Eye[J][3] * D) < MAGIC_NUMBER )

Definition at line 786 of file clip.c.

OUTSIDE [2/7]

#define OUTSIDE

(

K

)

(X(K) > W(K))

Definition at line 786 of file clip.c.

OUTSIDE [3/7]

#define OUTSIDE

(

K

)

(X(K) < -W(K))

Definition at line 786 of file clip.c.

OUTSIDE [4/7]

#define OUTSIDE

(

K

)

(Y(K) > W(K))

Definition at line 786 of file clip.c.

OUTSIDE [5/7]

#define OUTSIDE

(

K

)

(Y(K) < -W(K))

Definition at line 786 of file clip.c.

OUTSIDE [6/7]

#define OUTSIDE

(

K

)

(Z(K) > W(K))

Definition at line 786 of file clip.c.

OUTSIDE [7/7]

#define OUTSIDE

(

K

)

(Z(K) < -W(K))

Definition at line 786 of file clip.c.

W [1/2]

#define W

(

I

)

coord[I][3]

W [2/2]

#define W

(

I

)

coord[I][3]

X [1/2]

#define X

(

I

)

coord[I][0]

X [2/2]

#define X

(

I

)

coord[I][0]

Y [1/2]

#define Y

(

I

)

coord[I][1]

Y [2/2]

#define Y

(

I

)

coord[I][1]

Z [1/2]

#define Z

(

I

)

coord[I][2]

Z [2/2]

#define Z

(

I

)

coord[I][2]

Function Documentation

gl_ClipPlane()

void gl_ClipPlane	(	GLcontext *	ctx,
		GLenum	plane,
		const GLfloat *	equation
	)

Definition at line 204 of file clip.c.

{
   GLint p;
 
   p = (GLint) plane - (GLint) GL_CLIP_PLANE0;
   if (p<0 || p>=MAX_CLIP_PLANES) {
      gl_error( ctx, GL_INVALID_ENUM, "glClipPlane" );
      return;
   }
 
   /*
    * The equation is transformed by the transpose of the inverse of the
    * current modelview matrix and stored in the resulting eye coordinates.
    */
   if (ctx->NewModelViewMatrix) {
      gl_analyze_modelview_matrix(ctx);
   }
   gl_transform_vector( ctx->Transform.ClipEquation[p], equation,
                ctx->ModelViewInv );
}

Referenced by execute_list(), and init_exec_pointers().

gl_GetClipPlane()

void gl_GetClipPlane	(	GLcontext *	ctx,
		GLenum	plane,
		GLdouble *	equation
	)

Definition at line 227 of file clip.c.

{
   GLint p;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glGetClipPlane" );
      return;
   }
 
   p = (GLint) (plane - GL_CLIP_PLANE0);
   if (p<0 || p>=MAX_CLIP_PLANES) {
      gl_error( ctx, GL_INVALID_ENUM, "glGetClipPlane" );
      return;
   }
 
   equation[0] = (GLdouble) ctx->Transform.ClipEquation[p][0];
   equation[1] = (GLdouble) ctx->Transform.ClipEquation[p][1];
   equation[2] = (GLdouble) ctx->Transform.ClipEquation[p][2];
   equation[3] = (GLdouble) ctx->Transform.ClipEquation[p][3];
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_userclip_line()

GLuint gl_userclip_line	(	GLcontext *	ctx,
		GLuint *	i,
		GLuint *	j
	)

Definition at line 798 of file clip.c.

{
   struct vertex_buffer* VB = ctx->VB;
 
   GLuint p, ii, jj;
 
   ii = *i;
   jj = *j;
 
   for (p=0;p<MAX_CLIP_PLANES;p++) {
      if (ctx->Transform.ClipEnabled[p]) {
     register GLfloat a, b, c, d;
     a = ctx->Transform.ClipEquation[p][0];
     b = ctx->Transform.ClipEquation[p][1];
     c = ctx->Transform.ClipEquation[p][2];
     d = ctx->Transform.ClipEquation[p][3];
 
         if (OUTSIDE( ii, a,b,c,d  )) {
            if (OUTSIDE( jj, a,b,c,d )) {
               /* ii and jj outside ==> quit */
               return 0;
            }
            else {
               /* ii is outside, jj is inside ==> clip */
               GLfloat dx, dy, dz, dw, t, denom;
               dx = VB->Eye[ii][0] - VB->Eye[jj][0];
               dy = VB->Eye[ii][1] - VB->Eye[jj][1];
               dz = VB->Eye[ii][2] - VB->Eye[jj][2];
               dw = VB->Eye[ii][3] - VB->Eye[jj][3];
           denom = dx*a + dy*b + dz*c + dw*d;
           if (denom==0.0) {
          t = 0.0;
           }
           else {
          t = -(VB->Eye[jj][0]*a+VB->Eye[jj][1]*b
               +VB->Eye[jj][2]*c+VB->Eye[jj][3]*d) / denom;
                  if (t>1.0F)  t = 1.0F;
           }
           VB->Eye[VB->Free][0] = VB->Eye[jj][0] + t * dx;
           VB->Eye[VB->Free][1] = VB->Eye[jj][1] + t * dy;
           VB->Eye[VB->Free][2] = VB->Eye[jj][2] + t * dz;
           VB->Eye[VB->Free][3] = VB->Eye[jj][3] + t * dw;
 
           /* Interpolate colors, indexes, and/or texture coords */
           if (ctx->ClipMask)
          interpolate_aux( ctx, EYE_SPACE, VB->Free, t, jj, ii );
 
           ii = VB->Free;
           VB->Free++;
           if (VB->Free==VB_SIZE)   VB->Free = 1;
            }
         }
         else {
            if (OUTSIDE( jj, a,b,c,d )) {
               /* ii is inside, jj is outside ==> clip */
               GLfloat dx, dy, dz, dw, t, denom;
               dx = VB->Eye[jj][0] - VB->Eye[ii][0];
               dy = VB->Eye[jj][1] - VB->Eye[ii][1];
               dz = VB->Eye[jj][2] - VB->Eye[ii][2];
               dw = VB->Eye[jj][3] - VB->Eye[ii][3];
           denom = dx*a + dy*b + dz*c + dw*d;
           if (denom==0.0) {
          t = 0.0;
           }
           else {
          t = -(VB->Eye[ii][0]*a+VB->Eye[ii][1]*b
               +VB->Eye[ii][2]*c+VB->Eye[ii][3]*d) / denom;
                  if (t>1.0F)  t = 1.0F;
           }
           VB->Eye[VB->Free][0] = VB->Eye[ii][0] + t * dx;
           VB->Eye[VB->Free][1] = VB->Eye[ii][1] + t * dy;
           VB->Eye[VB->Free][2] = VB->Eye[ii][2] + t * dz;
           VB->Eye[VB->Free][3] = VB->Eye[ii][3] + t * dw;
 
           /* Interpolate colors, indexes, and/or texture coords */
           if (ctx->ClipMask)
          interpolate_aux( ctx, EYE_SPACE, VB->Free, t, ii, jj );
 
           jj = VB->Free;
           VB->Free++;
           if (VB->Free==VB_SIZE)   VB->Free = 1;
            }
            else {
               /* ii and jj inside ==> do nothing */
            }
         }
      }
   }
 
   *i = ii;
   *j = jj;
   return 1;
}

Referenced by render_clipped_line().

gl_userclip_point()

GLuint gl_userclip_point	(	GLcontext *	ctx,
		const GLfloat	v[]
	)

Definition at line 756 of file clip.c.

{
   GLuint p;
 
   for (p=0;p<MAX_CLIP_PLANES;p++) {
      if (ctx->Transform.ClipEnabled[p]) {
     GLfloat dot = v[0] * ctx->Transform.ClipEquation[p][0]
             + v[1] * ctx->Transform.ClipEquation[p][1]
             + v[2] * ctx->Transform.ClipEquation[p][2]
             + v[3] * ctx->Transform.ClipEquation[p][3];
         if (dot < 0.0F) {
            return 0;
         }
      }
   }
 
   return 1;
}

Referenced by gl_RasterPos4f().

gl_userclip_polygon()

GLuint gl_userclip_polygon	(	GLcontext *	ctx,
		GLuint	n,
		GLuint	vlist[]
	)

Definition at line 902 of file clip.c.

{
   struct vertex_buffer* VB = ctx->VB;
 
   GLuint vlist2[VB_SIZE];
   GLuint *inlist, *outlist;
   GLuint incount, outcount;
   GLuint curri, currj;
   GLuint previ, prevj;
   GLuint p;
 
   /* initialize input vertex list */
   incount = n;
   inlist = vlist;
   outlist = vlist2;
 
   for (p=0;p<MAX_CLIP_PLANES;p++) {
      if (ctx->Transform.ClipEnabled[p]) {
     register float a = ctx->Transform.ClipEquation[p][0];
     register float b = ctx->Transform.ClipEquation[p][1];
     register float c = ctx->Transform.ClipEquation[p][2];
     register float d = ctx->Transform.ClipEquation[p][3];
 
     if (incount<3)  return 0;
 
     /* initialize prev to be last in the input list */
     previ = incount - 1;
     prevj = inlist[previ];
 
         outcount = 0;
 
         for (curri=0;curri<incount;curri++) {
        currj = inlist[curri];
 
            if (INSIDE(currj, a,b,c,d)) {
               if (INSIDE(prevj, a,b,c,d)) {
                  /* both verts are inside ==> copy current to outlist */
          outlist[outcount++] = currj;
               }
               else {
                  /* current is inside and previous is outside ==> clip */
                  GLfloat dx, dy, dz, dw, t, denom;
          /* compute t */
          dx = VB->Eye[prevj][0] - VB->Eye[currj][0];
          dy = VB->Eye[prevj][1] - VB->Eye[currj][1];
          dz = VB->Eye[prevj][2] - VB->Eye[currj][2];
          dw = VB->Eye[prevj][3] - VB->Eye[currj][3];
          denom = dx*a + dy*b + dz*c + dw*d;
          if (denom==0.0) {
             t = 0.0;
          }
          else {
             t = -(VB->Eye[currj][0]*a+VB->Eye[currj][1]*b
               +VB->Eye[currj][2]*c+VB->Eye[currj][3]*d) / denom;
                     if (t>1.0F) {
                        t = 1.0F;
                     }
          }
          /* interpolate new vertex position */
          VB->Eye[VB->Free][0] = VB->Eye[currj][0] + t*dx;
          VB->Eye[VB->Free][1] = VB->Eye[currj][1] + t*dy;
          VB->Eye[VB->Free][2] = VB->Eye[currj][2] + t*dz;
          VB->Eye[VB->Free][3] = VB->Eye[currj][3] + t*dw;
 
          /* interpolate color, index, and/or texture coord */
          if (ctx->ClipMask) {
             interpolate_aux( ctx, EYE_SPACE, VB->Free, t, currj, prevj);
          }
          VB->Edgeflag[VB->Free] = VB->Edgeflag[prevj];
 
          /* output new vertex */
          outlist[outcount++] = VB->Free;
          VB->Free++;
          if (VB->Free==VB_SIZE)   VB->Free = 1;
          /* output current vertex */
          outlist[outcount++] = currj;
               }
            }
            else {
               if (INSIDE(prevj, a,b,c,d)) {
                  /* current is outside and previous is inside ==> clip */
                  GLfloat dx, dy, dz, dw, t, denom;
          /* compute t */
                  dx = VB->Eye[currj][0]-VB->Eye[prevj][0];
                  dy = VB->Eye[currj][1]-VB->Eye[prevj][1];
                  dz = VB->Eye[currj][2]-VB->Eye[prevj][2];
                  dw = VB->Eye[currj][3]-VB->Eye[prevj][3];
          denom = dx*a + dy*b + dz*c + dw*d;
          if (denom==0.0) {
             t = 0.0;
          }
          else {
             t = -(VB->Eye[prevj][0]*a+VB->Eye[prevj][1]*b
               +VB->Eye[prevj][2]*c+VB->Eye[prevj][3]*d) / denom;
                     if (t>1.0F) {
                        t = 1.0F;
                     }
          }
          /* interpolate new vertex position */
          VB->Eye[VB->Free][0] = VB->Eye[prevj][0] + t*dx;
          VB->Eye[VB->Free][1] = VB->Eye[prevj][1] + t*dy;
          VB->Eye[VB->Free][2] = VB->Eye[prevj][2] + t*dz;
          VB->Eye[VB->Free][3] = VB->Eye[prevj][3] + t*dw;
 
          /* interpolate color, index, and/or texture coord */
          if (ctx->ClipMask) {
             interpolate_aux( ctx, EYE_SPACE, VB->Free, t, prevj, currj);
          }
          VB->Edgeflag[VB->Free] = VB->Edgeflag[prevj];
 
          /* output new vertex */
          outlist[outcount++] = VB->Free;
          VB->Free++;
          if (VB->Free==VB_SIZE)   VB->Free = 1;
           }
               /* else  both verts are outside ==> do nothing */
            }
 
        previ = curri;
        prevj = currj;
 
        /* check for overflowing vertex buffer */
            if (outcount>=VB_SIZE-1) {
               /* Too many vertices */
               if (outlist!=vlist2) {
                  MEMCPY( vlist, vlist2, outcount * sizeof(GLuint) );
               }
               return VB_SIZE-1;
            }
 
         }  /* for i */
 
         /* swap inlist and outlist pointers */
         {
            GLuint *tmp;
            tmp = inlist;
            inlist = outlist;
            outlist = tmp;
            incount = outcount;
         }
 
      } /* if */
   } /* for p */
 
   /* outlist points to the list of vertices resulting from the last */
   /* clipping.  If outlist == vlist2 then we have to copy the vertices */
   /* back to vlist */
   if (outlist!=vlist2) {
      MEMCPY( vlist, vlist2, outcount * sizeof(GLuint) );
   }
 
   return outcount;
}

Referenced by render_clipped_polygon().

gl_viewclip_line()

GLuint gl_viewclip_line	(	GLcontext *	ctx,
		GLuint *	i,
		GLuint *	j
	)

Definition at line 283 of file clip.c.

{
   struct vertex_buffer* VB = ctx->VB;
   GLfloat (*coord)[4] = VB->Clip;
 
   GLfloat t, dx, dy, dz, dw;
   register GLuint ii, jj;
 
   ii = *i;
   jj = *j;
 
/*
 * We use 6 instances of this code to clip agains the 6 planes.
 * For each plane, we define the OUTSIDE and COMPUTE_INTERSECTION
 * macros apprpriately.
 */
#define GENERAL_CLIP                            \
   if (OUTSIDE(ii)) {                                           \
      if (OUTSIDE(jj)) {                                        \
         /* both verts are outside ==> return 0 */          \
         return 0;                                              \
      }                                                         \
      else {                                                    \
         /* ii is outside, jj is inside ==> clip */             \
     /* new vertex put in position VB->Free */          \
         COMPUTE_INTERSECTION( VB->Free, jj, ii )                   \
     if (ctx->ClipMask)                     \
            ctx->ClipInterpAuxFunc( ctx, CLIP_SPACE, VB->Free, t, jj, ii );\
     ii = VB->Free;                         \
     VB->Free++;                            \
     if (VB->Free==VB_SIZE)  VB->Free = 1;              \
      }                                                         \
   }                                                            \
   else {                                                       \
      if (OUTSIDE(jj)) {                                        \
         /* ii is inside, jj is outside ==> clip */             \
     /* new vertex put in position VB->Free */          \
         COMPUTE_INTERSECTION( VB->Free, ii, jj );                  \
     if (ctx->ClipMask)                     \
        ctx->ClipInterpAuxFunc( ctx, CLIP_SPACE, VB->Free, t, ii, jj );\
     jj = VB->Free;                         \
     VB->Free++;                            \
     if (VB->Free==VB_SIZE)  VB->Free = 1;              \
      }                                                         \
      /* else both verts are inside ==> do nothing */           \
   }
 
 
#define X(I)    coord[I][0]
#define Y(I)    coord[I][1]
#define Z(I)    coord[I][2]
#define W(I)    coord[I][3]
 
/*
 * Begin clipping
 */
 
   /*** Clip against +X side ***/
#define OUTSIDE(K)      (X(K) > W(K))
#define COMPUTE_INTERSECTION( new, in, out )        \
    dx = X(out) - X(in);                \
    dw = W(out) - W(in);                \
    t = (X(in) - W(in)) / (dw-dx);          \
    X(new) = X(in) + t * dx;            \
    Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = W(in) + t * dw;
 
   GENERAL_CLIP
 
#undef OUTSIDE
#undef COMPUTE_INTERSECTION
 
 
   /*** Clip against -X side ***/
#define OUTSIDE(K)      (X(K) < -W(K))
#define COMPUTE_INTERSECTION( new, in, out )        \
    dx = X(out) - X(in);                \
    dw = W(out) - W(in);                \
        t = -(X(in) + W(in)) / (dw+dx);         \
    X(new) = X(in) + t * dx;            \
    Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = W(in) + t * dw;
 
   GENERAL_CLIP
 
#undef OUTSIDE
#undef COMPUTE_INTERSECTION
 
 
   /*** Clip against +Y side ***/
#define OUTSIDE(K)      (Y(K) > W(K))
#define COMPUTE_INTERSECTION( new, in, out )        \
    dy = Y(out) - Y(in);                \
    dw = W(out) - W(in);                \
        t = (Y(in) - W(in)) / (dw-dy);          \
    X(new) = X(in) + t * (X(out) - X(in));      \
    Y(new) = Y(in) + t * dy;            \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = W(in) + t * dw;
 
   GENERAL_CLIP
 
#undef OUTSIDE
#undef COMPUTE_INTERSECTION
 
 
   /*** Clip against -Y side ***/
#define OUTSIDE(K)      (Y(K) < -W(K))
#define COMPUTE_INTERSECTION( new, in, out )        \
        dy = Y(out) - Y(in);                \
        dw = W(out) - W(in);                \
        t = -(Y(in) + W(in)) / (dw+dy);         \
        X(new) = X(in) + t * (X(out) - X(in));      \
    Y(new) = Y(in) + t * dy;            \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = W(in) + t * dw;
 
   GENERAL_CLIP
 
#undef OUTSIDE
#undef COMPUTE_INTERSECTION
 
 
   /*** Clip against +Z side ***/
#define OUTSIDE(K)      (Z(K) > W(K))
#define COMPUTE_INTERSECTION( new, in, out )        \
        dz = Z(out) - Z(in);                \
        dw = W(out) - W(in);                \
        t = (Z(in) - W(in)) / (dw-dz);          \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * dz;            \
    W(new) = W(in) + t * dw;
 
   GENERAL_CLIP
 
#undef OUTSIDE
#undef COMPUTE_INTERSECTION
 
 
   /*** Clip against -Z side ***/
#define OUTSIDE(K)      (Z(K) < -W(K))
#define COMPUTE_INTERSECTION( new, in, out )        \
        dz = Z(out) - Z(in);                \
        dw = W(out) - W(in);                \
        t = -(Z(in) + W(in)) / (dw+dz);         \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * dz;            \
    W(new) = W(in) + t * dw;
 
   GENERAL_CLIP
 
#undef OUTSIDE
#undef COMPUTE_INTERSECTION
 
#undef GENERAL_CLIP
 
   *i = ii;
   *j = jj;
   return 1;
}

Referenced by render_clipped_line().

gl_viewclip_point()

GLuint gl_viewclip_point

(

const GLfloat

v[]

)

Definition at line 262 of file clip.c.

{
   if (   v[0] > v[3] || v[0] < -v[3]
       || v[1] > v[3] || v[1] < -v[3]
       || v[2] > v[3] || v[2] < -v[3] ) {
      return 0;
   }
   else {
      return 1;
   }
}

Referenced by gl_RasterPos4f().

gl_viewclip_polygon()

GLuint gl_viewclip_polygon	(	GLcontext *	ctx,
		GLuint	n,
		GLuint	vlist[]
	)

Definition at line 458 of file clip.c.

{
   struct vertex_buffer* VB = ctx->VB;
   GLfloat (*coord)[4] = VB->Clip;
 
   GLuint previ, prevj;
   GLuint curri, currj;
   GLuint vlist2[VB_SIZE];
   GLuint n2;
   GLdouble dx, dy, dz, dw, t, neww;
 
/*
 * We use 6 instances of this code to implement clipping against the
 * 6 sides of the view volume.  Prior to each we define the macros:
 *    INLIST = array which lists input vertices
 *    OUTLIST = array which lists output vertices
 *    INCOUNT = variable which is the number of vertices in INLIST[]
 *    OUTCOUNT = variable which is the number of vertices in OUTLIST[]
 *    INSIDE(i) = test if vertex v[i] is inside the view volume
 *    COMPUTE_INTERSECTION(in,out,new) = compute intersection of line
 *              from v[in] to v[out] with the clipping plane and store
 *              the result in v[new]
 */
 
#define GENERAL_CLIP                                                    \
   if (INCOUNT<3)  return 0;                        \
   previ = INCOUNT-1;       /* let previous = last vertex */    \
   prevj = INLIST[previ];                       \
   OUTCOUNT = 0;                                                        \
   for (curri=0;curri<INCOUNT;curri++) {                \
      currj = INLIST[curri];                        \
      if (INSIDE(currj)) {                      \
         if (INSIDE(prevj)) {                       \
            /* both verts are inside ==> copy current to outlist */     \
        OUTLIST[OUTCOUNT] = currj;                  \
        OUTCOUNT++;                         \
         }                                                              \
         else {                                                         \
            /* current is inside and previous is outside ==> clip */    \
        COMPUTE_INTERSECTION( currj, prevj, VB->Free )      \
        /* if new point not coincident with previous point... */    \
        if (t>0.0) {                        \
           /* interpolate aux info using the value of t */      \
           if (ctx->ClipMask)                   \
          ctx->ClipInterpAuxFunc( ctx, CLIP_SPACE, VB->Free, t, currj, prevj ); \
           VB->Edgeflag[VB->Free] = VB->Edgeflag[prevj];        \
           /* output new point */                   \
           OUTLIST[OUTCOUNT] = VB->Free;                \
           VB->Free++;                      \
           if (VB->Free==VB_SIZE)   VB->Free = 1;           \
           OUTCOUNT++;                      \
        }                               \
        /* Output current */                    \
        OUTLIST[OUTCOUNT] = currj;                  \
        OUTCOUNT++;                         \
         }                                                              \
      }                                                                 \
      else {                                                            \
         if (INSIDE(prevj)) {                       \
            /* current is outside and previous is inside ==> clip */    \
        COMPUTE_INTERSECTION( prevj, currj, VB->Free )      \
        /* if new point not coincident with previous point... */    \
        if (t>0.0) {                        \
           /* interpolate aux info using the value of t */      \
           if (ctx->ClipMask)                   \
          ctx->ClipInterpAuxFunc( ctx, CLIP_SPACE, VB->Free, t, prevj, currj ); \
           VB->Edgeflag[VB->Free] = VB->Edgeflag[prevj];        \
           /* output new point */                   \
           OUTLIST[OUTCOUNT] = VB->Free;                \
           VB->Free++;                      \
           if (VB->Free==VB_SIZE)   VB->Free = 1;           \
           OUTCOUNT++;                      \
        }                               \
         }                              \
         /* else both verts are outside ==> do nothing */       \
      }                                 \
      /* let previous = current */                  \
      previ = curri;                            \
      prevj = currj;                            \
      /* check for overflowing vertex buffer */             \
      if (OUTCOUNT>=VB_SIZE-1) {                    \
     /* Too many vertices */                    \
         if (OUTLIST==vlist2) {                     \
        /* copy OUTLIST[] to vlist[] */             \
        int i;                          \
        for (i=0;i<VB_SIZE;i++) {                   \
           vlist[i] = OUTLIST[i];                   \
        }                               \
     }                              \
     return VB_SIZE-1;                      \
      }                                 \
   }
 
 
#define X(I)    coord[I][0]
#define Y(I)    coord[I][1]
#define Z(I)    coord[I][2]
#define W(I)    coord[I][3]
 
/*
 * Clip against +X
 */
#define INCOUNT n
#define OUTCOUNT n2
#define INLIST vlist
#define OUTLIST vlist2
#define INSIDE(K)      (X(K) <= W(K))
 
#define COMPUTE_INTERSECTION( in, out, new )        \
        dx = X(out) - X(in);                \
        dw = W(out) - W(in);                \
        t = (X(in)-W(in)) / (dw-dx);            \
    neww = W(in) + t * dw;              \
    X(new) = neww;                  \
    Y(new) = Y(in) + t * (Y(out) - Y(in));      \
    Z(new) = Z(in) + t * (Z(out) - Z(in));      \
    W(new) = neww;
 
   GENERAL_CLIP
 
#undef INCOUNT
#undef OUTCOUNT
#undef INLIST
#undef OUTLIST
#undef INSIDE
#undef COMPUTE_INTERSECTION
 
 
/*
 * Clip against -X
 */
#define INCOUNT n2
#define OUTCOUNT n
#define INLIST vlist2
#define OUTLIST vlist
#define INSIDE(K)       (X(K) >= -W(K))
#define COMPUTE_INTERSECTION( in, out, new )        \
        dx = X(out)-X(in);                          \
        dw = W(out)-W(in);                          \
        t = -(X(in)+W(in)) / (dw+dx);               \
    neww = W(in) + t * dw;              \
        X(new) = -neww;                 \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
        Z(new) = Z(in) + t * (Z(out) - Z(in));      \
        W(new) = neww;
 
   GENERAL_CLIP
 
#undef INCOUNT
#undef OUTCOUNT
#undef INLIST
#undef OUTLIST
#undef INSIDE
#undef COMPUTE_INTERSECTION
 
 
/*
 * Clip against +Y
 */
#define INCOUNT n
#define OUTCOUNT n2
#define INLIST vlist
#define OUTLIST vlist2
#define INSIDE(K)       (Y(K) <= W(K))
#define COMPUTE_INTERSECTION( in, out, new )        \
        dy = Y(out)-Y(in);                          \
        dw = W(out)-W(in);                          \
        t = (Y(in)-W(in)) / (dw-dy);                \
    neww = W(in) + t * dw;              \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = neww;                  \
        Z(new) = Z(in) + t * (Z(out) - Z(in));      \
        W(new) = neww;
 
   GENERAL_CLIP
 
#undef INCOUNT
#undef OUTCOUNT
#undef INLIST
#undef OUTLIST
#undef INSIDE
#undef COMPUTE_INTERSECTION
 
 
/*
 * Clip against -Y
 */
#define INCOUNT n2
#define OUTCOUNT n
#define INLIST vlist2
#define OUTLIST vlist
#define INSIDE(K)       (Y(K) >= -W(K))
#define COMPUTE_INTERSECTION( in, out, new )        \
        dy = Y(out)-Y(in);                          \
        dw = W(out)-W(in);                          \
        t = -(Y(in)+W(in)) / (dw+dy);               \
    neww = W(in) + t * dw;              \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = -neww;                 \
        Z(new) = Z(in) + t * (Z(out) - Z(in));      \
        W(new) = neww;
 
   GENERAL_CLIP
 
#undef INCOUNT
#undef OUTCOUNT
#undef INLIST
#undef OUTLIST
#undef INSIDE
#undef COMPUTE_INTERSECTION
 
 
 
/*
 * Clip against +Z
 */
#define INCOUNT n
#define OUTCOUNT n2
#define INLIST vlist
#define OUTLIST vlist2
#define INSIDE(K)       (Z(K) <= W(K))
#define COMPUTE_INTERSECTION( in, out, new )        \
        dz = Z(out)-Z(in);                          \
        dw = W(out)-W(in);                          \
        t = (Z(in)-W(in)) / (dw-dz);                \
    neww = W(in) + t * dw;              \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
        Z(new) = neww;                  \
        W(new) = neww;
 
   GENERAL_CLIP
 
#undef INCOUNT
#undef OUTCOUNT
#undef INLIST
#undef OUTLIST
#undef INSIDE
#undef COMPUTE_INTERSECTION
 
 
/*
 * Clip against -Z
 */
#define INCOUNT n2
#define OUTCOUNT n
#define INLIST vlist2
#define OUTLIST vlist
#define INSIDE(K)       (Z(K) >= -W(K))
#define COMPUTE_INTERSECTION( in, out, new )        \
        dz = Z(out)-Z(in);                          \
        dw = W(out)-W(in);                          \
        t = -(Z(in)+W(in)) / (dw+dz);               \
    neww = W(in) + t * dw;              \
        X(new) = X(in) + t * (X(out) - X(in));      \
        Y(new) = Y(in) + t * (Y(out) - Y(in));      \
        Z(new) = -neww;                 \
        W(new) = neww;
 
   GENERAL_CLIP
 
#undef INCOUNT
#undef INLIST
#undef OUTLIST
#undef INSIDE
#undef COMPUTE_INTERSECTION
 
   /* 'OUTCOUNT' clipped vertices are now back in v[] */
   return OUTCOUNT;
 
#undef GENERAL_CLIP
#undef OUTCOUNT
}

Referenced by render_clipped_polygon().

interpolate_aux()

void interpolate_aux	(	GLcontext *	ctx,
		GLuint	space,
		GLuint	dst,
		GLfloat	t,
		GLuint	in,
		GLuint	out
	)

Definition at line 116 of file clip.c.

{
   struct vertex_buffer* VB = ctx->VB;
 
   if (ctx->ClipMask & CLIP_FCOLOR_BIT) {
      VB->Fcolor[dst][0] = LINTERP( t, VB->Fcolor[in][0], VB->Fcolor[out][0] );
      VB->Fcolor[dst][1] = LINTERP( t, VB->Fcolor[in][1], VB->Fcolor[out][1] );
      VB->Fcolor[dst][2] = LINTERP( t, VB->Fcolor[in][2], VB->Fcolor[out][2] );
      VB->Fcolor[dst][3] = LINTERP( t, VB->Fcolor[in][3], VB->Fcolor[out][3] );
   }
   else if (ctx->ClipMask & CLIP_FINDEX_BIT) {
      VB->Findex[dst] = (GLuint) (GLint) LINTERP( t, (GLfloat) VB->Findex[in],
                                                 (GLfloat) VB->Findex[out] );
   }
 
   if (ctx->ClipMask & CLIP_BCOLOR_BIT) {
      VB->Bcolor[dst][0] = LINTERP( t, VB->Bcolor[in][0], VB->Bcolor[out][0] );
      VB->Bcolor[dst][1] = LINTERP( t, VB->Bcolor[in][1], VB->Bcolor[out][1] );
      VB->Bcolor[dst][2] = LINTERP( t, VB->Bcolor[in][2], VB->Bcolor[out][2] );
      VB->Bcolor[dst][3] = LINTERP( t, VB->Bcolor[in][3], VB->Bcolor[out][3] );
   }
   else if (ctx->ClipMask & CLIP_BINDEX_BIT) {
      VB->Bindex[dst] = (GLuint) (GLint) LINTERP( t, (GLfloat) VB->Bindex[in],
                                                 (GLfloat) VB->Bindex[out] );
   }
 
   if (ctx->ClipMask & CLIP_TEXTURE_BIT) {
      /* TODO: is more sophisticated texture coord interpolation needed?? */
      if (space==CLIP_SPACE) {
     /* also interpolate eye Z component */
     VB->Eye[dst][2] = LINTERP( t, VB->Eye[in][2], VB->Eye[out][2] );
      }
      VB->TexCoord[dst][0] = LINTERP(t,VB->TexCoord[in][0],VB->TexCoord[out][0]);
      VB->TexCoord[dst][1] = LINTERP(t,VB->TexCoord[in][1],VB->TexCoord[out][1]);
      VB->TexCoord[dst][2] = LINTERP(t,VB->TexCoord[in][2],VB->TexCoord[out][2]);
      VB->TexCoord[dst][3] = LINTERP(t,VB->TexCoord[in][3],VB->TexCoord[out][3]);
   }
 
}

Referenced by gl_userclip_line(), gl_userclip_polygon(), and update_clipmask().

interpolate_aux_color()

void interpolate_aux_color	(	GLcontext *	ctx,
		GLuint	space,
		GLuint	dst,
		GLfloat	t,
		GLuint	in,
		GLuint	out
	)

Definition at line 190 of file clip.c.

{
   struct vertex_buffer* VB = ctx->VB;
 
   VB->Fcolor[dst][0] = LINTERP( t, VB->Fcolor[in][0], VB->Fcolor[out][0] );
   VB->Fcolor[dst][1] = LINTERP( t, VB->Fcolor[in][1], VB->Fcolor[out][1] );
   VB->Fcolor[dst][2] = LINTERP( t, VB->Fcolor[in][2], VB->Fcolor[out][2] );
   VB->Fcolor[dst][3] = LINTERP( t, VB->Fcolor[in][3], VB->Fcolor[out][3] );
}

Referenced by update_clipmask().

interpolate_aux_color_tex2()

void interpolate_aux_color_tex2	(	GLcontext *	ctx,
		GLuint	space,
		GLuint	dst,
		GLfloat	t,
		GLuint	in,
		GLuint	out
	)

Definition at line 163 of file clip.c.

{
   struct vertex_buffer* VB = ctx->VB;
 
   VB->Fcolor[dst][0] = LINTERP( t, VB->Fcolor[in][0], VB->Fcolor[out][0] );
   VB->Fcolor[dst][1] = LINTERP( t, VB->Fcolor[in][1], VB->Fcolor[out][1] );
   VB->Fcolor[dst][2] = LINTERP( t, VB->Fcolor[in][2], VB->Fcolor[out][2] );
   VB->Fcolor[dst][3] = LINTERP( t, VB->Fcolor[in][3], VB->Fcolor[out][3] );
 
   VB->Eye[dst][2] = LINTERP( t, VB->Eye[in][2], VB->Eye[out][2] );
   VB->TexCoord[dst][0] = LINTERP(t,VB->TexCoord[in][0],VB->TexCoord[out][0]);
   VB->TexCoord[dst][1] = LINTERP(t,VB->TexCoord[in][1],VB->TexCoord[out][1]);
}

Referenced by update_clipmask().

interpolate_aux_tex2()

void interpolate_aux_tex2	(	GLcontext *	ctx,
		GLuint	space,
		GLuint	dst,
		GLfloat	t,
		GLuint	in,
		GLuint	out
	)

Definition at line 179 of file clip.c.

{
   struct vertex_buffer* VB = ctx->VB;
 
   VB->Eye[dst][2] = LINTERP( t, VB->Eye[in][2], VB->Eye[out][2] );
   VB->TexCoord[dst][0] = LINTERP(t,VB->TexCoord[in][0],VB->TexCoord[out][0]);
   VB->TexCoord[dst][1] = LINTERP(t,VB->TexCoord[in][1],VB->TexCoord[out][1]);
}

Referenced by update_clipmask().