• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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    struct glx_context *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    do {                                         \
159       int8_t __tmp = (a);                       \
160       memcpy((pc + (offset)), &__tmp, 1);       \
161    } while (0)
162 
163 #define __GLX_PUT_SHORT(offset,a)               \
164    do {                                         \
165       int16_t __tmp = (a);                      \
166       memcpy((pc + (offset)), &__tmp, 2);       \
167    } while (0)
168 
169 #define __GLX_PUT_LONG(offset,a)                \
170    do {                                         \
171       int32_t __tmp = (a);                      \
172       memcpy((pc + (offset)), &__tmp, 4);       \
173    } while (0)
174 
175 #define __GLX_PUT_FLOAT(offset,a)               \
176    do {                                         \
177       float __tmp = (a);                        \
178       memcpy((pc + (offset)), &__tmp, 4);       \
179    } while (0)
180 
181 #define __GLX_PUT_DOUBLE(offset,a)              \
182    do {                                         \
183       double __tmp = (a);                       \
184       memcpy((pc + (offset)), &__tmp, 8);       \
185    } while (0)
186 
187 #define __GLX_PUT_CHAR_ARRAY(offset,a,alen)                 \
188    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT8)
189 
190 #define __GLX_PUT_SHORT_ARRAY(offset,a,alen)                \
191    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT16)
192 
193 #define __GLX_PUT_LONG_ARRAY(offset,a,alen)                 \
194    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_INT32)
195 
196 #define __GLX_PUT_FLOAT_ARRAY(offset,a,alen)                   \
197    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT32)
198 
199 #define __GLX_PUT_DOUBLE_ARRAY(offset,a,alen)                  \
200    __GLX_MEM_COPY(pc + offset, a, alen * __GLX_SIZE_FLOAT64)
201 
202 
203 #endif /* !__GLX_packrender_h__ */
204