projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge branch '7.8'
[mesa.git] / src / mesa / drivers / dri / swrast / swrast_spantemp.h
1 /*
2 * Mesa 3-D graphics library
3 * Version: 6.5.1
4 *
5 * Copyright (C) 1999-2006 Brian Paul All Rights Reserved.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 */
24
25
26 /*
27 * Modified version of swrast/s_spantemp.h for front-buffer rendering. The
28 * no-mask paths use a scratch row to avoid repeated calls to the loader.
29 *
30 * For the mask paths we always use an array of 4 elements of RB_TYPE. This is
31 * to satisfy the xorg loader requirement of an image pitch of 32 bits and
32 * should be ok for other loaders also.
33 */
34
35
36 #ifndef _SWRAST_SPANTEMP_ONCE
37 #define _SWRAST_SPANTEMP_ONCE
38
39 static INLINE void
40 PUT_PIXEL( GLcontext *glCtx, GLint x, GLint y, GLubyte *p )
41 {
42 __DRIcontext *ctx = swrast_context(glCtx)->cPriv;
43 __DRIdrawable *draw = swrast_drawable(glCtx->DrawBuffer)->dPriv;
44
45 __DRIscreen *screen = ctx->driScreenPriv;
46
47 screen->swrast_loader->putImage(draw, __DRI_SWRAST_IMAGE_OP_DRAW,
48 x, y, 1, 1, (char *)p,
49 draw->loaderPrivate);
50 }
51
52
53 static INLINE void
54 GET_PIXEL( GLcontext *glCtx, GLint x, GLint y, GLubyte *p )
55 {
56 __DRIcontext *ctx = swrast_context(glCtx)->cPriv;
57 __DRIdrawable *read = swrast_drawable(glCtx->ReadBuffer)->dPriv;
58
59 __DRIscreen *screen = ctx->driScreenPriv;
60
61 screen->swrast_loader->getImage(read, x, y, 1, 1, (char *)p,
62 read->loaderPrivate);
63 }
64
65 static INLINE void
66 PUT_ROW( GLcontext *glCtx, GLint x, GLint y, GLuint n, char *row )
67 {
68 __DRIcontext *ctx = swrast_context(glCtx)->cPriv;
69 __DRIdrawable *draw = swrast_drawable(glCtx->DrawBuffer)->dPriv;
70
71 __DRIscreen *screen = ctx->driScreenPriv;
72
73 screen->swrast_loader->putImage(draw, __DRI_SWRAST_IMAGE_OP_DRAW,
74 x, y, n, 1, row,
75 draw->loaderPrivate);
76 }
77
78 static INLINE void
79 GET_ROW( GLcontext *glCtx, GLint x, GLint y, GLuint n, char *row )
80 {
81 __DRIcontext *ctx = swrast_context(glCtx)->cPriv;
82 __DRIdrawable *read = swrast_drawable(glCtx->ReadBuffer)->dPriv;
83
84 __DRIscreen *screen = ctx->driScreenPriv;
85
86 screen->swrast_loader->getImage(read, x, y, n, 1, row,
87 read->loaderPrivate);
88 }
89
90 #endif /* _SWRAST_SPANTEMP_ONCE */
91
92
93 /*
94 * Templates for the span/pixel-array write/read functions called via
95 * the gl_renderbuffer's GetRow, GetValues, PutRow, PutMonoRow, PutValues
96 * and PutMonoValues functions.
97 *
98 * Define the following macros before including this file:
99 * NAME(BASE) to generate the function name (i.e. add prefix or suffix)
100 * RB_TYPE the renderbuffer DataType
101 * SPAN_VARS to declare any local variables
102 * INIT_PIXEL_PTR(P, X, Y) to initialize a pointer to a pixel
103 * INC_PIXEL_PTR(P) to increment a pixel pointer by one pixel
104 * STORE_PIXEL(DST, X, Y, VALUE) to store pixel values in buffer
105 * FETCH_PIXEL(DST, SRC) to fetch pixel values from buffer
106 *
107 * Note that in the STORE_PIXEL macros, we also pass in the (X,Y) coordinates
108 * for the pixels to be stored. This is useful when dithering and probably
109 * ignored otherwise.
110 */
111
112 #include "main/macros.h"
113
114
115 #if !defined(RB_COMPONENTS)
116 #define RB_COMPONENTS 4
117 #endif
118
119
120 static void
121 NAME(get_row)( GLcontext *ctx, struct gl_renderbuffer *rb,
122 GLuint count, GLint x, GLint y, void *values )
123 {
124 #ifdef SPAN_VARS
125 SPAN_VARS
126 #endif
127 RB_TYPE (*dest)[RB_COMPONENTS] = (RB_TYPE (*)[RB_COMPONENTS]) values;
128 GLuint i;
129 char *row = swrast_drawable(ctx->ReadBuffer)->row;
130 INIT_PIXEL_PTR(pixel, x, y);
131 GET_ROW( ctx, x, YFLIP(xrb, y), count, row );
132 for (i = 0; i < count; i++) {
133 FETCH_PIXEL(dest[i], pixel);
134 INC_PIXEL_PTR(pixel);
135 }
136 (void) rb;
137 }
138
139
140 static void
141 NAME(get_values)( GLcontext *ctx, struct gl_renderbuffer *rb,
142 GLuint count, const GLint x[], const GLint y[], void *values )
143 {
144 #ifdef SPAN_VARS
145 SPAN_VARS
146 #endif
147 RB_TYPE (*dest)[RB_COMPONENTS] = (RB_TYPE (*)[RB_COMPONENTS]) values;
148 GLuint i;
149 for (i = 0; i < count; i++) {
150 RB_TYPE pixel[4];
151 GET_PIXEL(ctx, x[i], YFLIP(xrb, y[i]), pixel);
152 FETCH_PIXEL(dest[i], pixel);
153 }
154 (void) rb;
155 }
156
157
158 static void
159 NAME(put_row)( GLcontext *ctx, struct gl_renderbuffer *rb,
160 GLuint count, GLint x, GLint y,
161 const void *values, const GLubyte mask[] )
162 {
163 #ifdef SPAN_VARS
164 SPAN_VARS
165 #endif
166 const RB_TYPE (*src)[RB_COMPONENTS] = (const RB_TYPE (*)[RB_COMPONENTS]) values;
167 GLuint i;
168 if (mask) {
169 for (i = 0; i < count; i++) {
170 if (mask[i]) {
171 RB_TYPE pixel[4];
172 STORE_PIXEL(pixel, x + i, y, src[i]);
173 PUT_PIXEL(ctx, x + i, YFLIP(xrb, y), pixel);
174 }
175 }
176 }
177 else {
178 char *row = swrast_drawable(ctx->DrawBuffer)->row;
179 INIT_PIXEL_PTR(pixel, x, y);
180 for (i = 0; i < count; i++) {
181 STORE_PIXEL(pixel, x + i, y, src[i]);
182 INC_PIXEL_PTR(pixel);
183 }
184 PUT_ROW( ctx, x, YFLIP(xrb, y), count, row );
185 }
186 (void) rb;
187 }
188
189
190 static void
191 NAME(put_row_rgb)( GLcontext *ctx, struct gl_renderbuffer *rb,
192 GLuint count, GLint x, GLint y,
193 const void *values, const GLubyte mask[] )
194 {
195 #ifdef SPAN_VARS
196 SPAN_VARS
197 #endif
198 const RB_TYPE (*src)[3] = (const RB_TYPE (*)[3]) values;
199 GLuint i;
200 if (mask) {
201 for (i = 0; i < count; i++) {
202 if (mask[i]) {
203 RB_TYPE pixel[4];
204 #ifdef STORE_PIXEL_RGB
205 STORE_PIXEL_RGB(pixel, x + i, y, src[i]);
206 #else
207 STORE_PIXEL(pixel, x + i, y, src[i]);
208 #endif
209 PUT_PIXEL(ctx, x + i, YFLIP(xrb, y), pixel);
210 }
211 }
212 }
213 else {
214 char *row = swrast_drawable(ctx->DrawBuffer)->row;
215 INIT_PIXEL_PTR(pixel, x, y);
216 for (i = 0; i < count; i++) {
217 #ifdef STORE_PIXEL_RGB
218 STORE_PIXEL_RGB(pixel, x + i, y, src[i]);
219 #else
220 STORE_PIXEL(pixel, x + i, y, src[i]);
221 #endif
222 INC_PIXEL_PTR(pixel);
223 }
224 PUT_ROW( ctx, x, YFLIP(xrb, y), count, row );
225 }
226 (void) rb;
227 }
228
229
230 static void
231 NAME(put_mono_row)( GLcontext *ctx, struct gl_renderbuffer *rb,
232 GLuint count, GLint x, GLint y,
233 const void *value, const GLubyte mask[] )
234 {
235 #ifdef SPAN_VARS
236 SPAN_VARS
237 #endif
238 const RB_TYPE *src = (const RB_TYPE *) value;
239 GLuint i;
240 if (mask) {
241 for (i = 0; i < count; i++) {
242 if (mask[i]) {
243 RB_TYPE pixel[4];
244 STORE_PIXEL(pixel, x + i, y, src);
245 PUT_PIXEL(ctx, x + i, YFLIP(xrb, y), pixel);
246 }
247 }
248 }
249 else {
250 char *row = swrast_drawable(ctx->DrawBuffer)->row;
251 INIT_PIXEL_PTR(pixel, x, y);
252 for (i = 0; i < count; i++) {
253 STORE_PIXEL(pixel, x + i, y, src);
254 INC_PIXEL_PTR(pixel);
255 }
256 PUT_ROW( ctx, x, YFLIP(xrb, y), count, row );
257 }
258 (void) rb;
259 }
260
261
262 static void
263 NAME(put_values)( GLcontext *ctx, struct gl_renderbuffer *rb,
264 GLuint count, const GLint x[], const GLint y[],
265 const void *values, const GLubyte mask[] )
266 {
267 #ifdef SPAN_VARS
268 SPAN_VARS
269 #endif
270 const RB_TYPE (*src)[RB_COMPONENTS] = (const RB_TYPE (*)[RB_COMPONENTS]) values;
271 GLuint i;
272 ASSERT(mask);
273 for (i = 0; i < count; i++) {
274 if (mask[i]) {
275 RB_TYPE pixel[4];
276 STORE_PIXEL(pixel, x[i], y[i], src[i]);
277 PUT_PIXEL(ctx, x[i], YFLIP(xrb, y[i]), pixel);
278 }
279 }
280 (void) rb;
281 }
282
283
284 static void
285 NAME(put_mono_values)( GLcontext *ctx, struct gl_renderbuffer *rb,
286 GLuint count, const GLint x[], const GLint y[],
287 const void *value, const GLubyte mask[] )
288 {
289 #ifdef SPAN_VARS
290 SPAN_VARS
291 #endif
292 const RB_TYPE *src = (const RB_TYPE *) value;
293 GLuint i;
294 ASSERT(mask);
295 for (i = 0; i < count; i++) {
296 if (mask[i]) {
297 RB_TYPE pixel[4];
298 STORE_PIXEL(pixel, x[i], y[i], src);
299 PUT_PIXEL(ctx, x[i], YFLIP(xrb, y[i]), pixel);
300 }
301 }
302 (void) rb;
303 }
304
305
306 #undef NAME
307 #undef RB_TYPE
308 #undef RB_COMPONENTS
309 #undef SPAN_VARS
310 #undef INIT_PIXEL_PTR
311 #undef INC_PIXEL_PTR
312 #undef STORE_PIXEL
313 #undef STORE_PIXEL_RGB
314 #undef FETCH_PIXEL