desktop/Library_sofficeapp.mk | 4 desktop/unx/source/glxtest.cxx | 282 ----- include/vcl/opengl/OpenGLContext.hxx | 56 + include/vcl/opengl/glxtest.hxx | 2 include/vcl/outdev.hxx | 4 include/vcl/salgtype.hxx | 8 svx/Executable_gengal.mk | 7 sw/Executable_tiledrendering.mk | 16 vcl/CppunitTest_vcl_outdev.mk | 52 + vcl/Executable_icontest.mk | 9 vcl/Executable_ui-previewer.mk | 15 vcl/Executable_vcldemo.mk | 15 vcl/Library_vcl.mk | 4 vcl/Library_vclplug_gen.mk | 1 vcl/Module_vcl.mk | 2 vcl/Package_opengl.mk | 7 vcl/StaticLibrary_glxtest.mk | 45 vcl/generic/print/genpspgraphics.cxx | 10 vcl/headless/svpgdi.cxx | 10 vcl/headless/svpvd.cxx | 12 vcl/inc/generic/genpspgraphics.h | 6 vcl/inc/headless/svpgdi.hxx | 5 vcl/inc/headless/svpvd.hxx | 5 vcl/inc/opengl/framebuffer.hxx | 45 vcl/inc/opengl/program.hxx | 71 + vcl/inc/opengl/salbmp.hxx | 12 vcl/inc/opengl/texture.hxx | 4 vcl/inc/opengl/win/WinDeviceInfo.hxx | 190 +++ vcl/inc/opengl/win/gdiimpl.hxx | 10 vcl/inc/opengl/x11/gdiimpl.hxx | 11 vcl/inc/opengl/x11/salvd.hxx | 56 + vcl/inc/openglgdiimpl.hxx | 110 +- vcl/inc/quartz/salgdi.h | 8 vcl/inc/quartz/salvd.h | 1 vcl/inc/regionband.hxx | 2 vcl/inc/salframe.hxx | 9 vcl/inc/salgdi.hxx | 24 vcl/inc/salgdiimpl.hxx | 12 vcl/inc/salgeom.hxx | 12 vcl/inc/salvd.hxx | 8 vcl/inc/svdata.hxx | 5 vcl/inc/unx/gtk/gtkgdi.hxx | 14 vcl/inc/unx/salbmp.h | 2 vcl/inc/unx/salgdi.h | 16 vcl/inc/unx/salvd.h | 24 vcl/inc/unx/x11/x11gdiimpl.h | 3 vcl/inc/win/salgdi.h | 13 vcl/inc/win/salvd.h | 7 vcl/opengl/blendedTextureFragmentShader.glsl | 27 vcl/opengl/blendedTextureVertexShader.glsl | 22 vcl/opengl/diffTextureFragmentShader.glsl | 26 vcl/opengl/dumbVertexShader.glsl | 16 vcl/opengl/framebuffer.cxx | 70 + vcl/opengl/gdiimpl.cxx | 984 +++++++------------- vcl/opengl/maskVertexShader.glsl | 19 vcl/opengl/maskedTextureVertexShader.glsl | 19 vcl/opengl/program.cxx | 237 ++++ vcl/opengl/salbmp.cxx | 24 vcl/opengl/scale.cxx | 125 -- vcl/opengl/solidVertexShader.glsl | 16 vcl/opengl/texture.cxx | 39 vcl/opengl/win/WinDeviceInfo.cxx | 1126 +++++++++++++++++++++++ vcl/opengl/win/gdiimpl.cxx | 58 - vcl/opengl/x11/X11DeviceInfo.cxx | 5 vcl/opengl/x11/gdiimpl.cxx | 145 +- vcl/opengl/x11/salvd.cxx | 97 + vcl/qa/cppunit/outdev.cxx | 82 + vcl/quartz/salbmp.cxx | 6 vcl/quartz/salgdicommon.cxx | 14 vcl/quartz/salvd.cxx | 16 vcl/source/gdi/regionband.cxx | 2 vcl/source/gdi/salgdilayout.cxx | 32 vcl/source/gdi/virdev.cxx | 17 vcl/source/opengl/OpenGLContext.cxx | 193 +++ vcl/source/opengl/OpenGLHelper.cxx | 18 vcl/source/outdev/bitmap.cxx | 85 - vcl/source/outdev/gradient.cxx | 19 vcl/source/outdev/mask.cxx | 14 vcl/source/outdev/outdev.cxx | 54 - vcl/source/salmain/salmain.cxx | 7 vcl/source/window/window.cxx | 11 vcl/unx/generic/gdi/gdiimpl.cxx | 40 vcl/unx/generic/gdi/gdiimpl.hxx | 14 vcl/unx/generic/gdi/openglx11cairotextrender.cxx | 31 vcl/unx/generic/gdi/salbmp.cxx | 8 vcl/unx/generic/gdi/salgdi.cxx | 22 vcl/unx/generic/gdi/salgdi2.cxx | 27 vcl/unx/generic/gdi/salvd.cxx | 157 +-- vcl/unx/generic/gdi/x11cairotextrender.cxx | 36 vcl/unx/generic/window/salframe.cxx | 9 vcl/unx/glxtest.cxx | 280 +++++ vcl/unx/gtk/gdi/salnativewidgets-gtk.cxx | 685 ++++++++----- vcl/unx/kde/salnativewidgets-kde.cxx | 2 vcl/win/source/gdi/gdiimpl.cxx | 20 vcl/win/source/gdi/gdiimpl.hxx | 12 vcl/win/source/gdi/salbmp.cxx | 20 vcl/win/source/gdi/salgdi.cxx | 15 vcl/win/source/gdi/salgdi_gdiplus.cxx | 16 vcl/win/source/gdi/salnativewidgets-luna.cxx | 2 vcl/win/source/gdi/salprn.cxx | 2 vcl/win/source/gdi/salvd.cxx | 26 vcl/win/source/window/salframe.cxx | 4 vcl/workben/vcldemo.cxx | 66 + 103 files changed, 4412 insertions(+), 1953 deletions(-)
New commits: commit 214ab2c15e1fcdd0b1d6fa32ee0e101fb53a988c Author: Markus Mohrhard <[email protected]> Date: Tue Dec 2 00:47:10 2014 +0100 request a stencil on windows Change-Id: Ib8f337d80c5576380344893c49c4fa0284f1dc4b diff --git a/vcl/source/opengl/OpenGLContext.cxx b/vcl/source/opengl/OpenGLContext.cxx index 8a04cc2..2160c6e 100644 --- a/vcl/source/opengl/OpenGLContext.cxx +++ b/vcl/source/opengl/OpenGLContext.cxx @@ -850,7 +850,7 @@ bool OpenGLContext::ImplInit() 0, // No Accumulation Buffer 0, 0, 0, 0, // Accumulation Bits Ignored 64, // 32 bit Z-BUFFER - 0, // 0 bit stencil buffer + 8, // stencil buffer 0, // No Auxiliary Buffer 0, // now ignored 0, // Reserved commit dcf988aca5e7f19f995b9e4d1c6fd799bc304da7 Author: Markus Mohrhard <[email protected]> Date: Mon Dec 1 01:18:25 2014 +0100 introduce SAL_FORCEGL and document the variables SAL_FORCEGL can force OpenGL even if the driver is blacklisted. Change-Id: Idc763d81fef6dbdf915154995205fbf2b1f060b4 diff --git a/vcl/source/opengl/OpenGLHelper.cxx b/vcl/source/opengl/OpenGLHelper.cxx index daee089..3c08c03 100644 --- a/vcl/source/opengl/OpenGLHelper.cxx +++ b/vcl/source/opengl/OpenGLHelper.cxx @@ -401,6 +401,17 @@ bool OpenGLHelper::supportsVCLOpenGL() bool OpenGLHelper::isVCLOpenGLEnabled() { + /* + * There are a number of cases that these environment variables cover: + * * SAL_FORCEGL forces OpenGL independent of any other option + * * SAL_DISABLEGL or a blacklisted driver avoid the use of OpenGL if SAL_FORCEGL is not set + * * SAL_ENABLEGL overrides VCL_HIDE_WINDOWS and the configuration variable + * * the configuration variable is checked if no environment variable is set + */ + static bool bForceOpenGL = !!getenv("SAL_FORCEGL"); + if (bForceOpenGL) + return true; + if (!supportsVCLOpenGL()) return false; @@ -411,7 +422,6 @@ bool OpenGLHelper::isVCLOpenGLEnabled() static bool bDuringBuild = getenv("VCL_HIDE_WINDOWS"); if (bDuringBuild && !bEnable /* env. enable overrides */) bEnable = false; - else if (officecfg::Office::Common::VCL::UseOpenGL::get()) bEnable = true; commit 5d879e4a174054f3aa103b933e940b6bbd1c5076 Author: Markus Mohrhard <[email protected]> Date: Sun Nov 30 21:01:35 2014 +0100 whitelist some drivers Especially the ones from our developer machines as they are better tested than anything else. Change-Id: Id6ff6bcae314c03453d82ee4e64aaef1bd5ed84a diff --git a/vcl/inc/opengl/win/WinDeviceInfo.hxx b/vcl/inc/opengl/win/WinDeviceInfo.hxx index 9abddd0..21f14d9 100644 --- a/vcl/inc/opengl/win/WinDeviceInfo.hxx +++ b/vcl/inc/opengl/win/WinDeviceInfo.hxx @@ -82,7 +82,7 @@ struct DriverInfo DriverInfo(OperatingSystem os, const OUString& vendor, DeviceFamilyVector* devices, VersionComparisonOp op, - uint64_t driverVersion, const char *suggestedVersion = nullptr, + uint64_t driverVersion, bool bWhiteListed = false, const char *suggestedVersion = nullptr, bool ownDevices = false); DriverInfo(); @@ -101,6 +101,8 @@ struct DriverInfo // deallocated. False by default. bool mbDeleteDevices; + bool mbWhitelisted; + VersionComparisonOp meComparisonOp; /* versions are assumed to be A.B.C.D packed as 0xAAAABBBBCCCCDDDD */ diff --git a/vcl/opengl/win/WinDeviceInfo.cxx b/vcl/opengl/win/WinDeviceInfo.cxx index c9bf1ff..824d0fc 100644 --- a/vcl/opengl/win/WinDeviceInfo.cxx +++ b/vcl/opengl/win/WinDeviceInfo.cxx @@ -12,22 +12,25 @@ #include <windows.h> #include <setupapi.h> #include <cstdint> -#include <rtl/ustrbuf.hxx> OUString* WinOpenGLDeviceInfo::mpDeviceVendors[wgl::DeviceVendorMax]; std::vector<wgl::DriverInfo> WinOpenGLDeviceInfo::maDriverInfo; #define APPEND_TO_DRIVER_BLOCKLIST(os, vendor, devices, driverComparator, driverVersion, suggestedVersion) \ - maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion, suggestedVersion)) + maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion, false, suggestedVersion)) + #define APPEND_TO_DRIVER_BLOCKLIST2(os, vendor, devices, driverComparator, driverVersion) \ maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion)) +#define APPEND_TO_DRIVER_WHITELIST(os, vendor, devices, driverComparator, driverVersion) \ + maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion, true)) + #define APPEND_TO_DRIVER_BLOCKLIST_RANGE(os, vendor, devices, driverComparator, driverVersion, driverVersionMax, suggestedVersion) \ do { \ assert(driverComparator == wgl::DRIVER_BETWEEN_EXCLUSIVE || \ driverComparator == wgl::DRIVER_BETWEEN_INCLUSIVE || \ driverComparator == wgl::DRIVER_BETWEEN_INCLUSIVE_START); \ - wgl::DriverInfo info(os, vendor, devices, driverComparator, driverVersion, suggestedVersion); \ + wgl::DriverInfo info(os, vendor, devices, driverComparator, driverVersion, false, suggestedVersion); \ info.mnDriverVersionMax = driverVersionMax; \ maDriverInfo.push_back(info); \ } while (false) @@ -373,6 +376,7 @@ DriverInfo::DriverInfo() maAdapterVendor(WinOpenGLDeviceInfo::GetDeviceVendor(VendorAll)), mpDevices(allDevices), mbDeleteDevices(false), + mbWhitelisted(false), meComparisonOp(DRIVER_COMPARISON_IGNORED), mnDriverVersion(0), mnDriverVersionMax(0) @@ -382,6 +386,7 @@ DriverInfo::DriverInfo(OperatingSystem os, const OUString& vendor, DeviceFamilyVector* devices, VersionComparisonOp op, uint64_t driverVersion, + bool bWhitelisted, const char *suggestedVersion /* = nullptr */, bool ownDevices /* = false */) : meOperatingSystem(os), @@ -389,6 +394,7 @@ DriverInfo::DriverInfo(OperatingSystem os, const OUString& vendor, maAdapterVendor(vendor), mpDevices(devices), mbDeleteDevices(ownDevices), + mbWhitelisted(bWhitelisted), meComparisonOp(op), mnDriverVersion(driverVersion), mnDriverVersionMax(0) @@ -401,6 +407,7 @@ DriverInfo::DriverInfo(const DriverInfo& aOrig) : meOperatingSystem(aOrig.meOperatingSystem), mnOperatingSystemVersion(aOrig.mnOperatingSystemVersion), maAdapterVendor(aOrig.maAdapterVendor), + mbWhitelisted(aOrig.mbWhitelisted), meComparisonOp(aOrig.meComparisonOp), mnDriverVersion(aOrig.mnDriverVersion), mnDriverVersionMax(aOrig.mnDriverVersionMax) @@ -657,6 +664,13 @@ bool WinOpenGLDeviceInfo::FindBlocklistedDeviceInList() } if (match || maDriverInfo[i].mnDriverVersion == wgl::DriverInfo::allDriverVersions) { + // white listed drivers + if (maDriverInfo[i].mbWhitelisted) + { + SAL_WARN("vcl.opengl", "whitelisted driver"); + return false; + } + match = true; SAL_WARN("vcl.opengl", "use : " << maDriverInfo[i].maSuggestedVersion); break; @@ -980,6 +994,12 @@ OUString WinOpenGLDeviceInfo::GetDeviceVendor(wgl::DeviceVendor id) void WinOpenGLDeviceInfo::FillBlacklist() { /* + * Implement whitelist entries first as they will be used first to stop early; + */ + + APPEND_TO_DRIVER_WHITELIST( wgl::DRIVER_OS_WINDOWS_7, GetDeviceVendor(wgl::VendorIntel), + wgl::DriverInfo::allDevices, wgl::DRIVER_EQUAL, wgl::V(10,18,10,3412)); + /* * It should be noted here that more specialized rules on certain features * should be inserted -before- more generalized restriction. As the first * match for feature/OS/device found in the list will be used for the final commit a915cfcf5c200f521fe8f8724d57c18b5eb4ca6f Author: Markus Mohrhard <[email protected]> Date: Sun Nov 30 21:00:31 2014 +0100 block all RDP sessions from using OpenGL Normally you only get the Microsoft OpenGL 1.1 driver for RDP so it is save to just block it. Change-Id: Id9b3af23d56926b09316fbf8b873e271060d2c6a diff --git a/vcl/opengl/win/WinDeviceInfo.cxx b/vcl/opengl/win/WinDeviceInfo.cxx index 41f1a2b..c9bf1ff 100644 --- a/vcl/opengl/win/WinDeviceInfo.cxx +++ b/vcl/opengl/win/WinDeviceInfo.cxx @@ -682,6 +682,12 @@ bool WinOpenGLDeviceInfo::isDeviceBlocked() // out of static blocks (i.e. if we were wrong or something was patched, we // can back out our static block without doing a release). + if (mbRDP) + { + SAL_WARN("vcl.opengl", "all OpenGL blocked for RDP sessions"); + return true; + } + return FindBlocklistedDeviceInList(); } commit 1ac0c5ef3f63e864cc018564a3057a7d26c85146 Author: Markus Mohrhard <[email protected]> Date: Thu Nov 27 21:15:47 2014 +0100 fix few problems Change-Id: I4216ec60c7cf07bd92a157f4a86e2560cdbdca93 diff --git a/vcl/opengl/win/WinDeviceInfo.cxx b/vcl/opengl/win/WinDeviceInfo.cxx index f8c86e3..41f1a2b 100644 --- a/vcl/opengl/win/WinDeviceInfo.cxx +++ b/vcl/opengl/win/WinDeviceInfo.cxx @@ -344,6 +344,7 @@ bool ParseDriverVersion(const OUString& aVersion, uint64_t *aNumericVersion) template<typename T> void appendIntegerWithPadding(OUString& rString, T value, sal_uInt32 nChars) { + rString += "0x"; OUString aValue = OUString::number(value, 16); sal_Int32 nLength = aValue.getLength(); sal_uInt32 nPadLength = nChars - nLength; @@ -573,6 +574,7 @@ WinOpenGLDeviceInfo::WinOpenGLDeviceInfo(): mbRDP(false) { GetData(); + FillBlacklist(); } WinOpenGLDeviceInfo::~WinOpenGLDeviceInfo() @@ -617,36 +619,35 @@ bool WinOpenGLDeviceInfo::FindBlocklistedDeviceInList() } } -#if defined(XP_WIN) || defined(ANDROID) switch (maDriverInfo[i].meComparisonOp) { - case DRIVER_LESS_THAN: + case wgl::DRIVER_LESS_THAN: match = driverVersion < maDriverInfo[i].mnDriverVersion; break; - case DRIVER_LESS_THAN_OR_EQUAL: + case wgl::DRIVER_LESS_THAN_OR_EQUAL: match = driverVersion <= maDriverInfo[i].mnDriverVersion; break; - case DRIVER_GREATER_THAN: + case wgl::DRIVER_GREATER_THAN: match = driverVersion > maDriverInfo[i].mnDriverVersion; break; - case DRIVER_GREATER_THAN_OR_EQUAL: + case wgl::DRIVER_GREATER_THAN_OR_EQUAL: match = driverVersion >= maDriverInfo[i].mnDriverVersion; break; - case DRIVER_EQUAL: + case wgl::DRIVER_EQUAL: match = driverVersion == maDriverInfo[i].mnDriverVersion; break; - case DRIVER_NOT_EQUAL: + case wgl::DRIVER_NOT_EQUAL: match = driverVersion != maDriverInfo[i].mnDriverVersion; break; - case DRIVER_BETWEEN_EXCLUSIVE: + case wgl::DRIVER_BETWEEN_EXCLUSIVE: match = driverVersion > maDriverInfo[i].mnDriverVersion && driverVersion < maDriverInfo[i].mnDriverVersionMax; break; - case DRIVER_BETWEEN_INCLUSIVE: + case wgl::DRIVER_BETWEEN_INCLUSIVE: match = driverVersion >= maDriverInfo[i].mnDriverVersion && driverVersion <= maDriverInfo[i].mnDriverVersionMax; break; - case DRIVER_BETWEEN_INCLUSIVE_START: + case wgl::DRIVER_BETWEEN_INCLUSIVE_START: match = driverVersion >= maDriverInfo[i].mnDriverVersion && driverVersion < maDriverInfo[i].mnDriverVersionMax; break; - case DRIVER_COMPARISON_IGNORED: + case wgl::DRIVER_COMPARISON_IGNORED: // We don't have a comparison op, so we match everything. match = true; break; @@ -654,11 +655,6 @@ bool WinOpenGLDeviceInfo::FindBlocklistedDeviceInList() SAL_WARN("vcl.opengl", "Bogus op in GfxDriverInfo"); break; } -#else - // We don't care what driver version it was. We only check OS version and if - // the device matches. - match = true; -#endif if (match || maDriverInfo[i].mnDriverVersion == wgl::DriverInfo::allDriverVersions) { match = true; commit 8c377eab73c9a6d09fb7b05fd5639369ee86dc99 Author: Markus Mohrhard <[email protected]> Date: Thu Nov 27 19:12:31 2014 +0100 connect all pieces for OpenGL windows blacklist, part 3 Change-Id: Iaaafe7da8e717f7b127ab5806773a5a5d75b82d5 diff --git a/vcl/inc/opengl/win/WinDeviceInfo.hxx b/vcl/inc/opengl/win/WinDeviceInfo.hxx index 2c478ee..9abddd0 100644 --- a/vcl/inc/opengl/win/WinDeviceInfo.hxx +++ b/vcl/inc/opengl/win/WinDeviceInfo.hxx @@ -111,7 +111,7 @@ struct DriverInfo static const DeviceFamilyVector* GetDeviceFamily(DeviceFamily id); static DeviceFamilyVector* mpDeviceFamilies[DeviceFamilyMax]; - OUString maModel, maHardware, maProduct, maManufacturer; + OUString maSuggestedVersion; }; #define GFX_DRIVER_VERSION(a,b,c,d) \ @@ -169,6 +169,7 @@ private: void GetData(); void FillBlacklist(); + bool FindBlocklistedDeviceInList(); static OUString* mpDeviceVendors[wgl::DeviceVendorMax]; static std::vector<wgl::DriverInfo> maDriverInfo; diff --git a/vcl/opengl/win/WinDeviceInfo.cxx b/vcl/opengl/win/WinDeviceInfo.cxx index bab420c..f8c86e3 100644 --- a/vcl/opengl/win/WinDeviceInfo.cxx +++ b/vcl/opengl/win/WinDeviceInfo.cxx @@ -88,7 +88,8 @@ void GetDLLVersion(const sal_Unicode* aDLLPath, OUString& aVersion) template<typename T, size_t N> size_t ArrayLength(T (&aArr)[N]) { - return N; + (void) aArr; + return N; } #define GFX_DRIVER_VERSION(a,b,c,d) \ @@ -202,6 +203,29 @@ enum { kWindows10 = 0x60004 }; + +wgl::OperatingSystem WindowsVersionToOperatingSystem(int32_t aWindowsVersion) +{ + switch(aWindowsVersion) { + case kWindowsXP: + return wgl::DRIVER_OS_WINDOWS_XP; + case kWindowsServer2003: + return wgl::DRIVER_OS_WINDOWS_SERVER_2003; + case kWindowsVista: + return wgl::DRIVER_OS_WINDOWS_VISTA; + case kWindows7: + return wgl::DRIVER_OS_WINDOWS_7; + case kWindows8: + return wgl::DRIVER_OS_WINDOWS_8; + case kWindows8_1: + return wgl::DRIVER_OS_WINDOWS_8_1; + case kWindowsUnknown: + default: + return wgl::DRIVER_OS_UNKNOWN; + }; +} + + int32_t WindowsOSVersion() { static int32_t winVersion = kWindowsUnknown; @@ -322,7 +346,7 @@ template<typename T> void appendIntegerWithPadding(OUString& rString, T value, s { OUString aValue = OUString::number(value, 16); sal_Int32 nLength = aValue.getLength(); - sal_Int32 nPadLength = nChars - nLength; + sal_uInt32 nPadLength = nChars - nLength; assert(nPadLength >= 0); OUStringBuffer aBuffer; for (sal_uInt32 i = 0; i < nPadLength; ++i) @@ -367,7 +391,10 @@ DriverInfo::DriverInfo(OperatingSystem os, const OUString& vendor, meComparisonOp(op), mnDriverVersion(driverVersion), mnDriverVersionMax(0) -{} +{ + if (suggestedVersion) + maSuggestedVersion = OStringToOUString(OString(suggestedVersion), RTL_TEXTENCODING_UTF8); +} DriverInfo::DriverInfo(const DriverInfo& aOrig) : meOperatingSystem(aOrig.meOperatingSystem), @@ -552,6 +579,97 @@ WinOpenGLDeviceInfo::~WinOpenGLDeviceInfo() { } +bool WinOpenGLDeviceInfo::FindBlocklistedDeviceInList() +{ + uint64_t driverVersion; + ParseDriverVersion(maDriverVersion, &driverVersion); + + wgl::OperatingSystem eOS = WindowsVersionToOperatingSystem(mnWindowsVersion); + bool match = false; + uint32_t i = 0; + for (; i < maDriverInfo.size(); i++) { + if (maDriverInfo[i].meOperatingSystem != wgl::DRIVER_OS_ALL && + maDriverInfo[i].meOperatingSystem != eOS) + { + continue; + } + + if (maDriverInfo[i].mnOperatingSystemVersion && maDriverInfo[i].mnOperatingSystemVersion != mnWindowsVersion) { + continue; + } + + if (!maDriverInfo[i].maAdapterVendor.equalsIgnoreAsciiCase(GetDeviceVendor(wgl::VendorAll)) && + !maDriverInfo[i].maAdapterVendor.equalsIgnoreAsciiCase(maAdapterVendorID)) { + continue; + } + + if (maDriverInfo[i].mpDevices != wgl::DriverInfo::allDevices && maDriverInfo[i].mpDevices->size()) { + bool deviceMatches = false; + for (uint32_t j = 0; j < maDriverInfo[i].mpDevices->size(); j++) { + if ((*maDriverInfo[i].mpDevices)[j].equalsIgnoreAsciiCase(maAdapterDeviceID)) { + deviceMatches = true; + break; + } + } + + if (!deviceMatches) { + continue; + } + } + +#if defined(XP_WIN) || defined(ANDROID) + switch (maDriverInfo[i].meComparisonOp) { + case DRIVER_LESS_THAN: + match = driverVersion < maDriverInfo[i].mnDriverVersion; + break; + case DRIVER_LESS_THAN_OR_EQUAL: + match = driverVersion <= maDriverInfo[i].mnDriverVersion; + break; + case DRIVER_GREATER_THAN: + match = driverVersion > maDriverInfo[i].mnDriverVersion; + break; + case DRIVER_GREATER_THAN_OR_EQUAL: + match = driverVersion >= maDriverInfo[i].mnDriverVersion; + break; + case DRIVER_EQUAL: + match = driverVersion == maDriverInfo[i].mnDriverVersion; + break; + case DRIVER_NOT_EQUAL: + match = driverVersion != maDriverInfo[i].mnDriverVersion; + break; + case DRIVER_BETWEEN_EXCLUSIVE: + match = driverVersion > maDriverInfo[i].mnDriverVersion && driverVersion < maDriverInfo[i].mnDriverVersionMax; + break; + case DRIVER_BETWEEN_INCLUSIVE: + match = driverVersion >= maDriverInfo[i].mnDriverVersion && driverVersion <= maDriverInfo[i].mnDriverVersionMax; + break; + case DRIVER_BETWEEN_INCLUSIVE_START: + match = driverVersion >= maDriverInfo[i].mnDriverVersion && driverVersion < maDriverInfo[i].mnDriverVersionMax; + break; + case DRIVER_COMPARISON_IGNORED: + // We don't have a comparison op, so we match everything. + match = true; + break; + default: + SAL_WARN("vcl.opengl", "Bogus op in GfxDriverInfo"); + break; + } +#else + // We don't care what driver version it was. We only check OS version and if + // the device matches. + match = true; +#endif + + if (match || maDriverInfo[i].mnDriverVersion == wgl::DriverInfo::allDriverVersions) { + match = true; + SAL_WARN("vcl.opengl", "use : " << maDriverInfo[i].maSuggestedVersion); + break; + } + } + + return match; +} + bool WinOpenGLDeviceInfo::isDeviceBlocked() { SAL_INFO("vcl.opengl", maDriverVersion); @@ -562,7 +680,13 @@ bool WinOpenGLDeviceInfo::isDeviceBlocked() SAL_INFO("vcl.opengl", maAdapterSubsysID); SAL_INFO("vcl.opengl", maDeviceKey); SAL_INFO("vcl.opengl", maDeviceString); - return false; + + // Check if the device is blocked from the downloaded blocklist. If not, check + // the static list after that. This order is used so that we can later escape + // out of static blocks (i.e. if we were wrong or something was patched, we + // can back out our static block without doing a release). + + return FindBlocklistedDeviceInList(); } void WinOpenGLDeviceInfo::GetData() commit ea4394c57d43bf3eea797faccb52a89370b47300 Author: Markus Mohrhard <[email protected]> Date: Thu Nov 27 15:46:27 2014 +0100 port blacklist from mozilla code to LibreOffice, part2 Change-Id: Ia5810aa5f9e1e169b5f0217f6f176a253dc1439d diff --git a/vcl/inc/opengl/win/WinDeviceInfo.hxx b/vcl/inc/opengl/win/WinDeviceInfo.hxx index db91687..2c478ee 100644 --- a/vcl/inc/opengl/win/WinDeviceInfo.hxx +++ b/vcl/inc/opengl/win/WinDeviceInfo.hxx @@ -73,6 +73,67 @@ enum DeviceVendor { DeviceVendorMax }; +struct DriverInfo +{ + typedef std::vector<OUString> DeviceFamilyVector; + + // If |ownDevices| is true, you are transferring ownership of the devices + // array, and it will be deleted when this GfxDriverInfo is destroyed. + + DriverInfo(OperatingSystem os, const OUString& vendor, DeviceFamilyVector* devices, + VersionComparisonOp op, + uint64_t driverVersion, const char *suggestedVersion = nullptr, + bool ownDevices = false); + + DriverInfo(); + DriverInfo(const DriverInfo&); + ~DriverInfo(); + + OperatingSystem meOperatingSystem; + uint32_t mnOperatingSystemVersion; + + OUString maAdapterVendor; + + static DeviceFamilyVector* const allDevices; + DeviceFamilyVector* mpDevices; + + // Whether the mDevices array should be deleted when this structure is + // deallocated. False by default. + bool mbDeleteDevices; + + VersionComparisonOp meComparisonOp; + + /* versions are assumed to be A.B.C.D packed as 0xAAAABBBBCCCCDDDD */ + uint64_t mnDriverVersion; + uint64_t mnDriverVersionMax; + static uint64_t allDriverVersions; + + static const DeviceFamilyVector* GetDeviceFamily(DeviceFamily id); + static DeviceFamilyVector* mpDeviceFamilies[DeviceFamilyMax]; + + OUString maModel, maHardware, maProduct, maManufacturer; +}; + +#define GFX_DRIVER_VERSION(a,b,c,d) \ + ((uint64_t(a)<<48) | (uint64_t(b)<<32) | (uint64_t(c)<<16) | uint64_t(d)) + +inline uint64_t V(uint32_t a, uint32_t b, uint32_t c, uint32_t d) +{ + // We make sure every driver number is padded by 0s, this will allow us the + // easiest 'compare as if decimals' approach. See ParseDriverVersion for a + // more extensive explanation of this approach. + while (b > 0 && b < 1000) { + b *= 10; + } + while (c > 0 && c < 1000) { + c *= 10; + } + while (d > 0 && d < 1000) { + d *= 10; + } + return GFX_DRIVER_VERSION(a, b, c, d); +} + } class WinOpenGLDeviceInfo : public OpenGLDeviceInfo @@ -107,12 +168,15 @@ private: bool mbRDP; void GetData(); - OUString GetDeviceVendor(wgl::DeviceVendor eVendor); + void FillBlacklist(); static OUString* mpDeviceVendors[wgl::DeviceVendorMax]; + static std::vector<wgl::DriverInfo> maDriverInfo; public: WinOpenGLDeviceInfo(); + + static OUString GetDeviceVendor(wgl::DeviceVendor eVendor); virtual ~WinOpenGLDeviceInfo(); virtual bool isDeviceBlocked(); diff --git a/vcl/opengl/win/WinDeviceInfo.cxx b/vcl/opengl/win/WinDeviceInfo.cxx index 21ea19f..bab420c 100644 --- a/vcl/opengl/win/WinDeviceInfo.cxx +++ b/vcl/opengl/win/WinDeviceInfo.cxx @@ -15,6 +15,22 @@ #include <rtl/ustrbuf.hxx> OUString* WinOpenGLDeviceInfo::mpDeviceVendors[wgl::DeviceVendorMax]; +std::vector<wgl::DriverInfo> WinOpenGLDeviceInfo::maDriverInfo; + +#define APPEND_TO_DRIVER_BLOCKLIST(os, vendor, devices, driverComparator, driverVersion, suggestedVersion) \ + maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion, suggestedVersion)) +#define APPEND_TO_DRIVER_BLOCKLIST2(os, vendor, devices, driverComparator, driverVersion) \ + maDriverInfo.push_back(wgl::DriverInfo(os, vendor, devices, driverComparator, driverVersion)) + +#define APPEND_TO_DRIVER_BLOCKLIST_RANGE(os, vendor, devices, driverComparator, driverVersion, driverVersionMax, suggestedVersion) \ + do { \ + assert(driverComparator == wgl::DRIVER_BETWEEN_EXCLUSIVE || \ + driverComparator == wgl::DRIVER_BETWEEN_INCLUSIVE || \ + driverComparator == wgl::DRIVER_BETWEEN_INCLUSIVE_START); \ + wgl::DriverInfo info(os, vendor, devices, driverComparator, driverVersion, suggestedVersion); \ + info.mnDriverVersionMax = driverVersionMax; \ + maDriverInfo.push_back(info); \ + } while (false) namespace { @@ -319,6 +335,211 @@ template<typename T> void appendIntegerWithPadding(OUString& rString, T value, s #define DEVICE_KEY_PREFIX L"\\Registry\\Machine\\" } +namespace wgl { + +uint64_t DriverInfo::allDriverVersions = ~(uint64_t(0)); +DriverInfo::DeviceFamilyVector* const DriverInfo::allDevices = nullptr; + +DriverInfo::DeviceFamilyVector* DriverInfo::mpDeviceFamilies[DeviceFamilyMax]; + +DriverInfo::DriverInfo() + : meOperatingSystem(wgl::DRIVER_OS_UNKNOWN), + mnOperatingSystemVersion(0), + maAdapterVendor(WinOpenGLDeviceInfo::GetDeviceVendor(VendorAll)), + mpDevices(allDevices), + mbDeleteDevices(false), + meComparisonOp(DRIVER_COMPARISON_IGNORED), + mnDriverVersion(0), + mnDriverVersionMax(0) +{} + +DriverInfo::DriverInfo(OperatingSystem os, const OUString& vendor, + DeviceFamilyVector* devices, + VersionComparisonOp op, + uint64_t driverVersion, + const char *suggestedVersion /* = nullptr */, + bool ownDevices /* = false */) + : meOperatingSystem(os), + mnOperatingSystemVersion(0), + maAdapterVendor(vendor), + mpDevices(devices), + mbDeleteDevices(ownDevices), + meComparisonOp(op), + mnDriverVersion(driverVersion), + mnDriverVersionMax(0) +{} + +DriverInfo::DriverInfo(const DriverInfo& aOrig) + : meOperatingSystem(aOrig.meOperatingSystem), + mnOperatingSystemVersion(aOrig.mnOperatingSystemVersion), + maAdapterVendor(aOrig.maAdapterVendor), + meComparisonOp(aOrig.meComparisonOp), + mnDriverVersion(aOrig.mnDriverVersion), + mnDriverVersionMax(aOrig.mnDriverVersionMax) +{ + //If we're managing the lifetime of the device family, we have to make a + // copy of the original's device family. + if (aOrig.mbDeleteDevices && aOrig.mpDevices) { + mpDevices = new DeviceFamilyVector; + *mpDevices = *aOrig.mpDevices; + } else { + mpDevices = aOrig.mpDevices; + } + + mbDeleteDevices = aOrig.mbDeleteDevices; +} + +DriverInfo::~DriverInfo() +{ + if (mbDeleteDevices) + delete mpDevices; +} + +// Macros for appending a device to the DeviceFamily. +#define APPEND_DEVICE(device) APPEND_DEVICE2(#device) +#define APPEND_DEVICE2(device) deviceFamily->push_back(OUString("#device")) + +const DriverInfo::DeviceFamilyVector* DriverInfo::GetDeviceFamily(DeviceFamily id) +{ + // The code here is too sensitive to fall through to the default case if the + // code is invalid. + assert(id >= 0 && id < DeviceFamilyMax); + + // If it already exists, we must have processed it once, so return it now. + if (mpDeviceFamilies[id]) + return mpDeviceFamilies[id]; + + mpDeviceFamilies[id] = new wgl::DriverInfo::DeviceFamilyVector; + wgl::DriverInfo::DeviceFamilyVector* deviceFamily = mpDeviceFamilies[id]; + + switch (id) { + case IntelGMA500: + APPEND_DEVICE(0x8108); /* IntelGMA500_1 */ + APPEND_DEVICE(0x8109); /* IntelGMA500_2 */ + break; + case IntelGMA900: + APPEND_DEVICE(0x2582); /* IntelGMA900_1 */ + APPEND_DEVICE(0x2782); /* IntelGMA900_2 */ + APPEND_DEVICE(0x2592); /* IntelGMA900_3 */ + APPEND_DEVICE(0x2792); /* IntelGMA900_4 */ + break; + case IntelGMA950: + APPEND_DEVICE(0x2772); /* Intel945G_1 */ + APPEND_DEVICE(0x2776); /* Intel945G_2 */ + APPEND_DEVICE(0x27a2); /* Intel945_1 */ + APPEND_DEVICE(0x27a6); /* Intel945_2 */ + APPEND_DEVICE(0x27ae); /* Intel945_3 */ + break; + case IntelGMA3150: + APPEND_DEVICE(0xa001); /* IntelGMA3150_Nettop_1 */ + APPEND_DEVICE(0xa002); /* IntelGMA3150_Nettop_2 */ + APPEND_DEVICE(0xa011); /* IntelGMA3150_Netbook_1 */ + APPEND_DEVICE(0xa012); /* IntelGMA3150_Netbook_2 */ + break; + case IntelGMAX3000: + APPEND_DEVICE(0x2972); /* Intel946GZ_1 */ + APPEND_DEVICE(0x2973); /* Intel946GZ_2 */ + APPEND_DEVICE(0x2982); /* IntelG35_1 */ + APPEND_DEVICE(0x2983); /* IntelG35_2 */ + APPEND_DEVICE(0x2992); /* IntelQ965_1 */ + APPEND_DEVICE(0x2993); /* IntelQ965_2 */ + APPEND_DEVICE(0x29a2); /* IntelG965_1 */ + APPEND_DEVICE(0x29a3); /* IntelG965_2 */ + APPEND_DEVICE(0x29b2); /* IntelQ35_1 */ + APPEND_DEVICE(0x29b3); /* IntelQ35_2 */ + APPEND_DEVICE(0x29c2); /* IntelG33_1 */ + APPEND_DEVICE(0x29c3); /* IntelG33_2 */ + APPEND_DEVICE(0x29d2); /* IntelQ33_1 */ + APPEND_DEVICE(0x29d3); /* IntelQ33_2 */ + APPEND_DEVICE(0x2a02); /* IntelGL960_1 */ + APPEND_DEVICE(0x2a03); /* IntelGL960_2 */ + APPEND_DEVICE(0x2a12); /* IntelGM965_1 */ + APPEND_DEVICE(0x2a13); /* IntelGM965_2 */ + break; + case IntelGMAX4500HD: + APPEND_DEVICE(0x2a42); /* IntelGMA4500MHD_1 */ + APPEND_DEVICE(0x2a43); /* IntelGMA4500MHD_2 */ + APPEND_DEVICE(0x2e42); /* IntelB43_1 */ + APPEND_DEVICE(0x2e43); /* IntelB43_2 */ + APPEND_DEVICE(0x2e92); /* IntelB43_3 */ + APPEND_DEVICE(0x2e93); /* IntelB43_4 */ + APPEND_DEVICE(0x2e32); /* IntelG41_1 */ + APPEND_DEVICE(0x2e33); /* IntelG41_2 */ + APPEND_DEVICE(0x2e22); /* IntelG45_1 */ + APPEND_DEVICE(0x2e23); /* IntelG45_2 */ + APPEND_DEVICE(0x2e12); /* IntelQ45_1 */ + APPEND_DEVICE(0x2e13); /* IntelQ45_2 */ + APPEND_DEVICE(0x0042); /* IntelHDGraphics */ + APPEND_DEVICE(0x0046); /* IntelMobileHDGraphics */ + APPEND_DEVICE(0x0102); /* IntelSandyBridge_1 */ + APPEND_DEVICE(0x0106); /* IntelSandyBridge_2 */ + APPEND_DEVICE(0x0112); /* IntelSandyBridge_3 */ + APPEND_DEVICE(0x0116); /* IntelSandyBridge_4 */ + APPEND_DEVICE(0x0122); /* IntelSandyBridge_5 */ + APPEND_DEVICE(0x0126); /* IntelSandyBridge_6 */ + APPEND_DEVICE(0x010a); /* IntelSandyBridge_7 */ + APPEND_DEVICE(0x0080); /* IntelIvyBridge */ + break; + case IntelHD3000: + APPEND_DEVICE(0x0126); + break; + case IntelMobileHDGraphics: + APPEND_DEVICE(0x0046); /* IntelMobileHDGraphics */ + break; + case NvidiaBlockD3D9Layers: + // Glitches whilst scrolling (see bugs 612007, 644787, 645872) + APPEND_DEVICE(0x00f3); /* NV43 [GeForce 6200 (TM)] */ + APPEND_DEVICE(0x0146); /* NV43 [Geforce Go 6600TE/6200TE (TM)] */ + APPEND_DEVICE(0x014f); /* NV43 [GeForce 6200 (TM)] */ + APPEND_DEVICE(0x0161); /* NV44 [GeForce 6200 TurboCache (TM)] */ + APPEND_DEVICE(0x0162); /* NV44 [GeForce 6200SE TurboCache (TM)] */ + APPEND_DEVICE(0x0163); /* NV44 [GeForce 6200 LE (TM)] */ + APPEND_DEVICE(0x0164); /* NV44 [GeForce Go 6200 (TM)] */ + APPEND_DEVICE(0x0167); /* NV43 [GeForce Go 6200/6400 (TM)] */ + APPEND_DEVICE(0x0168); /* NV43 [GeForce Go 6200/6400 (TM)] */ + APPEND_DEVICE(0x0169); /* NV44 [GeForce 6250 (TM)] */ + APPEND_DEVICE(0x0222); /* NV44 [GeForce 6200 A-LE (TM)] */ + APPEND_DEVICE(0x0240); /* C51PV [GeForce 6150 (TM)] */ + APPEND_DEVICE(0x0241); /* C51 [GeForce 6150 LE (TM)] */ + APPEND_DEVICE(0x0244); /* C51 [Geforce Go 6150 (TM)] */ + APPEND_DEVICE(0x0245); /* C51 [Quadro NVS 210S/GeForce 6150LE (TM)] */ + APPEND_DEVICE(0x0247); /* C51 [GeForce Go 6100 (TM)] */ + APPEND_DEVICE(0x03d0); /* C61 [GeForce 6150SE nForce 430 (TM)] */ + APPEND_DEVICE(0x03d1); /* C61 [GeForce 6100 nForce 405 (TM)] */ + APPEND_DEVICE(0x03d2); /* C61 [GeForce 6100 nForce 400 (TM)] */ + APPEND_DEVICE(0x03d5); /* C61 [GeForce 6100 nForce 420 (TM)] */ + break; + case RadeonX1000: + // This list is from the ATIRadeonX1000.kext Info.plist + APPEND_DEVICE(0x7187); + APPEND_DEVICE(0x7210); + APPEND_DEVICE(0x71de); + APPEND_DEVICE(0x7146); + APPEND_DEVICE(0x7142); + APPEND_DEVICE(0x7109); + APPEND_DEVICE(0x71c5); + APPEND_DEVICE(0x71c0); + APPEND_DEVICE(0x7240); + APPEND_DEVICE(0x7249); + APPEND_DEVICE(0x7291); + break; + case Geforce7300GT: + APPEND_DEVICE(0x0393); + break; + case Nvidia310M: + APPEND_DEVICE(0x0A70); + break; + // This should never happen, but we get a warning if we don't handle this. + case DeviceFamilyMax: + SAL_WARN("vcl.opengl", "Invalid DeviceFamily id"); + break; + } + + return deviceFamily; +} + +} + WinOpenGLDeviceInfo::WinOpenGLDeviceInfo(): mbHasDualGPU(false), mbHasDriverVersionMismatch(false), @@ -630,5 +851,130 @@ OUString WinOpenGLDeviceInfo::GetDeviceVendor(wgl::DeviceVendor id) return *mpDeviceVendors[id]; } +void WinOpenGLDeviceInfo::FillBlacklist() +{ + /* + * It should be noted here that more specialized rules on certain features + * should be inserted -before- more generalized restriction. As the first + * match for feature/OS/device found in the list will be used for the final + * blacklisting call. + */ + + /* + * NVIDIA entries + */ + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_WINDOWS_XP, + GetDeviceVendor(wgl::VendorNVIDIA), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(6,14,11,8265), "182.65" ); + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_WINDOWS_VISTA, + GetDeviceVendor(wgl::VendorNVIDIA), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(8,17,11,8265), "182.65" ); + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_WINDOWS_7, + GetDeviceVendor(wgl::VendorNVIDIA), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(8,17,11,8265), "182.65" ); + + /* + * AMD/ATI entries + */ + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(8,62,0,0), "9.6" ); + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(8,62,0,0), "9.6" ); + + /* + * Bug 783517 - crashes in AMD driver on Windows 8 + */ + APPEND_TO_DRIVER_BLOCKLIST_RANGE( wgl::DRIVER_OS_WINDOWS_8, + GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices, + wgl::DRIVER_BETWEEN_INCLUSIVE_START, wgl::V(8,982,0,0), wgl::V(8,983,0,0), "!= 8.982.*.*" ); + APPEND_TO_DRIVER_BLOCKLIST_RANGE( wgl::DRIVER_OS_WINDOWS_8, + GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices, + wgl::DRIVER_BETWEEN_INCLUSIVE_START, wgl::V(8,982,0,0), wgl::V(8,983,0,0), "!= 8.982.*.*" ); + + /* OpenGL on any ATI/AMD hardware is discouraged + * See: + * bug 619773 - WebGL: Crash with blue screen : "NMI: Parity Check / Memory Parity Error" + * bugs 584403, 584404, 620924 - crashes in atioglxx + * + many complaints about incorrect rendering + */ + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorATI), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorAMD), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + + /* + * Intel entries + */ + + /* The driver versions used here come from bug 594877. They might not + * be particularly relevant anymore. + */ +#define IMPLEMENT_INTEL_DRIVER_BLOCKLIST(winVer, devFamily, driverVer) \ + APPEND_TO_DRIVER_BLOCKLIST2( winVer, \ + GetDeviceVendor(wgl::VendorIntel), (wgl::DriverInfo::DeviceFamilyVector*) wgl::DriverInfo::GetDeviceFamily(devFamily), \ + wgl::DRIVER_LESS_THAN, driverVer ) + + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA500, wgl::V(3,0,20,3200)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA900, wgl::V(6,14,10,4764)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA950, wgl::V(6,14,10,4926)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMA3150, wgl::V(6,14,10,5134)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMAX3000, wgl::V(6,14,10,5218)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_XP, wgl::IntelGMAX4500HD, wgl::V(6,14,10,4969)); + + // StrechRect seems to suffer from precision issues which leads to artifacting + // during content drawing starting with at least version 6.14.10.5082 + // and going until 6.14.10.5218. See bug 919454 and bug 949275 for more info. + APPEND_TO_DRIVER_BLOCKLIST_RANGE(wgl::DRIVER_OS_WINDOWS_XP, + GetDeviceVendor(wgl::VendorIntel), + const_cast<wgl::DriverInfo::DeviceFamilyVector*>(wgl::DriverInfo::GetDeviceFamily(wgl::IntelGMAX4500HD)), + wgl::DRIVER_BETWEEN_EXCLUSIVE, wgl::V(6,14,10,5076), wgl::V(6,14,10,5218), "6.14.10.5218"); + + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA500, wgl::V(3,0,20,3200)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA900, wgl::DriverInfo::allDriverVersions); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA950, wgl::V(7,14,10,1504)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMA3150, wgl::V(7,14,10,1910)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMAX3000, wgl::V(7,15,10,1666)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_VISTA, wgl::IntelGMAX4500HD, wgl::V(7,15,10,1666)); + + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA500, wgl::V(5,0,0,2026)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA900, wgl::DriverInfo::allDriverVersions); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA950, wgl::V(8,15,10,1930)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMA3150, wgl::V(8,14,10,1972)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMAX3000, wgl::V(7,15,10,1666)); + IMPLEMENT_INTEL_DRIVER_BLOCKLIST(wgl::DRIVER_OS_WINDOWS_7, wgl::IntelGMAX4500HD, wgl::V(7,15,10,1666)); + + /* OpenGL on any Intel hardware is discouraged */ + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorIntel), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + APPEND_TO_DRIVER_BLOCKLIST2( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorIntel), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::DriverInfo::allDriverVersions ); + + /** + * Disable acceleration on Intel HD 3000 for graphics drivers <= 8.15.10.2321. + * See bug 1018278 and bug 1060736. + */ + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorIntel), (wgl::DriverInfo::DeviceFamilyVector*) wgl::DriverInfo::GetDeviceFamily(wgl::IntelHD3000), + wgl::DRIVER_LESS_THAN_OR_EQUAL, wgl::V(8,15,10,2321), "8.15.10.2342" ); + + /* Microsoft RemoteFX; blocked less than 6.2.0.0 */ + APPEND_TO_DRIVER_BLOCKLIST( wgl::DRIVER_OS_ALL, + GetDeviceVendor(wgl::VendorMicrosoft), wgl::DriverInfo::allDevices, + wgl::DRIVER_LESS_THAN, wgl::V(6,2,0,0), "< 6.2.0.0" ); + +} + /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ commit 914915ac6d23373500ee584edeaaabc00fdd6aea Author: Markus Mohrhard <[email protected]> Date: Sun Nov 23 01:39:02 2014 +0100 block my OpenGL driver Kendy and I both ahve the same issue related to the driver returning the wrong attribute location in some shaders Change-Id: I496c0f545f7c28c71a94ca8a9ff9fb0b0df46005 diff --git a/vcl/opengl/x11/X11DeviceInfo.cxx b/vcl/opengl/x11/X11DeviceInfo.cxx index cf04d43..c678d4a 100644 --- a/vcl/opengl/x11/X11DeviceInfo.cxx +++ b/vcl/opengl/x11/X11DeviceInfo.cxx @@ -281,6 +281,11 @@ bool X11OpenGLDeviceInfo::isDeviceBlocked() SAL_WARN("vcl.opengl", "blocked driver version: requires at least mesa 7.10.3"); return true; } + else if (mbIsIntel && version(mnMajorVersion, mnMinorVersion, mnRevisionVersion) == version(9,0,2)) + { + SAL_WARN("vcl.opengl", "blocked driver version: my broken intel driver Mesa 9.0.2"); + return true; + } else if (mbIsOldSwrast) { SAL_WARN("vcl.opengl", "blocked driver version: software rasterizer"); return true; commit 1d7c80e01429125b0f9f55d130203a8326207e1d Author: Markus Mohrhard <[email protected]> Date: Sat Nov 22 16:55:44 2014 +0100 fix glx resource leak Change-Id: I013676d2f4caa0479c917a7f833966be8f0b8009 diff --git a/vcl/source/opengl/OpenGLContext.cxx b/vcl/source/opengl/OpenGLContext.cxx index 17c2c69..8a04cc2 100644 --- a/vcl/source/opengl/OpenGLContext.cxx +++ b/vcl/source/opengl/OpenGLContext.cxx @@ -116,8 +116,8 @@ OpenGLContext::~OpenGLContext() } glXDestroyContext(m_aGLWin.dpy, m_aGLWin.ctx); - if (mbPixmap) - glXDestroyGLXPixmap(m_aGLWin.dpy, m_aGLWin.glPix); + if (mbPixmap && m_aGLWin.glPix != None) + glXDestroyPixmap(m_aGLWin.dpy, m_aGLWin.glPix); } #endif } @@ -658,6 +658,12 @@ void OpenGLContext::resetToReInitialize() if( !mbInitialized ) return; resetCurrent(); + + if (mbPixmap) + { + glXDestroyPixmap(m_aGLWin.dpy, m_aGLWin.glPix); + m_aGLWin.glPix = None; + } mbInitialized = false; } commit f6cda7d91f3c2f3dce9c71eb4263c83a0a6d7e48 Author: Markus Mohrhard <[email protected]> Date: Fri Nov 21 12:45:51 2014 +0100 make glxtest available in salmain Change-Id: Ic8bc3f2d5d96506590d35138089ead2eac984314 diff --git a/desktop/Library_sofficeapp.mk b/desktop/Library_sofficeapp.mk index f322a6c..da37f9a 100644 --- a/desktop/Library_sofficeapp.mk +++ b/desktop/Library_sofficeapp.mk @@ -95,8 +95,8 @@ $(eval $(call gb_Library_add_exception_objects,sofficeapp,\ )) ifeq ($(OS),LINUX) -$(eval $(call gb_Library_add_exception_objects,sofficeapp,\ - desktop/unx/source/glxtest \ +$(eval $(call gb_Library_use_static_libraries,sofficeapp,\ + glxtest \ )) $(eval $(call gb_Library_add_libs,sofficeapp,\ diff --git a/include/vcl/opengl/glxtest.hxx b/include/vcl/opengl/glxtest.hxx index 0889cdd..687038f 100644 --- a/include/vcl/opengl/glxtest.hxx +++ b/include/vcl/opengl/glxtest.hxx @@ -16,6 +16,8 @@ VCL_DLLPUBLIC int* getGlxPipe(); VCL_DLLPUBLIC pid_t* getGlxPid(); +bool fire_glxtest_process(); + #endif /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/svx/Executable_gengal.mk b/svx/Executable_gengal.mk index 55cc2f1..17a57dc 100644 --- a/svx/Executable_gengal.mk +++ b/svx/Executable_gengal.mk @@ -65,6 +65,13 @@ ifeq ($(OS),LINUX) $(eval $(call gb_Executable_add_libs,gengal,\ -ldl \ -lpthread \ + -lGL \ + -lGLU \ + -lX11 \ +)) + +$(eval $(call gb_Executable_use_static_libraries,gengal,\ + glxtest \ )) endif diff --git a/sw/Executable_tiledrendering.mk b/sw/Executable_tiledrendering.mk index 089b0f5..f5664da 100644 --- a/sw/Executable_tiledrendering.mk +++ b/sw/Executable_tiledrendering.mk @@ -42,4 +42,20 @@ $(eval $(call gb_Executable_add_exception_objects,tiledrendering,\ sw/qa/tiledrendering/tiledrendering \ )) +ifeq ($(OS),LINUX) + +$(eval $(call gb_Executable_add_libs,tiledrendering,\ + -lm \ + -ldl \ + -lpthread \ + -lGL \ + -lGLU \ + -lX11 \ +)) + +$(eval $(call gb_Executable_use_static_libraries,tiledrendering,\ + glxtest \ +)) +endif + # vim: set noet sw=4 ts=4: diff --git a/vcl/Executable_icontest.mk b/vcl/Executable_icontest.mk index d7962d8..00dc906 100644 --- a/vcl/Executable_icontest.mk +++ b/vcl/Executable_icontest.mk @@ -24,7 +24,16 @@ $(eval $(call gb_Executable_use_api,icontest,\ ifeq ($(OS),LINUX) $(eval $(call gb_Executable_add_libs,icontest,\ + -lm \ + -ldl \ + -lpthread \ -lGL \ + -lGLU \ + -lX11 \ +)) + +$(eval $(call gb_Executable_use_static_libraries,icontest,\ + glxtest \ )) else ifeq ($(OS),WNT) diff --git a/vcl/Executable_ui-previewer.mk b/vcl/Executable_ui-previewer.mk index 444ded1..665f683 100644 --- a/vcl/Executable_ui-previewer.mk +++ b/vcl/Executable_ui-previewer.mk @@ -34,4 +34,19 @@ $(eval $(call gb_Executable_add_exception_objects,ui-previewer,\ vcl/source/uipreviewer/previewer \ )) +ifeq ($(OS),LINUX) +$(eval $(call gb_Executable_add_libs,ui-previewer,\ + -lm \ + -ldl \ + -lpthread \ + -lGL \ + -lGLU \ + -lX11 \ +)) + +$(eval $(call gb_Executable_use_static_libraries,ui-previewer,\ + glxtest \ +)) +endif + # vim: set noet sw=4 ts=4: diff --git a/vcl/Executable_vcldemo.mk b/vcl/Executable_vcldemo.mk index 721605f..44f13b2 100644 --- a/vcl/Executable_vcldemo.mk +++ b/vcl/Executable_vcldemo.mk @@ -41,4 +41,19 @@ $(eval $(call gb_Executable_use_static_libraries,vcldemo,\ vclmain \ )) +ifeq ($(OS),LINUX) +$(eval $(call gb_Executable_add_libs,vcldemo,\ + -lm \ + -ldl \ + -lpthread \ + -lGL \ + -lGLU \ + -lX11 \ +)) + +$(eval $(call gb_Executable_use_static_libraries,vcldemo,\ + glxtest \ +)) +endif + # vim: set noet sw=4 ts=4: diff --git a/vcl/Module_vcl.mk b/vcl/Module_vcl.mk index 655aadb..329740a 100644 --- a/vcl/Module_vcl.mk +++ b/vcl/Module_vcl.mk @@ -47,6 +47,7 @@ $(eval $(call gb_Module_add_targets,vcl,\ Library_vclplug_gen \ Library_desktop_detector \ StaticLibrary_headless \ + StaticLibrary_glxtest \ Package_fontunxppds \ Package_fontunxpsprint \ )) diff --git a/vcl/StaticLibrary_glxtest.mk b/vcl/StaticLibrary_glxtest.mk new file mode 100644 index 0000000..1e28775 --- /dev/null +++ b/vcl/StaticLibrary_glxtest.mk @@ -0,0 +1,45 @@ +# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*- +# +# This file is part of the LibreOffice project. +# +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. +# +# This file incorporates work covered by the following license notice: +# +# Licensed to the Apache Software Foundation (ASF) under one or more +# contributor license agreements. See the NOTICE file distributed +# with this work for additional information regarding copyright +# ownership. The ASF licenses this file to you under the Apache +# License, Version 2.0 (the "License"); you may not use this file +# except in compliance with the License. You may obtain a copy of +# the License at http://www.apache.org/licenses/LICENSE-2.0 . +# + +$(eval $(call gb_StaticLibrary_StaticLibrary,glxtest)) + +$(eval $(call gb_StaticLibrary_set_include,glxtest,\ + $$(INCLUDE) \ + -I$(SRCDIR)/vcl/inc \ +)) + +$(eval $(call gb_StaticLibrary_use_api,glxtest,\ + offapi \ + udkapi \ +)) + +$(eval $(call gb_StaticLibrary_add_libs,glxtest,\ + -lm \ + -ldl \ + -lpthread \ + -lGL \ + -lGLU \ + -lX11 \ +)) + +$(eval $(call gb_StaticLibrary_add_exception_objects,glxtest,\ + vcl/unx/glxtest \ +)) + +# vim: set noet sw=4 ts=4: diff --git a/vcl/source/salmain/salmain.cxx b/vcl/source/salmain/salmain.cxx index 7f0f90a..e7318e8 100644 --- a/vcl/source/salmain/salmain.cxx +++ b/vcl/source/salmain/salmain.cxx @@ -28,7 +28,14 @@ #include "salinst.hxx" +#if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID +#include <vcl/opengl/glxtest.hxx> +#endif + SAL_IMPLEMENT_MAIN() { +#if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID + fire_glxtest_process(); +#endif tools::extendApplicationEnvironment(); vclmain::createApplication(); return SVMain(); diff --git a/desktop/unx/source/glxtest.cxx b/vcl/unx/glxtest.cxx similarity index 99% rename from desktop/unx/source/glxtest.cxx rename to vcl/unx/glxtest.cxx index df9603a..d1f9591 100644 --- a/desktop/unx/source/glxtest.cxx +++ b/vcl/unx/glxtest.cxx @@ -5,8 +5,6 @@ * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ -#include "app.hxx" - ////////////////////////////////////////////////////////////////////////////// // // Explanation: See bug 639842. Safely getting GL driver info on X11 is hard, because the only way to do commit a1394adeee866bd9dc16691af7961b4aa02c4d0e Author: Tor Lillqvist <[email protected]> Date: Tue Dec 2 13:23:47 2014 +0200 WaE: private field 'mnAttribIndex' is not used Change-Id: I939e184f6706fc0135f6906f0c183e5166aba5bb diff --git a/vcl/inc/opengl/program.hxx b/vcl/inc/opengl/program.hxx index 4b2b26f..2aeb2fd 100644 --- a/vcl/inc/opengl/program.hxx +++ b/vcl/inc/opengl/program.hxx @@ -29,7 +29,6 @@ private: GLuint mnId; UniformCache maUniformLocations; sal_uInt32 mnEnabledAttribs; - GLuint mnAttribIndex; GLuint mnPositionAttrib; GLuint mnTexCoordAttrib; GLuint mnAlphaCoordAttrib; diff --git a/vcl/opengl/program.cxx b/vcl/opengl/program.cxx index c9542c7..320b06f 100644 --- a/vcl/opengl/program.cxx +++ b/vcl/opengl/program.cxx @@ -17,7 +17,6 @@ OpenGLProgram::OpenGLProgram() : mnId( 0 ), mnEnabledAttribs( 0 ), - mnAttribIndex( 0 ), mnPositionAttrib( SAL_MAX_UINT32 ), mnTexCoordAttrib( SAL_MAX_UINT32 ), mnAlphaCoordAttrib( SAL_MAX_UINT32 ), commit 5060b4485469525310980990ca8df7e82f68206d Author: Michael Meeks <[email protected]> Date: Tue Dec 2 06:54:27 2014 +0000 vcl: use resetToReInitialize to avoid context problems on Windows. It appears that we have to do this for VirtualDevices, where we have freed / re-allocated the underlying resource, or we fail to switch the current context, and render to the wrong place, before blatting a blank texture over the top of it. Change-Id: I0253f216ea7dc9786374dc83ca38f4f6295e3035 diff --git a/vcl/opengl/gdiimpl.cxx b/vcl/opengl/gdiimpl.cxx index 462a479..46d72dc6 100644 --- a/vcl/opengl/gdiimpl.cxx +++ b/vcl/opengl/gdiimpl.cxx @@ -105,6 +105,15 @@ void OpenGLSalGraphicsImpl::Init() maOffscreenTex.GetHeight() != GetHeight() ) { maOffscreenTex = OpenGLTexture(); +#if defined(WNT) + // URGH ... VirtualDevice may have destroyed the underlying resource + // our context is associated with - FIXME: can we do better here ? + if (mpContext) + { + mpContext->resetToReInitialize(); + ReleaseContext(); + } +#endif } } diff --git a/vcl/source/opengl/OpenGLContext.cxx b/vcl/source/opengl/OpenGLContext.cxx index c02573d..17c2c69 100644 --- a/vcl/source/opengl/OpenGLContext.cxx +++ b/vcl/source/opengl/OpenGLContext.cxx @@ -622,6 +622,17 @@ bool OpenGLContext::init(SystemChildWindow* pChildWindow) return ImplInit(); } +#if defined( WNT ) +// FIXME share resetToReInitialize() across platforms... +void OpenGLContext::resetToReInitialize() +{ + if( !mbInitialized ) + return; + resetCurrent(); + mbInitialized = false; +} +#endif + #if defined( UNX ) && !defined MACOSX && !defined IOS && !defined ANDROID bool OpenGLContext::init(Display* dpy, Window win, int screen) { commit 4642bb86dce6f5e820bf8921b731db1adf4d40c3 Author: Michael Meeks <[email protected]> Date: Tue Dec 2 06:30:38 2014 +0000 vcl: OpenGL texture creation debug. Change-Id: I6a21c89329d9e9396ed16ce58b184339719adab7 diff --git a/vcl/opengl/texture.cxx b/vcl/opengl/texture.cxx index 0c45d77..cc5be78 100644 --- a/vcl/opengl/texture.cxx +++ b/vcl/opengl/texture.cxx @@ -41,6 +41,8 @@ ImplOpenGLTexture::ImplOpenGLTexture( int nWidth, int nHeight, bool bAllocate ) glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, nWidth, nHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL ); glBindTexture( GL_TEXTURE_2D, 0 ); + SAL_INFO( "vcl.opengl", "OpenGLTexture " << mnTexture << " " << nWidth << "x" << nHeight << " allocate" ); + CHECK_GL_ERROR(); } @@ -65,6 +67,8 @@ ImplOpenGLTexture::ImplOpenGLTexture( int nX, int nY, int nWidth, int nHeight ) CHECK_GL_ERROR(); glBindTexture( GL_TEXTURE_2D, 0 ); + SAL_INFO( "vcl.opengl", "OpenGLTexture " << mnTexture << " " << nWidth << "x" << nHeight << " from x" << nX << ", y" << nY ); + CHECK_GL_ERROR(); } @@ -87,6 +91,8 @@ ImplOpenGLTexture::ImplOpenGLTexture( int nWidth, int nHeight, int nFormat, int glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, mnWidth, mnHeight, 0, nFormat, nType, pData ); glBindTexture( GL_TEXTURE_2D, 0 ); + SAL_INFO( "vcl.opengl", "OpenGLTexture " << mnTexture << " " << nWidth << "x" << nHeight << " from data" ); + CHECK_GL_ERROR(); } commit f4527d8f17285a139ef8aa626c50c3b492108af9 Author: Louis-Francis Ratté-Boulianne <[email protected]> Date: Fri Nov 28 14:58:53 2014 -0500 vcl: Fix a coordinate issue when getting a bitmap from a VirtualDevice Change-Id: I06fef2765f2dc9d64a991385a984a4c75a1fd424 diff --git a/vcl/opengl/gdiimpl.cxx b/vcl/opengl/gdiimpl.cxx index 4d362b1..462a479 100644 --- a/vcl/opengl/gdiimpl.cxx +++ b/vcl/opengl/gdiimpl.cxx @@ -1113,8 +1113,8 @@ SalBitmap* OpenGLSalGraphicsImpl::getBitmap( long nX, long nY, long nWidth, long OpenGLSalBitmap* pBitmap = new OpenGLSalBitmap; SAL_INFO( "vcl.opengl", "::getBitmap " << nX << "," << nY << " " << nWidth << "x" << nHeight ); + //TODO really needed? PreDraw(); - nY = GetHeight() - nHeight - nY; if( !pBitmap->Create( maOffscreenTex, nX, nY, nWidth, nHeight ) ) { delete pBitmap; @@ -1129,6 +1129,7 @@ SalColor OpenGLSalGraphicsImpl::getPixel( long nX, long nY ) char pixel[3] = { 0, 0, 0 }; PreDraw(); + nY = GetHeight() - nY; glReadPixels( nX, nY, 1, 1, GL_RGB, GL_UNSIGNED_BYTE, pixel); PostDraw(); diff --git a/vcl/opengl/texture.cxx b/vcl/opengl/texture.cxx index 7618c04..0c45d77 100644 --- a/vcl/opengl/texture.cxx +++ b/vcl/opengl/texture.cxx @@ -52,6 +52,9 @@ ImplOpenGLTexture::ImplOpenGLTexture( int nX, int nY, int nWidth, int nHeight ) mnHeight( nHeight ), mnFilter( GL_NEAREST ) { + // FIXME We need the window height here + // nY = GetHeight() - nHeight - nY; + glGenTextures( 1, &mnTexture ); glBindTexture( GL_TEXTURE_2D, mnTexture ); glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE ); commit 5933c72dd39d597037528f8473fa2bf67e59a757 Author: Louis-Francis Ratté-Boulianne <[email protected]> Date: Fri Nov 28 14:56:08 2014 -0500 vcl: Only load OpenGL shaders once for each context Change-Id: Idbf9026c5e64ef41d4c913153dfddf36923ff7de diff --git a/include/vcl/opengl/OpenGLContext.hxx b/include/vcl/opengl/OpenGLContext.hxx index 6d99488..843821d 100644 --- a/include/vcl/opengl/OpenGLContext.hxx +++ b/include/vcl/opengl/OpenGLContext.hxx @@ -51,11 +51,13 @@ class NSOpenGLView; #include <vcl/vclopengl_dllapi.hxx> #include <boost/scoped_ptr.hpp> +#include <boost/unordered_map.hpp> #include <vcl/window.hxx> #include <tools/gen.hxx> #include <vcl/syschild.hxx> class OpenGLFramebuffer; +class OpenGLProgram; class OpenGLTexture; /// Holds the information of our new child window @@ -156,6 +158,31 @@ struct GLWindow ~GLWindow(); }; +struct ProgramKey +{ + OUString maVertexShader; + OUString maFragmentShader; + + ProgramKey( const OUString& rVertexShader, const OUString& rFragmentShader ) + { + maVertexShader = rVertexShader; + maFragmentShader = rFragmentShader; + } +}; + +inline bool operator==( ProgramKey const& k1, ProgramKey const& k2 ) +{ + return k1.maVertexShader == k2.maVertexShader && k1.maFragmentShader == k2.maFragmentShader; +} + +inline std::size_t hash_value( ProgramKey const& rKey ) +{ + std::size_t nSeed = 0x9e3779b9; + nSeed = rKey.maVertexShader.hashCode(); + nSeed = rKey.maFragmentShader.hashCode() + 0x9e3779b9 + (nSeed << 6) + (nSeed >> 2); + return nSeed; +} + class VCLOPENGL_DLLPUBLIC OpenGLContext { public: @@ -185,6 +212,10 @@ public: OpenGLFramebuffer* AcquireFramebuffer( const OpenGLTexture& rTexture ); void ReleaseFramebuffer( OpenGLFramebuffer* pFramebuffer ); + // retrieve a program from the cache or compile/link it + OpenGLProgram* GetProgram( const OUString& rVertexShader, const OUString& rFragmentShader ); + OpenGLProgram* UseProgram( const OUString& rVertexShader, const OUString& rFragmentShader ); + void makeCurrent(); void resetCurrent(); void swapBuffers(); @@ -241,6 +272,9 @@ private: OpenGLFramebuffer* mpFirstFramebuffer; OpenGLFramebuffer* mpLastFramebuffer; + boost::unordered_map<ProgramKey, OpenGLProgram*> maPrograms; + OpenGLProgram* mpCurrentProgram; + public: vcl::Region maClipRegion; int mnPainting; diff --git a/vcl/Library_vcl.mk b/vcl/Library_vcl.mk index a7b901f..ccf3ddb 100644 --- a/vcl/Library_vcl.mk +++ b/vcl/Library_vcl.mk @@ -127,6 +127,7 @@ $(eval $(call gb_Library_add_exception_objects,vcl,\ vcl/opengl/salbmp \ vcl/opengl/scale \ vcl/opengl/framebuffer \ + vcl/opengl/program \ vcl/opengl/texture \ vcl/source/opengl/OpenGLContext \ vcl/source/opengl/OpenGLHelper \ diff --git a/vcl/Package_opengl.mk b/vcl/Package_opengl.mk index d81c0ec..98ff78b 100644 --- a/vcl/Package_opengl.mk +++ b/vcl/Package_opengl.mk @@ -12,16 +12,14 @@ $(eval $(call gb_Package_Package,vcl_opengl_shader,$(SRCDIR)/vcl/opengl)) $(eval $(call gb_Package_add_files,vcl_opengl_shader,$(LIBO_ETC_FOLDER)/opengl,\ blendedTextureFragmentShader.glsl \ blendedTextureVertexShader.glsl \ + dumbVertexShader.glsl \ diffTextureFragmentShader.glsl \ convolutionFragmentShader.glsl \ linearGradientFragmentShader.glsl \ maskFragmentShader.glsl \ - maskVertexShader.glsl \ maskedTextureFragmentShader.glsl \ - maskedTextureVertexShader.glsl \ radialGradientFragmentShader.glsl \ solidFragmentShader.glsl \ - solidVertexShader.glsl \ textureFragmentShader.glsl \ textureVertexShader.glsl \ transformedTextureVertexShader.glsl \ diff --git a/vcl/inc/opengl/program.hxx b/vcl/inc/opengl/program.hxx new file mode 100644 index 0000000..4b2b26f --- /dev/null +++ b/vcl/inc/opengl/program.hxx @@ -0,0 +1,72 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ +/* + * This file is part of the LibreOffice project. + * + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + */ + +#ifndef INCLUDED_VCL_INC_OPENGL_PROGRAM_H +#define INCLUDED_VCL_INC_OPENGL_PROGRAM_H + +#include <GL/glew.h> +#include <vcl/dllapi.h> + +#include <basegfx/point/b2dpoint.hxx> +#include <rtl/ustring.hxx> +#include <tools/color.hxx> +#include <opengl/texture.hxx> + +#include <boost/unordered_map.hpp> + +typedef boost::unordered_map< OString, GLuint, OStringHash > UniformCache; +typedef std::list< OpenGLTexture > TextureList; + +class VCL_PLUGIN_PUBLIC OpenGLProgram +{ +private: + GLuint mnId; + UniformCache maUniformLocations; + sal_uInt32 mnEnabledAttribs; + GLuint mnAttribIndex; + GLuint mnPositionAttrib; + GLuint mnTexCoordAttrib; + GLuint mnAlphaCoordAttrib; + TextureList maTextures; + bool mbBlending; + +public: + OpenGLProgram(); + ~OpenGLProgram(); + + bool Load( const OUString& rVertexShader, const OUString& rFragmentShader ); + bool Use(); + bool Clean(); + + void SetVertices( const GLvoid* pData ); + void SetTextureCoord( const GLvoid* pData ); + void SetAlphaCoord( const GLvoid* pData ); + + void SetUniform2f( const OString& rName, GLfloat v1, GLfloat v2 ); + void SetUniform1fv( const OString& rName, GLsizei nCount, GLfloat* aValues ); + void SetUniform2fv( const OString& rName, GLsizei nCount, GLfloat* aValues ); + void SetColor( const OString& rName, SalColor nColor, sal_uInt8 nTransparency ); + void SetColorf( const OString& rName, SalColor nColor, double fTransparency ); + void SetColorWithIntensity( const OString& rName, const Color& rColor, long nFactor ); + void SetTexture( const OString& rName, OpenGLTexture& rTexture ); + void SetTransform( const OString& rName, const OpenGLTexture& rTexture, + const basegfx::B2DPoint& rNull, const basegfx::B2DPoint& rX, + const basegfx::B2DPoint& rY ); + void SetBlendMode( GLenum nSFactor, GLenum nDFactor ); + + bool DrawTexture( OpenGLTexture& rTexture ); + +protected: + void SetVertexAttrib( GLuint& rAttrib, const OString& rName, const GLvoid* pData ); + GLuint GetUniformLocation( const OString& rName ); +}; + +#endif // INCLUDED_VCL_INC_OPENGL_PROGRAM_H + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/vcl/inc/opengl/salbmp.hxx b/vcl/inc/opengl/salbmp.hxx index bc232b1..6938a22 100644 --- a/vcl/inc/opengl/salbmp.hxx +++ b/vcl/inc/opengl/salbmp.hxx @@ -99,17 +99,6 @@ private: private: - GLuint ImplGetTextureProgram(); - GLuint mnTexProgram; - GLuint mnTexSamplerUniform; - - GLuint ImplGetConvolutionProgram(); - GLuint mnConvProgram; - GLuint mnConvSamplerUniform; - GLuint mnConvKernelUniform; - GLuint mnConvKernelSizeUniform; - GLuint mnConvOffsetsUniform; - bool ImplScaleFilter( const double& rScaleX, const double& rScaleY, GLenum nFilter ); void ImplCreateKernel( const double& fScale, const Kernel& rKernel, GLfloat*& pWeights, sal_uInt32& aKernelSize ); bool ImplScaleConvolution( const double& rScaleX, const double& rScaleY, const Kernel& aKernel ); diff --git a/vcl/inc/opengl/texture.hxx b/vcl/inc/opengl/texture.hxx index ad4738a..3d99526 100644 --- a/vcl/inc/opengl/texture.hxx +++ b/vcl/inc/opengl/texture.hxx @@ -65,6 +65,7 @@ public: int GetWidth() const; int GetHeight() const; void GetCoord( GLfloat* pCoord, const SalTwoRect& rPosAry, bool bInverted=false ) const; + void GetWholeCoord( GLfloat* pCoord ) const; void Bind(); void Unbind(); diff --git a/vcl/inc/openglgdiimpl.hxx b/vcl/inc/openglgdiimpl.hxx index 39e39fc..3f3ef4e 100644 --- a/vcl/inc/openglgdiimpl.hxx +++ b/vcl/inc/openglgdiimpl.hxx @@ -25,6 +25,7 @@ #include <vcl/dllapi.h> #include "opengl/framebuffer.hxx" +#include "opengl/program.hxx" #include "opengl/texture.hxx" #include "regionband.hxx" @@ -44,6 +45,7 @@ protected: /// Pointer to the SalFrame or SalVirtualDevice SalGeometryProvider* mpParent; OpenGLFramebuffer* mpFramebuffer; + OpenGLProgram* mpProgram; // clipping vcl::Region maClipRegion; @@ -56,72 +58,17 @@ protected: SalColor mnLineColor; SalColor mnFillColor; - GLuint mnSolidProgram; - GLuint mnColorUniform; - - GLuint mnTextureProgram; - GLuint mnSamplerUniform; - - GLuint mnTransformedTextureProgram; - GLuint mnTransformedViewportUniform; - GLuint mnTransformedTransformUniform; - GLuint mnTransformedSamplerUniform; - - GLuint mnTransformedMaskedTextureProgram; - GLuint mnTransformedMaskedViewportUniform; - GLuint mnTransformedMaskedTransformUniform; - GLuint mnTransformedMaskedSamplerUniform; - GLuint mnTransformedMaskedMaskUniform; - - GLuint mnDiffTextureProgram; - GLuint mnDiffTextureUniform; - GLuint mnDiffMaskUniform; - - GLuint mnMaskedTextureProgram; - GLuint mnMaskedSamplerUniform; - GLuint mnMaskSamplerUniform; - - GLuint mnBlendedTextureProgram; - GLuint mnBlendedTextureUniform; - GLuint mnBlendedMaskUniform; - GLuint mnBlendedAlphaUniform; - - GLuint mnMaskProgram; - GLuint mnMaskUniform; - GLuint mnMaskColorUniform; - - GLuint mnLinearGradientProgram; - GLuint mnLinearGradientStartColorUniform; - GLuint mnLinearGradientEndColorUniform; - - GLuint mnRadialGradientProgram; - GLuint mnRadialGradientStartColorUniform; - GLuint mnRadialGradientEndColorUniform; - GLuint mnRadialGradientCenterUniform; - void ImplInitClipRegion(); void ImplSetClipBit( const vcl::Region& rClip, GLuint nMask ); bool CheckOffscreenTexture(); - bool CreateSolidProgram( void ); - bool CreateTextureProgram( void ); - bool CreateTransformedTextureProgram( void ); - bool CreateDiffTextureProgram( void ); - bool CreateMaskedTextureProgram( void ); - bool CreateBlendedTextureProgram( void ); - bool CreateTransformedMaskedTextureProgram( void ); - bool CreateMaskProgram( void ); - bool CreateLinearGradientProgram( void ); - bool CreateRadialGradientProgram( void ); - public: - void BeginSolid( SalColor nColor, sal_uInt8 nTransparency ); - void BeginSolid( SalColor nColor, double fTransparency ); - void BeginSolid( SalColor nColor ); - void EndSolid( void ); - void BeginInvert( void ); - void EndInvert( void ); + bool UseProgram( const OUString& rVertexShader, const OUString& rFragmentShader ); + bool UseSolid( SalColor nColor, sal_uInt8 nTransparency ); + bool UseSolid( SalColor nColor, double fTransparency ); + bool UseSolid( SalColor nColor ); + bool UseInvert(); void DrawPoint( long nX, long nY ); void DrawLine( long nX1, long nY1, long nX2, long nY2 ); diff --git a/vcl/opengl/solidVertexShader.glsl b/vcl/opengl/dumbVertexShader.glsl similarity index 100% rename from vcl/opengl/solidVertexShader.glsl rename to vcl/opengl/dumbVertexShader.glsl diff --git a/vcl/opengl/gdiimpl.cxx b/vcl/opengl/gdiimpl.cxx index acc84a1..4d362b1 100644 --- a/vcl/opengl/gdiimpl.cxx +++ b/vcl/opengl/gdiimpl.cxx @@ -34,77 +34,18 @@ #include "svdata.hxx" #include "opengl/salbmp.hxx" -#include <glm/glm.hpp> -#include <glm/gtc/type_ptr.hpp> #include <vector> -#define GL_ATTRIB_POS 0 -#define GL_ATTRIB_TEX 1 -#define GL_ATTRIB_TEX2 2 - -#define glUniformColor(nUniform, nColor, nTransparency) \ - glUniform4f( nUniform, \ - ((float) SALCOLOR_RED( nColor )) / 255, \ - ((float) SALCOLOR_GREEN( nColor )) / 255, \ - ((float) SALCOLOR_BLUE( nColor )) / 255, \ - (100 - nTransparency) * (1.0 / 100) ) - -#define glUniformColorf(nUniform, nColor, fTransparency) \ - glUniform4f( nUniform, \ - ((float) SALCOLOR_RED( nColor )) / 255, \ - ((float) SALCOLOR_GREEN( nColor )) / 255, \ - ((float) SALCOLOR_BLUE( nColor )) / 255, \ - (1.0f - fTransparency) ) - -#define glUniformColorIntensity(nUniform, aColor, nFactor) \ - glUniform4f( nUniform, \ - ((float) aColor.GetRed()) * nFactor / 25500.0, \ - ((float) aColor.GetGreen()) * nFactor / 25500.0, \ - ((float) aColor.GetBlue()) * nFactor / 25500.0, \ - 1.0f ) - OpenGLSalGraphicsImpl::OpenGLSalGraphicsImpl(SalGeometryProvider* pParent) : mpContext(0) , mpParent(pParent) , mpFramebuffer(NULL) + , mpProgram(NULL) , mbUseScissor(false) , mbUseStencil(false) , mbOffscreen(false) , mnLineColor(SALCOLOR_NONE) , mnFillColor(SALCOLOR_NONE) - , mnSolidProgram(0) - , mnColorUniform(0) - , mnTextureProgram(0) - , mnSamplerUniform(0) - , mnTransformedTextureProgram(0) - , mnTransformedViewportUniform(0) - , mnTransformedTransformUniform(0) - , mnTransformedSamplerUniform(0) - , mnTransformedMaskedTextureProgram(0) - , mnTransformedMaskedViewportUniform(0) - , mnTransformedMaskedTransformUniform(0) - , mnTransformedMaskedSamplerUniform(0) - , mnTransformedMaskedMaskUniform(0) - , mnDiffTextureProgram(0) - , mnDiffTextureUniform(0) - , mnDiffMaskUniform(0) - , mnMaskedTextureProgram(0) - , mnMaskedSamplerUniform(0) - , mnMaskSamplerUniform(0) - , mnBlendedTextureProgram(0) - , mnBlendedTextureUniform(0) - , mnBlendedMaskUniform(0) - , mnBlendedAlphaUniform(0) - , mnMaskProgram(0) - , mnMaskUniform(0) - , mnMaskColorUniform(0) - , mnLinearGradientProgram(0) - , mnLinearGradientStartColorUniform(0) - , mnLinearGradientEndColorUniform(0) - , mnRadialGradientProgram(0) - , mnRadialGradientStartColorUniform(0) - , mnRadialGradientEndColorUniform(0) - , mnRadialGradientCenterUniform(0) { } @@ -198,6 +139,11 @@ void OpenGLSalGraphicsImpl::PostDraw() glDisable( GL_SCISSOR_TEST ); if( mbUseStencil ) glDisable( GL_STENCIL_TEST ); + if( mpProgram ) + { + mpProgram->Clean(); + mpProgram = NULL; + } mpContext->ReleaseFramebuffer( mpFramebuffer ); mpFramebuffer = NULL; @@ -219,12 +165,13 @@ void OpenGLSalGraphicsImpl::ImplSetClipBit( const vcl::Region& rClip, GLuint nMa glStencilOp( GL_REPLACE, GL_KEEP, GL_KEEP ); glClear( GL_STENCIL_BUFFER_BIT ); - BeginSolid( MAKE_SALCOLOR( 0xFF, 0xFF, 0xFF ) ); - if( rClip.getRegionBand() ) - DrawRegionBand( *rClip.getRegionBand() ); - else - DrawPolyPolygon( rClip.GetAsB2DPolyPolygon() ); - EndSolid(); + if( UseSolid( MAKE_SALCOLOR( 0xFF, 0xFF, 0xFF ) ) ) + { + if( rClip.getRegionBand() ) + DrawRegionBand( *rClip.getRegionBand() ); + else + DrawPolyPolygon( rClip.GetAsB2DPolyPolygon() ); + } glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE ); glStencilMask( 0x00 ); @@ -375,231 +322,45 @@ bool OpenGLSalGraphicsImpl::CheckOffscreenTexture() return true; } -bool OpenGLSalGraphicsImpl::CreateSolidProgram( void ) -{ - SAL_INFO( "vcl.opengl", "::CreateSolidProgram" ); - mnSolidProgram = OpenGLHelper::LoadShaders( "solidVertexShader", "solidFragmentShader" ); - if( mnSolidProgram == 0 ) - return false; - - SAL_INFO( "vcl.opengl", "Solid Program Created" ); - glBindAttribLocation( mnSolidProgram, GL_ATTRIB_POS, "position" ); - mnColorUniform = glGetUniformLocation( mnSolidProgram, "color" ); - - CHECK_GL_ERROR(); - return true; -} - -bool OpenGLSalGraphicsImpl::CreateTextureProgram( void ) -{ - mnTextureProgram = OpenGLHelper::LoadShaders( "textureVertexShader", "textureFragmentShader" ); - if( mnTextureProgram == 0 ) - return false; - - glBindAttribLocation( mnTextureProgram, GL_ATTRIB_POS, "position" ); - glBindAttribLocation( mnTextureProgram, GL_ATTRIB_TEX, "tex_coord_in" ); - mnSamplerUniform = glGetUniformLocation( mnTextureProgram, "sampler" ); - - CHECK_GL_ERROR(); - return true; -} - -bool OpenGLSalGraphicsImpl::CreateTransformedTextureProgram( void ) -{ - mnTransformedTextureProgram = OpenGLHelper::LoadShaders( "transformedTextureVertexShader", "textureFragmentShader" ); - if( mnTransformedTextureProgram == 0 ) - return false; - - glBindAttribLocation( mnTransformedTextureProgram, GL_ATTRIB_POS, "position" ); - glBindAttribLocation( mnTransformedTextureProgram, GL_ATTRIB_TEX, "tex_coord_in" ); - mnTransformedViewportUniform = glGetUniformLocation( mnTransformedTextureProgram, "viewport" ); - mnTransformedTransformUniform = glGetUniformLocation( mnTransformedTextureProgram, "transform" ); - mnTransformedSamplerUniform = glGetUniformLocation( mnTransformedTextureProgram, "sampler" ); - - CHECK_GL_ERROR(); - return true; -} - -bool OpenGLSalGraphicsImpl::CreateDiffTextureProgram( void ) +bool OpenGLSalGraphicsImpl::UseProgram( const OUString& rVertexShader, const OUString& rFragmentShader ) { - mnDiffTextureProgram = OpenGLHelper::LoadShaders( "textureVertexShader", "diffTextureFragmentShader" ); - if( mnDiffTextureProgram == 0 ) - return false; - - glBindAttribLocation( mnDiffTextureProgram, GL_ATTRIB_POS, "position" ); - glBindAttribLocation( mnDiffTextureProgram, GL_ATTRIB_TEX, "tex_coord_in" ); - mnDiffTextureUniform = glGetUniformLocation( mnDiffTextureProgram, "texture" ); - mnDiffMaskUniform = glGetUniformLocation( mnDiffTextureProgram, "mask" ); - - CHECK_GL_ERROR(); - return true; + mpProgram = mpContext->UseProgram( rVertexShader, rFragmentShader ); + return ( mpProgram != NULL ); } -bool OpenGLSalGraphicsImpl::CreateMaskedTextureProgram( void ) +bool OpenGLSalGraphicsImpl::UseSolid( SalColor nColor, sal_uInt8 nTransparency ) { - mnMaskedTextureProgram = OpenGLHelper::LoadShaders( "maskedTextureVertexShader", "maskedTextureFragmentShader" ); - if( mnMaskedTextureProgram == 0 ) + if( nColor == SALCOLOR_NONE ) return false; - - glBindAttribLocation( mnMaskedTextureProgram, GL_ATTRIB_POS, "position" ); - glBindAttribLocation( mnMaskedTextureProgram, GL_ATTRIB_TEX, "tex_coord_in" ); - mnMaskedSamplerUniform = glGetUniformLocation( mnMaskedTextureProgram, "sampler" ); - mnMaskSamplerUniform = glGetUniformLocation( mnMaskedTextureProgram, "mask" ); - - CHECK_GL_ERROR(); - return true; -} - -bool OpenGLSalGraphicsImpl::CreateTransformedMaskedTextureProgram( void ) -{ - mnTransformedMaskedTextureProgram = OpenGLHelper::LoadShaders( "transformedTextureVertexShader", "maskedTextureFragmentShader" ); - if( mnTransformedMaskedTextureProgram == 0 ) + if( !UseProgram( "dumbVertexShader", "solidFragmentShader" ) ) return false; - - glBindAttribLocation( mnTransformedMaskedTextureProgram, GL_ATTRIB_POS, "position" ); - glBindAttribLocation( mnTransformedMaskedTextureProgram, GL_ATTRIB_TEX, "tex_coord_in" ); - mnTransformedMaskedViewportUniform = glGetUniformLocation( mnTransformedMaskedTextureProgram, "viewport" ); - mnTransformedMaskedTransformUniform = glGetUniformLocation( mnTransformedMaskedTextureProgram, "transform" ); - mnTransformedMaskedSamplerUniform = glGetUniformLocation( mnTransformedMaskedTextureProgram, "sampler" ); - mnTransformedMaskedMaskUniform = glGetUniformLocation( mnTransformedMaskedTextureProgram, "mask" ); - - CHECK_GL_ERROR(); + mpProgram->SetColor( "color", nColor, nTransparency ); return true; } -bool OpenGLSalGraphicsImpl::CreateBlendedTextureProgram( void ) +bool OpenGLSalGraphicsImpl::UseSolid( SalColor nColor, double fTransparency ) { - mnBlendedTextureProgram = OpenGLHelper::LoadShaders( "blendedTextureVertexShader", "blendedTextureFragmentShader" ); - if( mnBlendedTextureProgram == 0 ) + if( nColor == SALCOLOR_NONE ) return false; - - glBindAttribLocation( mnBlendedTextureProgram, GL_ATTRIB_POS, "position" ); - glBindAttribLocation( mnBlendedTextureProgram, GL_ATTRIB_TEX, "tex_coord_in" ); - glBindAttribLocation( mnBlendedTextureProgram, GL_ATTRIB_TEX2, "alpha_coord_in" ); - mnBlendedTextureUniform = glGetUniformLocation( mnBlendedTextureProgram, "sampler" ); - mnBlendedMaskUniform = glGetUniformLocation( mnBlendedTextureProgram, "mask" ); - mnBlendedAlphaUniform = glGetUniformLocation( mnBlendedTextureProgram, "alpha" ); - - CHECK_GL_ERROR(); - return true; -} - -bool OpenGLSalGraphicsImpl::CreateMaskProgram( void ) -{ - mnMaskProgram = OpenGLHelper::LoadShaders( "maskVertexShader", "maskFragmentShader" ); - if( mnMaskProgram == 0 ) + if( !UseProgram( "dumbVertexShader", "solidFragmentShader" ) ) return false; - - glBindAttribLocation( mnMaskProgram, GL_ATTRIB_POS, "position" ); - glBindAttribLocation( mnMaskProgram, GL_ATTRIB_TEX, "tex_coord_in" ); - mnMaskUniform = glGetUniformLocation( mnMaskProgram, "sampler" ); - mnMaskColorUniform = glGetUniformLocation( mnMaskProgram, "color" ); - - CHECK_GL_ERROR(); + mpProgram->SetColorf( "color", nColor, fTransparency ); return true; } -bool OpenGLSalGraphicsImpl::CreateLinearGradientProgram( void ) +bool OpenGLSalGraphicsImpl::UseSolid( SalColor nColor ) { - mnLinearGradientProgram = OpenGLHelper::LoadShaders( "textureVertexShader", "linearGradientFragmentShader" ); - if( mnLinearGradientProgram == 0 ) - return false; - - glBindAttribLocation( mnLinearGradientProgram, GL_ATTRIB_POS, "position" ); - glBindAttribLocation( mnLinearGradientProgram, GL_ATTRIB_TEX, "tex_coord_in" ); - mnLinearGradientStartColorUniform = glGetUniformLocation( mnLinearGradientProgram, "start_color" ); - mnLinearGradientEndColorUniform = glGetUniformLocation( mnLinearGradientProgram, "end_color" ); - - CHECK_GL_ERROR(); - return true; + return UseSolid( nColor, 0.0f ); } -bool OpenGLSalGraphicsImpl::CreateRadialGradientProgram( void ) +bool OpenGLSalGraphicsImpl::UseInvert() { - mnRadialGradientProgram = OpenGLHelper::LoadShaders( "textureVertexShader", "radialGradientFragmentShader" ); - if( mnRadialGradientProgram == 0 ) + if( !UseSolid( MAKE_SALCOLOR( 255, 255, 255 ) ) ) return false; - - glBindAttribLocation( mnRadialGradientProgram, GL_ATTRIB_POS, "position" ); - glBindAttribLocation( mnRadialGradientProgram, GL_ATTRIB_TEX, "tex_coord_in" ); - mnRadialGradientStartColorUniform = glGetUniformLocation( mnRadialGradientProgram, "start_color" ); - mnRadialGradientEndColorUniform = glGetUniformLocation( mnRadialGradientProgram, "end_color" ); - mnRadialGradientCenterUniform = glGetUniformLocation( mnRadialGradientProgram, "center" ); - - CHECK_GL_ERROR(); + mpProgram->SetBlendMode( GL_ONE_MINUS_DST_COLOR, GL_ZERO ); return true; } -void OpenGLSalGraphicsImpl::BeginSolid( SalColor nColor, sal_uInt8 nTransparency ) -{ - if( mnSolidProgram == 0 ) - { - glClearColor( 1, 1, 1, 1 ); - glClear( GL_COLOR_BUFFER_BIT ); - if( !CreateSolidProgram() ) - return; - } - - if( nTransparency > 0 ) - { - glEnable( GL_BLEND ); - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); - } - glUseProgram( mnSolidProgram ); - glUniformColor( mnColorUniform, nColor, nTransparency ); - - CHECK_GL_ERROR(); -} - -void OpenGLSalGraphicsImpl::BeginSolid( SalColor nColor, double fTransparency ) -{ - if( mnSolidProgram == 0 ) - { - if( !CreateSolidProgram() ) - return; - } - - if( fTransparency > 0.0f ) - { - glEnable( GL_BLEND ); - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); - } - glUseProgram( mnSolidProgram ); - glUniformColorf( mnColorUniform, nColor, fTransparency ); - - CHECK_GL_ERROR(); -} - -void OpenGLSalGraphicsImpl::BeginSolid( SalColor nColor ) -{ - BeginSolid( nColor, 0.0f ); -} - -void OpenGLSalGraphicsImpl::EndSolid( void ) -{ - glUseProgram( 0 ); - glDisable( GL_BLEND ); - - CHECK_GL_ERROR(); -} - -void OpenGLSalGraphicsImpl::BeginInvert( void ) -{ - glEnable( GL_BLEND ); - glBlendFunc( GL_ONE_MINUS_DST_COLOR, GL_ZERO ); - BeginSolid( MAKE_SALCOLOR( 255, 255, 255 ) ); - - CHECK_GL_ERROR(); -} - -void OpenGLSalGraphicsImpl::EndInvert( void ) -{ - EndSolid(); - glDisable( GL_BLEND ); - - CHECK_GL_ERROR(); -} - void OpenGLSalGraphicsImpl::DrawPoint( long nX, long nY ) { GLfloat pPoint[2]; @@ -607,12 +368,8 @@ void OpenGLSalGraphicsImpl::DrawPoint( long nX, long nY ) pPoint[0] = 2 * nX / GetWidth() - 1.0f; pPoint[1] = 1.0f - 2 * nY / GetHeight(); - glEnableVertexAttribArray( GL_ATTRIB_POS ); - glVertexAttribPointer( GL_ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, pPoint ); + mpProgram->SetVertices( pPoint ); glDrawArrays( GL_POINTS, 0, 1 ); - glDisableVertexAttribArray( GL_ATTRIB_POS ); - - CHECK_GL_ERROR(); } void OpenGLSalGraphicsImpl::DrawLine( long nX1, long nY1, long nX2, long nY2 ) @@ -624,12 +381,8 @@ void OpenGLSalGraphicsImpl::DrawLine( long nX1, long nY1, long nX2, long nY2 ) pPoints[2] = (2 * nX2) / GetWidth() - 1.0;; pPoints[3] = 1.0f - 2 * nY2 / GetHeight(); - glEnableVertexAttribArray( GL_ATTRIB_POS ); - glVertexAttribPointer( GL_ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, pPoints ); + mpProgram->SetVertices( pPoints ); glDrawArrays( GL_LINES, 0, 2 ); - glDisableVertexAttribArray( GL_ATTRIB_POS ); - - CHECK_GL_ERROR(); } void OpenGLSalGraphicsImpl::DrawLines( sal_uInt32 nPoints, const SalPoint* pPtAry, bool bClose ) @@ -643,15 +396,11 @@ void OpenGLSalGraphicsImpl::DrawLines( sal_uInt32 nPoints, const SalPoint* pPtAr aPoints[j++] = 1.0f - (2 * pPtAry[i].mnY) / GetHeight(); } - glEnableVertexAttribArray( GL_ATTRIB_POS ); - glVertexAttribPointer( GL_ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, &aPoints[0] ); + mpProgram->SetVertices( &aPoints[0] ); if( bClose ) glDrawArrays( GL_LINE_LOOP, 0, nPoints ); else glDrawArrays( GL_LINE_STRIP, 0, nPoints ); - glDisableVertexAttribArray( GL_ATTRIB_POS ); - - CHECK_GL_ERROR(); } void OpenGLSalGraphicsImpl::DrawConvexPolygon( sal_uInt32 nPoints, const SalPoint* pPtAry ) @@ -665,12 +414,8 @@ void OpenGLSalGraphicsImpl::DrawConvexPolygon( sal_uInt32 nPoints, const SalPoin aVertices[j+1] = 1.0 - (2 * pPtAry[i].mnY / GetHeight()); } - glEnableVertexAttribArray( GL_ATTRIB_POS ); - glVertexAttribPointer( GL_ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, &aVertices[0] ); + mpProgram->SetVertices( &aVertices[0] ); glDrawArrays( GL_TRIANGLE_FAN, 0, nPoints ); - glDisableVertexAttribArray( GL_ATTRIB_POS ); - - CHECK_GL_ERROR(); } void OpenGLSalGraphicsImpl::DrawConvexPolygon( const Polygon& rPolygon ) @@ -686,12 +431,8 @@ void OpenGLSalGraphicsImpl::DrawConvexPolygon( const Polygon& rPolygon ) aVertices[j+1] = 1.0 - (2 * rPt.Y() / GetHeight()); } - glEnableVertexAttribArray( GL_ATTRIB_POS ); - glVertexAttribPointer( GL_ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, &aVertices[0] ); + mpProgram->SetVertices( &aVertices[0] ); glDrawArrays( GL_TRIANGLE_FAN, 0, nPoints ); - glDisableVertexAttribArray( GL_ATTRIB_POS ); - - CHECK_GL_ERROR(); } void OpenGLSalGraphicsImpl::DrawRect( long nX, long nY, long nWidth, long nHeight ) @@ -759,10 +500,8 @@ void OpenGLSalGraphicsImpl::DrawPolyPolygon( const basegfx::B2DPolyPolygon& rPol } } - glEnableVertexAttribArray( GL_ATTRIB_POS ); - glVertexAttribPointer( GL_ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, aVertices.data() ); + mpProgram->SetVertices( aVertices.data() ); glDrawArrays( GL_TRIANGLES, 0, aVertices.size() / 2 ); - glDisableVertexAttribArray( GL_ATTRIB_POS ); CHECK_GL_ERROR(); } @@ -794,50 +533,25 @@ void OpenGLSalGraphicsImpl::DrawRegionBand( const RegionBand& rRegion ) #undef ADD_VERTICE - glEnableVertexAttribArray( GL_ATTRIB_POS ); - glVertexAttribPointer( GL_ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, &aVertices[0] ); + mpProgram->SetVertices( &aVertices[0] ); glDrawArrays( GL_TRIANGLES, 0, aVertices.size() / 2 ); - glDisableVertexAttribArray( GL_ATTRIB_POS ); - - CHECK_GL_ERROR(); } void OpenGLSalGraphicsImpl::DrawTextureRect( OpenGLTexture& rTexture, const SalTwoRect& rPosAry, bool bInverted ) { GLfloat aTexCoord[8]; - rTexture.GetCoord( aTexCoord, rPosAry, bInverted ); - glEnableVertexAttribArray( GL_ATTRIB_TEX ); - glVertexAttribPointer( GL_ATTRIB_TEX, 2, GL_FLOAT, GL_FALSE, 0, aTexCoord ); - + mpProgram->SetTextureCoord( aTexCoord ); DrawRect( rPosAry.mnDestX, rPosAry.mnDestY, rPosAry.mnDestWidth, rPosAry.mnDestHeight ); - - glDisableVertexAttribArray( GL_ATTRIB_TEX ); - - CHECK_GL_ERROR(); } void OpenGLSalGraphicsImpl::DrawTexture( OpenGLTexture& rTexture, const SalTwoRect& pPosAry, bool bInverted ) { - if( mnTextureProgram == 0 ) - { - if( !CreateTextureProgram() ) - return; - } - - glUseProgram( mnTextureProgram ); - glUniform1i( mnSamplerUniform, 0 ); - glActiveTexture( GL_TEXTURE0 ); - CHECK_GL_ERROR(); - - rTexture.Bind(); + if( !UseProgram( "textureVertexShader", "textureFragmentShader" ) ) + return; + mpProgram->SetTexture( "sampler", rTexture ); DrawTextureRect( rTexture, pPosAry, bInverted ); - rTexture.Unbind(); - CHECK_GL_ERROR(); - - glUseProgram( 0 ); - - CHECK_GL_ERROR(); + mpProgram->Clean(); } void OpenGLSalGraphicsImpl::DrawTransformedTexture( @@ -847,14 +561,6 @@ void OpenGLSalGraphicsImpl::DrawTransformedTexture( const basegfx::B2DPoint& rX, const basegfx::B2DPoint& rY ) { - const basegfx::B2DVector aXRel = rX - rNull; - const basegfx::B2DVector aYRel = rY - rNull; - const float aValues[] = { - (float) aXRel.getX()/rTexture.GetWidth(), (float) aXRel.getY()/rTexture.GetWidth(), 0, 0, - (float) aYRel.getX()/rTexture.GetHeight(), (float) aYRel.getY()/rTexture.GetHeight(), 0, 0, - 0, 0, 1, 0, - (float) rNull.getX(), (float) rNull.getY(), 0, 1 }; - glm::mat4 mMatrix = glm::make_mat4( aValues ); GLfloat aVertices[8] = { 0, (float) rTexture.GetHeight(), 0, 0, (float) rTexture.GetWidth(), 0, (float) rTexture.GetWidth(), (float) rTexture.GetHeight() }; @@ -862,222 +568,98 @@ void OpenGLSalGraphicsImpl::DrawTransformedTexture( if( rMask ) { - if( mnTransformedMaskedTextureProgram == 0 ) - { - if( !CreateTransformedMaskedTextureProgram() ) - return; - } - glUseProgram( mnTransformedMaskedTextureProgram ); - glUniform2f( mnTransformedMaskedViewportUniform, GetWidth(), GetHeight() ); - glUniformMatrix4fv( mnTransformedMaskedTransformUniform, 1, GL_FALSE, glm::value_ptr( mMatrix ) ); - glUniform1i( mnTransformedMaskedSamplerUniform, 0 ); - glUniform1i( mnTransformedMaskedMaskUniform, 1 ); - glActiveTexture( GL_TEXTURE1 ); - rMask.Bind(); + if( !UseProgram( "transformedTextureVertexShader", "maskedTextureFragmentShader" ) ) + return; + mpProgram->SetTexture( "mask", rMask ); rMask.SetFilter( GL_LINEAR ); - glEnable( GL_BLEND ); - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + mpProgram->SetBlendMode( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); } else { - if( mnTransformedTextureProgram == 0 ) - { - if( !CreateTransformedTextureProgram() ) - return; - } - glUseProgram( mnTransformedTextureProgram ); - glUniform2f( mnTransformedViewportUniform, GetWidth(), GetHeight() ); - glUniformMatrix4fv( mnTransformedTransformUniform, 1, GL_FALSE, glm::value_ptr( mMatrix ) ); - glUniform1i( mnTransformedSamplerUniform, 0 ); + if( !UseProgram( "transformedTextureVertexShader", "textureFragmentShader" ) ) + return; } - glActiveTexture( GL_TEXTURE0 ); - rTexture.Bind(); + mpProgram->SetUniform2f( "viewport", GetWidth(), GetHeight() ); + mpProgram->SetTransform( "transform", rTexture, rNull, rX, rY ); + rTexture.GetWholeCoord( aTexCoord ); + mpProgram->SetTexture( "sampler", rTexture ); rTexture.SetFilter( GL_LINEAR ); - CHECK_GL_ERROR(); - - GLfloat fWidth = rTexture.GetWidth(); - GLfloat fHeight = rTexture.GetHeight(); - SalTwoRect aPosAry(0, 0, fWidth, fHeight, 0, 0, fWidth, fHeight); - rTexture.GetCoord( aTexCoord, aPosAry ); - glEnableVertexAttribArray( GL_ATTRIB_TEX ); - glVertexAttribPointer( GL_ATTRIB_TEX, 2, GL_FLOAT, GL_FALSE, 0, aTexCoord ); - glEnableVertexAttribArray( GL_ATTRIB_POS ); - glVertexAttribPointer( GL_ATTRIB_POS, 2, GL_FLOAT, GL_FALSE, 0, &aVertices[0] ); + mpProgram->SetTextureCoord( aTexCoord ); + mpProgram->SetVertices( &aVertices[0] ); glDrawArrays( GL_TRIANGLE_FAN, 0, 4 ); - glDisableVertexAttribArray( GL_ATTRIB_POS ); - glDisableVertexAttribArray( GL_ATTRIB_TEX ); - - if( rMask ) - { - glDisable( GL_BLEND ); - glActiveTexture( GL_TEXTURE1 ); - rMask.Unbind(); - } - - glActiveTexture( GL_TEXTURE0 ); - rTexture.Unbind(); - glUseProgram( 0 ); - CHECK_GL_ERROR(); + mpProgram->Clean(); } void OpenGLSalGraphicsImpl::DrawAlphaTexture( OpenGLTexture& rTexture, const SalTwoRect& rPosAry, bool bInverted, bool bPremultiplied ) { - glEnable( GL_BLEND ); - if( bPremultiplied ) - glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA ); - else - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); - DrawTexture( rTexture, rPosAry, bInverted ); - glDisable( GL_BLEND ); - CHECK_GL_ERROR(); + if( !UseProgram( "textureVertexShader", "textureFragmentShader" ) ) + return; + mpProgram->SetTexture( "sampler", rTexture ); + mpProgram->SetBlendMode( bPremultiplied ? GL_ONE : GL_SRC_ALPHA, + GL_ONE_MINUS_SRC_ALPHA ); + DrawTextureRect( rTexture, rPosAry, bInverted ); + mpProgram->Clean(); } void OpenGLSalGraphicsImpl::DrawTextureDiff( OpenGLTexture& rTexture, OpenGLTexture& rMask, const SalTwoRect& rPosAry, bool bInverted ) { - if( mnDiffTextureProgram == 0 ) - { - if( !CreateDiffTextureProgram() ) - return; - } - - glUseProgram( mnDiffTextureProgram ); - glUniform1i( mnDiffTextureUniform, 0 ); - glUniform1i( mnDiffMaskUniform, 1 ); - glActiveTexture( GL_TEXTURE0 ); - rTexture.Bind(); - glActiveTexture( GL_TEXTURE1 ); - rMask.Bind(); - - glEnable( GL_BLEND ); - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + if( !UseProgram( "textureVertexShader", "diffTextureFragmentShader" ) ) + return; + mpProgram->SetTexture( "texture", rTexture ); + mpProgram->SetTexture( "mask", rMask ); + mpProgram->SetBlendMode( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); DrawTextureRect( rTexture, rPosAry, bInverted ); - glDisable( GL_BLEND ); - - glActiveTexture( GL_TEXTURE1 ); - rMask.Unbind(); - glActiveTexture( GL_TEXTURE0 ); - rTexture.Unbind(); - glUseProgram( 0 ); - - CHECK_GL_ERROR(); + mpProgram->Clean(); } void OpenGLSalGraphicsImpl::DrawTextureWithMask( OpenGLTexture& rTexture, OpenGLTexture& rMask, const SalTwoRect& pPosAry ) { - if( mnMaskedTextureProgram == 0 ) - { - if( !CreateMaskedTextureProgram() ) - return; - } - - glUseProgram( mnMaskedTextureProgram ); - glUniform1i( mnMaskedSamplerUniform, 0 ); - glUniform1i( mnMaskSamplerUniform, 1 ); - glActiveTexture( GL_TEXTURE0 ); - rTexture.Bind(); - glActiveTexture( GL_TEXTURE1 ); - rMask.Bind(); - - glEnable( GL_BLEND ); - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + if( !UseProgram( "textureVertexShader", "maskedTextureFragmentShader" ) ) + return; + mpProgram->SetTexture( "sampler", rTexture ); + mpProgram->SetTexture( "mask", rMask ); + mpProgram->SetBlendMode( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); DrawTextureRect( rTexture, pPosAry ); - glDisable( GL_BLEND ); - - glActiveTexture( GL_TEXTURE1 ); - rMask.Unbind(); - glActiveTexture( GL_TEXTURE0 ); - rTexture.Unbind(); - glUseProgram( 0 ); - - CHECK_GL_ERROR(); + mpProgram->Clean(); } void OpenGLSalGraphicsImpl::DrawBlendedTexture( OpenGLTexture& rTexture, OpenGLTexture& rMask, OpenGLTexture& rAlpha, const SalTwoRect& rPosAry ) { GLfloat aTexCoord[8]; - - if( mnBlendedTextureProgram == 0 ) - { - if( !CreateBlendedTextureProgram() ) - return; - } - - glUseProgram( mnBlendedTextureProgram ); - glUniform1i( mnBlendedTextureUniform, 0 ); - glUniform1i( mnBlendedMaskUniform, 1 ); - glUniform1i( mnBlendedAlphaUniform, 2 ); - glActiveTexture( GL_TEXTURE0 ); - rTexture.Bind(); - glActiveTexture( GL_TEXTURE1 ); - rMask.Bind(); - glActiveTexture( GL_TEXTURE2 ); - rAlpha.Bind(); - + if( !UseProgram( "blendedTextureVertexShader", "blendedTextureFragmentShader" ) ) + return; + mpProgram->SetTexture( "sampler", rTexture ); + mpProgram->SetTexture( "mask", rMask ); + mpProgram->SetTexture( "alpha", rAlpha ); rAlpha.GetCoord( aTexCoord, rPosAry ); - glEnableVertexAttribArray( GL_ATTRIB_TEX2 ); - glVertexAttribPointer( GL_ATTRIB_TEX2, 2, GL_FLOAT, GL_FALSE, 0, aTexCoord ); - - glEnable( GL_BLEND ); - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + mpProgram->SetAlphaCoord( aTexCoord ); + mpProgram->SetBlendMode( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); DrawTextureRect( rTexture, rPosAry ); - glDisable( GL_BLEND ); - - glDisableVertexAttribArray( GL_ATTRIB_TEX2 ); - - glActiveTexture( GL_TEXTURE0 ); - rTexture.Unbind(); - glActiveTexture( GL_TEXTURE1 ); - rMask.Unbind(); - glActiveTexture( GL_TEXTURE2 ); - rAlpha.Unbind(); - glActiveTexture( GL_TEXTURE0 ); - glUseProgram( 0 ); - - CHECK_GL_ERROR(); + mpProgram->Clean(); } void OpenGLSalGraphicsImpl::DrawMask( OpenGLTexture& rMask, SalColor nMaskColor, const SalTwoRect& pPosAry ) { - if( mnMaskProgram == 0 ) - { - if( !CreateMaskProgram() ) - return; - } - - glUseProgram( mnMaskProgram ); - glUniformColor( mnMaskColorUniform, nMaskColor, 0 ); - glUniform1i( mnMaskUniform, 0 ); - glActiveTexture( GL_TEXTURE0 ); - rMask.Bind(); - - glEnable( GL_BLEND ); - glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); + if( !UseProgram( "textureVertexShader", "maskFragmentShader" ) ) + return; + mpProgram->SetColor( "color", nMaskColor, 0 ); + mpProgram->SetTexture( "sampler", rMask ); + mpProgram->SetBlendMode( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); DrawTextureRect( rMask, pPosAry ); - glDisable( GL_BLEND ); - - rMask.Unbind(); - glUseProgram( 0 ); - - CHECK_GL_ERROR(); + mpProgram->Clean(); } void OpenGLSalGraphicsImpl::DrawLinearGradient( const Gradient& rGradient, const Rectangle& rRect ) { - if( mnLinearGradientProgram == 0 ) - { - if( !CreateLinearGradientProgram() ) - return; - } - - glUseProgram( mnLinearGradientProgram ); - + if( !UseProgram( "textureVertexShader", "linearGradientFragmentShader" ) ) + return; Color aStartCol = rGradient.GetStartColor(); Color aEndCol = rGradient.GetEndColor(); long nFactor = rGradient.GetStartIntensity(); - glUniformColorIntensity( mnLinearGradientStartColorUniform, aStartCol, nFactor ); + mpProgram->SetColorWithIntensity( "start_color", aStartCol, nFactor ); nFactor = rGradient.GetEndIntensity(); - glUniformColorIntensity( mnLinearGradientEndColorUniform, aEndCol, nFactor ); + mpProgram->SetColorWithIntensity( "end_color", aEndCol, nFactor ); Rectangle aBoundRect; Point aCenter; @@ -1088,35 +670,20 @@ void OpenGLSalGraphicsImpl::DrawLinearGradient( const Gradient& rGradient, const GLfloat aTexCoord[8] = { 0, 1, 1, 1, 1, 0, 0, 0 }; GLfloat fMin = 1.0 - 100.0 / (100.0 - rGradient.GetBorder()); aTexCoord[5] = aTexCoord[7] = fMin; - glEnableVertexAttribArray( GL_ATTRIB_TEX ); - glVertexAttribPointer( GL_ATTRIB_TEX, 2, GL_FLOAT, GL_FALSE, 0, aTexCoord ); - + mpProgram->SetTextureCoord( aTexCoord ); DrawConvexPolygon( aPoly ); - - glDisableVertexAttribArray( GL_ATTRIB_TEX ); - CHECK_GL_ERROR(); - - glUseProgram( 0 ); - - CHECK_GL_ERROR(); } void OpenGLSalGraphicsImpl::DrawAxialGradient( const Gradient& rGradient, const Rectangle& rRect ) { - if( mnLinearGradientProgram == 0 ) - { - if( !CreateLinearGradientProgram() ) - return; - } - - glUseProgram( mnLinearGradientProgram ); - + if( !UseProgram( "textureVertexShader", "linearGradientFragmentShader" ) ) + return; Color aStartCol = rGradient.GetStartColor(); Color aEndCol = rGradient.GetEndColor(); long nFactor = rGradient.GetStartIntensity(); - glUniformColorIntensity( mnLinearGradientStartColorUniform, aStartCol, nFactor ); + mpProgram->SetColorWithIntensity( "start_color", aStartCol, nFactor ); nFactor = rGradient.GetEndIntensity(); - glUniformColorIntensity( mnLinearGradientEndColorUniform, aEndCol, nFactor ); + mpProgram->SetColorWithIntensity( "end_color", aEndCol, nFactor ); /** * Draw two rectangles with linear gradient. @@ -1153,33 +720,20 @@ void OpenGLSalGraphicsImpl::DrawAxialGradient( const Gradient& rGradient, const GLfloat aTexCoord[12] = { 0, 1, 1, 0, 2, 0, 3, 1, 4, 0, 5, 0 }; GLfloat fMin = 1.0 - 100.0 / (100.0 - rGradient.GetBorder()); aTexCoord[3] = aTexCoord[5] = aTexCoord[9] = aTexCoord[11] = fMin; - glEnableVertexAttribArray( GL_ATTRIB_TEX ); - glVertexAttribPointer( GL_ATTRIB_TEX, 2, GL_FLOAT, GL_FALSE, 0, aTexCoord ); - + mpProgram->SetTextureCoord( aTexCoord ); DrawConvexPolygon( aPoly ); - - glDisableVertexAttribArray( GL_ATTRIB_TEX ); - glUseProgram( 0 ); - - CHECK_GL_ERROR(); } void OpenGLSalGraphicsImpl::DrawRadialGradient( const Gradient& rGradient, const Rectangle& rRect ) { - if( mnRadialGradientProgram == 0 ) - { - if( !CreateRadialGradientProgram() ) - return; - } - - glUseProgram( mnRadialGradientProgram ); - + if( !UseProgram( "textureVertexShader", "radialGradientFragmentShader" ) ) + return; Color aStartCol = rGradient.GetStartColor(); Color aEndCol = rGradient.GetEndColor(); long nFactor = rGradient.GetStartIntensity(); - glUniformColorIntensity( mnRadialGradientStartColorUniform, aStartCol, nFactor ); + mpProgram->SetColorWithIntensity( "start_color", aStartCol, nFactor ); nFactor = rGradient.GetEndIntensity(); - glUniformColorIntensity( mnRadialGradientEndColorUniform, aEndCol, nFactor ); + mpProgram->SetColorWithIntensity( "end_color", aEndCol, nFactor ); ... etc. - the rest is truncated
_______________________________________________ Libreoffice-commits mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/libreoffice-commits
