pixel.h File Reference

#include "types.h"

Include dependency graph for pixel.h:

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

Go to the source code of this file.

Functions
void	gl_GetPixelMapfv (GLcontext *ctx, GLenum map, GLfloat *values)
void	gl_GetPixelMapuiv (GLcontext *ctx, GLenum map, GLuint *values)
void	gl_GetPixelMapusv (GLcontext *ctx, GLenum map, GLushort *values)
void	gl_PixelMapfv (GLcontext *ctx, GLenum map, GLint mapsize, const GLfloat *values)
void	gl_PixelStorei (GLcontext *ctx, GLenum pname, GLint param)
void	gl_PixelTransferf (GLcontext *ctx, GLenum pname, GLfloat param)
void	gl_PixelZoom (GLcontext *ctx, GLfloat xfactor, GLfloat yfactor)
GLvoid *	gl_unpack_pixels (GLcontext *ctx, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
void	gl_write_zoomed_color_span (GLcontext *ctx, GLuint n, GLint x, GLint y, const GLdepth z[], const GLubyte red[], const GLubyte green[], const GLubyte blue[], const GLubyte alpha[], GLint y0)
void	gl_write_zoomed_index_span (GLcontext *ctx, GLuint n, GLint x, GLint y, const GLdepth z[], const GLuint indexes[], GLint y0)
void	gl_write_zoomed_stencil_span (GLcontext *ctx, GLuint n, GLint x, GLint y, const GLubyte stencil[], GLint y0)

Function Documentation

gl_GetPixelMapfv()

void gl_GetPixelMapfv	(	GLcontext *	ctx,
		GLenum	map,
		GLfloat *	values
	)

Definition at line 621 of file pixel.c.

{
   GLuint i;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glGetPixelMapfv" );
      return;
   }
   switch (map) {
      case GL_PIXEL_MAP_I_TO_I:
         for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
        values[i] = (GLfloat) ctx->Pixel.MapItoI[i];
     }
     break;
      case GL_PIXEL_MAP_S_TO_S:
         for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
        values[i] = (GLfloat) ctx->Pixel.MapStoS[i];
     }
     break;
      case GL_PIXEL_MAP_I_TO_R:
         MEMCPY(values,ctx->Pixel.MapItoR,ctx->Pixel.MapItoRsize*sizeof(GLfloat));
     break;
      case GL_PIXEL_MAP_I_TO_G:
         MEMCPY(values,ctx->Pixel.MapItoG,ctx->Pixel.MapItoGsize*sizeof(GLfloat));
     break;
      case GL_PIXEL_MAP_I_TO_B:
         MEMCPY(values,ctx->Pixel.MapItoB,ctx->Pixel.MapItoBsize*sizeof(GLfloat));
     break;
      case GL_PIXEL_MAP_I_TO_A:
         MEMCPY(values,ctx->Pixel.MapItoA,ctx->Pixel.MapItoAsize*sizeof(GLfloat));
     break;
      case GL_PIXEL_MAP_R_TO_R:
         MEMCPY(values,ctx->Pixel.MapRtoR,ctx->Pixel.MapRtoRsize*sizeof(GLfloat));
     break;
      case GL_PIXEL_MAP_G_TO_G:
         MEMCPY(values,ctx->Pixel.MapGtoG,ctx->Pixel.MapGtoGsize*sizeof(GLfloat));
     break;
      case GL_PIXEL_MAP_B_TO_B:
         MEMCPY(values,ctx->Pixel.MapBtoB,ctx->Pixel.MapBtoBsize*sizeof(GLfloat));
     break;
      case GL_PIXEL_MAP_A_TO_A:
         MEMCPY(values,ctx->Pixel.MapAtoA,ctx->Pixel.MapAtoAsize*sizeof(GLfloat));
     break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_GetPixelMapuiv()

void gl_GetPixelMapuiv	(	GLcontext *	ctx,
		GLenum	map,
		GLuint *	values
	)

