GLint __glGetMap_size(GLenum target, GLenum query)
{
GLint k, order=0, majorMinor[2];
/*
** Assume target and query are both valid.
*/
switch (target) {
case GL_MAP1_COLOR_4:
case GL_MAP1_NORMAL:
case GL_MAP1_INDEX:
case GL_MAP1_TEXTURE_COORD_1:
case GL_MAP1_TEXTURE_COORD_2:
case GL_MAP1_TEXTURE_COORD_3:
case GL_MAP1_TEXTURE_COORD_4:
case GL_MAP1_VERTEX_3:
case GL_MAP1_VERTEX_4:
switch (query) {
case GL_COEFF:
k = __glMap1d_size(target);
glGetMapiv(target, GL_ORDER, &order);
/*
** The query above might fail, but then order will be zero anyway.
*/
return (order * k);
case GL_DOMAIN:
return 2;
case GL_ORDER:
return 1;
}
break;
case GL_MAP2_COLOR_4:
case GL_MAP2_NORMAL:
case GL_MAP2_INDEX:
case GL_MAP2_TEXTURE_COORD_1:
case GL_MAP2_TEXTURE_COORD_2:
case GL_MAP2_TEXTURE_COORD_3:
case GL_MAP2_TEXTURE_COORD_4:
case GL_MAP2_VERTEX_3:
case GL_MAP2_VERTEX_4:
switch (query) {
case GL_COEFF:
k = __glMap2d_size(target);
majorMinor[0] = majorMinor[1] = 0;
glGetMapiv(target, GL_ORDER, majorMinor);
/*
** The query above might fail, but then majorMinor will be zeroes
*/
return (majorMinor[0] * majorMinor[1] * k);
case GL_DOMAIN:
return 4;
case GL_ORDER:
return 2;
}
break;
}
return -1;
}
void
__glXDispSwap_Map2d(GLbyte * pc)
{
GLdouble u1, u2, v1, v2, *points;
GLint uorder, vorder, ustride, vstride, k, compsize;
GLenum target;
__GLX_DECLARE_SWAP_VARIABLES;
__GLX_DECLARE_SWAP_ARRAY_VARIABLES;
__GLX_SWAP_DOUBLE(pc + 0);
__GLX_SWAP_DOUBLE(pc + 8);
__GLX_SWAP_DOUBLE(pc + 16);
__GLX_SWAP_DOUBLE(pc + 24);
__GLX_SWAP_INT(pc + 32);
__GLX_SWAP_INT(pc + 36);
__GLX_SWAP_INT(pc + 40);
target = *(GLenum *) (pc + 32);
uorder = *(GLint *) (pc + 36);
vorder = *(GLint *) (pc + 40);
k = __glMap2d_size(target);
if (vorder <= 0 || uorder <= 0 || k < 0) {
/* Erroneous command. */
compsize = 0;
}
else {
compsize = uorder * vorder * k;
}
__GLX_GET_DOUBLE(u1, pc);
__GLX_GET_DOUBLE(u2, pc + 8);
__GLX_GET_DOUBLE(v1, pc + 16);
__GLX_GET_DOUBLE(v2, pc + 24);
__GLX_SWAP_DOUBLE_ARRAY(pc + 44, compsize);
pc += 44;
ustride = vorder * k;
vstride = k;
#ifdef __GLX_ALIGN64
if (((unsigned long) pc) & 7) {
/*
** Copy the doubles up 4 bytes, trashing the command but aligning
** the data in the process
*/
__GLX_MEM_COPY(pc - 4, pc, compsize * 8);
points = (GLdouble *) (pc - 4);
}
else {
points = (GLdouble *) pc;
}
#else
points = (GLdouble *) pc;
#endif
CALL_Map2d(GET_DISPATCH(),
(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder,
points));
}
void
__glXDisp_Map2d(GLbyte * pc)
{
GLdouble u1, u2, v1, v2, *points;
GLint uorder, vorder, ustride, vstride, k;
#ifdef __GLX_ALIGN64
GLint compsize;
#endif
GLenum target;
target = *(GLenum *) (pc + 32);
uorder = *(GLint *) (pc + 36);
vorder = *(GLint *) (pc + 40);
k = __glMap2d_size(target);
#ifdef __GLX_ALIGN64
if (vorder < 0 || uorder < 0 || k < 0) {
compsize = 0;
}
else {
compsize = uorder * vorder * k;
}
#endif
__GLX_GET_DOUBLE(u1, pc);
__GLX_GET_DOUBLE(u2, pc + 8);
__GLX_GET_DOUBLE(v1, pc + 16);
__GLX_GET_DOUBLE(v2, pc + 24);
pc += 44;
ustride = vorder * k;
vstride = k;
#ifdef __GLX_ALIGN64
if (((unsigned long) pc) & 7) {
/*
** Copy the doubles up 4 bytes, trashing the command but aligning
** the data in the process
*/
__GLX_MEM_COPY(pc - 4, pc, compsize * 8);
points = (GLdouble *) (pc - 4);
}
else {
points = (GLdouble *) pc;
}
#else
points = (GLdouble *) pc;
#endif
glMap2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}
int
__glXMap2dReqSize(const GLbyte * pc, Bool swap, int reqlen)
{
GLenum target;
GLint uorder, vorder;
target = *(GLenum *) (pc + 32);
uorder = *(GLint *) (pc + 36);
vorder = *(GLint *) (pc + 40);
if (swap) {
target = SWAPL(target);
uorder = SWAPL(uorder);
vorder = SWAPL(vorder);
}
return safe_mul(8, Map2Size(__glMap2d_size(target), uorder, vorder));
}
int __glXMap2dReqSize(GLbyte *pc, Bool swap )
{
GLenum target;
GLint uorder, vorder, k;
target = *(GLenum *)(pc + 32);
uorder = *(GLint *)(pc + 36);
vorder = *(GLint *)(pc + 40);
if (swap) {
target = SWAPL( target );
uorder = SWAPL( uorder );
vorder = SWAPL( vorder );
}
k = __glMap2d_size( target );
return 8 * Map2Size( k, uorder, vorder );
}
void
__indirect_glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustr,
GLint uord, GLdouble v1, GLdouble v2, GLint vstr,
GLint vord, const GLdouble * pnts)
{
__GLX_DECLARE_VARIABLES();
GLint k;
__GLX_LOAD_VARIABLES();
k = __glMap2d_size(target);
if (k == 0) {
__glXSetError(gc, GL_INVALID_ENUM);
return;
}
else if (vstr < k || ustr < k || vord <= 0 || uord <= 0) {
__glXSetError(gc, GL_INVALID_VALUE);
return;
}
compsize = k * uord * vord * __GLX_SIZE_FLOAT64;
cmdlen = 48 + compsize;
if (!gc->currentDpy)
return;
if (cmdlen <= gc->maxSmallRenderCommandSize) {
/* Use GLXRender protocol to send small command */
__GLX_BEGIN_VARIABLE(X_GLrop_Map2d, cmdlen);
__GLX_PUT_DOUBLE(4, u1);
__GLX_PUT_DOUBLE(12, u2);
__GLX_PUT_DOUBLE(20, v1);
__GLX_PUT_DOUBLE(28, v2);
__GLX_PUT_LONG(36, target);
__GLX_PUT_LONG(40, uord);
__GLX_PUT_LONG(44, vord);
/*
** Pack into a u-major ordering.
** NOTE: the doubles that follow are not aligned because of 5
** longs preceeding
*/
__glFillMap2d(k, uord, vord, ustr, vstr, pnts, (GLdouble *) (pc + 48));
__GLX_END(cmdlen);
}
else {
/* Use GLXRenderLarge protocol to send command */
__GLX_BEGIN_VARIABLE_LARGE(X_GLrop_Map2d, cmdlen + 4);
__GLX_PUT_DOUBLE(8, u1);
__GLX_PUT_DOUBLE(16, u2);
__GLX_PUT_DOUBLE(24, v1);
__GLX_PUT_DOUBLE(32, v2);
__GLX_PUT_LONG(40, target);
__GLX_PUT_LONG(44, uord);
__GLX_PUT_LONG(48, vord);
/*
** NOTE: the doubles that follow are not aligned because of 5
** longs preceeding
*/
if ((vstr != k) || (ustr != k * vord)) {
GLdouble *buf;
buf = (GLdouble *) Xmalloc(compsize);
if (!buf) {
__glXSetError(gc, GL_OUT_OF_MEMORY);
return;
}
/*
** Pack into a u-major ordering.
*/
__glFillMap2d(k, uord, vord, ustr, vstr, pnts, buf);
__glXSendLargeCommand(gc, pc, 52, buf, compsize);
Xfree((char *) buf);
}
else {
/* Data is already packed. Just send it out */
__glXSendLargeCommand(gc, pc, 52, pnts, compsize);
}
}
}
