Home | History | Annotate | Download | only in swrast 
      1 /*
      2  * Mesa 3-D graphics library
      3  *
      4  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
      5  *
      6  * Permission is hereby granted, free of charge, to any person obtaining a
      7  * copy of this software and associated documentation files (the "Software"),
      8  * to deal in the Software without restriction, including without limitation
      9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
     10  * and/or sell copies of the Software, and to permit persons to whom the
     11  * Software is furnished to do so, subject to the following conditions:
     12  *
     13  * The above copyright notice and this permission notice shall be included
     14  * in all copies or substantial portions of the Software.
     15  *
     16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
     17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
     19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
     20  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
     21  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
     22  * OTHER DEALINGS IN THE SOFTWARE.
     23  */
     24 
     25 
     26 #include "main/glheader.h"
     27 #include "main/context.h"
     28 #include "main/macros.h"
     29 #include "s_aaline.h"
     30 #include "s_context.h"
     31 #include "s_feedback.h"
     32 #include "s_lines.h"
     33 #include "s_span.h"
     34 
     35 
     36 /*
     37  * Init the mask[] array to implement a line stipple.
     38  */
     39 static void
     40 compute_stipple_mask( struct gl_context *ctx, GLuint len, GLubyte mask[] )
     41 {
     42    SWcontext *swrast = SWRAST_CONTEXT(ctx);
     43    GLuint i;
     44 
     45    for (i = 0; i < len; i++) {
     46       GLuint bit = (swrast->StippleCounter / ctx->Line.StippleFactor) & 0xf;
     47       if ((1 << bit) & ctx->Line.StipplePattern) {
     48          mask[i] = GL_TRUE;
     49       }
     50       else {
     51          mask[i] = GL_FALSE;
     52       }
     53       swrast->StippleCounter++;
     54    }
     55 }
     56 
     57 
     58 /*
     59  * To draw a wide line we can simply redraw the span N times, side by side.
     60  */
     61 static void
     62 draw_wide_line( struct gl_context *ctx, SWspan *span, GLboolean xMajor )
     63 {
     64    const GLint width = (GLint) CLAMP(ctx->Line.Width,
     65                                      ctx->Const.MinLineWidth,
     66                                      ctx->Const.MaxLineWidth);
     67    GLint start;
     68 
     69    assert(span->end < SWRAST_MAX_WIDTH);
     70 
     71    if (width & 1)
     72       start = width / 2;
     73    else
     74       start = width / 2 - 1;
     75 
     76    if (xMajor) {
     77       GLint *y = span->array->y;
     78       GLuint i;
     79       GLint w;
     80       for (w = 0; w < width; w++) {
     81          if (w == 0) {
     82             for (i = 0; i < span->end; i++)
     83                y[i] -= start;
     84          }
     85          else {
     86             for (i = 0; i < span->end; i++)
     87                y[i]++;
     88          }
     89 	 _swrast_write_rgba_span(ctx, span);
     90       }
     91    }
     92    else {
     93       GLint *x = span->array->x;
     94       GLuint i;
     95       GLint w;
     96       for (w = 0; w < width; w++) {
     97          if (w == 0) {
     98             for (i = 0; i < span->end; i++)
     99                x[i] -= start;
    100          }
    101          else {
    102             for (i = 0; i < span->end; i++)
    103                x[i]++;
    104          }
    105 	 _swrast_write_rgba_span(ctx, span);
    106       }
    107    }
    108 }
    109 
    110 
    111 
    112 /**********************************************************************/
    113 /*****                    Rasterization                           *****/
    114 /**********************************************************************/
    115 
    116 /* Simple RGBA index line (no stipple, width=1, no Z, no fog, no tex)*/
    117 #define NAME simple_no_z_rgba_line
    118 #define INTERP_RGBA
    119 #define RENDER_SPAN(span) _swrast_write_rgba_span(ctx, &span);
    120 #include "s_linetemp.h"
    121 
    122 
    123 /* Z, fog, wide, stipple RGBA line */
    124 #define NAME rgba_line
    125 #define INTERP_RGBA
    126 #define INTERP_Z
    127 #define RENDER_SPAN(span)					\
    128    if (ctx->Line.StippleFlag) {					\
    129       span.arrayMask |= SPAN_MASK;				\
    130       compute_stipple_mask(ctx, span.end, span.array->mask);	\
    131    }								\
    132    if (ctx->Line.Width > 1.0) {					\
    133       draw_wide_line(ctx, &span, (GLboolean)(dx > dy));		\
    134    }								\
    135    else {							\
    136       _swrast_write_rgba_span(ctx, &span);			\
    137    }
    138 #include "s_linetemp.h"
    139 
    140 
    141 /* General-purpose line (any/all features). */
    142 #define NAME general_line
    143 #define INTERP_RGBA
    144 #define INTERP_Z
    145 #define INTERP_ATTRIBS
    146 #define RENDER_SPAN(span)					\
    147    if (ctx->Line.StippleFlag) {					\
    148       span.arrayMask |= SPAN_MASK;				\
    149       compute_stipple_mask(ctx, span.end, span.array->mask);	\
    150    }								\
    151    if (ctx->Line.Width > 1.0) {					\
    152       draw_wide_line(ctx, &span, (GLboolean)(dx > dy));		\
    153    }								\
    154    else {							\
    155       _swrast_write_rgba_span(ctx, &span);			\
    156    }
    157 #include "s_linetemp.h"
    158 
    159 
    160 
    161 void
    162 _swrast_add_spec_terms_line(struct gl_context *ctx,
    163                             const SWvertex *v0, const SWvertex *v1)
    164 {
    165    SWvertex *ncv0 = (SWvertex *)v0;
    166    SWvertex *ncv1 = (SWvertex *)v1;
    167    GLfloat rSum, gSum, bSum;
    168    GLchan cSave[2][4];
    169 
    170    /* save original colors */
    171    COPY_CHAN4(cSave[0], ncv0->color);
    172    COPY_CHAN4(cSave[1], ncv1->color);
    173    /* sum v0 */
    174    rSum = CHAN_TO_FLOAT(ncv0->color[0]) + ncv0->attrib[VARYING_SLOT_COL1][0];
    175    gSum = CHAN_TO_FLOAT(ncv0->color[1]) + ncv0->attrib[VARYING_SLOT_COL1][1];
    176    bSum = CHAN_TO_FLOAT(ncv0->color[2]) + ncv0->attrib[VARYING_SLOT_COL1][2];
    177    UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[0], rSum);
    178    UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[1], gSum);
    179    UNCLAMPED_FLOAT_TO_CHAN(ncv0->color[2], bSum);
    180    /* sum v1 */
    181    rSum = CHAN_TO_FLOAT(ncv1->color[0]) + ncv1->attrib[VARYING_SLOT_COL1][0];
    182    gSum = CHAN_TO_FLOAT(ncv1->color[1]) + ncv1->attrib[VARYING_SLOT_COL1][1];
    183    bSum = CHAN_TO_FLOAT(ncv1->color[2]) + ncv1->attrib[VARYING_SLOT_COL1][2];
    184    UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[0], rSum);
    185    UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[1], gSum);
    186    UNCLAMPED_FLOAT_TO_CHAN(ncv1->color[2], bSum);
    187    /* draw */
    188    SWRAST_CONTEXT(ctx)->SpecLine( ctx, ncv0, ncv1 );
    189    /* restore original colors */
    190    COPY_CHAN4(ncv0->color, cSave[0]);
    191    COPY_CHAN4(ncv1->color, cSave[1]);
    192 }
    193 
    194 
    195 
    196 #ifdef DEBUG
    197 
    198 /* record the current line function name */
    199 static const char *lineFuncName = NULL;
    200 
    201 #define USE(lineFunc)                   \
    202 do {                                    \
    203     lineFuncName = #lineFunc;           \
    204     /*printf("%s\n", lineFuncName);*/   \
    205     swrast->Line = lineFunc;            \
    206 } while (0)
    207 
    208 #else
    209 
    210 #define USE(lineFunc)  swrast->Line = lineFunc
    211 
    212 #endif
    213 
    214 
    215 
    216 /**
    217  * Determine which line drawing function to use given the current
    218  * rendering context.
    219  *
    220  * Please update the summary flag _SWRAST_NEW_LINE if you add or remove
    221  * tests to this code.
    222  */
    223 void
    224 _swrast_choose_line( struct gl_context *ctx )
    225 {
    226    SWcontext *swrast = SWRAST_CONTEXT(ctx);
    227    GLboolean specular = (ctx->Fog.ColorSumEnabled ||
    228                          (ctx->Light.Enabled &&
    229                           ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR));
    230 
    231    if (ctx->RenderMode == GL_RENDER) {
    232       if (ctx->Line.SmoothFlag) {
    233          /* antialiased lines */
    234          _swrast_choose_aa_line_function(ctx);
    235          assert(swrast->Line);
    236       }
    237       else if (ctx->Texture._EnabledCoordUnits
    238                || _swrast_use_fragment_program(ctx)
    239                || swrast->_FogEnabled
    240                || specular) {
    241          USE(general_line);
    242       }
    243       else if (ctx->Depth.Test
    244                || ctx->Line.Width != 1.0F
    245                || ctx->Line.StippleFlag) {
    246          /* no texture, but Z, fog, width>1, stipple, etc. */
    247 #if CHAN_BITS == 32
    248          USE(general_line);
    249 #else
    250          USE(rgba_line);
    251 #endif
    252       }
    253       else {
    254          assert(!ctx->Depth.Test);
    255          assert(ctx->Line.Width == 1.0F);
    256          /* simple lines */
    257          USE(simple_no_z_rgba_line);
    258       }
    259    }
    260    else if (ctx->RenderMode == GL_FEEDBACK) {
    261       USE(_swrast_feedback_line);
    262    }
    263    else {
    264       assert(ctx->RenderMode == GL_SELECT);
    265       USE(_swrast_select_line);
    266    }
    267 }
    268