Definition at line 670 of file pixel.c.

{
   GLuint i;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glGetPixelMapfv" );
      return;
   }
   switch (map) {
      case GL_PIXEL_MAP_I_TO_I:
         MEMCPY(values, ctx->Pixel.MapItoI, ctx->Pixel.MapItoIsize*sizeof(GLint));
     break;
      case GL_PIXEL_MAP_S_TO_S:
         MEMCPY(values, ctx->Pixel.MapStoS, ctx->Pixel.MapStoSsize*sizeof(GLint));
     break;
      case GL_PIXEL_MAP_I_TO_R:
     for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
        values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoR[i] );
     }
     break;
      case GL_PIXEL_MAP_I_TO_G:
     for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
        values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoG[i] );
     }
     break;
      case GL_PIXEL_MAP_I_TO_B:
     for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
        values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoB[i] );
     }
     break;
      case GL_PIXEL_MAP_I_TO_A:
     for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
        values[i] = FLOAT_TO_UINT( ctx->Pixel.MapItoA[i] );
     }
     break;
      case GL_PIXEL_MAP_R_TO_R:
     for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
        values[i] = FLOAT_TO_UINT( ctx->Pixel.MapRtoR[i] );
     }
     break;
      case GL_PIXEL_MAP_G_TO_G:
     for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
        values[i] = FLOAT_TO_UINT( ctx->Pixel.MapGtoG[i] );
     }
     break;
      case GL_PIXEL_MAP_B_TO_B:
     for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
        values[i] = FLOAT_TO_UINT( ctx->Pixel.MapBtoB[i] );
     }
     break;
      case GL_PIXEL_MAP_A_TO_A:
     for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
        values[i] = FLOAT_TO_UINT( ctx->Pixel.MapAtoA[i] );
     }
     break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_GetPixelMapusv()

void gl_GetPixelMapusv	(	GLcontext *	ctx,
		GLenum	map,
		GLushort *	values
	)

Definition at line 731 of file pixel.c.

{
   GLuint i;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glGetPixelMapfv" );
      return;
   }
   switch (map) {
      case GL_PIXEL_MAP_I_TO_I:
     for (i=0;i<ctx->Pixel.MapItoIsize;i++) {
        values[i] = (GLushort) ctx->Pixel.MapItoI[i];
     }
     break;
      case GL_PIXEL_MAP_S_TO_S:
     for (i=0;i<ctx->Pixel.MapStoSsize;i++) {
        values[i] = (GLushort) ctx->Pixel.MapStoS[i];
     }
     break;
      case GL_PIXEL_MAP_I_TO_R:
     for (i=0;i<ctx->Pixel.MapItoRsize;i++) {
        values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoR[i] );
     }
     break;
      case GL_PIXEL_MAP_I_TO_G:
     for (i=0;i<ctx->Pixel.MapItoGsize;i++) {
        values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoG[i] );
     }
     break;
      case GL_PIXEL_MAP_I_TO_B:
     for (i=0;i<ctx->Pixel.MapItoBsize;i++) {
        values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoB[i] );
     }
     break;
      case GL_PIXEL_MAP_I_TO_A:
     for (i=0;i<ctx->Pixel.MapItoAsize;i++) {
        values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapItoA[i] );
     }
     break;
      case GL_PIXEL_MAP_R_TO_R:
     for (i=0;i<ctx->Pixel.MapRtoRsize;i++) {
        values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapRtoR[i] );
     }
     break;
      case GL_PIXEL_MAP_G_TO_G:
     for (i=0;i<ctx->Pixel.MapGtoGsize;i++) {
        values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapGtoG[i] );
     }
     break;
      case GL_PIXEL_MAP_B_TO_B:
     for (i=0;i<ctx->Pixel.MapBtoBsize;i++) {
        values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapBtoB[i] );
     }
     break;
      case GL_PIXEL_MAP_A_TO_A:
     for (i=0;i<ctx->Pixel.MapAtoAsize;i++) {
        values[i] = FLOAT_TO_USHORT( ctx->Pixel.MapAtoA[i] );
     }
     break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glGetPixelMapfv" );
   }
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_PixelMapfv()

