#include "packsingle.h"
void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
GLenum format, GLenum type, GLvoid *pixels)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXReadPixelsReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
__GLX_SINGLE_BEGIN(X_GLsop_ReadPixels,__GLX_PAD(26));
__GLX_SINGLE_PUT_LONG(0,x);
__GLX_SINGLE_PUT_LONG(4,y);
__GLX_SINGLE_PUT_LONG(8,width);
__GLX_SINGLE_PUT_LONG(12,height);
__GLX_SINGLE_PUT_LONG(16,format);
__GLX_SINGLE_PUT_LONG(20,type);
__GLX_SINGLE_PUT_CHAR(24,state->storePack.swapEndian);
__GLX_SINGLE_PUT_CHAR(25,GL_FALSE);
__GLX_SINGLE_READ_XREPLY();
compsize = reply.length << 2;
if (compsize != 0) {
buf = (GLubyte*) Xmalloc(compsize);
if (!buf) {
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
__GLX_SINGLE_GET_CHAR_ARRAY(buf,compsize);
__glEmptyImage(gc, 2, width, height, 1, format, type, buf, pixels);
Xfree((char*) buf);
}
} else {
}
__GLX_SINGLE_END();
}
void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type,
GLvoid *texels)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetTexImageReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
__GLX_SINGLE_BEGIN(X_GLsop_GetTexImage,__GLX_PAD(17));
__GLX_SINGLE_PUT_LONG(0,target);
__GLX_SINGLE_PUT_LONG(4,level);
__GLX_SINGLE_PUT_LONG(8,format);
__GLX_SINGLE_PUT_LONG(12,type);
__GLX_SINGLE_PUT_CHAR(16,state->storePack.swapEndian);
__GLX_SINGLE_READ_XREPLY();
compsize = reply.length << 2;
if (compsize != 0) {
buf = (GLubyte*) Xmalloc(compsize);
if (!buf) {
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
GLint width, height, depth;
width = reply.width;
height = reply.height;
depth = reply.depth;
__GLX_SINGLE_GET_CHAR_ARRAY(buf,compsize);
__glEmptyImage(gc, 2, width, height, depth, format, type, buf,
texels);
Xfree((char*) buf);
}
} else {
}
__GLX_SINGLE_END();
}
void glGetPolygonStipple(GLubyte *mask)
{
__GLX_SINGLE_DECLARE_VARIABLES();
xGLXSingleReply reply;
GLubyte buf[128];
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
__GLX_SINGLE_BEGIN(X_GLsop_GetPolygonStipple,__GLX_PAD(1));
__GLX_SINGLE_PUT_CHAR(0,GL_FALSE);
__GLX_SINGLE_READ_XREPLY();
if (reply.length == 32) {
__GLX_SINGLE_GET_CHAR_ARRAY(buf,128);
__glEmptyImage(gc, 2, 32, 32, 1, GL_COLOR_INDEX, GL_BITMAP, buf, mask);
}
__GLX_SINGLE_END();
}
void glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetColorTableReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
__GLX_SINGLE_BEGIN(X_GLsop_GetColorTable,__GLX_PAD(13));
__GLX_SINGLE_PUT_LONG(0,(long)target);
__GLX_SINGLE_PUT_LONG(4,(long)format);
__GLX_SINGLE_PUT_LONG(8,(long)type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_READ_XREPLY();
compsize = (long)reply.length << 2;
if (compsize != 0) {
buf = (GLubyte*)Xmalloc(compsize);
if (!buf) {
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
GLint width;
width = (int)reply.width;
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
__glEmptyImage(gc, 1, width, 1, 1, format, type, buf, table);
Xfree((char*) buf);
}
} else {
}
__GLX_SINGLE_END();
}
void glGetConvolutionFilter(GLenum target, GLenum format, GLenum type,
GLvoid *image)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetConvolutionFilterReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
__GLX_SINGLE_BEGIN(X_GLsop_GetConvolutionFilter, __GLX_PAD(13));
__GLX_SINGLE_PUT_LONG(0,target);
__GLX_SINGLE_PUT_LONG(4,format);
__GLX_SINGLE_PUT_LONG(8,type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_READ_XREPLY();
compsize = reply.length << 2;
if (compsize != 0) {
buf = (GLubyte*) Xmalloc(compsize);
if (!buf) {
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
GLint width, height;
width = reply.width;
height = reply.height;
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),compsize);
__glEmptyImage(gc, 2, width, height, 1, format, type, buf, image);
Xfree((char*) buf);
}
} else {
}
__GLX_SINGLE_END();
}
void glGetSeparableFilter(GLenum target, GLenum format, GLenum type,
GLvoid *row, GLvoid *column, GLvoid *span)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetSeparableFilterReply reply;
GLubyte *rowBuf, *colBuf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
__GLX_SINGLE_BEGIN(X_GLsop_GetSeparableFilter, __GLX_PAD(13));
__GLX_SINGLE_PUT_LONG(0,target);
__GLX_SINGLE_PUT_LONG(4,format);
__GLX_SINGLE_PUT_LONG(8,type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_READ_XREPLY();
compsize = reply.length << 2;
if (compsize != 0) {
GLint width, height;
GLint widthsize, heightsize;
width = reply.width;
height = reply.height;
widthsize = __glImageSize(width,1,1,format, type);
heightsize = __glImageSize(height,1,1,format, type);
rowBuf = (GLubyte*) Xmalloc(widthsize);
if (!rowBuf) {
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
UnlockDisplay(dpy);
SyncHandle();
return;
} else {
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)rowBuf),widthsize);
__glEmptyImage(gc, 1, width, 1, 1, format, type, rowBuf, row);
Xfree((char*) rowBuf);
}
colBuf = (GLubyte*) Xmalloc(heightsize);
if (!colBuf) {
_XEatData(dpy, compsize - __GLX_PAD(widthsize));
__glXSetError(gc, GL_OUT_OF_MEMORY);
UnlockDisplay(dpy);
SyncHandle();
return;
} else {
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)colBuf),heightsize);
__glEmptyImage(gc, 1, height, 1, 1, format, type, colBuf, column);
Xfree((char*) colBuf);
}
} else {
}
__GLX_SINGLE_END();
}
void glGetHistogram(GLenum target, GLboolean reset, GLenum format,
GLenum type, GLvoid *values)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetHistogramReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
__GLX_SINGLE_BEGIN(X_GLsop_GetHistogram,__GLX_PAD(14));
__GLX_SINGLE_PUT_LONG(0,(long)target);
__GLX_SINGLE_PUT_LONG(4,(long)format);
__GLX_SINGLE_PUT_LONG(8,(long)type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_PUT_CHAR(13,reset);
__GLX_SINGLE_READ_XREPLY();
compsize = (long)reply.length << 2;
if (compsize != 0) {
buf = (GLubyte*)Xmalloc(compsize);
if (!buf) {
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
GLint width;
width = (int)reply.width;
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
__glEmptyImage(gc, 1, width, 1, 1, format, type, buf, values);
Xfree((char*) buf);
}
} else {
}
__GLX_SINGLE_END();
}
void glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type,
GLvoid *values)
{
__GLX_SINGLE_DECLARE_VARIABLES();
const __GLXattribute * state;
xGLXGetMinmaxReply reply;
GLubyte *buf;
if (!dpy) return;
__GLX_SINGLE_LOAD_VARIABLES();
state = gc->client_state_private;
__GLX_SINGLE_BEGIN(X_GLsop_GetMinmax,__GLX_PAD(14));
__GLX_SINGLE_PUT_LONG(0,(long)target);
__GLX_SINGLE_PUT_LONG(4,(long)format);
__GLX_SINGLE_PUT_LONG(8,(long)type);
__GLX_SINGLE_PUT_CHAR(12,state->storePack.swapEndian);
__GLX_SINGLE_PUT_CHAR(13,reset);
__GLX_SINGLE_READ_XREPLY();
compsize = (long)reply.length << 2;
if (compsize != 0) {
buf = (GLubyte*)Xmalloc(compsize);
if (!buf) {
_XEatData(dpy, compsize);
__glXSetError(gc, GL_OUT_OF_MEMORY);
} else {
__GLX_SINGLE_GET_CHAR_ARRAY(((char*)buf),(long)compsize);
__glEmptyImage(gc, 1, 2, 1, 1, format, type, buf, values);
Xfree((char*) buf);
}
} else {
}
__GLX_SINGLE_END();
}