src/glx/packrender.h

   1 #ifndef __GLX_packrender_h__
   2 #define __GLX_packrender_h__
   3
   4 /*
   5  * SGI FREE SOFTWARE LICENSE B (Version 2.0, Sept. 18, 2008)
   6  * Copyright (C) 1991-2000 Silicon Graphics, Inc. All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice including the dates of first publication and
  16  * either this permission notice or a reference to
  17  * http://oss.sgi.com/projects/FreeB/
  18  * shall be included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  23  * SILICON GRAPHICS, INC. BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  24  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  25  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26  * SOFTWARE.
  27  *
  28  * Except as contained in this notice, the name of Silicon Graphics, Inc.
  29  * shall not be used in advertising or otherwise to promote the sale, use or
  30  * other dealings in this Software without prior written authorization from
  31  * Silicon Graphics, Inc.
  32  */
  33
  34 #include "glxclient.h"
  35
  36 /*
  37 ** The macros in this header convert the client machine's native data types to
  38 ** wire protocol data types.  The header is part of the porting layer of the
  39 ** client library, and it is intended that hardware vendors will rewrite this
  40 ** header to suit their own machines.
  41 */
  42
  43 /*
  44 ** Pad a count of bytes to the nearest multiple of 4.  The X protocol
  45 ** transfers data in 4 byte quantities, so this macro is used to
  46 ** insure the right amount of data being sent.
  47 */
  48 #define __GLX_PAD(a) (((a)+3) & ~3)
  49
  50 /*
  51 ** Network size parameters
  52 */
  53 #define sz_double 8
  54
  55 /* Setup for all commands */
  56 #define __GLX_DECLARE_VARIABLES()               \
  57    __GLXcontext *gc;                            \
  58    GLubyte *pc, *pixelHeaderPC;                 \
  59    GLuint compsize, cmdlen
  60
  61 #define __GLX_LOAD_VARIABLES()     \
  62    gc = __glXGetCurrentContext();  \
  63    pc = gc->pc;                    \
  64    /* Muffle compilers */                  \
  65    cmdlen = 0;         (void)cmdlen;          \
  66    compsize = 0;       (void)compsize;        \
  67    pixelHeaderPC = 0;  (void)pixelHeaderPC
  68
  69 /*
  70 ** Variable sized command support macro.  This macro is used by calls
  71 ** that are potentially larger than __GLX_SMALL_RENDER_CMD_SIZE.
  72 ** Because of their size, they may not automatically fit in the buffer.
  73 ** If the buffer can't hold the command then it is flushed so that
  74 ** the command will fit in the next buffer.
  75 */
  76 #define __GLX_BEGIN_VARIABLE(opcode,size)       \
  77    if (pc + (size) > gc->bufEnd) {              \
  78       pc = __glXFlushRenderBuffer(gc, pc);      \
  79    }                                            \
  80    __GLX_PUT_SHORT(0,size);                     \
  81    __GLX_PUT_SHORT(2,opcode)
  82
  83 #define __GLX_BEGIN_VARIABLE_LARGE(opcode,size) \
  84    pc = __glXFlushRenderBuffer(gc, pc);         \
  85    __GLX_PUT_LONG(0,size);                      \
  86    __GLX_PUT_LONG(4,opcode)
  87
  88 #define __GLX_BEGIN_VARIABLE_WITH_PIXEL(opcode,size)  \
  89    if (pc + (size) > gc->bufEnd) {                    \
  90       pc = __glXFlushRenderBuffer(gc, pc);            \
  91    }                                                  \
  92    __GLX_PUT_SHORT(0,size);                           \
  93    __GLX_PUT_SHORT(2,opcode);                         \
  94    pc += __GLX_RENDER_HDR_SIZE;                       \
  95    pixelHeaderPC = pc;                                \
  96    pc += __GLX_PIXEL_HDR_SIZE
  97
  98 #define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL(opcode,size)  \
  99    pc = __glXFlushRenderBuffer(gc, pc);                     \
 100    __GLX_PUT_LONG(0,size);                                  \
 101    __GLX_PUT_LONG(4,opcode);                                \
 102    pc += __GLX_RENDER_LARGE_HDR_SIZE;                       \
 103    pixelHeaderPC = pc;                                      \
 104    pc += __GLX_PIXEL_HDR_SIZE
 105
 106 #define __GLX_BEGIN_VARIABLE_WITH_PIXEL_3D(opcode,size)  \
 107    if (pc + (size) > gc->bufEnd) {                       \
 108       pc = __glXFlushRenderBuffer(gc, pc);               \
 109    }                                                     \
 110    __GLX_PUT_SHORT(0,size);                              \
 111    __GLX_PUT_SHORT(2,opcode);                            \
 112    pc += __GLX_RENDER_HDR_SIZE;                          \
 113    pixelHeaderPC = pc;                                   \
 114    pc += __GLX_PIXEL_3D_HDR_SIZE
 115
 116 #define __GLX_BEGIN_VARIABLE_LARGE_WITH_PIXEL_3D(opcode,size)  \
 117    pc = __glXFlushRenderBuffer(gc, pc);                        \
 118    __GLX_PUT_LONG(0,size);                                     \
 119    __GLX_PUT_LONG(4,opcode);                                   \
 120    pc += __GLX_RENDER_LARGE_HDR_SIZE;                          \
 121    pixelHeaderPC = pc;                                         \
 122    pc += __GLX_PIXEL_3D_HDR_SIZE
 123
 124 /*
 125 ** Fixed size command support macro.  This macro is used by calls that
 126 ** are never larger than __GLX_SMALL_RENDER_CMD_SIZE.  Because they
 127 ** always fit in the buffer, and because the buffer promises to
 128 ** maintain enough room for them, we don't need to check for space
 129 ** before doing the storage work.
 130 */
 131 #define __GLX_BEGIN(opcode,size) \
 132    __GLX_PUT_SHORT(0,size);      \
 133    __GLX_PUT_SHORT(2,opcode)
 134
 135 /*
 136 ** Finish a rendering command by advancing the pc.  If the pc is now past
 137 ** the limit pointer then there is no longer room for a
 138 ** __GLX_SMALL_RENDER_CMD_SIZE sized command, which will break the
 139 ** assumptions present in the __GLX_BEGIN macro.  In this case the
 140 ** rendering buffer is flushed out into the X protocol stream (which may
 141 ** or may not do I/O).
 142 */
 143 #define __GLX_END(size)           \
 144    pc += size;                       \
 145    if (pc > gc->limit) {                  \
 146       (void) __glXFlushRenderBuffer(gc, pc);    \
 147    } else {                                     \
 148       gc->pc = pc;                              \
 149    }
 150
 151 /* Array copy macros */
 152 #define __GLX_MEM_COPY(dest,src,bytes)          \
 153    if (src && dest)                             \
 154       memcpy(dest, src, bytes)
 155
 156 /* Single item copy macros */
 157 #define __GLX_PUT_CHAR(offset,a)                \
 158    *((INT8 *) (pc + offset)) = a
 159
 160 #ifndef _CRAY
 161 #define __GLX_PUT_SHORT(offset,a)               \
 162    *((INT16 *) (pc + offset)) = a
 163
 164 #define __GLX_PUT_LONG(offset,a)                \
 165    *((INT32 *) (pc + offset)) = a
 166
 167 #define __GLX_PUT_FLOAT(offset,a)               \
 168    *((FLOAT32 *) (pc + offset)) = a
 169
 170 #else
 171 #define __GLX_PUT_SHORT(offset,a)               \
 172    { GLubyte *cp = (pc+offset);                 \
 173       int shift = (64-16) - ((int)(cp) >> (64-6));                      \
 174       *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }
 175
 176 #define __GLX_PUT_LONG(offset,a)                \
 177    { GLubyte *cp = (pc+offset);                 \
 178       int shift = (64-32) - ((int)(cp) >> (64-6));                      \
 179       *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }
 180
 181 #define __GLX_PUT_FLOAT(offset,a)               \
 182    gl_put_float((pc + offset),a)
 183
 184 #define __GLX_PUT_DOUBLE(offset,a)              \
 185    gl_put_double(pc + offset, a)
 186
 187 extern void gl_put_float( /*GLubyte *, struct cray_single */ );
 188 extern void gl_put_double( /*GLubyte *, struct cray_double */ );
 189 #endif
 190
 191 #ifndef _CRAY
 192
 193 #ifdef __GLX_ALIGN64
 194 /*
 195 ** This can certainly be done better for a particular machine
 196 ** architecture!
 197 */
 198 #define __GLX_PUT_DOUBLE(offset,a)              \
 199    __GLX_MEM_COPY(pc + offset, &a, 8)
 200 #else
 201 #define __GLX_PUT_DOUBLE(offset,a)              \
 202    *((FLOAT64 *) (pc + offset)) = a
 203 #endif
 204
 205 #endif
 206
 207 #define __GLX_PUT_CHAR_ARRAY(offset,a,alen)                 \
 208    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT8)
 209
 210 #ifndef _CRAY
 211 #define __GLX_PUT_SHORT_ARRAY(offset,a,alen)                \
 212    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT16)
 213
 214 #define __GLX_PUT_LONG_ARRAY(offset,a,alen)                 \
 215    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT32)
 216
 217 #define __GLX_PUT_FLOAT_ARRAY(offset,a,alen)                   \
 218    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT32)
 219
 220 #define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen)                  \
 221    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT64)
 222
 223 #else
 224 #define __GLX_PUT_SHORT_ARRAY(offset,a,alen)                            \
 225    gl_put_short_array((GLubyte *)(pc + offset), a, alen * __GLX_SIZE_INT16)
 226
 227 #define __GLX_PUT_LONG_ARRAY(offset,a,alen)                             \
 228    gl_put_long_array((GLubyte *)(pc + offset), (long *)a, alen * __GLX_SIZE_INT32)
 229
 230 #define __GLX_PUT_FLOAT_ARRAY(offset,a,alen)                            \
 231    gl_put_float_array((GLubyte *)(pc + offset), (float *)a, alen * __GLX_SIZE_FLOAT32)
 232
 233 #define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen)                           \
 234    gl_put_double_array((GLubyte *)(pc + offset), (double *)a, alen * __GLX_SIZE_FLOAT64)
 235
 236 extern gl_put_short_array(GLubyte *, short *, int);
 237 extern gl_put_long_array(GLubyte *, long *, int);
 238 extern gl_put_float_array(GLubyte *, float *, int);
 239 extern gl_put_double_array(GLubyte *, double *, int);
 240
 241 #endif /* _CRAY */
 242
 243 #endif /* !__GLX_packrender_h__ */