void gl_PixelMapfv	(	GLcontext *	ctx,
		GLenum	map,
		GLint	mapsize,
		const GLfloat *	values
	)

Definition at line 520 of file pixel.c.

{
   GLuint i;
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glPixelMapfv" );
      return;
   }
 
   if (mapsize<0 || mapsize>MAX_PIXEL_MAP_TABLE) {
      gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
      return;
   }
 
   if (map>=GL_PIXEL_MAP_S_TO_S && map<=GL_PIXEL_MAP_I_TO_A) {
      /* test that mapsize is a power of two */
      GLuint p;
      GLboolean ok = GL_FALSE;
      for (p=1; p<=MAX_PIXEL_MAP_TABLE; p=p<<1) {
     if ( (p&mapsize) == p ) {
        ok = GL_TRUE;
        break;
     }
      }
      if (!ok) {
     gl_error( ctx, GL_INVALID_VALUE, "glPixelMapfv(mapsize)" );
         return;
      }
   }
 
   switch (map) {
      case GL_PIXEL_MAP_S_TO_S:
         ctx->Pixel.MapStoSsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapStoS[i] = (GLint) values[i];
     }
     break;
      case GL_PIXEL_MAP_I_TO_I:
         ctx->Pixel.MapItoIsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapItoI[i] = (GLint) values[i];
     }
     break;
      case GL_PIXEL_MAP_I_TO_R:
         ctx->Pixel.MapItoRsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapItoR[i] = CLAMP( values[i], 0.0, 1.0 );
     }
     break;
      case GL_PIXEL_MAP_I_TO_G:
         ctx->Pixel.MapItoGsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapItoG[i] = CLAMP( values[i], 0.0, 1.0 );
     }
     break;
      case GL_PIXEL_MAP_I_TO_B:
         ctx->Pixel.MapItoBsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapItoB[i] = CLAMP( values[i], 0.0, 1.0 );
     }
     break;
      case GL_PIXEL_MAP_I_TO_A:
         ctx->Pixel.MapItoAsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapItoA[i] = CLAMP( values[i], 0.0, 1.0 );
     }
     break;
      case GL_PIXEL_MAP_R_TO_R:
         ctx->Pixel.MapRtoRsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapRtoR[i] = CLAMP( values[i], 0.0, 1.0 );
     }
     break;
      case GL_PIXEL_MAP_G_TO_G:
         ctx->Pixel.MapGtoGsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapGtoG[i] = CLAMP( values[i], 0.0, 1.0 );
     }
     break;
      case GL_PIXEL_MAP_B_TO_B:
         ctx->Pixel.MapBtoBsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapBtoB[i] = CLAMP( values[i], 0.0, 1.0 );
     }
     break;
      case GL_PIXEL_MAP_A_TO_A:
         ctx->Pixel.MapAtoAsize = mapsize;
         for (i=0;i<mapsize;i++) {
        ctx->Pixel.MapAtoA[i] = CLAMP( values[i], 0.0, 1.0 );
     }
     break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glPixelMapfv(map)" );
   }
}

Referenced by execute_list(), and init_exec_pointers().

gl_PixelStorei()

void gl_PixelStorei	(	GLcontext *	ctx,
		GLenum	pname,
		GLint	param
	)

Definition at line 418 of file pixel.c.

