• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 /*
27  * Antialiased line template.
28  */
29 
30 
31 /*
32  * Function to render each fragment in the AA line.
33  * \param ix  - integer fragment window X coordiante
34  * \param iy  - integer fragment window Y coordiante
35  */
36 static void
NAME(plot)37 NAME(plot)(struct gl_context *ctx, struct LineInfo *line, int ix, int iy)
38 {
39    const SWcontext *swrast = SWRAST_CONTEXT(ctx);
40    const GLfloat fx = (GLfloat) ix;
41    const GLfloat fy = (GLfloat) iy;
42    const GLfloat coverage = compute_coveragef(line, ix, iy);
43    const GLuint i = line->span.end;
44 
45    (void) swrast;
46 
47    if (coverage == 0.0F)
48       return;
49 
50    line->span.end++;
51    line->span.array->coverage[i] = coverage;
52    line->span.array->x[i] = ix;
53    line->span.array->y[i] = iy;
54 
55    /*
56     * Compute Z, color, texture coords, fog for the fragment by
57     * solving the plane equations at (ix,iy).
58     */
59 #ifdef DO_Z
60    line->span.array->z[i] = (GLuint) solve_plane(fx, fy, line->zPlane);
61 #endif
62    line->span.array->rgba[i][RCOMP] = solve_plane_chan(fx, fy, line->rPlane);
63    line->span.array->rgba[i][GCOMP] = solve_plane_chan(fx, fy, line->gPlane);
64    line->span.array->rgba[i][BCOMP] = solve_plane_chan(fx, fy, line->bPlane);
65    line->span.array->rgba[i][ACOMP] = solve_plane_chan(fx, fy, line->aPlane);
66 #if defined(DO_ATTRIBS)
67    ATTRIB_LOOP_BEGIN
68       GLfloat (*attribArray)[4] = line->span.array->attribs[attr];
69       if (attr >= VARYING_SLOT_TEX0 && attr < VARYING_SLOT_VAR0
70           && !_swrast_use_fragment_program(ctx)) {
71          /* texcoord w/ divide by Q */
72          const GLuint unit = attr - VARYING_SLOT_TEX0;
73          const GLfloat invQ = solve_plane_recip(fx, fy, line->attrPlane[attr][3]);
74          GLuint c;
75          for (c = 0; c < 3; c++) {
76             attribArray[i][c] = solve_plane(fx, fy, line->attrPlane[attr][c]) * invQ;
77          }
78          line->span.array->lambda[unit][i]
79             = compute_lambda(line->attrPlane[attr][0],
80                              line->attrPlane[attr][1], invQ,
81                              line->texWidth[attr], line->texHeight[attr]);
82       }
83       else {
84          /* non-texture attrib */
85          const GLfloat invW = solve_plane_recip(fx, fy, line->wPlane);
86          GLuint c;
87          for (c = 0; c < 4; c++) {
88             attribArray[i][c] = solve_plane(fx, fy, line->attrPlane[attr][c]) * invW;
89          }
90       }
91    ATTRIB_LOOP_END
92 #endif
93 
94    if (line->span.end == SWRAST_MAX_WIDTH) {
95       _swrast_write_rgba_span(ctx, &(line->span));
96       line->span.end = 0; /* reset counter */
97    }
98 }
99 
100 
101 
102 /*
103  * Line setup
104  */
105 static void
NAME(line)106 NAME(line)(struct gl_context *ctx, const SWvertex *v0, const SWvertex *v1)
107 {
108    SWcontext *swrast = SWRAST_CONTEXT(ctx);
109    GLfloat tStart, tEnd;   /* segment start, end along line length */
110    GLboolean inSegment;
111    GLint iLen, i;
112 
113    /* Init the LineInfo struct */
114    struct LineInfo line;
115    line.x0 = v0->attrib[VARYING_SLOT_POS][0];
116    line.y0 = v0->attrib[VARYING_SLOT_POS][1];
117    line.x1 = v1->attrib[VARYING_SLOT_POS][0];
118    line.y1 = v1->attrib[VARYING_SLOT_POS][1];
119    line.dx = line.x1 - line.x0;
120    line.dy = line.y1 - line.y0;
121    line.len = sqrtf(line.dx * line.dx + line.dy * line.dy);
122    line.halfWidth = 0.5F * CLAMP(ctx->Line.Width,
123                                  ctx->Const.MinLineWidthAA,
124                                  ctx->Const.MaxLineWidthAA);
125 
126    if (line.len == 0.0F || IS_INF_OR_NAN(line.len))
127       return;
128 
129    INIT_SPAN(line.span, GL_LINE);
130    line.span.arrayMask = SPAN_XY | SPAN_COVERAGE;
131    line.span.facing = swrast->PointLineFacing;
132    line.xAdj = line.dx / line.len * line.halfWidth;
133    line.yAdj = line.dy / line.len * line.halfWidth;
134 
135 #ifdef DO_Z
136    line.span.arrayMask |= SPAN_Z;
137    compute_plane(line.x0, line.y0, line.x1, line.y1,
138                  v0->attrib[VARYING_SLOT_POS][2], v1->attrib[VARYING_SLOT_POS][2], line.zPlane);
139 #endif
140    line.span.arrayMask |= SPAN_RGBA;
141    if (ctx->Light.ShadeModel == GL_SMOOTH) {
142       compute_plane(line.x0, line.y0, line.x1, line.y1,
143                     v0->color[RCOMP], v1->color[RCOMP], line.rPlane);
144       compute_plane(line.x0, line.y0, line.x1, line.y1,
145                     v0->color[GCOMP], v1->color[GCOMP], line.gPlane);
146       compute_plane(line.x0, line.y0, line.x1, line.y1,
147                     v0->color[BCOMP], v1->color[BCOMP], line.bPlane);
148       compute_plane(line.x0, line.y0, line.x1, line.y1,
149                     v0->color[ACOMP], v1->color[ACOMP], line.aPlane);
150    }
151    else {
152       constant_plane(v1->color[RCOMP], line.rPlane);
153       constant_plane(v1->color[GCOMP], line.gPlane);
154       constant_plane(v1->color[BCOMP], line.bPlane);
155       constant_plane(v1->color[ACOMP], line.aPlane);
156    }
157 #if defined(DO_ATTRIBS)
158    {
159       const GLfloat invW0 = v0->attrib[VARYING_SLOT_POS][3];
160       const GLfloat invW1 = v1->attrib[VARYING_SLOT_POS][3];
161       line.span.arrayMask |= SPAN_LAMBDA;
162       compute_plane(line.x0, line.y0, line.x1, line.y1, invW0, invW1, line.wPlane);
163       ATTRIB_LOOP_BEGIN
164          GLuint c;
165          if (swrast->_InterpMode[attr] == GL_FLAT) {
166             for (c = 0; c < 4; c++) {
167                constant_plane(v1->attrib[attr][c], line.attrPlane[attr][c]);
168             }
169          }
170          else {
171             for (c = 0; c < 4; c++) {
172                const GLfloat a0 = v0->attrib[attr][c] * invW0;
173                const GLfloat a1 = v1->attrib[attr][c] * invW1;
174                compute_plane(line.x0, line.y0, line.x1, line.y1, a0, a1,
175                              line.attrPlane[attr][c]);
176             }
177          }
178          line.span.arrayAttribs |= BITFIELD64_BIT(attr);
179          if (attr >= VARYING_SLOT_TEX0 && attr < VARYING_SLOT_VAR0) {
180             const GLuint u = attr - VARYING_SLOT_TEX0;
181             const struct gl_texture_object *obj = ctx->Texture.Unit[u]._Current;
182             const struct gl_texture_image *texImage =
183                _mesa_base_tex_image(obj);
184             line.texWidth[attr]  = (GLfloat) texImage->Width;
185             line.texHeight[attr] = (GLfloat) texImage->Height;
186          }
187       ATTRIB_LOOP_END
188    }
189 #endif
190 
191    tStart = tEnd = 0.0;
192    inSegment = GL_FALSE;
193    iLen = (GLint) line.len;
194 
195    if (ctx->Line.StippleFlag) {
196       for (i = 0; i < iLen; i++) {
197          const GLuint bit = (swrast->StippleCounter / ctx->Line.StippleFactor) & 0xf;
198          if ((1 << bit) & ctx->Line.StipplePattern) {
199             /* stipple bit is on */
200             const GLfloat t = (GLfloat) i / (GLfloat) line.len;
201             if (!inSegment) {
202                /* start new segment */
203                inSegment = GL_TRUE;
204                tStart = t;
205             }
206             else {
207                /* still in the segment, extend it */
208                tEnd = t;
209             }
210          }
211          else {
212             /* stipple bit is off */
213             if (inSegment && (tEnd > tStart)) {
214                /* draw the segment */
215                segment(ctx, &line, NAME(plot), tStart, tEnd);
216                inSegment = GL_FALSE;
217             }
218             else {
219                /* still between segments, do nothing */
220             }
221          }
222          swrast->StippleCounter++;
223       }
224 
225       if (inSegment) {
226          /* draw the final segment of the line */
227          segment(ctx, &line, NAME(plot), tStart, 1.0F);
228       }
229    }
230    else {
231       /* non-stippled */
232       segment(ctx, &line, NAME(plot), 0.0, 1.0);
233    }
234 
235    _swrast_write_rgba_span(ctx, &(line.span));
236 }
237 
238 
239 
240 
241 #undef DO_Z
242 #undef DO_ATTRIBS
243 #undef NAME
244