Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. #ifndef __GLX_packsingle_h__
  2. #define __GLX_packsingle_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 "packrender.h"
  35.  
  36. /*
  37. ** The macros in this header convert wire protocol data types to the client
  38. ** machine's native data types.  The header is part of the porting layer of
  39. ** the client library, and it is intended that hardware vendors will rewrite
  40. ** this header to suit their own machines.
  41. */
  42.  
  43. /*
  44. ** Dummy define to make the GetReqExtra macro happy.  The value is not
  45. ** used, but instead the code in __GLX_SINGLE_BEGIN issues its own store
  46. ** to req->reqType with the proper code (our extension code).
  47. */
  48. #define X_GLXSingle 0
  49.  
  50. /* Declare common variables used during a single command */
  51. #define __GLX_SINGLE_DECLARE_VARIABLES()         \
  52.    struct glx_context *gc = __glXGetCurrentContext();  \
  53.    GLubyte *pc, *pixelHeaderPC;                  \
  54.    GLuint compsize, cmdlen;                      \
  55.    Display *dpy = gc->currentDpy;                \
  56.    xGLXSingleReq *req
  57.  
  58. #define __GLX_SINGLE_LOAD_VARIABLES()           \
  59.    pc = gc->pc;                                 \
  60.    /* Muffle compilers */                       \
  61.    pixelHeaderPC = 0;  (void)pixelHeaderPC;     \
  62.    compsize = 0;       (void)compsize;          \
  63.    cmdlen = 0;         (void)cmdlen
  64.  
  65. /* Start a single command */
  66. #define __GLX_SINGLE_BEGIN(opcode,bytes)        \
  67.    if (dpy) {                                   \
  68.    (void) __glXFlushRenderBuffer(gc, pc);       \
  69.    LockDisplay(dpy);                            \
  70.    GetReqExtra(GLXSingle,bytes,req);            \
  71.    req->reqType = gc->majorOpcode;              \
  72.    req->glxCode = opcode;                       \
  73.    req->contextTag = gc->currentContextTag;     \
  74.    pc = ((GLubyte *)(req) + sz_xGLXSingleReq)
  75.  
  76. /* End a single command */
  77. #define __GLX_SINGLE_END()       \
  78.    UnlockDisplay(dpy);           \
  79.    SyncHandle();                 \
  80.    }
  81.  
  82. /* Store data to sending for a single command */
  83. #define __GLX_SINGLE_PUT_CHAR(offset,a)         \
  84.    *((INT8 *) (pc + offset)) = a
  85.  
  86. #ifndef CRAY
  87. #define __GLX_SINGLE_PUT_SHORT(offset,a)        \
  88.    *((INT16 *) (pc + offset)) = a
  89.  
  90. #define __GLX_SINGLE_PUT_LONG(offset,a)         \
  91.    *((INT32 *) (pc + offset)) = a
  92.  
  93. #define __GLX_SINGLE_PUT_FLOAT(offset,a)        \
  94.    *((FLOAT32 *) (pc + offset)) = a
  95.  
  96. #else
  97. #define __GLX_SINGLE_PUT_SHORT(offset,a)        \
  98.    { GLubyte *cp = (pc+offset);                    \
  99.       int shift = (64-16) - ((int)(cp) >> (64-6));                      \
  100.       *(int *)cp = (*(int *)cp & ~(0xffff << shift)) | ((a & 0xffff) << shift); }
  101.  
  102. #define __GLX_SINGLE_PUT_LONG(offset,a)         \
  103.    { GLubyte *cp = (pc+offset);                    \
  104.       int shift = (64-32) - ((int)(cp) >> (64-6));                      \
  105.       *(int *)cp = (*(int *)cp & ~(0xffffffff << shift)) | ((a & 0xffffffff) << shift); }
  106.  
  107. #define __GLX_SINGLE_PUT_FLOAT(offset,a)        \
  108.    gl_put_float(pc + offset, a)
  109. #endif
  110.  
  111. /* Read support macros */
  112. #define __GLX_SINGLE_READ_XREPLY()                    \
  113.    (void) _XReply(dpy, (xReply*) &reply, 0, False)
  114.  
  115. #define __GLX_SINGLE_GET_RETVAL(a,cast)         \
  116.    a = (cast) reply.retval
  117.  
  118. #define __GLX_SINGLE_GET_SIZE(a)                \
  119.    a = (GLint) reply.size
  120.  
  121. #ifndef _CRAY
  122. #define __GLX_SINGLE_GET_CHAR(p)                \
  123.    *p = *(GLbyte *)&reply.pad3;
  124.  
  125. #define __GLX_SINGLE_GET_SHORT(p)               \
  126.    *p = *(GLshort *)&reply.pad3;
  127.  
  128. #define __GLX_SINGLE_GET_LONG(p)                \
  129.    *p = *(GLint *)&reply.pad3;
  130.  
  131. #define __GLX_SINGLE_GET_FLOAT(p)               \
  132.    *p = *(GLfloat *)&reply.pad3;
  133.  
  134. #else
  135. #define __GLX_SINGLE_GET_CHAR(p)                \
  136.    *p = reply.pad3 >> 24;
  137.  
  138. #define __GLX_SINGLE_GET_SHORT(p)               \
  139.    {int t = reply.pad3 >> 16;                            \
  140.       *p = (t & 0x8000) ? (t | ~0xffff) : (t & 0xffff);}
  141.  
  142. #define __GLX_SINGLE_GET_LONG(p)                \
  143.    {int t = reply.pad3;                                              \
  144.       *p = (t & 0x80000000) ? (t | ~0xffffffff) : (t & 0xffffffff);}
  145.  
  146. #define PAD3OFFSET 16
  147. #define __GLX_SINGLE_GET_FLOAT(p)                        \
  148.    *p = gl_ntoh_float((GLubyte *)&reply + PAD3OFFSET);
  149.  
  150. #define __GLX_SINGLE_GET_DOUBLE(p)                       \
  151.    *p = gl_ntoh_double((GLubyte *)&reply + PAD3OFFSET);
  152.  
  153. extern float gl_ntoh_float(GLubyte *);
  154. extern float gl_ntoh_double(GLubyte *);
  155. #endif
  156.  
  157. #ifndef _CRAY
  158.  
  159. #ifdef __GLX_ALIGN64
  160. #define __GLX_SINGLE_GET_DOUBLE(p)              \
  161.    __GLX_MEM_COPY(p, &reply.pad3, 8)
  162. #else
  163. #define __GLX_SINGLE_GET_DOUBLE(p)              \
  164.    *p = *(GLdouble *)&reply.pad3
  165. #endif
  166.  
  167. #endif
  168.  
  169. /* Get an array of typed data */
  170. #define __GLX_SINGLE_GET_VOID_ARRAY(a,alen)     \
  171.    {                                            \
  172.       GLint slop = alen*__GLX_SIZE_INT8 & 3;    \
  173.       _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT8);  \
  174.       if (slop) _XEatData(dpy,4-slop);             \
  175.    }
  176.  
  177. #define __GLX_SINGLE_GET_CHAR_ARRAY(a,alen)     \
  178.    {                                            \
  179.       GLint slop = alen*__GLX_SIZE_INT8 & 3;    \
  180.       _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT8);  \
  181.       if (slop) _XEatData(dpy,4-slop);             \
  182.    }
  183.  
  184.  
  185. #define __GLX_SINGLE_GET_SHORT_ARRAY(a,alen)    \
  186.    {                                            \
  187.       GLint slop = (alen*__GLX_SIZE_INT16) & 3;    \
  188.       _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT16); \
  189.       if (slop) _XEatData(dpy,4-slop);             \
  190.    }
  191.  
  192. #define __GLX_SINGLE_GET_LONG_ARRAY(a,alen)        \
  193.    _XRead(dpy,(char *)a,alen*__GLX_SIZE_INT32);
  194.  
  195. #ifndef _CRAY
  196. #define __GLX_SINGLE_GET_FLOAT_ARRAY(a,alen)       \
  197.    _XRead(dpy,(char *)a,alen*__GLX_SIZE_FLOAT32);
  198.  
  199. #define __GLX_SINGLE_GET_DOUBLE_ARRAY(a,alen)      \
  200.    _XRead(dpy,(char *)a,alen*__GLX_SIZE_FLOAT64);
  201.  
  202. #else
  203. #define __GLX_SINGLE_GET_FLOAT_ARRAY(a,alen)    \
  204.    gl_get_float_array(dpy,a,alen);
  205.  
  206. #define __GLX_SINGLE_GET_DOUBLE_ARRAY(a,alen)   \
  207.    gl_get_double_array(dpy, a, alen);
  208.  
  209. extern void gl_get_float_array(Display * dpy, float *a, int alen);
  210. extern void gl_get_double_array(Display * dpy, double *a, int alen);
  211. #endif
  212.  
  213. #endif /* !__GLX_packsingle_h__ */
  214.