{
   /* NOTE: this call can't be compiled into the display list */
 
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glPixelStore" );
      return;
   }
 
   switch (pname) {
      case GL_PACK_SWAP_BYTES:
         ctx->Pack.SwapBytes = param ? GL_TRUE : GL_FALSE;
     break;
      case GL_PACK_LSB_FIRST:
         ctx->Pack.LsbFirst = param ? GL_TRUE : GL_FALSE;
     break;
      case GL_PACK_ROW_LENGTH:
     if (param<0) {
        gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     }
     else {
        ctx->Pack.RowLength = param;
     }
     break;
      case GL_PACK_SKIP_PIXELS:
     if (param<0) {
        gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     }
     else {
        ctx->Pack.SkipPixels = param;
     }
     break;
      case GL_PACK_SKIP_ROWS:
     if (param<0) {
        gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     }
     else {
        ctx->Pack.SkipRows = param;
     }
     break;
      case GL_PACK_ALIGNMENT:
         if (param==1 || param==2 || param==4 || param==8) {
        ctx->Pack.Alignment = param;
     }
     else {
        gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     }
     break;
      case GL_UNPACK_SWAP_BYTES:
     ctx->Unpack.SwapBytes = param ? GL_TRUE : GL_FALSE;
         break;
      case GL_UNPACK_LSB_FIRST:
     ctx->Unpack.LsbFirst = param ? GL_TRUE : GL_FALSE;
     break;
      case GL_UNPACK_ROW_LENGTH:
     if (param<0) {
        gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     }
     else {
        ctx->Unpack.RowLength = param;
     }
     break;
      case GL_UNPACK_SKIP_PIXELS:
     if (param<0) {
        gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     }
     else {
        ctx->Unpack.SkipPixels = param;
     }
     break;
      case GL_UNPACK_SKIP_ROWS:
     if (param<0) {
        gl_error( ctx, GL_INVALID_VALUE, "glPixelStore(param)" );
     }
     else {
        ctx->Unpack.SkipRows = param;
     }
     break;
      case GL_UNPACK_ALIGNMENT:
         if (param==1 || param==2 || param==4 || param==8) {
        ctx->Unpack.Alignment = param;
     }
     else {
        gl_error( ctx, GL_INVALID_VALUE, "glPixelStore" );
     }
     break;
      default:
     gl_error( ctx, GL_INVALID_ENUM, "glPixelStore" );
   }
   update_drawpixels_state( ctx );
}

Referenced by init_dlist_pointers(), and init_exec_pointers().

gl_PixelTransferf()

void gl_PixelTransferf	(	GLcontext *	ctx,
		GLenum	pname,
		GLfloat	param
	)

Definition at line 806 of file pixel.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glPixelTransfer" );
      return;
   }
 
   switch (pname) {
      case GL_MAP_COLOR:
         ctx->Pixel.MapColorFlag = param ? GL_TRUE : GL_FALSE;
     break;
      case GL_MAP_STENCIL:
         ctx->Pixel.MapStencilFlag = param ? GL_TRUE : GL_FALSE;
     break;
      case GL_INDEX_SHIFT:
         ctx->Pixel.IndexShift = (GLint) param;
     break;
      case GL_INDEX_OFFSET:
         ctx->Pixel.IndexOffset = (GLint) param;
     break;
      case GL_RED_SCALE:
         ctx->Pixel.RedScale = param;
     break;
      case GL_RED_BIAS:
         ctx->Pixel.RedBias = param;
     break;
      case GL_GREEN_SCALE:
         ctx->Pixel.GreenScale = param;
     break;
      case GL_GREEN_BIAS:
         ctx->Pixel.GreenBias = param;
     break;
      case GL_BLUE_SCALE:
         ctx->Pixel.BlueScale = param;
     break;
      case GL_BLUE_BIAS:
         ctx->Pixel.BlueBias = param;
     break;
      case GL_ALPHA_SCALE:
         ctx->Pixel.AlphaScale = param;
     break;
      case GL_ALPHA_BIAS:
         ctx->Pixel.AlphaBias = param;
     break;
      case GL_DEPTH_SCALE:
         ctx->Pixel.DepthScale = param;
     break;
      case GL_DEPTH_BIAS:
         ctx->Pixel.DepthBias = param;
     break;
      default:
         gl_error( ctx, GL_INVALID_ENUM, "glPixelTransfer(pname)" );
         return;
   }
   update_drawpixels_state( ctx );
}

