This is mmesap.h in view mode; [Download] [Up]
/****************************************************************************
*
* Mesa bindings for SciTech MGL
*
* Copyright (C) 1996 SciTech Software.
* All rights reserved.
*
* Filename: $Workfile: mmesap.h $
* Version: $Revision: 1.3 $
*
* Language: ANSI C
* Environment: Any
*
* Description: Internal header file for the Mesa/OpenGL interface bindings
* for the SciTech MGL graphics library.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the Free
* Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* $Date: 07 Apr 1997 17:21:52 $ $Author: KendallB $
*
****************************************************************************/
#ifndef __MMESAP_H
#define __MMESAP_H
#include "mgl_int.h"
#include "context.h"
#include "matrix.h"
#include "types.h"
#include "vb.h"
#include "halftone.h"
/*---------------------- Macros and type definitions ----------------------*/
/* Internal Mesa rendering context */
struct MGLMesaContext {
GLcontext *gl_ctx; /* the core Mesa context */
GLvisual *gl_vis; /* describes the color buffer */
GLframebuffer *gl_buffer; /* the ancillary buffers */
MGLDC *dc; /* Rendering DC */
MGLDC *dispdc; /* Display DC */
MGLDC *memdc; /* Memory DC back buffer */
color_t clearColor; /* Color to clear device with */
color_t color; /* Current color */
uchar red,green,blue; /* RGB components for color */
int bottom; /* Bottom coordinate for buffer */
int bufferMode; /* Current buffer access mode */
int frontbuffer; /* Page index of front buffer */
int backbuffer; /* Page index of back buffer */
uint pixelformat; /* Current pixel format */
uint undithered_pf; /* Undithered pixel format */
uint dithered_pf; /* Dithered pixel format */
};
/* Macros for MGL API callbacks when running in a DLL for Windows */
#ifdef __WINDOWS__
#define MGL_makeCurrentDC(dc) _MGL_callbacks.makeCurrentDC(dc)
#define MGL_clearCurrentDC() _MGL_callbacks.makeCurrentDC(NULL)
#define MGL_setActivePage(dc,page) _MGL_callbacks.setActivePage(dc,page)
#define MGL_setVisualPage(dc,page,waitVRT) _MGL_callbacks.setVisualPage(dc,page,waitVRT)
#define MGL_surfaceAccessType(dc) _MGL_callbacks.surfaceAccessType(dc)
#define MGL_isDisplayDC(dc) _MGL_callbacks.isDisplayDC(dc)
#define MGL_isWindowedDC(dc) _MGL_callbacks.isWindowedDC(dc)
#define MGL_isMemoryDC(dc) _MGL_callbacks.isMemoryDC(dc)
#define MGL_createMemoryDC(xSize,ySize,bitsPerPixel,pf) _MGL_callbacks.createMemoryDC(xSize,ySize,bitsPerPixel,pf)
#define MGL_destroyDC(dc) _MGL_callbacks.destroyDC(dc)
#define MGL_bitBltCoord(dst,src,left,top,right,bottom,dstLeft,dstTop,op) _MGL_callbacks.bitBltCoord(dst,src,left,top,right,bottom,dstLeft,dstTop,op)
#define MGL_setPaletteEntry(dc,entry,red,green,blue) _MGL_callbacks.setPaletteEntry(dc,entry,red,green,blue)
#define MGL_setPalette(dc,pal,numColors,startIndex) _MGL_callbacks.setPalette(dc,pal,numColors,startIndex)
#define MGL_getPalette(dc,pal,numColors,startIndex) _MGL_callbacks.getPalette(dc,pal,numColors,startIndex)
#define MGL_realizePalette(dc,numColors,startIndex,waitVRT) _MGL_callbacks.realizePalette(dc,numColors,startIndex,waitVRT)
#else
#define MGL_clearCurrentDC() MGL_makeCurrentDC(NULL);
#endif
/* Macro to pack a color value for use by the MGL rendering functions. Since
* Mesa pre-scales our color values for us to the correct range we simply
* need to shift and combine the color values into the final packed color
* value used by the MGL.
*/
#define PACK_COLOR(R,G,B) \
((ulong)(R) << PF.redPos) \
| ((ulong)(G) << PF.greenPos) \
| ((ulong)(B) << PF.bluePos)
#define UNPACK_COLOR(c,R,G,B) \
{ \
(R) = (uchar)(((ulong)(c) >> PF.redPos) & PF.redMask); \
(G) = (uchar)(((ulong)(c) >> PF.greenPos) & PF.greenMask); \
(B) = (uchar)(((ulong)(c) >> PF.bluePos) & PF.blueMask); \
}
/* Converts a GL window Y coord to an X window Y coord */
#define FLIP(Y) (RC.bottom - (Y))
/* Values for RC.pixelformat */
#define PF_INDEX 1 /* Color Index mode */
#define PF_RGB8 2 /* 8bpp RGB without dithering */
#define PF_DITHER8 3 /* 8bpp RGB dithered */
#define PF_RGB555 4 /* 15bpp RGB without dithering */
#define PF_DITHER555 5 /* 15bpp RGB dithered */
#define PF_RGB565 6 /* 16bpp RGB without dithering */
#define PF_DITHER565 7 /* 16bpp RGB dithered */
#define PF_RGB888 8 /* 24bpp RGB TrueColor */
#define PF_BGR888 9 /* 24bpp BGR TrueColor */
#define PF_ARGB8888 10 /* 32bpp ARGB TrueColor */
#define PF_ABGR8888 11 /* 32bpp ABGR TrueColor */
#define PF_RGBA8888 12 /* 32bpp RGBA TrueColor */
#define PF_BGRA8888 13 /* 32bpp BGRA TrueColor */
/* Macros to directly access the software z-buffer */
#define ZBUF_ADDR(x,y) \
((GLdepth _HUGE*)(RC.dc->zbuffer) \
+ (((y) - RC.dc->size.top) * (long)RC.dc->zwidth) \
+ (x) - RC.dc->size.left)
/* Macros for 8bpp direct surface access */
#define PACKED8_pixelAddr(x,y) \
((void*)((uchar _HUGE *)RC.dc->surface + ((long)y * MI.bytesPerLine) + x))
#define PACK_COLOR_8(R,G,B) \
(uchar)(20 + _MGL_div51[R] + _MGL_mul6[_MGL_div51[G]] + \
_MGL_mul36[_MGL_div51[B]])
/* Macros for 16bpp direct surface access */
#define PACKED16_pixelAddr(x,y) \
((void*)((uchar _HUGE *)RC.dc->surface + ((long)y * MI.bytesPerLine) + x*2))
#define PACK_COLOR_555(R,G,B) \
(ushort)(((ulong)(R) << 10) \
| ((ulong)(G) << 5) \
| ((ulong)(B) << 0))
#define PACK_COLOR_565(R,G,B) \
(ushort)(((ulong)(R) << 11) \
| ((ulong)(G) << 5) \
| ((ulong)(B) << 0))
#define UNPACK_COLOR_555(c,R,G,B) \
{ \
(R) = (uchar)(((ulong)(c) >> 10) & 0x3); \
(G) = (uchar)(((ulong)(c) >> 5) & 0x3); \
(B) = (uchar)(((ulong)(c) >> 0) & 0x3); \
}
#define UNPACK_COLOR_565(c,R,G,B) \
{ \
(R) = (uchar)(((ulong)(c) >> 11) & 0x3); \
(G) = (uchar)(((ulong)(c) >> 5) & 0x7); \
(B) = (uchar)(((ulong)(c) >> 0) & 0x3); \
}
/* Macros for 24bpp direct surface access */
#define PACKED24_pixelAddr(x,y) \
((void*)((uchar _HUGE *)RC.dc->surface + ((long)y * MI.bytesPerLine) + x*3))
#define PACK_COLOR_RGB(R,G,B) \
((ulong)(R) << 16) \
| ((ulong)(G) << 8) \
| ((ulong)(B) << 0)
#define PACK_COLOR_BGR(R,G,B) \
((ulong)(R) << 0) \
| ((ulong)(G) << 8) \
| ((ulong)(B) << 16)
#define UNPACK_COLOR_RGB(c,R,G,B) \
{ \
(R) = (uchar)(((ulong)(c) >> 16) & 0xFF); \
(G) = (uchar)(((ulong)(c) >> 8) & 0xFF); \
(B) = (uchar)(((ulong)(c) >> 0) & 0xFF); \
}
#define UNPACK_COLOR_BGR(c,R,G,B) \
{ \
(R) = (uchar)(((ulong)(c) >> 0) & 0xFF); \
(G) = (uchar)(((ulong)(c) >> 8) & 0xFF); \
(B) = (uchar)(((ulong)(c) >> 16) & 0xFF); \
}
/* Macros for 32bpp direct surface access */
#define PACKED32_pixelAddr(x,y) \
((void*)((uchar _HUGE *)RC.dc->surface + ((long)y * MI.bytesPerLine) + x*4))
#define PACK_COLOR_ARGB(R,G,B) \
((ulong)(R) << 16) \
| ((ulong)(G) << 8) \
| ((ulong)(B) << 0)
#define PACK_COLOR_ABGR(R,G,B) \
((ulong)(R) << 0) \
| ((ulong)(G) << 8) \
| ((ulong)(B) << 16)
#define PACK_COLOR_RGBA(R,G,B) \
((ulong)(R) << 24) \
| ((ulong)(G) << 16) \
| ((ulong)(B) << 8)
#define PACK_COLOR_BGRA(R,G,B) \
((ulong)(R) << 8) \
| ((ulong)(G) << 16) \
| ((ulong)(B) << 24)
#define UNPACK_COLOR_ARGB(c,R,G,B) \
{ \
(R) = (uchar)(((ulong)(c) >> 16) & 0xFF); \
(G) = (uchar)(((ulong)(c) >> 8) & 0xFF); \
(B) = (uchar)(((ulong)(c) >> 0) & 0xFF); \
}
#define UNPACK_COLOR_ABGR(c,R,G,B) \
{ \
(R) = (uchar)(((ulong)(c) >> 0) & 0xFF); \
(G) = (uchar)(((ulong)(c) >> 8) & 0xFF); \
(B) = (uchar)(((ulong)(c) >> 16) & 0xFF); \
}
#define UNPACK_COLOR_RGBA(c,R,G,B) \
{ \
(R) = (uchar)(((ulong)(c) >> 24) & 0xFF); \
(G) = (uchar)(((ulong)(c) >> 16) & 0xFF); \
(B) = (uchar)(((ulong)(c) >> 8) & 0xFF); \
}
#define UNPACK_COLOR_BGRA(c,R,G,B) \
{ \
(R) = (uchar)(((ulong)(c) >> 8) & 0xFF); \
(G) = (uchar)(((ulong)(c) >> 16) & 0xFF); \
(B) = (uchar)(((ulong)(c) >> 24) & 0xFF); \
}
/*--------------------------- Global Variables ----------------------------*/
#define RC _MM_rc
#define MI _MGL_mi
#define PF _MGL_pf
#define VECS _MGL_vecs
extern MGLRC _MM_rc; /* Current rendering context */
extern MGLRC *_MM_rcPtr; /* Pointer to current context */
extern gmode_t _MGL_mi; /* MGL mode information */
extern pixel_format_t _MGL_pf; /* MGL mode pixel format */
extern vecs _MGL_vecs; /* MGL Rendering vectors */
/*------------------------- Function Prototypes ---------------------------*/
/* General functions */
void setup_DD_pointers(GLcontext *ctx);
points_func mmesa_get_points_func(GLcontext *ctx);
line_func mmesa_get_line_func(GLcontext *ctx);
triangle_func mmesa_get_triangle_func(GLcontext *ctx);
/* 8bpp rendering functions */
void _mmesa_write_span_ci(GLcontext *ctx,GLuint n, GLint x, GLint y,GLuint index[],GLubyte mask[]);
void _mmesa_write_span_8_8(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_8_DITHER8(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_mono_ci(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
void _mmesa_write_span_mono_8(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
void _mmesa_write_span_mono_8_DITHER8(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
void _mmesa_write_pixels_ci(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLuint index[], GLubyte mask[]);
void _mmesa_write_pixels_8_8(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_8_DITHER8(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_mono_ci(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
void _mmesa_write_pixels_mono_8(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
void _mmesa_write_pixels_mono_8_DITHER8(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
void _mmesa_read_span_ci(GLcontext *ctx,GLuint n, GLint x, GLint y,GLuint index[]);
void _mmesa_read_span_8(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
void _mmesa_read_pixels_ci(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLuint index[], GLubyte mask[]);
void _mmesa_read_pixels_8(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
/* 15/16bpp rendering functions */
void _mmesa_write_span_16_555(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_16_565(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_16_DITHER555(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_16_DITHER565(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_mono_16(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
void _mmesa_write_span_mono_16_DITHER555(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
void _mmesa_write_span_mono_16_DITHER565(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
void _mmesa_write_pixels_16_555(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_16_565(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_16_DITHER555(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_16_DITHER565(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_mono_16(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
void _mmesa_write_pixels_mono_16_DITHER555(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
void _mmesa_write_pixels_mono_16_DITHER565(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
void _mmesa_read_span_16_555(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
void _mmesa_read_span_16_565(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
void _mmesa_read_pixels_16_555(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_read_pixels_16_565(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
/* 24bpp rendering functions */
void _mmesa_write_span_24_RGB(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_24_BGR(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_mono_24_RGB(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
void _mmesa_write_span_mono_24_BGR(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
void _mmesa_write_pixels_24_RGB(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_24_BGR(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_mono_24_RGB(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
void _mmesa_write_pixels_mono_24_BGR(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
void _mmesa_read_span_24_RGB(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
void _mmesa_read_span_24_BGR(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
void _mmesa_read_pixels_24_RGB(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_read_pixels_24_BGR(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
/* 32bpp rendering functions */
void _mmesa_write_span_32_ARGB(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_32_ABGR(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_32_RGBA(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_32_BGRA(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_write_span_mono_32(GLcontext *ctx,GLuint n,GLint x,GLint y,GLubyte mask[]);
void _mmesa_write_pixels_32_ARGB(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_32_ABGR(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_32_RGBA(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_32_BGRA(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte r[], GLubyte g[],GLubyte b[],GLubyte a[],GLubyte mask[]);
void _mmesa_write_pixels_mono_32(GLcontext *ctx,GLuint n,GLint x[],GLint y[],GLubyte mask[]);
void _mmesa_read_span_32_ARGB(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
void _mmesa_read_span_32_ABGR(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
void _mmesa_read_span_32_RGBA(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
void _mmesa_read_span_32_BGRA(GLcontext *ctx,GLuint n, GLint x, GLint y,GLubyte red[], GLubyte green[],GLubyte blue[], GLubyte alpha[]);
void _mmesa_read_pixels_32_ARGB(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_read_pixels_32_ABGR(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_read_pixels_32_RGBA(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
void _mmesa_read_pixels_32_BGRA(GLcontext *ctx,GLuint n, GLint x[],GLint y[],GLubyte red[], GLubyte green[],GLubyte blue[],GLubyte alpha[],GLubyte mask[]);
#endif /* __MMESAP_H */
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.