VirtualBox

source: vbox/trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_bits_globalop.h@ 69496

Last change on this file since 69496 was 69496, checked in by vboxsync, 7 years ago

*: scm --update-copyright-year
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 11.4 KB
Line 
1/* $Id: state_bits_globalop.h 69496 2017-10-28 14:55:58Z vboxsync $ */
2
3/** @file
4 * Global State bits operation
5 */
6
7/*
8 * Copyright (C) 2013-2017 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19#include <iprt/cdefs.h>
20
21#include <cr_version.h>
22
23#ifndef CRSTATE_BITS_OP
24# error "CRSTATE_BITS_OP must be defined!"
25#endif
26
27#define _CRSTATE_BITS_OP_SIZEOF(_val) CRSTATE_BITS_OP(_val, RT_SIZEOFMEMB(CRStateBits, _val))
28
29#ifndef CRSTATE_BITS_OP_VERSION
30# define CRSTATE_BITS_OP_VERSION SHCROGL_SSM_VERSION
31#endif
32
33do {
34int i;
35#ifdef _CRSTATE_BITS_OP_STENCIL_V_33
36# error "_CRSTATE_BITS_OP_STENCIL_V_33 must no be defined!"
37#endif
38#if CRSTATE_BITS_OP_VERSION < SHCROGL_SSM_VERSION_WITH_FIXED_STENCIL
39# define _CRSTATE_BITS_OP_STENCIL_V_33
40#endif
41
42#ifdef _CRSTATE_BITS_OP_STENCIL_V_33
43# ifndef CRSTATE_BITS_OP_STENCIL_OP_V_33
44# error "CRSTATE_BITS_OP_STENCIL_OP_V_33 undefined!"
45# endif
46# ifndef CRSTATE_BITS_OP_STENCIL_FUNC_V_33
47# error "CRSTATE_BITS_OP_STENCIL_FUNC_V_33 undefined!"
48# endif
49#endif
50
51_CRSTATE_BITS_OP_SIZEOF(attrib.dirty);
52
53_CRSTATE_BITS_OP_SIZEOF(buffer.dirty);
54_CRSTATE_BITS_OP_SIZEOF(buffer.enable);
55_CRSTATE_BITS_OP_SIZEOF(buffer.alphaFunc);
56_CRSTATE_BITS_OP_SIZEOF(buffer.depthFunc);
57_CRSTATE_BITS_OP_SIZEOF(buffer.blendFunc);
58_CRSTATE_BITS_OP_SIZEOF(buffer.logicOp);
59_CRSTATE_BITS_OP_SIZEOF(buffer.indexLogicOp);
60_CRSTATE_BITS_OP_SIZEOF(buffer.drawBuffer);
61_CRSTATE_BITS_OP_SIZEOF(buffer.readBuffer);
62_CRSTATE_BITS_OP_SIZEOF(buffer.indexMask);
63_CRSTATE_BITS_OP_SIZEOF(buffer.colorWriteMask);
64_CRSTATE_BITS_OP_SIZEOF(buffer.clearColor);
65_CRSTATE_BITS_OP_SIZEOF(buffer.clearIndex);
66_CRSTATE_BITS_OP_SIZEOF(buffer.clearDepth);
67_CRSTATE_BITS_OP_SIZEOF(buffer.clearAccum);
68_CRSTATE_BITS_OP_SIZEOF(buffer.depthMask);
69#ifdef CR_EXT_blend_color
70_CRSTATE_BITS_OP_SIZEOF(buffer.blendColor);
71#endif
72#if defined(CR_EXT_blend_minmax) || defined(CR_EXT_blend_subtract) || defined(CR_EXT_blend_logic_op)
73_CRSTATE_BITS_OP_SIZEOF(buffer.blendEquation);
74#endif
75#if defined(CR_EXT_blend_func_separate)
76_CRSTATE_BITS_OP_SIZEOF(buffer.blendFuncSeparate);
77#endif
78
79#ifdef CR_ARB_vertex_buffer_object
80_CRSTATE_BITS_OP_SIZEOF(bufferobject.dirty);
81_CRSTATE_BITS_OP_SIZEOF(bufferobject.arrayBinding);
82_CRSTATE_BITS_OP_SIZEOF(bufferobject.elementsBinding);
83# ifdef CR_ARB_pixel_buffer_object
84_CRSTATE_BITS_OP_SIZEOF(bufferobject.packBinding);
85_CRSTATE_BITS_OP_SIZEOF(bufferobject.unpackBinding);
86# endif
87#endif
88
89_CRSTATE_BITS_OP_SIZEOF(client.dirty);
90_CRSTATE_BITS_OP_SIZEOF(client.pack);
91_CRSTATE_BITS_OP_SIZEOF(client.unpack);
92_CRSTATE_BITS_OP_SIZEOF(client.enableClientState);
93_CRSTATE_BITS_OP_SIZEOF(client.clientPointer);
94CRSTATE_BITS_OP(client.v, GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue));
95CRSTATE_BITS_OP(client.n, GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue));
96CRSTATE_BITS_OP(client.c, GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue));
97CRSTATE_BITS_OP(client.i, GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue));
98CRSTATE_BITS_OP(client.e, GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue));
99CRSTATE_BITS_OP(client.s, GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue));
100CRSTATE_BITS_OP(client.f, GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue));
101for (i=0; i<CR_MAX_TEXTURE_UNITS; i++)
102{
103 CRSTATE_BITS_OP(client.t[i], GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue));
104}
105#ifdef CR_NV_vertex_program
106for (i=0; i<CR_MAX_VERTEX_ATTRIBS; i++)
107{
108 CRSTATE_BITS_OP(client.a[i], GLCLIENT_BIT_ALLOC*sizeof(CRbitvalue));
109}
110#endif
111
112_CRSTATE_BITS_OP_SIZEOF(current.dirty);
113for (i=0; i<CR_MAX_VERTEX_ATTRIBS; i++)
114{
115 _CRSTATE_BITS_OP_SIZEOF(current.vertexAttrib[i]);
116}
117_CRSTATE_BITS_OP_SIZEOF(current.edgeFlag);
118_CRSTATE_BITS_OP_SIZEOF(current.colorIndex);
119_CRSTATE_BITS_OP_SIZEOF(current.rasterPos);
120
121
122_CRSTATE_BITS_OP_SIZEOF(eval.dirty);
123for (i=0; i<GLEVAL_TOT; i++)
124{
125 _CRSTATE_BITS_OP_SIZEOF(eval.eval1D[i]);
126 _CRSTATE_BITS_OP_SIZEOF(eval.eval2D[i]);
127 _CRSTATE_BITS_OP_SIZEOF(eval.enable1D[i]);
128 _CRSTATE_BITS_OP_SIZEOF(eval.enable2D[i]);
129}
130_CRSTATE_BITS_OP_SIZEOF(eval.enable);
131_CRSTATE_BITS_OP_SIZEOF(eval.grid1D);
132_CRSTATE_BITS_OP_SIZEOF(eval.grid2D);
133#ifdef CR_NV_vertex_program
134 /*@todo Those seems to be unused?
135_CRSTATE_BITS_OP_SIZEOF(eval.enableAttrib1D);
136_CRSTATE_BITS_OP_SIZEOF(eval.enableAttrib2D);
137 */
138#endif
139
140_CRSTATE_BITS_OP_SIZEOF(feedback.dirty);
141_CRSTATE_BITS_OP_SIZEOF(selection.dirty);
142
143_CRSTATE_BITS_OP_SIZEOF(fog.dirty);
144_CRSTATE_BITS_OP_SIZEOF(fog.color);
145_CRSTATE_BITS_OP_SIZEOF(fog.index);
146_CRSTATE_BITS_OP_SIZEOF(fog.density);
147_CRSTATE_BITS_OP_SIZEOF(fog.start);
148_CRSTATE_BITS_OP_SIZEOF(fog.end);
149_CRSTATE_BITS_OP_SIZEOF(fog.mode);
150_CRSTATE_BITS_OP_SIZEOF(fog.enable);
151#ifdef CR_NV_fog_distance
152_CRSTATE_BITS_OP_SIZEOF(fog.fogDistanceMode);
153#endif
154#ifdef CR_EXT_fog_coord
155_CRSTATE_BITS_OP_SIZEOF(fog.fogCoordinateSource);
156#endif
157
158_CRSTATE_BITS_OP_SIZEOF(hint.dirty);
159_CRSTATE_BITS_OP_SIZEOF(hint.perspectiveCorrection);
160_CRSTATE_BITS_OP_SIZEOF(hint.pointSmooth);
161_CRSTATE_BITS_OP_SIZEOF(hint.lineSmooth);
162_CRSTATE_BITS_OP_SIZEOF(hint.polygonSmooth);
163_CRSTATE_BITS_OP_SIZEOF(hint.fog);
164#ifdef CR_EXT_clip_volume_hint
165_CRSTATE_BITS_OP_SIZEOF(hint.clipVolumeClipping);
166
167#endif
168#ifdef CR_ARB_texture_compression
169_CRSTATE_BITS_OP_SIZEOF(hint.textureCompression);
170#endif
171#ifdef CR_SGIS_generate_mipmap
172_CRSTATE_BITS_OP_SIZEOF(hint.generateMipmap);
173#endif
174
175_CRSTATE_BITS_OP_SIZEOF(lighting.dirty);
176_CRSTATE_BITS_OP_SIZEOF(lighting.shadeModel);
177_CRSTATE_BITS_OP_SIZEOF(lighting.colorMaterial);
178_CRSTATE_BITS_OP_SIZEOF(lighting.lightModel);
179_CRSTATE_BITS_OP_SIZEOF(lighting.material);
180_CRSTATE_BITS_OP_SIZEOF(lighting.enable);
181for (i=0; i<CR_MAX_LIGHTS; ++i)
182{
183 _CRSTATE_BITS_OP_SIZEOF(lighting.light[i].dirty);
184 _CRSTATE_BITS_OP_SIZEOF(lighting.light[i].enable);
185 _CRSTATE_BITS_OP_SIZEOF(lighting.light[i].ambient);
186 _CRSTATE_BITS_OP_SIZEOF(lighting.light[i].diffuse);
187 _CRSTATE_BITS_OP_SIZEOF(lighting.light[i].specular);
188 _CRSTATE_BITS_OP_SIZEOF(lighting.light[i].position);
189 _CRSTATE_BITS_OP_SIZEOF(lighting.light[i].attenuation);
190 _CRSTATE_BITS_OP_SIZEOF(lighting.light[i].spot);
191}
192
193_CRSTATE_BITS_OP_SIZEOF(line.dirty);
194_CRSTATE_BITS_OP_SIZEOF(line.enable);
195_CRSTATE_BITS_OP_SIZEOF(line.width);
196_CRSTATE_BITS_OP_SIZEOF(line.stipple);
197
198_CRSTATE_BITS_OP_SIZEOF(lists.dirty);
199_CRSTATE_BITS_OP_SIZEOF(lists.base);
200
201_CRSTATE_BITS_OP_SIZEOF(multisample.dirty);
202_CRSTATE_BITS_OP_SIZEOF(multisample.enable);
203_CRSTATE_BITS_OP_SIZEOF(multisample.sampleAlphaToCoverage);
204_CRSTATE_BITS_OP_SIZEOF(multisample.sampleAlphaToOne);
205_CRSTATE_BITS_OP_SIZEOF(multisample.sampleCoverage);
206_CRSTATE_BITS_OP_SIZEOF(multisample.sampleCoverageValue);
207
208#if CR_ARB_occlusion_query
209_CRSTATE_BITS_OP_SIZEOF(occlusion.dirty);
210#endif
211
212_CRSTATE_BITS_OP_SIZEOF(pixel.dirty);
213_CRSTATE_BITS_OP_SIZEOF(pixel.transfer);
214_CRSTATE_BITS_OP_SIZEOF(pixel.zoom);
215_CRSTATE_BITS_OP_SIZEOF(pixel.maps);
216
217_CRSTATE_BITS_OP_SIZEOF(point.dirty);
218_CRSTATE_BITS_OP_SIZEOF(point.enableSmooth);
219_CRSTATE_BITS_OP_SIZEOF(point.size);
220#ifdef CR_ARB_point_parameters
221_CRSTATE_BITS_OP_SIZEOF(point.minSize);
222_CRSTATE_BITS_OP_SIZEOF(point.maxSize);
223_CRSTATE_BITS_OP_SIZEOF(point.fadeThresholdSize);
224_CRSTATE_BITS_OP_SIZEOF(point.distanceAttenuation);
225#endif
226#ifdef CR_ARB_point_sprite
227_CRSTATE_BITS_OP_SIZEOF(point.enableSprite);
228for (i=0; i<CR_MAX_TEXTURE_UNITS; ++i)
229{
230 _CRSTATE_BITS_OP_SIZEOF(point.coordReplacement[i]);
231}
232#endif
233#if CRSTATE_BITS_OP_VERSION >= SHCROGL_SSM_VERSION_WITH_SPRITE_COORD_ORIGIN
234_CRSTATE_BITS_OP_SIZEOF(point.spriteCoordOrigin);
235#endif
236
237_CRSTATE_BITS_OP_SIZEOF(polygon.dirty);
238_CRSTATE_BITS_OP_SIZEOF(polygon.enable);
239_CRSTATE_BITS_OP_SIZEOF(polygon.offset);
240_CRSTATE_BITS_OP_SIZEOF(polygon.mode);
241_CRSTATE_BITS_OP_SIZEOF(polygon.stipple);
242
243_CRSTATE_BITS_OP_SIZEOF(program.dirty);
244_CRSTATE_BITS_OP_SIZEOF(program.vpEnable);
245_CRSTATE_BITS_OP_SIZEOF(program.fpEnable);
246_CRSTATE_BITS_OP_SIZEOF(program.vpBinding);
247_CRSTATE_BITS_OP_SIZEOF(program.fpBinding);
248for (i=0; i<CR_MAX_VERTEX_ATTRIBS; ++i)
249{
250 _CRSTATE_BITS_OP_SIZEOF(program.vertexAttribArrayEnable[i]);
251 _CRSTATE_BITS_OP_SIZEOF(program.map1AttribArrayEnable[i]);
252 _CRSTATE_BITS_OP_SIZEOF(program.map2AttribArrayEnable[i]);
253}
254for (i=0; i<CR_MAX_VERTEX_PROGRAM_ENV_PARAMS; ++i)
255{
256 _CRSTATE_BITS_OP_SIZEOF(program.vertexEnvParameter[i]);
257}
258for (i=0; i<CR_MAX_FRAGMENT_PROGRAM_ENV_PARAMS; ++i)
259{
260 _CRSTATE_BITS_OP_SIZEOF(program.fragmentEnvParameter[i]);
261}
262_CRSTATE_BITS_OP_SIZEOF(program.vertexEnvParameters);
263_CRSTATE_BITS_OP_SIZEOF(program.fragmentEnvParameters);
264for (i=0; i<CR_MAX_VERTEX_PROGRAM_ENV_PARAMS/4; ++i)
265{
266 _CRSTATE_BITS_OP_SIZEOF(program.trackMatrix[i]);
267}
268
269_CRSTATE_BITS_OP_SIZEOF(regcombiner.dirty);
270_CRSTATE_BITS_OP_SIZEOF(regcombiner.enable);
271_CRSTATE_BITS_OP_SIZEOF(regcombiner.regCombinerVars);
272_CRSTATE_BITS_OP_SIZEOF(regcombiner.regCombinerColor0);
273_CRSTATE_BITS_OP_SIZEOF(regcombiner.regCombinerColor1);
274for (i=0; i<CR_MAX_GENERAL_COMBINERS; ++i)
275{
276 _CRSTATE_BITS_OP_SIZEOF(regcombiner.regCombinerStageColor0[i]);
277 _CRSTATE_BITS_OP_SIZEOF(regcombiner.regCombinerStageColor1[i]);
278 _CRSTATE_BITS_OP_SIZEOF(regcombiner.regCombinerInput[i]);
279 _CRSTATE_BITS_OP_SIZEOF(regcombiner.regCombinerOutput[i]);
280}
281_CRSTATE_BITS_OP_SIZEOF(regcombiner.regCombinerFinalInput);
282
283_CRSTATE_BITS_OP_SIZEOF(stencil.dirty);
284_CRSTATE_BITS_OP_SIZEOF(stencil.enable);
285#ifdef _CRSTATE_BITS_OP_STENCIL_V_33
286_CRSTATE_BITS_OP_SIZEOF(stencil.bufferRefs[CRSTATE_STENCIL_BUFFER_REF_ID_FRONT_AND_BACK].func);
287_CRSTATE_BITS_OP_SIZEOF(stencil.bufferRefs[CRSTATE_STENCIL_BUFFER_REF_ID_FRONT_AND_BACK].op);
288for (i = CRSTATE_STENCIL_BUFFER_REF_ID_FRONT_AND_BACK + 1; i < CRSTATE_STENCIL_BUFFER_REF_COUNT; ++i)
289{
290 CRSTATE_BITS_OP_STENCIL_FUNC_V_33(i, stencil.bufferRefs[i].func);
291 CRSTATE_BITS_OP_STENCIL_OP_V_33(i, stencil.bufferRefs[i].op);
292}
293_CRSTATE_BITS_OP_SIZEOF(stencil.clearValue);
294_CRSTATE_BITS_OP_SIZEOF(stencil.writeMask);
295#else
296_CRSTATE_BITS_OP_SIZEOF(stencil.enableTwoSideEXT);
297_CRSTATE_BITS_OP_SIZEOF(stencil.activeStencilFace);
298_CRSTATE_BITS_OP_SIZEOF(stencil.clearValue);
299_CRSTATE_BITS_OP_SIZEOF(stencil.writeMask);
300for (i = 0; i < CRSTATE_STENCIL_BUFFER_REF_COUNT; ++i)
301{
302 _CRSTATE_BITS_OP_SIZEOF(stencil.bufferRefs[i].func);
303 _CRSTATE_BITS_OP_SIZEOF(stencil.bufferRefs[i].op);
304}
305#endif
306
307_CRSTATE_BITS_OP_SIZEOF(texture.dirty);
308for (i=0; i<CR_MAX_TEXTURE_UNITS; ++i)
309{
310 _CRSTATE_BITS_OP_SIZEOF(texture.enable[i]);
311 _CRSTATE_BITS_OP_SIZEOF(texture.current[i]);
312 _CRSTATE_BITS_OP_SIZEOF(texture.objGen[i]);
313 _CRSTATE_BITS_OP_SIZEOF(texture.eyeGen[i]);
314 _CRSTATE_BITS_OP_SIZEOF(texture.genMode[i]);
315 _CRSTATE_BITS_OP_SIZEOF(texture.envBit[i]);
316}
317
318_CRSTATE_BITS_OP_SIZEOF(transform.dirty);
319_CRSTATE_BITS_OP_SIZEOF(transform.matrixMode);
320_CRSTATE_BITS_OP_SIZEOF(transform.modelviewMatrix);
321_CRSTATE_BITS_OP_SIZEOF(transform.projectionMatrix);
322_CRSTATE_BITS_OP_SIZEOF(transform.colorMatrix);
323_CRSTATE_BITS_OP_SIZEOF(transform.textureMatrix);
324_CRSTATE_BITS_OP_SIZEOF(transform.programMatrix);
325_CRSTATE_BITS_OP_SIZEOF(transform.clipPlane);
326_CRSTATE_BITS_OP_SIZEOF(transform.enable);
327_CRSTATE_BITS_OP_SIZEOF(transform.base);
328
329_CRSTATE_BITS_OP_SIZEOF(viewport.dirty);
330_CRSTATE_BITS_OP_SIZEOF(viewport.v_dims);
331_CRSTATE_BITS_OP_SIZEOF(viewport.s_dims);
332_CRSTATE_BITS_OP_SIZEOF(viewport.enable);
333_CRSTATE_BITS_OP_SIZEOF(viewport.depth);
334
335} while (0);
336
337#undef CRSTATE_BITS_OP_VERSION
338#undef _CRSTATE_BITS_OP_STENCIL_V_33
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette