DevVGA-SVGA3d-cocoa.m@ 62463

Last change on this file since 62463 was 62463, checked in by vboxsync, 8 years ago
Devices: scm
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 32.9 KB

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

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

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

Download in other formats: