Replaced struct gl_visual with struct __GLcontextModesRec from glcore.h.
[mesa.git] / src / mesa / swrast / s_aatriangle.c
1 /* $Id: s_aatriangle.c,v 1.6 2001/01/23 23:39:37 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 3.5
6 *
7 * Copyright (C) 1999-2001 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 /*
29 * Antialiased Triangle rasterizers
30 */
31
32
33 #include "mmath.h"
34 #include "s_aatriangle.h"
35 #include "s_context.h"
36 #include "s_span.h"
37
38
39 /*
40 * Compute coefficients of a plane using the X,Y coords of the v0, v1, v2
41 * vertices and the given Z values.
42 */
43 static INLINE void
44 compute_plane(const GLfloat v0[], const GLfloat v1[], const GLfloat v2[],
45 GLfloat z0, GLfloat z1, GLfloat z2, GLfloat plane[4])
46 {
47 const GLfloat px = v1[0] - v0[0];
48 const GLfloat py = v1[1] - v0[1];
49 const GLfloat pz = z1 - z0;
50
51 const GLfloat qx = v2[0] - v0[0];
52 const GLfloat qy = v2[1] - v0[1];
53 const GLfloat qz = z2 - z0;
54
55 const GLfloat a = py * qz - pz * qy;
56 const GLfloat b = pz * qx - px * qz;
57 const GLfloat c = px * qy - py * qx;
58 const GLfloat d = -(a * v0[0] + b * v0[1] + c * z0);
59
60 plane[0] = a;
61 plane[1] = b;
62 plane[2] = c;
63 plane[3] = d;
64 }
65
66
67 /*
68 * Compute coefficients of a plane with a constant Z value.
69 */
70 static INLINE void
71 constant_plane(GLfloat value, GLfloat plane[4])
72 {
73 plane[0] = 0.0;
74 plane[1] = 0.0;
75 plane[2] = -1.0;
76 plane[3] = value;
77 }
78
79 #define CONSTANT_PLANE(VALUE, PLANE) \
80 do { \
81 PLANE[0] = 0.0F; \
82 PLANE[1] = 0.0F; \
83 PLANE[2] = -1.0F; \
84 PLANE[3] = VALUE; \
85 } while (0)
86
87
88
89 /*
90 * Solve plane equation for Z at (X,Y).
91 */
92 static INLINE GLfloat
93 solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])
94 {
95 GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
96 return z;
97 }
98
99
100 #define SOLVE_PLANE(X, Y, PLANE) \
101 ((PLANE[3] + PLANE[0] * (X) + PLANE[1] * (Y)) / -PLANE[2])
102
103
104 /*
105 * Return 1 / solve_plane().
106 */
107 static INLINE GLfloat
108 solve_plane_recip(GLfloat x, GLfloat y, const GLfloat plane[4])
109 {
110 GLfloat z = -plane[2] / (plane[3] + plane[0] * x + plane[1] * y);
111 return z;
112 }
113
114
115
116 /*
117 * Solve plane and return clamped GLchan value.
118 */
119 static INLINE GLchan
120 solve_plane_chan(GLfloat x, GLfloat y, const GLfloat plane[4])
121 {
122 GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2] + 0.5F;
123 if (z < 0.0F)
124 return 0;
125 else if (z > CHAN_MAXF)
126 return CHAN_MAXF;
127 return (GLchan) (GLint) z;
128 }
129
130
131
132 /*
133 * Compute how much (area) of the given pixel is inside the triangle.
134 * Vertices MUST be specified in counter-clockwise order.
135 * Return: coverage in [0, 1].
136 */
137 static GLfloat
138 compute_coveragef(const GLfloat v0[3], const GLfloat v1[3],
139 const GLfloat v2[3], GLint winx, GLint winy)
140 {
141 static const GLfloat samples[16][2] = {
142 /* start with the four corners */
143 { 0.00, 0.00 },
144 { 0.75, 0.00 },
145 { 0.00, 0.75 },
146 { 0.75, 0.75 },
147 /* continue with interior samples */
148 { 0.25, 0.00 },
149 { 0.50, 0.00 },
150 { 0.00, 0.25 },
151 { 0.25, 0.25 },
152 { 0.50, 0.25 },
153 { 0.75, 0.25 },
154 { 0.00, 0.50 },
155 { 0.25, 0.50 },
156 { 0.50, 0.50 },
157 { 0.75, 0.50 },
158 { 0.25, 0.75 },
159 { 0.50, 0.75 }
160 };
161 const GLfloat x = (GLfloat) winx;
162 const GLfloat y = (GLfloat) winy;
163 const GLfloat dx0 = v1[0] - v0[0];
164 const GLfloat dy0 = v1[1] - v0[1];
165 const GLfloat dx1 = v2[0] - v1[0];
166 const GLfloat dy1 = v2[1] - v1[1];
167 const GLfloat dx2 = v0[0] - v2[0];
168 const GLfloat dy2 = v0[1] - v2[1];
169 GLint stop = 4, i;
170 GLfloat insideCount = 16.0F;
171
172 #ifdef DEBUG
173 {
174 const GLfloat area = dx0 * dy1 - dx1 * dy0;
175 assert(area >= 0.0);
176 }
177 #endif
178
179 for (i = 0; i < stop; i++) {
180 const GLfloat sx = x + samples[i][0];
181 const GLfloat sy = y + samples[i][1];
182 const GLfloat fx0 = sx - v0[0];
183 const GLfloat fy0 = sy - v0[1];
184 const GLfloat fx1 = sx - v1[0];
185 const GLfloat fy1 = sy - v1[1];
186 const GLfloat fx2 = sx - v2[0];
187 const GLfloat fy2 = sy - v2[1];
188 /* cross product determines if sample is inside or outside each edge */
189 GLfloat cross0 = (dx0 * fy0 - dy0 * fx0);
190 GLfloat cross1 = (dx1 * fy1 - dy1 * fx1);
191 GLfloat cross2 = (dx2 * fy2 - dy2 * fx2);
192 /* Check if the sample is exactly on an edge. If so, let cross be a
193 * positive or negative value depending on the direction of the edge.
194 */
195 if (cross0 == 0.0F)
196 cross0 = dx0 + dy0;
197 if (cross1 == 0.0F)
198 cross1 = dx1 + dy1;
199 if (cross2 == 0.0F)
200 cross2 = dx2 + dy2;
201 if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F) {
202 /* point is outside triangle */
203 insideCount -= 1.0F;
204 stop = 16;
205 }
206 }
207 if (stop == 4)
208 return 1.0F;
209 else
210 return insideCount * (1.0F / 16.0F);
211 }
212
213
214
215 /*
216 * Compute how much (area) of the given pixel is inside the triangle.
217 * Vertices MUST be specified in counter-clockwise order.
218 * Return: coverage in [0, 15].
219 */
220 static GLint
221 compute_coveragei(const GLfloat v0[3], const GLfloat v1[3],
222 const GLfloat v2[3], GLint winx, GLint winy)
223 {
224 /* NOTE: 15 samples instead of 16.
225 * A better sample distribution could be used.
226 */
227 static const GLfloat samples[15][2] = {
228 /* start with the four corners */
229 { 0.00, 0.00 },
230 { 0.75, 0.00 },
231 { 0.00, 0.75 },
232 { 0.75, 0.75 },
233 /* continue with interior samples */
234 { 0.25, 0.00 },
235 { 0.50, 0.00 },
236 { 0.00, 0.25 },
237 { 0.25, 0.25 },
238 { 0.50, 0.25 },
239 { 0.75, 0.25 },
240 { 0.00, 0.50 },
241 { 0.25, 0.50 },
242 /*{ 0.50, 0.50 },*/
243 { 0.75, 0.50 },
244 { 0.25, 0.75 },
245 { 0.50, 0.75 }
246 };
247 const GLfloat x = (GLfloat) winx;
248 const GLfloat y = (GLfloat) winy;
249 const GLfloat dx0 = v1[0] - v0[0];
250 const GLfloat dy0 = v1[1] - v0[1];
251 const GLfloat dx1 = v2[0] - v1[0];
252 const GLfloat dy1 = v2[1] - v1[1];
253 const GLfloat dx2 = v0[0] - v2[0];
254 const GLfloat dy2 = v0[1] - v2[1];
255 GLint stop = 4, i;
256 GLint insideCount = 15;
257
258 #ifdef DEBUG
259 {
260 const GLfloat area = dx0 * dy1 - dx1 * dy0;
261 assert(area >= 0.0);
262 }
263 #endif
264
265 for (i = 0; i < stop; i++) {
266 const GLfloat sx = x + samples[i][0];
267 const GLfloat sy = y + samples[i][1];
268 const GLfloat fx0 = sx - v0[0];
269 const GLfloat fy0 = sy - v0[1];
270 const GLfloat fx1 = sx - v1[0];
271 const GLfloat fy1 = sy - v1[1];
272 const GLfloat fx2 = sx - v2[0];
273 const GLfloat fy2 = sy - v2[1];
274 /* cross product determines if sample is inside or outside each edge */
275 GLfloat cross0 = (dx0 * fy0 - dy0 * fx0);
276 GLfloat cross1 = (dx1 * fy1 - dy1 * fx1);
277 GLfloat cross2 = (dx2 * fy2 - dy2 * fx2);
278 /* Check if the sample is exactly on an edge. If so, let cross be a
279 * positive or negative value depending on the direction of the edge.
280 */
281 if (cross0 == 0.0F)
282 cross0 = dx0 + dy0;
283 if (cross1 == 0.0F)
284 cross1 = dx1 + dy1;
285 if (cross2 == 0.0F)
286 cross2 = dx2 + dy2;
287 if (cross0 < 0.0F || cross1 < 0.0F || cross2 < 0.0F) {
288 /* point is outside triangle */
289 insideCount--;
290 stop = 15;
291 }
292 }
293 if (stop == 4)
294 return 15;
295 else
296 return insideCount;
297 }
298
299
300
301 static void
302 rgba_aa_tri(GLcontext *ctx,
303 const SWvertex *v0,
304 const SWvertex *v1,
305 const SWvertex *v2)
306 {
307 #define DO_Z
308 #define DO_RGBA
309 #include "s_aatritemp.h"
310 }
311
312
313 static void
314 index_aa_tri(GLcontext *ctx,
315 const SWvertex *v0,
316 const SWvertex *v1,
317 const SWvertex *v2)
318 {
319 #define DO_Z
320 #define DO_INDEX
321 #include "s_aatritemp.h"
322 }
323
324
325 /*
326 * Compute mipmap level of detail.
327 */
328 static INLINE GLfloat
329 compute_lambda(const GLfloat sPlane[4], const GLfloat tPlane[4],
330 GLfloat invQ, GLfloat width, GLfloat height)
331 {
332 GLfloat dudx = sPlane[0] / sPlane[2] * invQ * width;
333 GLfloat dudy = sPlane[1] / sPlane[2] * invQ * width;
334 GLfloat dvdx = tPlane[0] / tPlane[2] * invQ * height;
335 GLfloat dvdy = tPlane[1] / tPlane[2] * invQ * height;
336 GLfloat r1 = dudx * dudx + dudy * dudy;
337 GLfloat r2 = dvdx * dvdx + dvdy * dvdy;
338 GLfloat rho2 = r1 + r2;
339 /* return log base 2 of rho */
340 return log(rho2) * 1.442695 * 0.5; /* 1.442695 = 1/log(2) */
341 }
342
343
344 static void
345 tex_aa_tri(GLcontext *ctx,
346 const SWvertex *v0,
347 const SWvertex *v1,
348 const SWvertex *v2)
349 {
350 #define DO_Z
351 #define DO_RGBA
352 #define DO_TEX
353 #include "s_aatritemp.h"
354 }
355
356
357 static void
358 spec_tex_aa_tri(GLcontext *ctx,
359 const SWvertex *v0,
360 const SWvertex *v1,
361 const SWvertex *v2)
362 {
363 #define DO_Z
364 #define DO_RGBA
365 #define DO_TEX
366 #define DO_SPEC
367 #include "s_aatritemp.h"
368 }
369
370
371 static void
372 multitex_aa_tri(GLcontext *ctx,
373 const SWvertex *v0,
374 const SWvertex *v1,
375 const SWvertex *v2)
376 {
377 #define DO_Z
378 #define DO_RGBA
379 #define DO_MULTITEX
380 #include "s_aatritemp.h"
381 }
382
383 static void
384 spec_multitex_aa_tri(GLcontext *ctx,
385 const SWvertex *v0,
386 const SWvertex *v1,
387 const SWvertex *v2)
388 {
389 #define DO_Z
390 #define DO_RGBA
391 #define DO_MULTITEX
392 #define DO_SPEC
393 #include "s_aatritemp.h"
394 }
395
396
397 /*
398 * Examine GL state and set ctx->Driver.TriangleFunc to an
399 * appropriate antialiased triangle rasterizer function.
400 */
401 void
402 _mesa_set_aa_triangle_function(GLcontext *ctx)
403 {
404 SWcontext *swrast = SWRAST_CONTEXT(ctx);
405 ASSERT(ctx->Polygon.SmoothFlag);
406
407 if (ctx->Texture._ReallyEnabled) {
408 if (ctx->Light.Enabled &&
409 (ctx->Light.Model.ColorControl == GL_SEPARATE_SPECULAR_COLOR ||
410 ctx->Fog.ColorSumEnabled)) {
411 if (swrast->_MultiTextureEnabled) {
412 SWRAST_CONTEXT(ctx)->Triangle = spec_multitex_aa_tri;
413 }
414 else {
415 SWRAST_CONTEXT(ctx)->Triangle = spec_tex_aa_tri;
416 }
417 }
418 else {
419 if (swrast->_MultiTextureEnabled) {
420 SWRAST_CONTEXT(ctx)->Triangle = multitex_aa_tri;
421 }
422 else {
423 SWRAST_CONTEXT(ctx)->Triangle = tex_aa_tri;
424 }
425 }
426 }
427 else {
428 if (ctx->Visual.rgbMode) {
429 SWRAST_CONTEXT(ctx)->Triangle = rgba_aa_tri;
430 }
431 else {
432 SWRAST_CONTEXT(ctx)->Triangle = index_aa_tri;
433 }
434 }
435 ASSERT(SWRAST_CONTEXT(ctx)->Triangle);
436 }