Referenced by execute_list(), and init_exec_pointers().

gl_PixelZoom()

void gl_PixelZoom	(	GLcontext *	ctx,
		GLfloat	xfactor,
		GLfloat	yfactor
	)

Definition at line 112 of file pixel.c.

{
   if (INSIDE_BEGIN_END(ctx)) {
      gl_error( ctx, GL_INVALID_OPERATION, "glPixelZoom" );
      return;
   }
   ctx->Pixel.ZoomX = xfactor;
   ctx->Pixel.ZoomY = yfactor;
   update_drawpixels_state( ctx );
}

Referenced by execute_list(), and init_exec_pointers().

gl_unpack_pixels()

GLvoid * gl_unpack_pixels	(	GLcontext *	ctx,
		GLsizei	width,
		GLsizei	height,
		GLenum	format,
		GLenum	type,
		const GLvoid *	pixels
	)

Definition at line 880 of file pixel.c.

{
   GLint s, n;
 
   s = gl_sizeof_type( type );
   if (s<0) {
      gl_error( ctx, GL_INVALID_ENUM, "internal error in gl_unpack(type)" );
      return NULL;
   }
 
   n = gl_components_in_format( format );
   if (n<0) {
      gl_error( ctx, GL_INVALID_ENUM, "gl_unpack_pixels(format)" );
      return NULL;
   }
 
   if (type==GL_BITMAP) {
      /* BITMAP data */
      GLint bytes, i, width_in_bytes;
      GLubyte *buffer, *dst;
      GLvoid *src;
 
      /* Alloc dest storage */
      bytes = CEILING( width * height , 8 );
      buffer = (GLubyte *) malloc( bytes );
      if (!buffer) {
     return NULL;
      }
 
      /* Copy/unpack pixel data to buffer */
      width_in_bytes = CEILING( width, 8 );
      dst = buffer;
      for (i=0;i<height;i++) {
         src = gl_pixel_addr_in_image( &ctx->Unpack, pixels, width, height,
                                       format, type, i);
         if (!src) {
            free(buffer);
            return NULL;
         }
     MEMCPY( dst, src, width_in_bytes );
     dst += width_in_bytes;
      }
 
      /* Bit flipping */
      if (ctx->Unpack.LsbFirst) {
     gl_flip_bytes( buffer, bytes );
      }
      return (GLvoid *) buffer;
   }
   else {
      /* Non-BITMAP data */
      GLint width_in_bytes, bytes, i;
      GLubyte *buffer, *dst;
      GLvoid *src;
 
      width_in_bytes = width * n * s;
 
      /* Alloc dest storage */
      bytes = height * width_in_bytes;
      buffer = (GLubyte *) malloc( bytes );
      if (!buffer) {
     return NULL;
      }
 
      /* Copy/unpack pixel data to buffer */
      dst = buffer;
      for (i=0;i<height;i++) {
         src = gl_pixel_addr_in_image( &ctx->Unpack, pixels, width, height,
                                       format, type, i);
         if (!src) {
            free(buffer);
            return NULL;
         }
     MEMCPY( dst, src, width_in_bytes );
     dst += width_in_bytes;
      }
 
      /* Byte swapping */
      if (ctx->Unpack.SwapBytes && s>1) {
     if (s==2) {
        gl_swap2( (GLushort *) buffer, bytes/2 );
     }
     else if (s==4) {
        gl_swap4( (GLuint *) buffer, bytes/4 );
     }
      }
      return (GLvoid *) buffer;
   }
}

Referenced by gl_DrawPixels().

gl_write_zoomed_color_span()

void gl_write_zoomed_color_span	(	GLcontext *	ctx,
		GLuint	n,
		GLint	x,
		GLint	y,
		const GLdepth	z[],
		const GLubyte	red[],
		const GLubyte	green[],
		const GLubyte	blue[],
		const GLubyte	alpha[],
		GLint	y0
	)

Definition at line 136 of file pixel.c.

