DevVGA-SVGA3d-cocoa.m@ 96407

Last change on this file since 96407 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 33.5 KB

Line
1	/* $Id: DevVGA-SVGA3d-cocoa.m 96407 2022-08-22 17:43:14Z 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-2022 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	[[self openGLContext] update];
381	m_fUpdateCtx = false;
382	}
383	}
384
385
386	- (void)vboxClearBackBufferIfNecessary
387	{
388	#if 1 /* experiment */
389	if (m_cClears > 0)
390	{
391	Assert(![NSThread isMainThread]);
392	Assert([self openGLContext] == [NSOpenGLContext currentContext]);
393	Log(("OvlView(%p) vboxClearBackBufferIfNecessary: m_cClears=%d\n", (void *)self, m_cClears));
394	m_cClears--;
395
396	/* Clear errors. */
397	GLenum rc;
398	while ((rc = glGetError()) != GL_NO_ERROR)
399	continue;
400
401	/* Save the old buffer setting and make it GL_BACK (shall be GL_BACK already actually). */
402	GLint iOldDrawBuf = GL_BACK;
403	glGetIntegerv(GL_DRAW_BUFFER, &iOldDrawBuf);
404	if (iOldDrawBuf != GL_BACK)
405	glDrawBuffer(GL_BACK);
406	while ((rc = glGetError()) != GL_NO_ERROR)
407	AssertMsgFailed(("rc=%x\n", rc));
408
409	/* Clear the current GL_BACK. */
410	glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
411	glClear(GL_COLOR_BUFFER_BIT /\|GL_DEPTH_BUFFER_BIT/ );
412	while ((rc = glGetError()) != GL_NO_ERROR)
413	AssertMsgFailed(("rc=%x\n", rc));
414
415	/* We're back to the orignal back buffer now. Just restore GL_DRAW_BUFFER. */
416	if (iOldDrawBuf != GL_BACK)
417	glDrawBuffer(iOldDrawBuf);
418
419	while ((rc = glGetError()) != GL_NO_ERROR)
420	AssertMsgFailed(("rc=%x\n", rc));
421	}
422	#endif
423	}
424
425
426
427	- (void)vboxReshapePerform
428	{
429	/*
430	* Change the size and position if necessary.
431	*/
432	NSRect CurFrameRect = [self frame];
433	/** @todo conversions? */
434	if ( m_Pos.x != CurFrameRect.origin.x
435	\|\| m_Pos.y != CurFrameRect.origin.y)
436	{
437	LogFlow(("OvlView(%p) vboxReshapePerform: moving (%d,%d) -> (%d,%d)\n",
438	(void *)self, CurFrameRect.origin.x, CurFrameRect.origin.y, m_Pos.x, m_Pos.y));
439	[self setFrameOrigin:m_Pos];
440	}
441
442	if ( CurFrameRect.size.width != m_Size.width
443	\|\| CurFrameRect.size.height != m_Size.height)
444	{
445	LogFlow(("OvlView(%p) vboxReshapePerform: resizing (%d,%d) -> (%d,%d)\n",
446	(void *)self, CurFrameRect.size.width, CurFrameRect.size.height, m_Size.width, m_Size.height));
447	[self setFrameSize:m_Size];
448
449	/*
450	* Schedule two clears and a context update for now.
451	* Really though, we should just clear any new surface area.
452	*/
453	m_cClears = 2;
454	}
455	m_fUpdateCtx = true;
456	LogFlow(("OvlView(%p) vboxReshapePerform: returns\n", self));
457	}
458
459
460	- (void)vboxReshape
461	{
462	LogFlow(("OvlView(%p) vboxReshape:\n", (void *)self));
463
464	/*
465	* Resize the view.
466	*/
467	if ([NSThread isMainThread])
468	[self vboxReshapePerform];
469	else
470	{
471	[self performSelectorOnMainThread:@selector(vboxReshapePerform) withObject:nil waitUntilDone:NO];
472	vmsvga3dCocoaServiceRunLoop();
473
474	/*
475	* Try update the opengl context.
476	*/
477	[[self openGLContext] update];
478	}
479
480	LogFlow(("OvlView(%p) vboxReshape: returns\n", (void *)self));
481	}
482
483	/**
484	* This is called when the bounds change.
485	*
486	* We indicate that the FIFO thread must update the GL context.
487	*/
488	- (void)vboxBoundsDidChange:(NSNotification *)pNotification
489	{
490	RT_NOREF(pNotification);
491	LogFlow(("OvlView(%p) vboxBoundsDidChange:\n", (void *)self));
492	self->m_fUpdateCtx = true;
493	}
494
495	/**
496	* This is called when the frame changes size or position.
497	*
498	* We indicate that the FIFO thread must update the GL context.
499	*/
500	- (void)vboxFrameDidChange:(NSNotification *)pNotification
501	{
502	RT_NOREF(pNotification);
503	LogFlow(("OvlView(%p) vboxFrameDidChange:\n", (void *)self));
504	self->m_fUpdateCtx = true;
505	}
506
507	/**
508	* This is called when moved to different screen/GPU or/and when the GL context
509	* needs updating.
510	*
511	* We indicate that the FIFO thread must update the GL context.
512	*/
513	- (void)vboxFrameDidChangeGlobal:(NSNotification *)pNotification
514	{
515	RT_NOREF(pNotification);
516	LogFlow(("OvlView(%p) vboxFrameDidChangeGlobal:\n", (void *)self));
517	self->m_fUpdateCtx = true;
518	}
519
520	/** This enables the vboxFrameDidChange notification. */
521	- (BOOL)postsFrameChangedNotifications
522	{
523	LogFlow(("OvlView(%p) postsFrameChangedNotifications:\n", (void *)self));
524	return YES;
525	}
526
527	/**
528	* Removes the view from the parent, if it has one, and makes sure it's hidden.
529	*
530	* This is callbed before destroying it.
531	*/
532	- (void)vboxRemoveFromSuperviewAndHide
533	{
534	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide:\n", (void *)self));
535	if (m_pParentView)
536	{
537	/*
538	* The removeFromSuperview has been frequently seen to deadlock thing like this:
539	* #0 0x00007fff8db440fa in __psynch_cvwait ()
540	* #1 0x00007fff8d0acfb9 in _pthread_cond_wait ()
541	* #2 0x00007fff8a1bc8f0 in -[NSViewHierarchyLock _lockForWriting:handler:] ()
542	* #3 0x00007fff8a1bc171 in -[NSView removeFromSuperview] ()
543	* #4 0x000000010cffb2bb in -[VMSVGA3DOverlayView vboxRemoveFromSuperviewAndHide] (self=0x10a1da550, _cmd=0x10cffd734) at DevVGA-SVGA3d-cocoa.m:467
544	* #5 0x000000010cffbed3 in vmsvga3dCocoaDestroyViewAndContext (pView=0x10a1da550, pCtx=0x10a1da630) at DevVGA-SVGA3d-cocoa.m:662
545	* (This is from OS X 10.8.5.)
546	*/
547	if ([NSThread isMainThread])
548	{
549	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: calling removeFromSuperview\n", (void *)self));
550	[self removeFromSuperview];
551	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: calling setHidden\n", (void *)self));
552	[self setHidden:YES];
553	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: calling setHidden\n", (void *)self));
554	[[NSNotificationCenter defaultCenter] removeObserver:self];
555	}
556	else
557	{
558	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: defering to main thread\n", (void *)self));
559	vmsvga3dCocoaServiceRunLoop();
560	[self performSelectorOnMainThread:@selector(vboxRemoveFromSuperviewAndHide) withObject:nil waitUntilDone:YES];
561	vmsvga3dCocoaServiceRunLoop();
562	LogFlow(("OvlView(%p) vboxRemoveFromSuperviewAndHide: main thread done\n", (void *)self));
563	}
564	}
565	}
566
567
568	/**
569	* Changes to the OpenGL context associated with the view.
570	* @returns Previous OpenGL context.
571	*/
572	- (NSOpenGLContext *)makeCurrentGLContext
573	{
574	NSOpenGLContext *pSavedCtx = [NSOpenGLContext currentContext];
575
576	/* Always flush before changing. glXMakeCurrent and wglMakeCurrent does this
577	implicitly, seemingly NSOpenGLContext::makeCurrentContext doesn't. */
578	if (pSavedCtx != nil)
579	glFlush();
580
581	[[self openGLContext] makeCurrentContext];
582	return pSavedCtx;
583	}
584
585
586	/**
587	* Restores the previous OpenGL context after
588	* makeCurrentGLContext.
589	*
590	* @param pSavedCtx The makeCurrentGLContext return value.
591	*/
592	- (void)restoreSavedGLContext:(NSOpenGLContext *)pSavedCtx
593	{
594	/* Always flush before changing. glXMakeCurrent and wglMakeCurrent does this
595	implicitly, seemingly NSOpenGLContext::makeCurrentContext doesn't. */
596	glFlush();
597
598	if (pSavedCtx)
599	[pSavedCtx makeCurrentContext];
600	else
601	[NSOpenGLContext clearCurrentContext];
602	}
603
604	#ifndef USE_NSOPENGLVIEW
605	/*
606	* Faking NSOpenGLView interface.
607	*/
608	- (void)setOpenGLContext:(NSOpenGLContext *)pCtx
609	{
610	if (pCtx != m_pCtx)
611	{
612	if (pCtx)
613	{
614	[pCtx retain];
615	[pCtx setView:self];
616	/Assert([pCtx view] == self); - setView fails early on, works later... /
617	}
618
619	if (m_pCtx)
620	[m_pCtx release];
621
622	m_pCtx = pCtx;
623
624	if (pCtx)
625	[pCtx update];
626	}
627	}
628
629	- (NSOpenGLContext *)openGLContext
630	{
631	/* Stupid hacks to work around setView failing early. This can get kind of
632	noisy on some OS versions, so shut it up a little bit. */
633	/** @todo use NSOpenGLView for the non-visible contexts. */
634	if (m_pCtx && [m_pCtx view] != self)
635	{
636	m_cSetViewAttempts++;
637	if ( m_pParentView
638	\|\| m_cSetViewAttempts < 64
639	\|\| (m_cSetViewAttempts & (m_cSetViewAttempts < _64K ? 0xfff : 0x7fff)) == 0 )
640	[m_pCtx setView:self];
641	}
642	return m_pCtx;
643	}
644
645	- (void)prepareOpenGL
646	{
647	//[m_pCtx prepareOpenGL];
648	}
649	#endif /* USE_NSOPENGLVIEW */
650
651	/*
652	* Overridden NSOpenGLView / NSView methods:
653	*/
654
655	/** @todo do we need this? */
656	-(void)viewDidMoveToWindow
657	{
658	LogFlow(("OvlView(%p) viewDidMoveToWindow: new win: %p\n", (void )self, (void )[self window]));
659	[super viewDidMoveToWindow];
660	[self vboxReshape];
661	}
662
663	-(void)viewDidMoveToSuperview
664	{
665	LogFlow(("OvlView(%p) viewDidMoveToSuperview: new view: %p\n", (void )self, (void )[self superview]));
666	[super viewDidMoveToSuperview];
667	[self vboxReshape];
668	}
669
670	-(void)resizeWithOldSuperviewSize:(NSSize)oldBoundsSize
671	{
672	LogFlow(("OvlView(%p) resizeWithOldSuperviewSize: %d,%d -> %d,%d\n", (void *)self,
673	(int)oldBoundsSize.width, (int)oldBoundsSize.height, (int)[self bounds].size.width, (int)[self bounds].size.height));
674	[super resizeWithOldSuperviewSize:oldBoundsSize];
675	[self vboxReshape];
676	}
677
678	- (void)drawRect:(NSRect)rect
679	{
680	RT_NOREF(rect);
681	// if (m_fClear)
682	// {
683	// m_fClear = false;
684	// [self vboxClearBuffers];
685	// }
686	}
687
688	@end /* VMSVGA3DOverlayView */
689
690	@implementation VMSVGA3DCreateViewAndContext
691	@end
692
693
694	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaServiceRunLoop(void)
695	{
696	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
697	NSRunLoop *pRunLoop = [NSRunLoop currentRunLoop];
698
699	if ([NSRunLoop mainRunLoop] != pRunLoop)
700	{
701	[pRunLoop runUntilDate:[NSDate distantPast]];
702	}
703
704	[pPool release];
705	}
706
707
708	/**
709	* Document me later.
710	*
711	* @param ppView
712	* @param ppCtx
713	* @param pParentView The parent view if this is a context we'll be
714	* presenting to.
715	* @param cx
716	* @param cy
717	* @param pSharedCtx
718	* @param fOtherProfile
719	*/
720	VMSVGA3DCOCOA_DECL(bool) vmsvga3dCocoaCreateViewAndContext(NativeNSViewRef ppView, NativeNSOpenGLContextRef ppCtx,
721	NativeNSViewRef pParentView, uint32_t cx, uint32_t cy,
722	NativeNSOpenGLContextRef pSharedCtx, bool fOtherProfile)
723	{
724	LogFlow(("vmsvga3dCocoaCreateViewAndContext: pParentView=%d size=%d,%d pSharedCtx=%p fOtherProfile=%RTbool\n",
725	(void )pParentView, cx, cy, (void )pSharedCtx, fOtherProfile));
726	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
727	vmsvga3dCocoaServiceRunLoop();
728
729
730	VMSVGA3DCreateViewAndContext *pParams = [VMSVGA3DCreateViewAndContext alloc];
731	pParams->pParentView = pParentView;
732	pParams->cx = cx;
733	pParams->cy = cy;
734	pParams->pSharedCtx = pSharedCtx;
735	pParams->fOtherProfile = fOtherProfile;
736	pParams->pView = NULL;
737	pParams->pCtx = NULL;
738
739	[VMSVGA3DOverlayView performSelectorOnMainThread:@selector(createViewAndContext:)
740	withObject:pParams
741	waitUntilDone:YES];
742
743	vmsvga3dCocoaServiceRunLoop();
744
745	*ppCtx = pParams->pCtx;
746	*ppView = pParams->pView;
747	bool fRet = ppCtx != NULL && ppView != NULL;
748
749	[pParams release];
750
751	[pPool release];
752	LogFlow(("vmsvga3dCocoaDestroyContext: returns %RTbool\n", fRet));
753	return fRet;
754	}
755
756
757	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaDestroyViewAndContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
758	{
759	LogFlow(("vmsvga3dCocoaDestroyViewAndContext: pView=%p pCtx=%p\n", (void )pView, (void )pCtx));
760	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
761
762	/* The view */
763	VMSVGA3DOverlayView pOvlView = (VMSVGA3DOverlayView )pView;
764	[pOvlView vboxRemoveFromSuperviewAndHide];
765
766	Log(("vmsvga3dCocoaDestroyViewAndContext: view %p ref count=%d\n", (void *)pOvlView, [pOvlView retainCount]));
767	[pOvlView release];
768
769	/* The OpenGL context. */
770	Log(("vmsvga3dCocoaDestroyViewAndContext: ctx %p ref count=%d\n", (void *)pCtx, [pCtx retainCount]));
771	[pCtx release];
772
773	[pPool release];
774	LogFlow(("vmsvga3dCocoaDestroyViewAndContext: returns\n"));
775	}
776
777
778	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewInfo(PCDBGFINFOHLP pHlp, NativeNSViewRef pView)
779	{
780	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
781	if (pView != nil)
782	{
783	VMSVGA3DOverlayView pOvlView = (VMSVGA3DOverlayView )pView;
784
785	NSRect FrameRect = [pOvlView frame];
786	pHlp->pfnPrintf(pHlp, " Frame rect: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
787	FLOAT_FMT_ARGS(FrameRect.origin.x), FLOAT_FMT_ARGS(FrameRect.origin.y),
788	FLOAT_FMT_ARGS(FrameRect.size.width), FLOAT_FMT_ARGS(FrameRect.size.height));
789	NSRect BoundsRect = [pOvlView bounds];
790	pHlp->pfnPrintf(pHlp, " Bounds rect: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
791	FLOAT_FMT_ARGS(BoundsRect.origin.x), FLOAT_FMT_ARGS(BoundsRect.origin.y),
792	FLOAT_FMT_ARGS(BoundsRect.size.width), FLOAT_FMT_ARGS(BoundsRect.size.height));
793	NSRect VisibleRect = [pOvlView visibleRect];
794	pHlp->pfnPrintf(pHlp, " Visible rect: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
795	FLOAT_FMT_ARGS(VisibleRect.origin.x), FLOAT_FMT_ARGS(VisibleRect.origin.y),
796	FLOAT_FMT_ARGS(VisibleRect.size.width), FLOAT_FMT_ARGS(VisibleRect.size.height));
797	pHlp->pfnPrintf(pHlp, " isHidden: %RTbool\n", [pOvlView isHidden] != NO);
798	pHlp->pfnPrintf(pHlp, " canDraw: %RTbool\n", [pOvlView canDraw] != NO);
799	pHlp->pfnPrintf(pHlp, " wantsDefaultClipping: %RTbool\n", [pOvlView wantsDefaultClipping] != NO);
800	pHlp->pfnPrintf(pHlp, " wantsLayer: %RTbool\n", [pOvlView wantsLayer] != NO);
801	if ([pOvlView layer] != nil)
802	pHlp->pfnPrintf(pHlp, " Layer: %p\n", [pOvlView layer] != nil);
803	pHlp->pfnPrintf(pHlp, " isOpaque: %RTbool\n", [pOvlView isOpaque] != NO);
804	pHlp->pfnPrintf(pHlp, " autoresizingMask: %#x\n", [pOvlView autoresizingMask]);
805	pHlp->pfnPrintf(pHlp, " isRotatedOrScaledFromBase: %RTbool\n", [pOvlView isRotatedOrScaledFromBase] != NO);
806
807	NSView *pEnclosingScrollView = [pOvlView enclosingScrollView];
808	NSView *pCurView = [pOvlView superview];
809	uint32_t iLevel;
810	for (iLevel = 1; pCurView && iLevel < 7; iLevel++)
811	{
812	NSView *pNextView = [pCurView superview];
813	pHlp->pfnPrintf(pHlp, " Superview#%u: %p, super=%p\n", iLevel, pCurView, pNextView);
814	FrameRect = [pCurView frame];
815	pHlp->pfnPrintf(pHlp, " Superview#%u frame: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
816	iLevel,
817	FLOAT_FMT_ARGS(FrameRect.origin.x), FLOAT_FMT_ARGS(FrameRect.origin.y),
818	FLOAT_FMT_ARGS(FrameRect.size.width), FLOAT_FMT_ARGS(FrameRect.size.height));
819	BoundsRect = [pCurView bounds];
820	pHlp->pfnPrintf(pHlp, " Superview#%u bounds: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
821	iLevel,
822	FLOAT_FMT_ARGS(BoundsRect.origin.x), FLOAT_FMT_ARGS(BoundsRect.origin.y),
823	FLOAT_FMT_ARGS(BoundsRect.size.width), FLOAT_FMT_ARGS(BoundsRect.size.height));
824	if (pEnclosingScrollView == pCurView)
825	pHlp->pfnPrintf(pHlp, " Superview#%u is enclosing scroll view\n", iLevel);
826	if ([pCurView enclosingScrollView])
827	pHlp->pfnPrintf(pHlp, " Superview#%u has an enclosing scroll view: %p\n", [pCurView enclosingScrollView]);
828	pCurView = pNextView;
829	}
830	if (pCurView)
831	pHlp->pfnPrintf(pHlp, " (There are more super views)\n");
832
833	NSWindow *pWindow = [pOvlView window];
834	if (pWindow != nil)
835	{
836	pHlp->pfnPrintf(pHlp, " Window: %p\n", pWindow);
837	FrameRect = [pWindow frame];
838	pHlp->pfnPrintf(pHlp, " Window frame: x=" FLOAT_FMT_STR ", y=" FLOAT_FMT_STR " cx=" FLOAT_FMT_STR ", cy=" FLOAT_FMT_STR "\n",
839	FLOAT_FMT_ARGS(FrameRect.origin.x), FLOAT_FMT_ARGS(FrameRect.origin.y),
840	FLOAT_FMT_ARGS(FrameRect.size.width), FLOAT_FMT_ARGS(FrameRect.size.height));
841	CGFloat rFactor = [pWindow backingScaleFactor];
842	pHlp->pfnPrintf(pHlp, " W.backingScaleFactor: " FLOAT_FMT_STR "\n", FLOAT_FMT_ARGS(rFactor));
843	}
844
845	}
846	[pPool release];
847	}
848
849
850	/** @note Not currently used. */
851	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewSetPosition(NativeNSViewRef pView, NativeNSViewRef pParentView, int x, int y)
852	{
853	RT_NOREF(pParentView);
854	LogFlow(("vmsvga3dCocoaViewSetPosition: pView=%p pParentView=%p (%d,%d)\n", (void )pView, (void )pParentView, x, y));
855	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
856
857	[(VMSVGA3DOverlayView *)pView vboxSetPos:NSMakePoint(x, y)];
858
859	[pPool release];
860	LogFlow(("vmsvga3dCocoaViewSetPosition: returns\n"));
861	}
862
863
864	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewUpdateViewport(NativeNSViewRef pView)
865	{
866	LogFlow(("vmsvga3dCocoaViewSetSize: pView=%p\n", (void *)pView));
867	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
868	VMSVGA3DOverlayView pOverlayView = (VMSVGA3DOverlayView )pView;
869
870	/* Possible that we don't actually need to do this (i.e. this API), but right now I'm
871	leaving it to be sure things actually work right when scrolling. */
872	[pOverlayView vboxScheduleCtxUpdate];
873
874	[pPool release];
875	LogFlow(("vmsvga3dCocoaViewSetSize: returns\n"));
876	}
877
878
879	VMSVGA3DCOCOA_DECL(void) vmsvga3dCocoaViewSetSize(NativeNSViewRef pView, int cx, int cy)
880	{
881	LogFlow(("vmsvga3dCocoaViewSetSize: pView=%p (%d,%d)\n", (void *)pView, cx, cy));
882	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
883	VMSVGA3DOverlayView pOverlayView = (VMSVGA3DOverlayView )pView;
884
885	[pOverlayView vboxSetSize:NSMakeSize(cx, cy)];
886
887	[pPool release];
888	LogFlow(("vmsvga3dCocoaViewSetSize: returns\n"));
889	}
890
891
892	void vmsvga3dCocoaViewMakeCurrentContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
893	{
894	LogFlow(("vmsvga3dCocoaViewMakeCurrentContext: pView=%p, pCtx=%p\n", (void)pView, (void)pCtx));
895	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
896	VMSVGA3DOverlayView pOverlayView = (VMSVGA3DOverlayView )pView;
897
898	/* Always flush before flush. glXMakeCurrent and wglMakeCurrent does this
899	implicitly, seemingly NSOpenGLContext::makeCurrentContext doesn't. */
900	if ([NSOpenGLContext currentContext] != 0)
901	glFlush();
902
903	if (pOverlayView)
904	{
905	/* This must be a release assertion as we depend on the setView
906	sideeffect of the openGLContext method call. (hack alert!) */
907	AssertRelease([pOverlayView openGLContext] == pCtx);
908	[pCtx makeCurrentContext];
909	[pOverlayView vboxUpdateCtxIfNecessary];
910	}
911	else
912	[NSOpenGLContext clearCurrentContext];
913
914	[pPool release];
915	LogFlow(("vmsvga3dCocoaViewMakeCurrentContext: returns\n"));
916	}
917
918
919	void vmsvga3dCocoaSwapBuffers(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx)
920	{
921	LogFlow(("vmsvga3dCocoaSwapBuffers: pView=%p, pCtx=%p\n", (void)pView, (void)pCtx));
922	NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
923	VMSVGA3DOverlayView pMyView = (VMSVGA3DOverlayView )pView;
924
925	#ifndef USE_NSOPENGLVIEW
926	/* Hack alert! setView fails early on so call openGLContext to try again. */
927	if ([pCtx view] == NULL)
928	[pMyView openGLContext];
929	#endif
930
931	Assert(pCtx == [NSOpenGLContext currentContext]);
932	Assert(pCtx == [pMyView openGLContext]);
933	AssertMsg([pCtx view] == pMyView, ("%p != %p\n", (void )[pCtx view], (void )pMyView));
934
935	[pCtx flushBuffer];
936	//[pView setNeedsDisplay:YES];
937	vmsvga3dCocoaServiceRunLoop();
938
939	/* If buffer clearing or/and context updates are pending, execute that now. */
940	[pMyView vboxUpdateCtxIfNecessary];
941	[pMyView vboxClearBackBufferIfNecessary];
942
943	[pPool release];
944	LogFlow(("vmsvga3dCocoaSwapBuffers: returns\n"));
945	}
946

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

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

Download in other formats: