|
|
|
@@ -189,259 +189,6 @@ typedef struct __GLcontextModesRec { |
|
|
|
|
|
|
|
/************************************************************************/ |
|
|
|
|
|
|
|
/* |
|
|
|
** Structure used for allocating and freeing drawable private memory. |
|
|
|
** (like software buffers, for example). |
|
|
|
** |
|
|
|
** The memory allocation routines are provided by the surrounding |
|
|
|
** "operating system" code, and they are to be used for allocating |
|
|
|
** software buffers and things which are associated with the drawable, |
|
|
|
** and used by any context which draws to that drawable. There are |
|
|
|
** separate memory allocation functions for drawables and contexts |
|
|
|
** since drawables and contexts can be created and destroyed independently |
|
|
|
** of one another, and the "operating system" may want to use separate |
|
|
|
** allocation arenas for each. |
|
|
|
** |
|
|
|
** The freePrivate function is filled in by the core routines when they |
|
|
|
** allocates software buffers, and stick them in "private". The freePrivate |
|
|
|
** function will destroy anything allocated to this drawable (to be called |
|
|
|
** when the drawable is destroyed). |
|
|
|
*/ |
|
|
|
typedef struct __GLdrawableRegionRec __GLdrawableRegion; |
|
|
|
typedef struct __GLdrawableBufferRec __GLdrawableBuffer; |
|
|
|
typedef struct __GLdrawablePrivateRec __GLdrawablePrivate; |
|
|
|
|
|
|
|
typedef struct __GLregionRectRec { |
|
|
|
/* lower left (inside the rectangle) */ |
|
|
|
GLint x0, y0; |
|
|
|
/* upper right (outside the rectangle) */ |
|
|
|
GLint x1, y1; |
|
|
|
} __GLregionRect; |
|
|
|
|
|
|
|
struct __GLdrawableRegionRec { |
|
|
|
GLint numRects; |
|
|
|
__GLregionRect *rects; |
|
|
|
__GLregionRect boundingRect; |
|
|
|
}; |
|
|
|
|
|
|
|
/************************************************************************/ |
|
|
|
|
|
|
|
/* masks for the buffers */ |
|
|
|
#define __GL_FRONT_BUFFER_MASK 0x00000001 |
|
|
|
#define __GL_FRONT_LEFT_BUFFER_MASK 0x00000001 |
|
|
|
#define __GL_FRONT_RIGHT_BUFFER_MASK 0x00000002 |
|
|
|
#define __GL_BACK_BUFFER_MASK 0x00000004 |
|
|
|
#define __GL_BACK_LEFT_BUFFER_MASK 0x00000004 |
|
|
|
#define __GL_BACK_RIGHT_BUFFER_MASK 0x00000008 |
|
|
|
#define __GL_ACCUM_BUFFER_MASK 0x00000010 |
|
|
|
#define __GL_DEPTH_BUFFER_MASK 0x00000020 |
|
|
|
#define __GL_STENCIL_BUFFER_MASK 0x00000040 |
|
|
|
#define __GL_AUX_BUFFER_MASK(i) (0x0000080 << (i)) |
|
|
|
|
|
|
|
#define __GL_ALL_BUFFER_MASK 0xffffffff |
|
|
|
|
|
|
|
/* what Resize routines return if resize resorted to fallback case */ |
|
|
|
#define __GL_BUFFER_FALLBACK 0x10 |
|
|
|
|
|
|
|
typedef void (*__GLbufFallbackInitFn)(__GLdrawableBuffer *buf, |
|
|
|
__GLdrawablePrivate *glPriv, GLint bits); |
|
|
|
typedef void (*__GLbufMainInitFn)(__GLdrawableBuffer *buf, |
|
|
|
__GLdrawablePrivate *glPriv, GLint bits, |
|
|
|
__GLbufFallbackInitFn back); |
|
|
|
|
|
|
|
/* |
|
|
|
** A drawable buffer |
|
|
|
** |
|
|
|
** This data structure describes the context side of a drawable. |
|
|
|
** |
|
|
|
** According to the spec there could be multiple contexts bound to the same |
|
|
|
** drawable at the same time (from different threads). In order to avoid |
|
|
|
** multiple-access conflicts, locks are used to serialize access. When a |
|
|
|
** thread needs to access (read or write) a member of the drawable, it takes |
|
|
|
** a lock first. Some of the entries in the drawable are treated "mostly |
|
|
|
** constant", so we take the freedom of allowing access to them without |
|
|
|
** taking a lock (for optimization reasons). |
|
|
|
** |
|
|
|
** For more details regarding locking, see buffers.h in the GL core |
|
|
|
*/ |
|
|
|
struct __GLdrawableBufferRec { |
|
|
|
/* |
|
|
|
** Buffer dimensions |
|
|
|
*/ |
|
|
|
GLint width, height, depth; |
|
|
|
|
|
|
|
/* |
|
|
|
** Framebuffer base address |
|
|
|
*/ |
|
|
|
void *base; |
|
|
|
|
|
|
|
/* |
|
|
|
** Framebuffer size (in bytes) |
|
|
|
*/ |
|
|
|
GLuint size; |
|
|
|
|
|
|
|
/* |
|
|
|
** Size (in bytes) of each element in the framebuffer |
|
|
|
*/ |
|
|
|
GLuint elementSize; |
|
|
|
GLuint elementSizeLog2; |
|
|
|
|
|
|
|
/* |
|
|
|
** Element skip from one scanline to the next. |
|
|
|
** If the buffer is part of another buffer (for example, fullscreen |
|
|
|
** front buffer), outerWidth is the width of that buffer. |
|
|
|
*/ |
|
|
|
GLint outerWidth; |
|
|
|
|
|
|
|
/* |
|
|
|
** outerWidth * elementSize |
|
|
|
*/ |
|
|
|
GLint byteWidth; |
|
|
|
|
|
|
|
/* |
|
|
|
** Allocation/deallocation is done based on this handle. A handle |
|
|
|
** is conceptually different from the framebuffer 'base'. |
|
|
|
*/ |
|
|
|
void *handle; |
|
|
|
|
|
|
|
/* imported */ |
|
|
|
GLboolean (*resize)(__GLdrawableBuffer *buf, |
|
|
|
GLint x, GLint y, GLuint width, GLuint height, |
|
|
|
__GLdrawablePrivate *glPriv, GLuint bufferMask); |
|
|
|
void (*lock)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv); |
|
|
|
void (*unlock)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv); |
|
|
|
void (*fill)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv, |
|
|
|
GLuint val, GLint x, GLint y, GLint w, GLint h); |
|
|
|
void (*free)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv); |
|
|
|
|
|
|
|
/* exported */ |
|
|
|
void (*freePrivate)(__GLdrawableBuffer *buf, __GLdrawablePrivate *glPriv); |
|
|
|
#ifdef __cplusplus |
|
|
|
void *privatePtr; |
|
|
|
#else |
|
|
|
void *private; |
|
|
|
#endif |
|
|
|
|
|
|
|
/* private */ |
|
|
|
void *other; /* implementation private data */ |
|
|
|
__GLbufMainInitFn mainInit; |
|
|
|
__GLbufFallbackInitFn fallbackInit; |
|
|
|
}; |
|
|
|
|
|
|
|
/* |
|
|
|
** The context side of the drawable private |
|
|
|
*/ |
|
|
|
struct __GLdrawablePrivateRec { |
|
|
|
/* |
|
|
|
** Drawable Modes |
|
|
|
*/ |
|
|
|
__GLcontextModes *modes; |
|
|
|
|
|
|
|
/* |
|
|
|
** Drawable size |
|
|
|
*/ |
|
|
|
GLuint width, height; |
|
|
|
|
|
|
|
/* |
|
|
|
** Origin in screen coordinates of the drawable |
|
|
|
*/ |
|
|
|
GLint xOrigin, yOrigin; |
|
|
|
#ifdef __GL_ALIGNED_BUFFERS |
|
|
|
/* |
|
|
|
** Drawable offset from screen origin |
|
|
|
*/ |
|
|
|
GLint xOffset, yOffset; |
|
|
|
|
|
|
|
/* |
|
|
|
** Alignment restriction |
|
|
|
*/ |
|
|
|
GLint xAlignment, yAlignment; |
|
|
|
#endif |
|
|
|
/* |
|
|
|
** Should we invert the y axis? |
|
|
|
*/ |
|
|
|
GLint yInverted; |
|
|
|
|
|
|
|
/* |
|
|
|
** Mask specifying which buffers are renderable by the hw |
|
|
|
*/ |
|
|
|
GLuint accelBufferMask; |
|
|
|
|
|
|
|
/* |
|
|
|
** the buffers themselves |
|
|
|
*/ |
|
|
|
__GLdrawableBuffer frontBuffer; |
|
|
|
__GLdrawableBuffer backBuffer; |
|
|
|
__GLdrawableBuffer accumBuffer; |
|
|
|
__GLdrawableBuffer depthBuffer; |
|
|
|
__GLdrawableBuffer stencilBuffer; |
|
|
|
#if defined(__GL_NUMBER_OF_AUX_BUFFERS) && (__GL_NUMBER_OF_AUX_BUFFERS > 0) |
|
|
|
__GLdrawableBuffer *auxBuffer; |
|
|
|
#endif |
|
|
|
|
|
|
|
__GLdrawableRegion ownershipRegion; |
|
|
|
|
|
|
|
/* |
|
|
|
** Lock for the drawable private structure |
|
|
|
*/ |
|
|
|
void *lock; |
|
|
|
#ifdef DEBUG |
|
|
|
/* lock debugging info */ |
|
|
|
int lockRefCount; |
|
|
|
int lockLine[10]; |
|
|
|
char *lockFile[10]; |
|
|
|
#endif |
|
|
|
|
|
|
|
/* imported */ |
|
|
|
void *(*malloc)(size_t size); |
|
|
|
void *(*calloc)(size_t numElem, size_t elemSize); |
|
|
|
void *(*realloc)(void *oldAddr, size_t newSize); |
|
|
|
void (*free)(void *addr); |
|
|
|
|
|
|
|
GLboolean (*addSwapRect)(__GLdrawablePrivate *glPriv, |
|
|
|
GLint x, GLint y, GLsizei width, GLsizei height); |
|
|
|
void (*setClipRect)(__GLdrawablePrivate *glPriv, |
|
|
|
GLint x, GLint y, GLsizei width, GLsizei height); |
|
|
|
void (*updateClipRegion)(__GLdrawablePrivate *glPriv); |
|
|
|
GLboolean (*resize)(__GLdrawablePrivate *glPriv); |
|
|
|
void (*getDrawableSize)(__GLdrawablePrivate *glPriv, |
|
|
|
GLint *x, GLint *y, GLuint *width, GLuint *height); |
|
|
|
|
|
|
|
void (*lockDP)(__GLdrawablePrivate *glPriv, __GLcontext *gc); |
|
|
|
void (*unlockDP)(__GLdrawablePrivate *glPriv); |
|
|
|
|
|
|
|
/* exported */ |
|
|
|
#ifdef __cplusplus |
|
|
|
void *privatePtr; |
|
|
|
#else |
|
|
|
void *private; |
|
|
|
#endif |
|
|
|
void (*freePrivate)(__GLdrawablePrivate *); |
|
|
|
|
|
|
|
/* client data */ |
|
|
|
void *other; |
|
|
|
}; |
|
|
|
|
|
|
|
/* |
|
|
|
** Macros to lock/unlock the drawable private |
|
|
|
*/ |
|
|
|
#if defined(DEBUG) |
|
|
|
#define __GL_LOCK_DP(glPriv,gc) \ |
|
|
|
(*(glPriv)->lockDP)(glPriv,gc); \ |
|
|
|
(glPriv)->lockLine[(glPriv)->lockRefCount] = __LINE__; \ |
|
|
|
(glPriv)->lockFile[(glPriv)->lockRefCount] = __FILE__; \ |
|
|
|
(glPriv)->lockRefCount++ |
|
|
|
#define __GL_UNLOCK_DP(glPriv) \ |
|
|
|
(glPriv)->lockRefCount--; \ |
|
|
|
(glPriv)->lockLine[(glPriv)->lockRefCount] = 0; \ |
|
|
|
(glPriv)->lockFile[(glPriv)->lockRefCount] = NULL; \ |
|
|
|
(*(glPriv)->unlockDP)(glPriv) |
|
|
|
#else /* DEBUG */ |
|
|
|
#define __GL_LOCK_DP(glPriv,gc) (*(glPriv)->lockDP)(glPriv,gc) |
|
|
|
#define __GL_UNLOCK_DP(glPriv) (*(glPriv)->unlockDP)(glPriv) |
|
|
|
#endif /* DEBUG */ |
|
|
|
|
|
|
|
|
|
|
|
/* |
|
|
|
** Procedures which are imported by the GL from the surrounding |
|
|
|
** "operating system". Math functions are not considered part of the |
|
|
|
@@ -467,8 +214,8 @@ typedef struct __GLimportsRec { |
|
|
|
int (CAPI *fprintf)(__GLcontext *gc, void *stream, const char *fmt, ...); |
|
|
|
|
|
|
|
/* Drawing surface management */ |
|
|
|
__GLdrawablePrivate *(*getDrawablePrivate)(__GLcontext *gc); |
|
|
|
__GLdrawablePrivate *(*getReadablePrivate)(__GLcontext *gc); |
|
|
|
void *(*getDrawablePrivate)(__GLcontext *gc); |
|
|
|
void *(*getReadablePrivate)(__GLcontext *gc); |
|
|
|
|
|
|
|
/* Operating system dependent data goes here */ |
|
|
|
void *other; |