#include "types.h"

Include dependency graph for alphabuf.h:

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

Functions
void	gl_alloc_alpha_buffers (GLcontext *ctx)

void	gl_clear_alpha_buffers (GLcontext *ctx)

void	gl_write_alpha_span (GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte alpha[], GLubyte mask[])

void	gl_write_mono_alpha_span (GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte alpha, GLubyte mask[])

void	gl_write_alpha_pixels (GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], const GLubyte alpha[], const GLubyte mask[])

void	gl_write_mono_alpha_pixels (GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLubyte alpha, const GLubyte mask[])

void	gl_read_alpha_span (GLcontext *ctx, GLuint n, GLint x, GLint y, GLubyte alpha[])

void	gl_read_alpha_pixels (GLcontext *ctx, GLuint n, const GLint x[], const GLint y[], GLubyte alpha[], const GLubyte mask[])

Function Documentation

◆ gl_alloc_alpha_buffers()

void gl_alloc_alpha_buffers ( GLcontext * ctx )

Definition at line 71 of file alphabuf.c.

{
   GLint bytes = ctx->Buffer->Width * ctx->Buffer->Height * sizeof(GLubyte);
 
   if (ctx->Visual->FrontAlphaEnabled) {
      if (ctx->Buffer->FrontAlpha) {
         free( ctx->Buffer->FrontAlpha );
      }
      ctx->Buffer->FrontAlpha = (GLubyte *) malloc( bytes );
      if (!ctx->Buffer->FrontAlpha) {
         /* out of memory */
         gl_error( ctx, GL_OUT_OF_MEMORY, "Couldn't allocate front alpha buffer" );
      }
   }
   if (ctx->Visual->BackAlphaEnabled) {
      if (ctx->Buffer->BackAlpha) {
         free( ctx->Buffer->BackAlpha );
      }
      ctx->Buffer->BackAlpha = (GLubyte *) malloc( bytes );
      if (!ctx->Buffer->BackAlpha) {
         /* out of memory */
         gl_error( ctx, GL_OUT_OF_MEMORY, "Couldn't allocate back alpha buffer" );
      }
   }
   if (ctx->Color.DrawBuffer==GL_FRONT) {
      ctx->Buffer->Alpha = ctx->Buffer->FrontAlpha;
   }
   if (ctx->Color.DrawBuffer==GL_BACK) {
      ctx->Buffer->Alpha = ctx->Buffer->BackAlpha;
   }
}

Referenced by gl_ResizeBuffersMESA().

◆ gl_clear_alpha_buffers()

void gl_clear_alpha_buffers ( GLcontext * ctx )

Definition at line 108 of file alphabuf.c.

{
   GLint buffer;
 
   /* Loop over front and back buffers */
   for (buffer=0;buffer<2;buffer++) {
 
      /* Get pointer to front or back buffer */
      GLubyte *abuffer = NULL;
      if (buffer==0
          && (   ctx->Color.DrawBuffer==GL_FRONT
              || ctx->Color.DrawBuffer==GL_FRONT_AND_BACK)
          && ctx->Visual->FrontAlphaEnabled && ctx->Buffer->FrontAlpha) {
         abuffer = ctx->Buffer->FrontAlpha;
      }
      else if (buffer==1
               && (   ctx->Color.DrawBuffer==GL_BACK
                   || ctx->Color.DrawBuffer==GL_FRONT_AND_BACK)
               && ctx->Visual->BackAlphaEnabled && ctx->Buffer->BackAlpha) {
         abuffer = ctx->Buffer->BackAlpha;
      }
 
      /* Clear the alpha buffer */
      if (abuffer) {
         GLubyte aclear = (GLint) (ctx->Color.ClearColor[3]
                                   * ctx->Visual->AlphaScale);
         if (ctx->Scissor.Enabled) {
            /* clear scissor region */
            GLint i, j;
            for (j=0;j<ctx->Scissor.Height;j++) {
               GLubyte *aptr = ALPHA_ADDR(ctx->Buffer->Xmin,
                                          ctx->Buffer->Ymin+j);
               for (i=0;i<ctx->Scissor.Width;i++) {
                  *aptr++ = aclear;
               }
            }
         }
         else {
            /* clear whole buffer */
            MEMSET( abuffer, aclear, ctx->Buffer->Width*ctx->Buffer->Height );
         }
      }
   }
}

Referenced by clear_color_buffers().

◆ gl_read_alpha_pixels()

void gl_read_alpha_pixels	(	GLcontext *	ctx,
		GLuint	n,
		const GLint	x[],
		const GLint	y[],
		GLubyte	alpha[],
		const GLubyte	mask[]
	)

Definition at line 257 of file alphabuf.c.

{
   GLuint i;
   for (i=0;i<n;i++) {
      if (mask[i]) {
         GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
         alpha[i] = *aptr;
      }
   }
}

Referenced by gl_blend_pixels(), gl_logicop_rgba_pixels(), and gl_mask_color_pixels().

◆ gl_read_alpha_span()

void gl_read_alpha_span	(	GLcontext *	ctx,
		GLuint	n,
		GLint	x,
		GLint	y,
		GLubyte	alpha[]
	)

Definition at line 246 of file alphabuf.c.

{
   GLubyte *aptr = ALPHA_ADDR( x, y );
   GLuint i;
   for (i=0;i<n;i++) {
      alpha[i] = *aptr++;
   }
}

Referenced by gl_read_color_span(), and read_color_pixels().

◆ gl_write_alpha_pixels()

void gl_write_alpha_pixels	(	GLcontext *	ctx,
		GLuint	n,
		const GLint	x[],
		const GLint	y[],
		const GLubyte	alpha[],
		const GLubyte	mask[]
	)

Definition at line 199 of file alphabuf.c.

{
   GLuint i;
 
   if (mask) {
      for (i=0;i<n;i++) {
         if (mask[i]) {
            GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
            *aptr = alpha[i];
         }
      }
   }
   else {
      for (i=0;i<n;i++) {
         GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
         *aptr = alpha[i];
      }
   }
}

Referenced by gl_flush_pb().

◆ gl_write_alpha_span()

void gl_write_alpha_span	(	GLcontext *	ctx,
		GLuint	n,
		GLint	x,
		GLint	y,
		GLubyte	alpha[],
		GLubyte	mask[]
	)

Definition at line 155 of file alphabuf.c.

{
   GLubyte *aptr = ALPHA_ADDR( x, y );
   GLuint i;
 
   if (mask) {
      for (i=0;i<n;i++) {
         if (mask[i]) {
            *aptr = alpha[i];
         }
         aptr++;
      }
   }
   else {
      for (i=0;i<n;i++) {
         *aptr++ = alpha[i];
      }
   }
}

Referenced by clear_color_buffer_with_masking(), gl_write_color_span(), gl_write_monocolor_span(), and gl_write_texture_span().

◆ gl_write_mono_alpha_pixels()

void gl_write_mono_alpha_pixels	(	GLcontext *	ctx,
		GLuint	n,
		const GLint	x[],
		const GLint	y[],
		GLubyte	alpha,
		const GLubyte	mask[]
	)

Definition at line 222 of file alphabuf.c.

{
   GLuint i;
 
   if (mask) {
      for (i=0;i<n;i++) {
         if (mask[i]) {
            GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
            *aptr = alpha;
         }
      }
   }
   else {
      for (i=0;i<n;i++) {
         GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
         *aptr = alpha;
      }
   }
}