{
   GLint m;
   GLint r0, r1, row, r;
   GLint i, j, skipcol;
   GLubyte zred[MAX_WIDTH], zgreen[MAX_WIDTH];  /* zoomed pixel colors */
   GLubyte zblue[MAX_WIDTH], zalpha[MAX_WIDTH];
   GLdepth zdepth[MAX_WIDTH];  /* zoomed depth values */
   GLint maxwidth = MIN2( ctx->Buffer->Width, MAX_WIDTH );
 
   /* compute width of output row */
   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
   if (m==0) {
      return;
   }
   if (ctx->Pixel.ZoomX<0.0) {
      /* adjust x coordinate for left/right mirroring */
      x = x - m;
   }
 
   /* compute which rows to draw */
   row = y-y0;
   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
   if (r0==r1) {
      return;
   }
   else if (r1<r0) {
      GLint rtmp = r1;
      r1 = r0;
      r0 = rtmp;
   }
 
   /* return early if r0...r1 is above or below window */
   if (r0<0 && r1<0) {
      /* below window */
      return;
   }
   if (r0>=ctx->Buffer->Height && r1>=ctx->Buffer->Height) {
      /* above window */
      return;
   }
 
   /* check if left edge is outside window */
   skipcol = 0;
   if (x<0) {
      skipcol = -x;
      m += x;
   }
   /* make sure span isn't too long or short */
   if (m>maxwidth) {
      m = maxwidth;
   }
   else if (m<=0) {
      return;
   }
 
   assert( m <= MAX_WIDTH );
 
   /* zoom the span horizontally */
   if (ctx->Pixel.ZoomX==-1.0F) {
      /* n==m */
      for (j=0;j<m;j++) {
         i = n - (j+skipcol) - 1;
         zred[j]   = red[i];
         zgreen[j] = green[i];
         zblue[j]  = blue[i];
         zalpha[j] = alpha[i];
         zdepth[j] = z[i];
      }
   }
   else {
      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
      for (j=0;j<m;j++) {
         i = (j+skipcol) * xscale;
         if (i<0)  i = n + i - 1;
         zred[j]   = red[i];
         zgreen[j] = green[i];
         zblue[j]  = blue[i];
         zalpha[j] = alpha[i];
         zdepth[j] = z[i];
      }
   }
 
   /* write the span */
   for (r=r0; r<r1; r++) {
      gl_write_color_span( ctx, m, x+skipcol, r, zdepth,
                           zred, zgreen, zblue, zalpha, GL_BITMAP );
   }
}

Referenced by copy_depth_pixels(), copy_rgb_pixels(), draw_color_pixels(), draw_depth_pixels(), and draw_index_pixels().

gl_write_zoomed_index_span()

void gl_write_zoomed_index_span	(	GLcontext *	ctx,
		GLuint	n,
		GLint	x,
		GLint	y,
		const GLdepth	z[],
		const GLuint	indexes[],
		GLint	y0
	)

Definition at line 237 of file pixel.c.

{
   GLint m;
   GLint r0, r1, row, r;
   GLint i, j, skipcol;
   GLuint zindexes[MAX_WIDTH];  /* zoomed color indexes */
   GLdepth zdepth[MAX_WIDTH];  /* zoomed depth values */
   GLint maxwidth = MIN2( ctx->Buffer->Width, MAX_WIDTH );
 
   /* compute width of output row */
   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
   if (m==0) {
      return;
   }
   if (ctx->Pixel.ZoomX<0.0) {
      /* adjust x coordinate for left/right mirroring */
      x = x - m;
   }
 
   /* compute which rows to draw */
   row = y-y0;
   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
   if (r0==r1) {
      return;
   }
   else if (r1<r0) {
      GLint rtmp = r1;
      r1 = r0;
      r0 = rtmp;
   }
 
   /* return early if r0...r1 is above or below window */
   if (r0<0 && r1<0) {
      /* below window */
      return;
   }
   if (r0>=ctx->Buffer->Height && r1>=ctx->Buffer->Height) {
      /* above window */
      return;
   }
 
   /* check if left edge is outside window */
   skipcol = 0;
   if (x<0) {
      skipcol = -x;
      m += x;
   }
   /* make sure span isn't too long or short */
   if (m>maxwidth) {
      m = maxwidth;
   }
   else if (m<=0) {
      return;
   }
 
   assert( m <= MAX_WIDTH );
 
   /* zoom the span horizontally */
   if (ctx->Pixel.ZoomX==-1.0F) {
      /* n==m */
      for (j=0;j<m;j++) {
         i = n - (j+skipcol) - 1;
         zindexes[j] = indexes[i];
         zdepth[j]   = z[i];
      }
   }
   else {
      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
      for (j=0;j<m;j++) {
         i = (j+skipcol) * xscale;
         if (i<0)  i = n + i - 1;
         zindexes[j] = indexes[i];
         zdepth[j] = z[i];
      }
   }
 
   /* write the span */
   for (r=r0; r<r1; r++) {
      gl_write_index_span( ctx, m, x+skipcol, r, zdepth, zindexes, GL_BITMAP );
   }
}

Referenced by copy_ci_pixels(), copy_depth_pixels(), draw_depth_pixels(), and draw_index_pixels().

gl_write_zoomed_stencil_span()

void gl_write_zoomed_stencil_span	(	GLcontext *	ctx,
		GLuint	n,
		GLint	x,
		GLint	y,
		const GLubyte	stencil[],
		GLint	y0
	)

Definition at line 328 of file pixel.c.

{
   GLint m;
   GLint r0, r1, row, r;
   GLint i, j, skipcol;
   GLubyte zstencil[MAX_WIDTH];  /* zoomed stencil values */
   GLint maxwidth = MIN2( ctx->Buffer->Width, MAX_WIDTH );
 
   /* compute width of output row */
   m = (GLint) ABSF( n * ctx->Pixel.ZoomX );
   if (m==0) {
      return;
   }
   if (ctx->Pixel.ZoomX<0.0) {
      /* adjust x coordinate for left/right mirroring */
      x = x - m;
   }
 
   /* compute which rows to draw */
   row = y-y0;
   r0 = y0 + (GLint) (row * ctx->Pixel.ZoomY);
   r1 = y0 + (GLint) ((row+1) * ctx->Pixel.ZoomY);
   if (r0==r1) {
      return;
   }
   else if (r1<r0) {
      GLint rtmp = r1;
      r1 = r0;
      r0 = rtmp;
   }
 
   /* return early if r0...r1 is above or below window */
   if (r0<0 && r1<0) {
      /* below window */
      return;
   }
   if (r0>=ctx->Buffer->Height && r1>=ctx->Buffer->Height) {
      /* above window */
      return;
   }
 
   /* check if left edge is outside window */
   skipcol = 0;
   if (x<0) {
      skipcol = -x;
      m += x;
   }
   /* make sure span isn't too long or short */
   if (m>maxwidth) {
      m = maxwidth;
   }
   else if (m<=0) {
      return;
   }
 
   assert( m <= MAX_WIDTH );
 
   /* zoom the span horizontally */
   if (ctx->Pixel.ZoomX==-1.0F) {
      /* n==m */
      for (j=0;j<m;j++) {
         i = n - (j+skipcol) - 1;
         zstencil[j] = stencil[i];
      }
   }
   else {
      GLfloat xscale = 1.0F / ctx->Pixel.ZoomX;
      for (j=0;j<m;j++) {
         i = (j+skipcol) * xscale;
         if (i<0)  i = n + i - 1;
         zstencil[j] = stencil[i];
      }
   }
 
   /* write the span */
   for (r=r0; r<r1; r++) {
      gl_write_stencil_span( ctx, m, x+skipcol, r, zstencil );
   }
}

Referenced by copy_stencil_pixels(), and draw_stencil_pixels().