VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_lists.c@ 51442

Last change on this file since 51442 was 50829, checked in by vboxsync, 11 years ago

crOpenGL: remove debug assertion
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 12.0 KB
Line 
1/* Copyright (c) 2001-2003, Stanford University
2 All rights reserved.
3
4 See the file LICENSE.txt for information on redistributing this software. */
5
6#include "server_dispatch.h"
7#include "server.h"
8#include "cr_mem.h"
9
10
11/*
12 * Notes on ID translation:
13 *
14 * If a server has multiple clients (in the case of parallel applications)
15 * and N of the clients all create a display list with ID K, does K name
16 * one display list or N different display lists?
17 *
18 * By default, there is one display list named K. If the clients put
19 * identical commands into list K, then this is fine. But if the clients
20 * each put something different into list K when they created it, then this
21 * is a serious problem.
22 *
23 * By zeroing the 'shared_display_lists' configuration option, we can tell
24 * the server to make list K be unique for all N clients. We do this by
25 * translating K into a new, unique ID dependent on which client we're
26 * talking to (curClient->number).
27 *
28 * Same story for texture objects, vertex programs, etc.
29 *
30 * The application can also dynamically switch between shared and private
31 * display lists with:
32 * glChromiumParameteri(GL_SHARED_DISPLAY_LISTS_CR, GL_TRUE)
33 * and
34 * glChromiumParameteri(GL_SHARED_DISPLAY_LISTS_CR, GL_FALSE)
35 *
36 */
37
38
39
40static GLuint TranslateListID( GLuint id )
41{
42 if (!cr_server.sharedDisplayLists) {
43 int client = cr_server.curClient->number;
44 return id + client * 100000;
45 }
46 return id;
47}
48
49/* XXXX Note: shared/separate Program ID numbers aren't totally implemented! */
50GLuint crServerTranslateProgramID( GLuint id )
51{
52 if (!cr_server.sharedPrograms && id) {
53 int client = cr_server.curClient->number;
54 return id + client * 100000;
55 }
56 return id;
57}
58
59
60void SERVER_DISPATCH_APIENTRY
61crServerDispatchNewList( GLuint list, GLenum mode )
62{
63 if (mode == GL_COMPILE_AND_EXECUTE)
64 crWarning("using glNewList(GL_COMPILE_AND_EXECUTE) can confuse the crserver");
65
66 list = TranslateListID( list );
67 crStateNewList( list, mode );
68 cr_server.head_spu->dispatch_table.NewList( list, mode );
69}
70
71static void crServerQueryHWState()
72{
73 GLuint fbFbo, bbFbo;
74 CRClient *client = cr_server.curClient;
75 CRMuralInfo *mural = client ? client->currentMural : NULL;
76 if (mural && mural->fRedirected)
77 {
78 fbFbo = mural->aidFBOs[CR_SERVER_FBO_FB_IDX(mural)];
79 bbFbo = mural->aidFBOs[CR_SERVER_FBO_BB_IDX(mural)];
80 }
81 else
82 {
83 fbFbo = bbFbo = 0;
84 }
85 crStateQueryHWState(fbFbo, bbFbo);
86}
87
88void SERVER_DISPATCH_APIENTRY crServerDispatchEndList(void)
89{
90 CRContext *g = crStateGetCurrent();
91 CRListsState *l = &(g->lists);
92
93 cr_server.head_spu->dispatch_table.EndList();
94 crStateEndList();
95
96#ifndef IN_GUEST
97 if (l->mode==GL_COMPILE)
98 {
99 crServerQueryHWState();
100 }
101#endif
102}
103
104void SERVER_DISPATCH_APIENTRY
105crServerDispatchCallList( GLuint list )
106{
107 list = TranslateListID( list );
108
109 if (cr_server.curClient->currentCtxInfo->pContext->lists.mode == 0) {
110 /* we're not compiling, so execute the list now */
111 /* Issue the list as-is */
112 cr_server.head_spu->dispatch_table.CallList( list );
113 crServerQueryHWState();
114 }
115 else {
116 /* we're compiling glCallList into another list - just pass it through */
117 cr_server.head_spu->dispatch_table.CallList( list );
118 }
119}
120
121
122/**
123 * Translate an array of display list IDs from various datatypes to GLuint
124 * IDs while adding the per-client offset.
125 */
126static void
127TranslateListIDs(GLsizei n, GLenum type, const GLvoid *lists, GLuint *newLists)
128{
129 int offset = cr_server.curClient->number * 100000;
130 GLsizei i;
131 switch (type) {
132 case GL_UNSIGNED_BYTE:
133 {
134 const GLubyte *src = (const GLubyte *) lists;
135 for (i = 0; i < n; i++) {
136 newLists[i] = src[i] + offset;
137 }
138 }
139 break;
140 case GL_BYTE:
141 {
142 const GLbyte *src = (const GLbyte *) lists;
143 for (i = 0; i < n; i++) {
144 newLists[i] = src[i] + offset;
145 }
146 }
147 break;
148 case GL_UNSIGNED_SHORT:
149 {
150 const GLushort *src = (const GLushort *) lists;
151 for (i = 0; i < n; i++) {
152 newLists[i] = src[i] + offset;
153 }
154 }
155 break;
156 case GL_SHORT:
157 {
158 const GLshort *src = (const GLshort *) lists;
159 for (i = 0; i < n; i++) {
160 newLists[i] = src[i] + offset;
161 }
162 }
163 break;
164 case GL_UNSIGNED_INT:
165 {
166 const GLuint *src = (const GLuint *) lists;
167 for (i = 0; i < n; i++) {
168 newLists[i] = src[i] + offset;
169 }
170 }
171 break;
172 case GL_INT:
173 {
174 const GLint *src = (const GLint *) lists;
175 for (i = 0; i < n; i++) {
176 newLists[i] = src[i] + offset;
177 }
178 }
179 break;
180 case GL_FLOAT:
181 {
182 const GLfloat *src = (const GLfloat *) lists;
183 for (i = 0; i < n; i++) {
184 newLists[i] = (GLuint) src[i] + offset;
185 }
186 }
187 break;
188 case GL_2_BYTES:
189 {
190 const GLubyte *src = (const GLubyte *) lists;
191 for (i = 0; i < n; i++) {
192 newLists[i] = (src[i*2+0] * 256 +
193 src[i*2+1]) + offset;
194 }
195 }
196 break;
197 case GL_3_BYTES:
198 {
199 const GLubyte *src = (const GLubyte *) lists;
200 for (i = 0; i < n; i++) {
201 newLists[i] = (src[i*3+0] * 256 * 256 +
202 src[i*3+1] * 256 +
203 src[i*3+2]) + offset;
204 }
205 }
206 break;
207 case GL_4_BYTES:
208 {
209 const GLubyte *src = (const GLubyte *) lists;
210 for (i = 0; i < n; i++) {
211 newLists[i] = (src[i*4+0] * 256 * 256 * 256 +
212 src[i*4+1] * 256 * 256 +
213 src[i*4+2] * 256 +
214 src[i*4+3]) + offset;
215 }
216 }
217 break;
218 default:
219 crWarning("CRServer: invalid display list datatype 0x%x", type);
220 }
221}
222
223
224void SERVER_DISPATCH_APIENTRY
225crServerDispatchCallLists( GLsizei n, GLenum type, const GLvoid *lists )
226{
227 if (!cr_server.sharedDisplayLists) {
228 /* need to translate IDs */
229 GLuint *newLists = (GLuint *) crAlloc(n * sizeof(GLuint));
230 if (newLists) {
231 TranslateListIDs(n, type, lists, newLists);
232 }
233 lists = newLists;
234 type = GL_UNSIGNED_INT;
235 }
236
237 if (cr_server.curClient->currentCtxInfo->pContext->lists.mode == 0) {
238 /* we're not compiling, so execute the list now */
239 /* Issue the list as-is */
240 cr_server.head_spu->dispatch_table.CallLists( n, type, lists );
241 crServerQueryHWState();
242 }
243 else {
244 /* we're compiling glCallList into another list - just pass it through */
245 cr_server.head_spu->dispatch_table.CallLists( n, type, lists );
246 }
247
248 if (!cr_server.sharedDisplayLists) {
249 crFree((void *) lists); /* malloc'd above */
250 }
251}
252
253
254GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsList( GLuint list )
255{
256 GLboolean retval;
257 list = TranslateListID( list );
258 retval = cr_server.head_spu->dispatch_table.IsList( list );
259 crServerReturnValue( &retval, sizeof(retval) );
260 return retval;
261}
262
263
264void SERVER_DISPATCH_APIENTRY crServerDispatchDeleteLists( GLuint list, GLsizei range )
265{
266 list = TranslateListID( list );
267 crStateDeleteLists( list, range );
268 cr_server.head_spu->dispatch_table.DeleteLists( list, range );
269}
270
271
272void SERVER_DISPATCH_APIENTRY crServerDispatchBindTexture( GLenum target, GLuint texture )
273{
274 crStateBindTexture( target, texture );
275 cr_server.head_spu->dispatch_table.BindTexture(target, crStateGetTextureHWID(texture));
276}
277
278void SERVER_DISPATCH_APIENTRY crServerDispatchDeleteTextures( GLsizei n, const GLuint *textures)
279{
280 GLuint *newTextures = (GLuint *) crAlloc(n * sizeof(GLuint));
281 GLint i;
282
283 if (!newTextures)
284 {
285 crError("crServerDispatchDeleteTextures: out of memory");
286 return;
287 }
288
289 for (i = 0; i < n; i++)
290 {
291 newTextures[i] = crStateGetTextureHWID(textures[i]);
292 }
293
294 for (i = 0; i < n; ++i)
295 {
296 crDebug("DeleteTexture: %d, pid %d, ctx %d", textures[i], (uint32_t)cr_server.curClient->pid, cr_server.currentCtxInfo->pContext->id);
297 }
298
299
300 crStateDeleteTextures(n, textures);
301 cr_server.head_spu->dispatch_table.DeleteTextures(n, newTextures);
302 crFree(newTextures);
303}
304
305void SERVER_DISPATCH_APIENTRY crServerDispatchPrioritizeTextures( GLsizei n, const GLuint * textures, const GLclampf * priorities )
306{
307 GLuint *newTextures = (GLuint *) crAlloc(n * sizeof(GLuint));
308 GLint i;
309
310 if (!newTextures)
311 {
312 crError("crServerDispatchDeleteTextures: out of memory");
313 return;
314 }
315
316 crStatePrioritizeTextures(n, textures, priorities);
317
318 for (i = 0; i < n; i++)
319 {
320 newTextures[i] = crStateGetTextureHWID(textures[i]);
321 }
322
323 cr_server.head_spu->dispatch_table.PrioritizeTextures(n, newTextures, priorities);
324 crFree(newTextures);
325}
326
327void SERVER_DISPATCH_APIENTRY crServerDispatchDeleteProgramsARB(GLsizei n, const GLuint * programs)
328{
329 GLuint *pLocalProgs = (GLuint *) crAlloc(n * sizeof(GLuint));
330 GLint i;
331 if (!pLocalProgs) {
332 crError("crServerDispatchDeleteProgramsARB: out of memory");
333 return;
334 }
335 for (i = 0; i < n; i++) {
336 pLocalProgs[i] = crServerTranslateProgramID(programs[i]);
337 }
338 crStateDeleteProgramsARB(n, pLocalProgs);
339 cr_server.head_spu->dispatch_table.DeleteProgramsARB(n, pLocalProgs);
340 crFree(pLocalProgs);
341}
342
343/*@todo will fail for textures loaded from snapshot */
344GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsTexture( GLuint texture )
345{
346 GLboolean retval;
347 retval = cr_server.head_spu->dispatch_table.IsTexture(crStateGetTextureHWID(texture));
348 crServerReturnValue( &retval, sizeof(retval) );
349 return retval; /* WILL PROBABLY BE IGNORED */
350}
351
352/*@todo will fail for progs loaded from snapshot */
353GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsProgramARB( GLuint program )
354{
355 GLboolean retval;
356 program = crServerTranslateProgramID(program);
357 retval = cr_server.head_spu->dispatch_table.IsProgramARB( program );
358 crServerReturnValue( &retval, sizeof(retval) );
359 return retval; /* WILL PROBABLY BE IGNORED */
360}
361
362GLboolean SERVER_DISPATCH_APIENTRY
363crServerDispatchAreTexturesResident(GLsizei n, const GLuint *textures,
364 GLboolean *residences)
365{
366 GLboolean retval;
367 GLsizei i;
368 GLboolean *res = (GLboolean *) crAlloc(n * sizeof(GLboolean));
369 GLuint *textures2 = (GLuint *) crAlloc(n * sizeof(GLuint));
370
371 (void) residences;
372
373 for (i = 0; i < n; i++)
374 {
375 textures2[i] = crStateGetTextureHWID(textures[i]);
376 }
377 retval = cr_server.head_spu->dispatch_table.AreTexturesResident(n, textures2, res);
378
379 crFree(textures2);
380
381 crServerReturnValue(res, n * sizeof(GLboolean));
382
383 crFree(res);
384
385 return retval; /* WILL PROBABLY BE IGNORED */
386}
387
388
389GLboolean SERVER_DISPATCH_APIENTRY
390crServerDispatchAreProgramsResidentNV(GLsizei n, const GLuint *programs,
391 GLboolean *residences)
392{
393 GLboolean retval;
394 GLboolean *res = (GLboolean *) crAlloc(n * sizeof(GLboolean));
395 GLsizei i;
396
397 (void) residences;
398
399 if (!cr_server.sharedTextureObjects) {
400 GLuint *programs2 = (GLuint *) crAlloc(n * sizeof(GLuint));
401 for (i = 0; i < n; i++)
402 programs2[i] = crServerTranslateProgramID(programs[i]);
403 retval = cr_server.head_spu->dispatch_table.AreProgramsResidentNV(n, programs2, res);
404 crFree(programs2);
405 }
406 else {
407 retval = cr_server.head_spu->dispatch_table.AreProgramsResidentNV(n, programs, res);
408 }
409
410 crServerReturnValue(res, n * sizeof(GLboolean));
411 crFree(res);
412
413 return retval; /* WILL PROBABLY BE IGNORED */
414}
Note: See TracBrowser for help on using the repository browser.

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