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

176 lines
7.3 KiB
Raw Normal View History Unescape

Private (implementation-only) OpenGL state tracker.
14 years ago
/*
This file is part of Magnum.
Updated copyright year.
6 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019,
Updated copyright year.
5 years ago
2020, 2021 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.
Private (implementation-only) OpenGL state tracker.
14 years ago
*/
#include "State.h"
GL: put texture/image state trackers into the single allocation also.
5 years ago
#include <tuple>
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
#include <Corrade/Containers/ArrayTuple.h>
GL: put texture/image state trackers into the single allocation also.
5 years ago
#include <Corrade/Utility/Assert.h>
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 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/Context.h"
#include "Magnum/GL/Extensions.h"
#include "Magnum/GL/Implementation/BufferState.h"
#include "Magnum/GL/Implementation/ContextState.h"
First-class WebGL support, part 2: no debug output.
11 years ago
#ifndef MAGNUM_TARGET_WEBGL
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/DebugState.h"
First-class WebGL support, part 2: no debug output.
11 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/Implementation/FramebufferState.h"
#include "Magnum/GL/Implementation/MeshState.h"
#include "Magnum/GL/Implementation/QueryState.h"
#include "Magnum/GL/Implementation/RendererState.h"
#include "Magnum/GL/Implementation/ShaderState.h"
#include "Magnum/GL/Implementation/ShaderProgramState.h"
#include "Magnum/GL/Implementation/TextureState.h"
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
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"
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
#endif
Tracking Buffer state. Reduces OpenGL call count if subsequently binding the same Buffer into the same Target.
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 { namespace Implementation {
Private (implementation-only) OpenGL state tracker.
14 years ago
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
std::pair<Containers::ArrayTuple, State&> State::allocate(Context& context, std::ostream* const out) {
GL: put texture/image state trackers into the single allocation also.
5 years ago
/* TextureState needs to track state per texture / image binding, fetch
how many of them is there and allocate here as well so we don't need to
do another nested allocation */
GLint maxTextureUnits{};
glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
CORRADE_INTERNAL_ASSERT(maxTextureUnits > 0);
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
GLint maxImageUnits{};
#ifndef MAGNUM_TARGET_GLES
if(context.isExtensionSupported<Extensions::ARB::shader_image_load_store>())
#else
if(context.isVersionSupported(Version::GLES310))
#endif
{
glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImageUnits);
CORRADE_INTERNAL_ASSERT(maxImageUnits > 0);
}
#endif
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
/* I have to say, the ArrayTuple is quite a crazy thing */
Containers::ArrayView<State> stateView;
Containers::ArrayView<BufferState> bufferStateView;
Containers::ArrayView<ContextState> contextStateView;
#ifndef MAGNUM_TARGET_WEBGL
Containers::ArrayView<DebugState> debugStateView;
#endif
Containers::ArrayView<FramebufferState> framebufferStateView;
Containers::ArrayView<MeshState> meshStateView;
Containers::ArrayView<QueryState> queryStateView;
Containers::ArrayView<RendererState> rendererStateView;
Containers::ArrayView<ShaderState> shaderStateView;
Containers::ArrayView<ShaderProgramState> shaderProgramStateView;
Containers::ArrayView<TextureState> textureStateView;
GL: put texture/image state trackers into the single allocation also.
5 years ago
Containers::ArrayView<std::pair<GLenum, GLuint>> textureBindings;
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
Containers::ArrayView<std::tuple<GLuint, GLint, GLboolean, GLint, GLenum>> imageBindings;
#endif
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
Containers::ArrayView<TransformFeedbackState> transformFeedbackStateView;
#endif
Containers::ArrayTuple data{
{Containers::NoInit, 1, stateView},
{Containers::NoInit, 1, bufferStateView},
{Containers::NoInit, 1, contextStateView},
#ifndef MAGNUM_TARGET_WEBGL
{Containers::NoInit, 1, debugStateView},
#endif
{Containers::NoInit, 1, framebufferStateView},
{Containers::NoInit, 1, meshStateView},
{Containers::NoInit, 1, queryStateView},
{Containers::NoInit, 1, rendererStateView},
{Containers::NoInit, 1, shaderStateView},
{Containers::NoInit, 1, shaderProgramStateView},
{Containers::NoInit, 1, textureStateView},
GL: put texture/image state trackers into the single allocation also.
5 years ago
{Containers::ValueInit, std::size_t(maxTextureUnits), textureBindings},
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
{Containers::ValueInit, std::size_t(maxImageUnits), imageBindings},
#endif
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
#ifndef MAGNUM_TARGET_GLES2
{Containers::NoInit, 1, transformFeedbackStateView}
#endif
};
GL: put texture/image state trackers into the single allocation also.
5 years ago
#ifdef MAGNUM_TARGET_GLES
/* This whole thing would be trivially destructible except for MeshState
which has to delete scratch VAOs on desktop in a custom destructor. */
CORRADE_INTERNAL_ASSERT(!data.deleter());
#endif
GL: avoid populating and sorting (!!) a vector of strings for exts. Ew. At first I tried to just port a growable Array of StringViews (which would already save quite a lot), but then I realized I have a clear upper bound on the extensions and so can use a "counting sort" without having to deduplicate anything after. After the previous (rather minimal) reduction by the Context cleanup, this reduces the size of magnum-gl-info.wasm from 245 to 237 kB. Quite significant, I'd say!
5 years ago
/* Extensions that might get used by current context. The State classes
will set strings based on Extension::index() and then we'll go through
the list and print ones that aren't null. It's 1.5 kB of temporary data
but I think in terms of code size and overhead it's better than
populating a heap array and then std::sort() it to remove duplicates. */
const char* extensions[Implementation::ExtensionCount]{};
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
State& state = *(new(&stateView.front()) State{
bufferStateView.front(),
contextStateView.front(),
#ifndef MAGNUM_TARGET_WEBGL
debugStateView.front(),
#endif
framebufferStateView.front(),
meshStateView.front(),
queryStateView.front(),
rendererStateView.front(),
shaderStateView.front(),
shaderProgramStateView.front(),
textureStateView.front(),
#ifndef MAGNUM_TARGET_GLES2
transformFeedbackStateView.front()
#endif
});
new(&state.buffer) BufferState{context, extensions};
new(&state.context) ContextState{context, extensions};
First-class WebGL support, part 2: no debug output.
11 years ago
#ifndef MAGNUM_TARGET_WEBGL
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
new(&state.debug) DebugState{context, extensions};
First-class WebGL support, part 2: no debug output.
11 years ago
#endif
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
new(&state.framebuffer) FramebufferState{context, extensions};
new(&state.mesh) MeshState{context, stateView.front().context, extensions};
new(&state.query) QueryState{context, extensions};
new(&state.renderer) RendererState{context, stateView.front().context, extensions};
new(&state.shader) ShaderState(context, extensions);
new(&state.shaderProgram) ShaderProgramState{context, extensions};
GL: put texture/image state trackers into the single allocation also.
5 years ago
new(&state.texture) TextureState{context, textureBindings,
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
imageBindings,
#endif
extensions};
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
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
new(&state.transformFeedback) TransformFeedbackState{context, extensions};
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
#endif
Support for object labels from KHR_debug and EXT_debug_label. Can't test EXT_debug_label, as that is apparently OSX 10.9-only. Added GL tests for all implemented objects. KHR_debug is selected first, if that is not available, fall back to EXT_debug_label. If neither is available, the functions are no-op. I hope EXT_debug_label gets replaced by KHR_debug later, thus it is now only "emulated" through KHR_debug enums.
13 years ago
Ability to control the amount of console output in engine initialization.
10 years ago
Debug{out} << "Using optional features:";
GL: avoid populating and sorting (!!) a vector of strings for exts. Ew. At first I tried to just port a growable Array of StringViews (which would already save quite a lot), but then I realized I have a clear upper bound on the extensions and so can use a "counting sort" without having to deduplicate anything after. After the previous (rather minimal) reduction by the Context cleanup, this reduces the size of magnum-gl-info.wasm from 245 to 237 kB. Quite significant, I'd say!
5 years ago
for(const char* extension: extensions)
if(extension) Debug(out) << " " << extension;
Private (implementation-only) OpenGL state tracker.
14 years ago
GL: put all internal Context State substructures in a single allocation. This means that instead of 12 separate allocations we have just one, allocating everything together in a contiguous piece of memory. That should be also a bit more cache friendly when accessing the state as it's not scattered around the memory like crazy. Because there are no Pointer indirections needed anymore, the State members are just references now. That resulted in a lot of sweeping changes around the whole GL library, but they're all trivial, changing `->` to `.`, mostly. There's two more nested allocations in the TextureState struct, will take care of them in a separate commit.
5 years ago
return {std::move(data), state};
}
Private (implementation-only) OpenGL state tracker.
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
}}}