mirror of
https://gitlab.freedesktop.org/mesa/mesa.git
synced 2025-12-24 17:30:12 +01:00
first checkpoint commit of Klaus's new span code (struct sw_span)
This commit is contained in:
Brian Paul
parent
57d6e1aebf
commit
10f30eb438
22 changed files with 1746 additions and 1119 deletions
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: osmesa.c,v 1.71 2001/09/25 17:38:11 keithw Exp $ */
|
||||
/* $Id: osmesa.c,v 1.72 2001/12/17 04:56:29 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -55,7 +55,6 @@
|
|||
#include "swrast/s_depth.h"
|
||||
#include "swrast/s_lines.h"
|
||||
#include "swrast/s_triangle.h"
|
||||
#include "swrast/s_trispan.h"
|
||||
#include "tnl/tnl.h"
|
||||
#include "tnl/t_context.h"
|
||||
#include "tnl/t_pipeline.h"
|
||||
|
|
@ -1843,7 +1842,7 @@ static void smooth_rgba_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLchan *img = PIXELADDR4(span.x, span.y); \
|
||||
for (i = 0; i < span.count; i++, img += 4) { \
|
||||
for (i = 0; i < span.end; i++, img += 4) { \
|
||||
const GLdepth z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
PACK_RGBA(img, FixedToChan(span.red), \
|
||||
|
|
@ -1887,7 +1886,7 @@ static void flat_rgba_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLuint *img = (GLuint *) PIXELADDR4(span.x, span.y); \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const GLdepth z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
img[i] = pixel; \
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: xm_tri.c,v 1.20 2001/05/14 16:23:04 brianp Exp $ */
|
||||
/* $Id: xm_tri.c,v 1.21 2001/12/17 04:56:29 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -35,6 +35,7 @@
|
|||
#include "glxheader.h"
|
||||
#include "depth.h"
|
||||
#include "macros.h"
|
||||
#include "mem.h"
|
||||
#include "mmath.h"
|
||||
#include "mtypes.h"
|
||||
#include "xmesaP.h"
|
||||
|
|
@ -44,7 +45,6 @@
|
|||
#include "swrast/s_context.h"
|
||||
#include "swrast/s_depth.h"
|
||||
#include "swrast/s_triangle.h"
|
||||
#include "swrast/s_trispan.h"
|
||||
|
||||
|
||||
|
||||
|
|
@ -70,7 +70,7 @@ static void smooth_TRUECOLOR_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
unsigned long p; \
|
||||
|
|
@ -108,7 +108,7 @@ static void smooth_8A8B8G8R_z_triangle( GLcontext *ctx,
|
|||
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
|
||||
|
|
@ -143,7 +143,7 @@ static void smooth_8R8G8B_z_triangle( GLcontext *ctx,
|
|||
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
|
||||
|
|
@ -178,7 +178,7 @@ static void smooth_8R8G8B24_z_triangle( GLcontext *ctx,
|
|||
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
PIXEL_TYPE *ptr = pRow + i; \
|
||||
|
|
@ -214,7 +214,7 @@ static void smooth_TRUEDITHER_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
unsigned long p; \
|
||||
|
|
@ -251,7 +251,7 @@ static void smooth_5R6G5B_z_triangle( GLcontext *ctx,
|
|||
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = PACK_5R6G5B(FixedToInt(span.red), \
|
||||
|
|
@ -287,7 +287,7 @@ static void smooth_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
|
||||
|
|
@ -324,7 +324,7 @@ static void smooth_DITHER8_z_triangle( GLcontext *ctx,
|
|||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
XDITHER_SETUP(y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red),\
|
||||
|
|
@ -359,7 +359,7 @@ static void smooth_DITHER_z_triangle( GLcontext *ctx,
|
|||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
XDITHER_SETUP(y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
unsigned long p = XDITHER(x, FixedToInt(span.red), \
|
||||
|
|
@ -396,7 +396,7 @@ static void smooth_LOOKUP8_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
LOOKUP_SETUP; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = LOOKUP(FixedToInt(span.red), \
|
||||
|
|
@ -433,7 +433,7 @@ static void smooth_HPCR_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
|
||||
|
|
@ -469,7 +469,7 @@ static void flat_TRUECOLOR_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
XMesaPutPixel(img, x, y, pixel); \
|
||||
|
|
@ -501,7 +501,7 @@ static void flat_8A8B8G8R_z_triangle( GLcontext *ctx,
|
|||
v2->color[1], v2->color[2] );
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = (PIXEL_TYPE) p; \
|
||||
|
|
@ -533,7 +533,7 @@ static void flat_8R8G8B_z_triangle( GLcontext *ctx,
|
|||
v2->color[1], v2->color[2] );
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = (PIXEL_TYPE) p; \
|
||||
|
|
@ -563,7 +563,7 @@ static void flat_8R8G8B24_z_triangle( GLcontext *ctx,
|
|||
#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
PIXEL_TYPE *ptr = pRow + i; \
|
||||
|
|
@ -594,7 +594,7 @@ static void flat_TRUEDITHER_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
unsigned long p; \
|
||||
|
|
@ -629,7 +629,7 @@ static void flat_5R6G5B_z_triangle( GLcontext *ctx,
|
|||
v2->color[1], v2->color[2] );
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = (PIXEL_TYPE) p; \
|
||||
|
|
@ -660,7 +660,7 @@ static void flat_DITHER_5R6G5B_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
|
||||
|
|
@ -695,7 +695,7 @@ static void flat_DITHER8_z_triangle( GLcontext *ctx,
|
|||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y)); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
|
||||
|
|
@ -727,7 +727,7 @@ static void flat_DITHER_z_triangle( GLcontext *ctx,
|
|||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
FLAT_DITHER_ROW_SETUP(y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
unsigned long p = FLAT_DITHER(x); \
|
||||
|
|
@ -762,7 +762,7 @@ static void flat_HPCR_z_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
|
||||
|
|
@ -797,7 +797,7 @@ static void flat_LOOKUP8_z_triangle( GLcontext *ctx,
|
|||
GLubyte p = LOOKUP(r,g,b);
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
const DEPTH_TYPE z = FixedToDepth(span.z); \
|
||||
if (z < zRow[i]) { \
|
||||
pRow[i] = p; \
|
||||
|
|
@ -825,7 +825,7 @@ static void smooth_TRUECOLOR_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
unsigned long p; \
|
||||
PACK_TRUECOLOR(p, FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue)); \
|
||||
|
|
@ -854,7 +854,7 @@ static void smooth_8A8B8G8R_triangle( GLcontext *ctx,
|
|||
#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
pRow[i] = PACK_8B8G8R(FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue) ); \
|
||||
span.red += span.redStep; \
|
||||
|
|
@ -881,7 +881,7 @@ static void smooth_8R8G8B_triangle( GLcontext *ctx,
|
|||
#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
pRow[i] = PACK_8R8G8B(FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue) ); \
|
||||
span.red += span.redStep; \
|
||||
|
|
@ -909,7 +909,7 @@ static void smooth_8R8G8B24_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
PIXEL_TYPE *pixel = pRow; \
|
||||
for (i = 0; i < span.count; i++, pixel++) { \
|
||||
for (i = 0; i < span.end; i++, pixel++) { \
|
||||
pixel->r = FixedToInt(span.red); \
|
||||
pixel->g = FixedToInt(span.green); \
|
||||
pixel->b = FixedToInt(span.blue); \
|
||||
|
|
@ -936,7 +936,7 @@ static void smooth_TRUEDITHER_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
unsigned long p; \
|
||||
PACK_TRUEDITHER(p, x, y, FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue)); \
|
||||
|
|
@ -965,7 +965,7 @@ static void smooth_5R6G5B_triangle( GLcontext *ctx,
|
|||
#define BYTES_PER_ROW (xmesa->xm_buffer->backimage->bytes_per_line)
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
pRow[i] = (PIXEL_TYPE) PACK_5R6G5B(FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue)); \
|
||||
span.red += span.redStep; \
|
||||
|
|
@ -993,7 +993,7 @@ static void smooth_DITHER_5R6G5B_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
PACK_TRUEDITHER(pRow[i], x, y, FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue)); \
|
||||
span.red += span.redStep; \
|
||||
|
|
@ -1022,7 +1022,7 @@ static void smooth_DITHER8_triangle( GLcontext *ctx,
|
|||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
XDITHER_SETUP(y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
pRow[i] = (PIXEL_TYPE) XDITHER(x, FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue) ); \
|
||||
span.red += span.redStep; \
|
||||
|
|
@ -1050,7 +1050,7 @@ static void smooth_DITHER_triangle( GLcontext *ctx,
|
|||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
XDITHER_SETUP(y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
unsigned long p = XDITHER(x, FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue) ); \
|
||||
XMesaPutPixel(img, x, y, p); \
|
||||
|
|
@ -1080,7 +1080,7 @@ static void smooth_LOOKUP8_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
LOOKUP_SETUP; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
pRow[i] = LOOKUP(FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue));\
|
||||
span.red += span.redStep; \
|
||||
|
|
@ -1110,7 +1110,7 @@ static void smooth_HPCR_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
pRow[i] = DITHER_HPCR(x, y, FixedToInt(span.red), \
|
||||
FixedToInt(span.green), FixedToInt(span.blue)); \
|
||||
span.red += span.redStep; \
|
||||
|
|
@ -1139,7 +1139,7 @@ static void flat_TRUECOLOR_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
XMesaPutPixel(img, x, y, pixel); \
|
||||
}
|
||||
|
||||
|
|
@ -1164,7 +1164,7 @@ static void flat_8A8B8G8R_triangle( GLcontext *ctx,
|
|||
v2->color[1], v2->color[2] );
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
pRow[i] = (PIXEL_TYPE) p; \
|
||||
}
|
||||
|
||||
|
|
@ -1189,7 +1189,7 @@ static void flat_8R8G8B_triangle( GLcontext *ctx,
|
|||
v2->color[1], v2->color[2] );
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
pRow[i] = (PIXEL_TYPE) p; \
|
||||
}
|
||||
|
||||
|
|
@ -1213,7 +1213,7 @@ static void flat_8R8G8B24_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
PIXEL_TYPE *pixel = pRow; \
|
||||
for (i = 0; i < span.count; i++, pixel++) { \
|
||||
for (i = 0; i < span.end; i++, pixel++) { \
|
||||
pixel->r = color[RCOMP]; \
|
||||
pixel->g = color[GCOMP]; \
|
||||
pixel->b = color[BCOMP]; \
|
||||
|
|
@ -1236,7 +1236,7 @@ static void flat_TRUEDITHER_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
unsigned long p; \
|
||||
PACK_TRUEDITHER(p, x, y, v2->color[0], \
|
||||
v2->color[1], v2->color[2] ); \
|
||||
|
|
@ -1265,7 +1265,7 @@ static void flat_5R6G5B_triangle( GLcontext *ctx,
|
|||
v2->color[1], v2->color[2] );
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
pRow[i] = (PIXEL_TYPE) p; \
|
||||
}
|
||||
|
||||
|
|
@ -1289,7 +1289,7 @@ static void flat_DITHER_5R6G5B_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
PACK_TRUEDITHER(pRow[i], x, y, color[RCOMP], \
|
||||
color[GCOMP], color[BCOMP]); \
|
||||
}
|
||||
|
|
@ -1317,7 +1317,7 @@ static void flat_DITHER8_triangle( GLcontext *ctx,
|
|||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
FLAT_DITHER_ROW_SETUP(FLIP(xmesa->xm_buffer, y)); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
pRow[i] = (PIXEL_TYPE) FLAT_DITHER(x); \
|
||||
}
|
||||
|
||||
|
|
@ -1342,7 +1342,7 @@ static void flat_DITHER_triangle( GLcontext *ctx,
|
|||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
FLAT_DITHER_ROW_SETUP(y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
unsigned long p = FLAT_DITHER(x); \
|
||||
XMesaPutPixel(img, x, y, p ); \
|
||||
}
|
||||
|
|
@ -1370,7 +1370,7 @@ static void flat_HPCR_triangle( GLcontext *ctx,
|
|||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
GLint x = span.x, y = FLIP(xmesa->xm_buffer, span.y); \
|
||||
for (i = 0; i < span.count; i++, x++) { \
|
||||
for (i = 0; i < span.end; i++, x++) { \
|
||||
pRow[i] = (PIXEL_TYPE) DITHER_HPCR(x, y, r, g, b); \
|
||||
}
|
||||
|
||||
|
|
@ -1398,7 +1398,7 @@ static void flat_LOOKUP8_triangle( GLcontext *ctx,
|
|||
GLubyte p = LOOKUP(r,g,b);
|
||||
#define RENDER_SPAN( span ) \
|
||||
GLuint i; \
|
||||
for (i = 0; i < span.count; i++) { \
|
||||
for (i = 0; i < span.end; i++) { \
|
||||
pRow[i] = (PIXEL_TYPE) p; \
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_aatriangle.c,v 1.20 2001/11/13 00:26:39 brianp Exp $ */
|
||||
/* $Id: s_aatriangle.c,v 1.21 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -40,6 +40,7 @@
|
|||
/*
|
||||
* Compute coefficients of a plane using the X,Y coords of the v0, v1, v2
|
||||
* vertices and the given Z values.
|
||||
* A point (x,y,z) lies on plane iff a*x+b*y+c*z+d = 0.
|
||||
*/
|
||||
static INLINE void
|
||||
compute_plane(const GLfloat v0[], const GLfloat v1[], const GLfloat v2[],
|
||||
|
|
@ -53,9 +54,15 @@ compute_plane(const GLfloat v0[], const GLfloat v1[], const GLfloat v2[],
|
|||
const GLfloat qy = v2[1] - v0[1];
|
||||
const GLfloat qz = z2 - z0;
|
||||
|
||||
/* Crossproduct "(a,b,c):= dv1 x dv2" is orthogonal to plane. */
|
||||
const GLfloat a = py * qz - pz * qy;
|
||||
const GLfloat b = pz * qx - px * qz;
|
||||
const GLfloat c = px * qy - py * qx;
|
||||
/* Point on the plane = "r*(a,b,c) + w", with fixed "r" depending
|
||||
on the distance of plane from origin and arbitrary "w" parallel
|
||||
to the plane. */
|
||||
/* The scalar product "(r*(a,b,c)+w)*(a,b,c)" is "r*(a^2+b^2+c^2)",
|
||||
which is equal to "-d" below. */
|
||||
const GLfloat d = -(a * v0[0] + b * v0[1] + c * z0);
|
||||
|
||||
plane[0] = a;
|
||||
|
|
@ -93,8 +100,8 @@ do { \
|
|||
static INLINE GLfloat
|
||||
solve_plane(GLfloat x, GLfloat y, const GLfloat plane[4])
|
||||
{
|
||||
const GLfloat z = (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
|
||||
return z;
|
||||
ASSERT(plane[2] != 0.0F);
|
||||
return (plane[3] + plane[0] * x + plane[1] * y) / -plane[2];
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -193,7 +200,7 @@ compute_coveragef(const GLfloat v0[3], const GLfloat v1[3],
|
|||
#ifdef DEBUG
|
||||
{
|
||||
const GLfloat area = dx0 * dy1 - dx1 * dy0;
|
||||
assert(area >= 0.0);
|
||||
ASSERT(area >= 0.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -276,7 +283,7 @@ compute_coveragei(const GLfloat v0[3], const GLfloat v1[3],
|
|||
#ifdef DEBUG
|
||||
{
|
||||
const GLfloat area = dx0 * dy1 - dx1 * dy0;
|
||||
assert(area >= 0.0);
|
||||
ASSERT(area >= 0.0);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_aatritemp.h,v 1.22 2001/12/05 10:24:31 keithw Exp $ */
|
||||
/* $Id: s_aatritemp.h,v 1.23 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -52,7 +52,9 @@
|
|||
GLfloat yMin, yMax;
|
||||
GLboolean ltor;
|
||||
GLfloat majDx, majDy; /* major (i.e. long) edge dx and dy */
|
||||
|
||||
|
||||
struct sw_span span;
|
||||
|
||||
#ifdef DO_Z
|
||||
GLfloat zPlane[4];
|
||||
GLdepth z[MAX_WIDTH];
|
||||
|
|
@ -65,52 +67,29 @@
|
|||
#endif
|
||||
#ifdef DO_RGBA
|
||||
GLfloat rPlane[4], gPlane[4], bPlane[4], aPlane[4];
|
||||
DEFMARRAY(GLchan, rgba, MAX_WIDTH, 4); /* mac 32k limitation */
|
||||
#endif
|
||||
#ifdef DO_INDEX
|
||||
GLfloat iPlane[4];
|
||||
GLuint index[MAX_WIDTH];
|
||||
GLint icoverageSpan[MAX_WIDTH];
|
||||
#else
|
||||
GLfloat coverageSpan[MAX_WIDTH];
|
||||
#endif
|
||||
#ifdef DO_SPEC
|
||||
GLfloat srPlane[4], sgPlane[4], sbPlane[4];
|
||||
DEFMARRAY(GLchan, spec, MAX_WIDTH, 4);
|
||||
#endif
|
||||
#ifdef DO_TEX
|
||||
GLfloat sPlane[4], tPlane[4], uPlane[4], vPlane[4];
|
||||
GLfloat texWidth, texHeight;
|
||||
DEFARRAY(GLfloat, s, MAX_WIDTH); /* mac 32k limitation */
|
||||
DEFARRAY(GLfloat, t, MAX_WIDTH);
|
||||
DEFARRAY(GLfloat, u, MAX_WIDTH);
|
||||
DEFARRAY(GLfloat, lambda, MAX_WIDTH);
|
||||
#elif defined(DO_MULTITEX)
|
||||
GLfloat sPlane[MAX_TEXTURE_UNITS][4];
|
||||
GLfloat tPlane[MAX_TEXTURE_UNITS][4];
|
||||
GLfloat uPlane[MAX_TEXTURE_UNITS][4];
|
||||
GLfloat vPlane[MAX_TEXTURE_UNITS][4];
|
||||
GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
|
||||
DEFMARRAY(GLfloat, s, MAX_TEXTURE_UNITS, MAX_WIDTH); /* mac 32k limit */
|
||||
DEFMARRAY(GLfloat, t, MAX_TEXTURE_UNITS, MAX_WIDTH);
|
||||
DEFMARRAY(GLfloat, u, MAX_TEXTURE_UNITS, MAX_WIDTH);
|
||||
DEFMARRAY(GLfloat, lambda, MAX_TEXTURE_UNITS, MAX_WIDTH);
|
||||
#endif
|
||||
GLfloat bf = SWRAST_CONTEXT(ctx)->_backface_sign;
|
||||
|
||||
#ifdef DO_RGBA
|
||||
CHECKARRAY(rgba, return); /* mac 32k limitation */
|
||||
#endif
|
||||
#ifdef DO_SPEC
|
||||
CHECKARRAY(spec, return);
|
||||
#endif
|
||||
#if defined(DO_TEX) || defined(DO_MULTITEX)
|
||||
CHECKARRAY(s, return);
|
||||
CHECKARRAY(t, return);
|
||||
CHECKARRAY(u, return);
|
||||
CHECKARRAY(lambda, return);
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/* determine bottom to top order of vertices */
|
||||
{
|
||||
GLfloat y0 = v0->win[1];
|
||||
|
|
@ -286,6 +265,8 @@
|
|||
GLint ix, startX = (GLint) (x - xAdj);
|
||||
GLuint count, n;
|
||||
GLfloat coverage = 0.0F;
|
||||
SW_SPAN_RESET(span);
|
||||
|
||||
/* skip over fragments with zero coverage */
|
||||
while (startX < MAX_WIDTH) {
|
||||
coverage = compute_coveragef(pMin, pMid, pMax, startX, iy);
|
||||
|
|
@ -312,27 +293,27 @@
|
|||
fog[count] = solve_plane(cx, cy, fogPlane);
|
||||
#endif
|
||||
#ifdef DO_RGBA
|
||||
rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane);
|
||||
rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane);
|
||||
rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane);
|
||||
rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane);
|
||||
span.color.rgba[count][RCOMP] = solve_plane_chan(cx, cy, rPlane);
|
||||
span.color.rgba[count][GCOMP] = solve_plane_chan(cx, cy, gPlane);
|
||||
span.color.rgba[count][BCOMP] = solve_plane_chan(cx, cy, bPlane);
|
||||
span.color.rgba[count][ACOMP] = solve_plane_chan(cx, cy, aPlane);
|
||||
#endif
|
||||
#ifdef DO_INDEX
|
||||
index[count] = (GLint) solve_plane(cx, cy, iPlane);
|
||||
span.color.index[count] = (GLint) solve_plane(cx, cy, iPlane);
|
||||
#endif
|
||||
#ifdef DO_SPEC
|
||||
spec[count][RCOMP] = solve_plane_chan(cx, cy, srPlane);
|
||||
spec[count][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
|
||||
spec[count][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
|
||||
span.specular[count][RCOMP] = solve_plane_chan(cx, cy, srPlane);
|
||||
span.specular[count][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
|
||||
span.specular[count][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
|
||||
#endif
|
||||
#ifdef DO_TEX
|
||||
{
|
||||
const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
|
||||
s[count] = solve_plane(cx, cy, sPlane) * invQ;
|
||||
t[count] = solve_plane(cx, cy, tPlane) * invQ;
|
||||
u[count] = solve_plane(cx, cy, uPlane) * invQ;
|
||||
lambda[count] = compute_lambda(sPlane, tPlane, invQ,
|
||||
texWidth, texHeight);
|
||||
span.texcoords[0][count][0] = solve_plane(cx, cy, sPlane) * invQ;
|
||||
span.texcoords[0][count][1] = solve_plane(cx, cy, tPlane) * invQ;
|
||||
span.texcoords[0][count][2] = solve_plane(cx, cy, uPlane) * invQ;
|
||||
span.lambda[0][count] = compute_lambda(sPlane, tPlane, invQ,
|
||||
texWidth, texHeight);
|
||||
}
|
||||
#elif defined(DO_MULTITEX)
|
||||
{
|
||||
|
|
@ -340,11 +321,11 @@
|
|||
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
|
||||
if (ctx->Texture.Unit[unit]._ReallyEnabled) {
|
||||
GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
|
||||
s[unit][count] = solve_plane(cx, cy, sPlane[unit]) * invQ;
|
||||
t[unit][count] = solve_plane(cx, cy, tPlane[unit]) * invQ;
|
||||
u[unit][count] = solve_plane(cx, cy, uPlane[unit]) * invQ;
|
||||
lambda[unit][count] = compute_lambda(sPlane[unit],
|
||||
tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
|
||||
span.texcoords[unit][count][0] = solve_plane(cx, cy, sPlane[unit]) * invQ;
|
||||
span.texcoords[unit][count][1] = solve_plane(cx, cy, tPlane[unit]) * invQ;
|
||||
span.texcoords[unit][count][2] = solve_plane(cx, cy, uPlane[unit]) * invQ;
|
||||
span.lambda[unit][count] = compute_lambda(sPlane[unit],
|
||||
tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -353,46 +334,46 @@
|
|||
count++;
|
||||
coverage = compute_coveragef(pMin, pMid, pMax, ix, iy);
|
||||
}
|
||||
|
||||
|
||||
if (ix <= startX)
|
||||
continue;
|
||||
|
||||
|
||||
n = (GLuint) ix - (GLuint) startX;
|
||||
|
||||
#ifdef DO_MULTITEX
|
||||
# ifdef DO_SPEC
|
||||
_mesa_write_multitexture_span(ctx, n, startX, iy, z, fog,
|
||||
(const GLfloat (*)[MAX_WIDTH]) s,
|
||||
(const GLfloat (*)[MAX_WIDTH]) t,
|
||||
(const GLfloat (*)[MAX_WIDTH]) u,
|
||||
(GLfloat (*)[MAX_WIDTH]) lambda,
|
||||
rgba, (const GLchan (*)[4]) spec,
|
||||
coverageSpan, GL_POLYGON);
|
||||
_old_write_multitexture_span(ctx, n, startX, iy, z, fog,
|
||||
span.texcoords,
|
||||
span.lambda, span.color.rgba,
|
||||
span.specular,
|
||||
coverageSpan, GL_POLYGON);
|
||||
# else
|
||||
_mesa_write_multitexture_span(ctx, n, startX, iy, z, fog,
|
||||
(const GLfloat (*)[MAX_WIDTH]) s,
|
||||
(const GLfloat (*)[MAX_WIDTH]) t,
|
||||
(const GLfloat (*)[MAX_WIDTH]) u,
|
||||
lambda, rgba, NULL, coverageSpan,
|
||||
GL_POLYGON);
|
||||
_old_write_multitexture_span(ctx, n, startX, iy, z, fog,
|
||||
span.texcoords,
|
||||
span.lambda, span.color.rgba,
|
||||
NULL, coverageSpan,
|
||||
GL_POLYGON);
|
||||
# endif
|
||||
#elif defined(DO_TEX)
|
||||
# ifdef DO_SPEC
|
||||
_mesa_write_texture_span(ctx, n, startX, iy, z, fog,
|
||||
s, t, u, lambda, rgba,
|
||||
(const GLchan (*)[4]) spec,
|
||||
coverageSpan, GL_POLYGON);
|
||||
_old_write_texture_span(ctx, n, startX, iy, z, fog,
|
||||
span.texcoords[0],
|
||||
span.lambda[0], span.color.rgba,
|
||||
span.specular,
|
||||
coverageSpan, GL_POLYGON);
|
||||
# else
|
||||
_mesa_write_texture_span(ctx, n, startX, iy, z, fog,
|
||||
s, t, u, lambda,
|
||||
rgba, NULL, coverageSpan, GL_POLYGON);
|
||||
_old_write_texture_span(ctx, n, startX, iy, z, fog,
|
||||
span.texcoords[0],
|
||||
span.lambda[0],
|
||||
span.color.rgba, NULL,
|
||||
coverageSpan, GL_POLYGON);
|
||||
# endif
|
||||
#elif defined(DO_RGBA)
|
||||
_mesa_write_rgba_span(ctx, n, startX, iy, z, fog, rgba,
|
||||
coverageSpan, GL_POLYGON);
|
||||
_old_write_rgba_span(ctx, n, startX, iy, z, fog, span.color.rgba,
|
||||
coverageSpan, GL_POLYGON);
|
||||
#elif defined(DO_INDEX)
|
||||
_mesa_write_index_span(ctx, n, startX, iy, z, fog, index,
|
||||
icoverageSpan, GL_POLYGON);
|
||||
_old_write_index_span(ctx, n, startX, iy, z, fog, span.color.index,
|
||||
icoverageSpan, GL_POLYGON);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
@ -409,7 +390,7 @@
|
|||
GLint ix, left, startX = (GLint) (x + xAdj);
|
||||
GLuint count, n;
|
||||
GLfloat coverage = 0.0F;
|
||||
|
||||
|
||||
/* make sure we're not past the window edge */
|
||||
if (startX >= ctx->DrawBuffer->_Xmax) {
|
||||
startX = ctx->DrawBuffer->_Xmax - 1;
|
||||
|
|
@ -422,7 +403,7 @@
|
|||
break;
|
||||
startX--;
|
||||
}
|
||||
|
||||
|
||||
/* enter interior of triangle */
|
||||
ix = startX;
|
||||
count = 0;
|
||||
|
|
@ -441,26 +422,26 @@
|
|||
fog[ix] = solve_plane(cx, cy, fogPlane);
|
||||
#endif
|
||||
#ifdef DO_RGBA
|
||||
rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane);
|
||||
rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane);
|
||||
rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane);
|
||||
rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane);
|
||||
span.color.rgba[ix][RCOMP] = solve_plane_chan(cx, cy, rPlane);
|
||||
span.color.rgba[ix][GCOMP] = solve_plane_chan(cx, cy, gPlane);
|
||||
span.color.rgba[ix][BCOMP] = solve_plane_chan(cx, cy, bPlane);
|
||||
span.color.rgba[ix][ACOMP] = solve_plane_chan(cx, cy, aPlane);
|
||||
#endif
|
||||
#ifdef DO_INDEX
|
||||
index[ix] = (GLint) solve_plane(cx, cy, iPlane);
|
||||
span.color.index[ix] = (GLint) solve_plane(cx, cy, iPlane);
|
||||
#endif
|
||||
#ifdef DO_SPEC
|
||||
spec[ix][RCOMP] = solve_plane_chan(cx, cy, srPlane);
|
||||
spec[ix][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
|
||||
spec[ix][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
|
||||
span.specular[ix][RCOMP] = solve_plane_chan(cx, cy, srPlane);
|
||||
span.specular[ix][GCOMP] = solve_plane_chan(cx, cy, sgPlane);
|
||||
span.specular[ix][BCOMP] = solve_plane_chan(cx, cy, sbPlane);
|
||||
#endif
|
||||
#ifdef DO_TEX
|
||||
{
|
||||
const GLfloat invQ = solve_plane_recip(cx, cy, vPlane);
|
||||
s[ix] = solve_plane(cx, cy, sPlane) * invQ;
|
||||
t[ix] = solve_plane(cx, cy, tPlane) * invQ;
|
||||
u[ix] = solve_plane(cx, cy, uPlane) * invQ;
|
||||
lambda[ix] = compute_lambda(sPlane, tPlane, invQ,
|
||||
span.texcoords[0][ix][0] = solve_plane(cx, cy, sPlane) * invQ;
|
||||
span.texcoords[0][ix][1] = solve_plane(cx, cy, tPlane) * invQ;
|
||||
span.texcoords[0][ix][2] = solve_plane(cx, cy, uPlane) * invQ;
|
||||
span.lambda[0][ix] = compute_lambda(sPlane, tPlane, invQ,
|
||||
texWidth, texHeight);
|
||||
}
|
||||
#elif defined(DO_MULTITEX)
|
||||
|
|
@ -469,11 +450,14 @@
|
|||
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
|
||||
if (ctx->Texture.Unit[unit]._ReallyEnabled) {
|
||||
GLfloat invQ = solve_plane_recip(cx, cy, vPlane[unit]);
|
||||
s[unit][ix] = solve_plane(cx, cy, sPlane[unit]) * invQ;
|
||||
t[unit][ix] = solve_plane(cx, cy, tPlane[unit]) * invQ;
|
||||
u[unit][ix] = solve_plane(cx, cy, uPlane[unit]) * invQ;
|
||||
lambda[unit][ix] = compute_lambda(sPlane[unit],
|
||||
tPlane[unit], invQ, texWidth[unit], texHeight[unit]);
|
||||
span.texcoords[unit][ix][0] = solve_plane(cx, cy, sPlane[unit]) * invQ;
|
||||
span.texcoords[unit][ix][1] = solve_plane(cx, cy, tPlane[unit]) * invQ;
|
||||
span.texcoords[unit][ix][2] = solve_plane(cx, cy, uPlane[unit]) * invQ;
|
||||
span.lambda[unit][ix] = compute_lambda(sPlane[unit],
|
||||
tPlane[unit],
|
||||
invQ,
|
||||
texWidth[unit],
|
||||
texHeight[unit]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -482,7 +466,7 @@
|
|||
count++;
|
||||
coverage = compute_coveragef(pMin, pMax, pMid, ix, iy);
|
||||
}
|
||||
|
||||
|
||||
if (startX <= ix)
|
||||
continue;
|
||||
|
||||
|
|
@ -496,69 +480,55 @@
|
|||
if (ctx->Texture.Unit[unit]._ReallyEnabled) {
|
||||
GLint j;
|
||||
for (j = 0; j < (GLint) n; j++) {
|
||||
s[unit][j] = s[unit][j + left];
|
||||
t[unit][j] = t[unit][j + left];
|
||||
u[unit][j] = u[unit][j + left];
|
||||
lambda[unit][j] = lambda[unit][j + left];
|
||||
span.texcoords[unit][j][0] = span.texcoords[unit][j + left][0];
|
||||
span.texcoords[unit][j][1] = span.texcoords[unit][j + left][1];
|
||||
span.texcoords[unit][j][2] = span.texcoords[unit][j + left][2];
|
||||
span.lambda[unit][j] = span.lambda[unit][j + left];
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
# ifdef DO_SPEC
|
||||
_mesa_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
|
||||
(const GLfloat (*)[MAX_WIDTH]) s,
|
||||
(const GLfloat (*)[MAX_WIDTH]) t,
|
||||
(const GLfloat (*)[MAX_WIDTH]) u,
|
||||
lambda, rgba + left,
|
||||
(const GLchan (*)[4]) (spec + left),
|
||||
coverageSpan + left,
|
||||
GL_POLYGON);
|
||||
_old_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
|
||||
span.texcoords, span.lambda,
|
||||
span.color.rgba + left,
|
||||
span.specular + left,
|
||||
coverageSpan + left,
|
||||
GL_POLYGON);
|
||||
# else
|
||||
_mesa_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
|
||||
(const GLfloat (*)[MAX_WIDTH]) s,
|
||||
(const GLfloat (*)[MAX_WIDTH]) t,
|
||||
(const GLfloat (*)[MAX_WIDTH]) u,
|
||||
lambda,
|
||||
rgba + left, NULL, coverageSpan + left,
|
||||
GL_POLYGON);
|
||||
_old_write_multitexture_span(ctx, n, left, iy, z + left, fog + left,
|
||||
span.texcoords, span.lambda,
|
||||
span.color.rgba + left, NULL,
|
||||
coverageSpan + left,
|
||||
GL_POLYGON);
|
||||
# endif
|
||||
#elif defined(DO_TEX)
|
||||
# ifdef DO_SPEC
|
||||
_mesa_write_texture_span(ctx, n, left, iy, z + left, fog + left,
|
||||
s + left, t + left, u + left,
|
||||
lambda + left, rgba + left,
|
||||
(const GLchan (*)[4]) (spec + left),
|
||||
coverageSpan + left,
|
||||
GL_POLYGON);
|
||||
_old_write_texture_span(ctx, n, left, iy, z + left, fog + left,
|
||||
span.texcoords[0] + left,
|
||||
span.lambda[0] + left,
|
||||
span.color.rgba + left,
|
||||
span.specular + left, coverageSpan + left,
|
||||
GL_POLYGON);
|
||||
# else
|
||||
_mesa_write_texture_span(ctx, n, left, iy, z + left, fog + left,
|
||||
s + left, t + left,
|
||||
u + left, lambda + left,
|
||||
rgba + left, NULL,
|
||||
coverageSpan + left, GL_POLYGON);
|
||||
_old_write_texture_span(ctx, n, left, iy, z + left, fog + left,
|
||||
span.texcoords[0] + left,
|
||||
span.lambda[0] + left,
|
||||
span.color.rgba + left, NULL,
|
||||
coverageSpan + left, GL_POLYGON);
|
||||
# endif
|
||||
#elif defined(DO_RGBA)
|
||||
_mesa_write_rgba_span(ctx, n, left, iy, z + left, fog + left,
|
||||
rgba + left, coverageSpan + left, GL_POLYGON);
|
||||
_old_write_rgba_span(ctx, n, left, iy, z + left, fog + left,
|
||||
span.color.rgba + left, coverageSpan + left, GL_POLYGON);
|
||||
#elif defined(DO_INDEX)
|
||||
_mesa_write_index_span(ctx, n, left, iy, z + left, fog + left,
|
||||
index + left, icoverageSpan + left, GL_POLYGON);
|
||||
_old_write_index_span(ctx, n, left, iy, z + left, fog + left,
|
||||
span.color.index + left,
|
||||
icoverageSpan + left, GL_POLYGON);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef DO_RGBA
|
||||
UNDEFARRAY(rgba); /* mac 32k limitation */
|
||||
#endif
|
||||
#ifdef DO_SPEC
|
||||
UNDEFARRAY(spec);
|
||||
#endif
|
||||
#if defined(DO_TEX) || defined(DO_MULTITEX)
|
||||
UNDEFARRAY(s);
|
||||
UNDEFARRAY(t);
|
||||
UNDEFARRAY(u);
|
||||
UNDEFARRAY(lambda);
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_context.c,v 1.25 2001/07/28 19:28:49 keithw Exp $ */
|
||||
/* $Id: s_context.c,v 1.26 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -263,17 +263,15 @@ _swrast_validate_blend_func( GLcontext *ctx, GLuint n,
|
|||
static void
|
||||
_swrast_validate_texture_sample( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj,
|
||||
GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
GLuint n, GLfloat texcoords[][3],
|
||||
const GLfloat lambda[], GLchan rgba[][4] )
|
||||
{
|
||||
SWcontext *swrast = SWRAST_CONTEXT(ctx);
|
||||
|
||||
_swrast_validate_derived( ctx );
|
||||
_swrast_choose_texture_sample_func( ctx, texUnit, tObj );
|
||||
|
||||
swrast->TextureSample[texUnit]( ctx, texUnit, tObj, n, s, t, u,
|
||||
swrast->TextureSample[texUnit]( ctx, texUnit, tObj, n, texcoords,
|
||||
lambda, rgba );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_context.h,v 1.12 2001/08/14 14:08:44 brianp Exp $ */
|
||||
/* $Id: s_context.h,v 1.13 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -38,10 +38,8 @@
|
|||
*/
|
||||
typedef void (*TextureSampleFunc)( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj,
|
||||
GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLchan rgba[][4] );
|
||||
GLuint n, GLfloat texcoords[][3],
|
||||
const GLfloat lambda[], GLchan rgba[][4] );
|
||||
|
||||
|
||||
|
||||
|
|
@ -131,6 +129,7 @@ typedef struct
|
|||
GLuint NewState;
|
||||
GLuint StateChanges;
|
||||
|
||||
|
||||
/* Mechanism to allow driver (like X11) to register further
|
||||
* software rasterization routines.
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_copypix.c,v 1.25 2001/12/14 02:50:57 brianp Exp $ */
|
||||
/* $Id: s_copypix.c,v 1.26 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -268,6 +268,7 @@ copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
|
|||
|
||||
if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
|
||||
GLfloat s[MAX_WIDTH], t[MAX_WIDTH], r[MAX_WIDTH], q[MAX_WIDTH];
|
||||
GLfloat texcoord[MAX_WIDTH][3];
|
||||
GLchan primary_rgba[MAX_WIDTH][4];
|
||||
GLuint unit;
|
||||
/* XXX not sure how multitexture is supposed to work here */
|
||||
|
|
@ -275,11 +276,20 @@ copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
|
|||
MEMCPY(primary_rgba, rgba, 4 * width * sizeof(GLchan));
|
||||
|
||||
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
|
||||
GLint i;
|
||||
_mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
|
||||
s, t, r, q);
|
||||
_swrast_texture_fragments(ctx, unit, width, s, t, r, NULL,
|
||||
(CONST GLchan (*)[4]) primary_rgba,
|
||||
rgba);
|
||||
/* this is an ugly work-around. s,t,r has to be copied to
|
||||
texcoords, because the functions need different
|
||||
input. */
|
||||
for (i=0; i<width; i++) {
|
||||
texcoord[i][0] = s[i],
|
||||
texcoord[i][1] = t[i],
|
||||
texcoord[i][2] = r[i];
|
||||
}
|
||||
_old_swrast_texture_fragments( ctx, unit, width, texcoord, NULL,
|
||||
(CONST GLchan (*)[4]) primary_rgba,
|
||||
rgba);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -295,7 +305,7 @@ copy_conv_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
|
|||
(const GLchan (*)[4])rgba, desty);
|
||||
}
|
||||
else {
|
||||
_mesa_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
|
||||
_old_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
|
||||
NULL, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
|
|
@ -530,6 +540,7 @@ copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
|
|||
if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
|
||||
GLuint unit;
|
||||
GLchan primary_rgba[MAX_WIDTH][4];
|
||||
GLfloat texcoord[MAX_WIDTH][3];
|
||||
DEFARRAY(GLfloat, s, MAX_WIDTH); /* mac 32k limitation */
|
||||
DEFARRAY(GLfloat, t, MAX_WIDTH); /* mac 32k limitation */
|
||||
DEFARRAY(GLfloat, r, MAX_WIDTH); /* mac 32k limitation */
|
||||
|
|
@ -545,9 +556,17 @@ copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
|
|||
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
|
||||
_mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
|
||||
s, t, r, q);
|
||||
_swrast_texture_fragments(ctx, unit, width, s, t, r, NULL,
|
||||
(CONST GLchan (*)[4]) primary_rgba,
|
||||
rgba);
|
||||
/* this is an ugly work-around. s,t,r has to be copied to
|
||||
texcoords, because the functions need different
|
||||
input. */
|
||||
for (i=0; i<width; i++) {
|
||||
texcoord[i][0] = s[i],
|
||||
texcoord[i][1] = t[i],
|
||||
texcoord[i][2] = r[i];
|
||||
}
|
||||
_old_swrast_texture_fragments( ctx, unit, width, texcoord, NULL,
|
||||
(CONST GLchan (*)[4]) primary_rgba,
|
||||
rgba);
|
||||
}
|
||||
|
||||
UNDEFARRAY(s); /* mac 32k limitation */
|
||||
|
|
@ -565,7 +584,7 @@ copy_rgba_pixels(GLcontext *ctx, GLint srcx, GLint srcy,
|
|||
(const GLchan (*)[4])rgba, desty);
|
||||
}
|
||||
else {
|
||||
_mesa_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
|
||||
_old_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan, rgba,
|
||||
NULL, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
|
|
@ -689,7 +708,7 @@ static void copy_ci_pixels( GLcontext *ctx,
|
|||
indexes, desty );
|
||||
}
|
||||
else {
|
||||
_mesa_write_index_span(ctx, width, destx, dy, zspan, fogSpan, indexes,
|
||||
_old_write_index_span(ctx, width, destx, dy, zspan, fogSpan, indexes,
|
||||
NULL, GL_BITMAP);
|
||||
}
|
||||
}
|
||||
|
|
@ -819,7 +838,7 @@ static void copy_depth_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
|
|||
fogSpan, (const GLchan (*)[4])rgba, desty );
|
||||
}
|
||||
else {
|
||||
_mesa_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan,
|
||||
_old_write_rgba_span( ctx, width, destx, dy, zspan, fogSpan,
|
||||
(GLchan (*)[4])rgba, NULL, GL_BITMAP);
|
||||
}
|
||||
}
|
||||
|
|
@ -829,7 +848,7 @@ static void copy_depth_pixels( GLcontext *ctx, GLint srcx, GLint srcy,
|
|||
zspan, fogSpan, indexes, desty );
|
||||
}
|
||||
else {
|
||||
_mesa_write_index_span( ctx, width, destx, dy,
|
||||
_old_write_index_span( ctx, width, destx, dy,
|
||||
zspan, fogSpan, indexes, NULL, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_depth.c,v 1.9 2001/03/19 02:25:36 keithw Exp $ */
|
||||
/* $Id: s_depth.c,v 1.10 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -535,8 +535,8 @@ depth_test_span32( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
|||
* Apply depth test to span of fragments. Hardware or software z buffer.
|
||||
*/
|
||||
GLuint
|
||||
_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], GLubyte mask[] )
|
||||
_old_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], GLubyte mask[] )
|
||||
{
|
||||
SWcontext *swrast = SWRAST_CONTEXT(ctx);
|
||||
if (swrast->Driver.ReadDepthSpan) {
|
||||
|
|
@ -564,6 +564,49 @@ _mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
|||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Apply depth test to span of fragments. Hardware or software z buffer.
|
||||
*/
|
||||
GLuint
|
||||
_mesa_depth_test_span( GLcontext *ctx, struct sw_span *span)
|
||||
{
|
||||
SWcontext *swrast = SWRAST_CONTEXT(ctx);
|
||||
|
||||
ASSERT(span->activeMask & SPAN_Z);
|
||||
ASSERT(span->filledMask == GL_TRUE);
|
||||
ASSERT(span->filledDepth == GL_TRUE);
|
||||
SW_SPAN_SET_FLAG(span->testedDepth);
|
||||
|
||||
if (swrast->Driver.ReadDepthSpan) {
|
||||
/* hardware-based depth buffer */
|
||||
GLdepth zbuffer[MAX_WIDTH];
|
||||
GLuint passed;
|
||||
(*swrast->Driver.ReadDepthSpan)(ctx, span->end, span->x, span->y, zbuffer);
|
||||
passed = depth_test_span32(ctx, span->end, span->x, span->y,
|
||||
zbuffer, span->depth, span->mask);
|
||||
ASSERT(swrast->Driver.WriteDepthSpan);
|
||||
(*swrast->Driver.WriteDepthSpan)(ctx, span->end, span->x, span->y, zbuffer, span->mask);
|
||||
if (passed < span->end)
|
||||
span->write_all = GL_FALSE;
|
||||
return passed;
|
||||
}
|
||||
else {
|
||||
GLuint passed;
|
||||
/* software depth buffer */
|
||||
if (ctx->Visual.depthBits <= 16) {
|
||||
GLushort *zptr = (GLushort *) Z_ADDRESS16(ctx, span->x, span->y);
|
||||
passed = depth_test_span16(ctx, span->end, span->x, span->y, zptr, span->depth, span->mask);
|
||||
}
|
||||
else {
|
||||
GLuint *zptr = (GLuint *) Z_ADDRESS32(ctx, span->x, span->y);
|
||||
passed = depth_test_span32(ctx, span->end, span->x, span->y, zptr, span->depth, span->mask);
|
||||
}
|
||||
if (passed < span->end)
|
||||
span->write_all = GL_FALSE;
|
||||
return passed;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_depth.h,v 1.3 2001/03/12 00:48:41 gareth Exp $ */
|
||||
/* $Id: s_depth.h,v 1.4 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -38,8 +38,10 @@ _mesa_zbuffer_address(GLcontext *ctx, GLint x, GLint y);
|
|||
|
||||
|
||||
extern GLuint
|
||||
_mesa_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], GLubyte mask[] );
|
||||
_old_depth_test_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], GLubyte mask[] );
|
||||
extern GLuint
|
||||
_mesa_depth_test_span( GLcontext *ctx, struct sw_span *span);
|
||||
|
||||
extern void
|
||||
_mesa_depth_test_pixels( GLcontext *ctx,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_drawpix.c,v 1.22 2001/06/26 21:15:36 brianp Exp $ */
|
||||
/* $Id: s_drawpix.c,v 1.23 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -527,7 +527,7 @@ draw_index_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
indexes, desty);
|
||||
}
|
||||
else {
|
||||
_mesa_write_index_span(ctx, drawWidth, x, y, zspan, fogSpan, indexes,
|
||||
_old_write_index_span(ctx, drawWidth, x, y, zspan, fogSpan, indexes,
|
||||
NULL, GL_BITMAP);
|
||||
}
|
||||
}
|
||||
|
|
@ -650,7 +650,7 @@ draw_depth_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
GLint i;
|
||||
for (i = 0; i < width; i++)
|
||||
zspan[i] = zptr[i];
|
||||
_mesa_write_rgba_span(ctx, width, x, y, zspan, 0, rgba,
|
||||
_old_write_rgba_span(ctx, width, x, y, zspan, 0, rgba,
|
||||
NULL, GL_BITMAP);
|
||||
}
|
||||
}
|
||||
|
|
@ -662,7 +662,7 @@ draw_depth_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
const GLuint *zptr = (const GLuint *)
|
||||
_mesa_image_address(&ctx->Unpack, pixels, width, height,
|
||||
GL_DEPTH_COMPONENT, type, 0, row, 0);
|
||||
_mesa_write_rgba_span(ctx, width, x, y, zptr, 0, rgba,
|
||||
_old_write_rgba_span(ctx, width, x, y, zptr, 0, rgba,
|
||||
NULL, GL_BITMAP);
|
||||
}
|
||||
}
|
||||
|
|
@ -691,7 +691,7 @@ draw_depth_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
(const GLchan (*)[4]) rgba, desty);
|
||||
}
|
||||
else {
|
||||
_mesa_write_rgba_span(ctx, width, x, y, zspan, 0,
|
||||
_old_write_rgba_span(ctx, width, x, y, zspan, 0,
|
||||
rgba, NULL, GL_BITMAP);
|
||||
}
|
||||
}
|
||||
|
|
@ -701,7 +701,7 @@ draw_depth_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
ispan, GL_BITMAP);
|
||||
}
|
||||
else {
|
||||
_mesa_write_index_span(ctx, width, x, y, zspan, 0,
|
||||
_old_write_index_span(ctx, width, x, y, zspan, 0,
|
||||
ispan, NULL, GL_BITMAP);
|
||||
}
|
||||
}
|
||||
|
|
@ -839,6 +839,7 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
if (ctx->Texture._ReallyEnabled && ctx->Pixel.PixelTextureEnabled) {
|
||||
GLchan primary_rgba[MAX_WIDTH][4];
|
||||
GLuint unit;
|
||||
GLfloat texcoord[MAX_WIDTH][3];
|
||||
DEFARRAY(GLfloat, s, MAX_WIDTH); /* mac 32k limitation */
|
||||
DEFARRAY(GLfloat, t, MAX_WIDTH);
|
||||
DEFARRAY(GLfloat, r, MAX_WIDTH);
|
||||
|
|
@ -853,11 +854,21 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
|
||||
for (unit = 0; unit < ctx->Const.MaxTextureUnits; unit++) {
|
||||
if (ctx->Texture.Unit[unit]._ReallyEnabled) {
|
||||
GLint i;
|
||||
_mesa_pixeltexgen(ctx, width, (const GLchan (*)[4]) rgba,
|
||||
s, t, r, q);
|
||||
_swrast_texture_fragments(ctx, unit, width, s, t, r, NULL,
|
||||
(CONST GLchan (*)[4]) primary_rgba,
|
||||
rgba);
|
||||
/* this is an ugly work-around. s,t,r has to be
|
||||
copied to texcoords, because the functions need
|
||||
different input. */
|
||||
for (i=0; i<width; i++) {
|
||||
texcoord[i][0] = s[i],
|
||||
texcoord[i][1] = t[i],
|
||||
texcoord[i][2] = r[i];
|
||||
}
|
||||
_old_swrast_texture_fragments( ctx, unit, width,
|
||||
texcoord, NULL,
|
||||
(CONST GLchan (*)[4]) primary_rgba,
|
||||
rgba);
|
||||
}
|
||||
}
|
||||
UNDEFARRAY(s); /* mac 32k limitation */
|
||||
|
|
@ -875,7 +886,7 @@ draw_rgba_pixels( GLcontext *ctx, GLint x, GLint y,
|
|||
(CONST GLchan (*)[4]) rgba, desty);
|
||||
}
|
||||
else {
|
||||
_mesa_write_rgba_span(ctx, (GLuint) width, x, y, zspan, fogSpan,
|
||||
_old_write_rgba_span(ctx, (GLuint) width, x, y, zspan, fogSpan,
|
||||
rgba, NULL, GL_BITMAP);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_fog.c,v 1.14 2001/09/19 20:30:44 kschultz Exp $ */
|
||||
/* $Id: s_fog.c,v 1.15 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -70,6 +70,38 @@ _mesa_z_to_fogfactor(GLcontext *ctx, GLfloat z)
|
|||
|
||||
|
||||
|
||||
/*
|
||||
* Apply fog to a span of RGBA pixels.
|
||||
* Input: ctx -
|
||||
* span - where span->fog and span->fogStep have to be set.
|
||||
* red, green, blue, alpha - pixel colors
|
||||
* Output: red, green, blue, alpha - fogged pixel colors
|
||||
*/
|
||||
void
|
||||
_mesa_fog_rgba_pixels( const GLcontext *ctx, struct sw_span *span,
|
||||
GLchan rgba[][4] )
|
||||
{
|
||||
GLuint i;
|
||||
GLfloat fog = span->fog, Dfog = span->fogStep;
|
||||
GLchan rFog, gFog, bFog;
|
||||
|
||||
ASSERT(ctx->Fog.Enabled);
|
||||
ASSERT(span->activeMask & SPAN_FOG);
|
||||
ASSERT(span->filledColor == GL_TRUE);
|
||||
|
||||
UNCLAMPED_FLOAT_TO_CHAN(rFog, ctx->Fog.Color[RCOMP]);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(gFog, ctx->Fog.Color[GCOMP]);
|
||||
UNCLAMPED_FLOAT_TO_CHAN(bFog, ctx->Fog.Color[BCOMP]);
|
||||
|
||||
for (i = 0; i < span->end; i++) {
|
||||
const GLfloat one_min_fog = 1.0F - fog;
|
||||
rgba[i][RCOMP] = (GLchan) (fog * rgba[i][RCOMP] + one_min_fog * rFog);
|
||||
rgba[i][GCOMP] = (GLchan) (fog * rgba[i][GCOMP] + one_min_fog * gFog);
|
||||
rgba[i][BCOMP] = (GLchan) (fog * rgba[i][BCOMP] + one_min_fog * bFog);
|
||||
fog += Dfog;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Apply fog to an array of RGBA pixels.
|
||||
* Input: n - number of pixels
|
||||
|
|
@ -78,7 +110,7 @@ _mesa_z_to_fogfactor(GLcontext *ctx, GLfloat z)
|
|||
* Output: red, green, blue, alpha - fogged pixel colors
|
||||
*/
|
||||
void
|
||||
_mesa_fog_rgba_pixels( const GLcontext *ctx,
|
||||
_old_fog_rgba_pixels( const GLcontext *ctx,
|
||||
GLuint n,
|
||||
const GLfloat fog[],
|
||||
GLchan rgba[][4] )
|
||||
|
|
@ -100,6 +132,31 @@ _mesa_fog_rgba_pixels( const GLcontext *ctx,
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
* Apply fog to a span of color index pixels.
|
||||
* Input: ctx -
|
||||
* span - where span->fog and span->fogStep have to be set.
|
||||
* index - pixel color indexes
|
||||
* Output: index - fogged pixel color indexes
|
||||
*/
|
||||
void
|
||||
_mesa_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
|
||||
GLuint index[] )
|
||||
{
|
||||
GLuint idx = (GLuint) ctx->Fog.Index;
|
||||
GLuint i;
|
||||
GLfloat fog = span->fog, Dfog = span->fogStep;
|
||||
|
||||
ASSERT(ctx->Fog.Enabled);
|
||||
ASSERT(span->activeMask & SPAN_FOG);
|
||||
ASSERT(span->filledColor == GL_TRUE);
|
||||
|
||||
for (i = 0; i < span->end; i++) {
|
||||
const GLfloat f = CLAMP(fog, 0.0F, 1.0F);
|
||||
index[i] = (GLuint) ((GLfloat) index[i] + (1.0F - f) * idx);
|
||||
fog += Dfog;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Apply fog to an array of color index pixels.
|
||||
|
|
@ -109,7 +166,7 @@ _mesa_fog_rgba_pixels( const GLcontext *ctx,
|
|||
* Output: index - fogged pixel color indexes
|
||||
*/
|
||||
void
|
||||
_mesa_fog_ci_pixels( const GLcontext *ctx,
|
||||
_old_fog_ci_pixels( const GLcontext *ctx,
|
||||
GLuint n, const GLfloat fog[], GLuint index[] )
|
||||
{
|
||||
GLuint idx = (GLuint) ctx->Fog.Index;
|
||||
|
|
@ -263,6 +320,29 @@ compute_fog_factors_from_z( const GLcontext *ctx,
|
|||
}
|
||||
|
||||
|
||||
/*
|
||||
* Apply fog to a span of RGBA pixels.
|
||||
* Input: ctx -
|
||||
* span - where span->depth has to be filled.
|
||||
* red, green, blue, alpha - pixel colors
|
||||
* Output: red, green, blue, alpha - fogged pixel colors
|
||||
*/
|
||||
void
|
||||
_mesa_depth_fog_rgba_pixels(const GLcontext *ctx, struct sw_span *span,
|
||||
GLchan rgba[][4])
|
||||
{
|
||||
GLfloat fogFact[PB_SIZE];
|
||||
|
||||
ASSERT(ctx->Fog.Enabled);
|
||||
ASSERT(span->activeMask & SPAN_Z);
|
||||
ASSERT(span->end <= PB_SIZE);
|
||||
ASSERT(span->filledDepth == GL_TRUE);
|
||||
ASSERT(span->filledColor == GL_TRUE);
|
||||
|
||||
compute_fog_factors_from_z(ctx, span->end, span->depth, fogFact );
|
||||
_old_fog_rgba_pixels( ctx, span->end, fogFact, rgba );
|
||||
}
|
||||
|
||||
/*
|
||||
* Apply fog to an array of RGBA pixels.
|
||||
* Input: n - number of pixels
|
||||
|
|
@ -271,13 +351,37 @@ compute_fog_factors_from_z( const GLcontext *ctx,
|
|||
* Output: red, green, blue, alpha - fogged pixel colors
|
||||
*/
|
||||
void
|
||||
_mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
|
||||
_old_depth_fog_rgba_pixels( const GLcontext *ctx,
|
||||
GLuint n, const GLdepth z[], GLchan rgba[][4] )
|
||||
{
|
||||
GLfloat fogFact[PB_SIZE];
|
||||
ASSERT(n <= PB_SIZE);
|
||||
compute_fog_factors_from_z( ctx, n, z, fogFact );
|
||||
_mesa_fog_rgba_pixels( ctx, n, fogFact, rgba );
|
||||
_old_fog_rgba_pixels( ctx, n, fogFact, rgba );
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Apply fog to a span of color index pixels.
|
||||
* Input: ctx -
|
||||
* span - where span->depth has to be filled.
|
||||
* index - pixel color indexes
|
||||
* Output: index - fogged pixel color indexes
|
||||
*/
|
||||
void
|
||||
_mesa_depth_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
|
||||
GLuint index[] )
|
||||
{
|
||||
GLfloat fogFact[PB_SIZE];
|
||||
|
||||
ASSERT(ctx->Fog.Enabled);
|
||||
ASSERT(span->activeMask & SPAN_Z);
|
||||
ASSERT(span->end <= PB_SIZE);
|
||||
ASSERT(span->filledDepth == GL_TRUE);
|
||||
ASSERT(span->filledColor == GL_TRUE);
|
||||
|
||||
compute_fog_factors_from_z(ctx, span->end, span->depth, fogFact );
|
||||
_old_fog_ci_pixels( ctx, span->end, fogFact, index );
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -289,11 +393,11 @@ _mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
|
|||
* Output: index - fogged pixel color indexes
|
||||
*/
|
||||
void
|
||||
_mesa_depth_fog_ci_pixels( const GLcontext *ctx,
|
||||
_old_depth_fog_ci_pixels( const GLcontext *ctx,
|
||||
GLuint n, const GLdepth z[], GLuint index[] )
|
||||
{
|
||||
GLfloat fogFact[PB_SIZE];
|
||||
ASSERT(n <= PB_SIZE);
|
||||
compute_fog_factors_from_z( ctx, n, z, fogFact );
|
||||
_mesa_fog_ci_pixels( ctx, n, fogFact, index );
|
||||
_old_fog_ci_pixels( ctx, n, fogFact, index );
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_fog.h,v 1.5 2001/06/18 23:55:18 brianp Exp $ */
|
||||
/* $Id: s_fog.h,v 1.6 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -38,13 +38,20 @@ _mesa_z_to_fogfactor(GLcontext *ctx, GLfloat z);
|
|||
|
||||
|
||||
extern void
|
||||
_mesa_fog_rgba_pixels( const GLcontext *ctx,
|
||||
_old_fog_rgba_pixels( const GLcontext *ctx,
|
||||
GLuint n, const GLfloat fog[],
|
||||
GLchan rgba[][4] );
|
||||
extern void
|
||||
_mesa_fog_rgba_pixels( const GLcontext *ctx, struct sw_span *span,
|
||||
GLchan rgba[][4]);
|
||||
|
||||
extern void
|
||||
_mesa_fog_ci_pixels( const GLcontext *ctx,
|
||||
GLuint n, const GLfloat fog[], GLuint indx[] );
|
||||
_mesa_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
|
||||
GLuint indx[]);
|
||||
extern void
|
||||
_old_fog_ci_pixels( const GLcontext *ctx,
|
||||
GLuint n, const GLfloat fog[],
|
||||
GLuint indx[] );
|
||||
|
||||
extern void
|
||||
_mesa_win_fog_coords_from_z( const GLcontext *ctx,
|
||||
|
|
@ -53,12 +60,17 @@ _mesa_win_fog_coords_from_z( const GLcontext *ctx,
|
|||
GLfloat fogcoord[] );
|
||||
|
||||
extern void
|
||||
_mesa_depth_fog_rgba_pixels( const GLcontext *ctx,
|
||||
_mesa_depth_fog_rgba_pixels( const GLcontext *ctx, struct sw_span *span,
|
||||
GLchan rgba[][4] );
|
||||
extern void
|
||||
_old_depth_fog_rgba_pixels( const GLcontext *ctx,
|
||||
GLuint n, const GLdepth z[], GLchan rgba[][4] );
|
||||
|
||||
extern void
|
||||
_mesa_depth_fog_ci_pixels( const GLcontext *ctx,
|
||||
GLuint n, const GLdepth z[], GLuint index[] );
|
||||
|
||||
_mesa_depth_fog_ci_pixels( const GLcontext *ctx, struct sw_span *span,
|
||||
GLuint index[] );
|
||||
extern void
|
||||
_old_depth_fog_ci_pixels( const GLcontext *ctx,
|
||||
GLuint n, const GLdepth z[], GLuint index[] );
|
||||
|
||||
#endif
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_span.h,v 1.7 2001/11/19 01:18:28 brianp Exp $ */
|
||||
/* $Id: s_span.h,v 1.8 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -31,58 +31,55 @@
|
|||
|
||||
#include "mtypes.h"
|
||||
#include "swrast.h"
|
||||
#include "s_trispan.h"
|
||||
|
||||
|
||||
extern void
|
||||
_mesa_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
_old_write_index_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], const GLfloat fog[],
|
||||
GLuint index[], const GLint coverage[],
|
||||
GLenum primitive );
|
||||
|
||||
|
||||
extern void
|
||||
_mesa_write_monoindex_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], const GLfloat fog[],
|
||||
GLuint index, const GLint coverage[],
|
||||
GLenum primitive );
|
||||
|
||||
|
||||
extern void
|
||||
_mesa_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
_old_write_rgba_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], const GLfloat fog[],
|
||||
GLchan rgba[][4], const GLfloat coverage[],
|
||||
GLenum primitive );
|
||||
|
||||
void
|
||||
_mesa_write_index_span( GLcontext *ctx, struct sw_span *span,
|
||||
GLenum primitive);
|
||||
|
||||
extern void
|
||||
_mesa_write_monocolor_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], const GLfloat fog[],
|
||||
const GLchan color[4], const GLfloat coverage[],
|
||||
GLenum primitive );
|
||||
_mesa_write_monoindex_span( GLcontext *ctx, struct sw_span *span,
|
||||
GLuint index, GLenum primitive );
|
||||
|
||||
extern void
|
||||
_mesa_write_rgba_span( GLcontext *ctx, struct sw_span *span,
|
||||
GLenum primitive );
|
||||
|
||||
extern void
|
||||
_mesa_write_monocolor_span( GLcontext *ctx, struct sw_span *span,
|
||||
const GLchan color[4], GLenum primitive );
|
||||
|
||||
|
||||
extern void
|
||||
_mesa_rasterize_span(GLcontext *ctx, struct triangle_span *span);
|
||||
_mesa_rasterize_span(GLcontext *ctx, struct sw_span *span);
|
||||
|
||||
|
||||
extern void
|
||||
_mesa_write_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], const GLfloat fog[],
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], GLfloat lambda[],
|
||||
GLchan rgba[][4], CONST GLchan spec[][4],
|
||||
const GLfloat coverage[], GLenum primitive );
|
||||
_old_write_texture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], const GLfloat fog[],
|
||||
GLfloat texcoord[][3], GLfloat lambda[],
|
||||
GLchan rgba[][4], GLchan spec[][4],
|
||||
const GLfloat coverage[], GLenum primitive );
|
||||
|
||||
|
||||
extern void
|
||||
_mesa_write_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
_old_write_multitexture_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], const GLfloat fog[],
|
||||
CONST GLfloat s[MAX_TEXTURE_UNITS][MAX_WIDTH],
|
||||
CONST GLfloat t[MAX_TEXTURE_UNITS][MAX_WIDTH],
|
||||
CONST GLfloat u[MAX_TEXTURE_UNITS][MAX_WIDTH],
|
||||
GLfloat texcoord[MAX_TEXTURE_UNITS][MAX_WIDTH][3],
|
||||
GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH],
|
||||
GLchan rgba[][4], CONST GLchan spec[][4],
|
||||
GLchan rgba[][4], GLchan spec[][4],
|
||||
const GLfloat coverage[], GLenum primitive );
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_stencil.c,v 1.12 2001/05/17 20:18:45 brianp Exp $ */
|
||||
/* $Id: s_stencil.c,v 1.13 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -457,7 +457,7 @@ stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
|||
MEMCPY(oldmask, mask, n * sizeof(GLubyte));
|
||||
|
||||
/* apply the depth test */
|
||||
_mesa_depth_test_span(ctx, n, x, y, z, mask);
|
||||
_old_depth_test_span(ctx, n, x, y, z, mask);
|
||||
|
||||
/* Set the stencil pass/fail flags according to result of depth testing.
|
||||
* if oldmask[i] == 0 then
|
||||
|
|
@ -502,7 +502,7 @@ stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
|||
*
|
||||
*/
|
||||
GLboolean
|
||||
_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
_old_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], GLubyte mask[] )
|
||||
{
|
||||
SWcontext *swrast = SWRAST_CONTEXT(ctx);
|
||||
|
|
@ -536,6 +536,61 @@ _mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
|||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
* Apply stencil and depth testing to the span of pixels.
|
||||
* Both software and hardware stencil buffers are acceptable.
|
||||
* Input: n - number of pixels in the span
|
||||
* x, y - location of leftmost pixel in span
|
||||
* z - array [n] of z values
|
||||
* mask - array [n] of flags (1=test this pixel, 0=skip the pixel)
|
||||
* Output: mask - array [n] of flags (1=stencil and depth test passed)
|
||||
* Return: GL_TRUE - all fragments failed the testing
|
||||
* GL_FALSE - one or more fragments passed the testing
|
||||
*
|
||||
*/
|
||||
GLboolean
|
||||
_mesa_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span)
|
||||
{
|
||||
SWcontext *swrast = SWRAST_CONTEXT(ctx);
|
||||
|
||||
GLstencil stencilRow[MAX_WIDTH];
|
||||
GLstencil *stencil;
|
||||
GLboolean result;
|
||||
|
||||
ASSERT(ctx->Stencil.Enabled);
|
||||
ASSERT(span->end <= MAX_WIDTH);
|
||||
ASSERT(span->filledMask == GL_TRUE);
|
||||
ASSERT(span->filledDepth == GL_TRUE);
|
||||
SW_SPAN_SET_FLAG(span->testedDepth);
|
||||
|
||||
|
||||
/* Get initial stencil values */
|
||||
if (swrast->Driver.WriteStencilSpan) {
|
||||
ASSERT(swrast->Driver.ReadStencilSpan);
|
||||
/* Get stencil values from the hardware stencil buffer */
|
||||
(*swrast->Driver.ReadStencilSpan)(ctx, span->end, span->x, span->y, stencilRow);
|
||||
stencil = stencilRow;
|
||||
}
|
||||
else {
|
||||
/* software stencil buffer */
|
||||
stencil = STENCIL_ADDRESS(span->x, span->y);
|
||||
}
|
||||
|
||||
/* do all the stencil/depth testing/updating */
|
||||
result = stencil_and_ztest_span( ctx, span->end, span->x, span->y,
|
||||
span->depth, stencil, span->mask );
|
||||
|
||||
if (swrast->Driver.WriteStencilSpan) {
|
||||
/* Write updated stencil values into hardware stencil buffer */
|
||||
(swrast->Driver.WriteStencilSpan)(ctx, span->end, span->x,
|
||||
span->y, stencil, span->mask );
|
||||
}
|
||||
|
||||
span->write_all = GL_FALSE;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_stencil.h,v 1.3 2001/03/12 00:48:42 gareth Exp $ */
|
||||
/* $Id: s_stencil.h,v 1.4 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -34,8 +34,11 @@
|
|||
|
||||
|
||||
extern GLboolean
|
||||
_mesa_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
_old_stencil_and_ztest_span( GLcontext *ctx, GLuint n, GLint x, GLint y,
|
||||
const GLdepth z[], GLubyte mask[] );
|
||||
extern GLboolean
|
||||
_mesa_stencil_and_ztest_span(GLcontext *ctx, struct sw_span *span);
|
||||
|
||||
|
||||
extern GLboolean
|
||||
_mesa_stencil_and_ztest_pixels( GLcontext *ctx, GLuint n,
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_texture.c,v 1.43 2001/12/04 23:44:56 brianp Exp $ */
|
||||
/* $Id: s_texture.c,v 1.44 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -495,17 +495,14 @@ sample_1d_linear_mipmap_linear(GLcontext *ctx,
|
|||
static void
|
||||
sample_nearest_1d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLfloat texcoords[][3], const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
{
|
||||
GLuint i;
|
||||
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
|
||||
(void) t;
|
||||
(void) u;
|
||||
(void) lambda;
|
||||
for (i=0;i<n;i++) {
|
||||
sample_1d_nearest(ctx, tObj, image, s[i], rgba[i]);
|
||||
sample_1d_nearest(ctx, tObj, image, texcoords[i][0], rgba[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -514,17 +511,14 @@ sample_nearest_1d( GLcontext *ctx, GLuint texUnit,
|
|||
static void
|
||||
sample_linear_1d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLfloat texcoords[][3], const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
{
|
||||
GLuint i;
|
||||
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
|
||||
(void) t;
|
||||
(void) u;
|
||||
(void) lambda;
|
||||
for (i=0;i<n;i++) {
|
||||
sample_1d_linear(ctx, tObj, image, s[i], rgba[i]);
|
||||
sample_1d_linear(ctx, tObj, image, texcoords[i][0], rgba[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -537,42 +531,38 @@ sample_linear_1d( GLcontext *ctx, GLuint texUnit,
|
|||
static void
|
||||
sample_lambda_1d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
GLfloat texcoords[][3],
|
||||
const GLfloat lambda[], GLchan rgba[][4] )
|
||||
{
|
||||
GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
|
||||
GLuint i;
|
||||
|
||||
(void) t;
|
||||
(void) u;
|
||||
|
||||
for (i=0;i<n;i++) {
|
||||
if (lambda[i] > MinMagThresh) {
|
||||
/* minification */
|
||||
switch (tObj->MinFilter) {
|
||||
case GL_NEAREST:
|
||||
sample_1d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], rgba[i]);
|
||||
texcoords[i][0], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR:
|
||||
sample_1d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], rgba[i]);
|
||||
texcoords[i][0], rgba[i]);
|
||||
break;
|
||||
case GL_NEAREST_MIPMAP_NEAREST:
|
||||
sample_1d_nearest_mipmap_nearest(ctx, tObj, lambda[i], s[i],
|
||||
sample_1d_nearest_mipmap_nearest(ctx, tObj, lambda[i], texcoords[i][0],
|
||||
rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR_MIPMAP_NEAREST:
|
||||
sample_1d_linear_mipmap_nearest(ctx, tObj, s[i], lambda[i],
|
||||
sample_1d_linear_mipmap_nearest(ctx, tObj, texcoords[i][0], lambda[i],
|
||||
rgba[i]);
|
||||
break;
|
||||
case GL_NEAREST_MIPMAP_LINEAR:
|
||||
sample_1d_nearest_mipmap_linear(ctx, tObj, s[i], lambda[i],
|
||||
sample_1d_nearest_mipmap_linear(ctx, tObj, texcoords[i][0], lambda[i],
|
||||
rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR_MIPMAP_LINEAR:
|
||||
sample_1d_linear_mipmap_linear(ctx, tObj, s[i], lambda[i],
|
||||
sample_1d_linear_mipmap_linear(ctx, tObj, texcoords[i][0], lambda[i],
|
||||
rgba[i]);
|
||||
break;
|
||||
default:
|
||||
|
|
@ -585,11 +575,11 @@ sample_lambda_1d( GLcontext *ctx, GLuint texUnit,
|
|||
switch (tObj->MagFilter) {
|
||||
case GL_NEAREST:
|
||||
sample_1d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], rgba[i]);
|
||||
texcoords[i][0], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR:
|
||||
sample_1d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], rgba[i]);
|
||||
texcoords[i][0], rgba[i]);
|
||||
break;
|
||||
default:
|
||||
_mesa_problem(NULL, "Bad mag filter in sample_1d_texture");
|
||||
|
|
@ -847,16 +837,15 @@ sample_2d_linear_mipmap_linear(GLcontext *ctx,
|
|||
static void
|
||||
sample_nearest_2d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
GLfloat texcoords[][3],
|
||||
const GLfloat lambda[], GLchan rgba[][4] )
|
||||
{
|
||||
GLuint i;
|
||||
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
|
||||
(void) u;
|
||||
(void) lambda;
|
||||
for (i=0;i<n;i++) {
|
||||
sample_2d_nearest(ctx, tObj, image, s[i], t[i], rgba[i]);
|
||||
sample_2d_nearest(ctx, tObj, image, texcoords[i][0],
|
||||
texcoords[i][1], rgba[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -865,16 +854,15 @@ sample_nearest_2d( GLcontext *ctx, GLuint texUnit,
|
|||
static void
|
||||
sample_linear_2d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
GLfloat texcoords[][3],
|
||||
const GLfloat lambda[], GLchan rgba[][4] )
|
||||
{
|
||||
GLuint i;
|
||||
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
|
||||
(void) u;
|
||||
(void) lambda;
|
||||
for (i=0;i<n;i++) {
|
||||
sample_2d_linear(ctx, tObj, image, s[i], t[i], rgba[i]);
|
||||
sample_2d_linear(ctx, tObj, image, texcoords[i][0],
|
||||
texcoords[i][1], rgba[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -889,8 +877,8 @@ sample_linear_2d( GLcontext *ctx, GLuint texUnit,
|
|||
static void
|
||||
opt_sample_rgb_2d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj,
|
||||
GLuint n, const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLuint n, GLfloat texcoords[][3],
|
||||
const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
{
|
||||
const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
|
||||
|
|
@ -900,7 +888,6 @@ opt_sample_rgb_2d( GLcontext *ctx, GLuint texUnit,
|
|||
const GLint rowMask = img->Height - 1;
|
||||
const GLint shift = img->WidthLog2;
|
||||
GLuint k;
|
||||
(void) u;
|
||||
(void) lambda;
|
||||
ASSERT(tObj->WrapS==GL_REPEAT);
|
||||
ASSERT(tObj->WrapT==GL_REPEAT);
|
||||
|
|
@ -908,8 +895,8 @@ opt_sample_rgb_2d( GLcontext *ctx, GLuint texUnit,
|
|||
ASSERT(img->Format==GL_RGB);
|
||||
|
||||
for (k=0; k<n; k++) {
|
||||
GLint i = IFLOOR(s[k] * width) & colMask;
|
||||
GLint j = IFLOOR(t[k] * height) & rowMask;
|
||||
GLint i = IFLOOR(texcoords[k][0] * width) & colMask;
|
||||
GLint j = IFLOOR(texcoords[k][1] * height) & rowMask;
|
||||
GLint pos = (j << shift) | i;
|
||||
GLchan *texel = ((GLchan *) img->Data) + 3*pos;
|
||||
rgba[k][RCOMP] = texel[0];
|
||||
|
|
@ -929,8 +916,8 @@ opt_sample_rgb_2d( GLcontext *ctx, GLuint texUnit,
|
|||
static void
|
||||
opt_sample_rgba_2d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj,
|
||||
GLuint n, const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLuint n, GLfloat texcoords[][3],
|
||||
const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
{
|
||||
const struct gl_texture_image *img = tObj->Image[tObj->BaseLevel];
|
||||
|
|
@ -940,7 +927,6 @@ opt_sample_rgba_2d( GLcontext *ctx, GLuint texUnit,
|
|||
const GLint rowMask = img->Height - 1;
|
||||
const GLint shift = img->WidthLog2;
|
||||
GLuint i;
|
||||
(void) u;
|
||||
(void) lambda;
|
||||
ASSERT(tObj->WrapS==GL_REPEAT);
|
||||
ASSERT(tObj->WrapT==GL_REPEAT);
|
||||
|
|
@ -948,8 +934,8 @@ opt_sample_rgba_2d( GLcontext *ctx, GLuint texUnit,
|
|||
ASSERT(img->Format==GL_RGBA);
|
||||
|
||||
for (i = 0; i < n; i++) {
|
||||
const GLint col = IFLOOR(s[i] * width) & colMask;
|
||||
const GLint row = IFLOOR(t[i] * height) & rowMask;
|
||||
const GLint col = IFLOOR(texcoords[i][0] * width) & colMask;
|
||||
const GLint row = IFLOOR(texcoords[i][1] * height) & rowMask;
|
||||
const GLint pos = (row << shift) | col;
|
||||
const GLchan *texel = ((GLchan *) img->Data) + (pos << 2); /* pos*4 */
|
||||
COPY_CHAN4(rgba[i], texel);
|
||||
|
|
@ -986,14 +972,12 @@ span_is_monotonous (GLuint n, const GLfloat lambda[])
|
|||
static void
|
||||
sample_lambda_2d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj,
|
||||
GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLuint n, GLfloat texcoords[][3],
|
||||
const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
{
|
||||
const GLfloat minMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
|
||||
GLuint i;
|
||||
(void) u;
|
||||
|
||||
#ifdef DEBUG
|
||||
ASSERT (span_is_monotonous(n, lambda) == GL_TRUE);
|
||||
|
|
@ -1009,25 +993,25 @@ sample_lambda_2d( GLcontext *ctx, GLuint texUnit,
|
|||
img->Border == 0) {
|
||||
switch (img->Format) {
|
||||
case GL_RGB:
|
||||
opt_sample_rgb_2d(ctx, texUnit, tObj, n, s, t, NULL,
|
||||
opt_sample_rgb_2d(ctx, texUnit, tObj, n, texcoords,
|
||||
NULL, rgba);
|
||||
break;
|
||||
case GL_RGBA:
|
||||
opt_sample_rgba_2d(ctx, texUnit, tObj, n, s, t, NULL,
|
||||
opt_sample_rgba_2d(ctx, texUnit, tObj, n, texcoords,
|
||||
NULL, rgba);
|
||||
break;
|
||||
default:
|
||||
sample_nearest_2d(ctx, texUnit, tObj, n, s, t, NULL,
|
||||
sample_nearest_2d(ctx, texUnit, tObj, n, texcoords,
|
||||
NULL, rgba);
|
||||
}
|
||||
}
|
||||
else {
|
||||
sample_nearest_2d(ctx, texUnit, tObj, n, s, t, NULL,
|
||||
sample_nearest_2d(ctx, texUnit, tObj, n, texcoords,
|
||||
NULL, rgba);
|
||||
}
|
||||
break;
|
||||
case GL_LINEAR:
|
||||
sample_linear_2d(ctx, texUnit, tObj, n, s, t, NULL,
|
||||
sample_linear_2d(ctx, texUnit, tObj, n, texcoords,
|
||||
NULL, rgba);
|
||||
break;
|
||||
default:
|
||||
|
|
@ -1041,26 +1025,26 @@ sample_lambda_2d( GLcontext *ctx, GLuint texUnit,
|
|||
switch (tObj->MinFilter) {
|
||||
case GL_NEAREST:
|
||||
sample_2d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], t[i], rgba[i]);
|
||||
texcoords[i][0], texcoords[i][1], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR:
|
||||
sample_2d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], t[i], rgba[i]);
|
||||
texcoords[i][0], texcoords[i][1], rgba[i]);
|
||||
break;
|
||||
case GL_NEAREST_MIPMAP_NEAREST:
|
||||
sample_2d_nearest_mipmap_nearest(ctx, tObj, s[i], t[i],
|
||||
sample_2d_nearest_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR_MIPMAP_NEAREST:
|
||||
sample_2d_linear_mipmap_nearest(ctx,tObj, s[i], t[i],
|
||||
sample_2d_linear_mipmap_nearest(ctx,tObj, texcoords[i][0], texcoords[i][1],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
case GL_NEAREST_MIPMAP_LINEAR:
|
||||
sample_2d_nearest_mipmap_linear(ctx,tObj, s[i], t[i],
|
||||
sample_2d_nearest_mipmap_linear(ctx,tObj, texcoords[i][0], texcoords[i][1],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR_MIPMAP_LINEAR:
|
||||
sample_2d_linear_mipmap_linear(ctx,tObj, s[i], t[i],
|
||||
sample_2d_linear_mipmap_linear(ctx,tObj, texcoords[i][0], texcoords[i][1],
|
||||
lambda[i], rgba[i] );
|
||||
break;
|
||||
default:
|
||||
|
|
@ -1073,11 +1057,11 @@ sample_lambda_2d( GLcontext *ctx, GLuint texUnit,
|
|||
switch (tObj->MagFilter) {
|
||||
case GL_NEAREST:
|
||||
sample_2d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], t[i], rgba[i]);
|
||||
texcoords[i][0], texcoords[i][1], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR:
|
||||
sample_2d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], t[i], rgba[i] );
|
||||
texcoords[i][0], texcoords[i][1], rgba[i] );
|
||||
break;
|
||||
default:
|
||||
_mesa_problem(NULL, "Bad mag filter in sample_2d_texture");
|
||||
|
|
@ -1402,15 +1386,14 @@ sample_3d_linear_mipmap_linear(GLcontext *ctx,
|
|||
static void
|
||||
sample_nearest_3d(GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLfloat texcoords[][3], const GLfloat lambda[],
|
||||
GLchan rgba[][4])
|
||||
{
|
||||
GLuint i;
|
||||
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
|
||||
(void) lambda;
|
||||
for (i=0;i<n;i++) {
|
||||
sample_3d_nearest(ctx, tObj, image, s[i], t[i], u[i], rgba[i]);
|
||||
sample_3d_nearest(ctx, tObj, image, texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1419,15 +1402,14 @@ sample_nearest_3d(GLcontext *ctx, GLuint texUnit,
|
|||
static void
|
||||
sample_linear_3d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
GLfloat texcoords[][3],
|
||||
const GLfloat lambda[], GLchan rgba[][4] )
|
||||
{
|
||||
GLuint i;
|
||||
struct gl_texture_image *image = tObj->Image[tObj->BaseLevel];
|
||||
(void) lambda;
|
||||
for (i=0;i<n;i++) {
|
||||
sample_3d_linear(ctx, tObj, image, s[i], t[i], u[i], rgba[i]);
|
||||
sample_3d_linear(ctx, tObj, image, texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1439,8 +1421,7 @@ sample_linear_3d( GLcontext *ctx, GLuint texUnit,
|
|||
static void
|
||||
sample_lambda_3d( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLfloat texcoords[][3], const GLfloat lambda[],
|
||||
GLchan rgba[][4] )
|
||||
{
|
||||
GLuint i;
|
||||
|
|
@ -1453,26 +1434,26 @@ sample_lambda_3d( GLcontext *ctx, GLuint texUnit,
|
|||
switch (tObj->MinFilter) {
|
||||
case GL_NEAREST:
|
||||
sample_3d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], t[i], u[i], rgba[i]);
|
||||
texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR:
|
||||
sample_3d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], t[i], u[i], rgba[i]);
|
||||
texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
|
||||
break;
|
||||
case GL_NEAREST_MIPMAP_NEAREST:
|
||||
sample_3d_nearest_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
|
||||
sample_3d_nearest_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR_MIPMAP_NEAREST:
|
||||
sample_3d_linear_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
|
||||
sample_3d_linear_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
case GL_NEAREST_MIPMAP_LINEAR:
|
||||
sample_3d_nearest_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
|
||||
sample_3d_nearest_mipmap_linear(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR_MIPMAP_LINEAR:
|
||||
sample_3d_linear_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
|
||||
sample_3d_linear_mipmap_linear(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
default:
|
||||
|
|
@ -1484,11 +1465,11 @@ sample_lambda_3d( GLcontext *ctx, GLuint texUnit,
|
|||
switch (tObj->MagFilter) {
|
||||
case GL_NEAREST:
|
||||
sample_3d_nearest(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], t[i], u[i], rgba[i]);
|
||||
texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR:
|
||||
sample_3d_linear(ctx, tObj, tObj->Image[tObj->BaseLevel],
|
||||
s[i], t[i], u[i], rgba[i]);
|
||||
texcoords[i][0], texcoords[i][1], texcoords[i][2], rgba[i]);
|
||||
break;
|
||||
default:
|
||||
_mesa_problem(NULL, "Bad mag filter in sample_3d_texture");
|
||||
|
|
@ -1579,8 +1560,7 @@ choose_cube_face(const struct gl_texture_object *texObj,
|
|||
static void
|
||||
sample_nearest_cube(GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLfloat texcoords[][3], const GLfloat lambda[],
|
||||
GLchan rgba[][4])
|
||||
{
|
||||
GLuint i;
|
||||
|
|
@ -1588,7 +1568,7 @@ sample_nearest_cube(GLcontext *ctx, GLuint texUnit,
|
|||
for (i = 0; i < n; i++) {
|
||||
const struct gl_texture_image **images;
|
||||
GLfloat newS, newT;
|
||||
images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
|
||||
images = choose_cube_face(tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2], &newS, &newT);
|
||||
sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
|
||||
newS, newT, rgba[i]);
|
||||
}
|
||||
|
|
@ -1598,16 +1578,15 @@ sample_nearest_cube(GLcontext *ctx, GLuint texUnit,
|
|||
static void
|
||||
sample_linear_cube(GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLchan rgba[][4])
|
||||
GLfloat texcoords[][3],
|
||||
const GLfloat lambda[], GLchan rgba[][4])
|
||||
{
|
||||
GLuint i;
|
||||
(void) lambda;
|
||||
for (i = 0; i < n; i++) {
|
||||
const struct gl_texture_image **images;
|
||||
GLfloat newS, newT;
|
||||
images = choose_cube_face(tObj, s[i], t[i], u[i], &newS, &newT);
|
||||
images = choose_cube_face(tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2], &newS, &newT);
|
||||
sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
|
||||
newS, newT, rgba[i]);
|
||||
}
|
||||
|
|
@ -1711,8 +1690,7 @@ sample_cube_linear_mipmap_linear(GLcontext *ctx,
|
|||
static void
|
||||
sample_lambda_cube( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLfloat texcoords[][3], const GLfloat lambda[],
|
||||
GLchan rgba[][4])
|
||||
{
|
||||
GLfloat MinMagThresh = SWRAST_CONTEXT(ctx)->_MinMagThresh[texUnit];
|
||||
|
|
@ -1726,7 +1704,8 @@ sample_lambda_cube( GLcontext *ctx, GLuint texUnit,
|
|||
{
|
||||
const struct gl_texture_image **images;
|
||||
GLfloat newS, newT;
|
||||
images = choose_cube_face(tObj, s[i], t[i], u[i],
|
||||
images = choose_cube_face(tObj, texcoords[i][0],
|
||||
texcoords[i][1], texcoords[i][2],
|
||||
&newS, &newT);
|
||||
sample_2d_nearest(ctx, tObj, images[tObj->BaseLevel],
|
||||
newS, newT, rgba[i]);
|
||||
|
|
@ -1736,26 +1715,26 @@ sample_lambda_cube( GLcontext *ctx, GLuint texUnit,
|
|||
{
|
||||
const struct gl_texture_image **images;
|
||||
GLfloat newS, newT;
|
||||
images = choose_cube_face(tObj, s[i], t[i], u[i],
|
||||
images = choose_cube_face(tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
&newS, &newT);
|
||||
sample_2d_linear(ctx, tObj, images[tObj->BaseLevel],
|
||||
newS, newT, rgba[i]);
|
||||
}
|
||||
break;
|
||||
case GL_NEAREST_MIPMAP_NEAREST:
|
||||
sample_cube_nearest_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
|
||||
sample_cube_nearest_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR_MIPMAP_NEAREST:
|
||||
sample_cube_linear_mipmap_nearest(ctx, tObj, s[i], t[i], u[i],
|
||||
sample_cube_linear_mipmap_nearest(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
case GL_NEAREST_MIPMAP_LINEAR:
|
||||
sample_cube_nearest_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
|
||||
sample_cube_nearest_mipmap_linear(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
case GL_LINEAR_MIPMAP_LINEAR:
|
||||
sample_cube_linear_mipmap_linear(ctx, tObj, s[i], t[i], u[i],
|
||||
sample_cube_linear_mipmap_linear(ctx, tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
lambda[i], rgba[i]);
|
||||
break;
|
||||
default:
|
||||
|
|
@ -1766,7 +1745,7 @@ sample_lambda_cube( GLcontext *ctx, GLuint texUnit,
|
|||
/* magnification */
|
||||
const struct gl_texture_image **images;
|
||||
GLfloat newS, newT;
|
||||
images = choose_cube_face(tObj, s[i], t[i], u[i],
|
||||
images = choose_cube_face(tObj, texcoords[i][0], texcoords[i][1], texcoords[i][2],
|
||||
&newS, &newT);
|
||||
switch (tObj->MagFilter) {
|
||||
case GL_NEAREST:
|
||||
|
|
@ -1788,8 +1767,7 @@ sample_lambda_cube( GLcontext *ctx, GLuint texUnit,
|
|||
static void
|
||||
null_sample_func( GLcontext *ctx, GLuint texUnit,
|
||||
const struct gl_texture_object *tObj, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat u[], const GLfloat lambda[],
|
||||
GLfloat texcoords[][3], const GLfloat lambda[],
|
||||
GLchan rgba[][4])
|
||||
{
|
||||
}
|
||||
|
|
@ -2711,8 +2689,7 @@ apply_texture( const GLcontext *ctx,
|
|||
static void
|
||||
sample_depth_texture(const GLcontext *ctx,
|
||||
const struct gl_texture_unit *texUnit,
|
||||
GLuint n,
|
||||
const GLfloat s[], const GLfloat t[], const GLfloat r[],
|
||||
GLuint n, GLfloat texcoords[][3],
|
||||
GLchan texel[][4])
|
||||
{
|
||||
const struct gl_texture_object *texObj = texUnit->_Current;
|
||||
|
|
@ -2773,11 +2750,11 @@ sample_depth_texture(const GLcontext *ctx,
|
|||
for (i = 0; i < n; i++) {
|
||||
GLfloat depthSample;
|
||||
GLint col, row;
|
||||
COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, s[i], width, col);
|
||||
COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, t[i], height, row);
|
||||
COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, texcoords[i][0], width, col);
|
||||
COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, texcoords[i][1], height, row);
|
||||
depthSample = *((const GLfloat *) texImage->Data + row * width + col);
|
||||
if ((r[i] <= depthSample && lequal) ||
|
||||
(r[i] >= depthSample && gequal)) {
|
||||
if ((texcoords[i][2] <= depthSample && lequal) ||
|
||||
(texcoords[i][2] >= depthSample && gequal)) {
|
||||
result = CHAN_MAX;
|
||||
}
|
||||
else {
|
||||
|
|
@ -2817,8 +2794,8 @@ sample_depth_texture(const GLcontext *ctx,
|
|||
GLfloat u, v;
|
||||
GLuint useBorderTexel;
|
||||
|
||||
COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapS, s[i], u, width, i0, i1);
|
||||
COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapT, t[i], v, height,j0, j1);
|
||||
COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapS, texcoords[i][0], u, width, i0, i1);
|
||||
COMPUTE_LINEAR_TEXEL_LOCATIONS(texObj->WrapT, texcoords[i][1], v, height,j0, j1);
|
||||
|
||||
useBorderTexel = 0;
|
||||
if (texImage->Border) {
|
||||
|
|
@ -2870,8 +2847,8 @@ sample_depth_texture(const GLcontext *ctx,
|
|||
const GLfloat w11 = ( a) * ( b);
|
||||
const GLfloat depthSample = w00 * depth00 + w10 * depth10
|
||||
+ w01 * depth01 + w11 * depth11;
|
||||
if ((depthSample <= r[i] && lequal) ||
|
||||
(depthSample >= r[i] && gequal)) {
|
||||
if ((depthSample <= texcoords[i][2] && lequal) ||
|
||||
(depthSample >= texcoords[i][2] && gequal)) {
|
||||
result = ambient;
|
||||
}
|
||||
else {
|
||||
|
|
@ -2886,16 +2863,16 @@ sample_depth_texture(const GLcontext *ctx,
|
|||
const GLfloat d = (CHAN_MAXF - (GLfloat) ambient) * 0.25F;
|
||||
GLfloat luminance = CHAN_MAXF;
|
||||
if (lequal) {
|
||||
if (depth00 <= r[i]) luminance -= d;
|
||||
if (depth01 <= r[i]) luminance -= d;
|
||||
if (depth10 <= r[i]) luminance -= d;
|
||||
if (depth11 <= r[i]) luminance -= d;
|
||||
if (depth00 <= texcoords[i][2]) luminance -= d;
|
||||
if (depth01 <= texcoords[i][2]) luminance -= d;
|
||||
if (depth10 <= texcoords[i][2]) luminance -= d;
|
||||
if (depth11 <= texcoords[i][2]) luminance -= d;
|
||||
}
|
||||
else {
|
||||
if (depth00 >= r[i]) luminance -= d;
|
||||
if (depth01 >= r[i]) luminance -= d;
|
||||
if (depth10 >= r[i]) luminance -= d;
|
||||
if (depth11 >= r[i]) luminance -= d;
|
||||
if (depth00 >= texcoords[i][2]) luminance -= d;
|
||||
if (depth01 >= texcoords[i][2]) luminance -= d;
|
||||
if (depth10 >= texcoords[i][2]) luminance -= d;
|
||||
if (depth11 >= texcoords[i][2]) luminance -= d;
|
||||
}
|
||||
result = (GLchan) luminance;
|
||||
}
|
||||
|
|
@ -2934,8 +2911,7 @@ sample_depth_texture(const GLcontext *ctx,
|
|||
static void
|
||||
sample_depth_texture2(const GLcontext *ctx,
|
||||
const struct gl_texture_unit *texUnit,
|
||||
GLuint n,
|
||||
const GLfloat s[], const GLfloat t[], const GLfloat r[],
|
||||
GLuint n, GLfloat texcoords[][3],
|
||||
GLchan texel[][4])
|
||||
{
|
||||
const struct gl_texture_object *texObj = texUnit->_Current;
|
||||
|
|
@ -2981,8 +2957,10 @@ sample_depth_texture2(const GLcontext *ctx,
|
|||
GLint col, row, ii, jj, imin, imax, jmin, jmax, samples, count;
|
||||
GLfloat w;
|
||||
GLchan lum;
|
||||
COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, s[i], width, col);
|
||||
COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, t[i], height, row);
|
||||
COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapS, texcoords[i][0],
|
||||
width, col);
|
||||
COMPUTE_NEAREST_TEXEL_LOCATION(texObj->WrapT, texcoords[i][1],
|
||||
height, row);
|
||||
|
||||
imin = col - K;
|
||||
imax = col + K;
|
||||
|
|
@ -3025,20 +3003,20 @@ sample_depth_texture2(const GLcontext *ctx,
|
|||
* Apply a unit of texture mapping to the incoming fragments.
|
||||
*/
|
||||
void
|
||||
_swrast_texture_fragments( GLcontext *ctx, GLuint texUnit, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat r[], GLfloat lambda[],
|
||||
CONST GLchan primary_rgba[][4], GLchan rgba[][4] )
|
||||
_old_swrast_texture_fragments( GLcontext *ctx, GLuint texUnit, GLuint n,
|
||||
GLfloat texcoords[][3], GLfloat lambda[],
|
||||
CONST GLchan primary_rgba[][4],
|
||||
GLchan rgba[][4] )
|
||||
{
|
||||
const GLuint mask = TEXTURE0_ANY << (texUnit * 4);
|
||||
|
||||
if (ctx->Texture._ReallyEnabled & mask) {
|
||||
const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
|
||||
|
||||
|
||||
if (textureUnit->_Current) { /* XXX need this? */
|
||||
const struct gl_texture_object *curObj = textureUnit->_Current;
|
||||
GLchan texel[PB_SIZE][4];
|
||||
|
||||
|
||||
if (textureUnit->LodBias != 0.0F) {
|
||||
/* apply LOD bias, but don't clamp yet */
|
||||
GLuint i;
|
||||
|
|
@ -3046,7 +3024,7 @@ _swrast_texture_fragments( GLcontext *ctx, GLuint texUnit, GLuint n,
|
|||
lambda[i] += textureUnit->LodBias;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if ((curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0)
|
||||
&& lambda) {
|
||||
/* apply LOD clamping to lambda */
|
||||
|
|
@ -3062,13 +3040,13 @@ _swrast_texture_fragments( GLcontext *ctx, GLuint texUnit, GLuint n,
|
|||
/* Sample the texture. */
|
||||
if (curObj->Image[curObj->BaseLevel]->Format == GL_DEPTH_COMPONENT) {
|
||||
/* depth texture */
|
||||
sample_depth_texture(ctx, textureUnit, n, s, t, r, texel);
|
||||
sample_depth_texture(ctx, textureUnit, n, texcoords, texel);
|
||||
}
|
||||
else {
|
||||
/* color texture */
|
||||
SWRAST_CONTEXT(ctx)->TextureSample[texUnit]( ctx, texUnit,
|
||||
textureUnit->_Current,
|
||||
n, s, t, r,
|
||||
n, texcoords,
|
||||
lambda, texel );
|
||||
}
|
||||
apply_texture( ctx, textureUnit, n, primary_rgba,
|
||||
|
|
@ -3076,3 +3054,67 @@ _swrast_texture_fragments( GLcontext *ctx, GLuint texUnit, GLuint n,
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Apply a unit of texture mapping to the incoming fragments.
|
||||
*/
|
||||
void
|
||||
_swrast_texture_fragments( GLcontext *ctx, GLuint texUnit,
|
||||
struct sw_span *span,
|
||||
GLchan rgba[][4] )
|
||||
{
|
||||
const GLuint mask = TEXTURE0_ANY << (texUnit * 4);
|
||||
|
||||
if (ctx->Texture._ReallyEnabled & mask) {
|
||||
const struct gl_texture_unit *textureUnit = &ctx->Texture.Unit[texUnit];
|
||||
GLfloat *lambda = span->lambda[texUnit];
|
||||
|
||||
ASSERT(span->filledTex[texUnit] == GL_TRUE);
|
||||
|
||||
if (textureUnit->_Current) { /* XXX need this? */
|
||||
const struct gl_texture_object *curObj = textureUnit->_Current;
|
||||
GLchan texel[PB_SIZE][4];
|
||||
|
||||
if (textureUnit->LodBias != 0.0F) {
|
||||
/* apply LOD bias, but don't clamp yet */
|
||||
GLuint i;
|
||||
for (i=0;i<span->end;i++) {
|
||||
lambda[i] += textureUnit->LodBias;
|
||||
}
|
||||
}
|
||||
|
||||
if ((curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0)
|
||||
&& lambda) {
|
||||
/* apply LOD clamping to lambda */
|
||||
const GLfloat min = curObj->MinLod;
|
||||
const GLfloat max = curObj->MaxLod;
|
||||
GLuint i;
|
||||
for (i=0;i<span->end;i++) {
|
||||
GLfloat l = lambda[i];
|
||||
lambda[i] = CLAMP(l, min, max);
|
||||
}
|
||||
}
|
||||
|
||||
/* Sample the texture. */
|
||||
if (curObj->Image[curObj->BaseLevel]->Format == GL_DEPTH_COMPONENT) {
|
||||
/* depth texture */
|
||||
sample_depth_texture(ctx, textureUnit, span->end,
|
||||
span->texcoords[texUnit], texel);
|
||||
}
|
||||
else {
|
||||
/* color texture */
|
||||
SWRAST_CONTEXT(ctx)->TextureSample[texUnit]( ctx, texUnit,
|
||||
textureUnit->_Current,
|
||||
span->end,
|
||||
span->texcoords[texUnit],
|
||||
lambda, texel );
|
||||
}
|
||||
apply_texture( ctx, textureUnit, span->end,
|
||||
(CONST GLchan (*)[4])span->color.rgba,
|
||||
(CONST GLchan (*)[4]) texel, rgba );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_texture.h,v 1.6 2001/03/12 00:48:42 gareth Exp $ */
|
||||
/* $Id: s_texture.h,v 1.7 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -40,10 +40,14 @@ _swrast_choose_texture_sample_func( GLcontext *ctx,
|
|||
|
||||
|
||||
extern void
|
||||
_swrast_texture_fragments( GLcontext *ctx, GLuint texSet, GLuint n,
|
||||
const GLfloat s[], const GLfloat t[],
|
||||
const GLfloat r[], GLfloat lambda[],
|
||||
CONST GLchan primary_rgba[][4], GLchan rgba[][4] );
|
||||
_swrast_texture_fragments( GLcontext *ctx, GLuint texSet,
|
||||
struct sw_span *span,
|
||||
GLchan rgba[][4] );
|
||||
|
||||
extern void
|
||||
_old_swrast_texture_fragments( GLcontext *ctx, GLuint texSet, GLuint n,
|
||||
GLfloat texcoords[][3], GLfloat lambda[],
|
||||
CONST GLchan primary_rgba[][4], GLchan rgba[][4] );
|
||||
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_trispan.h,v 1.3 2001/09/13 22:12:54 brianp Exp $ */
|
||||
/* $Id: s_trispan.h,v 1.4 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -29,65 +29,4 @@
|
|||
#define S_TRISPAN_H
|
||||
|
||||
|
||||
/*
|
||||
* The triangle_span structure is used by the triangle template code in
|
||||
* s_tritemp.h. It describes how colors, Z, texcoords, etc are to be
|
||||
* interpolated across each scanline of triangle.
|
||||
* With this structure it's easy to hand-off span rasterization to a
|
||||
* subroutine instead of doing it all inline like we used to do.
|
||||
* It also cleans up the local variable namespace a great deal.
|
||||
*
|
||||
* It would be interesting to experiment with multiprocessor rasterization
|
||||
* with this structure. The triangle rasterizer could simply emit a
|
||||
* stream of these structures which would be consumed by one or more
|
||||
* span-processing threads which could run in parallel.
|
||||
*/
|
||||
|
||||
|
||||
/* When the triangle_span struct is initialized, these flags indicates
|
||||
* which values are needed for rendering the triangle.
|
||||
*/
|
||||
#define SPAN_RGBA 0x001
|
||||
#define SPAN_SPEC 0x002
|
||||
#define SPAN_INDEX 0x004
|
||||
#define SPAN_Z 0x008
|
||||
#define SPAN_FOG 0x010
|
||||
#define SPAN_TEXTURE 0x020
|
||||
#define SPAN_INT_TEXTURE 0x040
|
||||
#define SPAN_LAMBDA 0x080
|
||||
#define SPAN_FLAT 0x100 /* flat shading? */
|
||||
|
||||
|
||||
struct triangle_span {
|
||||
GLint x, y;
|
||||
GLuint count;
|
||||
GLuint activeMask; /* OR of the SPAN_* flags */
|
||||
#if CHAN_TYPE == GL_FLOAT
|
||||
GLfloat red, redStep;
|
||||
GLfloat green, greenStep;
|
||||
GLfloat blue, blueStep;
|
||||
GLfloat alpha, alphaStep;
|
||||
GLfloat specRed, specRedStep;
|
||||
GLfloat specGreen, specGreenStep;
|
||||
GLfloat specBlue, specBlueStep;
|
||||
#else
|
||||
GLfixed red, redStep;
|
||||
GLfixed green, greenStep;
|
||||
GLfixed blue, blueStep;
|
||||
GLfixed alpha, alphaStep;
|
||||
GLfixed specRed, specRedStep;
|
||||
GLfixed specGreen, specGreenStep;
|
||||
GLfixed specBlue, specBlueStep;
|
||||
#endif
|
||||
GLfixed index, indexStep;
|
||||
GLfixed z, zStep;
|
||||
GLfloat fog, fogStep;
|
||||
GLfloat tex[MAX_TEXTURE_UNITS][4], texStep[MAX_TEXTURE_UNITS][4];
|
||||
GLfixed intTex[2], intTexStep[2];
|
||||
/* Needed for texture lambda (LOD) computation */
|
||||
GLfloat rho[MAX_TEXTURE_UNITS];
|
||||
GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
|
||||
};
|
||||
|
||||
|
||||
#endif /* S_TRISPAN_H */
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_tritemp.h,v 1.28 2001/12/05 10:24:31 keithw Exp $ */
|
||||
/* $Id: s_tritemp.h,v 1.29 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -120,7 +120,7 @@
|
|||
const GLint snapMask = ~((FIXED_ONE / 16) - 1); /* for x/y coord snapping */
|
||||
GLfixed vMin_fx, vMin_fy, vMid_fx, vMid_fy, vMax_fx, vMax_fy;
|
||||
|
||||
struct triangle_span span;
|
||||
struct sw_span span;
|
||||
|
||||
#ifdef INTERP_Z
|
||||
(void) fixedToDepthShift;
|
||||
|
|
@ -1136,11 +1136,13 @@
|
|||
/* initialize the span interpolants to the leftmost value */
|
||||
/* ff = fixed-pt fragment */
|
||||
const GLint right = FixedToInt(fxRightEdge);
|
||||
SW_SPAN_RESET(span);
|
||||
span.x = FixedToInt(fxLeftEdge);
|
||||
|
||||
if (right <= span.x)
|
||||
span.count = 0;
|
||||
span.end = 0;
|
||||
else
|
||||
span.count = right - span.x;
|
||||
span.end = right - span.x;
|
||||
|
||||
#ifdef INTERP_Z
|
||||
span.z = fz;
|
||||
|
|
@ -1254,7 +1256,7 @@
|
|||
#endif
|
||||
|
||||
/* This is where we actually generate fragments */
|
||||
if (span.count > 0) {
|
||||
if (span.end > 0) {
|
||||
RENDER_SPAN( span );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: s_zoom.c,v 1.6 2001/05/15 21:30:27 brianp Exp $ */
|
||||
/* $Id: s_zoom.c,v 1.7 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -106,7 +106,7 @@ _mesa_write_zoomed_rgba_span( GLcontext *ctx,
|
|||
return;
|
||||
}
|
||||
|
||||
assert( m <= MAX_WIDTH );
|
||||
ASSERT( m <= MAX_WIDTH );
|
||||
|
||||
/* zoom the span horizontally */
|
||||
if (ctx->Pixel.ZoomX==-1.0F) {
|
||||
|
|
@ -142,7 +142,7 @@ _mesa_write_zoomed_rgba_span( GLcontext *ctx,
|
|||
|
||||
/* write the span */
|
||||
for (r=r0; r<r1; r++) {
|
||||
_mesa_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
|
||||
_old_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
|
||||
(fog ? zfog : 0), zrgba, NULL, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
|
|
@ -210,7 +210,7 @@ _mesa_write_zoomed_rgb_span( GLcontext *ctx,
|
|||
return;
|
||||
}
|
||||
|
||||
assert( m <= MAX_WIDTH );
|
||||
ASSERT( m <= MAX_WIDTH );
|
||||
|
||||
/* zoom the span horizontally */
|
||||
if (ctx->Pixel.ZoomX==-1.0F) {
|
||||
|
|
@ -252,7 +252,7 @@ _mesa_write_zoomed_rgb_span( GLcontext *ctx,
|
|||
|
||||
/* write the span */
|
||||
for (r=r0; r<r1; r++) {
|
||||
_mesa_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
|
||||
_old_write_rgba_span( ctx, m, x+skipcol, r, zdepth,
|
||||
(fog ? zfog : 0), zrgba, NULL, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
|
|
@ -323,7 +323,7 @@ _mesa_write_zoomed_index_span( GLcontext *ctx,
|
|||
return;
|
||||
}
|
||||
|
||||
assert( m <= MAX_WIDTH );
|
||||
ASSERT( m <= MAX_WIDTH );
|
||||
|
||||
/* zoom the span horizontally */
|
||||
if (ctx->Pixel.ZoomX==-1.0F) {
|
||||
|
|
@ -359,7 +359,7 @@ _mesa_write_zoomed_index_span( GLcontext *ctx,
|
|||
|
||||
/* write the span */
|
||||
for (r=r0; r<r1; r++) {
|
||||
_mesa_write_index_span( ctx, m, x+skipcol, r, zdepth,
|
||||
_old_write_index_span( ctx, m, x+skipcol, r, zdepth,
|
||||
(fog ? zfog : 0), zindexes, NULL, GL_BITMAP );
|
||||
}
|
||||
}
|
||||
|
|
@ -427,7 +427,7 @@ _mesa_write_zoomed_stencil_span( GLcontext *ctx,
|
|||
return;
|
||||
}
|
||||
|
||||
assert( m <= MAX_WIDTH );
|
||||
ASSERT( m <= MAX_WIDTH );
|
||||
|
||||
/* zoom the span horizontally */
|
||||
if (ctx->Pixel.ZoomX==-1.0F) {
|
||||
|
|
|
|||
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id: swrast.h,v 1.12 2001/03/19 02:25:36 keithw Exp $ */
|
||||
/* $Id: swrast.h,v 1.13 2001/12/17 04:54:35 brianp Exp $ */
|
||||
|
||||
/*
|
||||
* Mesa 3-D graphics library
|
||||
|
|
@ -67,6 +67,105 @@ typedef struct {
|
|||
} SWvertex;
|
||||
|
||||
|
||||
/*
|
||||
* The sw_span structure is used by the triangle template code in
|
||||
* s_tritemp.h. It describes how colors, Z, texcoords, etc are to be
|
||||
* interpolated across each scanline of triangle.
|
||||
* With this structure it's easy to hand-off span rasterization to a
|
||||
* subroutine instead of doing it all inline like we used to do.
|
||||
* It also cleans up the local variable namespace a great deal.
|
||||
*
|
||||
* It would be interesting to experiment with multiprocessor rasterization
|
||||
* with this structure. The triangle rasterizer could simply emit a
|
||||
* stream of these structures which would be consumed by one or more
|
||||
* span-processing threads which could run in parallel.
|
||||
*/
|
||||
|
||||
|
||||
/* When the sw_span struct is initialized, these flags indicates
|
||||
* which values are needed for rendering the triangle.
|
||||
*/
|
||||
#define SPAN_RGBA 0x001
|
||||
#define SPAN_SPEC 0x002
|
||||
#define SPAN_INDEX 0x004
|
||||
#define SPAN_Z 0x008
|
||||
#define SPAN_FOG 0x010
|
||||
#define SPAN_TEXTURE 0x020
|
||||
#define SPAN_INT_TEXTURE 0x040
|
||||
#define SPAN_LAMBDA 0x080
|
||||
#define SPAN_FLAT 0x100 /* flat shading? */
|
||||
|
||||
|
||||
struct sw_span {
|
||||
GLint x, y;
|
||||
GLuint start, end; /* start=first pixel in span, end=last pixel in span*/
|
||||
/* only end is used until now.(end was before called count) */
|
||||
GLuint activeMask; /* OR of the SPAN_* flags */
|
||||
#if CHAN_TYPE == GL_FLOAT
|
||||
GLfloat red, redStep;
|
||||
GLfloat green, greenStep;
|
||||
GLfloat blue, blueStep;
|
||||
GLfloat alpha, alphaStep;
|
||||
GLfloat specRed, specRedStep;
|
||||
GLfloat specGreen, specGreenStep;
|
||||
GLfloat specBlue, specBlueStep;
|
||||
#else /* CHAN_TYPE == */
|
||||
GLfixed red, redStep;
|
||||
GLfixed green, greenStep;
|
||||
GLfixed blue, blueStep;
|
||||
GLfixed alpha, alphaStep;
|
||||
GLfixed specRed, specRedStep;
|
||||
GLfixed specGreen, specGreenStep;
|
||||
GLfixed specBlue, specBlueStep;
|
||||
#endif
|
||||
GLfixed index, indexStep;
|
||||
GLfixed z, zStep;
|
||||
GLfloat fog, fogStep;
|
||||
GLfloat tex[MAX_TEXTURE_UNITS][4], texStep[MAX_TEXTURE_UNITS][4];
|
||||
GLfixed intTex[2], intTexStep[2];
|
||||
/* Needed for texture lambda (LOD) computation */
|
||||
GLfloat rho[MAX_TEXTURE_UNITS];
|
||||
GLfloat texWidth[MAX_TEXTURE_UNITS], texHeight[MAX_TEXTURE_UNITS];
|
||||
|
||||
GLboolean write_all; /* This flag indicates that only a part of */
|
||||
/*the span is visible. */
|
||||
#ifdef DEBUG
|
||||
GLboolean filledDepth, filledMask, filledAlpha;
|
||||
GLboolean filledColor, filledSpecular;
|
||||
GLboolean filledLambda[MAX_TEXTURE_UNITS], filledTex[MAX_TEXTURE_UNITS];
|
||||
GLboolean testedDepth, testedAlpha;
|
||||
#endif
|
||||
/* The interpolated fragment values */
|
||||
GLdepth depth[MAX_WIDTH];
|
||||
union {
|
||||
GLchan rgb[MAX_WIDTH][3];
|
||||
GLchan rgba[MAX_WIDTH][4];
|
||||
GLuint index[MAX_WIDTH];
|
||||
} color;
|
||||
GLchan specular[MAX_WIDTH][4];
|
||||
GLint itexcoords[MAX_WIDTH][2]; /* s, t */
|
||||
GLfloat texcoords[MAX_TEXTURE_UNITS][MAX_WIDTH][3]; /* s, t, r */
|
||||
GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH];
|
||||
GLfloat coverage[MAX_WIDTH];
|
||||
GLubyte mask[MAX_WIDTH];
|
||||
};
|
||||
|
||||
#ifdef DEBUG
|
||||
#define SW_SPAN_SET_FLAG(flag) {ASSERT((flag) == GL_FALSE);(flag) = GL_TRUE;}
|
||||
#define SW_SPAN_RESET(span) { \
|
||||
(span).filledDepth = (span).filledMask = (span).filledAlpha \
|
||||
= (span).filledColor = (span).filledSpecular \
|
||||
= (span).testedDepth = (span).testedAlpha = GL_FALSE; \
|
||||
MEMSET((span).filledTex, GL_FALSE, \
|
||||
MAX_TEXTURE_UNITS*sizeof(GLboolean)); \
|
||||
MEMSET((span).filledLambda, GL_FALSE, \
|
||||
MAX_TEXTURE_UNITS*sizeof(GLboolean)); \
|
||||
(span).start = 0; (span).write_all = GL_TRUE;}
|
||||
#else
|
||||
#define SW_SPAN_SET_FLAG(flag) ;
|
||||
#define SW_SPAN_RESET(span) {(span).start = 0;(span).write_all = GL_TRUE;}
|
||||
#endif
|
||||
|
||||
struct swrast_device_driver;
|
||||
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue