projects / mesa.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Header file clean-up:
[mesa.git] / src / mesa / drivers / osmesa / osmesa.c
1 /* $Id: osmesa.c,v 1.93 2002/10/24 23:57:23 brianp Exp $ */
2
3 /*
4 * Mesa 3-D graphics library
5 * Version: 4.1
6 *
7 * Copyright (C) 1999-2002 Brian Paul All Rights Reserved.
8 *
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
15 *
16 * The above copyright notice and this permission notice shall be included
17 * in all copies or substantial portions of the Software.
18 *
19 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
20 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
22 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
23 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
24 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 */
26
27
28 /*
29 * Off-Screen Mesa rendering / Rendering into client memory space
30 *
31 * Note on thread safety: this driver is thread safe. All
32 * functions are reentrant. The notion of current context is
33 * managed by the core _mesa_make_current() and _mesa_get_current_context()
34 * functions. Those functions are thread-safe.
35 */
36
37
38 #include "glheader.h"
39 #include "GL/osmesa.h"
40 #include "buffers.h"
41 #include "context.h"
42 #include "colormac.h"
43 #include "depth.h"
44 #include "extensions.h"
45 #include "imports.h"
46 #include "macros.h"
47 #include "matrix.h"
48 #include "mmath.h"
49 #include "mtypes.h"
50 #include "texformat.h"
51 #include "texstore.h"
52 #include "array_cache/acache.h"
53 #include "swrast/swrast.h"
54 #include "swrast_setup/swrast_setup.h"
55 #include "swrast/s_context.h"
56 #include "swrast/s_depth.h"
57 #include "swrast/s_lines.h"
58 #include "swrast/s_triangle.h"
59 #include "tnl/tnl.h"
60 #include "tnl/t_context.h"
61 #include "tnl/t_pipeline.h"
62
63
64
65 /*
66 * This is the OS/Mesa context struct.
67 * Notice how it includes a GLcontext. By doing this we're mimicking
68 * C++ inheritance/derivation.
69 * Later, we can cast a GLcontext pointer into an OSMesaContext pointer
70 * or vice versa.
71 */
72 struct osmesa_context {
73 GLcontext gl_ctx; /* The core GL/Mesa context */
74 GLvisual *gl_visual; /* Describes the buffers */
75 GLframebuffer *gl_buffer; /* Depth, stencil, accum, etc buffers */
76 GLenum format; /* either GL_RGBA or GL_COLOR_INDEX */
77 void *buffer; /* the image buffer */
78 GLint width, height; /* size of image buffer */
79 GLint rowlength; /* number of pixels per row */
80 GLint userRowLength; /* user-specified number of pixels per row */
81 GLint rshift, gshift; /* bit shifts for RGBA formats */
82 GLint bshift, ashift;
83 GLint rInd, gInd, bInd, aInd;/* index offsets for RGBA formats */
84 GLchan *rowaddr[MAX_HEIGHT]; /* address of first pixel in each image row */
85 GLboolean yup; /* TRUE -> Y increases upward */
86 /* FALSE -> Y increases downward */
87 };
88
89
90
91 /* A forward declaration: */
92 static void osmesa_update_state( GLcontext *ctx, GLuint newstate );
93 static void osmesa_register_swrast_functions( GLcontext *ctx );
94
95
96
97 #define OSMESA_CONTEXT(ctx) ((OSMesaContext) (ctx->DriverCtx))
98
99
100
101 /**********************************************************************/
102 /***** Public Functions *****/
103 /**********************************************************************/
104
105
106 /*
107 * Create an Off-Screen Mesa rendering context. The only attribute needed is
108 * an RGBA vs Color-Index mode flag.
109 *
110 * Input: format - either GL_RGBA or GL_COLOR_INDEX
111 * sharelist - specifies another OSMesaContext with which to share
112 * display lists. NULL indicates no sharing.
113 * Return: an OSMesaContext or 0 if error
114 */
115 GLAPI OSMesaContext GLAPIENTRY
116 OSMesaCreateContext( GLenum format, OSMesaContext sharelist )
117 {
118 return OSMesaCreateContextExt(format, DEFAULT_SOFTWARE_DEPTH_BITS,
119 8, 16, sharelist);
120 }
121
122
123
124 /*
125 * New in Mesa 3.5
126 *
127 * Create context and specify size of ancillary buffers.
128 */
129 GLAPI OSMesaContext GLAPIENTRY
130 OSMesaCreateContextExt( GLenum format, GLint depthBits, GLint stencilBits,
131 GLint accumBits, OSMesaContext sharelist )
132 {
133 OSMesaContext osmesa;
134 GLint rshift, gshift, bshift, ashift;
135 GLint rind, gind, bind, aind;
136 GLint indexBits = 0, redBits = 0, greenBits = 0, blueBits = 0, alphaBits =0;
137 GLboolean rgbmode;
138 const GLuint i4 = 1;
139 const GLubyte *i1 = (GLubyte *) &i4;
140 const GLint little_endian = *i1;
141
142 rind = gind = bind = aind = 0;
143 if (format==OSMESA_COLOR_INDEX) {
144 indexBits = 8;
145 rshift = gshift = bshift = ashift = 0;
146 rgbmode = GL_FALSE;
147 }
148 else if (format==OSMESA_RGBA) {
149 indexBits = 0;
150 redBits = CHAN_BITS;
151 greenBits = CHAN_BITS;
152 blueBits = CHAN_BITS;
153 alphaBits = CHAN_BITS;
154 rind = 0;
155 gind = 1;
156 bind = 2;
157 aind = 3;
158 if (little_endian) {
159 rshift = 0;
160 gshift = 8;
161 bshift = 16;
162 ashift = 24;
163 }
164 else {
165 rshift = 24;
166 gshift = 16;
167 bshift = 8;
168 ashift = 0;
169 }
170 rgbmode = GL_TRUE;
171 }
172 else if (format==OSMESA_BGRA) {
173 indexBits = 0;
174 redBits = CHAN_BITS;
175 greenBits = CHAN_BITS;
176 blueBits = CHAN_BITS;
177 alphaBits = CHAN_BITS;
178 bind = 0;
179 gind = 1;
180 rind = 2;
181 aind = 3;
182 if (little_endian) {
183 bshift = 0;
184 gshift = 8;
185 rshift = 16;
186 ashift = 24;
187 }
188 else {
189 bshift = 24;
190 gshift = 16;
191 rshift = 8;
192 ashift = 0;
193 }
194 rgbmode = GL_TRUE;
195 }
196 else if (format==OSMESA_ARGB) {
197 indexBits = 0;
198 redBits = CHAN_BITS;
199 greenBits = CHAN_BITS;
200 blueBits = CHAN_BITS;
201 alphaBits = CHAN_BITS;
202 aind = 0;
203 rind = 1;
204 gind = 2;
205 bind = 3;
206 if (little_endian) {
207 ashift = 0;
208 rshift = 8;
209 gshift = 16;
210 bshift = 24;
211 }
212 else {
213 ashift = 24;
214 rshift = 16;
215 gshift = 8;
216 bshift = 0;
217 }
218 rgbmode = GL_TRUE;
219 }
220 else if (format==OSMESA_RGB) {
221 indexBits = 0;
222 redBits = CHAN_BITS;
223 greenBits = CHAN_BITS;
224 blueBits = CHAN_BITS;
225 alphaBits = 0;
226 bshift = 0;
227 gshift = 8;
228 rshift = 16;
229 ashift = 24;
230 rind = 0;
231 gind = 1;
232 bind = 2;
233 rgbmode = GL_TRUE;
234 }
235 else if (format==OSMESA_BGR) {
236 indexBits = 0;
237 redBits = CHAN_BITS;
238 greenBits = CHAN_BITS;
239 blueBits = CHAN_BITS;
240 alphaBits = 0;
241 bshift = 0;
242 gshift = 8;
243 rshift = 16;
244 ashift = 24;
245 rind = 2;
246 gind = 1;
247 bind = 0;
248 rgbmode = GL_TRUE;
249 }
250 else if (format==OSMESA_RGB_565) {
251 indexBits = 0;
252 redBits = 5;
253 greenBits = 6;
254 blueBits = 5;
255 alphaBits = 0;
256 rshift = 11;
257 gshift = 5;
258 bshift = 0;
259 ashift = 0;
260 rind = 0; /* not used */
261 gind = 0;
262 bind = 0;
263 rgbmode = GL_TRUE;
264 }
265 else {
266 return NULL;
267 }
268
269
270 osmesa = (OSMesaContext) CALLOC_STRUCT(osmesa_context);
271 if (osmesa) {
272 osmesa->gl_visual = _mesa_create_visual( rgbmode,
273 GL_FALSE, /* double buffer */
274 GL_FALSE, /* stereo */
275 redBits,
276 greenBits,
277 blueBits,
278 alphaBits,
279 indexBits,
280 depthBits,
281 stencilBits,
282 accumBits,
283 accumBits,
284 accumBits,
285 alphaBits ? accumBits : 0,
286 1 /* num samples */
287 );
288 if (!osmesa->gl_visual) {
289 FREE(osmesa);
290 return NULL;
291 }
292
293 if (!_mesa_initialize_context(&osmesa->gl_ctx,
294 osmesa->gl_visual,
295 sharelist ? &sharelist->gl_ctx
296 : (GLcontext *) NULL,
297 (void *) osmesa,
298 GL_FALSE)) {
299 _mesa_destroy_visual( osmesa->gl_visual );
300 FREE(osmesa);
301 return NULL;
302 }
303
304 _mesa_enable_sw_extensions(&(osmesa->gl_ctx));
305 _mesa_enable_1_3_extensions(&(osmesa->gl_ctx));
306 /*_mesa_enable_1_4_extensions(&(osmesa->gl_ctx));*/
307
308 osmesa->gl_buffer = _mesa_create_framebuffer( osmesa->gl_visual,
309 (GLboolean) ( osmesa->gl_visual->depthBits > 0 ),
310 (GLboolean) ( osmesa->gl_visual->stencilBits > 0 ),
311 (GLboolean) ( osmesa->gl_visual->accumRedBits > 0 ),
312 GL_FALSE /* s/w alpha */ );
313
314 if (!osmesa->gl_buffer) {
315 _mesa_destroy_visual( osmesa->gl_visual );
316 _mesa_free_context_data( &osmesa->gl_ctx );
317 FREE(osmesa);
318 return NULL;
319 }
320 osmesa->format = format;
321 osmesa->buffer = NULL;
322 osmesa->width = 0;
323 osmesa->height = 0;
324 osmesa->userRowLength = 0;
325 osmesa->rowlength = 0;
326 osmesa->yup = GL_TRUE;
327 osmesa->rshift = rshift;
328 osmesa->gshift = gshift;
329 osmesa->bshift = bshift;
330 osmesa->ashift = ashift;
331 osmesa->rInd = rind;
332 osmesa->gInd = gind;
333 osmesa->bInd = bind;
334 osmesa->aInd = aind;
335
336
337 /* Initialize the software rasterizer and helper modules.
338 */
339 {
340 GLcontext *ctx = &osmesa->gl_ctx;
341
342 _swrast_CreateContext( ctx );
343 _ac_CreateContext( ctx );
344 _tnl_CreateContext( ctx );
345 _swsetup_CreateContext( ctx );
346
347 _swsetup_Wakeup( ctx );
348 osmesa_register_swrast_functions( ctx );
349 }
350 }
351 return osmesa;
352 }
353
354
355
356
357 /*
358 * Destroy an Off-Screen Mesa rendering context.
359 *
360 * Input: ctx - the context to destroy
361 */
362 GLAPI void GLAPIENTRY OSMesaDestroyContext( OSMesaContext ctx )
363 {
364 if (ctx) {
365 _swsetup_DestroyContext( &ctx->gl_ctx );
366 _tnl_DestroyContext( &ctx->gl_ctx );
367 _ac_DestroyContext( &ctx->gl_ctx );
368 _swrast_DestroyContext( &ctx->gl_ctx );
369
370 _mesa_destroy_visual( ctx->gl_visual );
371 _mesa_destroy_framebuffer( ctx->gl_buffer );
372 _mesa_free_context_data( &ctx->gl_ctx );
373 FREE( ctx );
374 }
375 }
376
377
378
379 /*
380 * Recompute the values of the context's rowaddr array.
381 */
382 static void compute_row_addresses( OSMesaContext ctx )
383 {
384 GLint bytesPerPixel, bytesPerRow, i;
385 GLubyte *origin = (GLubyte *) ctx->buffer;
386
387 if (ctx->format == OSMESA_COLOR_INDEX) {
388 /* CI mode */
389 bytesPerPixel = 1 * sizeof(GLchan);
390 }
391 else if ((ctx->format == OSMESA_RGB) || (ctx->format == OSMESA_BGR)) {
392 /* RGB mode */
393 bytesPerPixel = 3 * sizeof(GLchan);
394 }
395 else if (ctx->format == OSMESA_RGB_565) {
396 /* 5/6/5 RGB pixel in 16 bits */
397 bytesPerPixel = 2;
398 }
399 else {
400 /* RGBA mode */
401 bytesPerPixel = 4 * sizeof(GLchan);
402 }
403
404 bytesPerRow = ctx->rowlength * bytesPerPixel;
405
406 if (ctx->yup) {
407 /* Y=0 is bottom line of window */
408 for (i = 0; i < MAX_HEIGHT; i++) {
409 ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + i * bytesPerRow);
410 }
411 }
412 else {
413 /* Y=0 is top line of window */
414 for (i = 0; i < MAX_HEIGHT; i++) {
415 GLint j = ctx->height - i - 1;
416 ctx->rowaddr[i] = (GLchan *) ((GLubyte *) origin + j * bytesPerRow);
417 }
418 }
419 }
420
421
422 /*
423 * Bind an OSMesaContext to an image buffer. The image buffer is just a
424 * block of memory which the client provides. Its size must be at least
425 * as large as width*height*sizeof(type). Its address should be a multiple
426 * of 4 if using RGBA mode.
427 *
428 * Image data is stored in the order of glDrawPixels: row-major order
429 * with the lower-left image pixel stored in the first array position
430 * (ie. bottom-to-top).
431 *
432 * If the context's viewport hasn't been initialized yet, it will now be
433 * initialized to (0,0,width,height).
434 *
435 * Input: ctx - the rendering context
436 * buffer - the image buffer memory
437 * type - data type for pixel components
438 * Normally, only GL_UNSIGNED_BYTE and GL_UNSIGNED_SHORT_5_6_5
439 * are supported. But if Mesa's been compiled with CHAN_BITS==16
440 * then type must be GL_UNSIGNED_SHORT. And if Mesa's been build
441 * with CHAN_BITS==32 then type must be GL_FLOAT.
442 * width, height - size of image buffer in pixels, at least 1
443 * Return: GL_TRUE if success, GL_FALSE if error because of invalid ctx,
444 * invalid buffer address, invalid type, width<1, height<1,
445 * width>internal limit or height>internal limit.
446 */
447 GLAPI GLboolean GLAPIENTRY
448 OSMesaMakeCurrent( OSMesaContext ctx, void *buffer, GLenum type,
449 GLsizei width, GLsizei height )
450 {
451 if (!ctx || !buffer ||
452 width < 1 || height < 1 ||
453 width > MAX_WIDTH || height > MAX_HEIGHT) {
454 return GL_FALSE;
455 }
456
457 if (ctx->format == OSMESA_RGB_565) {
458 if (type != GL_UNSIGNED_SHORT_5_6_5)
459 return GL_FALSE;
460 }
461 else if (type != CHAN_TYPE) {
462 return GL_FALSE;
463 }
464
465 osmesa_update_state( &ctx->gl_ctx, 0 );
466 _mesa_make_current( &ctx->gl_ctx, ctx->gl_buffer );
467
468 ctx->buffer = buffer;
469 ctx->width = width;
470 ctx->height = height;
471 if (ctx->userRowLength)
472 ctx->rowlength = ctx->userRowLength;
473 else
474 ctx->rowlength = width;
475
476 compute_row_addresses( ctx );
477
478 /* init viewport */
479 if (ctx->gl_ctx.Viewport.Width == 0) {
480 /* initialize viewport and scissor box to buffer size */
481 _mesa_Viewport( 0, 0, width, height );
482 ctx->gl_ctx.Scissor.Width = width;
483 ctx->gl_ctx.Scissor.Height = height;
484 }
485 else {
486 /* this will make ensure we recognize the new buffer size */
487 _mesa_ResizeBuffersMESA();
488 }
489
490 /* Added by Gerk Huisma: */
491 _tnl_MakeCurrent( &ctx->gl_ctx, ctx->gl_ctx.DrawBuffer,
492 ctx->gl_ctx.ReadBuffer );
493
494 return GL_TRUE;
495 }
496
497
498
499 GLAPI OSMesaContext GLAPIENTRY OSMesaGetCurrentContext( void )
500 {
501 GLcontext *ctx = _mesa_get_current_context();
502 if (ctx)
503 return (OSMesaContext) ctx;
504 else
505 return NULL;
506 }
507
508
509
510 GLAPI void GLAPIENTRY OSMesaPixelStore( GLint pname, GLint value )
511 {
512 OSMesaContext ctx = OSMesaGetCurrentContext();
513
514 switch (pname) {
515 case OSMESA_ROW_LENGTH:
516 if (value<0) {
517 _mesa_error( &ctx->gl_ctx, GL_INVALID_VALUE,
518 "OSMesaPixelStore(value)" );
519 return;
520 }
521 ctx->userRowLength = value;
522 ctx->rowlength = value;
523 break;
524 case OSMESA_Y_UP:
525 ctx->yup = value ? GL_TRUE : GL_FALSE;
526 break;
527 default:
528 _mesa_error( &ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaPixelStore(pname)" );
529 return;
530 }
531
532 compute_row_addresses( ctx );
533 }
534
535
536 GLAPI void GLAPIENTRY OSMesaGetIntegerv( GLint pname, GLint *value )
537 {
538 OSMesaContext ctx = OSMesaGetCurrentContext();
539
540 switch (pname) {
541 case OSMESA_WIDTH:
542 *value = ctx->width;
543 return;
544 case OSMESA_HEIGHT:
545 *value = ctx->height;
546 return;
547 case OSMESA_FORMAT:
548 *value = ctx->format;
549 return;
550 case OSMESA_TYPE:
551 *value = CHAN_TYPE;
552 return;
553 case OSMESA_ROW_LENGTH:
554 *value = ctx->rowlength;
555 return;
556 case OSMESA_Y_UP:
557 *value = ctx->yup;
558 return;
559 case OSMESA_MAX_WIDTH:
560 *value = MAX_WIDTH;
561 return;
562 case OSMESA_MAX_HEIGHT:
563 *value = MAX_HEIGHT;
564 return;
565 default:
566 _mesa_error(&ctx->gl_ctx, GL_INVALID_ENUM, "OSMesaGetIntergerv(pname)");
567 return;
568 }
569 }
570
571 /*
572 * Return the depth buffer associated with an OSMesa context.
573 * Input: c - the OSMesa context
574 * Output: width, height - size of buffer in pixels
575 * bytesPerValue - bytes per depth value (2 or 4)
576 * buffer - pointer to depth buffer values
577 * Return: GL_TRUE or GL_FALSE to indicate success or failure.
578 */
579 GLAPI GLboolean GLAPIENTRY
580 OSMesaGetDepthBuffer( OSMesaContext c, GLint *width, GLint *height,
581 GLint *bytesPerValue, void **buffer )
582 {
583 if ((!c->gl_buffer) || (!c->gl_buffer->DepthBuffer)) {
584 *width = 0;
585 *height = 0;
586 *bytesPerValue = 0;
587 *buffer = 0;
588 return GL_FALSE;
589 }
590 else {
591 *width = c->gl_buffer->Width;
592 *height = c->gl_buffer->Height;
593 if (c->gl_visual->depthBits <= 16)
594 *bytesPerValue = sizeof(GLushort);
595 else
596 *bytesPerValue = sizeof(GLuint);
597 *buffer = c->gl_buffer->DepthBuffer;
598 return GL_TRUE;
599 }
600 }
601
602 /*
603 * Return the color buffer associated with an OSMesa context.
604 * Input: c - the OSMesa context
605 * Output: width, height - size of buffer in pixels
606 * format - the pixel format (OSMESA_FORMAT)
607 * buffer - pointer to color buffer values
608 * Return: GL_TRUE or GL_FALSE to indicate success or failure.
609 */
610 GLAPI GLboolean GLAPIENTRY
611 OSMesaGetColorBuffer( OSMesaContext c, GLint *width,
612 GLint *height, GLint *format, void **buffer )
613 {
614 if (!c->buffer) {
615 *width = 0;
616 *height = 0;
617 *format = 0;
618 *buffer = 0;
619 return GL_FALSE;
620 }
621 else {
622 *width = c->width;
623 *height = c->height;
624 *format = c->format;
625 *buffer = c->buffer;
626 return GL_TRUE;
627 }
628 }
629
630
631
632 struct name_address {
633 const char *Name;
634 GLvoid *Address;
635 };
636
637 static struct name_address functions[] = {
638 { "OSMesaCreateContext", (void *) OSMesaCreateContext },
639 { "OSMesaCreateContextExt", (void *) OSMesaCreateContextExt },
640 { "OSMesaDestroyContext", (void *) OSMesaDestroyContext },
641 { "OSMesaMakeCurrent", (void *) OSMesaMakeCurrent },
642 { "OSMesaGetCurrentContext", (void *) OSMesaGetCurrentContext },
643 { "OSMesaPixelsStore", (void *) OSMesaPixelStore },
644 { "OSMesaGetIntegerv", (void *) OSMesaGetIntegerv },
645 { "OSMesaGetDepthBuffer", (void *) OSMesaGetDepthBuffer },
646 { "OSMesaGetColorBuffer", (void *) OSMesaGetColorBuffer },
647 { "OSMesaGetProcAddress", (void *) OSMesaGetProcAddress },
648 { NULL, NULL }
649 };
650
651 GLAPI void * GLAPIENTRY
652 OSMesaGetProcAddress( const char *funcName )
653 {
654 int i;
655 for (i = 0; functions[i].Name; i++) {
656 if (strcmp(functions[i].Name, funcName) == 0)
657 return (void *) functions[i].Address;
658 }
659 return (void *) _glapi_get_proc_address(funcName);
660 }
661
662
663 /**********************************************************************/
664 /*** Device Driver Functions ***/
665 /**********************************************************************/
666
667
668 /*
669 * Useful macros:
670 */
671
672 #if CHAN_TYPE == GL_FLOAT
673 #define PACK_RGBA(DST, R, G, B, A) \
674 do { \
675 (DST)[0] = MAX2( R, 0.0F ); \
676 (DST)[1] = MAX2( G, 0.0F ); \
677 (DST)[2] = MAX2( B, 0.0F ); \
678 (DST)[3] = CLAMP(A, 0.0F, CHAN_MAXF);\
679 } while (0)
680 #else
681 #define PACK_RGBA(DST, R, G, B, A) \
682 do { \
683 (DST)[osmesa->rInd] = R; \
684 (DST)[osmesa->gInd] = G; \
685 (DST)[osmesa->bInd] = B; \
686 (DST)[osmesa->aInd] = A; \
687 } while (0)
688 #endif
689
690 #define PACK_RGB(DST, R, G, B) \
691 do { \
692 (DST)[0] = R; \
693 (DST)[1] = G; \
694 (DST)[2] = B; \
695 } while (0)
696
697 #define PACK_BGR(DST, R, G, B) \
698 do { \
699 (DST)[0] = B; \
700 (DST)[1] = G; \
701 (DST)[2] = R; \
702 } while (0)
703
704 #define PACK_RGB_565(DST, R, G, B) \
705 do { \
706 (DST) = (((int) (R) << 8) & 0xf800) | (((int) (G) << 3) & 0x7e0) | ((int) (B) >> 3);\
707 } while (0)
708
709
710 #define UNPACK_RED(P) ( (P)[osmesa->rInd] )
711 #define UNPACK_GREEN(P) ( (P)[osmesa->gInd] )
712 #define UNPACK_BLUE(P) ( (P)[osmesa->bInd] )
713 #define UNPACK_ALPHA(P) ( (P)[osmesa->aInd] )
714
715
716 #define PIXELADDR1(X,Y) (osmesa->rowaddr[Y] + (X))
717 #define PIXELADDR2(X,Y) (osmesa->rowaddr[Y] + 2 * (X))
718 #define PIXELADDR3(X,Y) (osmesa->rowaddr[Y] + 3 * (X))
719 #define PIXELADDR4(X,Y) (osmesa->rowaddr[Y] + 4 * (X))
720
721
722
723 static void set_buffer( GLcontext *ctx, GLframebuffer *buffer, GLuint bufferBit )
724 {
725 /* separate read buffer not supported */
726 ASSERT(buffer == ctx->DrawBuffer);
727 ASSERT(bufferBit == FRONT_LEFT_BIT);
728 }
729
730
731 static void clear( GLcontext *ctx, GLbitfield mask, GLboolean all,
732 GLint x, GLint y, GLint width, GLint height )
733 {
734 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
735 const GLuint *colorMask = (GLuint *) &ctx->Color.ColorMask;
736
737 /* sanity check - we only have a front-left buffer */
738 ASSERT((mask & (DD_FRONT_RIGHT_BIT | DD_BACK_LEFT_BIT | DD_BACK_RIGHT_BIT)) == 0);
739 if (*colorMask == 0xffffffff && ctx->Color.IndexMask == 0xffffffff) {
740 if (mask & DD_FRONT_LEFT_BIT) {
741 if (osmesa->format == OSMESA_COLOR_INDEX) {
742 if (all) {
743 /* Clear whole CI buffer */
744 #if CHAN_TYPE == GL_UNSIGNED_BYTE
745 MEMSET(osmesa->buffer, ctx->Color.ClearIndex,
746 osmesa->rowlength * osmesa->height);
747 #else
748 const GLint n = osmesa->rowlength * osmesa->height;
749 GLchan *buffer = (GLchan *) osmesa->buffer;
750 GLint i;
751 for (i = 0; i < n; i ++) {
752 buffer[i] = ctx->Color.ClearIndex;
753 }
754 #endif
755 }
756 else {
757 /* Clear part of CI buffer */
758 const GLchan clearIndex = (GLchan) ctx->Color.ClearIndex;
759 GLint i, j;
760 for (i = 0; i < height; i++) {
761 GLchan *ptr1 = PIXELADDR1(x, (y + i));
762 for (j = 0; j < width; j++) {
763 *ptr1++ = clearIndex;
764 }
765 }
766 }
767 }
768 else if (osmesa->format == OSMESA_RGB) {
769 GLchan r, g, b;
770 CLAMPED_FLOAT_TO_CHAN(r, ctx->Color.ClearColor[0]);
771 CLAMPED_FLOAT_TO_CHAN(g, ctx->Color.ClearColor[1]);
772 CLAMPED_FLOAT_TO_CHAN(b, ctx->Color.ClearColor[2]);
773 if (all) {
774 /* Clear whole RGB buffer */
775 GLuint n = osmesa->rowlength * osmesa->height;
776 GLchan *ptr3 = (GLchan *) osmesa->buffer;
777 GLuint i;
778 for (i = 0; i < n; i++) {
779 PACK_RGB(ptr3, r, g, b);
780 ptr3 += 3;
781 }
782 }
783 else {
784 /* Clear part of RGB buffer */
785 GLint i, j;
786 for (i = 0; i < height; i++) {
787 GLchan *ptr3 = PIXELADDR3(x, (y + i));
788 for (j = 0; j < width; j++) {
789 PACK_RGB(ptr3, r, g, b);
790 ptr3 += 3;
791 }
792 }
793 }
794 }
795 else if (osmesa->format == OSMESA_BGR) {
796 GLchan r, g, b;
797 CLAMPED_FLOAT_TO_CHAN(r, ctx->Color.ClearColor[0]);
798 CLAMPED_FLOAT_TO_CHAN(g, ctx->Color.ClearColor[1]);
799 CLAMPED_FLOAT_TO_CHAN(b, ctx->Color.ClearColor[2]);
800 if (all) {
801 /* Clear whole RGB buffer */
802 const GLint n = osmesa->rowlength * osmesa->height;
803 GLchan *ptr3 = (GLchan *) osmesa->buffer;
804 GLint i;
805 for (i = 0; i < n; i++) {
806 PACK_BGR(ptr3, r, g, b);
807 ptr3 += 3;
808 }
809 }
810 else {
811 /* Clear part of RGB buffer */
812 GLint i, j;
813 for (i = 0; i < height; i++) {
814 GLchan *ptr3 = PIXELADDR3(x, (y + i));
815 for (j = 0; j < width; j++) {
816 PACK_BGR(ptr3, r, g, b);
817 ptr3 += 3;
818 }
819 }
820 }
821 }
822 else if (osmesa->format == OSMESA_RGB_565) {
823 GLushort clearPixel;
824 GLchan r, g, b;
825 CLAMPED_FLOAT_TO_CHAN(r, ctx->Color.ClearColor[0]);
826 CLAMPED_FLOAT_TO_CHAN(g, ctx->Color.ClearColor[1]);
827 CLAMPED_FLOAT_TO_CHAN(b, ctx->Color.ClearColor[2]);
828 PACK_RGB_565(clearPixel, r, g, b);
829 if (all) {
830 /* Clear whole RGB buffer */
831 const GLuint n = osmesa->rowlength * osmesa->height;
832 GLushort *ptr2 = (GLushort *) osmesa->buffer;
833 GLuint i;
834 for (i = 0; i < n; i++) {
835 *ptr2 = clearPixel;
836 ptr2++;
837 }
838 }
839 else {
840 /* clear scissored region */
841 GLint i, j;
842 for (i = 0; i < height; i++) {
843 GLushort *ptr2 = (GLushort *) PIXELADDR2(x, (y + i));
844 for (j = 0; j < width; j++) {
845 *ptr2 = clearPixel;
846 ptr2++;
847 }
848 }
849 }
850 }
851 else {
852 #if CHAN_TYPE == GL_UNSIGNED_BYTE
853 /* 4-byte pixel value */
854 GLuint clearPixel;
855 GLchan *clr = (GLchan *) &clearPixel;
856 CLAMPED_FLOAT_TO_CHAN(clr[osmesa->rInd], ctx->Color.ClearColor[0]);
857 CLAMPED_FLOAT_TO_CHAN(clr[osmesa->gInd], ctx->Color.ClearColor[1]);
858 CLAMPED_FLOAT_TO_CHAN(clr[osmesa->bInd], ctx->Color.ClearColor[2]);
859 CLAMPED_FLOAT_TO_CHAN(clr[osmesa->aInd], ctx->Color.ClearColor[3]);
860 if (all) {
861 /* Clear whole RGBA buffer */
862 const GLuint n = osmesa->rowlength * osmesa->height;
863 GLuint *ptr4 = (GLuint *) osmesa->buffer;
864 GLuint i;
865 if (clearPixel) {
866 for (i = 0; i < n; i++) {
867 *ptr4++ = clearPixel;
868 }
869 }
870 else {
871 BZERO(ptr4, n * sizeof(GLuint));
872 }
873 }
874 else {
875 /* Clear part of RGBA buffer */
876 GLint i, j;
877 for (i = 0; i < height; i++) {
878 GLuint *ptr4 = (GLuint *) PIXELADDR4(x, (y + i));
879 for (j = 0; j < width; j++) {
880 *ptr4++ = clearPixel;
881 }
882 }
883 }
884 #else
885 GLchan r, g, b, a;
886 CLAMPED_FLOAT_TO_CHAN(r, ctx->Color.ClearColor[0]);
887 CLAMPED_FLOAT_TO_CHAN(g, ctx->Color.ClearColor[1]);
888 CLAMPED_FLOAT_TO_CHAN(b, ctx->Color.ClearColor[2]);
889 CLAMPED_FLOAT_TO_CHAN(a, ctx->Color.ClearColor[3]);
890 if (all) {
891 /* Clear whole RGBA buffer */
892 const GLuint n = osmesa->rowlength * osmesa->height;
893 GLchan *p = (GLchan *) osmesa->buffer;
894 GLuint i;
895 for (i = 0; i < n; i++) {
896 PACK_RGBA(p, r, g, b, a);
897 p += 4;
898 }
899 }
900 else {
901 /* Clear part of RGBA buffer */
902 GLint i, j;
903 for (i = 0; i < height; i++) {
904 GLchan *p = PIXELADDR4(x, (y + i));
905 for (j = 0; j < width; j++) {
906 PACK_RGBA(p, r, g, b, a);
907 p += 4;
908 }
909 }
910 }
911
912 #endif
913 }
914 mask &= ~DD_FRONT_LEFT_BIT;
915 }
916 }
917
918 if (mask)
919 _swrast_Clear( ctx, mask, all, x, y, width, height );
920 }
921
922
923
924 static void buffer_size( GLframebuffer *buffer, GLuint *width, GLuint *height )
925 {
926 /* don't use GET_CURRENT_CONTEXT(ctx) here - it's a problem on Windows */
927 GLcontext *ctx = (GLcontext *) _glapi_get_context();
928 (void) buffer;
929 if (ctx) {
930 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
931 *width = osmesa->width;
932 *height = osmesa->height;
933 }
934 }
935
936
937 /**********************************************************************/
938 /***** Read/write spans/arrays of RGBA pixels *****/
939 /**********************************************************************/
940
941 /* Write RGBA pixels to an RGBA (or permuted) buffer. */
942 static void
943 write_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
944 CONST GLchan rgba[][4], const GLubyte mask[] )
945 {
946 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
947 GLchan *p = PIXELADDR4(x, y);
948 GLuint i;
949 if (mask) {
950 for (i = 0; i < n; i++, p += 4) {
951 if (mask[i]) {
952 PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
953 rgba[i][BCOMP], rgba[i][ACOMP]);
954 }
955 }
956 }
957 else {
958 for (i = 0; i < n; i++, p += 4) {
959 PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
960 rgba[i][BCOMP], rgba[i][ACOMP]);
961 }
962 }
963 }
964
965
966 /* Write RGBA pixels to an RGBA buffer. This is the fastest span-writer. */
967 static void
968 write_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
969 CONST GLchan rgba[][4], const GLubyte mask[] )
970 {
971 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
972 GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
973 const GLuint *rgba4 = (const GLuint *) rgba;
974 GLuint i;
975 ASSERT(CHAN_TYPE == GL_UNSIGNED_BYTE);
976 if (mask) {
977 for (i = 0; i < n; i++) {
978 if (mask[i]) {
979 ptr4[i] = rgba4[i];
980 }
981 }
982 }
983 else {
984 MEMCPY( ptr4, rgba4, n * 4 );
985 }
986 }
987
988
989 /* Write RGB pixels to an RGBA (or permuted) buffer. */
990 static void
991 write_rgb_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
992 CONST GLchan rgb[][3], const GLubyte mask[] )
993 {
994 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
995 GLchan *p = PIXELADDR4(x, y);
996 GLuint i;
997 if (mask) {
998 for (i = 0; i < n; i++, p+=4) {
999 if (mask[i]) {
1000 PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], CHAN_MAX);
1001 }
1002 }
1003 }
1004 else {
1005 for (i = 0; i < n; i++, p+=4) {
1006 PACK_RGBA(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP], CHAN_MAX);
1007 }
1008 }
1009 }
1010
1011
1012
1013 static void
1014 write_monocolor_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1015 const GLchan color[4], const GLubyte mask[] )
1016 {
1017 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1018 GLchan *p = PIXELADDR4(x, y);
1019 GLuint i;
1020 for (i = 0; i < n; i++, p += 4) {
1021 if (mask[i]) {
1022 PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]);
1023 }
1024 }
1025 }
1026
1027
1028
1029 static void
1030 write_rgba_pixels( const GLcontext *ctx, GLuint n,
1031 const GLint x[], const GLint y[],
1032 CONST GLchan rgba[][4], const GLubyte mask[] )
1033 {
1034 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1035 GLuint i;
1036 for (i = 0; i < n; i++) {
1037 if (mask[i]) {
1038 GLchan *p = PIXELADDR4(x[i], y[i]);
1039 PACK_RGBA(p, rgba[i][RCOMP], rgba[i][GCOMP],
1040 rgba[i][BCOMP], rgba[i][ACOMP]);
1041 }
1042 }
1043 }
1044
1045
1046
1047 static void
1048 write_monocolor_pixels( const GLcontext *ctx, GLuint n,
1049 const GLint x[], const GLint y[],
1050 const GLchan color[4], const GLubyte mask[] )
1051 {
1052 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1053 GLuint i;
1054 for (i = 0; i < n; i++) {
1055 if (mask[i]) {
1056 GLchan *p = PIXELADDR4(x[i], y[i]);
1057 PACK_RGBA(p, color[RCOMP], color[GCOMP], color[BCOMP], color[ACOMP]);
1058 }
1059 }
1060 }
1061
1062
1063 static void
1064 read_rgba_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1065 GLchan rgba[][4] )
1066 {
1067 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1068 GLuint i;
1069 GLchan *p = PIXELADDR4(x, y);
1070 for (i = 0; i < n; i++, p += 4) {
1071 rgba[i][RCOMP] = UNPACK_RED(p);
1072 rgba[i][GCOMP] = UNPACK_GREEN(p);
1073 rgba[i][BCOMP] = UNPACK_BLUE(p);
1074 rgba[i][ACOMP] = UNPACK_ALPHA(p);
1075 }
1076 }
1077
1078
1079 /* Read RGBA pixels from an RGBA buffer */
1080 static void
1081 read_rgba_span_rgba( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1082 GLchan rgba[][4] )
1083 {
1084 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1085 GLuint *ptr4 = (GLuint *) PIXELADDR4(x, y);
1086 MEMCPY( rgba, ptr4, n * 4 * sizeof(GLchan) );
1087 }
1088
1089
1090 static void
1091 read_rgba_pixels( const GLcontext *ctx,
1092 GLuint n, const GLint x[], const GLint y[],
1093 GLchan rgba[][4], const GLubyte mask[] )
1094 {
1095 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1096 GLuint i;
1097 for (i = 0; i < n; i++) {
1098 if (mask[i]) {
1099 const GLchan *p = PIXELADDR4(x[i], y[i]);
1100 rgba[i][RCOMP] = UNPACK_RED(p);
1101 rgba[i][GCOMP] = UNPACK_GREEN(p);
1102 rgba[i][BCOMP] = UNPACK_BLUE(p);
1103 rgba[i][ACOMP] = UNPACK_ALPHA(p);
1104 }
1105 }
1106 }
1107
1108 /**********************************************************************/
1109 /***** 3 byte RGB pixel support funcs *****/
1110 /**********************************************************************/
1111
1112 /* Write RGBA pixels to an RGB buffer. */
1113 static void
1114 write_rgba_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1115 CONST GLchan rgba[][4], const GLubyte mask[] )
1116 {
1117 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1118 GLchan *p = PIXELADDR3(x, y);
1119 GLuint i;
1120 if (mask) {
1121 for (i = 0; i < n; i++, p += 3) {
1122 if (mask[i]) {
1123 PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
1124 }
1125 }
1126 }
1127 else {
1128 for (i = 0; i < n; i++, p += 3) {
1129 PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
1130 }
1131 }
1132 }
1133
1134 /* Write RGBA pixels to an BGR buffer. */
1135 static void
1136 write_rgba_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1137 CONST GLchan rgba[][4], const GLubyte mask[] )
1138 {
1139 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1140 GLchan *p = PIXELADDR3(x, y);
1141 GLuint i;
1142 if (mask) {
1143 for (i = 0; i < n; i++, p += 3) {
1144 if (mask[i]) {
1145 PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
1146 }
1147 }
1148 }
1149 else {
1150 for (i = 0; i < n; i++, p += 3) {
1151 PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
1152 }
1153 }
1154 }
1155
1156 /* Write RGB pixels to an RGB buffer. */
1157 static void
1158 write_rgb_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1159 CONST GLchan rgb[][3], const GLubyte mask[] )
1160 {
1161 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1162 GLchan *p = PIXELADDR3(x, y);
1163 GLuint i;
1164 if (mask) {
1165 for (i = 0; i < n; i++, p += 3) {
1166 if (mask[i]) {
1167 PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
1168 }
1169 }
1170 }
1171 else {
1172 for (i = 0; i < n; i++, p += 3) {
1173 PACK_RGB(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
1174 }
1175 }
1176 }
1177
1178 /* Write RGB pixels to an BGR buffer. */
1179 static void
1180 write_rgb_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1181 CONST GLchan rgb[][3], const GLubyte mask[] )
1182 {
1183 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1184 GLchan *p = PIXELADDR3(x, y);
1185 GLuint i;
1186 if (mask) {
1187 for (i = 0; i < n; i++, p += 3) {
1188 if (mask[i]) {
1189 PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
1190 }
1191 }
1192 }
1193 else {
1194 for (i = 0; i < n; i++, p += 3) {
1195 PACK_BGR(p, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
1196 }
1197 }
1198 }
1199
1200
1201 static void
1202 write_monocolor_span_RGB( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1203 const GLchan color[4], const GLubyte mask[] )
1204 {
1205 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1206 GLchan *p = PIXELADDR3(x, y);
1207 GLuint i;
1208 for (i = 0; i < n; i++, p += 3) {
1209 if (mask[i]) {
1210 PACK_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
1211 }
1212 }
1213 }
1214
1215 static void
1216 write_monocolor_span_BGR( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1217 const GLchan color[4], const GLubyte mask[] )
1218 {
1219 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1220 GLchan *p = PIXELADDR3(x, y);
1221 GLuint i;
1222 for (i = 0; i < n; i++, p += 3) {
1223 if (mask[i]) {
1224 PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
1225 }
1226 }
1227 }
1228
1229 static void
1230 write_rgba_pixels_RGB( const GLcontext *ctx, GLuint n,
1231 const GLint x[], const GLint y[],
1232 CONST GLchan rgba[][4], const GLubyte mask[] )
1233 {
1234 const OSMesaContext osmesa = (const OSMesaContext) ctx;
1235 GLuint i;
1236 for (i = 0; i < n; i++) {
1237 if (mask[i]) {
1238 GLchan *p = PIXELADDR3(x[i], y[i]);
1239 PACK_RGB(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
1240 }
1241 }
1242 }
1243
1244 static void
1245 write_rgba_pixels_BGR( const GLcontext *ctx, GLuint n,
1246 const GLint x[], const GLint y[],
1247 CONST GLchan rgba[][4], const GLubyte mask[] )
1248 {
1249 const OSMesaContext osmesa = (const OSMesaContext) ctx;
1250 GLuint i;
1251 for (i = 0; i < n; i++) {
1252 if (mask[i]) {
1253 GLchan *p = PIXELADDR3(x[i], y[i]);
1254 PACK_BGR(p, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
1255 }
1256 }
1257 }
1258
1259 static void
1260 write_monocolor_pixels_RGB( const GLcontext *ctx,
1261 GLuint n, const GLint x[], const GLint y[],
1262 const GLchan color[4], const GLubyte mask[] )
1263 {
1264 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1265 GLuint i;
1266 for (i = 0; i < n; i++) {
1267 if (mask[i]) {
1268 GLchan *p = PIXELADDR3(x[i], y[i]);
1269 PACK_RGB(p, color[RCOMP], color[GCOMP], color[BCOMP]);
1270 }
1271 }
1272 }
1273
1274 static void
1275 write_monocolor_pixels_BGR( const GLcontext *ctx,
1276 GLuint n, const GLint x[], const GLint y[],
1277 const GLchan color[4], const GLubyte mask[] )
1278 {
1279 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1280 GLuint i;
1281 for (i = 0; i < n; i++) {
1282 if (mask[i]) {
1283 GLchan *p = PIXELADDR3(x[i], y[i]);
1284 PACK_BGR(p, color[RCOMP], color[GCOMP], color[BCOMP]);
1285 }
1286 }
1287 }
1288
1289 static void
1290 read_rgba_span3( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1291 GLchan rgba[][4] )
1292 {
1293 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1294 GLuint i;
1295 const GLchan *p = PIXELADDR3(x, y);
1296 for (i = 0; i < n; i++, p += 3) {
1297 rgba[i][RCOMP] = UNPACK_RED(p);
1298 rgba[i][GCOMP] = UNPACK_GREEN(p);
1299 rgba[i][BCOMP] = UNPACK_BLUE(p);
1300 rgba[i][ACOMP] = CHAN_MAX;
1301 }
1302 }
1303
1304 static void
1305 read_rgba_pixels3( const GLcontext *ctx,
1306 GLuint n, const GLint x[], const GLint y[],
1307 GLchan rgba[][4], const GLubyte mask[] )
1308 {
1309 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1310 GLuint i;
1311 for (i = 0; i < n; i++) {
1312 if (mask[i]) {
1313 const GLchan *p = PIXELADDR3(x[i], y[i]);
1314 rgba[i][RCOMP] = UNPACK_RED(p);
1315 rgba[i][GCOMP] = UNPACK_GREEN(p);
1316 rgba[i][BCOMP] = UNPACK_BLUE(p);
1317 rgba[i][ACOMP] = CHAN_MAX;
1318 }
1319 }
1320 }
1321
1322
1323 /**********************************************************************/
1324 /***** 2 byte RGB pixel support funcs *****/
1325 /**********************************************************************/
1326
1327 /* Write RGBA pixels to an RGB_565 buffer. */
1328 static void
1329 write_rgba_span2( const GLcontext *ctx,
1330 GLuint n, GLint x, GLint y,
1331 CONST GLchan rgba[][4], const GLubyte mask[] )
1332 {
1333 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1334 GLushort *ptr2 = (GLushort *) PIXELADDR2(x, y);
1335 GLuint i;
1336 if (mask) {
1337 for (i = 0; i < n; i++, ptr2++) {
1338 if (mask[i]) {
1339 PACK_RGB_565(*ptr2, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
1340 }
1341 }
1342 }
1343 else {
1344 for (i = 0; i < n; i++, ptr2++) {
1345 PACK_RGB_565(*ptr2, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
1346 }
1347 }
1348 }
1349
1350
1351 /* Write RGB pixels to an RGB_565 buffer. */
1352 static void
1353 write_rgb_span2( const GLcontext *ctx,
1354 GLuint n, GLint x, GLint y,
1355 CONST GLchan rgb[][3], const GLubyte mask[] )
1356 {
1357 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1358 GLushort *ptr2 = (GLushort *) PIXELADDR2(x, y);
1359 GLuint i;
1360 if (mask) {
1361 for (i = 0; i < n; i++, ptr2++) {
1362 if (mask[i]) {
1363 PACK_RGB_565(*ptr2, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
1364 }
1365 }
1366 }
1367 else {
1368 for (i = 0; i < n; i++, ptr2++) {
1369 PACK_RGB_565(*ptr2, rgb[i][RCOMP], rgb[i][GCOMP], rgb[i][BCOMP]);
1370 }
1371 }
1372 }
1373
1374
1375 static void
1376 write_monocolor_span2( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1377 const GLchan color[4], const GLubyte mask[] )
1378 {
1379 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1380 GLushort pixel;
1381 GLushort *ptr2 = (GLushort *) PIXELADDR2(x, y);
1382 GLuint i;
1383 PACK_RGB_565(pixel, color[RCOMP], color[GCOMP], color[BCOMP]);
1384 for (i = 0; i < n; i++, ptr2++) {
1385 if (mask[i]) {
1386 *ptr2 = pixel;
1387 }
1388 }
1389 }
1390
1391
1392 static void
1393 write_rgba_pixels2( const GLcontext *ctx,
1394 GLuint n, const GLint x[], const GLint y[],
1395 CONST GLchan rgba[][4], const GLubyte mask[] )
1396 {
1397 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1398 GLuint i;
1399 for (i = 0; i < n; i++) {
1400 if (mask[i]) {
1401 GLushort *ptr2 = (GLushort *) PIXELADDR2(x[i],y[i]);
1402 PACK_RGB_565(*ptr2, rgba[i][RCOMP], rgba[i][GCOMP], rgba[i][BCOMP]);
1403 }
1404 }
1405 }
1406
1407 static void
1408 write_monocolor_pixels2( const GLcontext *ctx,
1409 GLuint n, const GLint x[], const GLint y[],
1410 const GLchan color[4], const GLubyte mask[] )
1411 {
1412 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1413 GLuint i;
1414 GLushort pixel;
1415 PACK_RGB_565(pixel, color[RCOMP], color[GCOMP], color[BCOMP]);
1416 for (i = 0; i < n; i++) {
1417 if (mask[i]) {
1418 GLushort *ptr2 = (GLushort *) PIXELADDR2(x[i],y[i]);
1419 *ptr2 = pixel;
1420 }
1421 }
1422 }
1423
1424 static void
1425 read_rgba_span2( const GLcontext *ctx,
1426 GLuint n, GLint x, GLint y,
1427 GLchan rgba[][4] )
1428 {
1429 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1430 GLuint i;
1431 const GLushort *ptr2 = (const GLushort *) PIXELADDR2(x, y);
1432 for (i = 0; i < n; i++, ptr2++) {
1433 /* This should be fixed to get the low bits right */
1434 rgba[i][RCOMP] = (*ptr2 >> 8) & 0xFe;
1435 rgba[i][GCOMP] = (*ptr2 >> 3) & 0xFc;
1436 rgba[i][BCOMP] = (*ptr2 << 3) & 0xFe;
1437 rgba[i][ACOMP] = 0;
1438 }
1439 }
1440
1441 static void
1442 read_rgba_pixels2( const GLcontext *ctx,
1443 GLuint n, const GLint x[], const GLint y[],
1444 GLchan rgba[][4], const GLubyte mask[] )
1445 {
1446 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1447 GLuint i;
1448 for (i = 0; i < n; i++) {
1449 if (mask[i]) {
1450 /* This should be fixed to get the low bits right */
1451 const GLushort *ptr2 = (const GLushort *) PIXELADDR2(x[i],y[i]);
1452 rgba[i][RCOMP] = (*ptr2 >> 8) & 0xFE;
1453 rgba[i][GCOMP] = (*ptr2 >> 3) & 0xFC;
1454 rgba[i][BCOMP] = (*ptr2 << 3) & 0xFE;
1455 rgba[i][ACOMP] = 0;
1456 }
1457 }
1458 }
1459
1460
1461
1462 /**********************************************************************/
1463 /***** Read/write spans/arrays of CI pixels *****/
1464 /**********************************************************************/
1465
1466 /* Write 32-bit color index to buffer */
1467 static void
1468 write_index32_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1469 const GLuint index[], const GLubyte mask[] )
1470 {
1471 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1472 GLchan *ptr1 = PIXELADDR1(x, y);
1473 GLuint i;
1474 if (mask) {
1475 for (i=0;i<n;i++,ptr1++) {
1476 if (mask[i]) {
1477 *ptr1 = (GLchan) index[i];
1478 }
1479 }
1480 }
1481 else {
1482 for (i=0;i<n;i++,ptr1++) {
1483 *ptr1 = (GLchan) index[i];
1484 }
1485 }
1486 }
1487
1488
1489 /* Write 8-bit color index to buffer */
1490 static void
1491 write_index8_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1492 const GLubyte index[], const GLubyte mask[] )
1493 {
1494 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1495 GLchan *ptr1 = PIXELADDR1(x, y);
1496 GLuint i;
1497 if (mask) {
1498 for (i=0;i<n;i++,ptr1++) {
1499 if (mask[i]) {
1500 *ptr1 = (GLchan) index[i];
1501 }
1502 }
1503 }
1504 else {
1505 MEMCPY(ptr1, index, n * sizeof(GLchan));
1506 }
1507 }
1508
1509
1510 static void
1511 write_monoindex_span( const GLcontext *ctx, GLuint n, GLint x, GLint y,
1512 GLuint colorIndex, const GLubyte mask[] )
1513 {
1514 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1515 GLchan *ptr1 = PIXELADDR1(x, y);
1516 GLuint i;
1517 for (i=0;i<n;i++,ptr1++) {
1518 if (mask[i]) {
1519 *ptr1 = (GLchan) colorIndex;
1520 }
1521 }
1522 }
1523
1524
1525 static void
1526 write_index_pixels( const GLcontext *ctx,
1527 GLuint n, const GLint x[], const GLint y[],
1528 const GLuint index[], const GLubyte mask[] )
1529 {
1530 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1531 GLuint i;
1532 for (i=0;i<n;i++) {
1533 if (mask[i]) {
1534 GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
1535 *ptr1 = (GLchan) index[i];
1536 }
1537 }
1538 }
1539
1540
1541 static void
1542 write_monoindex_pixels( const GLcontext *ctx,
1543 GLuint n, const GLint x[], const GLint y[],
1544 GLuint colorIndex, const GLubyte mask[] )
1545 {
1546 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1547 GLuint i;
1548 for (i=0;i<n;i++) {
1549 if (mask[i]) {
1550 GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
1551 *ptr1 = (GLchan) colorIndex;
1552 }
1553 }
1554 }
1555
1556
1557 static void
1558 read_index_span( const GLcontext *ctx,
1559 GLuint n, GLint x, GLint y, GLuint index[] )
1560 {
1561 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1562 GLuint i;
1563 const GLchan *ptr1 = (const GLchan *) PIXELADDR1(x, y);
1564 for (i=0;i<n;i++,ptr1++) {
1565 index[i] = (GLuint) *ptr1;
1566 }
1567 }
1568
1569
1570 static void
1571 read_index_pixels( const GLcontext *ctx,
1572 GLuint n, const GLint x[], const GLint y[],
1573 GLuint index[], const GLubyte mask[] )
1574 {
1575 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1576 GLuint i;
1577 for (i=0;i<n;i++) {
1578 if (mask[i] ) {
1579 const GLchan *ptr1 = PIXELADDR1(x[i], y[i]);
1580 index[i] = (GLuint) *ptr1;
1581 }
1582 }
1583 }
1584
1585
1586
1587 /**********************************************************************/
1588 /***** Optimized line rendering *****/
1589 /**********************************************************************/
1590
1591
1592 /*
1593 * Draw a flat-shaded, RGB line into an osmesa buffer.
1594 */
1595 static void
1596 flat_rgba_line( GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1 )
1597 {
1598 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1599 const GLchan *color = vert1->color;
1600
1601 #define INTERP_XY 1
1602 #define CLIP_HACK 1
1603 #define PLOT(X, Y) \
1604 do { \
1605 GLchan *p = PIXELADDR4(X, Y); \
1606 PACK_RGBA(p, color[0], color[1], color[2], color[3]); \
1607 } while (0)
1608
1609 #ifdef WIN32
1610 #include "..\swrast\s_linetemp.h"
1611 #else
1612 #include "swrast/s_linetemp.h"
1613 #endif
1614 }
1615
1616
1617 /*
1618 * Draw a flat-shaded, Z-less, RGB line into an osmesa buffer.
1619 */
1620 static void
1621 flat_rgba_z_line(GLcontext *ctx, const SWvertex *vert0, const SWvertex *vert1)
1622 {
1623 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1624 const GLchan *color = vert1->color;
1625
1626 #define INTERP_XY 1
1627 #define INTERP_Z 1
1628 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
1629 #define CLIP_HACK 1
1630 #define PLOT(X, Y) \
1631 do { \
1632 if (Z < *zPtr) { \
1633 GLchan *p = PIXELADDR4(X, Y); \
1634 PACK_RGBA(p, color[RCOMP], color[GCOMP], \
1635 color[BCOMP], color[ACOMP]); \
1636 *zPtr = Z; \
1637 } \
1638 } while (0)
1639
1640
1641 #ifdef WIN32
1642 #include "..\swrast\s_linetemp.h"
1643 #else
1644 #include "swrast/s_linetemp.h"
1645 #endif
1646 }
1647
1648
1649 /*
1650 * Draw a flat-shaded, alpha-blended, RGB line into an osmesa buffer.
1651 * XXX update for GLchan
1652 */
1653 static void
1654 flat_blend_rgba_line( GLcontext *ctx,
1655 const SWvertex *vert0, const SWvertex *vert1 )
1656 {
1657 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1658 const GLint rshift = osmesa->rshift;
1659 const GLint gshift = osmesa->gshift;
1660 const GLint bshift = osmesa->bshift;
1661 const GLint avalue = vert0->color[3];
1662 const GLint msavalue = CHAN_MAX - avalue;
1663 const GLint rvalue = vert1->color[0]*avalue;
1664 const GLint gvalue = vert1->color[1]*avalue;
1665 const GLint bvalue = vert1->color[2]*avalue;
1666
1667 #define INTERP_XY 1
1668 #define CLIP_HACK 1
1669 #define PLOT(X,Y) \
1670 { GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y); \
1671 GLuint pixel = 0; \
1672 pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift);\
1673 pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift);\
1674 pixel |=((((((*ptr4) >> bshift) & 0xff)*msavalue+bvalue)>>8) << bshift);\
1675 *ptr4 = pixel; \
1676 }
1677
1678 #if 0 /* XXX use this in the future */
1679 #define PLOT(X,Y) \
1680 { \
1681 GLchan *pixel = (GLchan *) PIXELADDR4(X, Y); \
1682 pixel[rInd] = (pixel[rInd] * msavalue + rvalue) >> CHAN_BITS; \
1683 pixel[gInd] = (pixel[gInd] * msavalue + gvalue) >> CHAN_BITS; \
1684 pixel[bInd] = (pixel[bInd] * msavalue + bvalue) >> CHAN_BITS; \
1685 pixel[aInd] = (pixel[aInd] * msavalue + avalue) >> CHAN_BITS; \
1686 }
1687 #endif
1688
1689 #ifdef WIN32
1690 #include "..\swrast\s_linetemp.h"
1691 #else
1692 #include "swrast/s_linetemp.h"
1693 #endif
1694 }
1695
1696
1697 /*
1698 * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer.
1699 * But don't write to Z buffer.
1700 * XXX update for GLchan
1701 */
1702 static void
1703 flat_blend_rgba_z_line( GLcontext *ctx,
1704 const SWvertex *vert0, const SWvertex *vert1 )
1705 {
1706 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1707 const GLint rshift = osmesa->rshift;
1708 const GLint gshift = osmesa->gshift;
1709 const GLint bshift = osmesa->bshift;
1710 const GLint avalue = vert0->color[3];
1711 const GLint msavalue = 256 - avalue;
1712 const GLint rvalue = vert1->color[0]*avalue;
1713 const GLint gvalue = vert1->color[1]*avalue;
1714 const GLint bvalue = vert1->color[2]*avalue;
1715
1716 #define INTERP_XY 1
1717 #define INTERP_Z 1
1718 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
1719 #define CLIP_HACK 1
1720 #define PLOT(X,Y) \
1721 if (Z < *zPtr) { \
1722 GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y); \
1723 GLuint pixel = 0; \
1724 pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift); \
1725 pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift); \
1726 pixel |=((((((*ptr4) >> bshift) & 0xff)*msavalue+bvalue)>>8) << bshift); \
1727 *ptr4 = pixel; \
1728 }
1729
1730 #if 0 /* XXX use this in the future */
1731 #define PLOT(X,Y) \
1732 if (Z < *zPtr) { \
1733 GLchan *pixel = (GLchan *) PIXELADDR4(X, Y); \
1734 pixel[rInd] = (pixel[rInd] * msavalue + rvalue) >> CHAN_BITS; \
1735 pixel[gInd] = (pixel[gInd] * msavalue + gvalue) >> CHAN_BITS; \
1736 pixel[bInd] = (pixel[bInd] * msavalue + bvalue) >> CHAN_BITS; \
1737 pixel[aInd] = (pixel[aInd] * msavalue + avalue) >> CHAN_BITS; \
1738 }
1739 #endif
1740
1741 #ifdef WIN32
1742 #include "..\swrast\s_linetemp.h"
1743 #else
1744 #include "swrast/s_linetemp.h"
1745 #endif
1746 }
1747
1748
1749 /*
1750 * Draw a flat-shaded, Z-less, alpha-blended, RGB line into an osmesa buffer.
1751 * XXX update for GLchan
1752 */
1753 static void
1754 flat_blend_rgba_z_line_write( GLcontext *ctx,
1755 const SWvertex *vert0, const SWvertex *vert1 )
1756 {
1757 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1758 const GLint rshift = osmesa->rshift;
1759 const GLint gshift = osmesa->gshift;
1760 const GLint bshift = osmesa->bshift;
1761 const GLint avalue = vert0->color[3];
1762 const GLint msavalue = 256 - avalue;
1763 const GLint rvalue = vert1->color[0]*avalue;
1764 const GLint gvalue = vert1->color[1]*avalue;
1765 const GLint bvalue = vert1->color[2]*avalue;
1766
1767 #define INTERP_XY 1
1768 #define INTERP_Z 1
1769 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
1770 #define CLIP_HACK 1
1771 #define PLOT(X,Y) \
1772 if (Z < *zPtr) { \
1773 GLuint *ptr4 = (GLuint *) PIXELADDR4(X, Y); \
1774 GLuint pixel = 0; \
1775 pixel |=((((((*ptr4) >> rshift) & 0xff)*msavalue+rvalue)>>8) << rshift); \
1776 pixel |=((((((*ptr4) >> gshift) & 0xff)*msavalue+gvalue)>>8) << gshift); \
1777 pixel |=((((((*ptr4) >> bshift) & 0xff)*msavalue+bvalue)>>8) << bshift); \
1778 *ptr4 = pixel; \
1779 *zPtr = Z; \
1780 }
1781
1782 #if 0 /* XXX use this in the future */
1783 #define PLOT(X,Y) \
1784 if (Z < *zPtr) { \
1785 GLchan *pixel = (GLchan *) PIXELADDR4(X, Y); \
1786 pixel[rInd] = (pixel[rInd] * msavalue + rvalue) >> CHAN_BITS; \
1787 pixel[gInd] = (pixel[gInd] * msavalue + gvalue) >> CHAN_BITS; \
1788 pixel[bInd] = (pixel[bInd] * msavalue + bvalue) >> CHAN_BITS; \
1789 pixel[aInd] = (pixel[aInd] * msavalue + avalue) >> CHAN_BITS; \
1790 *zPtr = Z; \
1791 }
1792 #endif
1793
1794 #ifdef WIN32
1795 #include "..\swrast\s_linetemp.h"
1796 #else
1797 #include "swrast/s_linetemp.h"
1798 #endif
1799 }
1800
1801
1802 /*
1803 * Analyze context state to see if we can provide a fast line drawing
1804 * function, like those in lines.c. Otherwise, return NULL.
1805 */
1806 static swrast_line_func
1807 osmesa_choose_line_function( GLcontext *ctx )
1808 {
1809 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1810 const SWcontext *swrast = SWRAST_CONTEXT(ctx);
1811
1812 if (CHAN_BITS != 8) return NULL;
1813 if (ctx->RenderMode != GL_RENDER) return NULL;
1814 if (ctx->Line.SmoothFlag) return NULL;
1815 if (ctx->Texture._EnabledUnits) return NULL;
1816 if (ctx->Light.ShadeModel != GL_FLAT) return NULL;
1817 if (ctx->Line.Width != 1.0F) return NULL;
1818 if (ctx->Line.StippleFlag) return NULL;
1819 if (ctx->Line.SmoothFlag) return NULL;
1820 if (osmesa->format != OSMESA_RGBA &&
1821 osmesa->format != OSMESA_BGRA &&
1822 osmesa->format != OSMESA_ARGB) return NULL;
1823
1824 if (swrast->_RasterMask==DEPTH_BIT
1825 && ctx->Depth.Func==GL_LESS
1826 && ctx->Depth.Mask==GL_TRUE
1827 && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
1828 return (swrast_line_func) flat_rgba_z_line;
1829 }
1830
1831 if (swrast->_RasterMask == 0) {
1832 return (swrast_line_func) flat_rgba_line;
1833 }
1834
1835 if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
1836 && ctx->Depth.Func==GL_LESS
1837 && ctx->Depth.Mask==GL_TRUE
1838 && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
1839 && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
1840 && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
1841 && ctx->Color.BlendSrcA==GL_SRC_ALPHA
1842 && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
1843 && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
1844 return (swrast_line_func) flat_blend_rgba_z_line_write;
1845 }
1846
1847 if (swrast->_RasterMask==(DEPTH_BIT|BLEND_BIT)
1848 && ctx->Depth.Func==GL_LESS
1849 && ctx->Depth.Mask==GL_FALSE
1850 && ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS
1851 && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
1852 && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
1853 && ctx->Color.BlendSrcA==GL_SRC_ALPHA
1854 && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
1855 && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
1856 return (swrast_line_func) flat_blend_rgba_z_line;
1857 }
1858
1859 if (swrast->_RasterMask==BLEND_BIT
1860 && ctx->Color.BlendSrcRGB==GL_SRC_ALPHA
1861 && ctx->Color.BlendDstRGB==GL_ONE_MINUS_SRC_ALPHA
1862 && ctx->Color.BlendSrcA==GL_SRC_ALPHA
1863 && ctx->Color.BlendDstA==GL_ONE_MINUS_SRC_ALPHA
1864 && ctx->Color.BlendEquation==GL_FUNC_ADD_EXT) {
1865 return (swrast_line_func) flat_blend_rgba_line;
1866 }
1867
1868 return (swrast_line_func) NULL;
1869 }
1870
1871
1872 /**********************************************************************/
1873 /***** Optimized triangle rendering *****/
1874 /**********************************************************************/
1875
1876
1877 /*
1878 * Smooth-shaded, z-less triangle, RGBA color.
1879 */
1880 static void smooth_rgba_z_triangle( GLcontext *ctx,
1881 const SWvertex *v0,
1882 const SWvertex *v1,
1883 const SWvertex *v2 )
1884 {
1885 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1886 #define INTERP_Z 1
1887 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
1888 #define INTERP_RGB 1
1889 #define INTERP_ALPHA 1
1890 #define RENDER_SPAN( span ) \
1891 GLuint i; \
1892 GLchan *img = PIXELADDR4(span.x, span.y); \
1893 for (i = 0; i < span.end; i++, img += 4) { \
1894 const GLdepth z = FixedToDepth(span.z); \
1895 if (z < zRow[i]) { \
1896 PACK_RGBA(img, FixedToChan(span.red), \
1897 FixedToChan(span.green), FixedToChan(span.blue), \
1898 FixedToChan(span.alpha)); \
1899 zRow[i] = z; \
1900 } \
1901 span.red += span.redStep; \
1902 span.green += span.greenStep; \
1903 span.blue += span.blueStep; \
1904 span.alpha += span.alphaStep; \
1905 span.z += span.zStep; \
1906 }
1907
1908 #ifdef WIN32
1909 #include "..\swrast\s_tritemp.h"
1910 #else
1911 #include "swrast/s_tritemp.h"
1912 #endif
1913 }
1914
1915
1916
1917
1918 /*
1919 * Flat-shaded, z-less triangle, RGBA color.
1920 */
1921 static void flat_rgba_z_triangle( GLcontext *ctx,
1922 const SWvertex *v0,
1923 const SWvertex *v1,
1924 const SWvertex *v2 )
1925 {
1926 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1927 #define INTERP_Z 1
1928 #define DEPTH_TYPE DEFAULT_SOFTWARE_DEPTH_TYPE
1929 #define SETUP_CODE \
1930 GLuint pixel; \
1931 PACK_RGBA((GLchan *) &pixel, v2->color[0], v2->color[1], \
1932 v2->color[2], v2->color[3]);
1933
1934 #define RENDER_SPAN( span ) \
1935 GLuint i; \
1936 GLuint *img = (GLuint *) PIXELADDR4(span.x, span.y); \
1937 for (i = 0; i < span.end; i++) { \
1938 const GLdepth z = FixedToDepth(span.z); \
1939 if (z < zRow[i]) { \
1940 img[i] = pixel; \
1941 zRow[i] = z; \
1942 } \
1943 span.z += span.zStep; \
1944 }
1945
1946 #ifdef WIN32
1947 #include "..\swrast\s_tritemp.h"
1948 #else
1949 #include "swrast/s_tritemp.h"
1950 #endif
1951 }
1952
1953
1954
1955 /*
1956 * Return pointer to an accelerated triangle function if possible.
1957 */
1958 static swrast_tri_func
1959 osmesa_choose_triangle_function( GLcontext *ctx )
1960 {
1961 const OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
1962 const SWcontext *swrast = SWRAST_CONTEXT(ctx);
1963
1964 if (CHAN_BITS != 8) return (swrast_tri_func) NULL;
1965 if (ctx->RenderMode != GL_RENDER) return (swrast_tri_func) NULL;
1966 if (ctx->Polygon.SmoothFlag) return (swrast_tri_func) NULL;
1967 if (ctx->Polygon.StippleFlag) return (swrast_tri_func) NULL;
1968 if (ctx->Texture._EnabledUnits) return (swrast_tri_func) NULL;
1969 if (osmesa->format != OSMESA_RGBA &&
1970 osmesa->format != OSMESA_BGRA &&
1971 osmesa->format != OSMESA_ARGB) return (swrast_tri_func) NULL;
1972 if (ctx->Polygon.CullFlag &&
1973 ctx->Polygon.CullFaceMode == GL_FRONT_AND_BACK)
1974 return (swrast_tri_func) NULL;
1975
1976 if (swrast->_RasterMask == DEPTH_BIT &&
1977 ctx->Depth.Func == GL_LESS &&
1978 ctx->Depth.Mask == GL_TRUE &&
1979 ctx->Visual.depthBits == DEFAULT_SOFTWARE_DEPTH_BITS) {
1980 if (ctx->Light.ShadeModel == GL_SMOOTH) {
1981 return (swrast_tri_func) smooth_rgba_z_triangle;
1982 }
1983 else {
1984 return (swrast_tri_func) flat_rgba_z_triangle;
1985 }
1986 }
1987 return (swrast_tri_func) NULL;
1988 }
1989
1990
1991
1992 /* Override for the swrast triangle-selection function. Try to use one
1993 * of our internal triangle functions, otherwise fall back to the
1994 * standard swrast functions.
1995 */
1996 static void osmesa_choose_triangle( GLcontext *ctx )
1997 {
1998 SWcontext *swrast = SWRAST_CONTEXT(ctx);
1999
2000 swrast->Triangle = osmesa_choose_triangle_function( ctx );
2001 if (!swrast->Triangle)
2002 _swrast_choose_triangle( ctx );
2003 }
2004
2005 static void osmesa_choose_line( GLcontext *ctx )
2006 {
2007 SWcontext *swrast = SWRAST_CONTEXT(ctx);
2008
2009 swrast->Line = osmesa_choose_line_function( ctx );
2010 if (!swrast->Line)
2011 _swrast_choose_line( ctx );
2012 }
2013
2014
2015 #define OSMESA_NEW_LINE (_NEW_LINE | \
2016 _NEW_TEXTURE | \
2017 _NEW_LIGHT | \
2018 _NEW_DEPTH | \
2019 _NEW_RENDERMODE | \
2020 _SWRAST_NEW_RASTERMASK)
2021
2022 #define OSMESA_NEW_TRIANGLE (_NEW_POLYGON | \
2023 _NEW_TEXTURE | \
2024 _NEW_LIGHT | \
2025 _NEW_DEPTH | \
2026 _NEW_RENDERMODE | \
2027 _SWRAST_NEW_RASTERMASK)
2028
2029
2030 /* Extend the software rasterizer with our line and triangle
2031 * functions.
2032 */
2033 static void osmesa_register_swrast_functions( GLcontext *ctx )
2034 {
2035 SWcontext *swrast = SWRAST_CONTEXT( ctx );
2036
2037 swrast->choose_line = osmesa_choose_line;
2038 swrast->choose_triangle = osmesa_choose_triangle;
2039
2040 swrast->invalidate_line |= OSMESA_NEW_LINE;
2041 swrast->invalidate_triangle |= OSMESA_NEW_TRIANGLE;
2042 }
2043
2044
2045 static const GLubyte *get_string( GLcontext *ctx, GLenum name )
2046 {
2047 (void) ctx;
2048 switch (name) {
2049 case GL_RENDERER:
2050 #if CHAN_BITS == 32
2051 return (const GLubyte *) "Mesa OffScreen32";
2052 #elif CHAN_BITS == 16
2053 return (const GLubyte *) "Mesa OffScreen16";
2054 #else
2055 return (const GLubyte *) "Mesa OffScreen";
2056 #endif
2057 default:
2058 return NULL;
2059 }
2060 }
2061
2062
2063 static void osmesa_update_state( GLcontext *ctx, GLuint new_state )
2064 {
2065 OSMesaContext osmesa = OSMESA_CONTEXT(ctx);
2066 struct swrast_device_driver *swdd = _swrast_GetDeviceDriverReference( ctx );
2067 TNLcontext *tnl = TNL_CONTEXT(ctx);
2068
2069 ASSERT((void *) osmesa == (void *) ctx->DriverCtx);
2070
2071 /*
2072 * XXX these function pointers could be initialized just once during
2073 * context creation since they don't depend on any state changes.
2074 */
2075
2076 ctx->Driver.GetString = get_string;
2077 ctx->Driver.UpdateState = osmesa_update_state;
2078 ctx->Driver.ResizeBuffers = _swrast_alloc_buffers;
2079 ctx->Driver.GetBufferSize = buffer_size;
2080
2081 ctx->Driver.Accum = _swrast_Accum;
2082 ctx->Driver.Bitmap = _swrast_Bitmap;
2083 ctx->Driver.Clear = clear;
2084 ctx->Driver.CopyPixels = _swrast_CopyPixels;
2085 ctx->Driver.DrawPixels = _swrast_DrawPixels;
2086 ctx->Driver.ReadPixels = _swrast_ReadPixels;
2087 ctx->Driver.DrawBuffer = _swrast_DrawBuffer;
2088
2089 ctx->Driver.ChooseTextureFormat = _mesa_choose_tex_format;
2090 ctx->Driver.TexImage1D = _mesa_store_teximage1d;
2091 ctx->Driver.TexImage2D = _mesa_store_teximage2d;
2092 ctx->Driver.TexImage3D = _mesa_store_teximage3d;
2093 ctx->Driver.TexSubImage1D = _mesa_store_texsubimage1d;
2094 ctx->Driver.TexSubImage2D = _mesa_store_texsubimage2d;
2095 ctx->Driver.TexSubImage3D = _mesa_store_texsubimage3d;
2096 ctx->Driver.TestProxyTexImage = _mesa_test_proxy_teximage;
2097
2098 ctx->Driver.CompressedTexImage1D = _mesa_store_compressed_teximage1d;
2099 ctx->Driver.CompressedTexImage2D = _mesa_store_compressed_teximage2d;
2100 ctx->Driver.CompressedTexImage3D = _mesa_store_compressed_teximage3d;
2101 ctx->Driver.CompressedTexSubImage1D = _mesa_store_compressed_texsubimage1d;
2102 ctx->Driver.CompressedTexSubImage2D = _mesa_store_compressed_texsubimage2d;
2103 ctx->Driver.CompressedTexSubImage3D = _mesa_store_compressed_texsubimage3d;
2104
2105 ctx->Driver.CopyTexImage1D = _swrast_copy_teximage1d;
2106 ctx->Driver.CopyTexImage2D = _swrast_copy_teximage2d;
2107 ctx->Driver.CopyTexSubImage1D = _swrast_copy_texsubimage1d;
2108 ctx->Driver.CopyTexSubImage2D = _swrast_copy_texsubimage2d;
2109 ctx->Driver.CopyTexSubImage3D = _swrast_copy_texsubimage3d;
2110 ctx->Driver.CopyColorTable = _swrast_CopyColorTable;
2111 ctx->Driver.CopyColorSubTable = _swrast_CopyColorSubTable;
2112 ctx->Driver.CopyConvolutionFilter1D = _swrast_CopyConvolutionFilter1D;
2113 ctx->Driver.CopyConvolutionFilter2D = _swrast_CopyConvolutionFilter2D;
2114
2115 swdd->SetBuffer = set_buffer;
2116
2117 /* RGB(A) span/pixel functions */
2118 if (osmesa->format == OSMESA_RGB) {
2119 swdd->WriteRGBASpan = write_rgba_span_RGB;
2120 swdd->WriteRGBSpan = write_rgb_span_RGB;
2121 swdd->WriteMonoRGBASpan = write_monocolor_span_RGB;
2122 swdd->WriteRGBAPixels = write_rgba_pixels_RGB;
2123 swdd->WriteMonoRGBAPixels = write_monocolor_pixels_RGB;
2124 swdd->ReadRGBASpan = read_rgba_span3;
2125 swdd->ReadRGBAPixels = read_rgba_pixels3;
2126 }
2127 else if (osmesa->format == OSMESA_BGR) {
2128 swdd->WriteRGBASpan = write_rgba_span_BGR;
2129 swdd->WriteRGBSpan = write_rgb_span_BGR;
2130 swdd->WriteMonoRGBASpan = write_monocolor_span_BGR;
2131 swdd->WriteRGBAPixels = write_rgba_pixels_BGR;
2132 swdd->WriteMonoRGBAPixels = write_monocolor_pixels_BGR;
2133 swdd->ReadRGBASpan = read_rgba_span3;
2134 swdd->ReadRGBAPixels = read_rgba_pixels3;
2135 }
2136 else if (osmesa->format == OSMESA_RGB_565) {
2137 swdd->WriteRGBASpan = write_rgba_span2;
2138 swdd->WriteRGBSpan = write_rgb_span2;
2139 swdd->WriteMonoRGBASpan = write_monocolor_span2;
2140 swdd->WriteRGBAPixels = write_rgba_pixels2;
2141 swdd->WriteMonoRGBAPixels = write_monocolor_pixels2;
2142 swdd->ReadRGBASpan = read_rgba_span2;
2143 swdd->ReadRGBAPixels = read_rgba_pixels2;
2144 }
2145 else {
2146 /* 4 GLchan / pixel in frame buffer */
2147 swdd->WriteRGBSpan = write_rgb_span;
2148 swdd->WriteRGBAPixels = write_rgba_pixels;
2149 swdd->WriteMonoRGBASpan = write_monocolor_span;
2150 swdd->WriteMonoRGBAPixels = write_monocolor_pixels;
2151 if (osmesa->format == OSMESA_RGBA &&
2152 CHAN_TYPE == GL_UNSIGNED_BYTE &&
2153 RCOMP==0 && GCOMP==1 && BCOMP==2 && ACOMP==3) {
2154 /* special, fast case */
2155 swdd->WriteRGBASpan = write_rgba_span_rgba;
2156 swdd->ReadRGBASpan = read_rgba_span_rgba;
2157 }
2158 else {
2159 swdd->WriteRGBASpan = write_rgba_span;
2160 swdd->ReadRGBASpan = read_rgba_span;
2161 }
2162 swdd->ReadRGBAPixels = read_rgba_pixels;
2163 }
2164
2165 /* CI span/pixel functions */
2166 swdd->WriteCI32Span = write_index32_span;
2167 swdd->WriteCI8Span = write_index8_span;
2168 swdd->WriteMonoCISpan = write_monoindex_span;
2169 swdd->WriteCI32Pixels = write_index_pixels;
2170 swdd->WriteMonoCIPixels = write_monoindex_pixels;
2171 swdd->ReadCI32Span = read_index_span;
2172 swdd->ReadCI32Pixels = read_index_pixels;
2173
2174 tnl->Driver.RunPipeline = _tnl_run_pipeline;
2175
2176 _swrast_InvalidateState( ctx, new_state );
2177 _swsetup_InvalidateState( ctx, new_state );
2178 _ac_InvalidateState( ctx, new_state );
2179 _tnl_InvalidateState( ctx, new_state );
2180 }