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.
5905 Commits
21 Branches
19 Tags
70 MiB
Tree: 2f8637ae3b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '2f8637ae3b'
${ noResults }
magnum/src/Magnum/GL/Context.cpp

961 lines
36 KiB
Raw Normal View History Unescape

Classes for handling version and extension information.
14 years ago
/*
This file is part of Magnum.
Updated copyright year.
8 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018
Happy new year too.
12 years ago
Vladimír Vondruš <mosra@centrum.cz>
Relicensing to MIT/Expat license, part 3: source files. Added license header also to shader sources. Hopefully it won't harm compilation times too much.
13 years ago
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.
Classes for handling version and extension information.
14 years ago
*/
#include "Context.h"
Added Context::isCoreProfile(). It's funny when implementing a new feature immediately involves doing a NV-specific workaround. Sigh.
9 years ago
#ifndef MAGNUM_TARGET_GLES
#include <algorithm> /* std::find in isCoreProfileImplementationNV() */
#endif
Ability to control the amount of console output in engine initialization.
10 years ago
#include <iostream> /* for initialization log redirection */
Classes for handling version and extension information.
14 years ago
#include <string>
#include <unordered_map>
Debug operator for Context::Flags.
9 years ago
#include <Corrade/Containers/EnumSet.hpp>
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
#include <Corrade/Utility/Arguments.h>
Making includes absolute, part 4: using absolute includes for Corrade. Also adapted to some Corrade renames.
12 years ago
#include <Corrade/Utility/Debug.h>
#include <Corrade/Utility/String.h>
Classes for handling version and extension information.
14 years ago
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
#include "Magnum/GL/AbstractFramebuffer.h"
#include "Magnum/GL/AbstractShaderProgram.h"
#include "Magnum/GL/AbstractTexture.h"
#include "Magnum/GL/Buffer.h"
Fixed OpenGL ES 2.0 and 3.0 build.
12 years ago
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
#include "Magnum/GL/BufferTexture.h"
Fixed OpenGL ES 2.0 and 3.0 build.
12 years ago
#endif
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
#include "Magnum/GL/DefaultFramebuffer.h"
#include "Magnum/GL/Extensions.h"
#include "Magnum/GL/Framebuffer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/GL/Renderbuffer.h"
#include "Magnum/GL/Renderer.h"
#include "Magnum/GL/Implementation/State.h"
#include "Magnum/GL/Implementation/ContextState.h"
#include "Magnum/GL/Implementation/BufferState.h"
#include "Magnum/GL/Implementation/FramebufferState.h"
#include "Magnum/GL/Implementation/MeshState.h"
#include "Magnum/GL/Implementation/RendererState.h"
#include "Magnum/GL/Implementation/ShaderProgramState.h"
#include "Magnum/GL/Implementation/TextureState.h"
Print error if transform feedback header is used in OpenGL ES 2.0 build.
11 years ago
#ifndef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 1: moving files to a new location. Minimal updates (just the include guards) so Git is hopefully able to detect the rename and track the history properly. Everything except Magnum::GL doesn't compile now.
8 years ago
#include "Magnum/GL/Implementation/TransformFeedbackState.h"
Print error if transform feedback header is used in OpenGL ES 2.0 build.
11 years ago
#endif
Classes for handling version and extension information.
14 years ago
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
namespace Magnum { namespace GL {
Classes for handling version and extension information.
14 years ago
const std::vector<Extension>& Extension::extensions(Version version) {
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
#define _extension(vendor, extension) \
{Extensions::vendor::extension::Index, Extensions::vendor::extension::requiredVersion(), Extensions::vendor::extension::coreVersion(), Extensions::vendor::extension::string()}
Extension lists can be const as well.
14 years ago
static const std::vector<Extension> empty;
Updated OpenGL ES support in Context and related files.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Extension lists can be const as well.
14 years ago
static const std::vector<Extension> extensions{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(AMD,transform_feedback3_lines_triangles),
_extension(AMD,vertex_shader_layer),
_extension(AMD,shader_trinary_minmax),
_extension(ARB,robustness),
_extension(ARB,robustness_isolation),
_extension(ARB,robustness_application_isolation),
_extension(ARB,robustness_share_group_isolation),
_extension(ARB,bindless_texture),
_extension(ARB,compute_variable_group_size),
_extension(ARB,seamless_cubemap_per_texture),
_extension(ARB,sparse_texture),
_extension(ARB,sparse_buffer),
_extension(ARB,ES3_2_compatibility),
_extension(ATI,texture_mirror_once),
_extension(EXT,texture_filter_anisotropic),
_extension(EXT,texture_compression_s3tc),
_extension(EXT,texture_mirror_clamp),
_extension(EXT,direct_state_access),
_extension(EXT,texture_sRGB_decode),
_extension(EXT,shader_integer_mix),
_extension(EXT,debug_label),
_extension(EXT,debug_marker),
_extension(GREMEDY,string_marker),
_extension(KHR,texture_compression_astc_ldr),
_extension(KHR,texture_compression_astc_hdr),
_extension(KHR,blend_equation_advanced),
_extension(KHR,blend_equation_advanced_coherent)};
Extension lists can be const as well.
14 years ago
static const std::vector<Extension> extensions300{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,map_buffer_range),
_extension(ARB,color_buffer_float),
_extension(ARB,half_float_pixel),
_extension(ARB,texture_float),
_extension(ARB,depth_buffer_float),
_extension(ARB,texture_rg),
_extension(ARB,vertex_array_object),
_extension(ARB,framebuffer_object),
_extension(ARB,framebuffer_sRGB),
_extension(ARB,half_float_vertex),
_extension(EXT,gpu_shader4),
_extension(EXT,packed_float),
_extension(EXT,texture_array),
_extension(EXT,texture_compression_rgtc),
_extension(EXT,texture_shared_exponent),
_extension(EXT,draw_buffers2),
_extension(EXT,texture_integer),
_extension(EXT,transform_feedback),
_extension(NV,depth_buffer_float),
_extension(NV,conditional_render)};
Extension lists can be const as well.
14 years ago
static const std::vector<Extension> extensions310{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,texture_rectangle),
_extension(ARB,draw_instanced),
_extension(ARB,texture_buffer_object),
_extension(ARB,uniform_buffer_object),
_extension(ARB,copy_buffer),
_extension(EXT,texture_snorm),
_extension(NV,primitive_restart)};
Extension lists can be const as well.
14 years ago
static const std::vector<Extension> extensions320{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,geometry_shader4),
_extension(ARB,depth_clamp),
_extension(ARB,draw_elements_base_vertex),
_extension(ARB,fragment_coord_conventions),
_extension(ARB,provoking_vertex),
_extension(ARB,seamless_cube_map),
_extension(ARB,sync),
_extension(ARB,texture_multisample),
_extension(ARB,vertex_array_bgra)};
Extension lists can be const as well.
14 years ago
static const std::vector<Extension> extensions330{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,instanced_arrays),
_extension(ARB,blend_func_extended),
_extension(ARB,explicit_attrib_location),
_extension(ARB,occlusion_query2),
_extension(ARB,sampler_objects),
_extension(ARB,shader_bit_encoding),
_extension(ARB,texture_rgb10_a2ui),
_extension(ARB,texture_swizzle),
_extension(ARB,timer_query),
_extension(ARB,vertex_type_2_10_10_10_rev)};
Extension lists can be const as well.
14 years ago
static const std::vector<Extension> extensions400{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,draw_buffers_blend),
_extension(ARB,sample_shading),
_extension(ARB,texture_cube_map_array),
_extension(ARB,texture_gather),
_extension(ARB,texture_query_lod),
_extension(ARB,draw_indirect),
_extension(ARB,gpu_shader5),
_extension(ARB,gpu_shader_fp64),
_extension(ARB,shader_subroutine),
_extension(ARB,tessellation_shader),
_extension(ARB,texture_buffer_object_rgb32),
_extension(ARB,transform_feedback2),
_extension(ARB,transform_feedback3)};
Extension lists can be const as well.
14 years ago
static const std::vector<Extension> extensions410{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,ES2_compatibility),
_extension(ARB,get_program_binary),
_extension(ARB,separate_shader_objects),
_extension(ARB,shader_precision),
_extension(ARB,vertex_attrib_64bit),
_extension(ARB,viewport_array)};
Extension lists can be const as well.
14 years ago
static const std::vector<Extension> extensions420{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,texture_compression_bptc),
_extension(ARB,base_instance),
_extension(ARB,shading_language_420pack),
_extension(ARB,transform_feedback_instanced),
_extension(ARB,compressed_texture_pixel_storage),
_extension(ARB,conservative_depth),
_extension(ARB,internalformat_query),
_extension(ARB,map_buffer_alignment),
_extension(ARB,shader_atomic_counters),
_extension(ARB,shader_image_load_store),
Added missing ARB_shading_language_packing extension. It contains a few (un)packing functions present in ARB_gpu_shader5, but isn't mentioned anywhere except GLSL 4.20 changelog (and there it has its old name, ARB_shading_language_pack2f). It might be supported on machines where ARB_gpu_shader5 can't be supported (GL3 HW).
13 years ago
/* Mentioned in GLSL 4.20 specs as newly added */
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,shading_language_packing),
_extension(ARB,texture_storage)};
Added OpenGL 4.3 extensions to the list.
14 years ago
static const std::vector<Extension> extensions430{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,arrays_of_arrays),
_extension(ARB,ES3_compatibility),
_extension(ARB,clear_buffer_object),
_extension(ARB,compute_shader),
_extension(ARB,copy_image),
_extension(ARB,explicit_uniform_location),
_extension(ARB,fragment_layer_viewport),
_extension(ARB,framebuffer_no_attachments),
_extension(ARB,internalformat_query2),
_extension(ARB,invalidate_subdata),
_extension(ARB,multi_draw_indirect),
_extension(ARB,program_interface_query),
_extension(ARB,robust_buffer_access_behavior),
_extension(ARB,shader_image_size),
_extension(ARB,shader_storage_buffer_object),
_extension(ARB,stencil_texturing),
_extension(ARB,texture_buffer_range),
_extension(ARB,texture_query_levels),
_extension(ARB,texture_storage_multisample),
_extension(ARB,texture_view),
_extension(ARB,vertex_attrib_binding),
_extension(KHR,debug)};
Initial support for OpenGL 4.4.
13 years ago
static const std::vector<Extension> extensions440{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,buffer_storage),
_extension(ARB,clear_texture),
_extension(ARB,enhanced_layouts),
_extension(ARB,multi_bind),
_extension(ARB,query_buffer_object),
_extension(ARB,texture_mirror_clamp_to_edge),
_extension(ARB,texture_stencil8),
_extension(ARB,vertex_type_10f_11f_11f_rev)};
Initial support for OpenGL 4.5.
12 years ago
static const std::vector<Extension> extensions450{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,ES3_1_compatibility),
_extension(ARB,clip_control),
_extension(ARB,conditional_render_inverted),
_extension(ARB,cull_distance),
_extension(ARB,derivative_control),
_extension(ARB,direct_state_access),
_extension(ARB,get_texture_sub_image),
_extension(ARB,shader_texture_image_samples),
_extension(ARB,texture_barrier),
_extension(KHR,context_flush_control),
_extension(KHR,robustness)};
Minimal support for OpenGL 4.6.
8 years ago
static const std::vector<Extension> extensions460{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ARB,indirect_parameters),
_extension(ARB,shader_draw_parameters),
_extension(ARB,shader_group_vote),
_extension(ARB,pipeline_statistics_query),
_extension(ARB,transform_feedback_overflow_query),
_extension(ARB,shader_atomic_counter_ops),
_extension(ARB,gl_spirv),
_extension(ARB,polygon_offset_clamp),
_extension(ARB,spirv_extensions),
_extension(ARB,texture_filter_anisotropic),
_extension(KHR,no_error)};
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
#elif defined(MAGNUM_TARGET_WEBGL)
static const std::vector<Extension> extensions{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(EXT,texture_filter_anisotropic),
_extension(EXT,disjoint_timer_query),
_extension(EXT,color_buffer_float),
_extension(OES,texture_float_linear),
_extension(WEBGL,compressed_texture_s3tc)};
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
#ifdef MAGNUM_TARGET_GLES2
static const std::vector<Extension> extensionsES300{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ANGLE,instanced_arrays),
_extension(EXT,color_buffer_half_float),
_extension(EXT,sRGB),
_extension(EXT,blend_minmax),
_extension(EXT,shader_texture_lod),
_extension(OES,texture_float),
_extension(OES,texture_half_float),
_extension(OES,standard_derivatives),
_extension(OES,vertex_array_object),
_extension(OES,element_index_uint),
_extension(OES,texture_half_float_linear),
_extension(OES,fbo_render_mipmap),
_extension(WEBGL,depth_texture),
_extension(WEBGL,color_buffer_float),
_extension(WEBGL,draw_buffers)};
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
#endif
Updated OpenGL ES support in Context and related files.
14 years ago
#else
Added all currently supported OpenGL ES extensions to the list.
14 years ago
static const std::vector<Extension> extensions{
Added ANDROID_extension_pack_es31a extensions. Just added them to the list, nothing integrated or implemented yet. Also added some more stuff into OpenGL mapping table, as I apparently forgot some entries.
11 years ago
#ifndef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ANDROID,extension_pack_es31a),
Added ANDROID_extension_pack_es31a extensions. Just added them to the list, nothing integrated or implemented yet. Also added some more stuff into OpenGL mapping table, as I apparently forgot some entries.
11 years ago
#endif
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(APPLE,texture_format_BGRA8888),
_extension(ARM,shader_framebuffer_fetch),
_extension(ARM,shader_framebuffer_fetch_depth_stencil),
_extension(EXT,texture_filter_anisotropic),
_extension(EXT,texture_format_BGRA8888),
_extension(EXT,read_format_bgra),
_extension(EXT,multi_draw_arrays),
_extension(EXT,debug_label),
_extension(EXT,debug_marker),
_extension(EXT,separate_shader_objects),
_extension(EXT,multisampled_render_to_texture),
_extension(EXT,robustness),
_extension(EXT,shader_framebuffer_fetch),
_extension(EXT,disjoint_timer_query),
_extension(EXT,texture_sRGB_decode),
_extension(EXT,sRGB_write_control),
_extension(EXT,texture_compression_s3tc),
Added ANDROID_extension_pack_es31a extensions. Just added them to the list, nothing integrated or implemented yet. Also added some more stuff into OpenGL mapping table, as I apparently forgot some entries.
11 years ago
#ifndef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(EXT,shader_integer_mix),
Added ANDROID_extension_pack_es31a extensions. Just added them to the list, nothing integrated or implemented yet. Also added some more stuff into OpenGL mapping table, as I apparently forgot some entries.
11 years ago
#endif
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(EXT,polygon_offset_clamp),
_extension(KHR,texture_compression_astc_hdr),
_extension(KHR,blend_equation_advanced_coherent),
_extension(KHR,context_flush_control),
_extension(KHR,no_error),
_extension(NV,read_buffer_front),
_extension(NV,read_depth),
_extension(NV,read_stencil),
_extension(NV,read_depth_stencil),
_extension(NV,texture_border_clamp),
Added NV_shader_noperspective_interpolation ES3 extension.
11 years ago
#ifndef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(NV,shader_noperspective_interpolation),
Added NV_shader_noperspective_interpolation ES3 extension.
11 years ago
#endif
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(NV,polygon_mode),
_extension(OES,depth32),
_extension(OES,mapbuffer),
_extension(OES,stencil1),
_extension(OES,stencil4),
_extension(OES,texture_float_linear)};
Don't expose unneeded ES2 extensions under ES3. They provide the same or slightly different functionality as is present in ES3 itself, causing confusion. Fortunately this change required only one modification in Context test and nowhere else.
13 years ago
#ifdef MAGNUM_TARGET_GLES2
Added all currently supported OpenGL ES extensions to the list.
14 years ago
static const std::vector<Extension> extensionsES300{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(ANGLE,framebuffer_blit),
_extension(ANGLE,framebuffer_multisample),
_extension(ANGLE,instanced_arrays),
_extension(ANGLE,depth_texture),
_extension(APPLE,framebuffer_multisample),
_extension(APPLE,texture_max_level),
_extension(ARM,rgba8),
_extension(EXT,texture_type_2_10_10_10_REV),
_extension(EXT,discard_framebuffer),
_extension(EXT,blend_minmax),
_extension(EXT,shader_texture_lod),
_extension(EXT,unpack_subimage),
_extension(EXT,occlusion_query_boolean),
_extension(EXT,shadow_samplers),
_extension(EXT,texture_rg),
_extension(EXT,sRGB),
_extension(EXT,texture_storage),
_extension(EXT,map_buffer_range),
_extension(EXT,draw_buffers),
_extension(EXT,instanced_arrays),
_extension(EXT,draw_instanced),
_extension(NV,draw_buffers),
_extension(NV,fbo_color_attachments),
_extension(NV,read_buffer),
_extension(NV,pack_subimage),
_extension(NV,draw_instanced),
_extension(NV,framebuffer_blit),
_extension(NV,framebuffer_multisample),
_extension(NV,instanced_arrays),
_extension(NV,shadow_samplers_array),
_extension(NV,shadow_samplers_cube),
_extension(OES,depth24),
_extension(OES,element_index_uint),
_extension(OES,fbo_render_mipmap),
_extension(OES,rgb8_rgba8),
_extension(OES,texture_3D),
_extension(OES,texture_half_float_linear),
_extension(OES,texture_half_float),
_extension(OES,texture_float),
_extension(OES,texture_npot),
_extension(OES,vertex_half_float),
_extension(OES,packed_depth_stencil),
_extension(OES,depth_texture),
_extension(OES,standard_derivatives),
_extension(OES,vertex_array_object),
_extension(OES,required_internalformat),
_extension(OES,surfaceless_context)};
Updated OpenGL ES support in Context and related files.
14 years ago
#endif
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
static const std::vector<Extension> extensionsES320{
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(EXT,color_buffer_half_float),
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#ifndef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(EXT,color_buffer_float),
_extension(EXT,copy_image),
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#endif
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(EXT,draw_buffers_indexed),
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#ifndef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(EXT,geometry_shader),
_extension(EXT,gpu_shader5),
_extension(EXT,shader_io_blocks),
_extension(EXT,tessellation_shader),
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#endif
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(EXT,texture_border_clamp),
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#ifndef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(EXT,texture_buffer),
_extension(EXT,texture_cube_map_array),
_extension(EXT,primitive_bounding_box),
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#endif
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(KHR,texture_compression_astc_ldr),
_extension(KHR,debug),
_extension(KHR,blend_equation_advanced),
_extension(KHR,robustness),
_extension(KHR,robust_buffer_access_behavior),
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#ifndef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(OES,sample_shading),
_extension(OES,sample_variables),
_extension(OES,shader_image_atomic),
_extension(OES,shader_multisample_interpolation),
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#endif
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(OES,texture_stencil8),
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#ifndef MAGNUM_TARGET_GLES2
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
_extension(OES,texture_storage_multisample_2d_array)
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
#endif
};
Don't expose unneeded ES2 extensions under ES3. They provide the same or slightly different functionality as is present in ES3 itself, causing confusion. Fortunately this change required only one modification in Context test and nowhere else.
13 years ago
#endif
Undef privately used macro in all cases.
11 years ago
#undef _extension
Classes for handling version and extension information.
14 years ago
switch(version) {
case Version::None: return extensions;
Updated OpenGL ES support in Context and related files.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Don't have `default:` in switches where all cases need to be handled. Also added assert for cases which shouldn't be reached.
14 years ago
case Version::GL210: return empty;
Classes for handling version and extension information.
14 years ago
case Version::GL300: return extensions300;
case Version::GL310: return extensions310;
case Version::GL320: return extensions320;
case Version::GL330: return extensions330;
case Version::GL400: return extensions400;
case Version::GL410: return extensions410;
case Version::GL420: return extensions420;
case Version::GL430: return extensions430;
Initial support for OpenGL 4.4.
13 years ago
case Version::GL440: return extensions440;
Initial support for OpenGL 4.5.
12 years ago
case Version::GL450: return extensions450;
Minimal support for OpenGL 4.6.
8 years ago
case Version::GL460: return extensions460;
Make the ES versions first-class on desktop OpenGL. What this changes: * Before, a Version::GLES310 shader was created with `#version 450` directive, which is wrong, because an implementation might support GLES 3.1 but not GL 4.5 so this was not working and also the syntax is a bit different so this wasn't helpful at all. * Similarly, Context::isVersionSupported(Version::GLES310) was checking for support of OpenGL 4.5. Now it just checks for `ARB_ES3_1_compatibility` extension. * Added a small isVersionES() utility that just tells whether given version is ES or not.
10 years ago
case Version::GLES200:
case Version::GLES300:
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
case Version::GLES310:
case Version::GLES320: return empty;
Updated OpenGL ES support in Context and related files.
14 years ago
#else
ES 2.0 extension list is equivalent to GL 2.1 extension list -- empty. We assert that minimal OpenGL version is GL 2.1 / ES 2.0, thus there is no need for list of extensions implemented in these versions.
14 years ago
case Version::GLES200: return empty;
Don't expose unneeded ES2 extensions under ES3. They provide the same or slightly different functionality as is present in ES3 itself, causing confusion. Fortunately this change required only one modification in Context test and nowhere else.
13 years ago
case Version::GLES300:
#ifdef MAGNUM_TARGET_GLES2
return extensionsES300;
#else
return empty;
#endif
First-class WebGL support, part 13: reduce version enum.
11 years ago
#ifndef MAGNUM_TARGET_WEBGL
There are no new extensions in ES 3.1.
11 years ago
case Version::GLES310: return empty;
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
case Version::GLES320: return extensionsES320;
Updated OpenGL ES support in Context and related files.
14 years ago
#endif
First-class WebGL support, part 13: reduce version enum.
11 years ago
#endif
Classes for handling version and extension information.
14 years ago
}
Don't have `default:` in switches where all cases need to be handled. Also added assert for cases which shouldn't be reached.
14 years ago
Exclude unreachable code from code coverage.
10 years ago
CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
Classes for handling version and extension information.
14 years ago
}
Introduce BUILD_MULTITHREADED CMake option. Enabled by default, makes the current Magnum context a thread-local variable instead of a global one, so it's possible to have multiple thread-local contexts. Might have some performance implications, that's why it's possible to disable it (but enabled by default is the safer option). GCC 4.7 and Apple platforms don't support thread_local, but __thread does the job too (though on iOS not until Xcode 7.3). Also had to move it to file-local because MSVC doesn't like having thread local variables as part of DLL interface. (And there is *of course* no way to disable exporting one particular member. F' that.)
10 years ago
namespace {
#ifdef MAGNUM_BUILD_MULTITHREADED
#if !defined(CORRADE_GCC47_COMPATIBILITY) && !defined(CORRADE_TARGET_APPLE)
thread_local
#else
__thread
#endif
#endif
Context* currentContext = nullptr;
}
Classes for handling version and extension information.
14 years ago
Introduce BUILD_MULTITHREADED CMake option. Enabled by default, makes the current Magnum context a thread-local variable instead of a global one, so it's possible to have multiple thread-local contexts. Might have some performance implications, that's why it's possible to disable it (but enabled by default is the safer option). GCC 4.7 and Apple platforms don't support thread_local, but __thread does the job too (though on iOS not until Xcode 7.3). Also had to move it to file-local because MSVC doesn't like having thread local variables as part of DLL interface. (And there is *of course* no way to disable exporting one particular member. F' that.)
10 years ago
bool Context::hasCurrent() { return currentContext; }
Context::current() now returns reference instead of pointer. 103% of use cases use the returned value directly without checking, so we might as well do the check ourselves. Added new function hasCurrent() and added deprecated backward-compatibility conversion and -> operators. Wow, that creeped to a lot of places. Last dinosaur from the pointer age.
10 years ago
Context& Context::current() {
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
CORRADE_ASSERT(currentContext, "GL::Context::current(): no current context", *currentContext);
Introduce BUILD_MULTITHREADED CMake option. Enabled by default, makes the current Magnum context a thread-local variable instead of a global one, so it's possible to have multiple thread-local contexts. Might have some performance implications, that's why it's possible to disable it (but enabled by default is the safer option). GCC 4.7 and Apple platforms don't support thread_local, but __thread does the job too (though on iOS not until Xcode 7.3). Also had to move it to file-local because MSVC doesn't like having thread local variables as part of DLL interface. (And there is *of course* no way to disable exporting one particular member. F' that.)
10 years ago
return *currentContext;
Context::current() now returns reference instead of pointer. 103% of use cases use the returned value directly without checking, so we might as well do the check ourselves. Added new function hasCurrent() and added deprecated backward-compatibility conversion and -> operators. Wow, that creeped to a lot of places. Last dinosaur from the pointer age.
10 years ago
}
GL: make it possible to pass a pre-filled Utility::Arguments to Context. For example to support additional app-specific configuration.
8 years ago
Context::Context(NoCreateT, Int argc, const char** argv, void functionLoader()): Context{NoCreate, Utility::Arguments{"magnum"}, argc, argv, functionLoader} {}
Context::Context(NoCreateT, Utility::Arguments& args, Int argc, const char** argv, void functionLoader()): _functionLoader{functionLoader}, _version{Version::None} {
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
/* Parse arguments */
GL: make it possible to pass a pre-filled Utility::Arguments to Context. For example to support additional app-specific configuration.
8 years ago
CORRADE_INTERNAL_ASSERT(args.prefix() == "magnum");
Ability to disable workarounds and extensions from environment. Use MAGNUM_DISABLE_WORKAROUNDS and MAGNUM_DISABLE_EXTENSIONS environment variables.
10 years ago
args.addOption("disable-workarounds")
doc: better documented GL driver workarounds and how to add them.
8 years ago
.setHelp("disable-workarounds", "driver workarounds to disable\n (see http://doc.magnum.graphics/magnum/opengl-workarounds.html for detailed info)", "LIST")
Ability to disable workarounds and extensions from environment. Use MAGNUM_DISABLE_WORKAROUNDS and MAGNUM_DISABLE_EXTENSIONS environment variables.
10 years ago
.addOption("disable-extensions").setHelp("disable-extensions", "OpenGL extensions to disable", "LIST")
Ability to control the amount of console output in engine initialization.
10 years ago
.addOption("log", "default").setHelp("log", "Console logging", "default|quiet")
Ability to disable workarounds and extensions from environment. Use MAGNUM_DISABLE_WORKAROUNDS and MAGNUM_DISABLE_EXTENSIONS environment variables.
10 years ago
.setFromEnvironment("disable-workarounds")
.setFromEnvironment("disable-extensions")
Ability to control the amount of console output in engine initialization.
10 years ago
.setFromEnvironment("log")
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
.parse(argc, argv);
Ability to control the amount of console output in engine initialization.
10 years ago
/* Decide whether to display initialization log */
_displayInitializationLog = !(args.value("log") == "quiet" || args.value("log") == "QUIET");
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
/* Disable driver workarounds */
for(auto&& workaround: Utility::String::splitWithoutEmptyParts(args.value("disable-workarounds")))
disableDriverWorkaround(workaround);
Ability to disable OpenGL extensions from command-line. Added `--magnum-disable-extensions` option next to the already existing `--magnum-disable-workarounds`. Specified extensions are not used automatically and also report as disabled and unsupported when asked using Context::isExtensionSupported() and Context::isExtensionDisabled().
11 years ago
/* Disable extensions */
for(auto&& extension: Utility::String::splitWithoutEmptyParts(args.value("disable-extensions")))
_disabledExtensions.push_back(extension);
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
}
Modernize #1
9 years ago
Context::Context(Context&& other): _version{other._version},
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
#ifndef MAGNUM_TARGET_WEBGL
Modernize #1
9 years ago
_flags{other._flags},
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
#endif
Modernize #1
9 years ago
_extensionRequiredVersion(other._extensionRequiredVersion),
_extensionStatus{other._extensionStatus},
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
_supportedExtensions{std::move(other._supportedExtensions)},
Modernize #1
9 years ago
_state{other._state},
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
_detectedDrivers{std::move(other._detectedDrivers)}
{
other._state = nullptr;
Introduce BUILD_MULTITHREADED CMake option. Enabled by default, makes the current Magnum context a thread-local variable instead of a global one, so it's possible to have multiple thread-local contexts. Might have some performance implications, that's why it's possible to disable it (but enabled by default is the safer option). GCC 4.7 and Apple platforms don't support thread_local, but __thread does the job too (though on iOS not until Xcode 7.3). Also had to move it to file-local because MSVC doesn't like having thread local variables as part of DLL interface. (And there is *of course* no way to disable exporting one particular member. F' that.)
10 years ago
if(currentContext == &other) currentContext = this;
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
}
Move extension loading into Magnum::Context. Resolves some linker errors in Windows, removes code bloat from Platform namespace (previously it was copied in _every_ *Application). Originally this was in Platform namespace because I thought that it would be possible to have one version of Magnum library for both desktop and ES and the actual Application would determine which GL edition will be used. Fun idea, but it would remove the static checks (e.g. accidentaly using geometry shaders on ES), which isn't worth it.
13 years ago
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
Context::~Context() {
delete _state;
Introduce BUILD_MULTITHREADED CMake option. Enabled by default, makes the current Magnum context a thread-local variable instead of a global one, so it's possible to have multiple thread-local contexts. Might have some performance implications, that's why it's possible to disable it (but enabled by default is the safer option). GCC 4.7 and Apple platforms don't support thread_local, but __thread does the job too (though on iOS not until Xcode 7.3). Also had to move it to file-local because MSVC doesn't like having thread local variables as part of DLL interface. (And there is *of course* no way to disable exporting one particular member. F' that.)
10 years ago
if(currentContext == this) currentContext = nullptr;
Ability to do GL context creation fallbacks even from Context constructor. In some cases the GL context creation might success without error, but the created version is one that we don't want (e.g. software GDI rasterizer on Windows). Previously the Context class constructor just exited the application and it was impossible to react on that from the application side (for example reducing some context feature requirements). Now there is Platform::Context::tryCreate(), which returns either created instance or `nullptr` if the instance creation failed with some error. That is now used in all Platform::*Application implementations.
11 years ago
}
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
void Context::create() {
Ability to do GL context creation fallbacks even from Context constructor. In some cases the GL context creation might success without error, but the created version is one that we don't want (e.g. software GDI rasterizer on Windows). Previously the Context class constructor just exited the application and it was impossible to react on that from the application side (for example reducing some context feature requirements). Now there is Platform::Context::tryCreate(), which returns either created instance or `nullptr` if the instance creation failed with some error. That is now used in all Platform::*Application implementations.
11 years ago
/* Hard exit if the context cannot be created */
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
if(!tryCreate()) std::exit(1);
Ability to do GL context creation fallbacks even from Context constructor. In some cases the GL context creation might success without error, but the created version is one that we don't want (e.g. software GDI rasterizer on Windows). Previously the Context class constructor just exited the application and it was impossible to react on that from the application side (for example reducing some context feature requirements). Now there is Platform::Context::tryCreate(), which returns either created instance or `nullptr` if the instance creation failed with some error. That is now used in all Platform::*Application implementations.
11 years ago
}
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
bool Context::tryCreate() {
CORRADE_ASSERT(_version == Version::None,
"Platform::Context::tryCreate(): context already created", false);
/* Load GL function pointers */
if(_functionLoader) _functionLoader();
Initialize version to (0, 0) to avoid crashes on broken GL contexts.
10 years ago
/* Initialize to something predictable to avoid crashes on improperly
created contexts */
GLint majorVersion = 0, minorVersion = 0;
Remove unused Context::{major,minor}Version() functions. Superseeded by Context::version() and various utilities around Version enum.
11 years ago
Don't query GL_{MMAJOR,MINOR}_VERSION on WebGL 2. It doesn't make any sense -- WebGL 2 doesn't provide any equivalent functionality for this and so I don't even know what values should this return (3.0? 2.0?). Instead I just check for "WebGL 2" string prefix and treat it as ES 3.0.
11 years ago
/* Get version on ES 3.0+/WebGL 2.0+ */
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
#if defined(MAGNUM_TARGET_GLES) && !defined(MAGNUM_TARGET_GLES2)
Don't query GL_{MMAJOR,MINOR}_VERSION on WebGL 2. It doesn't make any sense -- WebGL 2 doesn't provide any equivalent functionality for this and so I don't even know what values should this return (3.0? 2.0?). Instead I just check for "WebGL 2" string prefix and treat it as ES 3.0.
11 years ago
/* ES 3.0+ */
#ifndef MAGNUM_TARGET_WEBGL
Remove unused Context::{major,minor}Version() functions. Superseeded by Context::version() and various utilities around Version enum.
11 years ago
glGetIntegerv(GL_MAJOR_VERSION, &majorVersion);
glGetIntegerv(GL_MINOR_VERSION, &minorVersion);
Don't query GL_{MMAJOR,MINOR}_VERSION on WebGL 2. It doesn't make any sense -- WebGL 2 doesn't provide any equivalent functionality for this and so I don't even know what values should this return (3.0? 2.0?). Instead I just check for "WebGL 2" string prefix and treat it as ES 3.0.
11 years ago
/* WebGL 2.0, treat it as ES 3.0 */
If targetting exactly ES 2.0, hide everything not available there. Some target platforms supply their own OpenGL headers, thus we cannot use our own from ES 3.0 and compilation fails. On the other hand, this will be better for users as usage of unsupported features will be catched right during compilation and not at runtime.
14 years ago
#else
Don't query GL_{MMAJOR,MINOR}_VERSION on WebGL 2. It doesn't make any sense -- WebGL 2 doesn't provide any equivalent functionality for this and so I don't even know what values should this return (3.0? 2.0?). Instead I just check for "WebGL 2" string prefix and treat it as ES 3.0.
11 years ago
const std::string version = versionString();
if(version.find("WebGL 2") == std::string::npos) {
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
Error{} << "GL::Context: unsupported version string:" << version;
Ability to do GL context creation fallbacks even from Context constructor. In some cases the GL context creation might success without error, but the created version is one that we don't want (e.g. software GDI rasterizer on Windows). Previously the Context class constructor just exited the application and it was impossible to react on that from the application side (for example reducing some context feature requirements). Now there is Platform::Context::tryCreate(), which returns either created instance or `nullptr` if the instance creation failed with some error. That is now used in all Platform::*Application implementations.
11 years ago
return false;
Don't query GL_{MMAJOR,MINOR}_VERSION on WebGL 2. It doesn't make any sense -- WebGL 2 doesn't provide any equivalent functionality for this and so I don't even know what values should this return (3.0? 2.0?). Instead I just check for "WebGL 2" string prefix and treat it as ES 3.0.
11 years ago
}
Remove unused Context::{major,minor}Version() functions. Superseeded by Context::version() and various utilities around Version enum.
11 years ago
majorVersion = 3;
minorVersion = 0;
Don't query GL_{MMAJOR,MINOR}_VERSION on WebGL 2. It doesn't make any sense -- WebGL 2 doesn't provide any equivalent functionality for this and so I don't even know what values should this return (3.0? 2.0?). Instead I just check for "WebGL 2" string prefix and treat it as ES 3.0.
11 years ago
#endif
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
/* On GL 2.1 and ES 2.0 there is no GL_{MAJOR,MINOR}_VERSION, we have to
parse version string. On desktop GL we have no way to check version
without version (duh) so we work around that by checking for invalid
enum error. */
Don't query GL_{MMAJOR,MINOR}_VERSION on WebGL 2. It doesn't make any sense -- WebGL 2 doesn't provide any equivalent functionality for this and so I don't even know what values should this return (3.0? 2.0?). Instead I just check for "WebGL 2" string prefix and treat it as ES 3.0.
11 years ago
#else
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
Remove unused Context::{major,minor}Version() functions. Superseeded by Context::version() and various utilities around Version enum.
11 years ago
glGetIntegerv(GL_MAJOR_VERSION, &majorVersion);
Fix ES3 build. Gah. And I tested it seven times.
12 years ago
const auto versionNumberError = Renderer::error();
if(versionNumberError == Renderer::Error::NoError)
Remove unused Context::{major,minor}Version() functions. Superseeded by Context::version() and various utilities around Version enum.
11 years ago
glGetIntegerv(GL_MINOR_VERSION, &minorVersion);
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
else
If targetting exactly ES 2.0, hide everything not available there. Some target platforms supply their own OpenGL headers, thus we cannot use our own from ES 3.0 and compilation fails. On the other hand, this will be better for users as usage of unsupported features will be catched right during compilation and not at runtime.
14 years ago
#endif
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
{
#ifndef MAGNUM_TARGET_GLES2
Fix ES3 build. Gah. And I tested it seven times.
12 years ago
CORRADE_ASSERT(versionNumberError == Renderer::Error::InvalidEnum,
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
"GL::Context: cannot retrieve OpenGL version:" << versionNumberError, false);
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
#endif
Be less strict in OpenGL ES context version. I didn't yet have time to add more complete support for ES 3.1, but the engine should at least work on it. If the driver reports ES 3.0 or 3.1 it is taken as valid value in both ES2 and ES3 builds (i.e. the engine can work in ES2 mode also on ES3 driver).
12 years ago
/* Allow ES2 context on driver that reports ES3 as supported */
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
const std::string version = versionString();
#ifndef MAGNUM_TARGET_GLES
Less strict version string comparison in Context. Not all drivers return "2.1 Vendor", there is also "2.1.2 NVIDIA" (and probably more).
12 years ago
if(version.compare(0, 3, "2.1") == 0)
Use more general MAGNUM_TARGET_WEBGL instead of CORRADE_TARGET_EMSCRIPTEN. Only where it matters, though.
12 years ago
#elif defined(MAGNUM_TARGET_WEBGL)
Support Internet Explorer. It claims to have WebGL 0.94.
11 years ago
/* Internet Explorer currently has 0.94 */
if(version.find("WebGL 1") != std::string::npos ||
version.find("WebGL 0") != std::string::npos)
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
#else
Be less strict in OpenGL ES context version. I didn't yet have time to add more complete support for ES 3.1, but the engine should at least work on it. If the driver reports ES 3.0 or 3.1 it is taken as valid value in both ES2 and ES3 builds (i.e. the engine can work in ES2 mode also on ES3 driver).
12 years ago
if(version.find("OpenGL ES 2.0") != std::string::npos ||
Document the non-obvious behavior.
11 years ago
/* It is possible to use Magnum compiled for ES2 on ES3 contexts */
Be less strict in OpenGL ES context version. I didn't yet have time to add more complete support for ES 3.1, but the engine should at least work on it. If the driver reports ES 3.0 or 3.1 it is taken as valid value in both ES2 and ES3 builds (i.e. the engine can work in ES2 mode also on ES3 driver).
12 years ago
version.find("OpenGL ES 3.") != std::string::npos)
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
#endif
{
Remove unused Context::{major,minor}Version() functions. Superseeded by Context::version() and various utilities around Version enum.
11 years ago
majorVersion = 2;
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
#ifndef MAGNUM_TARGET_GLES
Remove unused Context::{major,minor}Version() functions. Superseeded by Context::version() and various utilities around Version enum.
11 years ago
minorVersion = 1;
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
#else
Remove unused Context::{major,minor}Version() functions. Superseeded by Context::version() and various utilities around Version enum.
11 years ago
minorVersion = 0;
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
#endif
} else {
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
Error{} << "GL::Context: unsupported version string:" << version;
Ability to do GL context creation fallbacks even from Context constructor. In some cases the GL context creation might success without error, but the created version is one that we don't want (e.g. software GDI rasterizer on Windows). Previously the Context class constructor just exited the application and it was impossible to react on that from the application side (for example reducing some context feature requirements). Now there is Platform::Context::tryCreate(), which returns either created instance or `nullptr` if the instance creation failed with some error. That is now used in all Platform::*Application implementations.
11 years ago
return false;
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
}
}
#endif
/* Compose the version enum */
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
_version = GL::version(majorVersion, minorVersion);
Classes for handling version and extension information.
14 years ago
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
/* Check that version retrieval went right */
Print more information when cannot retrieve OpenGL version. At least the OpenGL error should be enough to pinpoint what went wrong.
12 years ago
#ifndef CORRADE_NO_ASSERT
Fix ES3 build. Gah. And I tested it seven times.
12 years ago
const auto error = Renderer::error();
Print more information when cannot retrieve OpenGL version. At least the OpenGL error should be enough to pinpoint what went wrong.
12 years ago
CORRADE_ASSERT(error == Renderer::Error::NoError,
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
"GL::Context: cannot retrieve OpenGL version:" << error, false);
Print more information when cannot retrieve OpenGL version. At least the OpenGL error should be enough to pinpoint what went wrong.
12 years ago
#endif
Verify that version retrieval went right. Sometimes the context is created improperly and all gl* functions are causing errors. Added check for that case.
13 years ago
Fix version checks on OpenGL 2.1 and OpenGL ES 2.0. Both don't have GL_{MAJOR,MINOR}_VERSION enums so we must decide whether the version is older than OpenGL 3.0 / ES 3.0 either using MAGNUM_TARGET_GLES2 preprocessor definition or checking for invalid enum error and then we have to parse version string to ensure that the version is not too old. On ES2 the version check wasn't present at all (only optimistic hope), this makes it more hardened.
12 years ago
/* Check that the version is supported (now it probably is, but be sure) */
Sanity check for OpenGL version in Context. I though this check was present since forever, but isn't. Maybe it's hidden somewhere else.
13 years ago
#ifndef MAGNUM_TARGET_GLES
It probably isn't good idea to have version checks as assertions. In particular when building with CORRADE_NO_ASSERT the version doesn't get checked at all, silently failing on null pointer somewhere else.
12 years ago
if(!isVersionSupported(Version::GL210))
Sanity check for OpenGL version in Context. I though this check was present since forever, but isn't. Maybe it's hidden somewhere else.
13 years ago
#elif defined(MAGNUM_TARGET_GLES2)
Hardened checks for OpenGL ES version. There is no ES 2.5 or 3.01 and this way we can properly check for garbage returned by `glGet(GL_VERSION_M*OR)` (e.g. version 2674.-2O8539 would pass here).
12 years ago
if(_version != Version::GLES200)
Sanity check for OpenGL version in Context. I though this check was present since forever, but isn't. Maybe it's hidden somewhere else.
13 years ago
#else
Be less strict in OpenGL ES context version. I didn't yet have time to add more complete support for ES 3.1, but the engine should at least work on it. If the driver reports ES 3.0 or 3.1 it is taken as valid value in both ES2 and ES3 builds (i.e. the engine can work in ES2 mode also on ES3 driver).
12 years ago
if(!isVersionSupported(Version::GLES300))
Sanity check for OpenGL version in Context. I though this check was present since forever, but isn't. Maybe it's hidden somewhere else.
13 years ago
#endif
It probably isn't good idea to have version checks as assertions. In particular when building with CORRADE_NO_ASSERT the version doesn't get checked at all, silently failing on null pointer somewhere else.
12 years ago
{
#ifndef MAGNUM_TARGET_GLES
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
Error{} << "GL::Context: unsupported OpenGL version" << std::make_pair(majorVersion, minorVersion);
It probably isn't good idea to have version checks as assertions. In particular when building with CORRADE_NO_ASSERT the version doesn't get checked at all, silently failing on null pointer somewhere else.
12 years ago
#else
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
Error{} << "GL::Context: unsupported OpenGL ES version" << std::make_pair(majorVersion, minorVersion);
It probably isn't good idea to have version checks as assertions. In particular when building with CORRADE_NO_ASSERT the version doesn't get checked at all, silently failing on null pointer somewhere else.
12 years ago
#endif
Initial support for passing arguments directly to the engine. The parameterless Platform::Context::Context() constructor and Platform::Context::tryCreate() function are deprecated in favor functions that take argc/argv pair. The Context class now accepts arguments starting with --magnum-* prefix. Currently there are none except for the implicit --magnum-help, but that will change with the following commits.
11 years ago
/* Reset the version so the context is not marked as successfully created */
_version = Version::None;
Ability to do GL context creation fallbacks even from Context constructor. In some cases the GL context creation might success without error, but the created version is one that we don't want (e.g. software GDI rasterizer on Windows). Previously the Context class constructor just exited the application and it was impossible to react on that from the application side (for example reducing some context feature requirements). Now there is Platform::Context::tryCreate(), which returns either created instance or `nullptr` if the instance creation failed with some error. That is now used in all Platform::*Application implementations.
11 years ago
return false;
It probably isn't good idea to have version checks as assertions. In particular when building with CORRADE_NO_ASSERT the version doesn't get checked at all, silently failing on null pointer somewhere else.
12 years ago
}
Sanity check for OpenGL version in Context. I though this check was present since forever, but isn't. Maybe it's hidden somewhere else.
13 years ago
Initial support for context flags.
13 years ago
/* Context flags are supported since GL 3.0 */
#ifndef MAGNUM_TARGET_GLES
/**
* @todo According to KHR_debug specs this should be also present in ES2
* if KHR_debug is available, but in headers it is nowhere to be found
*/
if(isVersionSupported(Version::GL300))
glGetIntegerv(GL_CONTEXT_FLAGS, reinterpret_cast<GLint*>(&_flags));
#endif
No `using namespace std` anywhere. Also added missing std:: prefix to remaining cases of std::size_t, std::[u]int[0-9]+_t, std::sin() etc., std::exit().
14 years ago
std::vector<Version> versions{
Updated OpenGL ES support in Context and related files.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Classes for handling version and extension information.
14 years ago
Version::GL300,
Version::GL310,
Version::GL320,
Version::GL330,
Version::GL400,
Version::GL410,
Version::GL420,
Version::GL430,
Initial support for OpenGL 4.4.
13 years ago
Version::GL440,
Mark also all GL 4.5 extensions as supported if GL 4.5 is supported. Oh god, it got to the point where I should write an HOWTO *for myself*.
12 years ago
Version::GL450,
Support for ARB_texture_filter_anisotropic.
8 years ago
Version::GL460,
Updated OpenGL ES support in Context and related files.
14 years ago
#else
Version::GLES200,
Version::GLES300,
First-class WebGL support, part 13: reduce version enum.
11 years ago
#ifndef MAGNUM_TARGET_WEBGL
Initial support for OpenGL ES 3.1.
12 years ago
Version::GLES310,
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
Version::GLES320,
Updated OpenGL ES support in Context and related files.
14 years ago
#endif
First-class WebGL support, part 13: reduce version enum.
11 years ago
#endif
Classes for handling version and extension information.
14 years ago
Version::None
};
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
/* Get first future (not supported) version */
No `using namespace std` anywhere. Also added missing std:: prefix to remaining cases of std::size_t, std::[u]int[0-9]+_t, std::sin() etc., std::exit().
14 years ago
std::size_t future = 0;
Context initialization was not skipping surely supported extensions. On OpenGL 3.3 context it was checking for support of all 3.0, 3.1 and 3.2 extensions even if isExtensionSupported() didn't use that information at all.
14 years ago
while(versions[future] != Version::None && isVersionSupported(versions[future]))
Classes for handling version and extension information.
14 years ago
++future;
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
/* Mark all extensions from past versions as supported */
for(std::size_t i = 0; i != future; ++i)
for(const Extension& extension: Extension::extensions(versions[i]))
GL: use public API of the Extension class. No need to friend and use underscored members.
8 years ago
_extensionStatus.set(extension.index());
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
Doc++ I had no idea what that code was doing. Better to be documented.
14 years ago
/* List of extensions from future versions (extensions from current and
previous versions should be supported automatically, so we don't need
to check for them) */
No `using namespace std` anywhere. Also added missing std:: prefix to remaining cases of std::size_t, std::[u]int[0-9]+_t, std::sin() etc., std::exit().
14 years ago
std::unordered_map<std::string, Extension> futureExtensions;
for(std::size_t i = future; i != versions.size(); ++i)
Classes for handling version and extension information.
14 years ago
for(const Extension& extension: Extension::extensions(versions[i]))
GL: use public API of the Extension class. No need to friend and use underscored members.
8 years ago
futureExtensions.emplace(extension.string(), extension);
Classes for handling version and extension information.
14 years ago
Added Context::extensionStrings(). Returns list of _all_ extensions reported by the driver, even those that are not supported in Magnum and also those that are marked as disabled due to driver bugs. Usable mostly when doing fresh port to new platform to discover possible new features. The actual implementation was part of Context constructor (and now this function is called instead). It is rather ugly because we need to take care of both GL 2.1 and GL 3.0 (and also ES2 and ES3).
12 years ago
/* Check for presence of future and vendor extensions */
const std::vector<std::string> extensions = extensionStrings();
for(const std::string& extension: extensions) {
const auto found = futureExtensions.find(extension);
if(found != futureExtensions.end()) {
_supportedExtensions.push_back(found->second);
GL: use public API of the Extension class. No need to friend and use underscored members.
8 years ago
_extensionStatus.set(found->second.index());
Context: use glGetString(GL_EXTENSIONS) on GL 2.1. glGetStringi() is since GL 3.0.
14 years ago
}
Added Context::shadingLanguageVersionStrings(), better extension query. Not relying on GL version when asking for extensions, i.e. Mesa might know glGetStringi() even if it reports OpenGL 2.1 only. Similarly in shadingLanguageVersionStrings(), not all HW is capable of 4.3, but GL_NUM_SHADING_LANGUAGE_VERSIONS might be supported on GL3 HW too (not my case, though).
13 years ago
}
Classes for handling version and extension information.
14 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
/* Reset minimal required version to Version::None for whole array */
for(auto& i: _extensionRequiredVersion) i = Version::None;
/* Initialize required versions from extension info */
for(const auto version: versions)
for(const Extension& extension: Extension::extensions(version))
GL: use public API of the Extension class. No need to friend and use underscored members.
8 years ago
_extensionRequiredVersion[extension.index()] = extension.requiredVersion();
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
/* Setup driver workarounds (increase required version for particular
extensions), see Implementation/driverWorkarounds.cpp */
setupDriverWorkarounds();
Classes for handling version and extension information.
14 years ago
/* Set this context as current */
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
CORRADE_ASSERT(!currentContext, "GL::Context: Another context currently active", false);
Introduce BUILD_MULTITHREADED CMake option. Enabled by default, makes the current Magnum context a thread-local variable instead of a global one, so it's possible to have multiple thread-local contexts. Might have some performance implications, that's why it's possible to disable it (but enabled by default is the safer option). GCC 4.7 and Apple platforms don't support thread_local, but __thread does the job too (though on iOS not until Xcode 7.3). Also had to move it to file-local because MSVC doesn't like having thread local variables as part of DLL interface. (And there is *of course* no way to disable exporting one particular member. F' that.)
10 years ago
currentContext = this;
First extension-aware functionality - Buffer::copy(). If EXT_direct_state_access is supported, it uses faster alternative to explicit binding.
14 years ago
Ability to control the amount of console output in engine initialization.
10 years ago
/* Decide whether to print the initialization output or not */
Properly print engine startup info to Android log.
8 years ago
std::ostream* output = _displayInitializationLog ? Debug::output() : nullptr;
Ability to control the amount of console output in engine initialization.
10 years ago
Print some more info when initializing Context. Then also don't display this information duplicated in magnum-info.
12 years ago
/* Print some info and initialize state tracker (which also prints some
more info) */
Ability to control the amount of console output in engine initialization.
10 years ago
Debug{output} << "Renderer:" << rendererString() << "by" << vendorString();
Debug{output} << "OpenGL version:" << versionString();
Ability to disable OpenGL extensions from command-line. Added `--magnum-disable-extensions` option next to the already existing `--magnum-disable-workarounds`. Specified extensions are not used automatically and also report as disabled and unsupported when asked using Context::isExtensionSupported() and Context::isExtensionDisabled().
11 years ago
/* Disable extensions as requested by the user */
if(!_disabledExtensions.empty()) {
Ability to control the amount of console output in engine initialization.
10 years ago
Debug{output} << "Disabling extensions:";
Ability to disable OpenGL extensions from command-line. Added `--magnum-disable-extensions` option next to the already existing `--magnum-disable-workarounds`. Specified extensions are not used automatically and also report as disabled and unsupported when asked using Context::isExtensionSupported() and Context::isExtensionDisabled().
11 years ago
/* Put remaining extensions into the hashmap for faster lookup */
std::unordered_map<std::string, Extension> allExtensions{std::move(futureExtensions)};
for(std::size_t i = 0; i != future; ++i)
for(const Extension& extension: Extension::extensions(versions[i]))
GL: use public API of the Extension class. No need to friend and use underscored members.
8 years ago
allExtensions.emplace(extension.string(), extension);
Ability to disable OpenGL extensions from command-line. Added `--magnum-disable-extensions` option next to the already existing `--magnum-disable-workarounds`. Specified extensions are not used automatically and also report as disabled and unsupported when asked using Context::isExtensionSupported() and Context::isExtensionDisabled().
11 years ago
/* Disable extensions that are known and supported and print a message
for each */
for(auto&& extension: _disabledExtensions) {
auto found = allExtensions.find(extension);
/** @todo Error message here? I should not clutter the output at this point */
if(found == allExtensions.end()) continue;
GL: use public API of the Extension class. No need to friend and use underscored members.
8 years ago
_extensionRequiredVersion[found->second.index()] = Version::None;
Ability to control the amount of console output in engine initialization.
10 years ago
Debug{output} << " " << extension;
Ability to disable OpenGL extensions from command-line. Added `--magnum-disable-extensions` option next to the already existing `--magnum-disable-workarounds`. Specified extensions are not used automatically and also report as disabled and unsupported when asked using Context::isExtensionSupported() and Context::isExtensionDisabled().
11 years ago
}
}
Ability to control the amount of console output in engine initialization.
10 years ago
_state = new Implementation::State{*this, output};
Private (implementation-only) OpenGL state tracker.
14 years ago
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
/* Print a list of used workarounds */
Don't display "Using driver workarounds" when there aren't any.
11 years ago
if(!_driverWorkarounds.empty()) {
Ability to control the amount of console output in engine initialization.
10 years ago
Debug{output} << "Using driver workarounds:";
Don't display "Using driver workarounds" when there aren't any.
11 years ago
for(const auto& workaround: _driverWorkarounds)
Fix compilation on not-exactly-recent updates of MSVC 2015.
10 years ago
if(!workaround.second) Debug(output) << " " << workaround.first;
Don't display "Using driver workarounds" when there aren't any.
11 years ago
}
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
First extension-aware functionality - Buffer::copy(). If EXT_direct_state_access is supported, it uses faster alternative to explicit binding.
14 years ago
/* Initialize functionality based on current OpenGL version and extensions */
Moved global data from Renderer class to per-context state.
12 years ago
/** @todo Get rid of these */
Reducing pointer chasings, part 3a: less pointer passing in root namespace. Passing pointer as function parameter will now mean that it is possible to pass `nullptr`. Some code examples now look like the parameter is copied instead of referenced, which is misleading. Updated the documentation to reflect that more clearly.
13 years ago
DefaultFramebuffer::initializeContextBasedFunctionality(*this);
Moved global data from Renderer class to per-context state.
12 years ago
Renderer::initializeContextBasedFunctionality();
Ability to do GL context creation fallbacks even from Context constructor. In some cases the GL context creation might success without error, but the created version is one that we don't want (e.g. software GDI rasterizer on Windows). Previously the Context class constructor just exited the application and it was impossible to react on that from the application side (for example reducing some context feature requirements). Now there is Platform::Context::tryCreate(), which returns either created instance or `nullptr` if the instance creation failed with some error. That is now used in all Platform::*Application implementations.
11 years ago
/* Everything okay */
return true;
Classes for handling version and extension information.
14 years ago
}
Properly handle cases when glGetString() returns nullptr.
10 years ago
std::string Context::vendorString() const {
return Utility::String::fromArray(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
}
std::string Context::rendererString() const {
return Utility::String::fromArray(reinterpret_cast<const char*>(glGetString(GL_RENDERER)));
}
std::string Context::versionString() const {
return Utility::String::fromArray(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
}
std::string Context::shadingLanguageVersionString() const {
return Utility::String::fromArray(reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION)));
}
Added Context::shadingLanguageVersionStrings(), better extension query. Not relying on GL version when asking for extensions, i.e. Mesa might know glGetStringi() even if it reports OpenGL 2.1 only. Similarly in shadingLanguageVersionStrings(), not all HW is capable of 4.3, but GL_NUM_SHADING_LANGUAGE_VERSIONS might be supported on GL3 HW too (not my case, though).
13 years ago
std::vector<std::string> Context::shadingLanguageVersionStrings() const {
#ifndef MAGNUM_TARGET_GLES
GLint versionCount = 0;
glGetIntegerv(GL_NUM_SHADING_LANGUAGE_VERSIONS, &versionCount);
/* The implementation doesn't yet support this query (< OpenGL 4.3) */
if(!versionCount)
return {shadingLanguageVersionString()};
/* Get all of them */
std::vector<std::string> versions;
versions.reserve(versionCount);
for(GLint i = 0; i != versionCount; ++i)
push_back -> emplace_back
9 years ago
versions.emplace_back(reinterpret_cast<const char*>(glGetStringi(GL_SHADING_LANGUAGE_VERSION, i)));
Don't use `return std::move()` where it is not needed.
11 years ago
return versions;
Added Context::shadingLanguageVersionStrings(), better extension query. Not relying on GL version when asking for extensions, i.e. Mesa might know glGetStringi() even if it reports OpenGL 2.1 only. Similarly in shadingLanguageVersionStrings(), not all HW is capable of 4.3, but GL_NUM_SHADING_LANGUAGE_VERSIONS might be supported on GL3 HW too (not my case, though).
13 years ago
#else
return {shadingLanguageVersionString()};
#endif
}
Added Context::extensionStrings(). Returns list of _all_ extensions reported by the driver, even those that are not supported in Magnum and also those that are marked as disabled due to driver bugs. Usable mostly when doing fresh port to new platform to discover possible new features. The actual implementation was part of Context constructor (and now this function is called instead). It is rather ugly because we need to take care of both GL 2.1 and GL 3.0 (and also ES2 and ES3).
12 years ago
std::vector<std::string> Context::extensionStrings() const {
std::vector<std::string> extensions;
Use glGetStringi() on Emscripten/WebGL 2. Available in recent versions.
11 years ago
#ifndef MAGNUM_TARGET_GLES2
Added Context::extensionStrings(). Returns list of _all_ extensions reported by the driver, even those that are not supported in Magnum and also those that are marked as disabled due to driver bugs. Usable mostly when doing fresh port to new platform to discover possible new features. The actual implementation was part of Context constructor (and now this function is called instead). It is rather ugly because we need to take care of both GL 2.1 and GL 3.0 (and also ES2 and ES3).
12 years ago
GLint extensionCount = 0;
glGetIntegerv(GL_NUM_EXTENSIONS, &extensionCount);
#ifndef MAGNUM_TARGET_GLES3
if(extensionCount || isVersionSupported(Version::GL300))
#endif
{
extensions.reserve(extensionCount);
for(GLint i = 0; i != extensionCount; ++i)
push_back -> emplace_back
9 years ago
extensions.emplace_back(reinterpret_cast<const char*>(glGetStringi(GL_EXTENSIONS, i)));
Added Context::extensionStrings(). Returns list of _all_ extensions reported by the driver, even those that are not supported in Magnum and also those that are marked as disabled due to driver bugs. Usable mostly when doing fresh port to new platform to discover possible new features. The actual implementation was part of Context constructor (and now this function is called instead). It is rather ugly because we need to take care of both GL 2.1 and GL 3.0 (and also ES2 and ES3).
12 years ago
}
#ifndef MAGNUM_TARGET_GLES3
else
#endif
#endif
#ifndef MAGNUM_TARGET_GLES3
/* OpenGL 2.1 / OpenGL ES 2.0 doesn't have glGetStringi() */
{
/* Don't crash when glGetString() returns nullptr (i.e. don't trust the
old implementations) */
const char* e = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));
if(e) extensions = Utility::String::splitWithoutEmptyParts(e, ' ');
}
#endif
return extensions;
}
Added Context::isCoreProfile(). It's funny when implementing a new feature immediately involves doing a NV-specific workaround. Sigh.
9 years ago
#ifndef MAGNUM_TARGET_GLES
bool Context::isCoreProfile() {
Bind some default VAO in case we are on core profile with ARB_VAO disabled. Otherwise it's not possible to render anything. The original behavior was accepted by NVidia, but it's not accepted by Mesa, e.g.
9 years ago
return isCoreProfileInternal(*_state->context);
}
bool Context::isCoreProfileInternal(Implementation::ContextState& state) {
Added Context::isCoreProfile(). It's funny when implementing a new feature immediately involves doing a NV-specific workaround. Sigh.
9 years ago
Implementation::ContextState::CoreProfile& value = state.coreProfile;
if(value == Implementation::ContextState::CoreProfile::Initial)
value = (this->*state.isCoreProfileImplementation)() ?
Implementation::ContextState::CoreProfile::Core :
Implementation::ContextState::CoreProfile::Compatibility;
return value == Implementation::ContextState::CoreProfile::Core;
}
bool Context::isCoreProfileImplementationDefault() {
GLint value = 0;
glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &value);
return value & GL_CONTEXT_CORE_PROFILE_BIT;
}
bool Context::isCoreProfileImplementationNV() {
auto extensions = extensionStrings();
return std::find(extensions.begin(), extensions.end(), "GL_ARB_compatibility") == extensions.end();
}
#endif
Make the ES versions first-class on desktop OpenGL. What this changes: * Before, a Version::GLES310 shader was created with `#version 450` directive, which is wrong, because an implementation might support GLES 3.1 but not GL 4.5 so this was not working and also the syntax is a bit different so this wasn't helpful at all. * Similarly, Context::isVersionSupported(Version::GLES310) was checking for support of OpenGL 4.5. Now it just checks for `ARB_ES3_1_compatibility` extension. * Added a small isVersionES() utility that just tells whether given version is ES or not.
10 years ago
bool Context::isVersionSupported(Version version) const {
#ifndef MAGNUM_TARGET_GLES
if(version == Version::GLES200)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
return isExtensionSupported<Extensions::ARB::ES2_compatibility>();
Make the ES versions first-class on desktop OpenGL. What this changes: * Before, a Version::GLES310 shader was created with `#version 450` directive, which is wrong, because an implementation might support GLES 3.1 but not GL 4.5 so this was not working and also the syntax is a bit different so this wasn't helpful at all. * Similarly, Context::isVersionSupported(Version::GLES310) was checking for support of OpenGL 4.5. Now it just checks for `ARB_ES3_1_compatibility` extension. * Added a small isVersionES() utility that just tells whether given version is ES or not.
10 years ago
if(version == Version::GLES300)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
return isExtensionSupported<Extensions::ARB::ES3_compatibility>();
Make the ES versions first-class on desktop OpenGL. What this changes: * Before, a Version::GLES310 shader was created with `#version 450` directive, which is wrong, because an implementation might support GLES 3.1 but not GL 4.5 so this was not working and also the syntax is a bit different so this wasn't helpful at all. * Similarly, Context::isVersionSupported(Version::GLES310) was checking for support of OpenGL 4.5. Now it just checks for `ARB_ES3_1_compatibility` extension. * Added a small isVersionES() utility that just tells whether given version is ES or not.
10 years ago
if(version == Version::GLES310)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
return isExtensionSupported<Extensions::ARB::ES3_1_compatibility>();
Initial support for OpenGL ES 3.2. A bunch of extensions formerly in AEP are now part of ES 3.2, which means they were reordered in the extension lists. While at it, also added corresponding new GL and WebGL extensions and fixed a few wrongly categorized extensions in WebGL.
9 years ago
if(version == Version::GLES320)
Split the OpenGL layer out, pt 16: {Extensions::GL => GL::Extensions}. Was Magnum::GL::Extensions::GL before and the redundancy was completely unnecessary. Potential future extensions coming from GLX, EGL or whatnot will most probably be in the Platform namespace in a completely separate file, so this is not a problem. All code internal to the GL library is affected, not much the outside, as that is handled by the compatibility alias.
8 years ago
return isExtensionSupported<Extensions::ARB::ES3_2_compatibility>();
Make the ES versions first-class on desktop OpenGL. What this changes: * Before, a Version::GLES310 shader was created with `#version 450` directive, which is wrong, because an implementation might support GLES 3.1 but not GL 4.5 so this was not working and also the syntax is a bit different so this wasn't helpful at all. * Similarly, Context::isVersionSupported(Version::GLES310) was checking for support of OpenGL 4.5. Now it just checks for `ARB_ES3_1_compatibility` extension. * Added a small isVersionES() utility that just tells whether given version is ES or not.
10 years ago
#endif
return _version >= version;
}
No `using namespace std` anywhere. Also added missing std:: prefix to remaining cases of std::size_t, std::[u]int[0-9]+_t, std::sin() etc., std::exit().
14 years ago
Version Context::supportedVersion(std::initializer_list<Version> versions) const {
Added convenience function Context::supportedVersion().
14 years ago
for(auto version: versions)
if(isVersionSupported(version)) return version;
#ifndef MAGNUM_TARGET_GLES
return Version::GL210;
#else
return Version::GLES200;
#endif
}
Ability to reset internal state tracker.
12 years ago
void Context::resetState(const States states) {
if(states & State::Buffers)
_state->buffer->reset();
if(states & State::Framebuffers)
_state->framebuffer->reset();
if(states & State::Meshes)
_state->mesh->reset();
Improve state tracker resetting functionality.
8 years ago
if(states & State::MeshVao)
_state->mesh->bindVAOImplementation(0);
Ability to reset internal state tracker.
12 years ago
Pixel storage support, part 7: state tracking for glPixelStore().
11 years ago
if(states & State::PixelStorage) {
_state->renderer->unpackPixelStorage.reset();
_state->renderer->packPixelStorage.reset();
}
Ability to reset internal state tracker.
12 years ago
/* Nothing to reset for renderer yet */
if(states & State::Shaders) {
/* Nothing to reset for shaders */
_state->shaderProgram->reset();
}
if(states & State::Textures)
_state->texture->reset();
Initial transform feedback implementation. Full support for EXT_transform_feedback, transform feedback objects from ARB_transform_feedback2 and equivalent OpenGL ES 3.0 functionality. Example usage is in src/Magnum/Test/TransformFeedbackGLTest.cpp, I'll add some example later.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
if(states & State::TransformFeedback)
_state->transformFeedback->reset();
#endif
Ability to reset internal state tracker.
12 years ago
}
Doc++
12 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
Debug output for Context::DetectedDriver[s].
9 years ago
#ifndef MAGNUM_TARGET_WEBGL
Use new-style debug operators everywhere.
11 years ago
Debug& operator<<(Debug& debug, const Context::Flag value) {
Debug output operator for Context::Flag enum.
12 years ago
switch(value) {
Exclude debug operators from code coverage.
10 years ago
/* LCOV_EXCL_START */
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
#define _c(value) case Context::Flag::value: return debug << "GL::Context::Flag::" #value;
Debug output operator for Context::Flag enum.
12 years ago
_c(Debug)
Implemented KHR_no_error.
10 years ago
_c(NoError)
Updates for robust buffer access in ES 3.2.
9 years ago
#ifndef MAGNUM_TARGET_GLES2
Debug output operator for Context::Flag enum.
12 years ago
_c(RobustAccess)
Fix ES build.
12 years ago
#endif
Missing undef.
12 years ago
#undef _c
Exclude debug operators from code coverage.
10 years ago
/* LCOV_EXCL_STOP */
Debug output operator for Context::Flag enum.
12 years ago
}
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
return debug << "GL::Context::Flag(" << Debug::nospace << reinterpret_cast<void*>(GLint(value)) << Debug::nospace << ")";
Debug output operator for Context::Flag enum.
12 years ago
}
Debug operator for Context::Flags.
9 years ago
Debug& operator<<(Debug& debug, const Context::Flags value) {
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
return Containers::enumSetDebugOutput(debug, value, "GL::Context::Flags{}", {
Debug operator for Context::Flags.
9 years ago
Context::Flag::Debug,
Context::Flag::NoError,
Updates for robust buffer access in ES 3.2.
9 years ago
#ifndef MAGNUM_TARGET_GLES2
Debug operator for Context::Flags.
9 years ago
Context::Flag::RobustAccess
#endif
});
}
Doc++
12 years ago
#endif
Debug output for Context::DetectedDriver[s].
9 years ago
Debug& operator<<(Debug& debug, const Context::DetectedDriver value) {
switch(value) {
/* LCOV_EXCL_START */
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
#define _c(value) case Context::DetectedDriver::value: return debug << "GL::Context::DetectedDriver::" #value;
Debug output for Context::DetectedDriver[s].
9 years ago
#ifndef MAGNUM_TARGET_WEBGL
More consistent naming in Context::DetectedDriver. DetectedDriver::AMD is now DetectedDriver::Amd, DetectedDriver::ProbablyAngle is now just DetectedDriver::Angle. The old names are still present, but deprecated and will be removed in the future.
9 years ago
_c(Amd)
#endif
#ifdef MAGNUM_TARGET_GLES
_c(Angle)
#endif
#ifndef MAGNUM_TARGET_WEBGL
Debug output for Context::DetectedDriver[s].
9 years ago
_c(IntelWindows)
_c(Mesa)
_c(NVidia)
#endif
Detecting VMware SVGA3D driver. The SVGA3D driver is used on Windows as well, which means Mesa is now detected on Windows too.
9 years ago
#ifndef MAGNUM_TARGET_WEBGL
_c(Svga3D)
#endif
Debug output for Context::DetectedDriver[s].
9 years ago
#undef _c
/* LCOV_EXCL_STOP */
}
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
return debug << "GL::Context::DetectedDriver(" << Debug::nospace << reinterpret_cast<void*>(GLint(value)) << Debug::nospace << ")";
Debug output for Context::DetectedDriver[s].
9 years ago
}
Debug& operator<<(Debug& debug, const Context::DetectedDrivers value) {
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
return Containers::enumSetDebugOutput(debug, value, "GL::Context::DetectedDrivers{}", {
Debug output for Context::DetectedDriver[s].
9 years ago
#ifndef MAGNUM_TARGET_WEBGL
More consistent naming in Context::DetectedDriver. DetectedDriver::AMD is now DetectedDriver::Amd, DetectedDriver::ProbablyAngle is now just DetectedDriver::Angle. The old names are still present, but deprecated and will be removed in the future.
9 years ago
Context::DetectedDriver::Amd,
#endif
#ifdef MAGNUM_TARGET_GLES
Context::DetectedDriver::Angle,
#endif
#ifndef MAGNUM_TARGET_WEBGL
Debug output for Context::DetectedDriver[s].
9 years ago
Context::DetectedDriver::IntelWindows,
Context::DetectedDriver::Mesa,
Context::DetectedDriver::NVidia,
#endif
Detecting VMware SVGA3D driver. The SVGA3D driver is used on Windows as well, which means Mesa is now detected on Windows too.
9 years ago
#ifndef MAGNUM_TARGET_WEBGL
Context::DetectedDriver::Svga3D
#endif
Debug output for Context::DetectedDriver[s].
9 years ago
});
}
First-class WebGL support, part 11: no context flags.
11 years ago
#endif
Debug output operator for Context::Flag enum.
12 years ago
Split the OpenGL layer out, pt 4: new Magnum::GL namespace. At the moment just the GL library itself w/o the tests, and without backwards compatibility aliases. The following types were left in the root namespace, despite being in the GL/ directory, as they will get moved back soon: * Image, CompressedImage and their dimensional typedefs * ImageView, CompressedImageView and their dimensional typedefs * PixelStorage Not PixelFormat etc., that one will stay in the GL namespace and a completely new PixelFormat enum will be provided in the root namespace.
8 years ago
}}