1 /* $Id: s_lines.c,v 1.31 2002/08/07 00:45:07 brianp Exp $ */
4 * Mesa 3-D graphics library
7 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
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:
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
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.
33 #include "s_context.h"
35 #include "s_feedback.h"
41 * Init the mask[] array to implement a line stipple.
44 compute_stipple_mask( GLcontext
*ctx
, GLuint len
, GLubyte mask
[] )
46 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
49 for (i
= 0; i
< len
; i
++) {
50 GLuint bit
= (swrast
->StippleCounter
/ ctx
->Line
.StippleFactor
) & 0xf;
51 if ((1 << bit
) & ctx
->Line
.StipplePattern
) {
57 swrast
->StippleCounter
++;
63 * To draw a wide line we can simply redraw the span N times, side by side.
66 draw_wide_line( GLcontext
*ctx
, struct sw_span
*span
, GLboolean xMajor
)
70 ASSERT(span
->end
< MAX_WIDTH
);
72 width
= (GLint
) CLAMP( ctx
->Line
.Width
, MIN_LINE_WIDTH
, MAX_LINE_WIDTH
);
77 start
= width
/ 2 - 1;
80 GLint
*y
= span
->array
->y
;
83 for (w
= 0; w
< width
; w
++) {
85 for (i
= 0; i
< span
->end
; i
++)
89 for (i
= 0; i
< span
->end
; i
++)
92 if ((span
->interpMask
| span
->arrayMask
) & SPAN_TEXTURE
)
93 _mesa_write_texture_span(ctx
, span
);
94 else if ((span
->interpMask
| span
->arrayMask
) & SPAN_RGBA
)
95 _mesa_write_rgba_span(ctx
, span
);
97 _mesa_write_index_span(ctx
, span
);
101 GLint
*x
= span
->array
->x
;
104 for (w
= 0; w
< width
; w
++) {
106 for (i
= 0; i
< span
->end
; i
++)
110 for (i
= 0; i
< span
->end
; i
++)
113 if ((span
->interpMask
| span
->arrayMask
) & SPAN_TEXTURE
)
114 _mesa_write_texture_span(ctx
, span
);
115 else if ((span
->interpMask
| span
->arrayMask
) & SPAN_RGBA
)
116 _mesa_write_rgba_span(ctx
, span
);
118 _mesa_write_index_span(ctx
, span
);
125 /**********************************************************************/
126 /***** Rasterization *****/
127 /**********************************************************************/
130 /* Flat, color index line */
131 static void flat_ci_line( GLcontext
*ctx
,
132 const SWvertex
*vert0
,
133 const SWvertex
*vert1
)
138 ASSERT(ctx
->Light
.ShadeModel
== GL_FLAT
);
139 ASSERT(!ctx
->Line
.StippleFlag
);
140 ASSERT(ctx
->Line
.Width
== 1.0F
);
142 INIT_SPAN(span
, GL_LINE
, 0, SPAN_INDEX
, SPAN_XY
);
143 span
.index
= IntToFixed(vert1
->index
);
156 #include "s_linetemp.h"
158 _mesa_write_index_span(ctx
, &span
);
162 /* Flat-shaded, RGBA line */
163 static void flat_rgba_line( GLcontext
*ctx
,
164 const SWvertex
*vert0
,
165 const SWvertex
*vert1
)
170 ASSERT(ctx
->Light
.ShadeModel
== GL_FLAT
);
171 ASSERT(!ctx
->Line
.StippleFlag
);
172 ASSERT(ctx
->Line
.Width
== 1.0F
);
174 INIT_SPAN(span
, GL_LINE
, 0, SPAN_RGBA
, SPAN_XY
);
175 span
.red
= ChanToFixed(vert1
->color
[0]);
176 span
.green
= ChanToFixed(vert1
->color
[1]);
177 span
.blue
= ChanToFixed(vert1
->color
[2]);
178 span
.alpha
= ChanToFixed(vert1
->color
[3]);
194 #include "s_linetemp.h"
196 _mesa_write_rgba_span(ctx
, &span
);
200 /* Smooth shaded, color index line */
201 static void smooth_ci_line( GLcontext
*ctx
,
202 const SWvertex
*vert0
,
203 const SWvertex
*vert1
)
209 ASSERT(ctx
->Light
.ShadeModel
== GL_SMOOTH
);
210 ASSERT(!ctx
->Line
.StippleFlag
);
211 ASSERT(ctx
->Line
.Width
== 1.0F
);
213 INIT_SPAN(span
, GL_LINE
, 0, 0, SPAN_XY
| SPAN_INDEX
);
216 index
= span
.array
->index
;
219 #define INTERP_INDEX 1
224 index[span.end] = I; \
228 #include "s_linetemp.h"
230 _mesa_write_index_span(ctx
, &span
);
234 /* Smooth-shaded, RGBA line */
235 static void smooth_rgba_line( GLcontext
*ctx
,
236 const SWvertex
*vert0
,
237 const SWvertex
*vert1
)
243 ASSERT(ctx
->Light
.ShadeModel
== GL_SMOOTH
);
244 ASSERT(!ctx
->Line
.StippleFlag
);
245 ASSERT(ctx
->Line
.Width
== 1.0F
);
247 INIT_SPAN(span
, GL_LINE
, 0, 0, SPAN_XY
| SPAN_RGBA
);
250 rgba
= span
.array
->rgba
;
254 #define INTERP_ALPHA 1
259 rgba[span.end][RCOMP] = FixedToInt(r0); \
260 rgba[span.end][GCOMP] = FixedToInt(g0); \
261 rgba[span.end][BCOMP] = FixedToInt(b0); \
262 rgba[span.end][ACOMP] = FixedToInt(a0); \
266 #include "s_linetemp.h"
268 _mesa_write_rgba_span(ctx
, &span
);
272 /* Smooth shaded, color index, any width, maybe stippled */
273 static void general_smooth_ci_line( GLcontext
*ctx
,
274 const SWvertex
*vert0
,
275 const SWvertex
*vert1
)
277 GLboolean xMajor
= GL_FALSE
;
284 ASSERT(ctx
->Light
.ShadeModel
== GL_SMOOTH
);
286 INIT_SPAN(span
, GL_LINE
, 0, 0,
287 SPAN_XY
| SPAN_Z
| SPAN_FOG
| SPAN_INDEX
);
291 fog
= span
.array
->fog
;
292 index
= span
.array
->index
;
298 #define INTERP_INDEX 1
304 fog[span.end] = fog0; \
305 index[span.end] = I; \
308 #include "s_linetemp.h"
310 if (ctx
->Line
.StippleFlag
) {
311 span
.arrayMask
|= SPAN_MASK
;
312 compute_stipple_mask(ctx
, span
.end
, span
.array
->mask
);
315 if (ctx
->Line
.Width
> 1.0) {
316 draw_wide_line(ctx
, &span
, xMajor
);
319 _mesa_write_index_span(ctx
, &span
);
324 /* Flat shaded, color index, any width, maybe stippled */
325 static void general_flat_ci_line( GLcontext
*ctx
,
326 const SWvertex
*vert0
,
327 const SWvertex
*vert1
)
329 GLboolean xMajor
= GL_FALSE
;
335 ASSERT(ctx
->Light
.ShadeModel
== GL_FLAT
);
337 INIT_SPAN(span
, GL_LINE
, 0, SPAN_INDEX
,
338 SPAN_XY
| SPAN_Z
| SPAN_FOG
);
339 span
.index
= IntToFixed(vert1
->index
);
344 fog
= span
.array
->fog
;
355 fog[span.end] = fog0; \
358 #include "s_linetemp.h"
360 if (ctx
->Line
.StippleFlag
) {
361 span
.arrayMask
|= SPAN_MASK
;
362 compute_stipple_mask(ctx
, span
.end
, span
.array
->mask
);
365 if (ctx
->Line
.Width
> 1.0) {
366 draw_wide_line(ctx
, &span
, xMajor
);
369 _mesa_write_index_span(ctx
, &span
);
375 static void general_smooth_rgba_line( GLcontext
*ctx
,
376 const SWvertex
*vert0
,
377 const SWvertex
*vert1
)
379 GLboolean xMajor
= GL_FALSE
;
386 ASSERT(ctx
->Light
.ShadeModel
== GL_SMOOTH
);
388 INIT_SPAN(span
, GL_LINE
, 0, 0,
389 SPAN_XY
| SPAN_Z
| SPAN_FOG
| SPAN_RGBA
);
393 rgba
= span
.array
->rgba
;
394 fog
= span
.array
->fog
;
401 #define INTERP_ALPHA 1
407 rgba[span.end][RCOMP] = FixedToInt(r0); \
408 rgba[span.end][GCOMP] = FixedToInt(g0); \
409 rgba[span.end][BCOMP] = FixedToInt(b0); \
410 rgba[span.end][ACOMP] = FixedToInt(a0); \
411 fog[span.end] = fog0; \
414 #include "s_linetemp.h"
416 if (ctx
->Line
.StippleFlag
) {
417 span
.arrayMask
|= SPAN_MASK
;
418 compute_stipple_mask(ctx
, span
.end
, span
.array
->mask
);
421 if (ctx
->Line
.Width
> 1.0) {
422 draw_wide_line(ctx
, &span
, xMajor
);
425 _mesa_write_rgba_span(ctx
, &span
);
430 static void general_flat_rgba_line( GLcontext
*ctx
,
431 const SWvertex
*vert0
,
432 const SWvertex
*vert1
)
434 GLboolean xMajor
= GL_FALSE
;
440 ASSERT(ctx
->Light
.ShadeModel
== GL_FLAT
);
442 INIT_SPAN(span
, GL_LINE
, 0, SPAN_RGBA
,
443 SPAN_XY
| SPAN_Z
| SPAN_FOG
);
444 span
.red
= ChanToFixed(vert1
->color
[0]);
445 span
.green
= ChanToFixed(vert1
->color
[1]);
446 span
.blue
= ChanToFixed(vert1
->color
[2]);
447 span
.alpha
= ChanToFixed(vert1
->color
[3]);
455 fog
= span
.array
->fog
;
466 fog[span.end] = fog0; \
469 #include "s_linetemp.h"
471 if (ctx
->Line
.StippleFlag
) {
472 span
.arrayMask
|= SPAN_MASK
;
473 compute_stipple_mask(ctx
, span
.end
, span
.array
->mask
);
476 if (ctx
->Line
.Width
> 1.0) {
477 draw_wide_line(ctx
, &span
, xMajor
);
480 _mesa_write_rgba_span(ctx
, &span
);
485 /* Flat-shaded, textured, any width, maybe stippled */
486 static void flat_textured_line( GLcontext
*ctx
,
487 const SWvertex
*vert0
,
488 const SWvertex
*vert1
)
490 GLboolean xMajor
= GL_FALSE
;
493 ASSERT(ctx
->Light
.ShadeModel
== GL_FLAT
);
495 INIT_SPAN(span
, GL_LINE
, 0, SPAN_RGBA
| SPAN_SPEC
,
496 SPAN_XY
| SPAN_Z
| SPAN_FOG
| SPAN_TEXTURE
| SPAN_LAMBDA
);
497 span
.red
= ChanToFixed(vert1
->color
[0]);
498 span
.green
= ChanToFixed(vert1
->color
[1]);
499 span
.blue
= ChanToFixed(vert1
->color
[2]);
500 span
.alpha
= ChanToFixed(vert1
->color
[3]);
505 span
.specRed
= ChanToFixed(vert1
->specular
[0]);
506 span
.specGreen
= ChanToFixed(vert1
->specular
[1]);
507 span
.specBlue
= ChanToFixed(vert1
->specular
[2]);
508 span
.specRedStep
= 0;
509 span
.specGreenStep
= 0;
510 span
.specBlueStep
= 0;
519 span.array->x[span.end] = X; \
520 span.array->y[span.end] = Y; \
521 span.array->z[span.end] = Z; \
522 span.array->fog[span.end] = fog0; \
523 span.array->texcoords[0][span.end][0] = fragTexcoord[0]; \
524 span.array->texcoords[0][span.end][1] = fragTexcoord[1]; \
525 span.array->texcoords[0][span.end][2] = fragTexcoord[2]; \
526 span.array->lambda[0][span.end] = 0.0; \
529 #include "s_linetemp.h"
531 if (ctx
->Line
.StippleFlag
) {
532 span
.arrayMask
|= SPAN_MASK
;
533 compute_stipple_mask(ctx
, span
.end
, span
.array
->mask
);
536 if (ctx
->Line
.Width
> 1.0) {
537 draw_wide_line(ctx
, &span
, xMajor
);
540 _mesa_write_texture_span(ctx
, &span
);
546 /* Smooth-shaded, textured, any width, maybe stippled */
547 static void smooth_textured_line( GLcontext
*ctx
,
548 const SWvertex
*vert0
,
549 const SWvertex
*vert1
)
551 GLboolean xMajor
= GL_FALSE
;
554 ASSERT(ctx
->Light
.ShadeModel
== GL_SMOOTH
);
556 INIT_SPAN(span
, GL_LINE
, 0, 0,
557 SPAN_XY
| SPAN_Z
| SPAN_FOG
| SPAN_RGBA
| SPAN_TEXTURE
| SPAN_LAMBDA
);
564 #define INTERP_ALPHA 1
568 span.array->x[span.end] = X; \
569 span.array->y[span.end] = Y; \
570 span.array->z[span.end] = Z; \
571 span.array->fog[span.end] = fog0; \
572 span.array->rgba[span.end][RCOMP] = FixedToInt(r0); \
573 span.array->rgba[span.end][GCOMP] = FixedToInt(g0); \
574 span.array->rgba[span.end][BCOMP] = FixedToInt(b0); \
575 span.array->rgba[span.end][ACOMP] = FixedToInt(a0); \
576 span.array->texcoords[0][span.end][0] = fragTexcoord[0]; \
577 span.array->texcoords[0][span.end][1] = fragTexcoord[1]; \
578 span.array->texcoords[0][span.end][2] = fragTexcoord[2]; \
579 span.array->lambda[0][span.end] = 0.0; \
582 #include "s_linetemp.h"
584 if (ctx
->Line
.StippleFlag
) {
585 span
.arrayMask
|= SPAN_MASK
;
586 compute_stipple_mask(ctx
, span
.end
, span
.array
->mask
);
589 if (ctx
->Line
.Width
> 1.0) {
590 draw_wide_line(ctx
, &span
, xMajor
);
593 _mesa_write_texture_span(ctx
, &span
);
598 /* Smooth-shaded, multitextured, any width, maybe stippled, separate specular
599 * color interpolation.
601 static void smooth_multitextured_line( GLcontext
*ctx
,
602 const SWvertex
*vert0
,
603 const SWvertex
*vert1
)
605 GLboolean xMajor
= GL_FALSE
;
609 ASSERT(ctx
->Light
.ShadeModel
== GL_SMOOTH
);
611 INIT_SPAN(span
, GL_LINE
, 0, 0,
612 SPAN_XY
| SPAN_Z
| SPAN_FOG
| SPAN_RGBA
| SPAN_SPEC
| SPAN_TEXTURE
| SPAN_LAMBDA
);
619 #define INTERP_SPEC 1
620 #define INTERP_ALPHA 1
621 #define INTERP_MULTITEX 1
624 span.array->x[span.end] = X; \
625 span.array->y[span.end] = Y; \
626 span.array->z[span.end] = Z; \
627 span.array->fog[span.end] = fog0; \
628 span.array->rgba[span.end][RCOMP] = FixedToInt(r0); \
629 span.array->rgba[span.end][GCOMP] = FixedToInt(g0); \
630 span.array->rgba[span.end][BCOMP] = FixedToInt(b0); \
631 span.array->rgba[span.end][ACOMP] = FixedToInt(a0); \
632 span.array->spec[span.end][RCOMP] = FixedToInt(sr0); \
633 span.array->spec[span.end][GCOMP] = FixedToInt(sg0); \
634 span.array->spec[span.end][BCOMP] = FixedToInt(sb0); \
635 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { \
636 if (ctx->Texture.Unit[u]._ReallyEnabled) { \
637 span.array->texcoords[u][span.end][0] = fragTexcoord[u][0]; \
638 span.array->texcoords[u][span.end][1] = fragTexcoord[u][1]; \
639 span.array->texcoords[u][span.end][2] = fragTexcoord[u][2]; \
640 span.array->lambda[u][span.end] = 0.0; \
645 #include "s_linetemp.h"
647 if (ctx
->Line
.StippleFlag
) {
648 span
.arrayMask
|= SPAN_MASK
;
649 compute_stipple_mask(ctx
, span
.end
, span
.array
->mask
);
652 if (ctx
->Line
.Width
> 1.0) {
653 draw_wide_line(ctx
, &span
, xMajor
);
656 _mesa_write_texture_span(ctx
, &span
);
661 /* Flat-shaded, multitextured, any width, maybe stippled, separate specular
662 * color interpolation.
664 static void flat_multitextured_line( GLcontext
*ctx
,
665 const SWvertex
*vert0
,
666 const SWvertex
*vert1
)
668 GLboolean xMajor
= GL_FALSE
;
672 ASSERT(ctx
->Light
.ShadeModel
== GL_FLAT
);
674 INIT_SPAN(span
, GL_LINE
, 0, SPAN_RGBA
| SPAN_SPEC
,
675 SPAN_XY
| SPAN_Z
| SPAN_FOG
| SPAN_TEXTURE
| SPAN_LAMBDA
);
676 span
.red
= ChanToFixed(vert1
->color
[0]);
677 span
.green
= ChanToFixed(vert1
->color
[1]);
678 span
.blue
= ChanToFixed(vert1
->color
[2]);
679 span
.alpha
= ChanToFixed(vert1
->color
[3]);
684 span
.specRed
= ChanToFixed(vert1
->specular
[0]);
685 span
.specGreen
= ChanToFixed(vert1
->specular
[1]);
686 span
.specBlue
= ChanToFixed(vert1
->specular
[2]);
687 span
.specRedStep
= 0;
688 span
.specGreenStep
= 0;
689 span
.specBlueStep
= 0;
695 #define INTERP_MULTITEX 1
698 span.array->x[span.end] = X; \
699 span.array->y[span.end] = Y; \
700 span.array->z[span.end] = Z; \
701 span.array->fog[span.end] = fog0; \
702 for (u = 0; u < ctx->Const.MaxTextureUnits; u++) { \
703 if (ctx->Texture.Unit[u]._ReallyEnabled) { \
704 span.array->texcoords[u][span.end][0] = fragTexcoord[u][0]; \
705 span.array->texcoords[u][span.end][1] = fragTexcoord[u][1]; \
706 span.array->texcoords[u][span.end][2] = fragTexcoord[u][2]; \
707 span.array->lambda[u][span.end] = 0.0; \
712 #include "s_linetemp.h"
714 if (ctx
->Line
.StippleFlag
) {
715 span
.arrayMask
|= SPAN_MASK
;
716 compute_stipple_mask(ctx
, span
.end
, span
.array
->mask
);
719 if (ctx
->Line
.Width
> 1.0) {
720 draw_wide_line(ctx
, &span
, xMajor
);
723 _mesa_write_texture_span(ctx
, &span
);
728 void _swrast_add_spec_terms_line( GLcontext
*ctx
,
732 SWvertex
*ncv0
= (SWvertex
*)v0
;
733 SWvertex
*ncv1
= (SWvertex
*)v1
;
735 COPY_CHAN4( c
[0], ncv0
->color
);
736 COPY_CHAN4( c
[1], ncv1
->color
);
737 ACC_3V( ncv0
->color
, ncv0
->specular
);
738 ACC_3V( ncv1
->color
, ncv1
->specular
);
739 SWRAST_CONTEXT(ctx
)->SpecLine( ctx
, ncv0
, ncv1
);
740 COPY_CHAN4( ncv0
->color
, c
[0] );
741 COPY_CHAN4( ncv1
->color
, c
[1] );
747 _mesa_print_line_function(GLcontext
*ctx
); /* silence compiler warning */
749 _mesa_print_line_function(GLcontext
*ctx
)
751 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
753 printf("Line Func == ");
754 if (swrast
->Line
== flat_ci_line
)
755 printf("flat_ci_line\n");
756 else if (swrast
->Line
== flat_rgba_line
)
757 printf("flat_rgba_line\n");
758 else if (swrast
->Line
== smooth_ci_line
)
759 printf("smooth_ci_line\n");
760 else if (swrast
->Line
== smooth_rgba_line
)
761 printf("smooth_rgba_line\n");
762 else if (swrast
->Line
== general_smooth_ci_line
)
763 printf("general_smooth_ci_line\n");
764 else if (swrast
->Line
== general_flat_ci_line
)
765 printf("general_flat_ci_line\n");
766 else if (swrast
->Line
== general_smooth_rgba_line
)
767 printf("general_smooth_rgba_line\n");
768 else if (swrast
->Line
== general_flat_rgba_line
)
769 printf("general_flat_rgba_line\n");
770 else if (swrast
->Line
== flat_textured_line
)
771 printf("flat_textured_line\n");
772 else if (swrast
->Line
== smooth_textured_line
)
773 printf("smooth_textured_line\n");
774 else if (swrast
->Line
== smooth_multitextured_line
)
775 printf("smooth_multitextured_line\n");
776 else if (swrast
->Line
== flat_multitextured_line
)
777 printf("flat_multitextured_line\n");
779 printf("Driver func %p\n", (void *) swrast
->Line
);
787 /* record the current line function name */
788 static const char *lineFuncName
= NULL
;
790 #define USE(lineFunc) \
792 lineFuncName = #lineFunc; \
793 /*printf("%s\n", lineFuncName);*/ \
794 swrast->Line = lineFunc; \
799 #define USE(lineFunc) swrast->Line = lineFunc
806 * Determine which line drawing function to use given the current
809 * Please update the summary flag _SWRAST_NEW_LINE if you add or remove
810 * tests to this code.
813 _swrast_choose_line( GLcontext
*ctx
)
815 SWcontext
*swrast
= SWRAST_CONTEXT(ctx
);
816 const GLboolean rgbmode
= ctx
->Visual
.rgbMode
;
818 if (ctx
->RenderMode
== GL_RENDER
) {
819 if (ctx
->Line
.SmoothFlag
) {
820 /* antialiased lines */
821 _swrast_choose_aa_line_function(ctx
);
822 ASSERT(swrast
->Triangle
);
824 else if (ctx
->Texture
._EnabledUnits
) {
825 if (ctx
->Texture
._EnabledUnits
> 1 ||
826 (ctx
->_TriangleCaps
& DD_SEPARATE_SPECULAR
)) {
827 /* multi-texture and/or separate specular color */
828 if (ctx
->Light
.ShadeModel
== GL_SMOOTH
)
829 USE(smooth_multitextured_line
);
831 USE(flat_multitextured_line
);
834 if (ctx
->Light
.ShadeModel
== GL_SMOOTH
) {
835 USE(smooth_textured_line
);
838 USE(flat_textured_line
);
843 if (ctx
->Light
.ShadeModel
== GL_SMOOTH
) {
844 if (ctx
->Depth
.Test
|| ctx
->Fog
.Enabled
|| ctx
->Line
.Width
!= 1.0
845 || ctx
->Line
.StippleFlag
) {
847 USE(general_smooth_rgba_line
);
849 USE(general_smooth_ci_line
);
853 USE(smooth_rgba_line
);
859 if (ctx
->Depth
.Test
|| ctx
->Fog
.Enabled
|| ctx
->Line
.Width
!= 1.0
860 || ctx
->Line
.StippleFlag
) {
862 USE(general_flat_rgba_line
);
864 USE(general_flat_ci_line
);
875 else if (ctx
->RenderMode
== GL_FEEDBACK
) {
876 USE(_mesa_feedback_line
);
879 ASSERT(ctx
->RenderMode
== GL_SELECT
);
880 USE(_mesa_select_line
);
883 /*_mesa_print_line_function(ctx);*/