Ignore:
Timestamp:
May 23, 2000, 10:41:28 PM (25 years ago)
Author:
jeroen
Message:

* empty log message *

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/opengl/mesa/alphabuf.c

    r2962 r3598  
    1 /* $Id: alphabuf.c,v 1.2 2000-03-01 18:49:22 jeroen Exp $ */
     1/* $Id: alphabuf.c,v 1.3 2000-05-23 20:40:20 jeroen Exp $ */
    22
    33/*
    44 * Mesa 3-D graphics library
    5  * Version:  3.1
     5 * Version:  3.3
    66 *
    77 * Copyright (C) 1999  Brian Paul   All Rights Reserved.
    … …  
    3939#include "all.h"
    4040#else
     41#include "glheader.h"
    4142#include "types.h"
    4243#include "alphabuf.h"
    4344#include "context.h"
    4445#include "macros.h"
     46#include "mem.h"
    4547#endif
    4648
    4749
    4850
    49 #define ALPHA_ADDR(X,Y)  (ctx->Buffer->Alpha + (Y) * ctx->Buffer->Width + (X))
    50 
    51 
    52 
    53 /*
    54  * Allocate a new front and back alpha buffer.
    55  */
    56 void gl_alloc_alpha_buffers( GLcontext *ctx )
    57 {
    58    GLint bytes = ctx->Buffer->Width * ctx->Buffer->Height * sizeof(GLubyte);
     51#define ALPHA_DRAW_ADDR(X,Y) \
     52   (ctx->DrawBuffer->Alpha + (Y) * ctx->DrawBuffer->Width + (X))
     53
     54#define ALPHA_READ_ADDR(X,Y) \
     55   (ctx->ReadBuffer->Alpha + (Y) * ctx->ReadBuffer->Width + (X))
     56
     57
     58
     59/*
     60 * Allocate new front/back/left/right alpha buffers.
     61 * Input: ctx - the context
     62 */
     63static void
     64alloc_alpha_buffers( GLcontext *ctx, GLframebuffer *buf )
     65{
     66   GLint bytes = buf->Width * buf->Height * sizeof(GLubyte);
    5967
    6068   ASSERT(ctx->Visual->SoftwareAlpha);
    6169
    62    if (ctx->Buffer->FrontLeftAlpha) {
    63       FREE( ctx->Buffer->FrontLeftAlpha );
    64    }
    65    ctx->Buffer->FrontLeftAlpha = (GLubyte *) MALLOC( bytes );
    66    if (!ctx->Buffer->FrontLeftAlpha) {
     70   if (buf->FrontLeftAlpha) {
     71      FREE( buf->FrontLeftAlpha );
     72   }
     73   buf->FrontLeftAlpha = (GLubyte *) MALLOC( bytes );
     74   if (!buf->FrontLeftAlpha) {
    6775      /* out of memory */
    6876      gl_error( ctx, GL_OUT_OF_MEMORY,
    … …  
    7179
    7280   if (ctx->Visual->DBflag) {
    73       if (ctx->Buffer->BackLeftAlpha) {
    74          FREE( ctx->Buffer->BackLeftAlpha );
    75       }
    76       ctx->Buffer->BackLeftAlpha = (GLubyte *) MALLOC( bytes );
    77       if (!ctx->Buffer->BackLeftAlpha) {
     81      if (buf->BackLeftAlpha) {
     82         FREE( buf->BackLeftAlpha );
     83      }
     84      buf->BackLeftAlpha = (GLubyte *) MALLOC( bytes );
     85      if (!buf->BackLeftAlpha) {
    7886         /* out of memory */
    7987         gl_error( ctx, GL_OUT_OF_MEMORY,
    … …  
    8391
    8492   if (ctx->Visual->StereoFlag) {
    85       if (ctx->Buffer->FrontRightAlpha) {
    86          FREE( ctx->Buffer->FrontRightAlpha );
    87       }
    88       ctx->Buffer->FrontRightAlpha = (GLubyte *) MALLOC( bytes );
    89       if (!ctx->Buffer->FrontRightAlpha) {
     93      if (buf->FrontRightAlpha) {
     94         FREE( buf->FrontRightAlpha );
     95      }
     96      buf->FrontRightAlpha = (GLubyte *) MALLOC( bytes );
     97      if (!buf->FrontRightAlpha) {
    9098         /* out of memory */
    9199         gl_error( ctx, GL_OUT_OF_MEMORY,
    … …  
    94102
    95103      if (ctx->Visual->DBflag) {
    96          if (ctx->Buffer->BackRightAlpha) {
    97             FREE( ctx->Buffer->BackRightAlpha );
    98          }
    99          ctx->Buffer->BackRightAlpha = (GLubyte *) MALLOC( bytes );
    100          if (!ctx->Buffer->BackRightAlpha) {
     104         if (buf->BackRightAlpha) {
     105            FREE( buf->BackRightAlpha );
     106         }
     107         buf->BackRightAlpha = (GLubyte *) MALLOC( bytes );
     108         if (!buf->BackRightAlpha) {
    101109            /* out of memory */
    102110            gl_error( ctx, GL_OUT_OF_MEMORY,
    … …  
    107115
    108116   if (ctx->Color.DriverDrawBuffer == GL_FRONT_LEFT)
    109       ctx->Buffer->Alpha = ctx->Buffer->FrontLeftAlpha;
     117      buf->Alpha = buf->FrontLeftAlpha;
    110118   else if (ctx->Color.DriverDrawBuffer == GL_BACK_LEFT)
    111       ctx->Buffer->Alpha = ctx->Buffer->BackLeftAlpha;
     119      buf->Alpha = buf->BackLeftAlpha;
    112120   else if (ctx->Color.DriverDrawBuffer == GL_FRONT_RIGHT)
    113       ctx->Buffer->Alpha = ctx->Buffer->FrontRightAlpha;
     121      buf->Alpha = buf->FrontRightAlpha;
    114122   else if (ctx->Color.DriverDrawBuffer == GL_BACK_RIGHT)
    115       ctx->Buffer->Alpha = ctx->Buffer->BackRightAlpha;
     123      buf->Alpha = buf->BackRightAlpha;
     124}
     125
     126
     127/*
     128 * Allocate a new front and back alpha buffer.
     129 */
     130void gl_alloc_alpha_buffers( GLcontext *ctx )
     131{
     132   alloc_alpha_buffers( ctx, ctx->DrawBuffer );
     133   if (ctx->ReadBuffer != ctx->DrawBuffer) {
     134      alloc_alpha_buffers( ctx, ctx->ReadBuffer );
     135   }
    116136}
    117137
    … …  
    133153         GLubyte *buffer;
    134154         if (bufferBit == FRONT_LEFT_BIT) {
    135             buffer = ctx->Buffer->FrontLeftAlpha;
     155            buffer = ctx->DrawBuffer->FrontLeftAlpha;
    136156         }
    137157         else if (bufferBit == FRONT_RIGHT_BIT) {
    138             buffer = ctx->Buffer->FrontRightAlpha;
     158            buffer = ctx->DrawBuffer->FrontRightAlpha;
    139159         }
    140160         else if (bufferBit == BACK_LEFT_BIT) {
    141             buffer = ctx->Buffer->BackLeftAlpha;
     161            buffer = ctx->DrawBuffer->BackLeftAlpha;
    142162         }
    143163         else {
    144             buffer = ctx->Buffer->BackRightAlpha;
     164            buffer = ctx->DrawBuffer->BackRightAlpha;
    145165         }
    146166
    … …  
    148168            /* clear scissor region */
    149169            GLint j;
    150             GLint rowLen = ctx->Buffer->Xmax - ctx->Buffer->Xmin + 1;
    151             GLint rows = ctx->Buffer->Ymax - ctx->Buffer->Ymin + 1;
    152             GLubyte *aptr = buffer + ctx->Buffer->Ymin * ctx->Buffer->Width
    153                           + ctx->Buffer->Xmin;
     170            GLint rowLen = ctx->DrawBuffer->Xmax - ctx->DrawBuffer->Xmin + 1;
     171            GLint rows = ctx->DrawBuffer->Ymax - ctx->DrawBuffer->Ymin + 1;
     172            GLubyte *aptr = buffer
     173                          + ctx->DrawBuffer->Ymin * ctx->DrawBuffer->Width
     174                          + ctx->DrawBuffer->Xmin;
    154175            for (j = 0; j < rows; j++) {
    155176               MEMSET( aptr, aclear, rowLen );
    … …  
    159180         else {
    160181            /* clear whole buffer */
    161             MEMSET( buffer, aclear, ctx->Buffer->Width * ctx->Buffer->Height );
     182            GLuint bytes = ctx->DrawBuffer->Width * ctx->DrawBuffer->Height;
     183            MEMSET( buffer, aclear, bytes );
    162184         }
    163185      }
    … …  
    170192                          CONST GLubyte rgba[][4], const GLubyte mask[] )
    171193{
    172    GLubyte *aptr = ALPHA_ADDR( x, y );
     194   GLubyte *aptr = ALPHA_DRAW_ADDR( x, y );
    173195   GLuint i;
    174196
    … …  
    192214                               GLubyte alpha, const GLubyte mask[] )
    193215{
    194    GLubyte *aptr = ALPHA_ADDR( x, y );
     216   GLubyte *aptr = ALPHA_DRAW_ADDR( x, y );
    195217   GLuint i;
    196218
    … …  
    220242      for (i=0;i<n;i++) {
    221243         if (mask[i]) {
    222             GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
     244            GLubyte *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
    223245            *aptr = rgba[i][ACOMP];
    224246         }
    … …  
    227249   else {
    228250      for (i=0;i<n;i++) {
    229          GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
     251         GLubyte *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
    230252         *aptr = rgba[i][ACOMP];
    231253      }
    … …  
    243265      for (i=0;i<n;i++) {
    244266         if (mask[i]) {
    245             GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
     267            GLubyte *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
    246268            *aptr = alpha;
    247269         }
    … …  
    250272   else {
    251273      for (i=0;i<n;i++) {
    252          GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
     274         GLubyte *aptr = ALPHA_DRAW_ADDR( x[i], y[i] );
    253275         *aptr = alpha;
    254276      }
    … …  
    261283                         GLuint n, GLint x, GLint y, GLubyte rgba[][4] )
    262284{
    263    GLubyte *aptr = ALPHA_ADDR( x, y );
     285   GLubyte *aptr = ALPHA_READ_ADDR( x, y );
    264286   GLuint i;
    265287   for (i=0;i<n;i++) {
    … …  
    276298   for (i=0;i<n;i++) {
    277299      if (mask[i]) {
    278          GLubyte *aptr = ALPHA_ADDR( x[i], y[i] );
     300         GLubyte *aptr = ALPHA_READ_ADDR( x[i], y[i] );
    279301         rgba[i][ACOMP] = *aptr;
    280302      }
Note: See TracChangeset for help on using the changeset viewer.