ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4496 Commits
21 Branches
19 Tags
70 MiB
Tree: 356491e1df
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '356491e1df'
${ noResults }
magnum/src/Magnum/Implementation/driverSpecific.cpp

188 lines
7.4 KiB
Raw Normal View History Unescape

More robust support for extension-based driver bug workarounds. Previously the extensions were either disabled altogether (e.g. because we don't have yet extension wrangler on ES) or had manually adjusted minimal required versions to avoid issues on older versions (e.g. ARB_explicit_attrib_location is known to give compiler errors when used with GLSL < 1.50 on some drivers), both done basically at compile time unrelated to actual hardware/driver used. Now all the extensions are enabled exactly as the driver advertises them (or when their core version is not larger than the context version) and have minimal required versions as per specification. Given extension is supported in given version when it is marked as such and its minimal required version is not larger than the requested one. The extension disabling is thus done by simply increasing the minimal required version to larger value (or Version::None for disabling it for all versions). Currently no such disabling is put into place, but the existing workarounds scattered all over the place will be gradually converted to this. Simplified the code and tests by marking all extensions from previous versions as supported instead of additional "shorthand" checking whether extension's core version is supported. The check wasn't probably much of a speedup, as it was just another branch. This was also buggy previously, because when the extension would be reported as not being supported in older versions, which is not what we want. Hopefully this won't reintroduce the numerous issues with Mesa and OSX I had in the past :-) Also removed duplicate implementation of Context::isExtensionSupported(), one overload is now calling the other.
12 years ago
/*
This file is part of Magnum.
Oh, it's 2015 already.
11 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015
More robust support for extension-based driver bug workarounds. Previously the extensions were either disabled altogether (e.g. because we don't have yet extension wrangler on ES) or had manually adjusted minimal required versions to avoid issues on older versions (e.g. ARB_explicit_attrib_location is known to give compiler errors when used with GLSL < 1.50 on some drivers), both done basically at compile time unrelated to actual hardware/driver used. Now all the extensions are enabled exactly as the driver advertises them (or when their core version is not larger than the context version) and have minimal required versions as per specification. Given extension is supported in given version when it is marked as such and its minimal required version is not larger than the requested one. The extension disabling is thus done by simply increasing the minimal required version to larger value (or Version::None for disabling it for all versions). Currently no such disabling is put into place, but the existing workarounds scattered all over the place will be gradually converted to this. Simplified the code and tests by marking all extensions from previous versions as supported instead of additional "shorthand" checking whether extension's core version is supported. The check wasn't probably much of a speedup, as it was just another branch. This was also buggy previously, because when the extension would be reported as not being supported in older versions, which is not what we want. Hopefully this won't reintroduce the numerous issues with Mesa and OSX I had in the past :-) Also removed duplicate implementation of Context::isExtensionSupported(), one overload is now calling the other.
12 years ago
Vladimír Vondruš <mosra@centrum.cz>
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and/or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include "Magnum/Context.h"
More transparent way to handle driver workarounds. The engine can now list all driver workarounds that were used during the initialization. Any listed workaround can then be disabled from the command-line using `--magnum-disable-workarounds` command-line parameter. The disabling and querying API is private and undocumented, because the driver workarounds should be disabled only by end-users and not application developers. The workaround list is now empty, but will be filled up in the following commits and the workarounds will be probably documented only privately in Implementation/driverSpecific.hpp, as it is really something that should be used only to debug driver problems.
11 years ago
#include <algorithm>
More robust support for extension-based driver bug workarounds. Previously the extensions were either disabled altogether (e.g. because we don't have yet extension wrangler on ES) or had manually adjusted minimal required versions to avoid issues on older versions (e.g. ARB_explicit_attrib_location is known to give compiler errors when used with GLSL < 1.50 on some drivers), both done basically at compile time unrelated to actual hardware/driver used. Now all the extensions are enabled exactly as the driver advertises them (or when their core version is not larger than the context version) and have minimal required versions as per specification. Given extension is supported in given version when it is marked as such and its minimal required version is not larger than the requested one. The extension disabling is thus done by simply increasing the minimal required version to larger value (or Version::None for disabling it for all versions). Currently no such disabling is put into place, but the existing workarounds scattered all over the place will be gradually converted to this. Simplified the code and tests by marking all extensions from previous versions as supported instead of additional "shorthand" checking whether extension's core version is supported. The check wasn't probably much of a speedup, as it was just another branch. This was also buggy previously, because when the extension would be reported as not being supported in older versions, which is not what we want. Hopefully this won't reintroduce the numerous issues with Mesa and OSX I had in the past :-) Also removed duplicate implementation of Context::isExtensionSupported(), one overload is now calling the other.
12 years ago
#include "Magnum/Extensions.h"
Merged driver-specific stuff into one dedicated file.
11 years ago
#include "Magnum/Math/Range.h"
More robust support for extension-based driver bug workarounds. Previously the extensions were either disabled altogether (e.g. because we don't have yet extension wrangler on ES) or had manually adjusted minimal required versions to avoid issues on older versions (e.g. ARB_explicit_attrib_location is known to give compiler errors when used with GLSL < 1.50 on some drivers), both done basically at compile time unrelated to actual hardware/driver used. Now all the extensions are enabled exactly as the driver advertises them (or when their core version is not larger than the context version) and have minimal required versions as per specification. Given extension is supported in given version when it is marked as such and its minimal required version is not larger than the requested one. The extension disabling is thus done by simply increasing the minimal required version to larger value (or Version::None for disabling it for all versions). Currently no such disabling is put into place, but the existing workarounds scattered all over the place will be gradually converted to this. Simplified the code and tests by marking all extensions from previous versions as supported instead of additional "shorthand" checking whether extension's core version is supported. The check wasn't probably much of a speedup, as it was just another branch. This was also buggy previously, because when the extension would be reported as not being supported in older versions, which is not what we want. Hopefully this won't reintroduce the numerous issues with Mesa and OSX I had in the past :-) Also removed duplicate implementation of Context::isExtensionSupported(), one overload is now calling the other.
12 years ago
namespace Magnum {
More transparent way to handle driver workarounds. The engine can now list all driver workarounds that were used during the initialization. Any listed workaround can then be disabled from the command-line using `--magnum-disable-workarounds` command-line parameter. The disabling and querying API is private and undocumented, because the driver workarounds should be disabled only by end-users and not application developers. The workaround list is now empty, but will be filled up in the following commits and the workarounds will be probably documented only privately in Implementation/driverSpecific.hpp, as it is really something that should be used only to debug driver problems.
11 years ago
#ifndef CORRADE_NO_ASSERT
namespace {
std::vector<std::string> KnownWorkarounds{};
}
#endif
Ability to filter-out driver-specific "success" shader compilation logs. Intel drivers on Windows print out "No errors." when the shader is compiled/linked successfully. I consider that as unnecessary spam and filter it out.
11 years ago
namespace Implementation {
/* Used in Shader.cpp (duh) */
bool isShaderCompilationLogEmpty(const std::string&);
bool isShaderCompilationLogEmpty(const std::string& result) {
Don't compile desktop-only stuff on ES.
11 years ago
#if defined(CORRADE_TARGET_WINDOWS) && !defined(MAGNUM_TARGET_GLES)
Ability to filter-out driver-specific "success" shader compilation logs. Intel drivers on Windows print out "No errors." when the shader is compiled/linked successfully. I consider that as unnecessary spam and filter it out.
11 years ago
/* Intel Windows drivers are too chatty */
if((Context::current()->detectedDriver() & Context::DetectedDriver::IntelWindows) && result == "No errors.\n")
return true;
#else
static_cast<void>(result);
#endif
return false;
}
/* Used in AbstractShaderProgram.cpp (duh) */
bool isProgramLinkLogEmpty(const std::string&);
bool isProgramLinkLogEmpty(const std::string& result) {
Don't compile desktop-only stuff on ES.
11 years ago
#if defined(CORRADE_TARGET_WINDOWS) && !defined(MAGNUM_TARGET_GLES)
Ability to filter-out driver-specific "success" shader compilation logs. Intel drivers on Windows print out "No errors." when the shader is compiled/linked successfully. I consider that as unnecessary spam and filter it out.
11 years ago
/* Intel Windows drivers are too chatty */
if((Context::current()->detectedDriver() & Context::DetectedDriver::IntelWindows) && result == "No errors.\n")
return true;
#else
static_cast<void>(result);
#endif
return false;
}
}
Merged driver-specific stuff into one dedicated file.
11 years ago
auto Context::detectedDriver() -> DetectedDrivers {
if(_detectedDrivers) return *_detectedDrivers;
_detectedDrivers = DetectedDrivers{};
const std::string vendor = vendorString();
Improve ANGLE driver detection. It is now also on ES3, avoid mistakenly detecting Internet Explorer WebGL implementation as ANGLE (it has the same properties).
11 years ago
#ifndef MAGNUM_TARGET_GLES
Merged driver-specific stuff into one dedicated file.
11 years ago
/* AMD binary desktop drivers */
if(vendor.find("ATI Technologies Inc.") != std::string::npos)
return *_detectedDrivers |= DetectedDriver::AMD;
#ifdef CORRADE_TARGET_WINDOWS
/* Intel Windows drivers */
if(vendor.find("Intel") != std::string::npos)
return *_detectedDrivers |= DetectedDriver::IntelWindows;
#endif
#endif
Improve ANGLE driver detection. It is now also on ES3, avoid mistakenly detecting Internet Explorer WebGL implementation as ANGLE (it has the same properties).
11 years ago
/** @todo there is also D3D9/D3D11 distinction on webglreport.com, is it useful? */
#ifdef MAGNUM_TARGET_GLES
/* OpenGL ES implementation using ANGLE. Taken from these sources:
http://stackoverflow.com/a/20149090
http://webglreport.com
*/
Merged driver-specific stuff into one dedicated file.
11 years ago
{
Range1Di range;
glGetIntegerv(GL_ALIASED_LINE_WIDTH_RANGE, range.data());
Improve ANGLE driver detection. It is now also on ES3, avoid mistakenly detecting Internet Explorer WebGL implementation as ANGLE (it has the same properties).
11 years ago
if(range.min() == 1 && range.max() == 1 && vendor != "Internet Explorer")
Merged driver-specific stuff into one dedicated file.
11 years ago
return *_detectedDrivers |= DetectedDriver::ProbablyAngle;
}
#endif
return *_detectedDrivers;
}
More transparent way to handle driver workarounds. The engine can now list all driver workarounds that were used during the initialization. Any listed workaround can then be disabled from the command-line using `--magnum-disable-workarounds` command-line parameter. The disabling and querying API is private and undocumented, because the driver workarounds should be disabled only by end-users and not application developers. The workaround list is now empty, but will be filled up in the following commits and the workarounds will be probably documented only privately in Implementation/driverSpecific.hpp, as it is really something that should be used only to debug driver problems.
11 years ago
void Context::disableDriverWorkaround(const std::string& workaround) {
/* Ignore unknown workarounds */
if(std::find(KnownWorkarounds.begin(), KnownWorkarounds.end(), workaround) == KnownWorkarounds.end()) return;
_driverWorkarounds.emplace_back(workaround, true);
}
bool Context::isDriverWorkaroundDisabled(const std::string& workaround) {
CORRADE_INTERNAL_ASSERT(std::find(KnownWorkarounds.begin(), KnownWorkarounds.end(), workaround) != KnownWorkarounds.end());
/* If the workaround was already asked for or disabled, return its state,
otherwise add it to the list as used one */
for(const auto& i: _driverWorkarounds)
if(i.first == workaround) return i.second;
_driverWorkarounds.emplace_back(workaround, false);
return false;
}
More robust support for extension-based driver bug workarounds. Previously the extensions were either disabled altogether (e.g. because we don't have yet extension wrangler on ES) or had manually adjusted minimal required versions to avoid issues on older versions (e.g. ARB_explicit_attrib_location is known to give compiler errors when used with GLSL < 1.50 on some drivers), both done basically at compile time unrelated to actual hardware/driver used. Now all the extensions are enabled exactly as the driver advertises them (or when their core version is not larger than the context version) and have minimal required versions as per specification. Given extension is supported in given version when it is marked as such and its minimal required version is not larger than the requested one. The extension disabling is thus done by simply increasing the minimal required version to larger value (or Version::None for disabling it for all versions). Currently no such disabling is put into place, but the existing workarounds scattered all over the place will be gradually converted to this. Simplified the code and tests by marking all extensions from previous versions as supported instead of additional "shorthand" checking whether extension's core version is supported. The check wasn't probably much of a speedup, as it was just another branch. This was also buggy previously, because when the extension would be reported as not being supported in older versions, which is not what we want. Hopefully this won't reintroduce the numerous issues with Mesa and OSX I had in the past :-) Also removed duplicate implementation of Context::isExtensionSupported(), one overload is now calling the other.
12 years ago
void Context::setupDriverWorkarounds() {
#define _setRequiredVersion(extension, version) \
if(_extensionRequiredVersion[Extensions::extension::Index] < Version::version) \
_extensionRequiredVersion[Extensions::extension::Index] = Version::version
Disable ARB_explicit_uniform_location on AMD drivers. It causes GLSL compiler crash in 13.251 linux driver. Not sure about other platforms.
12 years ago
#ifndef MAGNUM_TARGET_GLES
/* This extension causes crash in GLSL compiler on AMD linux drivers 13.251 */
Added Context::detectedDriver(). A general way to detect drivers, which can be later used for applying driver-specific workarounds. Currently used for disabling ARB_explicit_uniform_location on AMD drivers.
12 years ago
if(detectedDriver() & DetectedDriver::AMD)
Disable ARB_explicit_uniform_location on AMD drivers. It causes GLSL compiler crash in 13.251 linux driver. Not sure about other platforms.
12 years ago
_setRequiredVersion(GL::ARB::explicit_uniform_location, None);
Disable ARB_shading_language_420pack for Intel on Windows. The preprocessor string is exposed in GLSL even though the extension is not supported.
12 years ago
#ifdef CORRADE_TARGET_WINDOWS
/* On Windows Intel drivers ARB_shading_language_420pack is exposed in GLSL
even that the extension (e.g. binding keyword) is not supported */
Fix crash on context creation on Windows on Intel drivers. Sorry! These driver-specific workarounds are a double-edged sword.
11 years ago
if((detectedDriver() & DetectedDriver::IntelWindows) && !isExtensionSupported<Extensions::GL::ARB::shading_language_420pack>())
Disable ARB_shading_language_420pack for Intel on Windows. The preprocessor string is exposed in GLSL even though the extension is not supported.
12 years ago
_setRequiredVersion(GL::ARB::shading_language_420pack, None);
Disable ARB_explicit_uniform_location on AMD drivers. It causes GLSL compiler crash in 13.251 linux driver. Not sure about other platforms.
12 years ago
#endif
Proper disabling of extensions related to GLSL layout qualifier. So the disabling can be detected.
12 years ago
/* Layout qualifier causes compiler error with GLSL 1.20 on Mesa, GLSL 1.30
on NVidia and 1.40 on Mac OS X */
/** @todo Different version on different vendors? */
_setRequiredVersion(GL::ARB::explicit_attrib_location, GL320);
_setRequiredVersion(GL::ARB::explicit_uniform_location, GL320);
_setRequiredVersion(GL::ARB::shading_language_420pack, GL320);
#endif
First-class WebGL support, part 14: reduced available extensions. This was the actual problem. Most of ES extensions are not available in WebGL, thus the GL headers and the code was far more bloated than it needed to be. The GL header is now reduced and the previous 13 commits were disabling features that aren't actually available in WebGL. The final executable size is reduced by ~50 kB, which actually isn't much, but still something. Some ES extensions (ANGLE_depth_texture and ANGLE_instanced_arrays) have now WEBGL_* prefix. I'm still using the original prefix in the implementation because there are headers for these, but in public docs and elsewhere they are exposed with WEBGL_*.
11 years ago
/* Disable extensions not available on NaCl */
#ifdef CORRADE_TARGET_NACL
Added support for glMultiDrawArrays()/glMultiDrawElements(). In OpenGL ES this is implemented in EXT_multi_draw_arrays extension, if it is not available, the functionality is emulated using sequence of normal draw() calls.
12 years ago
_setRequiredVersion(GL::EXT::multi_draw_arrays, None);
Proper unimplemented ES2 extension disabling. To have the disabling detectable.
12 years ago
_setRequiredVersion(GL::EXT::debug_label, None);
_setRequiredVersion(GL::EXT::debug_marker, None);
_setRequiredVersion(GL::EXT::disjoint_timer_query, None);
_setRequiredVersion(GL::EXT::separate_shader_objects, None);
_setRequiredVersion(GL::EXT::multisampled_render_to_texture, None);
_setRequiredVersion(GL::EXT::robustness, None);
_setRequiredVersion(GL::KHR::debug, None);
_setRequiredVersion(GL::NV::read_buffer_front, None);
_setRequiredVersion(GL::OES::mapbuffer, None);
_setRequiredVersion(GL::ANGLE::framebuffer_blit, None);
_setRequiredVersion(GL::ANGLE::framebuffer_multisample, None);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
_setRequiredVersion(GL::ANGLE::instanced_arrays, None);
Proper unimplemented ES2 extension disabling. To have the disabling detectable.
12 years ago
_setRequiredVersion(GL::APPLE::framebuffer_multisample, None);
_setRequiredVersion(GL::EXT::discard_framebuffer, None);
_setRequiredVersion(GL::EXT::blend_minmax, None);
_setRequiredVersion(GL::EXT::texture_storage, None);
_setRequiredVersion(GL::EXT::map_buffer_range, None);
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
_setRequiredVersion(GL::EXT::instanced_arrays, None);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
_setRequiredVersion(GL::EXT::draw_instanced, None);
Proper unimplemented ES2 extension disabling. To have the disabling detectable.
12 years ago
_setRequiredVersion(GL::NV::draw_buffers, None);
_setRequiredVersion(GL::NV::fbo_color_attachments, None); // ??
_setRequiredVersion(GL::NV::read_buffer, None);
Support for instanced mesh drawing and base instance. On desktop GL this is provided by ARB_draw_instanced (GL 3.1). Base instance is available only on desktop GL (4.2, ARB_base_instance). In ES2 the instanced functionality is provided by three (!) different extensions (ANGLE_instanced_arrays, EXT_draw_instanced, NV_draw_instanced), the proper implementation is chosen on context creation based on what extension is available. Though we don't have extension loader for ES yet, thus all these extensions are disabled and the implementation has assertion in it. Added blind test which tests only that something has been drawn and no errors were emitted, but not whether the right command is used. I'll probably need to check this later, because the Mesh::draw() behemoth is going slightly out of hand :)
12 years ago
_setRequiredVersion(GL::NV::draw_instanced, None);
Disable also NV_framebuffer_blit on ES2. Until we have proper extension loader implemented (caused FramebufferGLTest to assert). On a related note, NVidia drivers 334.21 support *a lot* of ES2 extensions. Wow.
12 years ago
_setRequiredVersion(GL::NV::framebuffer_blit, None);
Proper unimplemented ES2 extension disabling. To have the disabling detectable.
12 years ago
_setRequiredVersion(GL::NV::framebuffer_multisample, None);
Added Mesh::addVertexBufferInstanced(). Functionality provided by GL 3.3 and ARB_instanced_arrays, on ES2 this is again implemented in three different extensions -- {ANGLE,EXT,NV}_instanced_arrays. They are disabled until Magnum has proper extension loading on ES.
12 years ago
_setRequiredVersion(GL::NV::instanced_arrays, None);
Proper unimplemented ES2 extension disabling. To have the disabling detectable.
12 years ago
_setRequiredVersion(GL::OES::texture_3D, None);
_setRequiredVersion(GL::OES::vertex_array_object, None);
#endif
Re-enable ES extensions everywhere except NaCl and Emscripten.
12 years ago
More robust support for extension-based driver bug workarounds. Previously the extensions were either disabled altogether (e.g. because we don't have yet extension wrangler on ES) or had manually adjusted minimal required versions to avoid issues on older versions (e.g. ARB_explicit_attrib_location is known to give compiler errors when used with GLSL < 1.50 on some drivers), both done basically at compile time unrelated to actual hardware/driver used. Now all the extensions are enabled exactly as the driver advertises them (or when their core version is not larger than the context version) and have minimal required versions as per specification. Given extension is supported in given version when it is marked as such and its minimal required version is not larger than the requested one. The extension disabling is thus done by simply increasing the minimal required version to larger value (or Version::None for disabling it for all versions). Currently no such disabling is put into place, but the existing workarounds scattered all over the place will be gradually converted to this. Simplified the code and tests by marking all extensions from previous versions as supported instead of additional "shorthand" checking whether extension's core version is supported. The check wasn't probably much of a speedup, as it was just another branch. This was also buggy previously, because when the extension would be reported as not being supported in older versions, which is not what we want. Hopefully this won't reintroduce the numerous issues with Mesa and OSX I had in the past :-) Also removed duplicate implementation of Context::isExtensionSupported(), one overload is now calling the other.
12 years ago
#undef _setRequiredVersion
}
}