-/* $Id: swrast.h,v 1.30 2002/10/11 17:41:06 brianp Exp $ */
-
/*
* Mesa 3-D graphics library
- * Version: 4.1
+ * Version: 6.5
*
- * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
+ * Copyright (C) 1999-2006 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
#define SWRAST_H
-#include "mtypes.h"
+#include "main/mtypes.h"
/**
* \struct SWvertex
* improve its usefulness as a fallback mechanism for hardware
* drivers.
*
+ * wpos = attr[FRAG_ATTRIB_WPOS] and MUST BE THE FIRST values in the
+ * vertex because of the tnl clipping code.
+
+ * wpos[0] and [1] are the screen-coords of SWvertex.
+ * wpos[2] is the z-buffer coord (if 16-bit Z buffer, in range [0,65535]).
+ * wpos[3] is 1/w where w is the clip-space W coord. This is the value
+ * that clip{XYZ} were multiplied by to get ndc{XYZ}.
+ *
* Full software drivers:
* - Register the rastersetup and triangle functions from
* utils/software_helper.
* primitives unaccelerated), hook in swrast_setup instead.
*/
typedef struct {
- GLfloat win[4];
- GLfloat texcoord[MAX_TEXTURE_UNITS][4];
- GLchan color[4];
- GLchan specular[4];
- GLfloat fog;
- GLuint index;
+ GLfloat attrib[FRAG_ATTRIB_MAX][4];
+ GLchan color[4]; /** integer color */
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)->SpanArrays; \
-} while (0)
-
+#define FRAG_ATTRIB_CI FRAG_ATTRIB_COL0
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 );
-
-extern void
-_swrast_use_draw_buffer( GLcontext *ctx );
extern GLboolean
_swrast_CreateContext( GLcontext *ctx );
GLvoid *pixels );
extern void
-_swrast_Clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
- GLint x, GLint y, GLint width, GLint height );
+_swrast_BlitFramebuffer(GLcontext *ctx,
+ GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
+ GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
+ GLbitfield mask, GLenum filter);
extern void
-_swrast_Accum( GLcontext *ctx, GLenum op,
- GLfloat value, GLint xpos, GLint ypos,
- GLint width, GLint height );
-
+_swrast_Clear(GLcontext *ctx, GLbitfield buffers);
extern void
-_swrast_DrawBuffer( GLcontext *ctx, GLenum mode );
+_swrast_Accum(GLcontext *ctx, GLenum op, GLfloat value);
+
/* Reset the stipple counter
extern void
_swrast_ResetLineStipple( GLcontext *ctx );
+/**
+ * Indicates front/back facing for subsequent points/lines when drawing
+ * unfilled polygons. Needed for two-side stencil.
+ */
+extern void
+_swrast_SetFacing(GLcontext *ctx, GLuint facing);
+
/* These will always render the correct point/line/triangle for the
* current state.
*
/* Tell the software rasterizer about core state changes.
*/
extern void
-_swrast_InvalidateState( GLcontext *ctx, GLuint new_state );
+_swrast_InvalidateState( GLcontext *ctx, GLbitfield new_state );
/* Configure software rasterizer to match hardware rasterizer characteristics:
*/
/*
- * 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);
+extern void
+_swrast_eject_texture_images(GLcontext *ctx);
-/* The driver interface for the software rasterizer.
- * Unless otherwise noted, all functions are mandatory.
- */
-struct swrast_device_driver {
-
- void (*SetBuffer)( GLcontext *ctx, GLframebuffer *buffer, GLuint bufferBit);
- /*
- * Specifies the current 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!
- * bufferBit indicates which color buffer, one of:
- * FRONT_LEFT_BIT - this buffer always exists
- * BACK_LEFT_BIT - when double buffering
- * FRONT_RIGHT_BIT - when using stereo
- * BACK_RIGHT_BIT - when using stereo and double buffering
- * AUXn_BIT - if aux buffers are implemented
- */
+#if FEATURE_MESA_program_debug
+extern void
+_swrast_get_program_register(GLcontext *, enum register_file file,
+ GLuint index, GLfloat val[4]);
+#endif /* FEATURE_MESA_program_debug */
- /***
- *** Functions for synchronizing access to the framebuffer:
- ***/
- void (*SpanRenderStart)(GLcontext *ctx);
- void (*SpanRenderFinish)(GLcontext *ctx);
- /* OPTIONAL.
+/**
+ * The driver interface for the software rasterizer.
+ * XXX this may go away.
+ * We may move these functions to ctx->Driver.RenderStart, RenderEnd.
+ */
+struct swrast_device_driver {
+ /*
+ * These are called before and after accessing renderbuffers during
+ * software rasterization.
*
- * Called before and after all rendering operations, including DrawPixels,
- * ReadPixels, Bitmap, span functions, and CopyTexImage, etc commands.
* These are a suitable place for grabbing/releasing hardware locks.
*
* NOTE: The swrast triangle/line/point routines *DO NOT* call
* these functions. Locking in that case must be organized by the
* driver by other mechanisms.
*/
-
- /***
- *** Functions for writing pixels to the frame buffer:
- ***/
-
- void (*WriteRGBASpan)( const GLcontext *ctx,
- GLuint n, GLint x, GLint y,
- CONST GLchan rgba[][4], const GLubyte mask[] );
- void (*WriteRGBSpan)( const GLcontext *ctx,
- 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 NULL, draw all 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,
- const GLchan color[4], const GLubyte mask[] );
- /* Write a horizontal run of RGBA pixels all with the same color.
- */
-
- void (*WriteRGBAPixels)( const GLcontext *ctx,
- 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,
- 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,
- const GLuint index[], const GLubyte mask[] );
- void (*WriteCI8Span)( const GLcontext *ctx, 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.
- */
-
- void (*WriteMonoCISpan)( const GLcontext *ctx, 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.
- */
-
- void (*WriteCI32Pixels)( const GLcontext *ctx,
- 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[],
- 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,
- 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,
- GLuint n, const GLint x[], const GLint y[],
- GLuint indx[], const GLubyte mask[] );
- /* Read a random array of CI pixels.
- */
-
- void (*ReadRGBAPixels)( const GLcontext *ctx,
- GLuint n, const GLint x[], const GLint y[],
- GLchan rgba[][4], const GLubyte mask[] );
- /* Read a random array of RGBA pixels.
- */
-
-
-
- /***
- *** For supporting hardware Z buffers:
- *** Either ALL or NONE of these functions must be implemented!
- *** NOTE that Each depth value is a 32-bit GLuint. If the depth
- *** buffer is less than 32 bits deep then the extra upperbits are zero.
- ***/
-
- void (*WriteDepthSpan)( GLcontext *ctx, 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[] );
- /* Read a horizontal span of values from the depth buffer.
- */
-
-
- void (*WriteDepthPixels)( GLcontext *ctx, 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[],
- GLdepth depth[] );
- /* Read an array of randomly positioned depth values from the depth buffer.
- */
-
-
-
- /***
- *** For supporting hardware stencil buffers:
- *** Either ALL or NONE of these functions must be implemented!
- ***/
-
- void (*WriteStencilSpan)( GLcontext *ctx, 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[] );
- /* Read a horizontal span of stencil values from the stencil buffer.
- */
-
- void (*WriteStencilPixels)( GLcontext *ctx, GLuint n,
- const GLint x[], const GLint y[],
- const GLstencil stencil[],
- const GLubyte mask[] );
- /* Write an array 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 (*ReadStencilPixels)( GLcontext *ctx, GLuint n,
- const GLint x[], const GLint y[],
- GLstencil stencil[] );
- /* Read an array of stencil values from the stencil buffer.
- */
+ void (*SpanRenderStart)(GLcontext *ctx);
+ void (*SpanRenderFinish)(GLcontext *ctx);
};