VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_init.c@ 18721

Last change on this file since 18721 was 18721, checked in by vboxsync, 16 years ago

crOpenGL-OSX: more clipping updates

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 13.6 KB
Line 
1/* Copyright (c) 2001, Stanford University
2 * All rights reserved
3 *
4 * See the file LICENSE.txt for information on redistributing this software.
5 */
6
7#include "cr_mem.h"
8#include "cr_spu.h"
9#include "cr_error.h"
10#include "cr_string.h"
11#include "cr_url.h"
12#include "renderspu.h"
13#include <stdio.h>
14
15#ifdef RT_OS_DARWIN
16# include <iprt/semaphore.h>
17#endif /* RT_OS_DARWIN */
18
19static SPUNamedFunctionTable _cr_render_table[1000];
20
21SPUFunctions render_functions = {
22 NULL, /* CHILD COPY */
23 NULL, /* DATA */
24 _cr_render_table /* THE ACTUAL FUNCTIONS */
25};
26
27RenderSPU render_spu;
28unsigned int render_spu_parent_window_id;
29
30#ifdef CHROMIUM_THREADSAFE
31CRtsd _RenderTSD;
32#endif
33
34static void swapsyncConnect(void)
35{
36 char hostname[4096], protocol[4096];
37 unsigned short port;
38
39 crNetInit(NULL, NULL);
40
41 if (!crParseURL( render_spu.swap_master_url, protocol, hostname,
42 &port, 9876))
43 crError( "Bad URL: %s", render_spu.swap_master_url );
44
45 if (render_spu.is_swap_master)
46 {
47 int a;
48
49 render_spu.swap_conns = (CRConnection **)crAlloc(
50 render_spu.num_swap_clients*sizeof(CRConnection *));
51 for (a=0; a<render_spu.num_swap_clients; a++)
52 {
53 render_spu.swap_conns[a] = crNetAcceptClient( protocol, hostname, port,
54 render_spu.swap_mtu, 1);
55 }
56 }
57 else
58 {
59 render_spu.swap_conns = (CRConnection **)crAlloc(sizeof(CRConnection *));
60
61 render_spu.swap_conns[0] = crNetConnectToServer(render_spu.swap_master_url,
62 port, render_spu.swap_mtu, 1);
63 if (!render_spu.swap_conns[0])
64 crError("Failed connection");
65 }
66}
67
68#ifdef RT_OS_WINDOWS
69static DWORD WINAPI renderSPUWindowThreadProc(void* unused)
70{
71 MSG msg;
72 bool bRet;
73
74 (void) unused;
75
76 /* Force system to create the message queue.
77 * Else, there's a chance that render spu will issue PostThreadMessage
78 * before this thread calls GetMessage for first time.
79 */
80 PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
81
82 crDebug("RenderSPU: Window thread started (%x)", crThreadID());
83 SetEvent(render_spu.hWinThreadReadyEvent);
84
85 while( (bRet = GetMessage( &msg, 0, 0, 0 )) != 0)
86 {
87 if (bRet == -1)
88 {
89 crError("RenderSPU: Window thread GetMessage failed (%x)", GetLastError());
90 break;
91 }
92 else
93 {
94 if (msg.message == WM_VBOX_RENDERSPU_CREATE_WINDOW)
95 {
96 LPCREATESTRUCT pCS = (LPCREATESTRUCT) msg.lParam;
97 HWND *phWnd;
98
99 CRASSERT(msg.lParam && !msg.wParam && pCS->lpCreateParams);
100
101 phWnd = pCS->lpCreateParams;
102
103 *phWnd = CreateWindowEx(pCS->dwExStyle, pCS->lpszName, pCS->lpszClass, pCS->style,
104 pCS->x, pCS->y, pCS->cx, pCS->cy,
105 pCS->hwndParent, pCS->hMenu, pCS->hInstance, &render_spu);
106
107 SetEvent(render_spu.hWinThreadReadyEvent);
108 }
109 else if (msg.message == WM_VBOX_RENDERSPU_DESTROY_WINDOW)
110 {
111 CRASSERT(msg.lParam && !msg.wParam);
112
113 DestroyWindow(((VBOX_RENDERSPU_DESTROY_WINDOW*) msg.lParam)->hWnd);
114
115 SetEvent(render_spu.hWinThreadReadyEvent);
116 }
117 else
118 {
119 TranslateMessage(&msg);
120 DispatchMessage(&msg);
121 }
122 }
123 }
124
125 render_spu.dwWinThreadId = 0;
126
127 crDebug("RenderSPU: Window thread stopped (%x)", crThreadID());
128 SetEvent(render_spu.hWinThreadReadyEvent);
129
130 return 0;
131}
132#endif
133
134static SPUFunctions *
135renderSPUInit( int id, SPU *child, SPU *self,
136 unsigned int context_id, unsigned int num_contexts )
137{
138 int numFuncs, numSpecial;
139 GLint defaultWin, defaultCtx;
140 WindowInfo *windowInfo;
141
142 (void) child;
143 (void) context_id;
144 (void) num_contexts;
145
146 self->privatePtr = (void *) &render_spu;
147
148#ifdef CHROMIUM_THREADSAFE
149 crDebug("Render SPU: thread-safe");
150#endif
151
152 crMemZero(&render_spu, sizeof(render_spu));
153
154 render_spu.id = id;
155 renderspuSetVBoxConfiguration(&render_spu);
156
157 if (render_spu.swap_master_url)
158 swapsyncConnect();
159
160
161 /* Get our special functions. */
162 numSpecial = renderspuCreateFunctions( _cr_render_table );
163
164#ifdef RT_OS_WINDOWS
165 /* Start thread to create windows and process window messages */
166 crDebug("RenderSPU: Starting windows serving thread");
167 render_spu.hWinThreadReadyEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
168 if (!render_spu.hWinThreadReadyEvent)
169 {
170 crError("RenderSPU: Failed to create WinThreadReadyEvent! (%x)", GetLastError());
171 return NULL;
172 }
173
174 if (!CreateThread(NULL, 0, renderSPUWindowThreadProc, 0, 0, &render_spu.dwWinThreadId))
175 {
176 crError("RenderSPU: Failed to start windows thread! (%x)", GetLastError());
177 return NULL;
178 }
179 WaitForSingleObject(render_spu.hWinThreadReadyEvent, INFINITE);
180#endif
181
182 /* Get the OpenGL functions. */
183 numFuncs = crLoadOpenGL( &render_spu.ws, _cr_render_table + numSpecial );
184 if (numFuncs == 0) {
185 crError("The render SPU was unable to load the native OpenGL library");
186 return NULL;
187 }
188
189 numFuncs += numSpecial;
190
191#ifdef GLX
192 if (!render_spu.use_glxchoosevisual) {
193 /* sometimes want to set this option with ATI drivers */
194 render_spu.ws.glXChooseVisual = NULL;
195 }
196#endif
197
198 render_spu.window_id = 0;
199 render_spu.context_id = 0;
200 render_spu.contextTable = crAllocHashtable();
201 render_spu.windowTable = crAllocHashtable();
202
203 CRASSERT(render_spu.default_visual & CR_RGB_BIT);
204
205#ifdef USE_OSMESA
206 if (render_spu.use_osmesa) {
207 if (!crLoadOSMesa(&render_spu.OSMesaCreateContext,
208 &render_spu.OSMesaMakeCurrent,
209 &render_spu.OSMesaDestroyContext)) {
210 crError("Unable to load OSMesa library");
211 }
212 }
213#endif
214
215#ifdef DARWIN
216# ifndef __LP64__ /** @todo port to 64-bit darwin. */
217 render_spu.hRootVisibleRegion = 0;
218 render_spu.currentBufferName = 1;
219 render_spu.uiDockUpdateTS = 0;
220 /* Create a mutex for syncronizing events from the main Qt thread & this
221 thread */
222 RTSemFastMutexCreate(&render_spu.syncMutex);
223 /* Create our window groups */
224 CreateWindowGroup(kWindowGroupAttrMoveTogether | kWindowGroupAttrLayerTogether | kWindowGroupAttrSharedActivation | kWindowGroupAttrHideOnCollapse | kWindowGroupAttrFixedLevel, &render_spu.pMasterGroup);
225 CreateWindowGroup(kWindowGroupAttrMoveTogether | kWindowGroupAttrLayerTogether | kWindowGroupAttrSharedActivation | kWindowGroupAttrHideOnCollapse | kWindowGroupAttrFixedLevel, &render_spu.pParentGroup);
226 /* Make the correct z-layering */
227 SendWindowGroupBehind (render_spu.pParentGroup, render_spu.pMasterGroup);
228 /* and set the gParentGroup as parent for gMasterGroup. */
229 SetWindowGroupParent (render_spu.pMasterGroup, render_spu.pParentGroup);
230 /* Install the event handlers */
231 EventTypeSpec eventList[] =
232 {
233 {kEventClassVBox, kEventVBoxUpdateContext}, /* Update the context after show/size/move events */
234 {kEventClassVBox, kEventVBoxBoundsChanged} /* Clip/Pos the OpenGL windows when the main window is changed in pos/size */
235 };
236 /* We need to process events from our main window */
237 render_spu.hParentEventHandler = NewEventHandlerUPP(windowEvtHndlr);
238 InstallApplicationEventHandler (render_spu.hParentEventHandler,
239 GetEventTypeCount(eventList), eventList,
240 NULL, NULL);
241# endif /* !__LP64__ */
242#endif /* DARWIN */
243
244 /*
245 * Create the default window and context. Their indexes are zero and
246 * a client can use them without calling CreateContext or WindowCreate.
247 */
248 crDebug("Render SPU: Creating default window (visBits=0x%x, id=0)",
249 render_spu.default_visual);
250 defaultWin = renderspuWindowCreate( NULL, render_spu.default_visual );
251 if (defaultWin != 0) {
252 crError("Render SPU: Couldn't get a double-buffered, RGB visual with Z!");
253 return NULL;
254 }
255 crDebug( "Render SPU: WindowCreate returned %d (0=normal)", defaultWin );
256
257 crDebug("Render SPU: Creating default context, visBits=0x%x",
258 render_spu.default_visual );
259 defaultCtx = renderspuCreateContext( NULL, render_spu.default_visual, 0 );
260 CRASSERT(defaultCtx == 0);
261
262 renderspuMakeCurrent( defaultWin, 0, defaultCtx );
263
264 /* Get windowInfo for the default window */
265 windowInfo = (WindowInfo *) crHashtableSearch(render_spu.windowTable, 0);
266 CRASSERT(windowInfo);
267 windowInfo->mapPending = GL_TRUE;
268
269 /*
270 * Get the OpenGL extension functions.
271 * SIGH -- we have to wait until the very bitter end to load the
272 * extensions, because the context has to be bound before
273 * wglGetProcAddress will work correctly. No such issue with GLX though.
274 */
275 numFuncs += crLoadOpenGLExtensions( &render_spu.ws, _cr_render_table + numFuncs );
276 CRASSERT(numFuncs < 1000);
277
278#ifdef WINDOWS
279 /*
280 * Same problem as above, these are extensions so we need to
281 * load them after a context has been bound. As they're WGL
282 * extensions too, we can't simply tag them into the spu_loader.
283 * So we do them here for now.
284 * Grrr, NVIDIA driver uses EXT for GetExtensionsStringEXT,
285 * but ARB for others. Need furthur testing here....
286 */
287 render_spu.ws.wglGetExtensionsStringEXT =
288 (wglGetExtensionsStringEXTFunc_t)
289 render_spu.ws.wglGetProcAddress( "wglGetExtensionsStringEXT" );
290 render_spu.ws.wglChoosePixelFormatEXT =
291 (wglChoosePixelFormatEXTFunc_t)
292 render_spu.ws.wglGetProcAddress( "wglChoosePixelFormatARB" );
293 render_spu.ws.wglGetPixelFormatAttribivEXT =
294 (wglGetPixelFormatAttribivEXTFunc_t)
295 render_spu.ws.wglGetProcAddress( "wglGetPixelFormatAttribivARB" );
296 render_spu.ws.wglGetPixelFormatAttribfvEXT =
297 (wglGetPixelFormatAttribfvEXTFunc_t)
298 render_spu.ws.wglGetProcAddress( "wglGetPixelFormatAttribfvARB" );
299
300 if (render_spu.ws.wglGetProcAddress("glTexImage3D"))
301 {
302 _cr_render_table[numFuncs].name = crStrdup("TexImage3D");
303 _cr_render_table[numFuncs].fn = (SPUGenericFunction) render_spu.ws.wglGetProcAddress("glTexImage3D");
304 ++numFuncs;
305 crDebug("Render SPU: Found glTexImage3D function");
306 }
307
308 if (render_spu.ws.wglGetExtensionsStringEXT) {
309 crDebug("WGL - found wglGetExtensionsStringEXT\n");
310 }
311 if (render_spu.ws.wglChoosePixelFormatEXT) {
312 crDebug("WGL - found wglChoosePixelFormatEXT\n");
313 }
314#endif
315
316 render_spu.barrierHash = crAllocHashtable();
317
318 render_spu.cursorX = 0;
319 render_spu.cursorY = 0;
320 render_spu.use_L2 = 0;
321
322 render_spu.gather_conns = NULL;
323
324 crDebug("Render SPU: ---------- End of Init -------------");
325 return &render_functions;
326}
327
328
329static void renderSPUSelfDispatch(SPUDispatchTable *self)
330{
331 crSPUInitDispatchTable( &(render_spu.self) );
332 crSPUCopyDispatchTable( &(render_spu.self), self );
333
334 render_spu.server = (CRServer *)(self->server);
335}
336
337
338static void DeleteContextCallback( void *data )
339{
340 ContextInfo *context = (ContextInfo *) data;
341 renderspu_SystemDestroyContext(context);
342 crFree(context);
343}
344
345static void DeleteWindowCallback( void *data )
346{
347 WindowInfo *window = (WindowInfo *) data;
348 renderspu_SystemDestroyWindow(window);
349 crFree(window);
350}
351
352static int renderSPUCleanup(void)
353{
354 crFreeHashtable(render_spu.contextTable, DeleteContextCallback);
355 render_spu.contextTable = NULL;
356 crFreeHashtable(render_spu.windowTable, DeleteWindowCallback);
357 render_spu.windowTable = NULL;
358 crFreeHashtable(render_spu.barrierHash, crFree);
359 render_spu.barrierHash = NULL;
360
361#ifdef RT_OS_DARWIN
362 DisposeEventHandlerUPP(render_spu.hParentEventHandler);
363 ReleaseWindowGroup(render_spu.pMasterGroup);
364 ReleaseWindowGroup(render_spu.pParentGroup);
365 if (render_spu.hRootVisibleRegion)
366 {
367 DisposeRgn(render_spu.hRootVisibleRegion);
368 render_spu.hRootVisibleRegion = 0;
369 }
370 render_spu.currentBufferName = 1;
371 render_spu.uiDockUpdateTS = 0;
372 RTSemFastMutexDestroy(render_spu.syncMutex);
373#endif /* RT_OS_DARWIN */
374
375#ifdef RT_OS_WINDOWS
376 if (render_spu.dwWinThreadId)
377 {
378 PostThreadMessage(render_spu.dwWinThreadId, WM_QUIT, 0, 0);
379 WaitForSingleObject(render_spu.hWinThreadReadyEvent, INFINITE);
380 }
381 CloseHandle(render_spu.hWinThreadReadyEvent);
382 render_spu.hWinThreadReadyEvent = NULL;
383#endif
384
385 return 1;
386}
387
388
389extern SPUOptions renderSPUOptions[];
390
391int SPULoad( char **name, char **super, SPUInitFuncPtr *init,
392 SPUSelfDispatchFuncPtr *self, SPUCleanupFuncPtr *cleanup,
393 SPUOptionsPtr *options, int *flags )
394{
395 *name = "render";
396 *super = NULL;
397 *init = renderSPUInit;
398 *self = renderSPUSelfDispatch;
399 *cleanup = renderSPUCleanup;
400 *options = renderSPUOptions;
401 *flags = (SPU_NO_PACKER|SPU_IS_TERMINAL|SPU_MAX_SERVERS_ZERO);
402
403 return 1;
404}
405
406DECLEXPORT(void) renderspuSetWindowId(unsigned int winId)
407{
408 render_spu_parent_window_id = winId;
409}
410
411static void renderspuWindowVisibleRegionCB(unsigned long key, void *data1, void *data2)
412{
413 WindowInfo *window = (WindowInfo *) data1;
414 CRASSERT(window);
415
416 renderspu_SystemWindowApplyVisibleRegion(window);
417}
418
419DECLEXPORT(void) renderspuSetRootVisibleRegion(GLint cRects, GLint *pRects)
420{
421#ifdef RT_OS_DARWIN
422 renderspu_SystemSetRootVisibleRegion(cRects, pRects);
423
424 crHashtableWalk(render_spu.windowTable, renderspuWindowVisibleRegionCB, NULL);
425#endif
426}
427
428#ifndef RT_OS_DARWIN
429void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *window)
430{
431}
432#endif
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