DevVGA-SVGA3d-cocoa.m@ 105982

Last change on this file since 105982 was 98103, checked in by vboxsync, 23 months ago
Copyright year updates by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 33.6 KB

Line
1	/* $Id: DevVGA-SVGA3d-cocoa.m 98103 2023-01-17 14:15:46Z vboxsync $ */
2	/** @file
3	* VirtualBox OpenGL Cocoa Window System Helper Implementation.
4	*
5	* @remarks Inspired by HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m.
6	*/
7
8	/*
9	* Copyright (C) 2009-2023 Oracle and/or its affiliates.
10	*
11	* This file is part of VirtualBox base platform packages, as
12	* available from https://www.virtualbox.org.
13	*
14	* This program is free software; you can redistribute it and/or
15	* modify it under the terms of the GNU General Public License
16	* as published by the Free Software Foundation, in version 3 of the
17	* License.
18	*
19	* This program is distributed in the hope that it will be useful, but
20	* WITHOUT ANY WARRANTY; without even the implied warranty of
21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
22	* General Public License for more details.
23	*
24	* You should have received a copy of the GNU General Public License
25	* along with this program; if not, see <https://www.gnu.org/licenses>.
26	*
27	* SPDX-License-Identifier: GPL-3.0-only
28	*/
29
30
31	/*********************************************************************************************************************************
32	* Header Files *
33	*********************************************************************************************************************************/
34	#define LOG_GROUP LOG_GROUP_DEV_VMSVGA
35	#include "DevVGA-SVGA3d-cocoa.h"
36	#import <Cocoa/Cocoa.h>
37	#undef PVM /* Stupid namespace pollution from outdated sys/param.h header file. */
38	#import <OpenGL/gl.h>
39
40	#include <iprt/thread.h>
41	#include <iprt/assert.h>
42	#include <iprt/string.h>
43	#include <VBox/log.h>
44	#include <VBox/vmm/dbgf.h>
45
46
47	/*********************************************************************************************************************************
48	* Defined Constants And Macros *
49	*********************************************************************************************************************************/
50	/** @def USE_NSOPENGLVIEW
51	* Define this to experiment with using NSOpenGLView instead
52	* of NSView. There are transparency issues with the former,
53	* so for the time being we're using the latter. */
54	#if 0 \|\| DOXYGEN_RUNNING
55	# define USE_NSOPENGLVIEW
56	#endif
57
58	/**@def FLOAT_FMT_STR
59	* Format string bits to go with FLOAT_FMT_ARGS. */
60	#define FLOAT_FMT_STR "%d.%06u"
61	/** @def FLOAT_FMT_ARGS
62	* Format arguments for a float value, corresponding to FLOAT_FMT_STR.
63	* @param r The floating point value to format. */
64	#define FLOAT_FMT_ARGS(r) (int)(r), ((unsigned)(RT_ABS(r) * 1000000) % 1000000U)
65
66
67
68	/*********************************************************************************************************************************
69	* Structures and Typedefs *
70	*********************************************************************************************************************************/
71	/**
72	* Argument package for doing this on the main thread.
73	*/
74	@interface VMSVGA3DCreateViewAndContext : NSObject
75	{
76	@public
77	/* in */
78	NativeNSViewRef pParentView;
79	uint32_t cx;
80	uint32_t cy;
81	NativeNSOpenGLContextRef pSharedCtx;
82	bool fOtherProfile;
83
84	/* out */
85	NativeNSViewRef pView;
86	NativeNSOpenGLContextRef pCtx;
87	}
88	@end
89
90
91	/**
92	* The overlay view.
93	*/
94	@interface VMSVGA3DOverlayView
95	#ifdef USE_NSOPENGLVIEW
96	: NSOpenGLView
97	#else
98	: NSView
99	#endif
100	{
101	@private
102	/** This points to the parent view, if there is one. If there isn't a parent
103	* the view will be hidden and never used for displaying stuff. We only have
104	* one visible context per guest screen that is visible to the user and
105	* subject to buffer swapping. */
106	NSView *m_pParentView;
107	/** Indicates that buffers (back+front) needs clearing before use because
108	* the view changed size. There are two buffers, so this is set to two
109	* each time when the view area increases. */
110	uint32_t m_cClears;
111	/** Set if the OpenGL context needs updating after a resize. */
112	bool m_fUpdateCtx;
113
114	#ifndef USE_NSOPENGLVIEW
115	/** The OpenGL context associated with this view. */
116	NSOpenGLContext *m_pCtx;
117	/** Number of times we've tried to set the view (shut up noisy NSLog). */
118	uint32_t m_cSetViewAttempts;
119	#endif
120
121	/** The desired view position relative to super. */
122	NSPoint m_Pos;
123	/** The desired view size. */
124	NSSize m_Size;
125	}
126	+ (void)createViewAndContext:(VMSVGA3DCreateViewAndContext *)pParams;
127	- (id)initWithFrameAndFormat:(NSRect)frame parentView:(NSView)pparentView pixelFormat:(NSOpenGLPixelFormat )pFmt;
128	- (void)vboxSetPos:(NSPoint)pos;
129	- (void)vboxSetSize:(NSSize)size;
130	- (void)vboxScheduleCtxUpdate;
131	- (void)vboxReshapePerform;
132	- (void)vboxReshape;
133	- (void)vboxBoundsDidChange:(NSNotification *)pNotification;
134	- (void)vboxFrameDidChange:(NSNotification *)pNotification;
135	- (void)vboxFrameDidChangeGlobal:(NSNotification *)pNotification;
136	- (BOOL)postsFrameChangedNotifications;
137	- (void)vboxRemoveFromSuperviewAndHide;
138	- (void)vboxUpdateCtxIfNecessary;
139	- (void)vboxClearBackBufferIfNecessary;
140	- (NSOpenGLContext *)makeCurrentGLContext;
141	- (void)restoreSavedGLContext:(NSOpenGLContext *)pSavedCtx;
142
143	#ifndef USE_NSOPENGLVIEW
144	/* NSOpenGLView fakes: */
145	- (void)setOpenGLContext:(NSOpenGLContext *)pCtx;
146	- (NSOpenGLContext *)openGLContext;
147	- (void)prepareOpenGL;
148
149	#endif
150	/* Overridden: */
151	- (void)viewDidMoveToWindow;
152	- (void)viewDidMoveToSuperview;
153	- (void)resizeWithOldSuperviewSize:(NSSize)oldBoundsSize;
154	- (void)drawRect:(NSRect)rect;
155
156	@end
157
158
159	/********************************************************************************
160	*
161	* VMSVGA3DOverlayView class implementation
162	*
163	********************************************************************************/
164	@implementation VMSVGA3DOverlayView
165
166
167	+ (void)createViewAndContext:(VMSVGA3DCreateViewAndContext *)pParams
168	{
169	LogFlow(("OvlView createViewAndContext:\n"));
170
171	/*
172	* Create a pixel format.
173	*/
174	NSOpenGLPixelFormat *pFmt = nil;
175
176	// Consider to remove it and check if it's harmless.
177	NSOpenGLPixelFormatAttribute attribs[] =
178	{
179	NSOpenGLPFAOpenGLProfile, (NSOpenGLPixelFormatAttribute)0,
180	//NSOpenGLPFAWindow, - obsolete/deprecated, try work without it...
181	NSOpenGLPFAAccelerated,
182	NSOpenGLPFADoubleBuffer,
183	NSOpenGLPFABackingStore,
184	NSOpenGLPFAColorSize, (NSOpenGLPixelFormatAttribute)24,
185	NSOpenGLPFAAlphaSize, (NSOpenGLPixelFormatAttribute)8,
186	NSOpenGLPFADepthSize, (NSOpenGLPixelFormatAttribute)24,
187	0
188	};
189	attribs[1] = pParams->fOtherProfile ? NSOpenGLProfileVersion3_2Core : NSOpenGLProfileVersionLegacy;
190	pFmt = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs];
191	if (pFmt)
192	{
193	/*
194	* Create a new view.
195	*/
196	NSRect Frame;
197	Frame.origin.x = 0;
198	Frame.origin.y = 0;
199	Frame.size.width = pParams->cx < _1M && pParams->cx > 0 ? pParams->cx : 1; /* 'invalid drawable' if 0,0 size? */
200	Frame.size.height = pParams->cy < _1M && pParams->cy > 0 ? pParams->cy : 1;
201	VMSVGA3DOverlayView *pView = [[VMSVGA3DOverlayView alloc] initWithFrameAndFormat:Frame
202	parentView:pParams->pParentView
203	pixelFormat:pFmt];
204	if (pView)
205	{
206	/*
207	* If we have no shared GL context, we use the one that NSOpenGLView create. Otherwise,
208	* we replace it. (If we don't call openGLContext, it won't yet have been instantiated,
209	* so there is no unecessary contexts created here when pSharedCtx != NULL.)
210	*/
211	NSOpenGLContext *pCtx;
212	#ifdef USE_NSOPENGLVIEW
213	if (!pParams->pSharedCtx)
214	pCtx = [pView openGLContext];
215	else
216	#endif
217	{
218	pCtx = [[NSOpenGLContext alloc] initWithFormat:pFmt shareContext: pParams->pSharedCtx];
219	if (pCtx)
220	{
221	[pView setOpenGLContext:pCtx];
222	[pCtx setView:pView];
223	#ifdef USE_NSOPENGLVIEW
224	Assert([pCtx view] == pView);
225	#endif
226	}
227	}
228	if (pCtx)
229	{
230	/*
231	* Attach the view to the parent if we have one. Otherwise make sure its invisible.
232	*/
233	if (pParams->pParentView)
234	[pParams->pParentView addSubview:pView];
235	else
236	[pView setHidden:YES];
237
238	/*
239	* Resize and return.
240	*/
241	//[pView vboxSetSize:Frame.size];
242
243	NSOpenGLContext *pSavedCtx = [pView makeCurrentGLContext];
244
245	[pView prepareOpenGL];
246	GLint x;
247	//x = 0; [pCtx setValues:&x forParameter:NSOpenGLCPSwapInterval];
248	//x = 1; [pCtx setValues:&x forParameter:NSOpenGLCPSurfaceOrder];
249	x = 0; [pCtx setValues:&x forParameter:NSOpenGLCPSurfaceOpacity];
250
251	if (pParams->pParentView)
252	[pView setHidden:NO];
253	else
254	[pView setHidden:YES];
255
256	[pView restoreSavedGLContext:pSavedCtx];
257
258	pParams->pView = pView;
259	pParams->pCtx = pCtx;
260	[pCtx retain]; //??
261
262	[pFmt release];
263
264	LogFlow(("OvlView createViewAndContext: returns successfully\n"));
265	return;
266	}
267	[pView release];
268	}
269	[pFmt release];
270	}
271	else
272	AssertFailed();
273
274	LogFlow(("OvlView createViewAndContext: returns failure\n"));
275	return;
276	}
277
278	- (id)initWithFrameAndFormat:(NSRect) frame parentView:(NSView )pParentView pixelFormat:(NSOpenGLPixelFormat )pFmt
279	{
280	LogFlow(("OvlView(%p) initWithFrameAndFormat:\n", (void *)self));
281
282	m_pParentView = pParentView;
283	/* Make some reasonable defaults */
284	m_Pos = NSZeroPoint;
285	m_Size = frame.size;
286	m_cClears = 2;
287	m_fUpdateCtx = true;
288
289	#ifdef USE_NSOPENGLVIEW
290	self = [super initWithFrame:frame pixelFormat:pFmt];
291	#else
292	RT_NOREF(pFmt);
293	m_cSetViewAttempts = 0;
294	m_pCtx = NULL;
295	self = [super initWithFrame:frame];
296	#endif
297	if (self)
298	{
299	//self.autoresizingMask = NSViewMinXMargin \| NSViewMaxXMargin \| NSViewMinYMargin \| NSViewMaxYMargin;
300	self.autoresizingMask = NSViewNotSizable;
301
302	/*
303	* Get notifications when we're moved or resized and when we're moved
304	* to a different screen or GPU or when the GL context simply needs updating.
305	*/
306	if (pParentView)
307	{
308	[[NSNotificationCenter defaultCenter] addObserver:self
309	selector:@selector(vboxBoundsDidChange:)
310	name:NSViewBoundsDidChangeNotification
311	object:self];
312	[[NSNotificationCenter defaultCenter] addObserver:self
313	selector:@selector(vboxFrameDidChange:)
314	name:NSViewFrameDidChangeNotification
315	object:self];
316	//[[NSNotificationCenter defaultCenter] addObserver:self
317	// selector:@selector(vboxFrameDidChange:)
318	// name:NSViewDidUpdateTrackingAreasNotification
319	// object:self];
320	[[NSNotificationCenter defaultCenter] addObserver:self
321	selector:@selector(vboxFrameDidChangeGlobal:)
322	name:NSViewGlobalFrameDidChangeNotification
323	object:self];
324	}
325	}
326	LogFlow(("OvlView(%p) initWithFrameAndFormat: returns %p\n", (void )self, (void )self));
327	return self;
328	}
329
330	- (void)dealloc
331	{
332	LogFlow(("OvlView(%p) dealloc:\n", (void *)self));
333
334	#ifdef USE_NSOPENGLVIEW
335	[[self openGLContext] clearDrawable];
336	#else
337	if (m_pCtx)
338	{
339	[m_pCtx clearDrawable];
340	[m_pCtx release];
341	m_pCtx = nil;
342	}
343	#endif
344
345	[super dealloc];
346
347	LogFlow(("OvlView(%p) dealloc: returns\n", (void *)self));
348	}
349
350
351	- (void)vboxSetPos:(NSPoint)pos
352	{
353	Log(("OvlView(%p) vboxSetPos: (%d,%d)\n", (void *)self, (int)pos.x, (int)pos.y));
354
355	m_Pos = pos;
356	[self vboxReshape];
357
358	LogFlow(("OvlView(%p) vboxSetPos: returns\n", (void *)self));
359	}
360
361
362	- (void)vboxSetSize:(NSSize)size
363	{
364	Log(("OvlView(%p) vboxSetSize: (%d,%d):\n", (void *)self, (int)size.width, (int)size.height));
365	m_Size = size;
366	[self vboxReshape];
367	LogFlow(("OvlView(%p) vboxSetSize: returns\n", (void *)self));
368	}
369
370	- (void)vboxScheduleCtxUpdate
371	{
372	m_fUpdateCtx = true;
373	}
374
375	- (void)vboxUpdateCtxIfNecessary
376	{
377	if (m_fUpdateCtx)
378	{
379	Log(("OvlView(%p) vboxUpdateCtxIfNecessary: m_fUpdateCtx\n", (void *)self));
380	/* This must be done on the main thread or it will crash with an error. */
381	[[self openGLContext] performSelectorOnMainThread:@selector(update) withObject:nil waitUntilDone:YES];
382	m_fUpdateCtx = false;
383	}
384	}
385
386
387	- (void)vboxClearBackBufferIfNecessary
388	{
389	#if 1 /* experiment */
390	if (m_cClears > 0)
391	{
392	Assert(![NSThread isMainThread]);
393	Assert([self openGLContext] == [NSOpenGLContext currentContext]);
394	Log(("OvlView(%p) vboxClearBackBufferIfNecessary: m_cClears=%d\n", (void *)self, m_cClears));
395	m_cClears--;
396
397	/* Clear errors. */
398	GLenum rc;
399	while ((rc = glGetError()) != GL_NO_ERROR)
400	continue;
401
402	/* Save the old buffer setting and make it GL_BACK (shall be GL_BACK already actually). */
403	GLint iOldDrawBuf = GL_BACK;
404	glGetIntegerv(GL_DRAW_BUFFER, &iOldDrawBuf);
405	if (iOldDrawBuf != GL_BACK)
406	glDrawBuffer(GL_BACK);
407	while ((rc = glGetError()) != GL_NO_ERROR)
408	AssertMsgFailed(("rc=%x\n", rc));
409
410	/* Clear the current GL_BACK. */
411	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
412	glClear(GL_COLOR_BUFFER_BIT /\|GL_DEPTH_BUFFER_BIT/ );
413	while ((rc = glGetError()) != GL_NO_ERROR)
414	AssertMsgFailed(("rc=%x\n", rc));
415
416	/* We're back to the orignal back buffer now. Just restore GL_DRAW_BUFFER. */
417	if (iOldDrawBuf != GL_BACK)
418	glDrawBuffer(iOldDrawBuf);
419
420	while ((rc = glGetError()) != GL_NO_ERROR)
421	AssertMsgFailed(("rc=%x\n", rc));
422	}
423	#endif
424	}
425
426
427
428	- (void)vboxReshapePerform
429	{
430	/*
431	* Change the size and position if necessary.
432	*/
433	NSRect CurFrameRect = [self frame];
434	/** @todo conversions? */
435	if ( m_Pos.x != CurFrameRect.origin.x
436	\|\| m_Pos.y != CurFrameRect.origin.y)
437	{
438	LogFlow(("OvlView(%p) vboxReshapePerform: moving (%d,%d) -> (%d,%d)\n",
439	(void *)self, CurFrameRect.origin.x, CurFrameRect.origin.y, m_Pos.x, m_Pos.y));
440	[self setFrameOrigin:m_Pos];
441	}
442
443	if ( CurFrameRect.size.width != m_Size.width
444	\|\| CurFrameRect.size.height != m_Size.height)
445	{
446	LogFlow(("OvlView(%p) vboxReshapePerform: resizing (%d,%d) -> (%d,%d)\n",
447	(void *)self, CurFrameRect.size.width, CurFrameRect.size.height, m_Size.width, m_Size.height));
448	[self setFrameSize:m_Size];
449
450	/*
451	* Schedule two clears and a context update for now.
452	* Really though, we should just clear any new surface area.
453	*/
454	m_cClears = 2;
455	}
456	m_fUpdateCtx = true;
457	LogFlow(("OvlView(%p) vboxReshapePerform: returns\n", self));
458	}
459
460
461	- (void)vboxReshape
462	{
463	LogFlow(("OvlView(%p) vboxReshape:\n", (void *)self));
464
465	/*
466	* Resize the view.
467	*/
468	if ([NSThread isMainThread])
469	[self vboxReshapePerform];
470	else
471	{
472	[self performSelectorOnMainThread:@selector(vboxReshapePerform) withObject:nil waitUntilDone:NO];
473	vmsvga3dCocoaServiceRunLoop();
474
475	/*
476	* Try update the opengl context.
477	*/
478	[[self openGLContext] update];
479	}
480
481	LogFlow(("OvlView(%p) vboxReshape: returns\n", (void *)self));
482	}
483
484	/**
485	* This is called when the bounds change.
486	*
487	* We indicate that the FIFO thread must update the GL context.
488	*/
489	- (void)vboxBoundsDidChange:(NSNotification *)pNotification
490	{
491	RT_NOREF(pNotification);
492	LogFlow(("OvlView(%p) vboxBoundsDidChange:\n", (void *)self));
493	self->m_fUpdateCtx = true;
494	}
495
496	/**
497	* This is called when the frame changes size or position.
498	*
499	* We indicate that the FIFO thread must update the GL context.
500	*/
501	- (void)vboxFrameDidChange:(NSNotification *)pNotification
502	{
503	RT_NOREF(pNotification);
504	LogFlow(("OvlView(%p) vboxFrameDidChange:\n", (void *)self));
505	self->m_fUpdateCtx = true;
506	}
507
508	/**
509	* This is called when moved to different screen/GPU or/and when the GL context
510	* needs updating.
511	*
512	* We indicate that the FIFO thread must update the GL context.
513	*/
514	- (void)vboxFrameDidChangeGlobal:(NSNotification *)pNotification
515	{
516	RT_NOREF(pNotification);
517	LogFlow(("OvlView(%p) vboxFrameDidChangeGlobal:\n", (void *)self));
518	self->m_fUpdateCtx = true;
519	}
520
521	/** This enables the vboxFrameDidChange notification. */
522	- (BOOL)postsFrameChangedNotifications
523	{
524	LogFlow(("OvlView(%p) postsFrameChangedNotifications:\n", (void *)self));
525	return YES;
526	}
527
528	/**
529	* Removes the view from the parent, if it has one, and makes sure it's hidden.
530	*
531	* This is callbed before destroying it.
532	*/
533	- (void)vboxRemoveFromSuperviewAndHide
534	{
535	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide:\n", (void *)self));
536	if (m_pParentView)
537	{
538	/*
539	* The removeFromSuperview has been frequently seen to deadlock thing like this:
540	* #0 0x00007fff8db440fa in __psynch_cvwait ()
541	* #1 0x00007fff8d0acfb9 in _pthread_cond_wait ()
542	* #2 0x00007fff8a1bc8f0 in -[NSViewHierarchyLock _lockForWriting:handler:] ()
543	* #3 0x00007fff8a1bc171 in -[NSView removeFromSuperview] ()
544	* #4 0x000000010cffb2bb in -[VMSVGA3DOverlayView vboxRemoveFromSuperviewAndHide] (self=0x10a1da550, _cmd=0x10cffd734) at DevVGA-SVGA3d-cocoa.m:467
545	* #5 0x000000010cffbed3 in vmsvga3dCocoaDestroyViewAndContext (pView=0x10a1da550, pCtx=0x10a1da630) at DevVGA-SVGA3d-cocoa.m:662
546	* (This is from OS X 10.8.5.)
547	*/
548	if ([NSThread isMainThread])
549	{
550	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: calling removeFromSuperview\n", (void *)self));
551	[self removeFromSuperview];
552	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: calling setHidden\n", (void *)self));
553	[self setHidden:YES];
554	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: calling setHidden\n", (void *)self));
555	[[NSNotificationCenter defaultCenter] removeObserver:self];
556	}
557	else
558	{
559	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: defering to main thread\n", (void *)self));
560	vmsvga3dCocoaServiceRunLoop();
561	[self performSelectorOnMainThread:@selector(vboxRemoveFromSuperviewAndHide) withObject:nil waitUntilDone:YES];
562	vmsvga3dCocoaServiceRunLoop();
563	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: main thread done\n", (void *)self));
564	}
565	}
566	}
567
568
569	/**
570	* Changes to the OpenGL context associated with the view.
571	* @returns Previous OpenGL context.
572	*/
573	- (NSOpenGLContext *)makeCurrentGLContext
574	{
575	NSOpenGLContext *pSavedCtx = [NSOpenGLContext currentContext];
576
577	/* Always flush before changing. glXMakeCurrent and wglMakeCurrent does this
578	implicitly, seemingly NSOpenGLContext::makeCurrentContext doesn't. */
579	if (pSavedCtx != nil)
580	glFlush();
581
582	[[self openGLContext] makeCurrentContext];
583	return pSavedCtx;
584	}
585
586
587	/**
588	* Restores the previous OpenGL context after
589	* makeCurrentGLContext.
590	*
591	* @param pSavedCtx The makeCurrentGLContext return value.
592	*/
593	- (void)restoreSavedGLContext:(NSOpenGLContext *)pSavedCtx
594	{
595	/* Always flush before changing. glXMakeCurrent and wglMakeCurrent does this
596	implicitly, seemingly NSOpenGLContext::makeCurrentContext doesn't. */
597	glFlush();
598
599	if (pSavedCtx)
600	[pSavedCtx makeCurrentContext];
601	else
602	[NSOpenGLContext clearCurrentContext];
603	}
604
605	#ifndef USE_NSOPENGLVIEW
606	/*
607	* Faking NSOpenGLView interface.
608	*/
609	- (void)setOpenGLContext:(NSOpenGLContext *)pCtx
610	{
611	if (pCtx != m_pCtx)
612	{
613	if (pCtx)
614	{
615	[pCtx retain];
616	[pCtx setView:self];
617	/Assert([pCtx view] == self); - setView fails early on, works later... /
618	}
619
620	if (m_pCtx)
621	[m_pCtx release];
622
623	m_pCtx = pCtx;
624
625	if (pCtx)
626	[pCtx update];
627	}
628	}
629
630	- (NSOpenGLContext *)openGLContext
631	{
632	/* Stupid hacks to work around setView failing early. This can get kind of
633	noisy on some OS versions, so shut it up a little bit. */
634	/** @todo use NSOpenGLView for the non-visible contexts. */
635	if (m_pCtx && [m_pCtx view] != self)
636	{
637	m_cSetViewAttempts++;
638	if ( m_pParentView
639	\|\| m_cSetViewAttempts < 64
640	\|\| (m_cSetViewAttempts & (m_cSetViewAttempts < _64K ? 0xfff : 0x7fff)) == 0 )
641	[m_pCtx setView:self];
642	}
643	return m_pCtx;
644	}
645
646	- (void)prepareOpenGL
647	{
648	//[m_pCtx prepareOpenGL];
649	}
650	#endif /* USE_NSOPENGLVIEW */
651
652	/*
653	* Overridden NSOpenGLView / NSView methods:
654	*/
655
656	/** @todo do we need this? */
657	-(void)viewDidMoveToWindow
658	{
659	LogFlow(("OvlView(%p) viewDidMoveToWindow: new win: %p\n", (void )self, (void )[self window]));
660	[super viewDidMoveToWindow];
661	[self vboxReshape];
662	}
663
664	-(void)viewDidMoveToSuperview
665	{
666	LogFlow(("OvlView(%p) viewDidMoveToSuperview: new view: %p\n", (void )self, (void )[self superview]));
667	[super viewDidMoveToSuperview];
668	[self vboxReshape];
669	}
670
671	-(void)resizeWithOldSuperviewSize:(NSSize)oldBoundsSize
672	{
673	LogFlow(("OvlView(%p) resizeWithOldSuperviewSize: %d,%d -> %d,%d\n", (void *)self,
674	(int)oldBoundsSize.width, (int)oldBoundsSize.height, (int)[self bounds].size.width, (int)[self bounds].size.height));
675	[super resizeWithOldSuperviewSize:oldBoundsSize];
676	[self vboxReshape];
677	}
678
679	- (void)drawRect:(NSRect)rect
680	{
681	RT_NOREF(rect);
682	// if (m_fClear)
683	// {
684	// m_fClear = false;
685	// [self vboxClearBuffers];
686	// }
687	}
688
689	@end /* VMSVGA3DOverlayView */
690
691	@implementation VMSVGA3DCreateViewAndContext
692	@end
693
694
695	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaServiceRunLoop(void)
696	{
697	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
698	NSRunLoop *pRunLoop = [NSRunLoop currentRunLoop];
699
700	if ([NSRunLoop mainRunLoop] != pRunLoop)
701	{
702	[pRunLoop runUntilDate:[NSDate distantPast]];
703	}
704
705	[pPool release];
706	}
707
708
709	/**
710	* Document me later.
711	*
712	* @param ppView
713	* @param ppCtx
714	* @param pParentView The parent view if this is a context we'll be
715	* presenting to.
716	* @param cx
717	* @param cy
718	* @param pSharedCtx
719	* @param fOtherProfile
720	*/
721	VMSVGA3DCOCOA_DECL(bool) vmsvga3dCocoaCreateViewAndContext(NativeNSViewRef ppView, NativeNSOpenGLContextRef ppCtx,
722	NativeNSViewRef pParentView, uint32_t cx, uint32_t cy,
723	NativeNSOpenGLContextRef pSharedCtx, bool fOtherProfile)
724	{
725	LogFlow(("vmsvga3dCocoaCreateViewAndContext: pParentView=%d size=%d,%d pSharedCtx=%p fOtherProfile=%RTbool\n",
726	(void )pParentView, cx, cy, (void )pSharedCtx, fOtherProfile));
727	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
728	vmsvga3dCocoaServiceRunLoop();
729
730
731	VMSVGA3DCreateViewAndContext *pParams = [VMSVGA3DCreateViewAndContext alloc];
732	pParams->pParentView = pParentView;
733	pParams->cx = cx;
734	pParams->cy = cy;
735	pParams->pSharedCtx = pSharedCtx;
736	pParams->fOtherProfile = fOtherProfile;
737	pParams->pView = NULL;
738	pParams->pCtx = NULL;
739
740	[VMSVGA3DOverlayView performSelectorOnMainThread:@selector(createViewAndContext:)
741	withObject:pParams
742	waitUntilDone:YES];
743
744	vmsvga3dCocoaServiceRunLoop();
745
746	*ppCtx = pParams->pCtx;
747	*ppView = pParams->pView;
748	bool fRet = ppCtx != NULL && ppView != NULL;
749
750	[pParams release];
751
752	[pPool release];
753	LogFlow(("vmsvga3dCocoaDestroyContext: returns %RTbool\n", fRet));
754	return fRet;
755	}
756
757
758	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaDestroyViewAndContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
759	{
760	LogFlow(("vmsvga3dCocoaDestroyViewAndContext: pView=%p pCtx=%p\n", (void )pView, (void )pCtx));
761	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
762
763	/* The view */
764	VMSVGA3DOverlayView pOvlView = (VMSVGA3DOverlayView )pView;
765	[pOvlView vboxRemoveFromSuperviewAndHide];
766
767	Log(("vmsvga3dCocoaDestroyViewAndContext: view %p ref count=%d\n", (void *)pOvlView, [pOvlView retainCount]));
768	[pOvlView release];
769
770	/* The OpenGL context. */
771	Log(("vmsvga3dCocoaDestroyViewAndContext: ctx %p ref count=%d\n", (void *)pCtx, [pCtx retainCount]));
772	[pCtx release];
773
774	[pPool release];
775	LogFlow(("vmsvga3dCocoaDestroyViewAndContext: returns\n"));
776	}
777
778
779	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewInfo(PCDBGFINFOHLP pHlp, NativeNSViewRef pView)
780	{
781	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
782	if (pView != nil)
783	{
784	VMSVGA3DOverlayView pOvlView = (VMSVGA3DOverlayView )pView;
785
786	NSRect FrameRect = [pOvlView frame];
787	pHlp->pfnPrintf(pHlp, " Frame rect: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
788	FLOAT_FMT_ARGS(FrameRect.origin.x), FLOAT_FMT_ARGS(FrameRect.origin.y),
789	FLOAT_FMT_ARGS(FrameRect.size.width), FLOAT_FMT_ARGS(FrameRect.size.height));
790	NSRect BoundsRect = [pOvlView bounds];
791	pHlp->pfnPrintf(pHlp, " Bounds rect: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
792	FLOAT_FMT_ARGS(BoundsRect.origin.x), FLOAT_FMT_ARGS(BoundsRect.origin.y),
793	FLOAT_FMT_ARGS(BoundsRect.size.width), FLOAT_FMT_ARGS(BoundsRect.size.height));
794	NSRect VisibleRect = [pOvlView visibleRect];
795	pHlp->pfnPrintf(pHlp, " Visible rect: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
796	FLOAT_FMT_ARGS(VisibleRect.origin.x), FLOAT_FMT_ARGS(VisibleRect.origin.y),
797	FLOAT_FMT_ARGS(VisibleRect.size.width), FLOAT_FMT_ARGS(VisibleRect.size.height));
798	pHlp->pfnPrintf(pHlp, " isHidden: %RTbool\n", [pOvlView isHidden] != NO);
799	pHlp->pfnPrintf(pHlp, " canDraw: %RTbool\n", [pOvlView canDraw] != NO);
800	pHlp->pfnPrintf(pHlp, " wantsDefaultClipping: %RTbool\n", [pOvlView wantsDefaultClipping] != NO);
801	pHlp->pfnPrintf(pHlp, " wantsLayer: %RTbool\n", [pOvlView wantsLayer] != NO);
802	if ([pOvlView layer] != nil)
803	pHlp->pfnPrintf(pHlp, " Layer: %p\n", [pOvlView layer] != nil);
804	pHlp->pfnPrintf(pHlp, " isOpaque: %RTbool\n", [pOvlView isOpaque] != NO);
805	pHlp->pfnPrintf(pHlp, " autoresizingMask: %#x\n", [pOvlView autoresizingMask]);
806	pHlp->pfnPrintf(pHlp, " isRotatedOrScaledFromBase: %RTbool\n", [pOvlView isRotatedOrScaledFromBase] != NO);
807
808	NSView *pEnclosingScrollView = [pOvlView enclosingScrollView];
809	NSView *pCurView = [pOvlView superview];
810	uint32_t iLevel;
811	for (iLevel = 1; pCurView && iLevel < 7; iLevel++)
812	{
813	NSView *pNextView = [pCurView superview];
814	pHlp->pfnPrintf(pHlp, " Superview#%u: %p, super=%p\n", iLevel, pCurView, pNextView);
815	FrameRect = [pCurView frame];
816	pHlp->pfnPrintf(pHlp, " Superview#%u frame: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
817	iLevel,
818	FLOAT_FMT_ARGS(FrameRect.origin.x), FLOAT_FMT_ARGS(FrameRect.origin.y),
819	FLOAT_FMT_ARGS(FrameRect.size.width), FLOAT_FMT_ARGS(FrameRect.size.height));
820	BoundsRect = [pCurView bounds];
821	pHlp->pfnPrintf(pHlp, " Superview#%u bounds: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
822	iLevel,
823	FLOAT_FMT_ARGS(BoundsRect.origin.x), FLOAT_FMT_ARGS(BoundsRect.origin.y),
824	FLOAT_FMT_ARGS(BoundsRect.size.width), FLOAT_FMT_ARGS(BoundsRect.size.height));
825	if (pEnclosingScrollView == pCurView)
826	pHlp->pfnPrintf(pHlp, " Superview#%u is enclosing scroll view\n", iLevel);
827	if ([pCurView enclosingScrollView])
828	pHlp->pfnPrintf(pHlp, " Superview#%u has an enclosing scroll view: %p\n", [pCurView enclosingScrollView]);
829	pCurView = pNextView;
830	}
831	if (pCurView)
832	pHlp->pfnPrintf(pHlp, " (There are more super views)\n");
833
834	NSWindow *pWindow = [pOvlView window];
835	if (pWindow != nil)
836	{
837	pHlp->pfnPrintf(pHlp, " Window: %p\n", pWindow);
838	FrameRect = [pWindow frame];
839	pHlp->pfnPrintf(pHlp, " Window frame: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
840	FLOAT_FMT_ARGS(FrameRect.origin.x), FLOAT_FMT_ARGS(FrameRect.origin.y),
841	FLOAT_FMT_ARGS(FrameRect.size.width), FLOAT_FMT_ARGS(FrameRect.size.height));
842	CGFloat rFactor = [pWindow backingScaleFactor];
843	pHlp->pfnPrintf(pHlp, " W.backingScaleFactor: " FLOAT_FMT_STR "\n", FLOAT_FMT_ARGS(rFactor));
844	}
845
846	}
847	[pPool release];
848	}
849
850
851	/** @note Not currently used. */
852	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewSetPosition(NativeNSViewRef pView, NativeNSViewRef pParentView, int x, int y)
853	{
854	RT_NOREF(pParentView);
855	LogFlow(("vmsvga3dCocoaViewSetPosition: pView=%p pParentView=%p (%d,%d)\n", (void )pView, (void )pParentView, x, y));
856	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
857
858	[(VMSVGA3DOverlayView *)pView vboxSetPos:NSMakePoint(x, y)];
859
860	[pPool release];
861	LogFlow(("vmsvga3dCocoaViewSetPosition: returns\n"));
862	}
863
864
865	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewUpdateViewport(NativeNSViewRef pView)
866	{
867	LogFlow(("vmsvga3dCocoaViewSetSize: pView=%p\n", (void *)pView));
868	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
869	VMSVGA3DOverlayView pOverlayView = (VMSVGA3DOverlayView )pView;
870
871	/* Possible that we don't actually need to do this (i.e. this API), but right now I'm
872	leaving it to be sure things actually work right when scrolling. */
873	[pOverlayView vboxScheduleCtxUpdate];
874
875	[pPool release];
876	LogFlow(("vmsvga3dCocoaViewSetSize: returns\n"));
877	}
878
879
880	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewSetSize(NativeNSViewRef pView, int cx, int cy)
881	{
882	LogFlow(("vmsvga3dCocoaViewSetSize: pView=%p (%d,%d)\n", (void *)pView, cx, cy));
883	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
884	VMSVGA3DOverlayView pOverlayView = (VMSVGA3DOverlayView )pView;
885
886	[pOverlayView vboxSetSize:NSMakeSize(cx, cy)];
887
888	[pPool release];
889	LogFlow(("vmsvga3dCocoaViewSetSize: returns\n"));
890	}
891
892
893	void vmsvga3dCocoaViewMakeCurrentContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
894	{
895	LogFlow(("vmsvga3dCocoaViewMakeCurrentContext: pView=%p, pCtx=%p\n", (void)pView, (void)pCtx));
896	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
897	VMSVGA3DOverlayView pOverlayView = (VMSVGA3DOverlayView )pView;
898
899	/* Always flush before flush. glXMakeCurrent and wglMakeCurrent does this
900	implicitly, seemingly NSOpenGLContext::makeCurrentContext doesn't. */
901	if ([NSOpenGLContext currentContext] != 0)
902	glFlush();
903
904	if (pOverlayView)
905	{
906	/* This must be a release assertion as we depend on the setView
907	sideeffect of the openGLContext method call. (hack alert!) */
908	AssertRelease([pOverlayView openGLContext] == pCtx);
909	[pCtx makeCurrentContext];
910	[pOverlayView vboxUpdateCtxIfNecessary];
911	}
912	else
913	[NSOpenGLContext clearCurrentContext];
914
915	[pPool release];
916	LogFlow(("vmsvga3dCocoaViewMakeCurrentContext: returns\n"));
917	}
918
919
920	void vmsvga3dCocoaSwapBuffers(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
921	{
922	LogFlow(("vmsvga3dCocoaSwapBuffers: pView=%p, pCtx=%p\n", (void)pView, (void)pCtx));
923	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
924	VMSVGA3DOverlayView pMyView = (VMSVGA3DOverlayView )pView;
925
926	#ifndef USE_NSOPENGLVIEW
927	/* Hack alert! setView fails early on so call openGLContext to try again. */
928	if ([pCtx view] == NULL)
929	[pMyView openGLContext];
930	#endif
931
932	Assert(pCtx == [NSOpenGLContext currentContext]);
933	Assert(pCtx == [pMyView openGLContext]);
934	AssertMsg([pCtx view] == pMyView, ("%p != %p\n", (void )[pCtx view], (void )pMyView));
935
936	[pCtx flushBuffer];
937	//[pView setNeedsDisplay:YES];
938	vmsvga3dCocoaServiceRunLoop();
939
940	/* If buffer clearing or/and context updates are pending, execute that now. */
941	[pMyView vboxUpdateCtxIfNecessary];
942	[pMyView vboxClearBackBufferIfNecessary];
943
944	[pPool release];
945	LogFlow(("vmsvga3dCocoaSwapBuffers: returns\n"));
946	}
947

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-cocoa.m@ 105982

Download in other formats: