src/mesa/swrast/s_bitmap.c

   1 /* $Id: s_bitmap.c,v 1.20 2002/11/25 20:26:59 brianp Exp $ */
   2
   3 /*
   4  * Mesa 3-D graphics library
   5  * Version:  5.0
   6  *
   7  * Copyright (C) 1999-2002  Brian Paul   All Rights Reserved.
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included
  17  * in all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  20  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  22  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  23  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  24  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  */
  26
  27 /**
  28  * \file swrast/s_bitmap.c
  29  * \brief glBitmap rendering.
  30  * \author Brian Paul
  31  */
  32
  33 #include "glheader.h"
  34 #include "image.h"
  35 #include "macros.h"
  36 #include "mmath.h"
  37 #include "pixel.h"
  38
  39 #include "s_context.h"
  40 #include "s_span.h"
  41
  42
  43
  44 /*
  45  * Render a bitmap.
  46  */
  47 void
  48 _swrast_Bitmap( GLcontext *ctx, GLint px, GLint py,
  49                 GLsizei width, GLsizei height,
  50                 const struct gl_pixelstore_attrib *unpack,
  51                 const GLubyte *bitmap )
  52 {
  53    SWcontext *swrast = SWRAST_CONTEXT(ctx);
  54    GLint row, col;
  55    GLuint count = 0;
  56    struct sw_span span;
  57
  58    ASSERT(ctx->RenderMode == GL_RENDER);
  59    ASSERT(bitmap);
  60
  61    RENDER_START(swrast,ctx);
  62
  63    if (SWRAST_CONTEXT(ctx)->NewState)
  64       _swrast_validate_derived( ctx );
  65
  66    INIT_SPAN(span, GL_BITMAP, width, 0, SPAN_XY);
  67
  68    if (ctx->Visual.rgbMode) {
  69       span.interpMask |= SPAN_RGBA;
  70       span.red   = FloatToFixed(ctx->Current.RasterColor[0] * CHAN_MAXF);
  71       span.green = FloatToFixed(ctx->Current.RasterColor[1] * CHAN_MAXF);
  72       span.blue  = FloatToFixed(ctx->Current.RasterColor[2] * CHAN_MAXF);
  73       span.alpha = FloatToFixed(ctx->Current.RasterColor[3] * CHAN_MAXF);
  74       span.redStep = span.greenStep = span.blueStep = span.alphaStep = 0;
  75    }
  76    else {
  77       span.interpMask |= SPAN_INDEX;
  78       span.index = ChanToFixed(ctx->Current.RasterIndex);
  79       span.indexStep = 0;
  80    }
  81
  82    if (ctx->Depth.Test)
  83       _mesa_span_default_z(ctx, &span);
  84    if (ctx->Fog.Enabled)
  85       _mesa_span_default_fog(ctx, &span);
  86    if (ctx->Texture._EnabledUnits)
  87       _mesa_span_default_texcoords(ctx, &span);
  88
  89    for (row = 0; row < height; row++, span.y++) {
  90       const GLubyte *src = (const GLubyte *) _mesa_image_address( unpack,
  91                  bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 );
  92
  93       if (unpack->LsbFirst) {
  94          /* Lsb first */
  95          GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
  96          for (col = 0; col < width; col++) {
  97             if (*src & mask) {
  98                span.array->x[count] = px + col;
  99                span.array->y[count] = py + row;
 100                count++;
 101             }
 102             if (mask == 128U) {
 103                src++;
 104                mask = 1U;
 105             }
 106             else {
 107                mask = mask << 1;
 108             }
 109          }
 110
 111          /* get ready for next row */
 112          if (mask != 1)
 113             src++;
 114       }
 115       else {
 116          /* Msb first */
 117          GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
 118          for (col = 0; col < width; col++) {
 119             if (*src & mask) {
 120                span.array->x[count] = px + col;
 121                span.array->y[count] = py + row;
 122                count++;
 123             }
 124             if (mask == 1U) {
 125                src++;
 126                mask = 128U;
 127             }
 128             else {
 129                mask = mask >> 1;
 130             }
 131          }
 132
 133          /* get ready for next row */
 134          if (mask != 128)
 135             src++;
 136       }
 137
 138       if (count + width >= MAX_WIDTH || row + 1 == height) {
 139          /* flush the span */
 140          span.end = count;
 141          if (ctx->Visual.rgbMode)
 142             _mesa_write_rgba_span(ctx, &span);
 143          else
 144             _mesa_write_index_span(ctx, &span);
 145          span.end = 0;
 146          count = 0;
 147       }
 148    }
 149
 150    RENDER_FINISH(swrast,ctx);
 151 }
 152
 153
 154 #if 0
 155 /*
 156  * XXX this is another way to implement Bitmap.  Use horizontal runs of
 157  * fragments, initializing the mask array to indicate which fragmens to
 158  * draw or skip.
 159  */
 160 void
 161 _swrast_Bitmap( GLcontext *ctx, GLint px, GLint py,
 162                 GLsizei width, GLsizei height,
 163                 const struct gl_pixelstore_attrib *unpack,
 164                 const GLubyte *bitmap )
 165 {
 166    SWcontext *swrast = SWRAST_CONTEXT(ctx);
 167    GLint row, col;
 168    struct sw_span span;
 169
 170    ASSERT(ctx->RenderMode == GL_RENDER);
 171    ASSERT(bitmap);
 172
 173    RENDER_START(swrast,ctx);
 174
 175    if (SWRAST_CONTEXT(ctx)->NewState)
 176       _swrast_validate_derived( ctx );
 177
 178    INIT_SPAN(span, GL_BITMAP, width, 0, SPAN_MASK);
 179
 180    /*span.arrayMask |= SPAN_MASK;*/  /* we'll init span.mask[] */
 181    span.x = px;
 182    span.y = py;
 183    /*span.end = width;*/
 184    if (ctx->Visual.rgbMode) {
 185       span.interpMask |= SPAN_RGBA;
 186       span.red   = FloatToFixed(ctx->Current.RasterColor[0] * CHAN_MAXF);
 187       span.green = FloatToFixed(ctx->Current.RasterColor[1] * CHAN_MAXF);
 188       span.blue  = FloatToFixed(ctx->Current.RasterColor[2] * CHAN_MAXF);
 189       span.alpha = FloatToFixed(ctx->Current.RasterColor[3] * CHAN_MAXF);
 190       span.redStep = span.greenStep = span.blueStep = span.alphaStep = 0;
 191    }
 192    else {
 193       span.interpMask |= SPAN_INDEX;
 194       span.index = ChanToFixed(ctx->Current.RasterIndex);
 195       span.indexStep = 0;
 196    }
 197
 198    if (ctx->Depth.Test)
 199       _mesa_span_default_z(ctx, &span);
 200    if (ctx->Fog.Enabled)
 201       _mesa_span_default_fog(ctx, &span);
 202    if (ctx->Texture._EnabledUnits)
 203       _mesa_span_default_texcoords(ctx, &span);
 204
 205    for (row=0; row<height; row++, span.y++) {
 206       const GLubyte *src = (const GLubyte *) _mesa_image_address( unpack,
 207                  bitmap, width, height, GL_COLOR_INDEX, GL_BITMAP, 0, row, 0 );
 208
 209       if (unpack->LsbFirst) {
 210          /* Lsb first */
 211          GLubyte mask = 1U << (unpack->SkipPixels & 0x7);
 212          for (col=0; col<width; col++) {
 213             span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;
 214             if (mask == 128U) {
 215                src++;
 216                mask = 1U;
 217             }
 218             else {
 219                mask = mask << 1;
 220             }
 221          }
 222
 223          if (ctx->Visual.rgbMode)
 224             _mesa_write_rgba_span(ctx, &span);
 225          else
 226             _mesa_write_index_span(ctx, &span);
 227
 228          /* get ready for next row */
 229          if (mask != 1)
 230             src++;
 231       }
 232       else {
 233          /* Msb first */
 234          GLubyte mask = 128U >> (unpack->SkipPixels & 0x7);
 235          for (col=0; col<width; col++) {
 236             span.array->mask[col] = (*src & mask) ? GL_TRUE : GL_FALSE;
 237             if (mask == 1U) {
 238                src++;
 239                mask = 128U;
 240             }
 241             else {
 242                mask = mask >> 1;
 243             }
 244          }
 245
 246          if (ctx->Visual.rgbMode)
 247             _mesa_write_rgba_span(ctx, &span);
 248          else
 249             _mesa_write_index_span(ctx, &span);
 250
 251          /* get ready for next row */
 252          if (mask != 128)
 253             src++;
 254       }
 255    }
 256
 257    RENDER_FINISH(swrast,ctx);
 258 }
 259 #endif