[Libreoffice-commits] core.git: avmedia/source include/vcl slideshow/source vcl/headless vcl/inc vcl/opengl vcl/osx vcl/source
Caolán McNamara
caolanm at redhat.com
Sat May 21 09:04:42 UTC 2016
avmedia/source/viewer/mediawindow_impl.cxx | 2
include/vcl/opengl/OpenGLContext.hxx | 50
slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx | 28
slideshow/source/engine/shapes/viewmediashape.cxx | 2
vcl/headless/svpinst.cxx | 11
vcl/inc/headless/svpinst.hxx | 2
vcl/inc/opengl/zone.hxx | 6
vcl/inc/osx/salinst.h | 1
vcl/inc/salinst.hxx | 3
vcl/inc/unx/salinst.h | 1
vcl/inc/win/salinst.h | 1
vcl/opengl/win/gdiimpl.cxx | 479 ++++
vcl/opengl/x11/gdiimpl.cxx | 556 +++++
vcl/osx/salobj.cxx | 109 +
vcl/source/opengl/OpenGLContext.cxx | 1074 ----------
vcl/source/window/openglwin.cxx | 2
16 files changed, 1230 insertions(+), 1097 deletions(-)
New commits:
commit b8d163f4334424e78290eae49713e6ba2405b30f
Author: Caolán McNamara <caolanm at redhat.com>
Date: Fri May 20 09:41:18 2016 +0100
Split OpenGLContext up into SalInstance specific classes
which, at least theoretically, allows there to be vclplug
specific ones. i.e. a gtk3 specific one which doesn't
assume gtk3 is running under X
Change-Id: I6c007a87abbd3049b6fffc70d349e3b7ac445eec
diff --git a/avmedia/source/viewer/mediawindow_impl.cxx b/avmedia/source/viewer/mediawindow_impl.cxx
index 87080ba..1bd55af 100644
--- a/avmedia/source/viewer/mediawindow_impl.cxx
+++ b/avmedia/source/viewer/mediawindow_impl.cxx
@@ -489,7 +489,7 @@ void MediaWindowImpl::onURLChanged()
#if HAVE_FEATURE_GLTF
else if (m_sMimeType == AVMEDIA_MIMETYPE_JSON)
{
- SystemWindowData aWinData = OpenGLContext::generateWinData(this, false);
+ SystemWindowData aWinData = OpenGLContext::Create()->generateWinData(this, false);
mpChildWindow.disposeAndClear();
mpChildWindow.reset(VclPtr<MediaChildWindow>::Create(this,&aWinData));
mbEventTransparent = false;
diff --git a/include/vcl/opengl/OpenGLContext.hxx b/include/vcl/opengl/OpenGLContext.hxx
index 1ca86c7..0036849 100644
--- a/include/vcl/opengl/OpenGLContext.hxx
+++ b/include/vcl/opengl/OpenGLContext.hxx
@@ -65,7 +65,7 @@ class OpenGLTests;
class RenderState;
/// Holds the information of our new child window
-struct GLWindow
+struct VCL_DLLPUBLIC GLWindow
{
#if defined( _WIN32 )
HWND hWnd;
@@ -121,16 +121,19 @@ struct GLWindow
{
}
+ bool Synchronize(bool bOnoff) const;
+
~GLWindow();
};
class VCL_DLLPUBLIC OpenGLContext
{
friend class OpenGLTests;
+protected:
OpenGLContext();
public:
static rtl::Reference<OpenGLContext> Create();
- ~OpenGLContext();
+ virtual ~OpenGLContext();
void acquire() { mnRefCount++; }
void release() { if ( --mnRefCount == 0 ) delete this; }
void dispose();
@@ -141,13 +144,6 @@ public:
bool init(vcl::Window* pParent = nullptr);
bool init(SystemChildWindow* pChildWindow);
-// these methods are for the deep platform layer, don't use them in normal code
-// only in vcl's platform code
-#if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID && !defined(LIBO_HEADLESS)
- bool init(Display* dpy, Window win, int screen);
-#elif defined( _WIN32 )
- bool init( HDC hDC, HWND hWnd );
-#endif
void reset();
// use these methods right after setting a context to make sure drawing happens
@@ -173,7 +169,9 @@ public:
}
/// Is this GL context the current context ?
- bool isCurrent();
+ virtual bool isCurrent();
+ /// Is any GL context the current context ?
+ virtual bool isAnyCurrent();
/// release bound resources from the current context
static void clearCurrent();
/// release contexts etc. before (potentially) allowing another thread run.
@@ -186,13 +184,13 @@ public:
/// fetch any VCL context, creating one if bMakeIfNecessary is set.
static rtl::Reference<OpenGLContext> getVCLContext(bool bMakeIfNecessary = true);
/// make this GL context current - so it is implicit in subsequent GL calls
- void makeCurrent();
+ virtual void makeCurrent();
/// Put this GL context to the end of the context list.
void registerAsCurrent();
/// reset the GL context so this context is not implicit in subsequent GL calls.
- void resetCurrent();
- void swapBuffers();
- void sync();
+ virtual void resetCurrent();
+ virtual void swapBuffers();
+ virtual void sync();
void show();
void setWinPosAndSize(const Point &rPos, const Size& rSize);
@@ -213,23 +211,20 @@ public:
bool supportMultiSampling() const;
- static SystemWindowData generateWinData(vcl::Window* pParent, bool bRequestLegacyContext);
+ virtual SystemWindowData generateWinData(vcl::Window* pParent, bool bRequestLegacyContext);
private:
- SAL_DLLPRIVATE bool InitGLEW();
- SAL_DLLPRIVATE void InitGLEWDebugging();
- SAL_DLLPRIVATE bool initWindow();
- SAL_DLLPRIVATE bool ImplInit();
- SAL_DLLPRIVATE void InitChildWindow(SystemChildWindow *pChildWindow);
-#if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID && !defined(LIBO_HEADLESS)
- SAL_DLLPRIVATE void initGLWindow(Visual* pVisual);
-#endif
-
-#if defined(MACOSX)
- NSOpenGLView* getOpenGLView();
-#endif
+ virtual bool initWindow();
+ virtual void destroyCurrentContext();
+protected:
GLWindow m_aGLWin;
+ bool InitGLEW();
+ void InitGLEWDebugging();
+ void InitChildWindow(SystemChildWindow *pChildWindow);
+ void BuffersSwapped();
+ virtual bool ImplInit();
+
VclPtr<vcl::Window> m_xWindow;
VclPtr<vcl::Window> mpWindow; //points to m_pWindow or the parent window, don't delete it
VclPtr<SystemChildWindow> m_pChildWindow;
@@ -244,6 +239,7 @@ private:
OpenGLFramebuffer* mpFirstFramebuffer;
OpenGLFramebuffer* mpLastFramebuffer;
+private:
struct ProgramHash
{
size_t operator()( const rtl::OString& aDigest ) const
diff --git a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx
index 5ba940f..fa4df10 100644
--- a/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx
+++ b/slideshow/source/engine/OGLTrans/generic/OGLTrans_TransitionerImpl.cxx
@@ -67,11 +67,6 @@
#include "OGLTrans_TransitionImpl.hxx"
-#if defined( UNX ) && !defined( MACOSX )
- #include <X11/keysym.h>
- #include <X11/X.h>
-#endif
-
#include <vcl/sysdata.hxx>
#if OSL_DEBUG_LEVEL > 0
@@ -257,9 +252,7 @@ private:
bool mbFreeLeavingPixmap;
bool mbFreeEnteringPixmap;
#endif
-#if defined( UNX ) && !defined( MACOSX )
bool mbRestoreSync;
-#endif
bool mbUseLeavingPixmap;
bool mbUseEnteringPixmap;
@@ -437,10 +430,9 @@ void OGLTransitionerImpl::impl_prepareSlides()
mbUseLeavingPixmap = false;
mbUseEnteringPixmap = false;
-#if defined( GLX_EXT_texture_from_pixmap )
-
const GLWindow& rGLWindow(mpContext->getOpenGLWindow());
+#if defined( GLX_EXT_texture_from_pixmap )
if( GLXEW_EXT_texture_from_pixmap && xLeavingSet.is() && xEnteringSet.is() && mbHasTFPVisual ) {
Sequence< Any > leaveArgs;
Sequence< Any > enterArgs;
@@ -509,8 +501,8 @@ void OGLTransitionerImpl::impl_prepareSlides()
XSetErrorHandler( oldHandler );
}
}
-
#endif
+
if( !mbUseLeavingPixmap )
maLeavingBytes = mxLeavingBitmap->getData(maSlideBitmapLayout, aSlideRect);
if( !mbUseEnteringPixmap )
@@ -524,13 +516,11 @@ void OGLTransitionerImpl::impl_prepareSlides()
mpContext->sync();
CHECK_GL_ERROR();
-#if defined( UNX ) && !defined( MACOSX )
+
// synchronized X still gives us much smoother play
// I suspect some issues in above code in slideshow
// synchronize whole transition for now
- XSynchronize( rGLWindow.dpy, true );
- mbRestoreSync = true;
-#endif
+ mbRestoreSync = rGLWindow.Synchronize(true);
}
bool OGLTransitionerImpl::impl_prepareTransition()
@@ -1326,13 +1316,11 @@ void OGLTransitionerImpl::disposing()
}
#endif
-#if defined( UNX ) && !defined( MACOSX )
- if( mbRestoreSync && bool(mpContext.is()) ) {
+ if (mbRestoreSync && bool(mpContext.is())) {
// try to reestablish synchronize state
- char* sal_synchronize = getenv("SAL_SYNCHRONIZE");
- XSynchronize( mpContext->getOpenGLWindow().dpy, sal_synchronize && *sal_synchronize == '1' );
+ const char* sal_synchronize = getenv("SAL_SYNCHRONIZE");
+ mpContext->getOpenGLWindow().Synchronize(sal_synchronize && *sal_synchronize == '1' );
}
-#endif
impl_dispose();
@@ -1359,9 +1347,7 @@ OGLTransitionerImpl::OGLTransitionerImpl()
, mbFreeLeavingPixmap(false)
, mbFreeEnteringPixmap(false)
#endif
-#if defined( UNX ) && !defined( MACOSX )
, mbRestoreSync(false)
-#endif
, mbUseLeavingPixmap(false)
, mbUseEnteringPixmap(false)
, maSlideBitmapLayout()
diff --git a/slideshow/source/engine/shapes/viewmediashape.cxx b/slideshow/source/engine/shapes/viewmediashape.cxx
index e0c30a2..0db3ea6 100644
--- a/slideshow/source/engine/shapes/viewmediashape.cxx
+++ b/slideshow/source/engine/shapes/viewmediashape.cxx
@@ -463,7 +463,7 @@ namespace slideshow
Size( aAWTRect.Width, aAWTRect.Height ) );
mpEventHandlerParent->EnablePaint(false);
mpEventHandlerParent->Show();
- SystemWindowData aWinData = OpenGLContext::generateWinData(mpEventHandlerParent.get(), false);
+ SystemWindowData aWinData = OpenGLContext::Create()->generateWinData(mpEventHandlerParent.get(), false);
mpMediaWindow = VclPtr<SystemChildWindow>::Create(mpEventHandlerParent.get(), 0, &aWinData);
mpMediaWindow->SetPosSizePixel( Point( 0, 0 ),
Size( aAWTRect.Width, aAWTRect.Height ) );
diff --git a/vcl/headless/svpinst.cxx b/vcl/headless/svpinst.cxx
index 0bd50fe..2665bb5 100644
--- a/vcl/headless/svpinst.cxx
+++ b/vcl/headless/svpinst.cxx
@@ -27,6 +27,7 @@
#include <sal/types.h>
#include <vcl/inputtypes.hxx>
+#include <vcl/opengl/OpenGLContext.hxx>
#include <headless/svpinst.hxx>
#include <headless/svpframe.hxx>
@@ -443,6 +444,16 @@ void SvpSalInstance::AddToRecentDocumentList(const OUString&, const OUString&, c
{
}
+//obviously doesn't actually do anything, its just a nonfunctional stub
+class SvpOpenGLContext : public OpenGLContext
+{
+};
+
+OpenGLContext* SvpSalInstance::CreateOpenGLContext()
+{
+ return new SvpOpenGLContext;
+}
+
SvpSalTimer::~SvpSalTimer()
{
}
diff --git a/vcl/inc/headless/svpinst.hxx b/vcl/inc/headless/svpinst.hxx
index ae23d71..932e928 100644
--- a/vcl/inc/headless/svpinst.hxx
+++ b/vcl/inc/headless/svpinst.hxx
@@ -163,6 +163,8 @@ public:
// may return NULL to disable session management
virtual SalSession* CreateSalSession() override;
+ virtual OpenGLContext* CreateOpenGLContext() override;
+
virtual void* GetConnectionIdentifier( ConnectionIdentifierType& rReturnedType, int& rReturnedBytes ) override;
virtual void AddToRecentDocumentList(const OUString& rFileUrl, const OUString& rMimeType, const OUString& rDocumentService) override;
diff --git a/vcl/inc/opengl/zone.hxx b/vcl/inc/opengl/zone.hxx
index c6ba0ccc7..11f6ed0 100644
--- a/vcl/inc/opengl/zone.hxx
+++ b/vcl/inc/opengl/zone.hxx
@@ -21,7 +21,7 @@ class OpenGLWatchdogThread;
* We want to be able to detect if a given crash came
* from the OpenGL code, so use this helper to track that.
*/
-class OpenGLZone {
+class VCL_DLLPUBLIC OpenGLZone {
friend class OpenGLZoneTest;
friend class OpenGLWatchdogThread;
friend class OpenGLSalGraphicsImpl;
@@ -31,8 +31,8 @@ class OpenGLZone {
/// how many times have we left a new GL zone
static volatile sal_uInt64 gnLeaveCount;
- static VCL_DLLPUBLIC void enter();
- static VCL_DLLPUBLIC void leave();
+ static void enter();
+ static void leave();
public:
OpenGLZone() { gnEnterCount++; }
~OpenGLZone() { gnLeaveCount++; }
diff --git a/vcl/inc/osx/salinst.h b/vcl/inc/osx/salinst.h
index 20f3e3e..6144825 100644
--- a/vcl/inc/osx/salinst.h
+++ b/vcl/inc/osx/salinst.h
@@ -117,6 +117,7 @@ public:
virtual SalMenuItem* CreateMenuItem( const SalItemParams* pItemData ) override;
virtual void DestroyMenuItem( SalMenuItem* ) override;
virtual SalSession* CreateSalSession() override;
+ virtual OpenGLContext* CreateOpenGLContext() override;
virtual void* GetConnectionIdentifier( ConnectionIdentifierType& rReturnedType,
int& rReturnedBytes ) override;
virtual void AddToRecentDocumentList(const OUString& rFileUrl, const OUString& rMimeType,
diff --git a/vcl/inc/salinst.hxx b/vcl/inc/salinst.hxx
index 6502679..21f7be2 100644
--- a/vcl/inc/salinst.hxx
+++ b/vcl/inc/salinst.hxx
@@ -36,6 +36,7 @@ namespace comphelper { class SolarMutex; }
struct SystemParentData;
struct SalPrinterQueueInfo;
struct ImplJobSetup;
+class OpenGLContext;
class SalGraphics;
class SalFrame;
class SalObject;
@@ -145,6 +146,8 @@ public:
// may return NULL to disable session management
virtual SalSession* CreateSalSession() = 0;
+ virtual OpenGLContext* CreateOpenGLContext() = 0;
+
// methods for XDisplayConnection
void SetEventCallback( rtl::Reference< vcl::DisplayConnectionDispatch > const & pInstance )
diff --git a/vcl/inc/unx/salinst.h b/vcl/inc/unx/salinst.h
index cc0e086..8cb1014 100644
--- a/vcl/inc/unx/salinst.h
+++ b/vcl/inc/unx/salinst.h
@@ -69,6 +69,7 @@ public:
virtual SalSystem* CreateSalSystem() override;
virtual SalBitmap* CreateSalBitmap() override;
virtual SalSession* CreateSalSession() override;
+ virtual OpenGLContext* CreateOpenGLContext() override;
virtual SalYieldResult DoYield(bool bWait, bool bHandleAllCurrentEvents, sal_uLong nReleased) override;
virtual bool AnyInput( VclInputFlags nType ) override;
diff --git a/vcl/inc/win/salinst.h b/vcl/inc/win/salinst.h
index 43c0313..23c0de7 100644
--- a/vcl/inc/win/salinst.h
+++ b/vcl/inc/win/salinst.h
@@ -71,6 +71,7 @@ public:
virtual SalMenuItem* CreateMenuItem( const SalItemParams* pItemData ) override;
virtual void DestroyMenuItem( SalMenuItem* ) override;
virtual SalSession* CreateSalSession() override;
+ virtual OpenGLContext* CreateOpenGLContext() override;
virtual void* GetConnectionIdentifier( ConnectionIdentifierType& rReturnedType, int& rReturnedBytes ) override;
virtual void AddToRecentDocumentList(const OUString& rFileUrl, const OUString& rMimeType, const OUString& rDocumentService) override;
diff --git a/vcl/opengl/win/gdiimpl.cxx b/vcl/opengl/win/gdiimpl.cxx
index 7fbf8f7..50fb392 100644
--- a/vcl/opengl/win/gdiimpl.cxx
+++ b/vcl/opengl/win/gdiimpl.cxx
@@ -12,6 +12,477 @@
#include <win/wincomp.hxx>
#include <win/saldata.hxx>
#include <win/salframe.h>
+#include <win/salinst.h>
+
+static std::vector<HGLRC> g_vShareList;
+
+class WinOpenGLContext : public OpenGLContext
+{
+public:
+ bool init( HDC hDC, HWND hWnd );
+ virtual bool initWindow() override;
+private:
+ virtual bool ImplInit() override;
+ virtual void makeCurrent() override;
+ virtual void destroyCurrentContext() override;
+ virtual bool isCurrent() override;
+ virtual bool isAnyCurrent() override;
+ virtual void resetCurrent() override;
+ virtual void swapBuffers() override;
+};
+
+void WinOpenGLContext::swapBuffers()
+{
+ OpenGLZone aZone;
+
+ SwapBuffers(m_aGLWin.hDC);
+
+ BuffersSwapped();
+}
+
+void WinOpenGLContext::resetCurrent()
+{
+ clearCurrent();
+
+ OpenGLZone aZone;
+
+ wglMakeCurrent(NULL, NULL);
+}
+
+bool WinOpenGLContext::isCurrent()
+{
+ OpenGLZone aZone;
+ return wglGetCurrentContext() == m_aGLWin.hRC &&
+ wglGetCurrentDC() == m_aGLWin.hDC;
+}
+
+bool WinOpenGLContext::isAnyCurrent()
+{
+ return wglGetCurrentContext() != NULL;
+}
+
+void WinOpenGLContext::makeCurrent()
+{
+ if (isCurrent())
+ return;
+
+ OpenGLZone aZone;
+
+ clearCurrent();
+
+ if (!wglMakeCurrent(m_aGLWin.hDC, m_aGLWin.hRC))
+ {
+ SAL_WARN("vcl.opengl", "OpenGLContext::makeCurrent(): wglMakeCurrent failed: " << GetLastError());
+ return;
+ }
+
+ registerAsCurrent();
+}
+
+bool WinOpenGLContext::init(HDC hDC, HWND hWnd)
+{
+ if (isInitialized())
+ return false;
+
+ m_aGLWin.hDC = hDC;
+ m_aGLWin.hWnd = hWnd;
+ return ImplInit();
+}
+
+bool WinOpenGLContext::initWindow()
+{
+ if( !m_pChildWindow )
+ {
+ SystemWindowData winData = generateWinData(mpWindow, false);
+ m_pChildWindow = VclPtr<SystemChildWindow>::Create(mpWindow, 0, &winData, false);
+ }
+
+ if (m_pChildWindow)
+ {
+ InitChildWindow(m_pChildWindow.get());
+ const SystemEnvData* sysData(m_pChildWindow->GetSystemData());
+ m_aGLWin.hWnd = sysData->hWnd;
+ }
+
+ m_aGLWin.hDC = GetDC(m_aGLWin.hWnd);
+ return true;
+}
+
+void WinOpenGLContext::destroyCurrentContext()
+{
+ if (m_aGLWin.hRC)
+ {
+ std::vector<HGLRC>::iterator itr = std::remove(g_vShareList.begin(), g_vShareList.end(), m_aGLWin.hRC);
+ if (itr != g_vShareList.end())
+ g_vShareList.erase(itr);
+
+ if (wglGetCurrentContext() != NULL)
+ wglMakeCurrent(NULL, NULL);
+ wglDeleteContext( m_aGLWin.hRC );
+ ReleaseDC( m_aGLWin.hWnd, m_aGLWin.hDC );
+ m_aGLWin.hRC = 0;
+ }
+}
+
+static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
+{
+ switch (message)
+ {
+ case WM_CREATE:
+ return 0;
+ case WM_CLOSE:
+ PostQuitMessage(0);
+ return 0;
+ case WM_DESTROY:
+ return 0;
+ case WM_KEYDOWN:
+ switch(wParam)
+ {
+ case VK_ESCAPE:
+ PostQuitMessage(0);
+ return 0;
+
+ case VK_SPACE:
+ break;
+ }
+ default:
+ return DefWindowProc(hwnd, message, wParam, lParam);
+ }
+}
+
+int InitTempWindow(HWND *hwnd, int width, int height, const PIXELFORMATDESCRIPTOR& inPfd, GLWindow& glWin)
+{
+ OpenGLZone aZone;
+
+ PIXELFORMATDESCRIPTOR pfd = inPfd;
+ int pfmt;
+ int ret;
+ WNDCLASS wc;
+ wc.style = 0;
+ wc.lpfnWndProc = WndProc;
+ wc.cbClsExtra = wc.cbWndExtra = 0;
+ wc.hInstance = NULL;
+ wc.hIcon = NULL;
+ wc.hCursor = NULL;
+ wc.hbrBackground = NULL;
+ wc.lpszMenuName = NULL;
+ wc.lpszClassName = (LPCSTR)"GLRenderer";
+ RegisterClass(&wc);
+ *hwnd = CreateWindow(wc.lpszClassName, NULL, WS_DISABLED, 0, 0, width, height, NULL, NULL, wc.hInstance, NULL);
+ glWin.hDC = GetDC(*hwnd);
+ pfmt = ChoosePixelFormat(glWin.hDC, &pfd);
+ if (!pfmt)
+ {
+ return -1;
+ }
+ ret = SetPixelFormat(glWin.hDC, pfmt, &pfd);
+ if(!ret)
+ {
+ return -1;
+ }
+ glWin.hRC = wglCreateContext(glWin.hDC);
+ if(!(glWin.hRC))
+ {
+ return -1;
+ }
+ ret = wglMakeCurrent(glWin.hDC, glWin.hRC);
+ if(!ret)
+ {
+ return -1;
+ }
+
+ return 0;
+}
+
+bool WGLisExtensionSupported(const char *extension)
+{
+ OpenGLZone aZone;
+
+ const size_t extlen = strlen(extension);
+ const char *supported = NULL;
+
+ // Try to use wglGetExtensionStringARB on current DC, if possible
+ PROC wglGetExtString = wglGetProcAddress("wglGetExtensionsStringARB");
+
+ if (wglGetExtString)
+ supported = ((char*(__stdcall*)(HDC))wglGetExtString)(wglGetCurrentDC());
+ // If that failed, try standard OpenGL extensions string
+ if (supported == NULL)
+ supported = (char*)glGetString(GL_EXTENSIONS);
+ // If that failed too, must be no extensions supported
+ if (supported == NULL)
+ return false;
+
+ // Begin examination at start of string, increment by 1 on false match
+ for (const char* p = supported; ; p++)
+ {
+ // Advance p up to the next possible match
+ p = strstr(p, extension);
+
+ if (p == NULL)
+ return 0; // No Match
+
+ // Make sure that match is at the start of the string or that
+ // the previous char is a space, or else we could accidentally
+ // match "wglFunkywglExtension" with "wglExtension"
+
+ // Also, make sure that the following character is space or null
+ // or else "wglExtensionTwo" might match "wglExtension"
+ if ((p==supported || p[-1]==' ') && (p[extlen]=='\0' || p[extlen]==' '))
+ return 1; // Match
+ }
+}
+
+bool InitMultisample(const PIXELFORMATDESCRIPTOR& pfd, int& rPixelFormat,
+ bool bUseDoubleBufferedRendering, bool bRequestVirtualDevice)
+{
+ OpenGLZone aZone;
+
+ HWND hWnd = NULL;
+ GLWindow glWin;
+ // Create a temp window to check whether support multi-sample, if support, get the format
+ if (InitTempWindow(&hWnd, 1, 1, pfd, glWin) < 0)
+ {
+ SAL_WARN("vcl.opengl", "Can't create temp window to test");
+ return false;
+ }
+
+ // See if the string exists in WGL
+ if (!WGLisExtensionSupported("WGL_ARB_multisample"))
+ {
+ SAL_WARN("vcl.opengl", "Device doesn't support multisample");
+ return false;
+ }
+ // Get our pixel format
+ PFNWGLCHOOSEPIXELFORMATARBPROC fn_wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");
+ if (!fn_wglChoosePixelFormatARB)
+ {
+ return false;
+ }
+ // Get our current device context
+ HDC hDC = GetDC(hWnd);
+
+ int pixelFormat;
+ int valid;
+ UINT numFormats;
+ float fAttributes[] = {0,0};
+ // These attributes are the bits we want to test for in our sample.
+ // Everything is pretty standard, the only one we want to
+ // really focus on is the WGL_SAMPLE_BUFFERS_ARB and WGL_SAMPLES_ARB.
+ // These two are going to do the main testing for whether or not
+ // we support multisampling on this hardware.
+ int iAttributes[] =
+ {
+ WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
+ WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
+ WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
+ WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
+ WGL_COLOR_BITS_ARB,24,
+ WGL_ALPHA_BITS_ARB,8,
+ WGL_DEPTH_BITS_ARB,24,
+ WGL_STENCIL_BITS_ARB,0,
+ WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
+ WGL_SAMPLES_ARB,8,
+ 0,0
+ };
+
+ if (!bUseDoubleBufferedRendering)
+ {
+ // Use asserts to make sure the iAttributes array is not changed without changing these ugly
+ // hardcode indexes into it.
+ assert(iAttributes[0] == WGL_DOUBLE_BUFFER_ARB);
+ iAttributes[1] = GL_FALSE;
+ }
+
+ if (bRequestVirtualDevice)
+ {
+ assert(iAttributes[2] == WGL_DRAW_TO_WINDOW_ARB);
+ iAttributes[2] = WGL_DRAW_TO_BITMAP_ARB;
+ }
+
+ bool bArbMultisampleSupported = false;
+
+ // First we check to see if we can get a pixel format for 8 samples
+ valid = fn_wglChoosePixelFormatARB(hDC, iAttributes, fAttributes, 1, &pixelFormat, &numFormats);
+ // If we returned true, and our format count is greater than 1
+ if (valid && numFormats >= 1)
+ {
+ bArbMultisampleSupported = true;
+ rPixelFormat = pixelFormat;
+ wglMakeCurrent(NULL, NULL);
+ wglDeleteContext(glWin.hRC);
+ ReleaseDC(hWnd, glWin.hDC);
+ DestroyWindow(hWnd);
+ return bArbMultisampleSupported;
+ }
+ // Our pixel format with 8 samples failed, test for 2 samples
+ assert(iAttributes[18] == WGL_SAMPLES_ARB);
+ iAttributes[19] = 2;
+ valid = fn_wglChoosePixelFormatARB(hDC, iAttributes, fAttributes, 1, &pixelFormat, &numFormats);
+ if (valid && numFormats >= 1)
+ {
+ bArbMultisampleSupported = true;
+ rPixelFormat = pixelFormat;
+ wglMakeCurrent(NULL, NULL);
+ wglDeleteContext(glWin.hRC);
+ ReleaseDC(hWnd, glWin.hDC);
+ DestroyWindow(hWnd);
+ return bArbMultisampleSupported;
+ }
+ // Return the valid format
+ wglMakeCurrent(NULL, NULL);
+ wglDeleteContext(glWin.hRC);
+ ReleaseDC(hWnd, glWin.hDC);
+ DestroyWindow(hWnd);
+
+ return bArbMultisampleSupported;
+}
+
+bool WinOpenGLContext::ImplInit()
+{
+ OpenGLZone aZone;
+
+ VCL_GL_INFO("OpenGLContext::ImplInit----start");
+ // PixelFormat tells Windows how we want things to be
+ PIXELFORMATDESCRIPTOR PixelFormatFront =
+ {
+ sizeof(PIXELFORMATDESCRIPTOR),
+ 1, // Version Number
+ PFD_SUPPORT_OPENGL,
+ PFD_TYPE_RGBA, // Request An RGBA Format
+ (BYTE)32, // Select Our Color Depth
+ 0, 0, 0, 0, 0, 0, // Color Bits Ignored
+ 0, // No Alpha Buffer
+ 0, // Shift Bit Ignored
+ 0, // No Accumulation Buffer
+ 0, 0, 0, 0, // Accumulation Bits Ignored
+ 24, // 24 bit z-buffer
+ 8, // stencil buffer
+ 0, // No Auxiliary Buffer
+ 0, // now ignored
+ 0, // Reserved
+ 0, 0, 0 // Layer Masks Ignored
+ };
+
+ if (mbUseDoubleBufferedRendering)
+ PixelFormatFront.dwFlags |= PFD_DOUBLEBUFFER;
+
+ PixelFormatFront.dwFlags |= PFD_DRAW_TO_WINDOW;
+
+ // we must check whether can set the MSAA
+ int WindowPix = 0;
+ bool bMultiSampleSupport = InitMultisample(PixelFormatFront, WindowPix,
+ mbUseDoubleBufferedRendering, false);
+ if (bMultiSampleSupport && WindowPix != 0)
+ {
+ m_aGLWin.bMultiSampleSupported = true;
+ }
+ else
+ {
+ WindowPix = ChoosePixelFormat(m_aGLWin.hDC, &PixelFormatFront);
+#if OSL_DEBUG_LEVEL > 0
+ PIXELFORMATDESCRIPTOR pfd;
+ DescribePixelFormat(m_aGLWin.hDC, WindowPix, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
+ SAL_WARN("vcl.opengl", "Render Target: Window: " << (int) ((pfd.dwFlags & PFD_DRAW_TO_WINDOW) != 0) << ", Bitmap: " << (int) ((pfd.dwFlags & PFD_DRAW_TO_BITMAP) != 0));
+ SAL_WARN("vcl.opengl", "Supports OpenGL: " << (int) ((pfd.dwFlags & PFD_SUPPORT_OPENGL) != 0));
+#endif
+ }
+
+ if (WindowPix == 0)
+ {
+ SAL_WARN("vcl.opengl", "Invalid pixelformat");
+ return false;
+ }
+
+ if (!SetPixelFormat(m_aGLWin.hDC, WindowPix, &PixelFormatFront))
+ {
+ ImplWriteLastError(GetLastError(), "SetPixelFormat in OpenGLContext::ImplInit");
+ SAL_WARN("vcl.opengl", "SetPixelFormat failed");
+ return false;
+ }
+
+ HGLRC hTempRC = wglCreateContext(m_aGLWin.hDC);
+ if (hTempRC == NULL)
+ {
+ ImplWriteLastError(GetLastError(), "wglCreateContext in OpenGLContext::ImplInit");
+ SAL_WARN("vcl.opengl", "wglCreateContext failed");
+ return false;
+ }
+
+ if (!wglMakeCurrent(m_aGLWin.hDC, hTempRC))
+ {
+ ImplWriteLastError(GetLastError(), "wglMakeCurrent in OpenGLContext::ImplInit");
+ SAL_WARN("vcl.opengl", "wglMakeCurrent failed");
+ return false;
+ }
+
+ if (!InitGLEW())
+ {
+ wglMakeCurrent(NULL, NULL);
+ wglDeleteContext(hTempRC);
+ return false;
+ }
+
+ HGLRC hSharedCtx = 0;
+ if (!g_vShareList.empty())
+ hSharedCtx = g_vShareList.front();
+
+ if (!wglCreateContextAttribsARB)
+ {
+ wglMakeCurrent(NULL, NULL);
+ wglDeleteContext(hTempRC);
+ return false;
+ }
+
+ // now setup the shared context; this needs a temporary context already
+ // set up in order to work
+ int attribs [] =
+ {
+#ifdef DBG_UTIL
+ WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB,
+#endif
+ 0
+ };
+ m_aGLWin.hRC = wglCreateContextAttribsARB(m_aGLWin.hDC, hSharedCtx, attribs);
+ if (m_aGLWin.hRC == 0)
+ {
+ ImplWriteLastError(GetLastError(), "wglCreateContextAttribsARB in OpenGLContext::ImplInit");
+ SAL_WARN("vcl.opengl", "wglCreateContextAttribsARB failed");
+ wglMakeCurrent(NULL, NULL);
+ wglDeleteContext(hTempRC);
+ return false;
+ }
+
+ wglMakeCurrent(NULL, NULL);
+ wglDeleteContext(hTempRC);
+
+ if (!wglMakeCurrent(m_aGLWin.hDC, m_aGLWin.hRC))
+ {
+ ImplWriteLastError(GetLastError(), "wglMakeCurrent (with shared context) in OpenGLContext::ImplInit");
+ SAL_WARN("vcl.opengl", "wglMakeCurrent failed");
+ return false;
+ }
+
+ InitGLEWDebugging();
+
+ g_vShareList.push_back(m_aGLWin.hRC);
+
+ RECT clientRect;
+ GetClientRect(WindowFromDC(m_aGLWin.hDC), &clientRect);
+ m_aGLWin.Width = clientRect.right - clientRect.left;
+ m_aGLWin.Height = clientRect.bottom - clientRect.top;
+
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+ registerAsCurrent();
+
+ return true;
+}
+
+OpenGLContext* WinSalInstance::CreateOpenGLContext()
+{
+ return new WinOpenGLContext;
+}
WinOpenGLSalGraphicsImpl::WinOpenGLSalGraphicsImpl(WinSalGraphics& rGraphics,
SalGeometryProvider *mpProvider):
@@ -28,10 +499,10 @@ void WinOpenGLSalGraphicsImpl::copyBits( const SalTwoRect& rPosAry, SalGraphics*
rtl::Reference<OpenGLContext> WinOpenGLSalGraphicsImpl::CreateWinContext()
{
- rtl::Reference<OpenGLContext> pContext = OpenGLContext::Create();
- pContext->setVCLOnly();
- pContext->init( mrParent.mhLocalDC, mrParent.mhWnd );
- return pContext;
+ rtl::Reference<WinOpenGLContext> xContext(new WinOpenGLContext);
+ xContext->setVCLOnly();
+ xContext->init(mrParent.mhLocalDC, mrParent.mhWnd);
+ return rtl::Reference<OpenGLContext>(xContext.get());
}
void WinOpenGLSalGraphicsImpl::Init()
diff --git a/vcl/opengl/x11/gdiimpl.cxx b/vcl/opengl/x11/gdiimpl.cxx
index 61dba9b..1137a3a 100644
--- a/vcl/opengl/x11/gdiimpl.cxx
+++ b/vcl/opengl/x11/gdiimpl.cxx
@@ -16,19 +16,565 @@
#include <unx/saldisp.hxx>
#include <unx/salframe.h>
#include <unx/salgdi.h>
+#include <unx/salinst.h>
#include <unx/salvd.h>
#include <unx/x11/xlimits.hxx>
#include <opengl/texture.hxx>
+#include <opengl/zone.hxx>
+#include <opengl/RenderState.hxx>
#include <opengl/x11/gdiimpl.hxx>
#include <opengl/x11/salvd.hxx>
-#include "opengl/RenderState.hxx"
#include <vcl/opengl/OpenGLContext.hxx>
#include <vcl/opengl/OpenGLHelper.hxx>
#include <o3tl/lru_map.hxx>
+static std::vector<GLXContext> g_vShareList;
+
+class X11OpenGLContext : public OpenGLContext
+{
+public:
+ bool init(Display* dpy, Window win, int screen);
+ virtual bool initWindow() override;
+private:
+ virtual bool ImplInit() override;
+ void initGLWindow(Visual* pVisual);
+ virtual SystemWindowData generateWinData(vcl::Window* pParent, bool bRequestLegacyContext) override;
+ virtual void makeCurrent() override;
+ virtual void destroyCurrentContext() override;
+ virtual bool isCurrent() override;
+ virtual bool isAnyCurrent() override;
+ virtual void sync() override;
+ virtual void resetCurrent() override;
+ virtual void swapBuffers() override;
+};
+
+namespace
+{
+
+#ifdef DBG_UTIL
+ int unxErrorHandler(Display* dpy, XErrorEvent* event)
+ {
+ char err[256];
+ char req[256];
+ char minor[256];
+ XGetErrorText(dpy, event->error_code, err, 256);
+ XGetErrorText(dpy, event->request_code, req, 256);
+ XGetErrorText(dpy, event->minor_code, minor, 256);
+ SAL_WARN("vcl.opengl", "Error: " << err << ", Req: " << req << ", Minor: " << minor);
+ return 0;
+ }
+#endif
+
+ typedef int (*errorHandler)(Display* /*dpy*/, XErrorEvent* /*evnt*/);
+
+ class TempErrorHandler
+ {
+ private:
+ errorHandler oldErrorHandler;
+ Display* mdpy;
+
+ public:
+ TempErrorHandler(Display* dpy, errorHandler newErrorHandler)
+ : oldErrorHandler(nullptr)
+ , mdpy(dpy)
+ {
+ if (mdpy)
+ {
+ XLockDisplay(dpy);
+ XSync(dpy, false);
+ oldErrorHandler = XSetErrorHandler(newErrorHandler);
+ }
+ }
+
+ ~TempErrorHandler()
+ {
+ if (mdpy)
+ {
+ // sync so that we possibly get an XError
+ glXWaitGL();
+ XSync(mdpy, false);
+ XSetErrorHandler(oldErrorHandler);
+ XUnlockDisplay(mdpy);
+ }
+ }
+ };
+
+ static bool errorTriggered;
+ int oglErrorHandler( Display* /*dpy*/, XErrorEvent* /*evnt*/ )
+ {
+ errorTriggered = true;
+
+ return 0;
+ }
+
+ GLXFBConfig* getFBConfig(Display* dpy, Window win, int& nBestFBC, bool bUseDoubleBufferedRendering, bool bWithSameVisualID)
+ {
+ OpenGLZone aZone;
+
+ if( dpy == nullptr || !glXQueryExtension( dpy, nullptr, nullptr ) )
+ return nullptr;
+
+ VCL_GL_INFO("window: " << win);
+
+ XWindowAttributes xattr;
+ if( !XGetWindowAttributes( dpy, win, &xattr ) )
+ {
+ SAL_WARN("vcl.opengl", "Failed to get window attributes for fbconfig " << win);
+ xattr.screen = nullptr;
+ xattr.visual = nullptr;
+ }
+
+ int screen = XScreenNumberOfScreen( xattr.screen );
+
+ // TODO: moggi: Select colour channel depth based on visual attributes, not hardcoded */
+ static int visual_attribs[] =
+ {
+ GLX_DOUBLEBUFFER, True,
+ GLX_X_RENDERABLE, True,
+ GLX_RED_SIZE, 8,
+ GLX_GREEN_SIZE, 8,
+ GLX_BLUE_SIZE, 8,
+ GLX_ALPHA_SIZE, 8,
+ GLX_DEPTH_SIZE, 24,
+ GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
+ None
+ };
+
+ if (!bUseDoubleBufferedRendering)
+ visual_attribs[1] = False;
+
+ int fbCount = 0;
+ GLXFBConfig* pFBC = glXChooseFBConfig( dpy,
+ screen,
+ visual_attribs, &fbCount );
+
+ if(!pFBC)
+ {
+ SAL_WARN("vcl.opengl", "no suitable fb format found");
+ return nullptr;
+ }
+
+ int best_num_samp = -1;
+ for(int i = 0; i < fbCount; ++i)
+ {
+ XVisualInfo* pVi = glXGetVisualFromFBConfig( dpy, pFBC[i] );
+ if(pVi && (!bWithSameVisualID || (xattr.visual && pVi->visualid == xattr.visual->visualid)) )
+ {
+ // pick the one with the most samples per pixel
+ int nSampleBuf = 0;
+ int nSamples = 0;
+ glXGetFBConfigAttrib( dpy, pFBC[i], GLX_SAMPLE_BUFFERS, &nSampleBuf );
+ glXGetFBConfigAttrib( dpy, pFBC[i], GLX_SAMPLES , &nSamples );
+
+ if ( nBestFBC < 0 || (nSampleBuf && ( nSamples > best_num_samp )) )
+ {
+ nBestFBC = i;
+ best_num_samp = nSamples;
+ }
+ }
+ XFree( pVi );
+ }
+
+ return pFBC;
+ }
+
+ // we need them before glew can initialize them
+ // glew needs an OpenGL context so we need to get the address manually
+ void initOpenGLFunctionPointers()
+ {
+ glXChooseFBConfig = reinterpret_cast<GLXFBConfig*(*)(Display *dpy, int screen, const int *attrib_list, int *nelements)>(glXGetProcAddressARB(reinterpret_cast<GLubyte const *>("glXChooseFBConfig")));
+ glXGetVisualFromFBConfig = reinterpret_cast<XVisualInfo*(*)(Display *dpy, GLXFBConfig config)>(glXGetProcAddressARB(reinterpret_cast<GLubyte const *>("glXGetVisualFromFBConfig"))); // try to find a visual for the current set of attributes
+ glXGetFBConfigAttrib = reinterpret_cast<int(*)(Display *dpy, GLXFBConfig config, int attribute, int* value)>(glXGetProcAddressARB(reinterpret_cast<GLubyte const *>("glXGetFBConfigAttrib")));
+ glXCreateContextAttribsARB = reinterpret_cast<GLXContext(*)(Display*, GLXFBConfig, GLXContext, Bool, const int*)>(glXGetProcAddressARB(reinterpret_cast<const GLubyte *>("glXCreateContextAttribsARB")));
+ glXCreatePixmap = reinterpret_cast<GLXPixmap(*)(Display*, GLXFBConfig, Pixmap, const int*)>(glXGetProcAddressARB(reinterpret_cast<const GLubyte *>("glXCreatePixmap")));
+ }
+
+ Visual* getVisual(Display* dpy, Window win)
+ {
+ OpenGLZone aZone;
+
+ initOpenGLFunctionPointers();
+
+ XWindowAttributes xattr;
+ if( !XGetWindowAttributes( dpy, win, &xattr ) )
+ {
+ SAL_WARN("vcl.opengl", "Failed to get window attributes for getVisual " << win);
+ xattr.visual = nullptr;
+ }
+ VCL_GL_INFO("using VisualID " << xattr.visual);
+ return xattr.visual;
+ }
+}
+
+void X11OpenGLContext::sync()
+{
+ OpenGLZone aZone;
+ glXWaitGL();
+ XSync(m_aGLWin.dpy, false);
+}
+
+void X11OpenGLContext::swapBuffers()
+{
+ OpenGLZone aZone;
+
+ glXSwapBuffers(m_aGLWin.dpy, m_aGLWin.win);
+
+ BuffersSwapped();
+}
+
+void X11OpenGLContext::resetCurrent()
+{
+ clearCurrent();
+
+ OpenGLZone aZone;
+
+ if (m_aGLWin.dpy)
+ glXMakeCurrent(m_aGLWin.dpy, None, nullptr);
+}
+
+bool X11OpenGLContext::isCurrent()
+{
+ OpenGLZone aZone;
+ return m_aGLWin.ctx && glXGetCurrentContext() == m_aGLWin.ctx &&
+ glXGetCurrentDrawable() == m_aGLWin.win;
+}
+
+bool X11OpenGLContext::isAnyCurrent()
+{
+ return glXGetCurrentContext() != None;
+}
+
+SystemWindowData X11OpenGLContext::generateWinData(vcl::Window* pParent, bool /*bRequestLegacyContext*/)
+{
+ OpenGLZone aZone;
+
+ SystemWindowData aWinData;
+ aWinData.nSize = sizeof(aWinData);
+ aWinData.pVisual = nullptr;
+
+ const SystemEnvData* sysData(pParent->GetSystemData());
+
+ Display *dpy = static_cast<Display*>(sysData->pDisplay);
+ Window win = sysData->aWindow;
+
+ if( dpy == nullptr || !glXQueryExtension( dpy, nullptr, nullptr ) )
+ return aWinData;
+
+ initOpenGLFunctionPointers();
+
+ int best_fbc = -1;
+ GLXFBConfig* pFBC = getFBConfig(dpy, win, best_fbc, true, false);
+
+ if (!pFBC)
+ return aWinData;
+
+ XVisualInfo* vi = nullptr;
+ if( best_fbc != -1 )
+ vi = glXGetVisualFromFBConfig( dpy, pFBC[best_fbc] );
+
+ XFree(pFBC);
+
+ if( vi )
+ {
+ VCL_GL_INFO("using VisualID " << vi->visualid);
+ aWinData.pVisual = static_cast<void*>(vi->visual);
+ }
+
+ return aWinData;
+}
+
+bool X11OpenGLContext::ImplInit()
+{
+ if (!m_aGLWin.dpy)
+ return false;
+
+ OpenGLZone aZone;
+
+ GLXContext pSharedCtx( nullptr );
+#ifdef DBG_UTIL
+ TempErrorHandler aErrorHandler(m_aGLWin.dpy, unxErrorHandler);
+#endif
+
+ VCL_GL_INFO("OpenGLContext::ImplInit----start");
+
+ if (!g_vShareList.empty())
+ pSharedCtx = g_vShareList.front();
+
+ if (glXCreateContextAttribsARB && !mbRequestLegacyContext)
+ {
+ int best_fbc = -1;
+ GLXFBConfig* pFBC = getFBConfig(m_aGLWin.dpy, m_aGLWin.win, best_fbc, mbUseDoubleBufferedRendering, false);
+
+ if (pFBC && best_fbc != -1)
+ {
+ int pContextAttribs[] =
+ {
+#if 0 // defined(DBG_UTIL)
+ GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
+ GLX_CONTEXT_MINOR_VERSION_ARB, 2,
+#endif
+ None
+
+ };
+ m_aGLWin.ctx = glXCreateContextAttribsARB(m_aGLWin.dpy, pFBC[best_fbc], pSharedCtx, /* direct, not via X */ GL_TRUE, pContextAttribs);
+ SAL_INFO_IF(m_aGLWin.ctx, "vcl.opengl", "created a 3.2 core context");
+ }
+ else
+ SAL_WARN("vcl.opengl", "unable to find correct FBC");
+ }
+
+ if (!m_aGLWin.ctx)
+ {
+ if (!m_aGLWin.vi)
+ return false;
+
+ SAL_WARN("vcl.opengl", "attempting to create a non-double-buffered "
+ "visual matching the context");
+
+ m_aGLWin.ctx = glXCreateContext(m_aGLWin.dpy,
+ m_aGLWin.vi,
+ pSharedCtx,
+ GL_TRUE /* direct, not via X server */);
+ }
+
+ if( m_aGLWin.ctx )
+ {
+ g_vShareList.push_back( m_aGLWin.ctx );
+ }
+ else
+ {
+ SAL_WARN("vcl.opengl", "unable to create GLX context");
+ return false;
+ }
+
+ if( !glXMakeCurrent( m_aGLWin.dpy, m_aGLWin.win, m_aGLWin.ctx ) )
+ {
+ SAL_WARN("vcl.opengl", "unable to select current GLX context");
+ return false;
+ }
+
+ int glxMinor, glxMajor;
+ double nGLXVersion = 0;
+ if( glXQueryVersion( m_aGLWin.dpy, &glxMajor, &glxMinor ) )
+ nGLXVersion = glxMajor + 0.1*glxMinor;
+ SAL_INFO("vcl.opengl", "available GLX version: " << nGLXVersion);
+
+ m_aGLWin.GLExtensions = glGetString( GL_EXTENSIONS );
+ SAL_INFO("vcl.opengl", "available GL extensions: " << m_aGLWin.GLExtensions);
+
+ XWindowAttributes aWinAttr;
+ if( !XGetWindowAttributes( m_aGLWin.dpy, m_aGLWin.win, &aWinAttr ) )
+ {
+ SAL_WARN("vcl.opengl", "Failed to get window attributes on " << m_aGLWin.win);
+ m_aGLWin.Width = 0;
+ m_aGLWin.Height = 0;
+ }
+ else
+ {
+ m_aGLWin.Width = aWinAttr.width;
+ m_aGLWin.Height = aWinAttr.height;
+ }
+
+ if( m_aGLWin.HasGLXExtension("GLX_SGI_swap_control" ) )
+ {
+ // enable vsync
+ typedef GLint (*glXSwapIntervalProc)(GLint);
+ glXSwapIntervalProc glXSwapInterval = reinterpret_cast<glXSwapIntervalProc>(glXGetProcAddress( reinterpret_cast<const GLubyte*>("glXSwapIntervalSGI") ));
+ if( glXSwapInterval )
+ {
+ TempErrorHandler aLocalErrorHandler(m_aGLWin.dpy, oglErrorHandler);
+
+ errorTriggered = false;
+
+ glXSwapInterval( 1 );
+
+ if( errorTriggered )
+ SAL_WARN("vcl.opengl", "error when trying to set swap interval, NVIDIA or Mesa bug?");
+ else
+ VCL_GL_INFO("set swap interval to 1 (enable vsync)");
+ }
+ }
+
+ bool bRet = InitGLEW();
+ InitGLEWDebugging();
+
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+
+ registerAsCurrent();
+
+ return bRet;
+}
+
+void X11OpenGLContext::makeCurrent()
+{
+ if (isCurrent())
+ return;
+
+ OpenGLZone aZone;
+
+ clearCurrent();
+
+#ifdef DBG_UTIL
+ TempErrorHandler aErrorHandler(m_aGLWin.dpy, unxErrorHandler);
+#endif
+
+ if (m_aGLWin.dpy)
+ {
+ if (!glXMakeCurrent( m_aGLWin.dpy, m_aGLWin.win, m_aGLWin.ctx ))
+ {
+ SAL_WARN("vcl.opengl", "OpenGLContext::makeCurrent failed "
+ "on drawable " << m_aGLWin.win);
+ return;
+ }
+ }
+
+ registerAsCurrent();
+}
+
+void X11OpenGLContext::destroyCurrentContext()
+{
+ if(m_aGLWin.ctx)
+ {
+ std::vector<GLXContext>::iterator itr = std::remove( g_vShareList.begin(), g_vShareList.end(), m_aGLWin.ctx );
+ if (itr != g_vShareList.end())
+ g_vShareList.erase(itr);
+
+ glXMakeCurrent(m_aGLWin.dpy, None, nullptr);
+ if( glGetError() != GL_NO_ERROR )
+ {
+ SAL_WARN("vcl.opengl", "glError: " << glGetError());
+ }
+ glXDestroyContext(m_aGLWin.dpy, m_aGLWin.ctx);
+ m_aGLWin.ctx = nullptr;
+ }
+}
+
+bool X11OpenGLContext::init(Display* dpy, Window win, int screen)
+{
+ if (isInitialized())
+ return true;
+
+ if (!dpy)
+ return false;
+
+ OpenGLZone aZone;
+
+ m_aGLWin.dpy = dpy;
+ m_aGLWin.win = win;
+ m_aGLWin.screen = screen;
+
+ Visual* pVisual = getVisual(dpy, win);
+
+ initGLWindow(pVisual);
+
+ return ImplInit();
+}
+
+void X11OpenGLContext::initGLWindow(Visual* pVisual)
+{
+ OpenGLZone aZone;
+
+ // Get visual info
+ {
+ XVisualInfo aTemplate;
+ aTemplate.visualid = XVisualIDFromVisual( pVisual );
+ int nVisuals = 0;
+ XVisualInfo* pInfo = XGetVisualInfo( m_aGLWin.dpy, VisualIDMask, &aTemplate, &nVisuals );
+ if( nVisuals != 1 )
+ SAL_WARN( "vcl.opengl", "match count for visual id is not 1" );
+ m_aGLWin.vi = pInfo;
+ }
+
+ // Check multisample support
+ /* TODO: moggi: This is not necessarily correct in the DBG_UTIL path, as it picks
+ * an FBConfig instead ... */
+ int nSamples = 0;
+ glXGetConfig(m_aGLWin.dpy, m_aGLWin.vi, GLX_SAMPLES, &nSamples);
+ if( nSamples > 0 )
+ m_aGLWin.bMultiSampleSupported = true;
+
+ m_aGLWin.GLXExtensions = glXQueryExtensionsString( m_aGLWin.dpy, m_aGLWin.screen );
+ SAL_INFO("vcl.opengl", "available GLX extensions: " << m_aGLWin.GLXExtensions);
+}
+
+bool X11OpenGLContext::initWindow()
+{
+ const SystemEnvData* pChildSysData = nullptr;
+ SystemWindowData winData = generateWinData(mpWindow, false);
+ if( winData.pVisual )
+ {
+ if( !m_pChildWindow )
+ {
+ m_pChildWindow = VclPtr<SystemChildWindow>::Create(mpWindow, 0, &winData, false);
+ }
+ pChildSysData = m_pChildWindow->GetSystemData();
+ }
+
+ if (!m_pChildWindow || !pChildSysData)
+ return false;
+
+ InitChildWindow(m_pChildWindow.get());
+
+ m_aGLWin.dpy = static_cast<Display*>(pChildSysData->pDisplay);
+ m_aGLWin.win = pChildSysData->aWindow;
+ m_aGLWin.screen = pChildSysData->nScreen;
+
+ Visual* pVisual = static_cast<Visual*>(pChildSysData->pVisual);
+ initGLWindow(pVisual);
+
+ return true;
+}
+
+// Copy of gluCheckExtension(), from the Apache-licensed
+// https://code.google.com/p/glues/source/browse/trunk/glues/source/glues_registry.c
+static GLboolean checkExtension(const GLubyte* extName, const GLubyte* extString)
+{
+ GLboolean flag=GL_FALSE;
+ char* word;
+ char* lookHere;
+ char* deleteThis;
+
+ if (extString==nullptr)
+ {
+ return GL_FALSE;
+ }
+
+ deleteThis=lookHere=static_cast<char*>(malloc(strlen(reinterpret_cast<const char*>(extString))+1));
+ if (lookHere==nullptr)
+ {
+ return GL_FALSE;
+ }
+
+ /* strtok() will modify string, so copy it somewhere */
+ strcpy(lookHere, reinterpret_cast<const char*>(extString));
+
+ while ((word=strtok(lookHere, " "))!=nullptr)
+ {
+ if (strcmp(word, reinterpret_cast<const char*>(extName))==0)
+ {
+ flag=GL_TRUE;
+ break;
+ }
+ lookHere=nullptr; /* get next token */
+ }
+ free(static_cast<void*>(deleteThis));
+
+ return flag;
+}
+
+bool GLWindow::HasGLXExtension( const char* name ) const
+{
+ return checkExtension( reinterpret_cast<const GLubyte*>(name), reinterpret_cast<const GLubyte*>(GLXExtensions) );
+}
+
+OpenGLContext* X11SalInstance::CreateOpenGLContext()
+{
+ return new X11OpenGLContext;
+}
+
X11OpenGLSalGraphicsImpl::X11OpenGLSalGraphicsImpl( X11SalGraphics& rParent ):
OpenGLSalGraphicsImpl(rParent,rParent.GetGeometryProvider()),
mrParent(rParent)
@@ -54,11 +600,11 @@ rtl::Reference<OpenGLContext> X11OpenGLSalGraphicsImpl::CreateWinContext()
return nullptr;
sal_uIntPtr aWin = pProvider->GetNativeWindowHandle();
- rtl::Reference<OpenGLContext> pContext = OpenGLContext::Create();
- pContext->setVCLOnly();
- pContext->init( mrParent.GetXDisplay(), aWin,
+ rtl::Reference<X11OpenGLContext> xContext = new X11OpenGLContext;
+ xContext->setVCLOnly();
+ xContext->init( mrParent.GetXDisplay(), aWin,
mrParent.m_nXScreen.getXScreen() );
- return pContext;
+ return rtl::Reference<OpenGLContext>(xContext.get());
}
void X11OpenGLSalGraphicsImpl::copyBits( const SalTwoRect& rPosAry, SalGraphics* pSrcGraphics )
diff --git a/vcl/osx/salobj.cxx b/vcl/osx/salobj.cxx
index 87edbfa..6bbb43a 100644
--- a/vcl/osx/salobj.cxx
+++ b/vcl/osx/salobj.cxx
@@ -18,10 +18,15 @@
*/
#include <string.h>
+#include <vcl/opengl/OpenGLContext.hxx>
+#include <vcl/opengl/OpenGLHelper.hxx>
+#include <opengl/zone.hxx>
#include "osx/saldata.hxx"
-#include "osx/salobj.h"
#include "osx/salframe.h"
+#include "osx/salinst.h"
+#include "osx/salobj.h"
+
#include <AppKit/NSOpenGLView.h>
AquaSalObject::AquaSalObject( AquaSalFrame* pFrame, SystemWindowData* pWindowData ) :
@@ -226,4 +231,106 @@ const SystemEnvData* AquaSalObject::GetSystemData() const
return &maSysData;
}
+class AquaOpenGLContext : public OpenGLContext
+{
+public:
+ virtual bool initWindow() override;
+private:
+ NSOpenGLView* getOpenGLView();
+ virtual bool ImplInit() override;
+ virtual SystemWindowData generateWinData(vcl::Window* pParent, bool bRequestLegacyContext) override;
+ virtual void makeCurrent() override;
+ virtual void destroyCurrentContext() override;
+ virtual void resetCurrent() override;
+ virtual void swapBuffers() override;
+};
+
+void AquaOpenGLContext::resetCurrent()
+{
+ clearCurrent();
+
+ OpenGLZone aZone;
+
+ (void) this; // loplugin:staticmethods
+ [NSOpenGLContext clearCurrentContext];
+}
+
+void AquaOpenGLContext::makeCurrent()
+{
+ if (isCurrent())
+ return;
+
+ OpenGLZone aZone;
+
+ clearCurrent();
+
+ NSOpenGLView* pView = getOpenGLView();
+ [[pView openGLContext] makeCurrentContext];
+
+ registerAsCurrent();
+}
+
+void AquaOpenGLContext::swapBuffers()
+{
+ OpenGLZone aZone;
+
+ NSOpenGLView* pView = getOpenGLView();
+ [[pView openGLContext] flushBuffer];
+
+ BuffersSwapped();
+}
+
+SystemWindowData AquaOpenGLContext::generateWinData(vcl::Window* /*pParent*/, bool bRequestLegacyContext)
+{
+ SystemWindowData aWinData;
+ aWinData.bOpenGL = true;
+ aWinData.bLegacy = bRequestLegacyContext;
+ aWinData.nSize = sizeof(aWinData);
+ return aWinData;
+}
+
+void AquaOpenGLContext::destroyCurrentContext()
+{
+ [NSOpenGLContext clearCurrentContext];
+}
+
+bool AquaOpenGLContext::initWindow()
+{
+ if( !m_pChildWindow )
+ {
+ SystemWindowData winData = generateWinData(mpWindow, mbRequestLegacyContext);
+ m_pChildWindow = VclPtr<SystemChildWindow>::Create(mpWindow, 0, &winData, false);
+ }
+
+ if (m_pChildWindow)
+ {
+ InitChildWindow(m_pChildWindow.get());
+ }
+
+ return true;
+}
+
+bool AquaOpenGLContext::ImplInit()
+{
+ OpenGLZone aZone;
+
+ VCL_GL_INFO("OpenGLContext::ImplInit----start");
+ NSOpenGLView* pView = getOpenGLView();
+ [[pView openGLContext] makeCurrentContext];
+
+ bool bRet = InitGLEW();
+ InitGLEWDebugging();
+ return bRet;
+}
+
+NSOpenGLView* AquaOpenGLContext::getOpenGLView()
+{
+ return reinterpret_cast<NSOpenGLView*>(m_pChildWindow->GetSystemData()->mpNSView);
+}
+
+OpenGLContext* AquaSalInstance::CreateOpenGLContext()
+{
+ return new AquaOpenGLContext;
+}
+
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/source/opengl/OpenGLContext.cxx b/vcl/source/opengl/OpenGLContext.cxx
index f254974..89ce970 100644
--- a/vcl/source/opengl/OpenGLContext.cxx
+++ b/vcl/source/opengl/OpenGLContext.cxx
@@ -22,19 +22,9 @@
#include <osl/thread.hxx>
-#if defined(MACOSX)
-#include <premac.h>
-#include <AppKit/NSOpenGLView.h>
-#include <AppKit/NSOpenGL.h>
-#include <postmac.h>
-#endif
-
-#if defined(_WIN32)
-#include <win/saldata.hxx>
-#endif
-
#include "svdata.hxx"
#include "salgdi.hxx"
+#include "salinst.hxx"
#include <opengl/framebuffer.hxx>
#include <opengl/program.hxx>
@@ -47,13 +37,6 @@ using namespace com::sun::star;
#define MAX_FRAMEBUFFER_COUNT 30
-// TODO use rtl::Static instead of 'static'
-#if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID && !defined(LIBO_HEADLESS)
-static std::vector<GLXContext> g_vShareList;
-#elif defined(WNT)
-static std::vector<HGLRC> g_vShareList;
-#endif
-
static sal_Int64 nBufferSwapCounter = 0;
GLWindow::~GLWindow()
@@ -63,6 +46,17 @@ GLWindow::~GLWindow()
#endif
}
+bool GLWindow::Synchronize(bool bOnoff) const
+{
+#if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID && !defined(LIBO_HEADLESS)
+ XSynchronize(dpy, bOnoff);
+ return true;
+#else
+ (void)bOnoff;
+ return false;
+#endif
+}
+
OpenGLContext::OpenGLContext():
mpWindow(nullptr),
m_pChildWindow(nullptr),
@@ -128,7 +122,7 @@ void OpenGLContext::dispose()
rtl::Reference<OpenGLContext> OpenGLContext::Create()
{
- return rtl::Reference<OpenGLContext>(new OpenGLContext);
+ return rtl::Reference<OpenGLContext>(ImplGetSVData()->mpDefInst->CreateOpenGLContext());
}
void OpenGLContext::requestLegacyContext()
@@ -141,222 +135,6 @@ void OpenGLContext::requestSingleBufferedRendering()
mbUseDoubleBufferedRendering = false;
}
-#if defined( _WIN32 )
-static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
-{
- switch (message)
- {
- case WM_CREATE:
- return 0;
- case WM_CLOSE:
- PostQuitMessage(0);
- return 0;
- case WM_DESTROY:
- return 0;
- case WM_KEYDOWN:
- switch(wParam)
- {
- case VK_ESCAPE:
- PostQuitMessage(0);
- return 0;
-
- case VK_SPACE:
- break;
- }
- default:
- return DefWindowProc(hwnd, message, wParam, lParam);
- }
-}
-
-int InitTempWindow(HWND *hwnd, int width, int height, const PIXELFORMATDESCRIPTOR& inPfd, GLWindow& glWin)
-{
- OpenGLZone aZone;
-
- PIXELFORMATDESCRIPTOR pfd = inPfd;
- int pfmt;
- int ret;
- WNDCLASS wc;
- wc.style = 0;
- wc.lpfnWndProc = WndProc;
- wc.cbClsExtra = wc.cbWndExtra = 0;
- wc.hInstance = NULL;
- wc.hIcon = NULL;
- wc.hCursor = NULL;
- wc.hbrBackground = NULL;
- wc.lpszMenuName = NULL;
- wc.lpszClassName = (LPCSTR)"GLRenderer";
- RegisterClass(&wc);
- *hwnd = CreateWindow(wc.lpszClassName, NULL, WS_DISABLED, 0, 0, width, height, NULL, NULL, wc.hInstance, NULL);
- glWin.hDC = GetDC(*hwnd);
- pfmt = ChoosePixelFormat(glWin.hDC, &pfd);
- if (!pfmt)
- {
- return -1;
- }
- ret = SetPixelFormat(glWin.hDC, pfmt, &pfd);
- if(!ret)
- {
- return -1;
- }
- glWin.hRC = wglCreateContext(glWin.hDC);
- if(!(glWin.hRC))
- {
- return -1;
- }
- ret = wglMakeCurrent(glWin.hDC, glWin.hRC);
- if(!ret)
- {
- return -1;
- }
-
- return 0;
-}
-
-bool WGLisExtensionSupported(const char *extension)
-{
- OpenGLZone aZone;
-
- const size_t extlen = strlen(extension);
- const char *supported = NULL;
-
- // Try to use wglGetExtensionStringARB on current DC, if possible
- PROC wglGetExtString = wglGetProcAddress("wglGetExtensionsStringARB");
-
- if (wglGetExtString)
- supported = ((char*(__stdcall*)(HDC))wglGetExtString)(wglGetCurrentDC());
- // If that failed, try standard OpenGL extensions string
- if (supported == NULL)
- supported = (char*)glGetString(GL_EXTENSIONS);
- // If that failed too, must be no extensions supported
- if (supported == NULL)
- return false;
-
- // Begin examination at start of string, increment by 1 on false match
- for (const char* p = supported; ; p++)
- {
- // Advance p up to the next possible match
- p = strstr(p, extension);
-
- if (p == NULL)
- return 0; // No Match
-
- // Make sure that match is at the start of the string or that
- // the previous char is a space, or else we could accidentally
- // match "wglFunkywglExtension" with "wglExtension"
-
- // Also, make sure that the following character is space or null
- // or else "wglExtensionTwo" might match "wglExtension"
- if ((p==supported || p[-1]==' ') && (p[extlen]=='\0' || p[extlen]==' '))
- return 1; // Match
- }
-}
-
-bool InitMultisample(const PIXELFORMATDESCRIPTOR& pfd, int& rPixelFormat,
- bool bUseDoubleBufferedRendering, bool bRequestVirtualDevice)
-{
- OpenGLZone aZone;
-
- HWND hWnd = NULL;
- GLWindow glWin;
- // Create a temp window to check whether support multi-sample, if support, get the format
- if (InitTempWindow(&hWnd, 1, 1, pfd, glWin) < 0)
- {
- SAL_WARN("vcl.opengl", "Can't create temp window to test");
- return false;
- }
-
- // See if the string exists in WGL
- if (!WGLisExtensionSupported("WGL_ARB_multisample"))
- {
- SAL_WARN("vcl.opengl", "Device doesn't support multisample");
- return false;
- }
- // Get our pixel format
- PFNWGLCHOOSEPIXELFORMATARBPROC fn_wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB");
- if (!fn_wglChoosePixelFormatARB)
- {
- return false;
- }
- // Get our current device context
- HDC hDC = GetDC(hWnd);
-
- int pixelFormat;
- int valid;
- UINT numFormats;
- float fAttributes[] = {0,0};
- // These attributes are the bits we want to test for in our sample.
- // Everything is pretty standard, the only one we want to
- // really focus on is the WGL_SAMPLE_BUFFERS_ARB and WGL_SAMPLES_ARB.
- // These two are going to do the main testing for whether or not
- // we support multisampling on this hardware.
- int iAttributes[] =
- {
- WGL_DOUBLE_BUFFER_ARB,GL_TRUE,
- WGL_DRAW_TO_WINDOW_ARB,GL_TRUE,
- WGL_SUPPORT_OPENGL_ARB,GL_TRUE,
- WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB,
- WGL_COLOR_BITS_ARB,24,
- WGL_ALPHA_BITS_ARB,8,
- WGL_DEPTH_BITS_ARB,24,
- WGL_STENCIL_BITS_ARB,0,
- WGL_SAMPLE_BUFFERS_ARB,GL_TRUE,
- WGL_SAMPLES_ARB,8,
- 0,0
- };
-
- if (!bUseDoubleBufferedRendering)
- {
- // Use asserts to make sure the iAttributes array is not changed without changing these ugly
- // hardcode indexes into it.
- assert(iAttributes[0] == WGL_DOUBLE_BUFFER_ARB);
- iAttributes[1] = GL_FALSE;
- }
-
- if (bRequestVirtualDevice)
- {
- assert(iAttributes[2] == WGL_DRAW_TO_WINDOW_ARB);
- iAttributes[2] = WGL_DRAW_TO_BITMAP_ARB;
- }
-
- bool bArbMultisampleSupported = false;
-
- // First we check to see if we can get a pixel format for 8 samples
- valid = fn_wglChoosePixelFormatARB(hDC, iAttributes, fAttributes, 1, &pixelFormat, &numFormats);
- // If we returned true, and our format count is greater than 1
- if (valid && numFormats >= 1)
- {
- bArbMultisampleSupported = true;
- rPixelFormat = pixelFormat;
- wglMakeCurrent(NULL, NULL);
- wglDeleteContext(glWin.hRC);
- ReleaseDC(hWnd, glWin.hDC);
- DestroyWindow(hWnd);
- return bArbMultisampleSupported;
- }
- // Our pixel format with 8 samples failed, test for 2 samples
- assert(iAttributes[18] == WGL_SAMPLES_ARB);
- iAttributes[19] = 2;
- valid = fn_wglChoosePixelFormatARB(hDC, iAttributes, fAttributes, 1, &pixelFormat, &numFormats);
- if (valid && numFormats >= 1)
- {
- bArbMultisampleSupported = true;
- rPixelFormat = pixelFormat;
- wglMakeCurrent(NULL, NULL);
- wglDeleteContext(glWin.hRC);
- ReleaseDC(hWnd, glWin.hDC);
- DestroyWindow(hWnd);
- return bArbMultisampleSupported;
- }
- // Return the valid format
- wglMakeCurrent(NULL, NULL);
- wglDeleteContext(glWin.hRC);
- ReleaseDC(hWnd, glWin.hDC);
- DestroyWindow(hWnd);
-
- return bArbMultisampleSupported;
-}
-#endif
-
#ifdef DBG_UTIL
namespace {
@@ -456,168 +234,6 @@ debug_callback(GLenum source, GLenum type, GLuint id,
#endif
-#if defined UNX && !defined MACOSX && !defined IOS && !defined ANDROID && !defined(LIBO_HEADLESS)
-
-namespace {
-
-#ifdef DBG_UTIL
-int unxErrorHandler(Display* dpy, XErrorEvent* event)
-{
- char err[256];
- char req[256];
- char minor[256];
- XGetErrorText(dpy, event->error_code, err, 256);
- XGetErrorText(dpy, event->request_code, req, 256);
- XGetErrorText(dpy, event->minor_code, minor, 256);
- SAL_WARN("vcl.opengl", "Error: " << err << ", Req: " << req << ", Minor: " << minor);
- return 0;
-}
-#endif
-
-typedef int (*errorHandler)(Display* /*dpy*/, XErrorEvent* /*evnt*/);
-
-class TempErrorHandler
-{
-private:
- errorHandler oldErrorHandler;
- Display* mdpy;
-
-public:
- TempErrorHandler(Display* dpy, errorHandler newErrorHandler)
- : oldErrorHandler(nullptr)
- , mdpy(dpy)
- {
- if (mdpy)
- {
- XLockDisplay(dpy);
- XSync(dpy, false);
- oldErrorHandler = XSetErrorHandler(newErrorHandler);
- }
- }
-
- ~TempErrorHandler()
- {
- if (mdpy)
- {
- // sync so that we possibly get an XError
- glXWaitGL();
- XSync(mdpy, false);
- XSetErrorHandler(oldErrorHandler);
- XUnlockDisplay(mdpy);
- }
- }
-};
-
-static bool errorTriggered;
-int oglErrorHandler( Display* /*dpy*/, XErrorEvent* /*evnt*/ )
-{
- errorTriggered = true;
-
- return 0;
-}
-
-GLXFBConfig* getFBConfig(Display* dpy, Window win, int& nBestFBC, bool bUseDoubleBufferedRendering, bool bWithSameVisualID)
-{
- OpenGLZone aZone;
-
- if( dpy == nullptr || !glXQueryExtension( dpy, nullptr, nullptr ) )
- return nullptr;
-
- VCL_GL_INFO("window: " << win);
-
- XWindowAttributes xattr;
- if( !XGetWindowAttributes( dpy, win, &xattr ) )
- {
- SAL_WARN("vcl.opengl", "Failed to get window attributes for fbconfig " << win);
- xattr.screen = nullptr;
- xattr.visual = nullptr;
- }
-
- int screen = XScreenNumberOfScreen( xattr.screen );
-
- // TODO: moggi: Select colour channel depth based on visual attributes, not hardcoded */
- static int visual_attribs[] =
- {
- GLX_DOUBLEBUFFER, True,
- GLX_X_RENDERABLE, True,
- GLX_RED_SIZE, 8,
- GLX_GREEN_SIZE, 8,
- GLX_BLUE_SIZE, 8,
- GLX_ALPHA_SIZE, 8,
- GLX_DEPTH_SIZE, 24,
- GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR,
- None
- };
-
- if (!bUseDoubleBufferedRendering)
- visual_attribs[1] = False;
-
- int fbCount = 0;
- GLXFBConfig* pFBC = glXChooseFBConfig( dpy,
- screen,
- visual_attribs, &fbCount );
-
- if(!pFBC)
- {
- SAL_WARN("vcl.opengl", "no suitable fb format found");
- return nullptr;
- }
-
- int best_num_samp = -1;
- for(int i = 0; i < fbCount; ++i)
- {
- XVisualInfo* pVi = glXGetVisualFromFBConfig( dpy, pFBC[i] );
- if(pVi && (!bWithSameVisualID || (xattr.visual && pVi->visualid == xattr.visual->visualid)) )
- {
- // pick the one with the most samples per pixel
- int nSampleBuf = 0;
- int nSamples = 0;
- glXGetFBConfigAttrib( dpy, pFBC[i], GLX_SAMPLE_BUFFERS, &nSampleBuf );
- glXGetFBConfigAttrib( dpy, pFBC[i], GLX_SAMPLES , &nSamples );
-
- if ( nBestFBC < 0 || (nSampleBuf && ( nSamples > best_num_samp )) )
- {
- nBestFBC = i;
- best_num_samp = nSamples;
- }
- }
- XFree( pVi );
- }
-
- return pFBC;
-}
-
-// we need them before glew can initialize them
-// glew needs an OpenGL context so we need to get the address manually
-void initOpenGLFunctionPointers()
-{
- glXChooseFBConfig = reinterpret_cast<GLXFBConfig*(*)(Display *dpy, int screen, const int *attrib_list, int *nelements)>(glXGetProcAddressARB(reinterpret_cast<GLubyte const *>("glXChooseFBConfig")));
- glXGetVisualFromFBConfig = reinterpret_cast<XVisualInfo*(*)(Display *dpy, GLXFBConfig config)>(glXGetProcAddressARB(reinterpret_cast<GLubyte const *>("glXGetVisualFromFBConfig"))); // try to find a visual for the current set of attributes
- glXGetFBConfigAttrib = reinterpret_cast<int(*)(Display *dpy, GLXFBConfig config, int attribute, int* value)>(glXGetProcAddressARB(reinterpret_cast<GLubyte const *>("glXGetFBConfigAttrib")));
- glXCreateContextAttribsARB = reinterpret_cast<GLXContext(*)(Display*, GLXFBConfig, GLXContext, Bool, const int*)>(glXGetProcAddressARB(reinterpret_cast<const GLubyte *>("glXCreateContextAttribsARB")));
- glXCreatePixmap = reinterpret_cast<GLXPixmap(*)(Display*, GLXFBConfig, Pixmap, const int*)>(glXGetProcAddressARB(reinterpret_cast<const GLubyte *>("glXCreatePixmap")));
-}
-
-Visual* getVisual(Display* dpy, Window win)
-{
- OpenGLZone aZone;
-
- initOpenGLFunctionPointers();
-
- XWindowAttributes xattr;
- if( !XGetWindowAttributes( dpy, win, &xattr ) )
- {
- SAL_WARN("vcl.opengl", "Failed to get window attributes for getVisual " << win);
- xattr.visual = nullptr;
- }
- VCL_GL_INFO("using VisualID " << xattr.visual);
- return xattr.visual;
-}
-
-}
-
-#endif
-
bool OpenGLContext::init( vcl::Window* pParent )
{
if(mbInitialized)
@@ -650,370 +266,12 @@ bool OpenGLContext::init(SystemChildWindow* pChildWindow)
return ImplInit();
}
-#if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID && !defined(LIBO_HEADLESS)
-bool OpenGLContext::init(Display* dpy, Window win, int screen)
-{
- if(mbInitialized)
- return true;
-
- if (!dpy)
- return false;
-
- OpenGLZone aZone;
-
- m_aGLWin.dpy = dpy;
- m_aGLWin.win = win;
- m_aGLWin.screen = screen;
-
- Visual* pVisual = getVisual(dpy, win);
-
- initGLWindow(pVisual);
-
- return ImplInit();
-}
-
-// Copy of gluCheckExtension(), from the Apache-licensed
-// https://code.google.com/p/glues/source/browse/trunk/glues/source/glues_registry.c
-static GLboolean checkExtension(const GLubyte* extName, const GLubyte* extString)
-{
- GLboolean flag=GL_FALSE;
- char* word;
- char* lookHere;
- char* deleteThis;
-
- if (extString==nullptr)
- {
- return GL_FALSE;
- }
-
- deleteThis=lookHere=static_cast<char*>(malloc(strlen(reinterpret_cast<const char*>(extString))+1));
- if (lookHere==nullptr)
- {
- return GL_FALSE;
- }
-
- /* strtok() will modify string, so copy it somewhere */
- strcpy(lookHere, reinterpret_cast<const char*>(extString));
-
- while ((word=strtok(lookHere, " "))!=nullptr)
- {
- if (strcmp(word, reinterpret_cast<const char*>(extName))==0)
- {
- flag=GL_TRUE;
- break;
- }
- lookHere=nullptr; /* get next token */
- }
- free(static_cast<void*>(deleteThis));
-
- return flag;
-}
-
-bool GLWindow::HasGLXExtension( const char* name ) const
-{
- return checkExtension( reinterpret_cast<const GLubyte*>(name), reinterpret_cast<const GLubyte*>(GLXExtensions) );
-}
-
-bool OpenGLContext::ImplInit()
-{
- if (!m_aGLWin.dpy)
- return false;
-
- OpenGLZone aZone;
-
- GLXContext pSharedCtx( nullptr );
-#ifdef DBG_UTIL
- TempErrorHandler aErrorHandler(m_aGLWin.dpy, unxErrorHandler);
-#endif
-
- VCL_GL_INFO("OpenGLContext::ImplInit----start");
-
- if (!g_vShareList.empty())
- pSharedCtx = g_vShareList.front();
-
- if (glXCreateContextAttribsARB && !mbRequestLegacyContext)
- {
- int best_fbc = -1;
- GLXFBConfig* pFBC = getFBConfig(m_aGLWin.dpy, m_aGLWin.win, best_fbc, mbUseDoubleBufferedRendering, false);
-
- if (pFBC && best_fbc != -1)
- {
- int pContextAttribs[] =
- {
-#if 0 // defined(DBG_UTIL)
- GLX_CONTEXT_MAJOR_VERSION_ARB, 3,
- GLX_CONTEXT_MINOR_VERSION_ARB, 2,
-#endif
- None
-
- };
- m_aGLWin.ctx = glXCreateContextAttribsARB(m_aGLWin.dpy, pFBC[best_fbc], pSharedCtx, /* direct, not via X */ GL_TRUE, pContextAttribs);
- SAL_INFO_IF(m_aGLWin.ctx, "vcl.opengl", "created a 3.2 core context");
- }
- else
- SAL_WARN("vcl.opengl", "unable to find correct FBC");
- }
-
- if (!m_aGLWin.ctx)
- {
- if (!m_aGLWin.vi)
- return false;
-
- SAL_WARN("vcl.opengl", "attempting to create a non-double-buffered "
- "visual matching the context");
-
- m_aGLWin.ctx = glXCreateContext(m_aGLWin.dpy,
- m_aGLWin.vi,
- pSharedCtx,
- GL_TRUE /* direct, not via X server */);
- }
-
- if( m_aGLWin.ctx )
- {
- g_vShareList.push_back( m_aGLWin.ctx );
- }
- else
- {
- SAL_WARN("vcl.opengl", "unable to create GLX context");
- return false;
- }
-
- if( !glXMakeCurrent( m_aGLWin.dpy, m_aGLWin.win, m_aGLWin.ctx ) )
- {
- SAL_WARN("vcl.opengl", "unable to select current GLX context");
- return false;
- }
-
- int glxMinor, glxMajor;
- double nGLXVersion = 0;
- if( glXQueryVersion( m_aGLWin.dpy, &glxMajor, &glxMinor ) )
- nGLXVersion = glxMajor + 0.1*glxMinor;
- SAL_INFO("vcl.opengl", "available GLX version: " << nGLXVersion);
-
- m_aGLWin.GLExtensions = glGetString( GL_EXTENSIONS );
- SAL_INFO("vcl.opengl", "available GL extensions: " << m_aGLWin.GLExtensions);
-
- XWindowAttributes aWinAttr;
- if( !XGetWindowAttributes( m_aGLWin.dpy, m_aGLWin.win, &aWinAttr ) )
- {
- SAL_WARN("vcl.opengl", "Failed to get window attributes on " << m_aGLWin.win);
- m_aGLWin.Width = 0;
- m_aGLWin.Height = 0;
- }
- else
- {
- m_aGLWin.Width = aWinAttr.width;
- m_aGLWin.Height = aWinAttr.height;
- }
-
- if( m_aGLWin.HasGLXExtension("GLX_SGI_swap_control" ) )
- {
- // enable vsync
- typedef GLint (*glXSwapIntervalProc)(GLint);
- glXSwapIntervalProc glXSwapInterval = reinterpret_cast<glXSwapIntervalProc>(glXGetProcAddress( reinterpret_cast<const GLubyte*>("glXSwapIntervalSGI") ));
- if( glXSwapInterval )
- {
- TempErrorHandler aLocalErrorHandler(m_aGLWin.dpy, oglErrorHandler);
-
- errorTriggered = false;
-
- glXSwapInterval( 1 );
-
- if( errorTriggered )
- SAL_WARN("vcl.opengl", "error when trying to set swap interval, NVIDIA or Mesa bug?");
- else
- VCL_GL_INFO("set swap interval to 1 (enable vsync)");
- }
- }
-
- bool bRet = InitGLEW();
- InitGLEWDebugging();
-
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-
- registerAsCurrent();
-
- return bRet;
-}
-
-#elif defined( _WIN32 )
-
-bool OpenGLContext::init(HDC hDC, HWND hWnd)
-{
- if (mbInitialized)
- return false;
-
- m_aGLWin.hDC = hDC;
- m_aGLWin.hWnd = hWnd;
- return ImplInit();
-}
-
-bool OpenGLContext::ImplInit()
-{
- OpenGLZone aZone;
-
- VCL_GL_INFO("OpenGLContext::ImplInit----start");
- // PixelFormat tells Windows how we want things to be
- PIXELFORMATDESCRIPTOR PixelFormatFront =
- {
- sizeof(PIXELFORMATDESCRIPTOR),
- 1, // Version Number
- PFD_SUPPORT_OPENGL,
- PFD_TYPE_RGBA, // Request An RGBA Format
- (BYTE)32, // Select Our Color Depth
- 0, 0, 0, 0, 0, 0, // Color Bits Ignored
- 0, // No Alpha Buffer
- 0, // Shift Bit Ignored
- 0, // No Accumulation Buffer
- 0, 0, 0, 0, // Accumulation Bits Ignored
- 24, // 24 bit z-buffer
- 8, // stencil buffer
- 0, // No Auxiliary Buffer
- 0, // now ignored
- 0, // Reserved
- 0, 0, 0 // Layer Masks Ignored
- };
-
- if (mbUseDoubleBufferedRendering)
- PixelFormatFront.dwFlags |= PFD_DOUBLEBUFFER;
-
- PixelFormatFront.dwFlags |= PFD_DRAW_TO_WINDOW;
-
- // we must check whether can set the MSAA
- int WindowPix = 0;
- bool bMultiSampleSupport = InitMultisample(PixelFormatFront, WindowPix,
- mbUseDoubleBufferedRendering, false);
- if (bMultiSampleSupport && WindowPix != 0)
- {
- m_aGLWin.bMultiSampleSupported = true;
- }
- else
- {
- WindowPix = ChoosePixelFormat(m_aGLWin.hDC, &PixelFormatFront);
-#if OSL_DEBUG_LEVEL > 0
- PIXELFORMATDESCRIPTOR pfd;
- DescribePixelFormat(m_aGLWin.hDC, WindowPix, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
- SAL_WARN("vcl.opengl", "Render Target: Window: " << (int) ((pfd.dwFlags & PFD_DRAW_TO_WINDOW) != 0) << ", Bitmap: " << (int) ((pfd.dwFlags & PFD_DRAW_TO_BITMAP) != 0));
- SAL_WARN("vcl.opengl", "Supports OpenGL: " << (int) ((pfd.dwFlags & PFD_SUPPORT_OPENGL) != 0));
-#endif
- }
-
- if (WindowPix == 0)
- {
- SAL_WARN("vcl.opengl", "Invalid pixelformat");
- return false;
- }
-
- if (!SetPixelFormat(m_aGLWin.hDC, WindowPix, &PixelFormatFront))
- {
- ImplWriteLastError(GetLastError(), "SetPixelFormat in OpenGLContext::ImplInit");
- SAL_WARN("vcl.opengl", "SetPixelFormat failed");
- return false;
- }
-
- HGLRC hTempRC = wglCreateContext(m_aGLWin.hDC);
- if (hTempRC == NULL)
- {
- ImplWriteLastError(GetLastError(), "wglCreateContext in OpenGLContext::ImplInit");
- SAL_WARN("vcl.opengl", "wglCreateContext failed");
- return false;
- }
-
- if (!wglMakeCurrent(m_aGLWin.hDC, hTempRC))
- {
- ImplWriteLastError(GetLastError(), "wglMakeCurrent in OpenGLContext::ImplInit");
- SAL_WARN("vcl.opengl", "wglMakeCurrent failed");
- return false;
- }
-
- if (!InitGLEW())
- {
- wglMakeCurrent(NULL, NULL);
- wglDeleteContext(hTempRC);
- return false;
- }
-
- HGLRC hSharedCtx = 0;
- if (!g_vShareList.empty())
- hSharedCtx = g_vShareList.front();
-
- if (!wglCreateContextAttribsARB)
- {
- wglMakeCurrent(NULL, NULL);
- wglDeleteContext(hTempRC);
- return false;
- }
-
- // now setup the shared context; this needs a temporary context already
- // set up in order to work
- int attribs [] =
- {
-#ifdef DBG_UTIL
- WGL_CONTEXT_FLAGS_ARB, WGL_CONTEXT_DEBUG_BIT_ARB,
-#endif
- 0
- };
- m_aGLWin.hRC = wglCreateContextAttribsARB(m_aGLWin.hDC, hSharedCtx, attribs);
- if (m_aGLWin.hRC == 0)
- {
- ImplWriteLastError(GetLastError(), "wglCreateContextAttribsARB in OpenGLContext::ImplInit");
- SAL_WARN("vcl.opengl", "wglCreateContextAttribsARB failed");
- wglMakeCurrent(NULL, NULL);
- wglDeleteContext(hTempRC);
- return false;
- }
-
- wglMakeCurrent(NULL, NULL);
- wglDeleteContext(hTempRC);
-
- if (!wglMakeCurrent(m_aGLWin.hDC, m_aGLWin.hRC))
- {
- ImplWriteLastError(GetLastError(), "wglMakeCurrent (with shared context) in OpenGLContext::ImplInit");
- SAL_WARN("vcl.opengl", "wglMakeCurrent failed");
- return false;
- }
-
- InitGLEWDebugging();
-
- g_vShareList.push_back(m_aGLWin.hRC);
-
- RECT clientRect;
- GetClientRect(WindowFromDC(m_aGLWin.hDC), &clientRect);
- m_aGLWin.Width = clientRect.right - clientRect.left;
- m_aGLWin.Height = clientRect.bottom - clientRect.top;
-
- glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
-
- registerAsCurrent();
-
- return true;
-}
-
-#elif defined( MACOSX )
-
-bool OpenGLContext::ImplInit()
-{
- OpenGLZone aZone;
-
- VCL_GL_INFO("OpenGLContext::ImplInit----start");
- NSOpenGLView* pView = getOpenGLView();
- [[pView openGLContext] makeCurrentContext];
-
- bool bRet = InitGLEW();
- InitGLEWDebugging();
- return bRet;
-}
-
-#else
-
bool OpenGLContext::ImplInit()
{
VCL_GL_INFO("OpenGLContext not implemented for this platform");
return false;
}
-#endif
-
bool OpenGLContext::InitGLEW()
{
static bool bGlewInit = false;
@@ -1101,111 +359,16 @@ void OpenGLContext::InitChildWindow(SystemChildWindow *pChildWindow)
pChildWindow->SetControlBackground();
}
-#if defined(_WIN32)
-
-bool OpenGLContext::initWindow()
-{
- if( !m_pChildWindow )
- {
- SystemWindowData winData = generateWinData(mpWindow, false);
- m_pChildWindow = VclPtr<SystemChildWindow>::Create(mpWindow, 0, &winData, false);
- }
-
- if (m_pChildWindow)
- {
- InitChildWindow(m_pChildWindow.get());
- const SystemEnvData* sysData(m_pChildWindow->GetSystemData());
- m_aGLWin.hWnd = sysData->hWnd;
- }
-
- m_aGLWin.hDC = GetDC(m_aGLWin.hWnd);
- return true;
-}
-
-#elif defined( MACOSX )
-
-bool OpenGLContext::initWindow()
-{
- if( !m_pChildWindow )
- {
- SystemWindowData winData = generateWinData(mpWindow, mbRequestLegacyContext);
- m_pChildWindow = VclPtr<SystemChildWindow>::Create(mpWindow, 0, &winData, false);
- }
-
- if (m_pChildWindow)
- {
- InitChildWindow(m_pChildWindow.get());
- }
-
- return true;
-}
-
-#elif defined( IOS ) || defined( ANDROID ) || defined(LIBO_HEADLESS)
-
bool OpenGLContext::initWindow()
{
return false;
}
-#elif defined( UNX )
-
-bool OpenGLContext::initWindow()
+void OpenGLContext::destroyCurrentContext()
{
- const SystemEnvData* pChildSysData = nullptr;
- SystemWindowData winData = generateWinData(mpWindow, false);
- if( winData.pVisual )
- {
- if( !m_pChildWindow )
- {
- m_pChildWindow = VclPtr<SystemChildWindow>::Create(mpWindow, 0, &winData, false);
- }
- pChildSysData = m_pChildWindow->GetSystemData();
- }
-
- if (!m_pChildWindow || !pChildSysData)
- return false;
-
- InitChildWindow(m_pChildWindow.get());
-
- m_aGLWin.dpy = static_cast<Display*>(pChildSysData->pDisplay);
- m_aGLWin.win = pChildSysData->aWindow;
- m_aGLWin.screen = pChildSysData->nScreen;
-
- Visual* pVisual = static_cast<Visual*>(pChildSysData->pVisual);
- initGLWindow(pVisual);
-
- return true;
-}
-
-void OpenGLContext::initGLWindow(Visual* pVisual)
-{
- OpenGLZone aZone;
-
- // Get visual info
- {
- XVisualInfo aTemplate;
- aTemplate.visualid = XVisualIDFromVisual( pVisual );
- int nVisuals = 0;
- XVisualInfo* pInfo = XGetVisualInfo( m_aGLWin.dpy, VisualIDMask, &aTemplate, &nVisuals );
- if( nVisuals != 1 )
- SAL_WARN( "vcl.opengl", "match count for visual id is not 1" );
- m_aGLWin.vi = pInfo;
- }
-
- // Check multisample support
- /* TODO: moggi: This is not necessarily correct in the DBG_UTIL path, as it picks
- * an FBConfig instead ... */
- int nSamples = 0;
- glXGetConfig(m_aGLWin.dpy, m_aGLWin.vi, GLX_SAMPLES, &nSamples);
- if( nSamples > 0 )
- m_aGLWin.bMultiSampleSupported = true;
-
- m_aGLWin.GLXExtensions = glXQueryExtensionsString( m_aGLWin.dpy, m_aGLWin.screen );
- SAL_INFO("vcl.opengl", "available GLX extensions: " << m_aGLWin.GLXExtensions);
+ //nothing by default
}
-#endif
-
void OpenGLContext::reset()
{
if( !mbInitialized )
@@ -1249,127 +412,46 @@ void OpenGLContext::reset()
mbInitialized = false;
// destroy the context itself
-#if defined(_WIN32)
- if (m_aGLWin.hRC)
- {
- std::vector<HGLRC>::iterator itr = std::remove(g_vShareList.begin(), g_vShareList.end(), m_aGLWin.hRC);
- if (itr != g_vShareList.end())
- g_vShareList.erase(itr);
-
- if (wglGetCurrentContext() != NULL)
- wglMakeCurrent(NULL, NULL);
- wglDeleteContext( m_aGLWin.hRC );
- ReleaseDC( m_aGLWin.hWnd, m_aGLWin.hDC );
- m_aGLWin.hRC = 0;
- }
-#elif defined( MACOSX )
- [NSOpenGLContext clearCurrentContext];
-#elif defined( IOS ) || defined( ANDROID ) || defined(LIBO_HEADLESS)
- // nothing
-#elif defined( UNX )
- if(m_aGLWin.ctx)
- {
- std::vector<GLXContext>::iterator itr = std::remove( g_vShareList.begin(), g_vShareList.end(), m_aGLWin.ctx );
- if (itr != g_vShareList.end())
- g_vShareList.erase(itr);
-
- glXMakeCurrent(m_aGLWin.dpy, None, nullptr);
- if( glGetError() != GL_NO_ERROR )
- {
- SAL_WARN("vcl.opengl", "glError: " << glGetError());
- }
- glXDestroyContext(m_aGLWin.dpy, m_aGLWin.ctx);
- m_aGLWin.ctx = nullptr;
- }
-#endif
+ destroyCurrentContext();
}
-#if defined(_WIN32) || defined( MACOSX ) || defined( IOS ) || defined( ANDROID )
-
-SystemWindowData OpenGLContext::generateWinData(vcl::Window* /*pParent*/, bool bRequestLegacyContext)
+SystemWindowData OpenGLContext::generateWinData(vcl::Window* /*pParent*/, bool /*bRequestLegacyContext*/)
{
- (void) bRequestLegacyContext;
SystemWindowData aWinData;
-#if defined(MACOSX)
- aWinData.bOpenGL = true;
- aWinData.bLegacy = bRequestLegacyContext;
-#endif
aWinData.nSize = sizeof(aWinData);
return aWinData;
}
-#elif defined( UNX )
-
-SystemWindowData OpenGLContext::generateWinData(vcl::Window* pParent, bool)
+bool OpenGLContext::isCurrent()
{
- OpenGLZone aZone;
-
- SystemWindowData aWinData;
- aWinData.nSize = sizeof(aWinData);
- aWinData.pVisual = nullptr;
-
-#if !defined(LIBO_HEADLESS)
- const SystemEnvData* sysData(pParent->GetSystemData());
-
- Display *dpy = static_cast<Display*>(sysData->pDisplay);
- Window win = sysData->aWindow;
-
- if( dpy == nullptr || !glXQueryExtension( dpy, nullptr, nullptr ) )
- return aWinData;
-
- initOpenGLFunctionPointers();
-
- int best_fbc = -1;
- GLXFBConfig* pFBC = getFBConfig(dpy, win, best_fbc, true, false);
+ (void) this; // loplugin:staticmethods
+ return false;
+}
- if (!pFBC)
- return aWinData;
+void OpenGLContext::makeCurrent()
+{
+ if (isCurrent())
+ return;
- XVisualInfo* vi = nullptr;
- if( best_fbc != -1 )
- vi = glXGetVisualFromFBConfig( dpy, pFBC[best_fbc] );
+ OpenGLZone aZone;
- XFree(pFBC);
+ clearCurrent();
- if( vi )
- {
- VCL_GL_INFO("using VisualID " << vi->visualid);
- aWinData.pVisual = static_cast<void*>(vi->visual);
- }
-#endif
+ // by default nothing else to do
- return aWinData;
+ registerAsCurrent();
}
-#endif
-
-bool OpenGLContext::isCurrent()
+bool OpenGLContext::isAnyCurrent()
{
- OpenGLZone aZone;
-
-#if defined(_WIN32)
- return wglGetCurrentContext() == m_aGLWin.hRC &&
- wglGetCurrentDC() == m_aGLWin.hDC;
-#elif defined( MACOSX )
- (void) this; // loplugin:staticmethods
- return false;
-#elif defined( IOS ) || defined( ANDROID ) || defined(LIBO_HEADLESS)
return false;
-#elif defined( UNX )
- return m_aGLWin.ctx && glXGetCurrentContext() == m_aGLWin.ctx &&
- glXGetCurrentDrawable() == m_aGLWin.win;
-#endif
}
bool OpenGLContext::hasCurrent()
{
-#if defined(_WIN32)
- return wglGetCurrentContext() != NULL;
-#elif defined( MACOSX ) || defined( IOS ) || defined( ANDROID ) || defined(LIBO_HEADLESS)
- return false;
-#elif defined( UNX )
- return glXGetCurrentContext() != None;
-#endif
+ ImplSVData* pSVData = ImplGetSVData();
+ rtl::Reference<OpenGLContext> pCurrentCtx = pSVData->maGDIData.mpLastContext;
+ return pCurrentCtx.is() && pCurrentCtx->isAnyCurrent();
}
void OpenGLContext::clearCurrent()
@@ -1402,45 +484,6 @@ void OpenGLContext::prepareForYield()
assert (!hasCurrent());
}
-void OpenGLContext::makeCurrent()
-{
- if (isCurrent())
- return;
-
- OpenGLZone aZone;
-
- clearCurrent();
-
-#if defined(_WIN32)
- if (!wglMakeCurrent(m_aGLWin.hDC, m_aGLWin.hRC))
- {
- SAL_WARN("vcl.opengl", "OpenGLContext::makeCurrent(): wglMakeCurrent failed: " << GetLastError());
- return;
- }
-#elif defined( MACOSX )
- NSOpenGLView* pView = getOpenGLView();
- [[pView openGLContext] makeCurrentContext];
-#elif defined( IOS ) || defined( ANDROID ) || defined(LIBO_HEADLESS)
- // nothing
-#elif defined( UNX )
-#ifdef DBG_UTIL
- TempErrorHandler aErrorHandler(m_aGLWin.dpy, unxErrorHandler);
-#endif
-
- if (m_aGLWin.dpy)
- {
- if (!glXMakeCurrent( m_aGLWin.dpy, m_aGLWin.win, m_aGLWin.ctx ))
- {
- SAL_WARN("vcl.opengl", "OpenGLContext::makeCurrent failed "
- "on drawable " << m_aGLWin.win);
- return;
- }
- }
-#endif
-
- registerAsCurrent();
-}
-
rtl::Reference<OpenGLContext> OpenGLContext::getVCLContext(bool bMakeIfNecessary)
{
ImplSVData* pSVData = ImplGetSVData();
@@ -1503,37 +546,17 @@ void OpenGLContext::registerAsCurrent()
void OpenGLContext::resetCurrent()
{
clearCurrent();
-
- OpenGLZone aZone;
-
-#if defined(_WIN32)
- wglMakeCurrent(NULL, NULL);
-#elif defined( MACOSX )
- (void) this; // loplugin:staticmethods
- [NSOpenGLContext clearCurrentContext];
-#elif defined( IOS ) || defined( ANDROID ) || defined(LIBO_HEADLESS)
- // nothing
-#elif defined( UNX )
- if (m_aGLWin.dpy)
- glXMakeCurrent(m_aGLWin.dpy, None, nullptr);
-#endif
+ // by default nothing else to do
}
void OpenGLContext::swapBuffers()
{
- OpenGLZone aZone;
-
-#if defined(_WIN32)
- SwapBuffers(m_aGLWin.hDC);
-#elif defined( MACOSX )
- NSOpenGLView* pView = getOpenGLView();
- [[pView openGLContext] flushBuffer];
-#elif defined( IOS ) || defined( ANDROID ) || defined(LIBO_HEADLESS)
- // nothing
-#elif defined( UNX )
- glXSwapBuffers(m_aGLWin.dpy, m_aGLWin.win);
-#endif
+ // by default nothing else to do
+ BuffersSwapped();
+}
+void OpenGLContext::BuffersSwapped()
+{
nBufferSwapCounter++;
static bool bSleep = getenv("SAL_GL_SLEEP_ON_SWAP");
@@ -1544,6 +567,7 @@ void OpenGLContext::swapBuffers()
}
}
+
sal_Int64 OpenGLWrapper::getBufferSwapCounter()
{
return nBufferSwapCounter;
@@ -1551,17 +575,8 @@ sal_Int64 OpenGLWrapper::getBufferSwapCounter()
void OpenGLContext::sync()
{
- OpenGLZone aZone;
-
-#if defined(_WIN32)
- // nothing
-#elif defined( MACOSX ) || defined( IOS ) || defined( ANDROID ) || defined(LIBO_HEADLESS)
+ // default is nothing
(void) this; // loplugin:staticmethods
- // nothing
-#elif defined( UNX )
- glXWaitGL();
- XSync(m_aGLWin.dpy, false);
-#endif
}
void OpenGLContext::show()
@@ -1587,13 +602,6 @@ bool OpenGLContext::supportMultiSampling() const
return m_aGLWin.bMultiSampleSupported;
}
-#if defined(MACOSX)
-NSOpenGLView* OpenGLContext::getOpenGLView()
-{
- return reinterpret_cast<NSOpenGLView*>(m_pChildWindow->GetSystemData()->mpNSView);
-}
-#endif
-
bool OpenGLContext::BindFramebuffer( OpenGLFramebuffer* pFramebuffer )
{
OpenGLZone aZone;
diff --git a/vcl/source/window/openglwin.cxx b/vcl/source/window/openglwin.cxx
index 3f95894..442d1da 100644
--- a/vcl/source/window/openglwin.cxx
+++ b/vcl/source/window/openglwin.cxx
@@ -26,7 +26,7 @@ private:
OpenGLWindowImpl::OpenGLWindowImpl(vcl::Window* pWindow)
: mxContext(OpenGLContext::Create())
{
- SystemWindowData aData = OpenGLContext::generateWinData(pWindow, false);
+ SystemWindowData aData = mxContext->generateWinData(pWindow, false);
mxChildWindow.reset(VclPtr<SystemChildWindow>::Create(pWindow, 0, &aData));
mxChildWindow->Show();
mxContext->init(mxChildWindow.get());
More information about the Libreoffice-commits
mailing list