-/* $Id: swrast.h,v 1.28 2002/10/02 23:24:04 brianp Exp $ */
-
/*
* Mesa 3-D graphics library
- * Version: 4.1
+ * Version: 6.3
*
- * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2005 Brian Paul All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
/**
* \file swrast/swrast.h
- * \brief Defines basic structures for sw_rasterizer.
- * \author Keith Whitwell <keithw@valinux.com>
+ * \brief Public interface to the software rasterization functions.
+ * \author Keith Whitwell <keith@tungstengraphics.com>
*/
#ifndef SWRAST_H
* primitives unaccelerated), hook in swrast_setup instead.
*/
typedef struct {
+ /** win[0], win[1] are the screen-coords of SWvertex. win[2] is the
+ * z-coord. what is win[3]? */
GLfloat win[4];
- GLfloat texcoord[MAX_TEXTURE_UNITS][4];
+ GLfloat texcoord[MAX_TEXTURE_COORD_UNITS][4];
GLchan color[4];
GLchan specular[4];
GLfloat fog;
- GLuint index;
+ GLfloat index;
GLfloat pointSize;
} SWvertex;
-/**
- * \struct sw_span
- * \brief Contains data for either a horizontal line or a set of
- * pixels that are passed through a pipeline of functions before being
- * drawn.
- *
- * The sw_span structure describes the colors, Z, fogcoord, texcoords,
- * etc for either a horizontal run or a set of independent pixels. We
- * can either specify a base/step to indicate interpolated values, or
- * fill in arrays of values. The interpMask and arrayMask bitfields
- * indicate which are active.
- *
- * With this structure it's easy to hand-off span rasterization to
- * subroutines instead of doing it all inline in the triangle functions
- * 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.
- */
-
-
-/* Values for interpMask and arrayMask */
-#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_COVERAGE 0x100
-#define SPAN_FLAT 0x200 /* flat shading? */
-#define SPAN_XY 0x400 /* arrayMask only - for xArray, yArray */
-#define SPAN_MASK 0x800 /* arrayMask only */
-
-
-struct span_arrays {
- /**
- * Arrays of fragment values. These will either be computed from the
- * x/xStep values above or filled in by glDraw/CopyPixels, etc.
- */
- GLchan rgb[MAX_WIDTH][3];
- GLchan rgba[MAX_WIDTH][4];
- GLuint index[MAX_WIDTH];
- GLchan spec[MAX_WIDTH][4]; /* specular color */
- GLint x[MAX_WIDTH]; /**< X/Y used for point/line rendering only */
- GLint y[MAX_WIDTH]; /**< X/Y used for point/line rendering only */
- GLdepth z[MAX_WIDTH];
- GLfloat fog[MAX_WIDTH];
- GLfloat texcoords[MAX_TEXTURE_UNITS][MAX_WIDTH][4];
- GLfloat lambda[MAX_TEXTURE_UNITS][MAX_WIDTH];
- GLfloat coverage[MAX_WIDTH];
-
- /** This mask indicates if fragment is alive or culled */
- GLubyte mask[MAX_WIDTH];
-};
-
-
-struct sw_span {
- GLint x, y;
-
- /** Only need to process pixels between start <= i < end */
- /** At this time, start is always zero. */
- GLuint start, end;
-
- /** This flag indicates that mask[] array is effectively filled with ones */
- GLboolean writeAll;
-
- /** either GL_POLYGON, GL_LINE, GL_POLYGON, GL_BITMAP */
- GLenum primitive;
-
- /** 0 = front-facing span, 1 = back-facing span (for two-sided stencil) */
- GLuint facing;
-
- /**
- * This bitmask (of SPAN_* flags) indicates which of the x/xStep
- * variables are relevant.
- */
- GLuint interpMask;
-
-#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 == GL_UNSIGNED_BYTE or GL_UNSIGNED SHORT */
- 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];
- GLfloat texStepX[MAX_TEXTURE_UNITS][4];
- GLfloat texStepY[MAX_TEXTURE_UNITS][4];
- GLfixed intTex[2], intTexStep[2];
-
- /**
- * This bitmask (of SPAN_* flags) indicates which of the fragment arrays
- * in the span_arrays struct are relevant.
- */
- GLuint arrayMask;
-
- /**
- * We store the arrays of fragment values in a separate struct so
- * that we can allocate sw_span structs on the stack without using
- * a lot of memory. The span_arrays struct is about 400KB while the
- * sw_span struct is only about 512 bytes.
- */
- struct span_arrays *array;
-};
-
-
-#define INIT_SPAN(S, PRIMITIVE, END, INTERP_MASK, ARRAY_MASK) \
-do { \
- (S).primitive = (PRIMITIVE); \
- (S).interpMask = (INTERP_MASK); \
- (S).arrayMask = (ARRAY_MASK); \
- (S).start = 0; \
- (S).end = (END); \
- (S).facing = 0; \
- (S).array = SWRAST_CONTEXT(ctx)->span_data; \
-} while (0)
-
-
-
struct swrast_device_driver;
/* These are the public-access functions exported from swrast.
*/
-extern void
-_swrast_alloc_buffers( GLframebuffer *buffer );
-
extern void
_swrast_use_read_buffer( GLcontext *ctx );
_swrast_DrawBuffer( GLcontext *ctx, GLenum mode );
+extern void
+_swrast_DrawBuffers( GLcontext *ctx, GLsizei n, const GLenum *buffers );
+
+
/* Reset the stipple counter
*/
extern void
extern void
_swrast_flush( GLcontext *ctx );
+extern void
+_swrast_render_primitive( GLcontext *ctx, GLenum mode );
+
extern void
_swrast_render_start( GLcontext *ctx );
/*
- * Texture fallbacks, Brian Paul. Could also live in a new module
+ * Texture fallbacks. Could also live in a new module
* with the rest of the texture store fallbacks?
*/
extern void
GLint x, GLint y, GLsizei width, GLsizei height);
-
-/* The driver interface for the software rasterizer. Unless otherwise
- * noted, all functions are mandatory.
+/* The driver interface for the software rasterizer.
+ * Unless otherwise noted, all functions are mandatory.
*/
struct swrast_device_driver {
-
- void (*SetBuffer)( GLcontext *ctx, GLframebuffer *buffer,
- GLenum colorBuffer );
+#if OLD_RENDERBUFFER
+ void (*SetBuffer)(GLcontext *ctx, GLframebuffer *buffer, GLuint bufferBit);
/*
- * Specifies the current buffer for span/pixel writing/reading.
+ * Specifies the current color buffer for span/pixel writing/reading.
* buffer indicates which window to write to / read from. Normally,
* this'll be the buffer currently bound to the context, but it doesn't
* have to be!
- * colorBuffer indicates which color buffer, one of:
- * GL_FRONT_LEFT - this buffer always exists
- * GL_BACK_LEFT - when double buffering
- * GL_FRONT_RIGHT - when using stereo
- * GL_BACK_RIGHT - when using stereo and double buffering
+ * bufferBit indicates which color buffer, exactly one of:
+ * DD_FRONT_LEFT_BIT - this buffer always exists
+ * DD_BACK_LEFT_BIT - when double buffering
+ * DD_FRONT_RIGHT_BIT - when using stereo
+ * DD_BACK_RIGHT_BIT - when using stereo and double buffering
+ * DD_AUXn_BIT - if aux buffers are implemented
*/
-
+#endif
/***
*** Functions for synchronizing access to the framebuffer:
*** Functions for writing pixels to the frame buffer:
***/
- void (*WriteRGBASpan)( const GLcontext *ctx,
+ void (*WriteRGBASpan)( const GLcontext *ctx, struct gl_renderbuffer *rb,
GLuint n, GLint x, GLint y,
CONST GLchan rgba[][4], const GLubyte mask[] );
- void (*WriteRGBSpan)( const GLcontext *ctx,
+ void (*WriteRGBSpan)( const GLcontext *ctx, struct gl_renderbuffer *rb,
GLuint n, GLint x, GLint y,
CONST GLchan rgb[][3], const GLubyte mask[] );
/* Write a horizontal run of RGBA or RGB pixels.
* If mask is not null, only draw pixel [i] when mask [i] is true.
*/
- void (*WriteMonoRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ void (*WriteMonoRGBASpan)( const GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y,
const GLchan color[4], const GLubyte mask[] );
/* Write a horizontal run of RGBA pixels all with the same color.
+ * If mask is NULL, draw all pixels.
+ * If mask is not null, only draw pixel [i] when mask [i] is true.
*/
- void (*WriteRGBAPixels)( const GLcontext *ctx,
+ void (*WriteRGBAPixels)( const GLcontext *ctx, struct gl_renderbuffer *rb,
GLuint n, const GLint x[], const GLint y[],
CONST GLchan rgba[][4], const GLubyte mask[] );
/* Write array of RGBA pixels at random locations.
*/
void (*WriteMonoRGBAPixels)( const GLcontext *ctx,
+ struct gl_renderbuffer *rb,
GLuint n, const GLint x[], const GLint y[],
const GLchan color[4], const GLubyte mask[] );
/* Write an array of mono-RGBA pixels at random locations.
*/
- void (*WriteCI32Span)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+#if OLD_RENDERBUFFER /* these are obsolete */
+ void (*WriteCI32Span)( const GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y,
const GLuint index[], const GLubyte mask[] );
- void (*WriteCI8Span)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ void (*WriteCI8Span)( const GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y,
const GLubyte index[], const GLubyte mask[] );
/* Write a horizontal run of CI pixels. One function is for 32bpp
* indexes and the other for 8bpp pixels (the common case). You mus
* implement both for color index mode.
+ * If mask is NULL, draw all pixels.
+ * If mask is not null, only draw pixel [i] when mask [i] is true.
*/
-
- void (*WriteMonoCISpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+ void (*WriteMonoCISpan)( const GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y,
GLuint colorIndex, const GLubyte mask[] );
/* Write a horizontal run of color index pixels using the color index
* last specified by the Index() function.
+ * If mask is NULL, draw all pixels.
+ * If mask is not null, only draw pixel [i] when mask [i] is true.
*/
- void (*WriteCI32Pixels)( const GLcontext *ctx,
+ void (*WriteCI32Pixels)( const GLcontext *ctx, struct gl_renderbuffer *rb,
GLuint n, const GLint x[], const GLint y[],
const GLuint index[], const GLubyte mask[] );
/*
* Write a random array of CI pixels.
*/
-
- void (*WriteMonoCIPixels)( const GLcontext *ctx,
- GLuint n, const GLint x[], const GLint y[],
+ void (*WriteMonoCIPixels)( const GLcontext *ctx, struct gl_renderbuffer *rb, GLuint n, const GLint x[], const GLint y[],
GLuint colorIndex, const GLubyte mask[] );
/* Write a random array of color index pixels using the color index
* last specified by the Index() function.
*/
-
/***
*** Functions to read pixels from frame buffer:
***/
- void (*ReadCI32Span)( const GLcontext *ctx,
+ void (*ReadCI32Span)( const GLcontext *ctx, struct gl_renderbuffer *rb,
GLuint n, GLint x, GLint y, GLuint index[] );
/* Read a horizontal run of color index pixels.
*/
- void (*ReadRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
- GLchan rgba[][4] );
- /* Read a horizontal run of RGBA pixels.
- */
-
- void (*ReadCI32Pixels)( const GLcontext *ctx,
+ void (*ReadCI32Pixels)( const GLcontext *ctx, struct gl_renderbuffer *rb,
GLuint n, const GLint x[], const GLint y[],
GLuint indx[], const GLubyte mask[] );
/* Read a random array of CI pixels.
*/
+#endif
+
+ void (*ReadRGBASpan)( const GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y, GLchan rgba[][4] );
+ /* Read a horizontal run of RGBA pixels.
+ */
- void (*ReadRGBAPixels)( const GLcontext *ctx,
+ void (*ReadRGBAPixels)( const GLcontext *ctx, struct gl_renderbuffer *rb,
GLuint n, const GLint x[], const GLint y[],
GLchan rgba[][4], const GLubyte mask[] );
/* Read a random array of RGBA pixels.
*** buffer is less than 32 bits deep then the extra upperbits are zero.
***/
- void (*WriteDepthSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ void (*WriteDepthSpan)( GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y,
const GLdepth depth[], const GLubyte mask[] );
/* Write a horizontal span of values into the depth buffer. Only write
* depth[i] value if mask[i] is nonzero.
*/
- void (*ReadDepthSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
- GLdepth depth[] );
+ void (*WriteMonoDepthSpan)( GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y,
+ const GLdepth depth, const GLubyte mask[] );
+ /* Write a horizontal run of depth values.
+ * If mask is NULL, draw all pixels.
+ * If mask is not null, only draw pixel [i] when mask [i] is true.
+ */
+
+ void (*ReadDepthSpan)( GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y, GLdepth depth[] );
/* Read a horizontal span of values from the depth buffer.
*/
- void (*WriteDepthPixels)( GLcontext *ctx, GLuint n,
- const GLint x[], const GLint y[],
+ void (*WriteDepthPixels)( GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, const GLint x[], const GLint y[],
const GLdepth depth[], const GLubyte mask[] );
/* Write an array of randomly positioned depth values into the
* depth buffer. Only write depth[i] value if mask[i] is nonzero.
*/
- void (*ReadDepthPixels)( GLcontext *ctx, GLuint n,
- const GLint x[], const GLint y[],
+ void (*ReadDepthPixels)( GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, const GLint x[], const GLint y[],
GLdepth depth[] );
/* Read an array of randomly positioned depth values from the depth buffer.
*/
*** Either ALL or NONE of these functions must be implemented!
***/
- void (*WriteStencilSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
+ void (*WriteStencilSpan)( GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y,
const GLstencil stencil[], const GLubyte mask[] );
/* Write a horizontal span of stencil values into the stencil buffer.
* If mask is NULL, write all stencil values.
* Else, only write stencil[i] if mask[i] is non-zero.
*/
- void (*ReadStencilSpan)( GLcontext *ctx, GLuint n, GLint x, GLint y,
- GLstencil stencil[] );
+ void (*ReadStencilSpan)( GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, GLint x, GLint y, GLstencil stencil[] );
/* Read a horizontal span of stencil values from the stencil buffer.
*/
- void (*WriteStencilPixels)( GLcontext *ctx, GLuint n,
- const GLint x[], const GLint y[],
+ void (*WriteStencilPixels)( GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, const GLint x[], const GLint y[],
const GLstencil stencil[],
const GLubyte mask[] );
/* Write an array of stencil values into the stencil buffer.
* Else, only write stencil[i] if mask[i] is non-zero.
*/
- void (*ReadStencilPixels)( GLcontext *ctx, GLuint n,
- const GLint x[], const GLint y[],
+ void (*ReadStencilPixels)( GLcontext *ctx, struct gl_renderbuffer *rb,
+ GLuint n, const GLint x[], const GLint y[],
GLstencil stencil[] );
/* Read an array of stencil values from the stencil buffer.
*/
projects / mesa.git / blobdiff