#include <string.h>
#include <stdlib.h>
#include <stdio.h>
-#ifdef WIN32
#include <stdint.h>
-#endif
+#include <pthread.h>
#include "GL/glxproto.h"
-#include "glapi/glapitable.h"
#include "glxconfig.h"
#include "glxhash.h"
-#if defined( PTHREADS )
-# include <pthread.h>
-#endif
+#include "util/macros.h"
#include "glxextensions.h"
-#define ARRAY_SIZE(a) (sizeof (a) / sizeof ((a)[0]))
#define GLX_MAJOR_VERSION 1 /* current version numbers */
#define GLX_MINOR_VERSION 4
typedef struct __GLXDRIscreenRec __GLXDRIscreen;
typedef struct __GLXDRIdrawableRec __GLXDRIdrawable;
-#include "glxextensions.h"
-
struct __GLXDRIdisplayRec
{
/**
struct glx_config *config);
int64_t (*swapBuffers)(__GLXDRIdrawable *pdraw, int64_t target_msc,
- int64_t divisor, int64_t remainder);
+ int64_t divisor, int64_t remainder, Bool flush);
void (*copySubBuffer)(__GLXDRIdrawable *pdraw,
- int x, int y, int width, int height);
+ int x, int y, int width, int height, Bool flush);
int (*getDrawableMSC)(struct glx_screen *psc, __GLXDRIdrawable *pdraw,
int64_t *ust, int64_t *msc, int64_t *sbc);
int (*waitForMSC)(__GLXDRIdrawable *pdraw, int64_t target_msc,
int64_t *msc, int64_t *sbc);
int (*setSwapInterval)(__GLXDRIdrawable *pdraw, int interval);
int (*getSwapInterval)(__GLXDRIdrawable *pdraw);
+ int (*getBufferAge)(__GLXDRIdrawable *pdraw);
};
struct __GLXDRIdrawableRec
GLenum textureTarget;
GLenum textureFormat; /* EXT_texture_from_pixmap support */
unsigned long eventMask;
+ int refcount;
};
/*
extern __GLXDRIdisplay *driCreateDisplay(Display * dpy);
extern __GLXDRIdisplay *dri2CreateDisplay(Display * dpy);
extern void dri2InvalidateBuffers(Display *dpy, XID drawable);
+extern unsigned dri2GetSwapEventType(Display *dpy, XID drawable);
+extern __GLXDRIdisplay *dri3_create_display(Display * dpy);
/*
** Functions to obtain driver configuration information from a direct
void (*destroy)(struct glx_context *ctx);
int (*bind)(struct glx_context *context, struct glx_context *old,
GLXDrawable draw, GLXDrawable read);
- void (*unbind)(struct glx_context *context, struct glx_context *new);
+ void (*unbind)(struct glx_context *context, struct glx_context *new_ctx);
void (*wait_gl)(struct glx_context *ctx);
void (*wait_x)(struct glx_context *ctx);
void (*use_x_font)(struct glx_context *ctx,
GLXDrawable drawable,
int buffer, const int *attrib_list);
void (*release_tex_image)(Display * dpy, GLXDrawable drawable, int buffer);
-
+ void * (*get_proc_address)(const char *symbol);
};
-extern void
-glx_send_destroy_context(Display *dpy, XID xid);
-
/**
* GLX state that needs to be kept on the client. One of these records
* exist for each context that has been made current by this client.
GLint bufSize;
/*@} */
+ const struct glx_context_vtable *vtable;
+
/**
* The XID of this rendering context. When the context is created a
* new XID is allocated. This is set to None when the context is
GLuint *selectBuf;
/*@} */
- /**
- * This is \c GL_TRUE if the pixel unpack modes are such that an image
- * can be unpacked from the clients memory by just copying. It may
- * still be true that the server will have to do some work. This
- * just promises that a straight copy will fetch the correct bytes.
- */
- GLboolean fastImageUnpack;
-
/**
* Fill newImage with the unpacked form of \c oldImage getting it
* ready for transport to the server.
*/
Bool isDirect;
+#if defined(GLX_DIRECT_RENDERING) && defined(GLX_USE_APPLEGL)
+ void *driContext;
+#endif
+
/**
* \c dpy of current display for this context. Will be \c NULL if not
* current to any display, or if this is the "dummy context".
/*@} */
/**
- * Thread ID we're currently current in. Zero if none.
+ * Number of threads we're currently current in.
*/
- unsigned long thread_id;
+ unsigned long thread_refcount;
char gl_extension_bits[__GL_EXT_BYTES];
-
- const struct glx_context_vtable *vtable;
};
extern Bool
struct glx_config *config,
struct glx_context *shareList,
int renderType);
+
+ struct glx_context *(*create_context_attribs)(struct glx_screen *psc,
+ struct glx_config *config,
+ struct glx_context *shareList,
+ unsigned num_attrib,
+ const uint32_t *attribs,
+ unsigned *error);
+ int (*query_renderer_integer)(struct glx_screen *psc,
+ int attribute,
+ unsigned int *value);
+ int (*query_renderer_string)(struct glx_screen *psc,
+ int attribute,
+ const char **value);
};
struct glx_screen
struct glx_display *display;
+ Display *dpy;
+ int scr;
+
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
/**
* Per screen direct rendering interface functions and data.
*/
- Display *dpy;
- int scr;
-
__GLXDRIscreen *driScreen;
#endif
*/
struct glx_screen **screens;
+ __glxHashTable *glXDrawHash;
+
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
__glxHashTable *drawHash;
__GLXDRIdisplay *driswDisplay;
__GLXDRIdisplay *driDisplay;
__GLXDRIdisplay *dri2Display;
+ __GLXDRIdisplay *dri3Display;
#endif
};
+struct glx_drawable {
+ XID xDrawable;
+ XID drawable;
+
+ uint32_t lastEventSbc;
+ int64_t eventSbcWrap;
+};
+
extern int
glx_screen_init(struct glx_screen *psc,
int screen, struct glx_display * priv);
+extern void
+glx_screen_cleanup(struct glx_screen *psc);
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
extern __GLXDRIdrawable *
extern int __glXDebug;
/* This is per-thread storage in an MT environment */
-#if defined( PTHREADS )
extern void __glXSetCurrentContext(struct glx_context * c);
# endif /* defined( GLX_USE_TLS ) */
-#else
-
-extern struct glx_context *__glXcurrentContext;
-#define __glXGetCurrentContext() __glXcurrentContext
-#define __glXSetCurrentContext(gc) __glXcurrentContext = gc
-
-#endif /* defined( PTHREADS ) */
-
extern void __glXSetCurrentContextNull(void);
** Global lock for all threads in this address space using the GLX
** extension
*/
-#if defined( PTHREADS )
extern pthread_mutex_t __glXmutex;
#define __glXLock() pthread_mutex_lock(&__glXmutex)
#define __glXUnlock() pthread_mutex_unlock(&__glXmutex)
-#else
-#define __glXLock()
-#define __glXUnlock()
-#endif
/*
** Setup for a command. Initialize the extension for dpy if necessary.
*/
extern void __glXClientInfo(Display * dpy, int opcode);
+_X_HIDDEN void
+__glX_send_client_info(struct glx_display *glx_dpy);
+
/************************************************************************/
/*
extern char *__glXGetString(Display * dpy, int opcode,
CARD32 screen, CARD32 name);
-extern char *__glXstrdup(const char *str);
-
-
extern const char __glXGLClientVersion[];
extern const char __glXGLClientExtensions[];
#if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
extern GLboolean
-__glxGetMscRate(__GLXDRIdrawable *glxDraw,
+__glxGetMscRate(struct glx_screen *psc,
int32_t * numerator, int32_t * denominator);
/* So that dri2.c:DRI2WireToEvent() can access
extern __GLXDRIdrawable *
GetGLXDRIDrawable(Display *dpy, GLXDrawable drawable);
+#endif
+
+extern struct glx_screen *GetGLXScreenConfigs(Display * dpy, int scrn);
+#ifdef GLX_USE_APPLEGL
+extern struct glx_screen *
+applegl_create_screen(int screen, struct glx_display * priv);
+
+extern struct glx_context *
+applegl_create_context(struct glx_screen *psc,
+ struct glx_config *mode,
+ struct glx_context *shareList, int renderType);
+
+extern int
+applegl_create_display(struct glx_display *display);
#endif
+extern Bool validate_renderType_against_config(const struct glx_config *config,
+ int renderType);
+
+
+extern struct glx_drawable *GetGLXDrawable(Display *dpy, GLXDrawable drawable);
+extern int InitGLXDrawable(Display *dpy, struct glx_drawable *glxDraw,
+ XID xDrawable, GLXDrawable drawable);
+extern void DestroyGLXDrawable(Display *dpy, GLXDrawable drawable);
+
+extern struct glx_context dummyContext;
+
extern struct glx_screen *
indirect_create_screen(int screen, struct glx_display * priv);
extern struct glx_context *
indirect_create_context(struct glx_screen *psc,
struct glx_config *mode,
struct glx_context *shareList, int renderType);
+extern struct glx_context *
+indirect_create_context_attribs(struct glx_screen *base,
+ struct glx_config *config_base,
+ struct glx_context *shareList,
+ unsigned num_attribs,
+ const uint32_t *attribs,
+ unsigned *error);
#endif /* !__GLX_client_h__ */