home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 5 / MA_Cover_5.iso / ppc / mesa / src / mmesap.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-01-31  |  20.4 KB  |  354 lines

  1. /****************************************************************************
  2. *
  3. *                      Mesa bindings for SciTech MGL
  4. *
  5. *                   Copyright (C) 1996 SciTech Software.
  6. *                           All rights reserved.
  7. *
  8. * Filename:     $Workfile:   mmesap.h  $
  9. * Version:      $Revision:   1.3  $
  10. *
  11. * Language:     ANSI C
  12. * Environment:  Any
  13. *
  14. * Description:  Internal header file for the Mesa/OpenGL interface bindings
  15. *               for the SciTech MGL graphics library. 
  16. *
  17. * This library is free software; you can redistribute it and/or
  18. * modify it under the terms of the GNU Library General Public
  19. * License as published by the Free Software Foundation; either
  20. * version 2 of the License, or (at your option) any later version.
  21. *
  22. * This library is distributed in the hope that it will be useful,
  23. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  25. * Library General Public License for more details.
  26. *
  27. * You should have received a copy of the GNU Library General Public
  28. * License along with this library; if not, write to the Free
  29. * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  30. *
  31. * $Date:   07 Apr 1997 17:21:52  $ $Author:   KendallB  $
  32. *
  33. ****************************************************************************/
  34.  
  35. #ifndef __MMESAP_H
  36. #define __MMESAP_H
  37.  
  38. #include "mgl_int.h"
  39. #include "context.h"
  40. #include "matrix.h"
  41. #include "types.h"
  42. #include "vb.h"
  43. #include "halftone.h"
  44.  
  45. /*---------------------- Macros and type definitions ----------------------*/
  46.  
  47. /* Internal Mesa rendering context */
  48.  
  49. struct MGLMesaContext {
  50.     GLcontext       *gl_ctx;            /* the core Mesa context        */
  51.     GLvisual        *gl_vis;            /* describes the color buffer   */
  52.     GLframebuffer   *gl_buffer;         /* the ancillary buffers        */
  53.     MGLDC           *dc;                /* Rendering DC                 */
  54.     MGLDC           *dispdc;            /* Display DC                   */
  55.     MGLDC           *memdc;             /* Memory DC back buffer        */
  56.     color_t         clearColor;         /* Color to clear device with   */
  57.     color_t         color;              /* Current color                */
  58.     uchar           red,green,blue;     /* RGB components for color     */
  59.     int             bottom;             /* Bottom coordinate for buffer */
  60.     int             bufferMode;         /* Current buffer access mode   */
  61.     int             frontbuffer;        /* Page index of front buffer   */
  62.     int             backbuffer;         /* Page index of back buffer    */
  63.     uint            pixelformat;        /* Current pixel format         */
  64.     uint            undithered_pf;      /* Undithered pixel format      */
  65.     uint            dithered_pf;        /* Dithered pixel format        */
  66.     };
  67.  
  68. /* Macros for MGL API callbacks when running in a DLL for Windows */
  69.  
  70. #ifdef  __WINDOWS__
  71. #define MGL_makeCurrentDC(dc)                                               _MGL_callbacks.makeCurrentDC(dc)
  72. #define MGL_clearCurrentDC()                                                _MGL_callbacks.makeCurrentDC(NULL)
  73. #define MGL_setActivePage(dc,page)                                          _MGL_callbacks.setActivePage(dc,page)
  74. #define MGL_setVisualPage(dc,page,waitVRT)                                  _MGL_callbacks.setVisualPage(dc,page,waitVRT)
  75. #define MGL_surfaceAccessType(dc)                                           _MGL_callbacks.surfaceAccessType(dc)
  76. #define MGL_isDisplayDC(dc)                                                 _MGL_callbacks.isDisplayDC(dc)
  77. #define MGL_isWindowedDC(dc)                                                _MGL_callbacks.isWindowedDC(dc)
  78. #define MGL_isMemoryDC(dc)                                                  _MGL_callbacks.isMemoryDC(dc)
  79. #define MGL_createMemoryDC(xSize,ySize,bitsPerPixel,pf)                     _MGL_callbacks.createMemoryDC(xSize,ySize,bitsPerPixel,pf)
  80. #define MGL_destroyDC(dc)                                                   _MGL_callbacks.destroyDC(dc)
  81. #define MGL_bitBltCoord(dst,src,left,top,right,bottom,dstLeft,dstTop,op)    _MGL_callbacks.bitBltCoord(dst,src,left,top,right,bottom,dstLeft,dstTop,op)
  82. #define MGL_setPaletteEntry(dc,entry,red,green,blue)                        _MGL_callbacks.setPaletteEntry(dc,entry,red,green,blue)
  83. #define MGL_setPalette(dc,pal,numColors,startIndex)                         _MGL_callbacks.setPalette(dc,pal,numColors,startIndex)
  84. #define MGL_getPalette(dc,pal,numColors,startIndex)                         _MGL_callbacks.getPalette(dc,pal,numColors,startIndex)
  85. #define MGL_realizePalette(dc,numColors,startIndex,waitVRT)                 _MGL_callbacks.realizePalette(dc,numColors,startIndex,waitVRT)
  86. #else
  87. #define MGL_clearCurrentDC()                                                MGL_makeCurrentDC(NULL);
  88. #endif
  89.  
  90. /* Macro to pack a color value for use by the MGL rendering functions. Since
  91.  * Mesa pre-scales our color values for us to the correct range we simply
  92.  * need to shift and combine the color values into the final packed color
  93.  * value used by the MGL.
  94.  */
  95.  
  96. #define PACK_COLOR(R,G,B)                   \
  97.     ((ulong)(R) << PF.redPos)           \
  98.     | ((ulong)(G) << PF.greenPos)       \
  99.     | ((ulong)(B) << PF.bluePos)
  100.  
  101. #define UNPACK_COLOR(c,R,G,B)                                       \
  102. {                                                                   \
  103.  (R) = (uchar)(((ulong)(c) >> PF.redPos) & PF.redMask);     \
  104.  (G) = (uchar)(((ulong)(c) >> PF.greenPos) & PF.greenMask); \
  105.  (B) = (uchar)(((ulong)(c) >> PF.bluePos) & PF.blueMask);       \
  106. }
  107.  
  108. /* Converts a GL window Y coord to an X window Y coord */
  109.  
  110. #define FLIP(Y)  (RC.bottom - (Y))
  111.  
  112. /* Values for RC.pixelformat */
  113.  
  114. #define PF_INDEX        1       /* Color Index mode                     */
  115. #define PF_RGB8         2       /* 8bpp RGB without dithering           */
  116. #define PF_DITHER8      3       /* 8bpp RGB dithered                    */
  117. #define PF_RGB555       4       /* 15bpp RGB without dithering          */
  118. #define PF_DITHER555    5       /* 15bpp RGB dithered                   */
  119. #define PF_RGB565       6       /* 16bpp RGB without dithering          */
  120. #define PF_DITHER565    7       /* 16bpp RGB dithered                   */
  121. #define PF_RGB888       8       /* 24bpp RGB TrueColor                  */
  122. #define PF_BGR888       9       /* 24bpp BGR TrueColor                  */
  123. #define PF_ARGB8888     10      /* 32bpp ARGB TrueColor                 */
  124. #define PF_ABGR8888     11      /* 32bpp ABGR TrueColor                 */
  125. #define PF_RGBA8888     12      /* 32bpp RGBA TrueColor                 */
  126. #define PF_BGRA8888     13      /* 32bpp BGRA TrueColor                 */
  127.  
  128. /* Macros to directly access the software z-buffer */
  129.  
  130. #define ZBUF_ADDR(x,y)                                          \
  131.     ((GLdepth _HUGE*)(RC.dc->zbuffer)                           \
  132.         + (((y) - RC.dc->size.top) * (long)RC.dc->zwidth)       \
  133.         + (x) - RC.dc->size.left)
  134.  
  135. /* Macros for 8bpp direct surface access */
  136.  
  137. #define PACKED8_pixelAddr(x,y)  \
  138.      ((void*)((uchar _HUGE *)RC.dc->surface + ((long)y * MI.bytesPerLine) + x))
  139.  
  140. #define PACK_COLOR_8(R,G,B)                                     \
  141.     (uchar)(20 + _MGL_div51[R] + _MGL_mul6[_MGL_div51[G]] +     \
  142.           _MGL_mul36[_MGL_div51[B]])
  143.  
  144. /* Macros for 16bpp direct surface access */
  145.  
  146. #define PACKED16_pixelAddr(x,y) \
  147.      ((void*)((uchar _HUGE *)RC.dc->surface + ((long)y * MI.bytesPerLine) + x*2))
  148.  
  149. #define PACK_COLOR_555(R,G,B)               \
  150.     (ushort)(((ulong)(R) << 10)             \
  151.             | ((ulong)(G) << 5)             \
  152.             | ((ulong)(B) << 0))
  153.  
  154. #define PACK_COLOR_565(R,G,B)               \
  155.     (ushort)(((ulong)(R) << 11)             \
  156.             | ((ulong)(G) << 5)             \
  157.             | ((ulong)(B) << 0))
  158.  
  159. #define UNPACK_COLOR_555(c,R,G,B)                   \
  160. {                                                   \
  161.  (R) = (uchar)(((ulong)(c) >> 10) & 0x3);           \
  162.  (G) = (uchar)(((ulong)(c) >> 5) & 0x3);            \
  163.  (B) = (uchar)(((ulong)(c) >> 0) & 0x3);            \
  164. }
  165.  
  166. #define UNPACK_COLOR_565(c,R,G,B)                   \
  167. {                                                   \
  168.  (R) = (uchar)(((ulong)(c) >> 11) & 0x3);           \
  169.  (G) = (uchar)(((ulong)(c) >> 5) & 0x7);            \
  170.  (B) = (uchar)(((ulong)(c) >> 0) & 0x3);            \
  171. }
  172.  
  173. /* Macros for 24bpp direct surface access */
  174.  
  175. #define PACKED24_pixelAddr(x,y) \
  176.      ((void*)((uchar _HUGE *)RC.dc->surface + ((long)y * MI.bytesPerLine) + x*3))
  177.  
  178. #define PACK_COLOR_RGB(R,G,B)       \
  179.     ((ulong)(R) << 16)              \
  180.     | ((ulong)(G) << 8)             \
  181.     | ((ulong)(B) << 0)
  182.  
  183. #define PACK_COLOR_BGR(R,G,B)       \
  184.     ((ulong)(R) << 0)               \
  185.     | ((ulong)(G) << 8)             \
  186.     | ((ulong)(B) << 16)
  187.  
  188. #define UNPACK_COLOR_RGB(c,R,G,B)                   \
  189. {                                                   \
  190.  (R) = (uchar)(((ulong)(c) >> 16) & 0xFF);          \
  191.  (G) = (uchar)(((ulong)(c) >> 8) & 0xFF);           \
  192.  (B) = (uchar)(((ulong)(c) >> 0) & 0xFF);           \
  193. }
  194.  
  195. #define UNPACK_COLOR_BGR(c,R,G,B)                   \
  196. {                                                   \
  197.  (R) = (uchar)(((ulong)(c) >> 0) & 0xFF);           \
  198.  (G) = (uchar)(((ulong)(c) >> 8) & 0xFF);           \
  199.  (B) = (uchar)(((ulong)(c) >> 16) & 0xFF);          \
  200. }
  201.  
  202. /* Macros for 32bpp direct surface access */
  203.  
  204. #define PACKED32_pixelAddr(x,y) \
  205.      ((void*)((uchar _HUGE *)RC.dc->surface + ((long)y * MI.bytesPerLine) + x*4))
  206.  
  207. #define PACK_COLOR_ARGB(R,G,B)      \
  208.     ((ulong)(R) << 16)              \
  209.     | ((ulong)(G) << 8)             \
  210.     | ((ulong)(B) << 0)
  211.  
  212. #define PACK_COLOR_ABGR(R,G,B)      \
  213.     ((ulong)(R) << 0)               \
  214.     | ((ulong)(G) << 8)             \
  215.     | ((ulong)(B) << 16)
  216.  
  217. #define PACK_COLOR_RGBA(R,G,B)      \
  218.     ((ulong)(R) << 24)              \
  219.     | ((ulong)(G) << 16)            \
  220.     | ((ulong)(B) << 8)
  221.  
  222. #define PACK_COLOR_BGRA(R,G,B)      \
  223.     ((ulong)(R) << 8)               \
  224.     | ((ulong)(G) << 16)            \
  225.     | ((ulong)(B) << 24)
  226.  
  227. #define UNPACK_COLOR_ARGB(c,R,G,B)                  \
  228. {                                                   \
  229.  (R) = (uchar)(((ulong)(c) >> 16) & 0xFF);          \
  230.  (G) = (uchar)(((ulong)(c) >> 8) & 0xFF);           \
  231.  (B) = (uchar)(((ulong)(c) >> 0) & 0xFF);           \
  232. }
  233.  
  234. #define UNPACK_COLOR_ABGR(c,R,G,B)                  \
  235. {                                                   \
  236.  (R) = (uchar)(((ulong)(c) >> 0) & 0xFF);           \
  237.  (G) = (uchar)(((ulong)(c) >> 8) & 0xFF);           \
  238.  (B) = (uchar)(((ulong)(c) >> 16) & 0xFF);          \
  239. }
  240.  
  241. #define UNPACK_COLOR_RGBA(c,R,G,B)                  \
  242. {                                                   \
  243.  (R) = (uchar)(((ulong)(c) >> 24) & 0xFF);          \
  244.  (G) = (uchar)(((ulong)(c) >> 16) & 0xFF);          \
  245.  (B) = (uchar)(((ulong)(c) >> 8) & 0xFF);           \
  246. }
  247.  
  248. #define UNPACK_COLOR_BGRA(c,R,G,B)                  \
  249. {                                                   \
  250.  (R) = (uchar)(((ulong)(c) >> 8) & 0xFF);           \
  251.  (G) = (uchar)(((ulong)(c) >> 16) & 0xFF);          \
  252.  (B) = (uchar)(((ulong)(c) >> 24) & 0xFF);          \
  253. }
  254.  
  255. /*--------------------------- Global Variables ----------------------------*/
  256.  
  257. #define RC      _MM_rc
  258. #define MI      _MGL_mi
  259. #define PF      _MGL_pf
  260. #define VECS    _MGL_vecs
  261. extern MGLRC            _MM_rc;         /* Current rendering context    */
  262. extern MGLRC            *_MM_rcPtr;     /* Pointer to current context   */
  263. extern gmode_t          _MGL_mi;        /* MGL mode information         */
  264. extern pixel_format_t   _MGL_pf;        /* MGL mode pixel format        */
  265. extern vecs             _MGL_vecs;      /* MGL Rendering vectors        */
  266.  
  267. /*------------------------- Function Prototypes ---------------------------*/
  268.  
  269. /* General functions */
  270.  
  271. void setup_DD_pointers(GLcontext *ctx);
  272. points_func mmesa_get_points_func(GLcontext *ctx);
  273. line_func mmesa_get_line_func(GLcontext *ctx);
  274. triangle_func mmesa_get_triangle_func(GLcontext *ctx);
  275.  
  276. /* 8bpp rendering functions */
  277.  
  278. void _mmesa_write_span_ci(GLcontext *ctx,GLuint n, GLint x, GLint y,GLuint index[],GLubyte mask[]);
  279. void _mmesa_write_span_8_8(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  280. void _mmesa_write_span_8_DITHER8(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  281. void _mmesa_write_span_mono_ci(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
  282. void _mmesa_write_span_mono_8(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
  283. void _mmesa_write_span_mono_8_DITHER8(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
  284. void _mmesa_write_pixels_ci(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLuint index[], GLubyte mask[]);
  285. void _mmesa_write_pixels_8_8(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  286. void _mmesa_write_pixels_8_DITHER8(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  287. void _mmesa_write_pixels_mono_ci(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
  288. void _mmesa_write_pixels_mono_8(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
  289. void _mmesa_write_pixels_mono_8_DITHER8(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
  290. void _mmesa_read_span_ci(GLcontext *ctx,GLuint n, GLint x, GLint y,GLuint index[]);
  291. void _mmesa_read_span_8(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
  292. void _mmesa_read_pixels_ci(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLuint index[], GLubyte mask[]);
  293. void _mmesa_read_pixels_8(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  294.  
  295. /* 15/16bpp rendering functions */ 
  296.  
  297. void _mmesa_write_span_16_555(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  298. void _mmesa_write_span_16_565(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  299. void _mmesa_write_span_16_DITHER555(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  300. void _mmesa_write_span_16_DITHER565(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  301. void _mmesa_write_span_mono_16(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
  302. void _mmesa_write_span_mono_16_DITHER555(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
  303. void _mmesa_write_span_mono_16_DITHER565(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
  304. void _mmesa_write_pixels_16_555(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  305. void _mmesa_write_pixels_16_565(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  306. void _mmesa_write_pixels_16_DITHER555(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  307. void _mmesa_write_pixels_16_DITHER565(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  308. void _mmesa_write_pixels_mono_16(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
  309. void _mmesa_write_pixels_mono_16_DITHER555(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
  310. void _mmesa_write_pixels_mono_16_DITHER565(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
  311. void _mmesa_read_span_16_555(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
  312. void _mmesa_read_span_16_565(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
  313. void _mmesa_read_pixels_16_555(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  314. void _mmesa_read_pixels_16_565(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  315.  
  316. /* 24bpp rendering functions */
  317.  
  318. void _mmesa_write_span_24_RGB(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  319. void _mmesa_write_span_24_BGR(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  320. void _mmesa_write_span_mono_24_RGB(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
  321. void _mmesa_write_span_mono_24_BGR(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
  322. void _mmesa_write_pixels_24_RGB(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  323. void _mmesa_write_pixels_24_BGR(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  324. void _mmesa_write_pixels_mono_24_RGB(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
  325. void _mmesa_write_pixels_mono_24_BGR(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
  326. void _mmesa_read_span_24_RGB(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
  327. void _mmesa_read_span_24_BGR(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
  328. void _mmesa_read_pixels_24_RGB(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  329. void _mmesa_read_pixels_24_BGR(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  330.  
  331. /* 32bpp rendering functions */
  332.  
  333. void _mmesa_write_span_32_ARGB(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  334. void _mmesa_write_span_32_ABGR(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  335. void _mmesa_write_span_32_RGBA(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  336. void _mmesa_write_span_32_BGRA(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  337. void _mmesa_write_span_mono_32(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
  338. void _mmesa_write_pixels_32_ARGB(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  339. void _mmesa_write_pixels_32_ABGR(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  340. void _mmesa_write_pixels_32_RGBA(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  341. void _mmesa_write_pixels_32_BGRA(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
  342. void _mmesa_write_pixels_mono_32(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
  343. void _mmesa_read_span_32_ARGB(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
  344. void _mmesa_read_span_32_ABGR(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
  345. void _mmesa_read_span_32_RGBA(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
  346. void _mmesa_read_span_32_BGRA(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
  347. void _mmesa_read_pixels_32_ARGB(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  348. void _mmesa_read_pixels_32_ABGR(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  349. void _mmesa_read_pixels_32_RGBA(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  350. void _mmesa_read_pixels_32_BGRA(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
  351.  
  352. #endif  /* __MMESAP_H */
  353.  
  354.