s_span.h revision 4a49301e
1/* 2 * Mesa 3-D graphics library 3 * Version: 7.5 4 * 5 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 6 * Copyright (C) 2009 VMware, Inc. All Rights Reserved. 7 * 8 * Permission is hereby granted, free of charge, to any person obtaining a 9 * copy of this software and associated documentation files (the "Software"), 10 * to deal in the Software without restriction, including without limitation 11 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 12 * and/or sell copies of the Software, and to permit persons to whom the 13 * Software is furnished to do so, subject to the following conditions: 14 * 15 * The above copyright notice and this permission notice shall be included 16 * in all copies or substantial portions of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN 22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 24 */ 25 26 27#ifndef S_SPAN_H 28#define S_SPAN_H 29 30 31#include "swrast.h" 32 33 34/** 35 * \defgroup SpanFlags 36 * Special bitflags to describe span data. 37 * 38 * In general, the point/line/triangle functions interpolate/emit the 39 * attributes specified by swrast->_ActiveAttribs (i.e. FRAT_BIT_* values). 40 * Some things don't fit into that, though, so we have these flags. 41 */ 42/*@{*/ 43#define SPAN_RGBA 0x01 /**< interpMask and arrayMask */ 44#define SPAN_INDEX 0x02 /**< interpMask and arrayMask */ 45#define SPAN_Z 0x04 /**< interpMask and arrayMask */ 46#define SPAN_FLAT 0x08 /**< interpMask: flat shading? */ 47#define SPAN_XY 0x10 /**< array.x[], y[] valid? */ 48#define SPAN_MASK 0x20 /**< was array.mask[] filled in by caller? */ 49#define SPAN_LAMBDA 0x40 /**< array.lambda[] valid? */ 50#define SPAN_COVERAGE 0x80 /**< array.coverage[] valid? */ 51/*@}*/ 52 53 54/** 55 * \sw_span_arrays 56 * \brief Arrays of fragment values. 57 * 58 * These will either be computed from the span x/xStep values or 59 * filled in by glDraw/CopyPixels, etc. 60 * These arrays are separated out of sw_span to conserve memory. 61 */ 62typedef struct sw_span_arrays 63{ 64 /** Per-fragment attributes (indexed by FRAG_ATTRIB_* tokens) */ 65 /* XXX someday look at transposing first two indexes for better memory 66 * access pattern. 67 */ 68 GLfloat attribs[FRAG_ATTRIB_MAX][MAX_WIDTH][4]; 69 70 /** This mask indicates which fragments are alive or culled */ 71 GLubyte mask[MAX_WIDTH]; 72 73 GLenum ChanType; /**< Color channel type, GL_UNSIGNED_BYTE, GL_FLOAT */ 74 75 /** Attribute arrays that don't fit into attribs[] array above */ 76 /*@{*/ 77 GLubyte rgba8[MAX_WIDTH][4]; 78 GLushort rgba16[MAX_WIDTH][4]; 79 GLchan (*rgba)[4]; /** either == rgba8 or rgba16 */ 80 GLint x[MAX_WIDTH]; /**< fragment X coords */ 81 GLint y[MAX_WIDTH]; /**< fragment Y coords */ 82 GLuint z[MAX_WIDTH]; /**< fragment Z coords */ 83 GLuint index[MAX_WIDTH]; /**< Color indexes */ 84 GLfloat lambda[MAX_TEXTURE_COORD_UNITS][MAX_WIDTH]; /**< Texture LOD */ 85 GLfloat coverage[MAX_WIDTH]; /**< Fragment coverage for AA/smoothing */ 86 /*@}*/ 87} SWspanarrays; 88 89 90/** 91 * The SWspan structure describes the colors, Z, fogcoord, texcoords, 92 * etc for either a horizontal run or an array of independent pixels. 93 * We can either specify a base/step to indicate interpolated values, or 94 * fill in explicit arrays of values. The interpMask and arrayMask bitfields 95 * indicate which attributes are active interpolants or arrays, respectively. 96 * 97 * It would be interesting to experiment with multiprocessor rasterization 98 * with this structure. The triangle rasterizer could simply emit a 99 * stream of these structures which would be consumed by one or more 100 * span-processing threads which could run in parallel. 101 */ 102typedef struct sw_span 103{ 104 /** Coord of first fragment in horizontal span/run */ 105 GLint x, y; 106 107 /** Number of fragments in the span */ 108 GLuint end; 109 110 /** for clipping left edge of spans */ 111 GLuint leftClip; 112 113 /** This flag indicates that mask[] array is effectively filled with ones */ 114 GLboolean writeAll; 115 116 /** either GL_POLYGON, GL_LINE, GL_POLYGON, GL_BITMAP */ 117 GLenum primitive; 118 119 /** 0 = front-facing span, 1 = back-facing span (for two-sided stencil) */ 120 GLuint facing; 121 122 /** 123 * This bitmask (of \link SpanFlags SPAN_* flags\endlink) indicates 124 * which of the attrStart/StepX/StepY variables are relevant. 125 */ 126 GLbitfield interpMask; 127 128 /** Fragment attribute interpolants */ 129 GLfloat attrStart[FRAG_ATTRIB_MAX][4]; /**< initial value */ 130 GLfloat attrStepX[FRAG_ATTRIB_MAX][4]; /**< dvalue/dx */ 131 GLfloat attrStepY[FRAG_ATTRIB_MAX][4]; /**< dvalue/dy */ 132 133 /* XXX the rest of these will go away eventually... */ 134 135 /* For horizontal spans, step is the partial derivative wrt X. 136 * For lines, step is the delta from one fragment to the next. 137 */ 138 GLfixed red, redStep; 139 GLfixed green, greenStep; 140 GLfixed blue, blueStep; 141 GLfixed alpha, alphaStep; 142 GLfixed index, indexStep; 143 GLfixed z, zStep; /**< XXX z should probably be GLuint */ 144 GLfixed intTex[2], intTexStep[2]; /**< (s,t) for unit[0] only */ 145 146 /** 147 * This bitmask (of \link SpanFlags SPAN_* flags\endlink) indicates 148 * which of the fragment arrays in the span_arrays struct are relevant. 149 */ 150 GLbitfield arrayMask; 151 152 GLbitfield arrayAttribs; 153 154 /** 155 * We store the arrays of fragment values in a separate struct so 156 * that we can allocate sw_span structs on the stack without using 157 * a lot of memory. The span_arrays struct is about 1.4MB while the 158 * sw_span struct is only about 512 bytes. 159 */ 160 SWspanarrays *array; 161} SWspan; 162 163 164 165#define INIT_SPAN(S, PRIMITIVE) \ 166do { \ 167 (S).primitive = (PRIMITIVE); \ 168 (S).interpMask = 0x0; \ 169 (S).arrayMask = 0x0; \ 170 (S).arrayAttribs = 0x0; \ 171 (S).end = 0; \ 172 (S).leftClip = 0; \ 173 (S).facing = 0; \ 174 (S).array = SWRAST_CONTEXT(ctx)->SpanArrays; \ 175} while (0) 176 177 178 179extern void 180_swrast_span_default_attribs(GLcontext *ctx, SWspan *span); 181 182extern void 183_swrast_span_interpolate_z( const GLcontext *ctx, SWspan *span ); 184 185extern GLfloat 186_swrast_compute_lambda(GLfloat dsdx, GLfloat dsdy, GLfloat dtdx, GLfloat dtdy, 187 GLfloat dqdx, GLfloat dqdy, GLfloat texW, GLfloat texH, 188 GLfloat s, GLfloat t, GLfloat q, GLfloat invQ); 189 190extern void 191_swrast_write_index_span( GLcontext *ctx, SWspan *span); 192 193 194extern void 195_swrast_write_rgba_span( GLcontext *ctx, SWspan *span); 196 197 198extern void 199_swrast_read_rgba_span(GLcontext *ctx, struct gl_renderbuffer *rb, 200 GLuint n, GLint x, GLint y, GLenum type, GLvoid *rgba); 201 202extern void 203_swrast_read_index_span( GLcontext *ctx, struct gl_renderbuffer *rb, 204 GLuint n, GLint x, GLint y, GLuint indx[] ); 205 206extern void 207_swrast_get_values(GLcontext *ctx, struct gl_renderbuffer *rb, 208 GLuint count, const GLint x[], const GLint y[], 209 void *values, GLuint valueSize); 210 211extern void 212_swrast_put_row(GLcontext *ctx, struct gl_renderbuffer *rb, 213 GLuint count, GLint x, GLint y, 214 const GLvoid *values, GLuint valueSize); 215 216extern void 217_swrast_get_row(GLcontext *ctx, struct gl_renderbuffer *rb, 218 GLuint count, GLint x, GLint y, 219 GLvoid *values, GLuint valueSize); 220 221 222extern void * 223_swrast_get_dest_rgba(GLcontext *ctx, struct gl_renderbuffer *rb, 224 SWspan *span); 225 226#endif 227