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.
11214 Commits
21 Branches
19 Tags
70 MiB
Tree: 9b4d394a14
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '9b4d394a14'
${ noResults }
magnum/src/Magnum/GL/Implementation/TextureState.h

195 lines
9.7 KiB
Raw Normal View History Unescape

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
#ifndef Magnum_GL_Implementation_TextureState_h
#define Magnum_GL_Implementation_TextureState_h
Tracking texture state - bindings and limits.
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,
It's October already?!
2 years ago
2020, 2021, 2022, 2023, 2024
Vladimír Vondruš <mosra@centrum.cz>
Relicensing to MIT/Expat license, part 2: headers.
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.
Tracking texture state - bindings and limits.
14 years ago
*/
GL: drop std::pair from texture state tracker internals. Apparently even `= {}` was broken for std::pair once, not to mention the unnecessary extra overhead with this type not being trivially copyable. Good riddance.
3 years ago
#include <Corrade/Containers/Pair.h>
GL: put texture/image state trackers into the single allocation also.
5 years ago
#include <Corrade/Containers/ArrayView.h>
Removed unneeded includes.
13 years ago
Extracted CubeMapTexture::Coordinate enum into CubeMapCoordinate. Allows to break the dependency on the <Magnum/CubeMapTexture.h> header in Framebuffer, TextureState and elsewhere. The old CubeMapTexture::Coordinate enum is now just an alias, is marked as deprecated and will be removed in a future release.
10 years ago
#include "Magnum/Magnum.h"
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/GL.h"
#include "Magnum/GL/OpenGL.h"
Tracking texture state - bindings and limits.
14 years ago
GL: finalize the apple-buffer-texture-unbind-on-buffer-modify workaround. Followup to 24cc971b1f43c61aa157228f6ea9916007ffb3cd, covering the remaining case.
6 years ago
#if defined(CORRADE_TARGET_APPLE) && !defined(MAGNUM_TARGET_GLES)
Math: rename BoolVector to BitVector. Because it somewhat confusingly may have implied that it's really composed of 8-bit bools, and not bits. The same reasoning was used to pick the name for Corrade's Containers::BitArray. Backwards compatibility aliases are in place as usual, however the internal BoolVectorConverter is now BitVectorConverter and there unfortunately cannot be any backwards compatibility. This breaks only GLM and Eigen integration in the magnum-integration repo, which I'm fixing immediately. I don't expect any user code to use this internal helper. For regular vectors maybe, for this one definitely not.
4 years ago
#include "Magnum/Math/BitVector.h"
GL: finalize the apple-buffer-texture-unbind-on-buffer-modify workaround. Followup to 24cc971b1f43c61aa157228f6ea9916007ffb3cd, covering the remaining case.
6 years ago
#endif
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 {
Tracking texture state - bindings and limits.
14 years ago
struct TextureState {
GL: drop a silly <tuple> from state tracker internals. Using a tuple was very useful, helpful and exciting as I had to make an explicit comment about what element is what, and then having to remember the order in all places that accessed the tuple. Using a struct however is rather boring as the fields are just named there, I don't need any complex std::get<4>() and extra comments explaining what is where and it's just not so adventurous anymore. The build time of a non-deprecated MagnumGL library also dropped from 5.9 seconds to 5.85. SAD!
4 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
struct ImageBinding {
GLuint id;
GLint level;
GLboolean layered;
GLint layer;
GLenum access;
/* Used inside AbstractTexture to check if the state changed */
bool operator==(const ImageBinding& other) {
return other.id == id &&
other.level == level &&
other.layered == layered &&
other.layer == layer &&
other.access == access;
}
bool operator!=(const ImageBinding& other) {
return !operator==(other);
}
};
#endif
GL: put texture/image state trackers into the single allocation also.
5 years ago
explicit TextureState(Context& context,
GL: drop std::pair from texture state tracker internals. Apparently even `= {}` was broken for std::pair once, not to mention the unnecessary extra overhead with this type not being trivially copyable. Good riddance.
3 years ago
Containers::ArrayView<Containers::Pair<GLenum, GLuint>> bindings,
GL: put texture/image state trackers into the single allocation also.
5 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
GL: drop a silly <tuple> from state tracker internals. Using a tuple was very useful, helpful and exciting as I had to make an explicit comment about what element is what, and then having to remember the order in all places that accessed the tuple. Using a struct however is rather boring as the fields are just named there, I don't need any complex std::get<4>() and extra comments explaining what is where and it's just not so adventurous anymore. The build time of a non-deprecated MagnumGL library also dropped from 5.9 seconds to 5.85. SAD!
4 years ago
Containers::ArrayView<ImageBinding> imageBindings,
GL: put texture/image state trackers into the single allocation also.
5 years ago
#endif
Containers::StaticArrayView<Implementation::ExtensionCount, const char*> extensions);
Tracking texture state - bindings and limits.
14 years ago
Ability to reset internal state tracker.
12 years ago
void reset();
Added workaround for NVidia reporting compressed block size in bits. Instead of bytes as per specification of glGetInternalformativ().
10 years ago
Int(*compressedBlockDataSizeImplementation)(GLenum, TextureFormat);
Added *Texture::unbind(). Will be used in fallback implementation of multi-bind.
12 years ago
void(*unbindImplementation)(GLint);
Adapted to Corrade changes.
11 years ago
void(*bindMultiImplementation)(GLint, Containers::ArrayView<AbstractTexture* const>);
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*createImplementation)(AbstractTexture&);
void(*bindImplementation)(AbstractTexture&, GLint);
void(*bindInternalImplementation)(AbstractTexture&, GLint);
void(*parameteriImplementation)(AbstractTexture&, GLenum, GLint);
void(*parameterfImplementation)(AbstractTexture&, GLenum, GLfloat);
Implemented ARB_texture_swizzle.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*parameterivImplementation)(AbstractTexture&, GLenum, const GLint*);
Implemented ARB_texture_swizzle.
12 years ago
#endif
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*parameterfvImplementation)(AbstractTexture&, GLenum, const GLfloat*);
Implemented EXT_texture_border_clamp AEP extension. Replaced NV_texture_border_clamp enum values with EXT ones, as this is a superset of the NV extension.
11 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*parameterIuivImplementation)(AbstractTexture&, GLenum, const GLuint*);
void(*parameterIivImplementation)(AbstractTexture&, GLenum, const GLint*);
Remove unused members from ES build.
12 years ago
#endif
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*setMaxAnisotropyImplementation)(AbstractTexture&, GLfloat);
First-class WebGL support, part 4: reduced texture functionality.
11 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*getLevelParameterivImplementation)(AbstractTexture&, GLint, GLenum, GLint*);
Remove unused members from ES build.
12 years ago
#endif
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*mipmapImplementation)(AbstractTexture&);
Moved global data from texture classes to per-context state.
12 years ago
#ifndef MAGNUM_TARGET_GLES
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*storage1DImplementation)(AbstractTexture&, GLsizei, TextureFormat, const Math::Vector<1, GLsizei>&);
Moved global data from texture classes to per-context state.
12 years ago
#endif
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*storage2DImplementation)(AbstractTexture&, GLsizei, TextureFormat, const Vector2i&);
First-class WebGL support, part 4: reduced texture functionality.
11 years ago
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*storage3DImplementation)(AbstractTexture&, GLsizei, TextureFormat, const Vector3i&);
First-class WebGL support, part 4: reduced texture functionality.
11 years ago
#endif
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*storage2DMultisampleImplementation)(AbstractTexture&, GLsizei, TextureFormat, const Vector2i&, GLboolean);
void(*storage3DMultisampleImplementation)(AbstractTexture&, GLsizei, TextureFormat, const Vector3i&, GLboolean);
Enabled 2D multisample textures in ES 3.1.
12 years ago
#endif
#ifndef MAGNUM_TARGET_GLES
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*getImageImplementation)(AbstractTexture&, GLint, PixelFormat, PixelType, std::size_t, GLvoid*);
void(*getCompressedImageImplementation)(AbstractTexture&, GLint, std::size_t, GLvoid*);
Moved global data from texture classes to per-context state.
12 years ago
#endif
#ifndef MAGNUM_TARGET_GLES
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*subImage1DImplementation)(AbstractTexture&, GLint, const Math::Vector<1, GLint>&, const Math::Vector<1, GLsizei>&, PixelFormat, PixelType, const GLvoid*);
void(*compressedSubImage1DImplementation)(AbstractTexture&, GLint, const Math::Vector<1, GLint>&, const Math::Vector<1, GLsizei>&, CompressedPixelFormat, const GLvoid*, GLsizei);
Moved global data from texture classes to per-context state.
12 years ago
#endif
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*image2DImplementation)(AbstractTexture&, GLenum, GLint, TextureFormat, const Vector2i&, PixelFormat, PixelType, const GLvoid*, const PixelStorage&);
void(*subImage2DImplementation)(AbstractTexture&, GLint, const Vector2i&, const Vector2i&, PixelFormat, PixelType, const GLvoid*, const PixelStorage&);
void(*compressedSubImage2DImplementation)(AbstractTexture&, GLint, const Vector2i&, const Vector2i&, CompressedPixelFormat, const GLvoid*, GLsizei);
First-class WebGL support, part 4: reduced texture functionality.
11 years ago
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*image3DImplementation)(AbstractTexture&, GLint, TextureFormat, const Vector3i&, PixelFormat, PixelType, const GLvoid*, const PixelStorage&);
void(*subImage3DImplementation)(AbstractTexture&, GLint, const Vector3i&, const Vector3i&, PixelFormat, PixelType, const GLvoid*, const PixelStorage&);
void(*compressedSubImage3DImplementation)(AbstractTexture&, GLint, const Vector3i&, const Vector3i&, CompressedPixelFormat, const GLvoid*, GLsizei);
First-class WebGL support, part 4: reduced texture functionality.
11 years ago
#endif
GL: implement {ARB,OES,EXT}_texture_view. "Funny" how this is the only API where I can't use glCreateTextures(). Like, it would have been so easy to just stop teaching glGen*() and all their quirks and "this ID exists but it's not an object until you bind it somewhere actually" to people altogether, BUT NO! FFS.
3 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
void(APIENTRY *viewImplementation)(GLuint, GLenum, GLuint, GLenum, GLuint, GLuint, GLuint, GLuint);
#endif
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*invalidateImageImplementation)(AbstractTexture&, GLint);
void(*invalidateSubImageImplementation)(AbstractTexture&, GLint, const Vector3i&, const Vector3i&);
Moved global data from texture classes to per-context state.
12 years ago
Implemented EXT_texture_buffer AEP extension.
11 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*setBufferImplementation)(BufferTexture&, BufferTextureFormat, Buffer*);
void(*setBufferRangeImplementation)(BufferTexture&, BufferTextureFormat, Buffer&, GLintptr, GLsizeiptr);
Moved global data from texture classes to per-context state.
12 years ago
#endif
Don't spread cubemap texture level parameter query workarounds elsewhere. Pre-DSA code paths need to specify for which face we are querying the level parameters, which meant that all other calls had to specify the (implicit) target too. I'm also preparing to put a cubemap-specific workaround in the level parameter query and that really shouldn't be present in the generic implementation for all texture types. The other place where a specific target is needed is in setImage() implementations, but these are rather big chunks of code and I don't feel like copying these verbatim to cubemap implementation just to isolate the workaround in one place.
10 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
void(*getCubeLevelParameterivImplementation)(CubeMapTexture&, GLint, GLenum, GLint*);
Don't spread cubemap texture level parameter query workarounds elsewhere. Pre-DSA code paths need to specify for which face we are querying the level parameters, which meant that all other calls had to specify the (implicit) target too. I'm also preparing to put a cubemap-specific workaround in the level parameter query and that really shouldn't be present in the generic implementation for all texture types. The other place where a specific target is needed is in setImage() implementations, but these are rather big chunks of code and I don't feel like copying these verbatim to cubemap implementation just to isolate the workaround in one place.
10 years ago
#endif
Full ARB_direct_state_access support in textures. ARB_DSA is now preferred in single-bind cases, as it is easier to use than passing pointers to ARB_multi_bind. ARB_multi_bind was preferred for single-bind previously simply because EXT_DSA was not in core. Because there is a lot to say about feature selection for each function, I took this as a opportunity to remove redundant documentation blocks, just refer to Texture documentation from everywhere and add extension requirements and deprecation where needed, so it's clear for each class what needs what. ARB_DSA also took the opportunity to finally remove all target enum values from function calls and because of that the CubeMapTexture has to handle a bunch of special cases. In order: - CubeMapTexture::imageSize() now doesn't take face parameter and returns one value for all faces. I'm thus now also assuming that the user is sane and called either setStorage() or setImage() with the same size for all faces. In non-ARB_DSA path I'm thus querying only size of +X face and returning it as size for all faces. The old imageSize(Coordinate, Int) overload is still present, but ignores the first parameter and calls imageSize(Int). It is marked as deprecated and will be removed in some future release. - CubeMapTexture::image() now needs to call glTextureSubImage() in ARB_DSA path to make it possible to extract single face. Other code paths (EXT_DSA, Robustness and "default") remain the same. - CubeMapTexture::setSubImage() calls glTextureSubImage3D() in ARB_DSA, because it is not possible to specify face index in glTextureSubImage2D(). Other code paths (EXT_DSA and "default") remain the same. Implementation of these special cases is extracted into CubeMapTexture class to avoid pollution of AbstractTexture with incompatible nonsense.
12 years ago
#ifndef MAGNUM_TARGET_GLES
GL: clean up remaining member function pointers in the state tracker. And use static functions with an explicit "self" pointer instead. Those have half the size (8 vs 16 bytes on 64bit x86), which in turn reduces the state tracker memory use by about 750 bytes. On desktop GL with an Intel GPU & Mesa this reduces the state tracker allocation size by almot 10%, from 8.3 kB to 7.6 kB. Not bad. Apart from small memory savings, this also removes the need to include the full class definiton from the State headers on MSVC (because on that compiler the member function pointer size is different based on whether the type definition is known or not, IMAGINE THAT BEING A FEATURE AND NOT A BUG), leading to less header dependencies and better incremental compile times there. This was already done in some cases (and the Vk library used this from the beginning), and as I'm about to add some more extension-dependent functionality it felt like a good time to finish that change, finally. In some cases the *Implementation() could even be dropped in favor of pointing to the GL API directly (such as is already done for various glUniform*() calls), that'd be another step -- this is good enough for now.
3 years ago
GLint(*getCubeLevelCompressedImageSizeImplementation)(CubeMapTexture&, GLint);
void(*getCubeImageImplementation)(CubeMapTexture&, CubeMapCoordinate, GLint, const Vector2i&, PixelFormat, PixelType, std::size_t, GLvoid*);
void(*getCubeImage3DImplementation)(CubeMapTexture&, GLint, const Vector3i&, PixelFormat, PixelType, std::size_t, GLvoid*, const PixelStorage&);
void(*getCompressedCubeImage3DImplementation)(CubeMapTexture&, GLint, const Vector2i&, std::size_t, std::size_t, GLvoid*);
void(*getCompressedCubeImageImplementation)(CubeMapTexture&, CubeMapCoordinate, GLint, const Vector2i&, std::size_t, GLvoid*);
#endif
void(*cubeSubImage3DImplementation)(CubeMapTexture&, GLint, const Vector3i&, const Vector3i&, PixelFormat, PixelType, const GLvoid*, const PixelStorage&);
void(*cubeSubImageImplementation)(CubeMapTexture&, CubeMapCoordinate, GLint, const Vector2i&, const Vector2i&, PixelFormat, PixelType, const GLvoid*);
void(*cubeCompressedSubImageImplementation)(CubeMapTexture&, CubeMapCoordinate, GLint, const Vector2i&, const Vector2i&, CompressedPixelFormat, const GLvoid*, GLsizei);
Full ARB_direct_state_access support in textures. ARB_DSA is now preferred in single-bind cases, as it is easier to use than passing pointers to ARB_multi_bind. ARB_multi_bind was preferred for single-bind previously simply because EXT_DSA was not in core. Because there is a lot to say about feature selection for each function, I took this as a opportunity to remove redundant documentation blocks, just refer to Texture documentation from everywhere and add extension requirements and deprecation where needed, so it's clear for each class what needs what. ARB_DSA also took the opportunity to finally remove all target enum values from function calls and because of that the CubeMapTexture has to handle a bunch of special cases. In order: - CubeMapTexture::imageSize() now doesn't take face parameter and returns one value for all faces. I'm thus now also assuming that the user is sane and called either setStorage() or setImage() with the same size for all faces. In non-ARB_DSA path I'm thus querying only size of +X face and returning it as size for all faces. The old imageSize(Coordinate, Int) overload is still present, but ignores the first parameter and calls imageSize(Int). It is marked as deprecated and will be removed in some future release. - CubeMapTexture::image() now needs to call glTextureSubImage() in ARB_DSA path to make it possible to extract single face. Other code paths (EXT_DSA, Robustness and "default") remain the same. - CubeMapTexture::setSubImage() calls glTextureSubImage3D() in ARB_DSA, because it is not possible to specify face index in glTextureSubImage2D(). Other code paths (EXT_DSA and "default") remain the same. Implementation of these special cases is extracted into CubeMapTexture class to avoid pollution of AbstractTexture with incompatible nonsense.
12 years ago
Queries for max supported texture size.
12 years ago
GLint maxSize,
First-class WebGL support, part 4: reduced texture functionality.
11 years ago
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2))
Queries for max supported texture size.
12 years ago
max3DSize,
First-class WebGL support, part 4: reduced texture functionality.
11 years ago
#endif
Queries for max supported texture size.
12 years ago
maxCubeMapSize;
Hide texture state members which are not used on ES. Shaved eight bytes off total memory footprint, yay!
12 years ago
#ifndef MAGNUM_TARGET_GLES2
GLint maxArrayLayers;
#endif
Queries for max supported texture size.
12 years ago
#ifndef MAGNUM_TARGET_GLES
Implemented EXT_texture_buffer AEP extension.
11 years ago
GLint maxRectangleSize;
#endif
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
GLint maxBufferSize;
Queries for max supported texture size.
12 years ago
#endif
Follow OpenGL terminology for texture binding units. Until now the textures were bound to layers, which was rather confusing, especially when binding layered textures to layers (gaah). Also the wording might have implied that each texture must be in some layer in order to make it usable in shader. This is no longer the case with (yet unimplemented) bindless texture, so another reason to remove the confusion. All occurences of texture layers were replaced texture binding units to follow OpenGL naming. It was mostly in the docs, except for already-deprecated *Layer enums in shaders, but they will be removed soon anyway.
12 years ago
GLint maxTextureUnits;
Max texture LOD bias _is_ available in OpenGL ES 3.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
Hide texture state members which are not used on ES. Shaved eight bytes off total memory footprint, yay!
12 years ago
GLfloat maxLodBias;
#endif
GLfloat maxMaxAnisotropy;
Follow OpenGL terminology for texture binding units. Until now the textures were bound to layers, which was rather confusing, especially when binding layered textures to layers (gaah). Also the wording might have implied that each texture must be in some layer in order to make it usable in shader. This is no longer the case with (yet unimplemented) bindless texture, so another reason to remove the confusion. All occurences of texture layers were replaced texture binding units to follow OpenGL naming. It was mostly in the docs, except for already-deprecated *Layer enums in shaders, but they will be removed soon anyway.
12 years ago
GLint currentTextureUnit;
Enabled multisample texture limit queries in ES 3.1.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
Texture-related limit queries. Renamed AbstractTexture::maxSupportedLayerCount() to maxLayers(), which is in fact alias to Shader::maxCombinedTextureImageUnits(). Also renamed Samples::maxSupportedAnisotropy() to maxAnisotropy(). It now has slightly confusing naming, will fix that later. Both original functions are now alias to new ones to retain source compatibility, will be removed in future releases. Also printing the values in magnum-info.
13 years ago
GLint maxColorSamples,
maxDepthSamples,
Enabled multisample texture limit queries in ES 3.1.
12 years ago
maxIntegerSamples;
#endif
Implemented EXT_texture_buffer AEP extension.
11 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
Enabled multisample texture limit queries in ES 3.1.
12 years ago
GLint bufferOffsetAlignment;
Texture-related limit queries. Renamed AbstractTexture::maxSupportedLayerCount() to maxLayers(), which is in fact alias to Shader::maxCombinedTextureImageUnits(). Also renamed Samples::maxSupportedAnisotropy() to maxAnisotropy(). It now has slightly confusing naming, will fix that later. Both original functions are now alias to new ones to retain source compatibility, will be removed in future releases. Also printing the values in magnum-info.
13 years ago
#endif
Tracking texture state - bindings and limits.
14 years ago
GL: put texture/image state trackers into the single allocation also.
5 years ago
/* These arrays get allocated in State in a single allocation and views to
them are passed here via the constructor. */
/* Texture type, texture object ID. While not true, for simplicity this
assumes that each slot can have just one ID bound, not one ID per
texture type. */
GL: drop std::pair from texture state tracker internals. Apparently even `= {}` was broken for std::pair once, not to mention the unnecessary extra overhead with this type not being trivially copyable. Good riddance.
3 years ago
Containers::ArrayView<Containers::Pair<GLenum, GLuint>> bindings;
GL: fix compilation on macOS + ANGLE.
6 years ago
#if defined(CORRADE_TARGET_APPLE) && !defined(MAGNUM_TARGET_GLES)
Math: rename BoolVector to BitVector. Because it somewhat confusingly may have implied that it's really composed of 8-bit bools, and not bits. The same reasoning was used to pick the name for Corrade's Containers::BitArray. Backwards compatibility aliases are in place as usual, however the internal BoolVectorConverter is now BitVectorConverter and there unfortunately cannot be any backwards compatibility. This breaks only GLM and Eigen integration in the magnum-integration repo, which I'm fixing immediately. I don't expect any user code to use this internal helper. For regular vectors maybe, for this one definitely not.
4 years ago
Math::BitVector<80> bufferTextureBound;
GL: finalize the apple-buffer-texture-unbind-on-buffer-modify workaround. Followup to 24cc971b1f43c61aa157228f6ea9916007ffb3cd, covering the remaining case.
6 years ago
#endif
Implemented ARB_shader_image_load_store.
10 years ago
#if !defined(MAGNUM_TARGET_GLES2) && !defined(MAGNUM_TARGET_WEBGL)
Minor cleanup and documentation.
10 years ago
/* Texture object ID, level, layered, layer, access */
GL: drop a silly <tuple> from state tracker internals. Using a tuple was very useful, helpful and exciting as I had to make an explicit comment about what element is what, and then having to remember the order in all places that accessed the tuple. Using a struct however is rather boring as the fields are just named there, I don't need any complex std::get<4>() and extra comments explaining what is where and it's just not so adventurous anymore. The build time of a non-deprecated MagnumGL library also dropped from 5.9 seconds to 5.85. SAD!
4 years ago
Containers::ArrayView<ImageBinding> imageBindings;
Implemented ARB_shader_image_load_store.
10 years ago
#endif
Tracking texture state - bindings and limits.
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
}}}
Tracking texture state - bindings and limits.
14 years ago
#endif