VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa.c@ 62534

Last change on this file since 62534 was 62489, checked in by vboxsync, 8 years ago

(C) 2016
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 12.5 KB
Line 
1/** @file
2 * VirtualBox OpenGL Cocoa Window System implementation
3 */
4
5/*
6 * Copyright (C) 2009-2016 Oracle Corporation
7 *
8 * This file is part of VirtualBox Open Source Edition (OSE), as
9 * available from http://www.virtualbox.org. This file is free software;
10 * you can redistribute it and/or modify it under the terms of the GNU
11 * General Public License (GPL) as published by the Free Software
12 * Foundation, in version 2 as it comes in the "COPYING" file of the
13 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
14 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
15 */
16
17#include <OpenGL/OpenGL.h>
18
19#include "renderspu.h"
20#include <iprt/process.h>
21#include <iprt/string.h>
22#include <iprt/path.h>
23
24#include <cr_string.h>
25#include <cr_mem.h>
26
27GLboolean renderspu_SystemInitVisual(VisualInfo *pVisInfo)
28{
29 CRASSERT(pVisInfo);
30
31/* cocoaGLVisualCreate(&pCtxInfo->context);*/
32
33 return GL_TRUE;
34}
35
36GLboolean renderspu_SystemCreateContext(VisualInfo *pVisInfo, ContextInfo *pCtxInfo, ContextInfo *pSharedCtxInfo)
37{
38 CRASSERT(pVisInfo);
39 CRASSERT(pCtxInfo);
40
41 pCtxInfo->currentWindow = NULL;
42
43 cocoaGLCtxCreate(&pCtxInfo->context, pVisInfo->visAttribs, pSharedCtxInfo ? pSharedCtxInfo->context : NULL);
44
45 return GL_TRUE;
46}
47
48void renderspu_SystemDestroyContext(ContextInfo *pCtxInfo)
49{
50 if(!pCtxInfo)
51 return;
52
53 if(pCtxInfo->context)
54 {
55 cocoaGLCtxDestroy(pCtxInfo->context);
56 pCtxInfo->context = NULL;
57 }
58}
59
60void renderspuFullscreen(WindowInfo *pWinInfo, GLboolean fFullscreen)
61{
62 /* Real fullscreen isn't supported by VirtualBox */
63}
64
65GLboolean renderspu_SystemVBoxCreateWindow(VisualInfo *pVisInfo, GLboolean fShowIt, WindowInfo *pWinInfo)
66{
67 CRASSERT(pVisInfo);
68 CRASSERT(pWinInfo);
69
70 /* VirtualBox is the only frontend which support 3D right now. */
71 char pszName[256];
72 if (RTProcGetExecutablePath(pszName, sizeof(pszName)))
73 /* Check for VirtualBox and VirtualBoxVM */
74 if (RTStrNICmp(RTPathFilename(pszName), "VirtualBox", 10) != 0)
75 return GL_FALSE;
76
77 pWinInfo->visual = pVisInfo;
78 pWinInfo->window = NULL;
79 pWinInfo->nativeWindow = NULL;
80 pWinInfo->currentCtx = NULL;
81
82 NativeNSViewRef pParentWin = (NativeNSViewRef)(uintptr_t)render_spu_parent_window_id;
83
84 cocoaViewCreate(&pWinInfo->window, pWinInfo, pParentWin, pVisInfo->visAttribs);
85
86 if (fShowIt)
87 renderspu_SystemShowWindow(pWinInfo, fShowIt);
88
89 return GL_TRUE;
90}
91
92void renderspu_SystemReparentWindow(WindowInfo *pWinInfo)
93{
94 NativeNSViewRef pParentWin = (NativeNSViewRef)(uintptr_t)render_spu_parent_window_id;
95 cocoaViewReparent(pWinInfo->window, pParentWin);
96}
97
98void renderspu_SystemDestroyWindow(WindowInfo *pWinInfo)
99{
100 CRASSERT(pWinInfo);
101
102 cocoaViewDestroy(pWinInfo->window);
103}
104
105void renderspu_SystemWindowPosition(WindowInfo *pWinInfo, GLint x, GLint y)
106{
107 CRASSERT(pWinInfo);
108 NativeNSViewRef pParentWin = (NativeNSViewRef)(uintptr_t)render_spu_parent_window_id;
109
110 /*pParentWin is unused in the call, otherwise it might hold incorrect value if for ex. last reparent call was for
111 a different screen*/
112 cocoaViewSetPosition(pWinInfo->window, pParentWin, x, y);
113}
114
115void renderspu_SystemWindowSize(WindowInfo *pWinInfo, GLint w, GLint h)
116{
117 CRASSERT(pWinInfo);
118
119 cocoaViewSetSize(pWinInfo->window, w, h);
120}
121
122void renderspu_SystemGetWindowGeometry(WindowInfo *pWinInfo, GLint *pX, GLint *pY, GLint *pW, GLint *pH)
123{
124 CRASSERT(pWinInfo);
125
126 cocoaViewGetGeometry(pWinInfo->window, pX, pY, pW, pH);
127}
128
129void renderspu_SystemGetMaxWindowSize(WindowInfo *pWinInfo, GLint *pW, GLint *pH)
130{
131 CRASSERT(pWinInfo);
132
133 *pW = 10000;
134 *pH = 10000;
135}
136
137void renderspu_SystemShowWindow(WindowInfo *pWinInfo, GLboolean fShowIt)
138{
139 CRASSERT(pWinInfo);
140
141 cocoaViewShow(pWinInfo->window, fShowIt);
142}
143
144void renderspu_SystemVBoxPresentComposition( WindowInfo *window, const struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
145{
146 cocoaViewPresentComposition(window->window, pChangedEntry);
147}
148
149void renderspu_SystemMakeCurrent(WindowInfo *pWinInfo, GLint nativeWindow, ContextInfo *pCtxInfo)
150{
151/* if(pWinInfo->visual != pCtxInfo->visual)*/
152/* printf ("visual mismatch .....................\n");*/
153
154 nativeWindow = 0;
155
156 if (pWinInfo && pCtxInfo)
157 cocoaViewMakeCurrentContext(pWinInfo->window, pCtxInfo->context);
158 else
159 cocoaViewMakeCurrentContext(NULL, NULL);
160}
161
162void renderspu_SystemSwapBuffers(WindowInfo *pWinInfo, GLint flags)
163{
164 CRASSERT(pWinInfo);
165
166 cocoaViewDisplay(pWinInfo->window);
167}
168
169GLboolean renderspu_SystemWindowNeedEmptyPresent(WindowInfo *pWinInfo)
170{
171 return cocoaViewNeedsEmptyPresent(pWinInfo->window);
172}
173
174void renderspu_SystemWindowVisibleRegion(WindowInfo *pWinInfo, GLint cRects, const GLint* paRects)
175{
176 CRASSERT(pWinInfo);
177
178 cocoaViewSetVisibleRegion(pWinInfo->window, cRects, paRects);
179}
180
181void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *pWinInfo)
182{
183}
184
185int renderspu_SystemInit()
186{
187 return VINF_SUCCESS;
188}
189
190int renderspu_SystemTerm()
191{
192 CrGlslTerm(&render_spu.GlobalShaders);
193 return VINF_SUCCESS;
194}
195
196static SPUNamedFunctionTable * renderspuFindEntry(SPUNamedFunctionTable *aFunctions, const char *pcszName)
197{
198 SPUNamedFunctionTable *pCur;
199
200 for (pCur = aFunctions ; pCur->name != NULL ; pCur++)
201 {
202 if (!crStrcmp( pcszName, pCur->name ) )
203 {
204 return pCur;
205 }
206 }
207
208 AssertFailed();
209
210 return NULL;
211}
212
213typedef struct CR_RENDER_CTX_INFO
214{
215 ContextInfo * pContext;
216 WindowInfo * pWindow;
217} CR_RENDER_CTX_INFO;
218
219void renderspuCtxInfoInitCurrent(CR_RENDER_CTX_INFO *pInfo)
220{
221 GET_CONTEXT(pCurCtx);
222 pInfo->pContext = pCurCtx;
223 pInfo->pWindow = pCurCtx ? pCurCtx->currentWindow : NULL;
224}
225
226void renderspuCtxInfoRestoreCurrent(CR_RENDER_CTX_INFO *pInfo)
227{
228 GET_CONTEXT(pCurCtx);
229 if (pCurCtx == pInfo->pContext && (!pCurCtx || pCurCtx->currentWindow == pInfo->pWindow))
230 return;
231 renderspuPerformMakeCurrent(pInfo->pWindow, 0, pInfo->pContext);
232}
233
234GLboolean renderspuCtxSetCurrentWithAnyWindow(ContextInfo * pContext, CR_RENDER_CTX_INFO *pInfo)
235{
236 WindowInfo * window;
237 renderspuCtxInfoInitCurrent(pInfo);
238
239 if (pInfo->pContext == pContext)
240 return GL_TRUE;
241
242 window = pContext->currentWindow;
243 if (!window)
244 {
245 window = renderspuGetDummyWindow(pContext->BltInfo.Base.visualBits);
246 if (!window)
247 {
248 WARN(("renderspuGetDummyWindow failed"));
249 return GL_FALSE;
250 }
251 }
252
253 Assert(window);
254
255 renderspuPerformMakeCurrent(window, 0, pContext);
256 return GL_TRUE;
257}
258
259void renderspu_SystemDefaultSharedContextChanged(ContextInfo *fromContext, ContextInfo *toContext)
260{
261 CRASSERT(fromContext != toContext);
262
263 if (!CrGlslIsInited(&render_spu.GlobalShaders))
264 {
265 CrGlslInit(&render_spu.GlobalShaders, &render_spu.blitterDispatch);
266 }
267
268 if (fromContext)
269 {
270 if (CrGlslNeedsCleanup(&render_spu.GlobalShaders))
271 {
272 CR_RENDER_CTX_INFO Info;
273 if (renderspuCtxSetCurrentWithAnyWindow(fromContext, &Info))
274 {
275 CrGlslCleanup(&render_spu.GlobalShaders);
276 renderspuCtxInfoRestoreCurrent(&Info);
277 }
278 else
279 WARN(("renderspuCtxSetCurrentWithAnyWindow failed!"));
280 }
281 }
282 else
283 {
284 CRASSERT(!CrGlslNeedsCleanup(&render_spu.GlobalShaders));
285 }
286
287 CRASSERT(!CrGlslNeedsCleanup(&render_spu.GlobalShaders));
288
289 if (toContext)
290 {
291 CR_RENDER_CTX_INFO Info;
292 if (renderspuCtxSetCurrentWithAnyWindow(toContext, &Info))
293 {
294 int rc = CrGlslProgGenAllNoAlpha(&render_spu.GlobalShaders);
295 if (!RT_SUCCESS(rc))
296 WARN(("CrGlslProgGenAllNoAlpha failed, rc %d", rc));
297
298 renderspuCtxInfoRestoreCurrent(&Info);
299 }
300 else
301 crWarning("renderspuCtxSetCurrentWithAnyWindow failed!");
302 }
303}
304
305AssertCompile(sizeof (GLhandleARB) == sizeof (void*));
306
307static VBoxGLhandleARB crHndlSearchVBox(GLhandleARB hNative)
308{
309 CRASSERT(!(((uintptr_t)hNative) >> 32));
310 return (VBoxGLhandleARB)((uintptr_t)hNative);
311}
312
313static GLhandleARB crHndlSearchNative(VBoxGLhandleARB hVBox)
314{
315 return (GLhandleARB)((uintptr_t)hVBox);
316}
317
318static VBoxGLhandleARB crHndlAcquireVBox(GLhandleARB hNative)
319{
320 CRASSERT(!(((uintptr_t)hNative) >> 32));
321 return (VBoxGLhandleARB)((uintptr_t)hNative);
322}
323
324static GLhandleARB crHndlReleaseVBox(VBoxGLhandleARB hVBox)
325{
326 return (GLhandleARB)((uintptr_t)hVBox);
327}
328
329static void SPU_APIENTRY renderspu_SystemDeleteObjectARB(VBoxGLhandleARB obj)
330{
331 GLhandleARB hNative = crHndlReleaseVBox(obj);
332 if (!hNative)
333 {
334 crWarning("no native for %d", obj);
335 return;
336 }
337
338 render_spu.pfnDeleteObject(hNative);
339}
340
341static void SPU_APIENTRY renderspu_SystemGetAttachedObjectsARB( VBoxGLhandleARB containerObj, GLsizei maxCount, GLsizei * pCount, VBoxGLhandleARB * obj )
342{
343 GLhandleARB *paAttachments;
344 GLhandleARB hNative = crHndlSearchNative(containerObj);
345 GLsizei count, i;
346
347 if (pCount)
348 *pCount = 0;
349
350 if (!hNative)
351 {
352 crWarning("no native for %d", obj);
353 return;
354 }
355
356 paAttachments = crCalloc(maxCount * sizeof (*paAttachments));
357 if (!paAttachments)
358 {
359 crWarning("crCalloc failed");
360 return;
361 }
362
363 render_spu.pfnGetAttachedObjects(hNative, maxCount, &count, paAttachments);
364 if (pCount)
365 *pCount = count;
366 if (count > maxCount)
367 {
368 crWarning("count too big");
369 count = maxCount;
370 }
371
372 for (i = 0; i < count; ++i)
373 {
374 obj[i] = crHndlSearchVBox(paAttachments[i]);
375 CRASSERT(obj[i]);
376 }
377
378 crFree(paAttachments);
379}
380
381static VBoxGLhandleARB SPU_APIENTRY renderspu_SystemGetHandleARB(GLenum pname)
382{
383 GLhandleARB hNative = render_spu.pfnGetHandle(pname);
384 VBoxGLhandleARB hVBox;
385 if (!hNative)
386 {
387 crWarning("pfnGetHandle failed");
388 return 0;
389 }
390 hVBox = crHndlAcquireVBox(hNative);
391 CRASSERT(hVBox);
392 return hVBox;
393}
394
395static void SPU_APIENTRY renderspu_SystemGetInfoLogARB( VBoxGLhandleARB obj, GLsizei maxLength, GLsizei * length, GLcharARB * infoLog )
396{
397 GLhandleARB hNative = crHndlSearchNative(obj);
398 if (!hNative)
399 {
400 crWarning("invalid handle!");
401 return;
402 }
403
404 render_spu.pfnGetInfoLog(hNative, maxLength, length, infoLog);
405}
406
407static void SPU_APIENTRY renderspu_SystemGetObjectParameterfvARB( VBoxGLhandleARB obj, GLenum pname, GLfloat * params )
408{
409 GLhandleARB hNative = crHndlSearchNative(obj);
410 if (!hNative)
411 {
412 crWarning("invalid handle!");
413 return;
414 }
415
416 render_spu.pfnGetObjectParameterfv(hNative, pname, params);
417}
418
419static void SPU_APIENTRY renderspu_SystemGetObjectParameterivARB( VBoxGLhandleARB obj, GLenum pname, GLint * params )
420{
421 GLhandleARB hNative = crHndlSearchNative(obj);
422 if (!hNative)
423 {
424 crWarning("invalid handle!");
425 return;
426 }
427
428 render_spu.pfnGetObjectParameteriv(hNative, pname, params);
429}
430
431uint32_t renderspu_SystemPostprocessFunctions(SPUNamedFunctionTable *aFunctions, uint32_t cFunctions, uint32_t cTable)
432{
433 SPUNamedFunctionTable * pEntry;
434
435 pEntry = renderspuFindEntry(aFunctions, "DeleteObjectARB");
436 if (pEntry)
437 {
438 render_spu.pfnDeleteObject = (PFNDELETE_OBJECT)pEntry->fn;
439 pEntry->fn = (SPUGenericFunction)renderspu_SystemDeleteObjectARB;
440 }
441
442 pEntry = renderspuFindEntry(aFunctions, "GetAttachedObjectsARB");
443 if (pEntry)
444 {
445 render_spu.pfnGetAttachedObjects = (PFNGET_ATTACHED_OBJECTS)pEntry->fn;
446 pEntry->fn = (SPUGenericFunction)renderspu_SystemGetAttachedObjectsARB;
447 }
448
449 pEntry = renderspuFindEntry(aFunctions, "GetHandleARB");
450 if (pEntry)
451 {
452 render_spu.pfnGetHandle = (PFNGET_HANDLE)pEntry->fn;
453 pEntry->fn = (SPUGenericFunction)renderspu_SystemGetHandleARB;
454 }
455
456 pEntry = renderspuFindEntry(aFunctions, "GetInfoLogARB");
457 if (pEntry)
458 {
459 render_spu.pfnGetInfoLog = (PFNGET_INFO_LOG)pEntry->fn;
460 pEntry->fn = (SPUGenericFunction)renderspu_SystemGetInfoLogARB;
461 }
462
463 pEntry = renderspuFindEntry(aFunctions, "GetObjectParameterfvARB");
464 if (pEntry)
465 {
466 render_spu.pfnGetObjectParameterfv = (PFNGET_OBJECT_PARAMETERFV)pEntry->fn;
467 pEntry->fn = (SPUGenericFunction)renderspu_SystemGetObjectParameterfvARB;
468 }
469
470 pEntry = renderspuFindEntry(aFunctions, "GetObjectParameterivARB");
471 if (pEntry)
472 {
473 render_spu.pfnGetObjectParameteriv = (PFNGET_OBJECT_PARAMETERIV)pEntry->fn;
474 pEntry->fn = (SPUGenericFunction)renderspu_SystemGetObjectParameterivARB;
475 }
476
477 return cFunctions;
478}
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