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.
3369 Commits
21 Branches
19 Tags
70 MiB
Tree: 1b1ad41ae1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '1b1ad41ae1'
${ noResults }
magnum/src/Magnum/AbstractTexture.h

551 lines
27 KiB
Raw Normal View History Unescape

Splitting non-templated things from Texture to AbstractTexture.
15 years ago
#ifndef Magnum_AbstractTexture_h
#define Magnum_AbstractTexture_h
/*
This file is part of Magnum.
Happy new year too.
12 years ago
Copyright © 2010, 2011, 2012, 2013, 2014
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.
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*/
/** @file
Shotgun documentation updates. Fixed old references to Buffer::Usage, fixed parameter order in Image constructor, fixed some function references. Added explicit references to linkable stuff.
13 years ago
* @brief Class @ref Magnum::AbstractTexture
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*/
Making includes absolute, part 5: absolute includes everywhere. The only places where they aren't absolute are: - when header is included from corresponding source file - when including headers which are not part of final installation (e.g. test-specific configuration, headers from Implementation/)
12 years ago
#include "Magnum/Sampler.h"
#include "Magnum/AbstractObject.h"
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
namespace Magnum {
Moved global data from texture classes to per-context state.
12 years ago
namespace Implementation { struct TextureState; }
Revert "Documentation: organizing the classes into "modules"." It only caused another maintenance burden and was confusing to users. Now when scene graph is in SceneGraph namespace there is no need for another grouping. Namespaces are (and should be) sufficient. This reverts commit 79945ab6fce4bf0b53faab1d2f694f4cd934d562. Conflicts: src/BufferedImage.h src/BufferedTexture.h src/Framebuffer.h src/Query.h src/SceneGraph/Scene.h
14 years ago
/**
Texture documentation reorganization. The part similar for all AbstractTexture subclasses should be in AbstractTexture itself, not anywhere else.
14 years ago
@brief Base for textures
doc: texture documentation updates. Remove duplicates, add minimal multisample docs, update GL function mapping table.
12 years ago
Encapsulates one OpenGL texture object. See @ref Texture, @ref TextureArray,
@ref CubeMapTexture, @ref CubeMapTextureArray, @ref RectangleTexture,
@ref BufferTexture and @ref MultisampleTexture documentation for more
information and usage examples.
Texture documentation reorganization. The part similar for all AbstractTexture subclasses should be in AbstractTexture itself, not anywhere else.
14 years ago
doc: document all WebGL restrictions.
12 years ago
@section AbstractTexture-webgl-restrictions WebGL restrictions
@ref MAGNUM_TARGET_WEBGL "WebGL" puts some restrictions on type of data
submitted to @ref Texture::setSubImage() "*Texture::setSubImage()", see its
documentation for details.
Ability to retrieve texture images.
13 years ago
@section AbstractTexture-performance-optimization Performance optimizations and security
Documentation and example usage of textures. Mentions some not-yet-done features such as Vector2i or proper texture formats.
14 years ago
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
The engine tracks currently bound textures in all available texture units to
avoid unnecessary calls to @fn_gl{ActiveTexture} and @fn_gl{BindTexture}.
%Texture configuration functions use dedicated highest available texture unit
to not affect active bindings in user units. %Texture limits and
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
implementation-defined values (such as @ref maxColorSamples()) are cached, so
repeated queries don't result in repeated @fn_gl{Get} calls.
Tracking texture state - bindings and limits.
14 years ago
Initial ARB_multi_bind usage in *Texture::bind().
12 years ago
If extension @extension{ARB,multi_bind} is available, @ref bind() uses
@fn_gl{BindTextures} to avoid unnecessary calls to @fn_gl{ActiveTexture}.
Otherwise, if extension @extension{EXT,direct_state_access} is available,
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
@ref bind() uses @fn_gl_extension{BindMultiTexture,EXT,direct_state_access}
function.
Initial ARB_multi_bind usage in *Texture::bind().
12 years ago
In addition, if extension @extension{EXT,direct_state_access} is available,
also all texture configuration and data updating functions use DSA functions
to avoid unnecessary calls to @fn_gl{ActiveTexture} and @fn_gl{BindTexture}.
See respective function documentation for more information.
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Ability to retrieve texture images.
13 years ago
If extension @extension{ARB,robustness} is available, image reading operations
Shotgun documentation updates. Fixed old references to Buffer::Usage, fixed parameter order in Image constructor, fixed some function references. Added explicit references to linkable stuff.
13 years ago
(such as @ref Texture::image()) are protected from buffer overflow. However, if
both @extension{EXT,direct_state_access} and @extension{ARB,robustness} are
Ability to retrieve texture images.
13 years ago
available, the DSA version is used, because it is better for performance and
there isn't any function combining both features.
Tracking texture state - bindings and limits.
14 years ago
To achieve least state changes, fully configure each texture in one run --
method chaining comes in handy -- and try to have often used textures in
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
dedicated units, not occupied by other textures. First configure the texture
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
and *then* set the data, so OpenGL can optimize them to match the settings. To
avoid redundant consistency checks and memory reallocations when updating
texture data, set texture storage at once using @ref Texture::setStorage() "setStorage()"
and then set data using @ref Texture::setSubImage() "setSubImage()".
Tracking texture state - bindings and limits.
14 years ago
Fallback for texture storage feature. It's now possible to call *Texture::setStorage() even if OpenGL 4.2, ARB_texture_storage, OpenGL ES 3.0 or EXT_texture_storage in ES 2.0 is not available, the function will internally use sequence of setImage() calls as fallback. It seems to me that this behavior is better than forcing the user to always check for extension presence and then implementing this functionality again and again. The huge switches for setting proper image format and type are ugly though, but according to specs they must be set even if we are sending no data (which is weird).
13 years ago
Function @ref Texture::setStorage() "setStorage()" creates immutable texture
storage, removing the need for additional consistency checks and memory
reallocations when updating the data later. If OpenGL 4.2, @extension{ARB,texture_storage},
OpenGL ES 3.0 or @es_extension{EXT,texture_storage} in OpenGL ES 2.0 is not
available, the feature is emulated with sequence of @ref Texture::setImage() "setImage()"
calls.
Doc++
12 years ago
You can use functions @ref Texture::invalidateImage() "invalidateImage()" and
Shotgun documentation updates. Fixed old references to Buffer::Usage, fixed parameter order in Image constructor, fixed some function references. Added explicit references to linkable stuff.
13 years ago
@ref Texture::invalidateSubImage() "invalidateSubImage()" if you don't need
texture data anymore to avoid unnecessary memory operations performed by OpenGL
in order to preserve the data. If running on OpenGL ES or extension
doc: mention also OpenGL version for optionally used extensions.
12 years ago
@extension{ARB,invalidate_subdata} (part of OpenGL 4.3) is not available, these
functions do nothing.
Extension-aware Buffer and *Texture data invalidation. If ARB_invalidate_subdata is not available, these functions do nothing, instead of crashing on null pointer dereference. It results in more convenient usage, enabling users to call them whenever they want, improving performance on implementations which supports that.
14 years ago
Added TODOs.
13 years ago
@todo all texture [level] parameters, global texture parameters
Added some TODOs.
14 years ago
@todo Add glPixelStore encapsulation
@todo++
14 years ago
@todo Texture copying
Move constructor and move assignment for textures.
14 years ago
@todo Move constructor/assignment - how to avoid creation of empty texture and
then deleting it immediately?
Proper passing of image data to textures. Explicitly unbinding pixel unpack buffer when passing data from client memory and binding it when passing data from BufferImage.
13 years ago
@todo ES2 - proper support for pixel unpack buffer when extension is in headers
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
@todo `GL_NUM_COMPRESSED_TEXTURE_FORMATS` when compressed textures are implemented
@todo `GL_MAX_SAMPLE_MASK_WORDS` when @extension{ARB,texture_multisample} is done
Doc++ Also added new Doxygen alias for more specific GL function links.
12 years ago
@todo Query for immutable levels (@extension{ARB,ES3_compatibility})
Fix (workaround) failing texture tests. With ARB_multi_bind it is needed to associate the texture with some target before calling glBindTextures(), otherwise the texture is treated as invalid.
12 years ago
@bug If using @extension{ARB,multi_bind} and the texture is bound right after
construction, the @fn_gl{BindTextures} call will fail with
Renderer::Error::InvalidOperation, because the texture doesn't yet have
associated target
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*/
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
class MAGNUM_EXPORT AbstractTexture: public AbstractObject {
Fix class/struct mismatch. Thanks, Clang.
12 years ago
friend struct Implementation::TextureState;
Tracking texture state - bindings and limits.
14 years ago
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
public:
Deprecate AbstractTexture::maxLayers() altogether. *Texture::bind() is now meant to be used only internally from shaders, thus this function is not needed at all, as we should query directly the particular shader type for the limits. The name also somehow clashes with layered textures, which should be avoided.
12 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
/**
Deprecate AbstractTexture::maxLayers() altogether. *Texture::bind() is now meant to be used only internally from shaders, thus this function is not needed at all, as we should query directly the particular shader type for the limits. The name also somehow clashes with layered textures, which should be avoided.
12 years ago
* @copybrief Shader::maxCombinedTextureImageUnits()
* @deprecated Use @ref Magnum::Shader::maxCombinedTextureImageUnits() "Shader::maxCombinedTextureImageUnits()"
* instead.
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
*/
Deprecate AbstractTexture::maxLayers() altogether. *Texture::bind() is now meant to be used only internally from shaders, thus this function is not needed at all, as we should query directly the particular shader type for the limits. The name also somehow clashes with layered textures, which should be avoided.
12 years ago
static CORRADE_DEPRECATED("use Shader::maxCombinedTextureImageUnits() instead") Int maxLayers();
#endif
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
Implemented texture LOD parameters.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
/**
* @brief Max level-of-detail bias
*
* The result is cached, repeated queries don't result in repeated
* OpenGL calls.
* @see @fn_gl{Get} with @def_gl{MAX_TEXTURE_LOD_BIAS}
* @requires_gles30 %Texture LOD bias doesn't have
* implementation-defined range in OpenGL ES 2.0.
*/
static Float maxLodBias();
#endif
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
#ifndef MAGNUM_TARGET_GLES
/**
* @brief Max supported color sample count
*
* The result is cached, repeated queries don't result in repeated
* OpenGL calls. If extension @extension{ARB,texture_multisample} is
* not available, returns `0`.
* @see @fn_gl{Get} with @def_gl{MAX_COLOR_TEXTURE_SAMPLES}
* @requires_gl Multisample textures are not available in OpenGL ES.
*/
static Int maxColorSamples();
/**
* @brief Max supported depth sample count
*
* The result is cached, repeated queries don't result in repeated
* OpenGL calls. If extension @extension{ARB,texture_multisample} is
* not available, returns `0`.
* @see @fn_gl{Get} with @def_gl{MAX_DEPTH_TEXTURE_SAMPLES}
* @requires_gl Multisample textures are not available in OpenGL ES.
*/
static Int maxDepthSamples();
/**
* @brief Max supported integer sample count
*
* The result is cached, repeated queries don't result in repeated
* OpenGL calls. If extension @extension{ARB,texture_multisample} is
* not available, returns `0`.
* @see @fn_gl{Get} with @def_gl{MAX_INTEGER_SAMPLES}
* @requires_gl Multisample textures are not available in OpenGL ES.
*/
static Int maxIntegerSamples();
#endif
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
Added *Texture::unbind(). Will be used in fallback implementation of multi-bind.
12 years ago
/**
* @brief Unbind any texture from given texture unit
*
* If @extension{ARB,multi_bind} (part of OpenGL 4.4) or
* @extension{EXT,direct_state_access} is not available, the texture
* unit is made active before binding the texture.
* @note This function is meant to be used only internally from
* @ref AbstractShaderProgram subclasses. See its documentation
* for more information.
* @see @ref bind(), @ref Shader::maxCombinedTextureImageUnits(),
* @fn_gl{ActiveTexture}, @fn_gl{BindTexture}, @fn_gl{BindTextures}
* or @fn_gl_extension{BindMultiTexture,EXT,direct_state_access}
*/
static void unbind(Int textureUnit);
Support ARB_multi_bind for textures.
12 years ago
/**
* @brief Bind textures to given range of texture units
*
* Binds first texture in the list to @p firstTextureUnit, second to
* `firstTextureUnit + 1` etc. If any texture is `nullptr`, given
* texture unit is unbound. If @extension{ARB,multi_bind} (part of
* OpenGL 4.4) is not available, the feature is emulated with sequence
* of @ref bind(Int) / @ref unbind() calls.
* @see @fn_gl{BindTextures}, eventually @fn_gl{ActiveTexture},
* @fn_gl{BindTexture} or @fn_gl_extension{BindMultiTexture,EXT,direct_state_access}
*/
static void bind(Int firstTextureUnit, std::initializer_list<AbstractTexture*> textures);
Minor cleanup.
12 years ago
/** @brief Copying is not allowed */
AbstractTexture(const AbstractTexture&) = delete;
/** @brief Move constructor */
AbstractTexture(AbstractTexture&& other) noexcept;
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
/**
* @brief Destructor
*
* Deletes associated OpenGL texture.
* @see @fn_gl{DeleteTextures}
*/
~AbstractTexture();
Document disallowed copy and allowed move better. Moreover when the deleted function was private, the compilation failed with (rather cryptic) error that the function is private instead of noticing that the function is deleted.
13 years ago
/** @brief Copying is not allowed */
AbstractTexture& operator=(const AbstractTexture&) = delete;
Move constructor and move assignment for textures.
14 years ago
/** @brief Move assignment */
Simplified and tested Texture move constructor/assignment. Move constructor and move assignment is now noexcept and it just swaps the data of the two instances instead of calling GL API, thus it can be inline. Also removed unneded limitations in BufferTexture.
13 years ago
AbstractTexture& operator=(AbstractTexture&& other) noexcept;
Move constructor and move assignment for textures.
14 years ago
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
/**
* @brief %Texture label
*
* The result is *not* cached, repeated queries will result in repeated
doc: mention also OpenGL version for optionally used extensions.
12 years ago
* OpenGL calls. If OpenGL 4.3 is not supported and neither
* @extension{KHR,debug} nor @extension2{EXT,debug_label} desktop or ES
* extension is available, this function returns empty string.
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
* @see @fn_gl{GetObjectLabel} or
Fixed documentation links to EXT_debug_label.
13 years ago
* @fn_gl_extension2{GetObjectLabel,EXT,debug_label} with
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
* @def_gl{TEXTURE}
*/
std::string label() const;
/**
* @brief Set texture label
* @return Reference to self (for method chaining)
*
doc: mention also OpenGL version for optionally used extensions.
12 years ago
* Default is empty string. If OpenGL 4.3 is not supported and neither
* @extension{KHR,debug} nor @extension2{EXT,debug_label} desktop or ES
* extension is available, this function does nothing.
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
* @see @ref maxLabelLength(), @fn_gl{ObjectLabel} or
Fixed documentation links to EXT_debug_label.
13 years ago
* @fn_gl_extension2{LabelObject,EXT,debug_label} with
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
* @def_gl{TEXTURE}
*/
AbstractTexture& setLabel(const std::string& label);
Refactoring of internal OpenGL object names.
14 years ago
/** @brief OpenGL texture ID */
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
GLuint id() const { return _id; }
Added function to get OpenGL internal ID for given texture.
14 years ago
Doc++
14 years ago
/**
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
* @brief Bind texture to given texture unit
Doc++
14 years ago
*
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
* If @extension{ARB,multi_bind} (part of OpenGL 4.4) or
* @extension{EXT,direct_state_access} is not available, the texture
* unit is made active before binding the texture.
Use functions to bind textures to shader rather than *Texture::bind(). Why did I do this: * It is more clean, shorter and nice looking with method chaining, i.e. instead of: shader.setColor(...) .setOtherParam(5); texture1.bind(MyShader::Texture1Layer); texture2.bind(MyShader::Texture2Layer); We now have this: shader.setColor(...) .setOtherParam(5) .setTexture1(texture1) .setTexture2(texture2); * It is now also clear which texture type is expected, the layer constant did not say anything about type. * Also it is possible to use new features (multi bind, bindless textures etc.) while preserving the same public API. The only potential disadvantage is that the textures don't stay bound like uniform values do, but this become a non-issue with bindless textures. As usual, the old way is now deprecated and will be removed in some future release.
12 years ago
* @note This function is meant to be used only internally from
* @ref AbstractShaderProgram subclasses. See its documentation
* for more information.
Support ARB_multi_bind for textures.
12 years ago
* @see @ref bind(Int, std::initializer_list<AbstractTexture*>),
* @ref unbind(), @ref Shader::maxCombinedTextureImageUnits(),
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
* @fn_gl{ActiveTexture}, @fn_gl{BindTexture}, @fn_gl{BindTextures}
* or @fn_gl_extension{BindMultiTexture,EXT,direct_state_access}
Doc++
14 years ago
*/
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
void bind(Int textureUnit);
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
Doxygen: ignore specific namespaces instead of whole directories. Less maintenance burden with `#ifndef DOXYGEN_GENERATING_OUTPUT`, removed the ones which are not needed anymore.
13 years ago
#ifdef DOXYGEN_GENERATING_OUTPUT
private:
#else
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
protected:
Doxygen: ignore specific namespaces instead of whole directories. Less maintenance burden with `#ifndef DOXYGEN_GENERATING_OUTPUT`, removed the ones which are not needed anymore.
13 years ago
#endif
Using new type aliases in whole root Magnum namespace.
13 years ago
template<UnsignedInt textureDimensions> struct DataHelper {};
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
explicit AbstractTexture(GLenum target);
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
/* Unlike bind() this also sets the texture binding unit as active */
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL bindInternal();
Fixed CubeMapTexture wrapping, simplified code of texture classes. Texture now doesn't have it's own redundant copy of target, but uses the one from AbstractTexture. Subsequently, all DataHelper functions now accept "untyped" GLenum as target for better flexibility. CubeMapTexture is not based on Texture2D anymore, all references to cube map textures were removed from Target enums, so it's now not possible to create cube map texture other way than using CubeMapTexture class, which is how it should be done in first place. The wrapping mode fix is thus now trivial.
14 years ago
Ability to set base and max mip level on textures. Curiously this functionality is not available on ES2, just the max limit is supported by APPLE_texture_max_level extension.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
void setBaseLevel(Int level);
#endif
void setMaxLevel(Int level);
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
void setMinificationFilter(Sampler::Filter filter, Sampler::Mipmap mipmap);
void setMagnificationFilter(Sampler::Filter filter);
Implemented texture LOD parameters.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
void setMinLod(Float lod);
void setMaxLod(Float lod);
#endif
#ifndef MAGNUM_TARGET_GLES
void setLodBias(Float bias);
#endif
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
void setBorderColor(const Color4& color);
Integer texture borders are not available in OpenGL ES.
12 years ago
#ifndef MAGNUM_TARGET_GLES
Support for setting border color on integer textures. EXT_texture_integer implementation is now complete. Just GL 3.0 subset, though, as apparently glClearColorI*() is not part of it.
12 years ago
void setBorderColor(const Vector4i& color);
void setBorderColor(const Vector4ui& color);
Integer texture borders are not available in OpenGL ES.
12 years ago
#endif
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
void setMaxAnisotropy(Float anisotropy);
Implemented depth texture compare mode and function.
12 years ago
void setCompareMode(Sampler::CompareMode mode);
void setCompareFunction(Sampler::CompareFunction function);
Implementation of ARB_stencil_texturing.
12 years ago
#ifndef MAGNUM_TARGET_GLES
void setDepthStencilMode(Sampler::DepthStencilMode mode);
#endif
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
void invalidateImage(Int level);
void generateMipmap();
Ability to retrieve texture images.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Pass image as reference, not pointer to *Texture::image(). Avoids some nullptr-related errors.
13 years ago
template<UnsignedInt dimensions> void image(GLenum target, GLint level, Image<dimensions>& image);
Extract Buffer::Usage enum out of Buffer class. Buffer usage is used as parameter in many functions, e.g. in *Framebuffer::read() and *Texture::image(), but they are rather seldom used and including whole Buffer.h file just for one enum is just overkill. The old Buffer::Usage is now alias to BufferUsage, it is marked as deprecated and will be removed in future release.
13 years ago
template<UnsignedInt dimensions> void image(GLenum target, GLint level, BufferImage<dimensions>& image, BufferUsage usage);
Ability to retrieve texture images.
13 years ago
#endif
Move constructor and move assignment for textures.
14 years ago
GLenum _target;
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
private:
Added *Texture::unbind(). Will be used in fallback implementation of multi-bind.
12 years ago
static void MAGNUM_LOCAL unbindImplementationDefault(GLint textureUnit);
#ifndef MAGNUM_TARGET_GLES
static void MAGNUM_LOCAL unbindImplementationMulti(GLint textureUnit);
static void MAGNUM_LOCAL unbindImplementationDSA(GLint textureUnit);
#endif
Support ARB_multi_bind for textures.
12 years ago
static void MAGNUM_LOCAL bindImplementationFallback(GLint firstTextureUnit, std::initializer_list<AbstractTexture*> textures);
#ifndef MAGNUM_TARGET_GLES
static void MAGNUM_LOCAL bindImplementationMulti(GLint firstTextureUnit, std::initializer_list<AbstractTexture*> textures);
#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
void MAGNUM_LOCAL bindImplementationDefault(GLint textureUnit);
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
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
void MAGNUM_LOCAL bindImplementationMulti(GLint textureUnit);
void MAGNUM_LOCAL bindImplementationDSA(GLint textureUnit);
Updated OpenGL ES support in textures.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL parameterImplementationDefault(GLenum parameter, GLint value);
void MAGNUM_LOCAL parameterImplementationDefault(GLenum parameter, GLfloat value);
Support for setting border color on integer textures. EXT_texture_integer implementation is now complete. Just GL 3.0 subset, though, as apparently glClearColorI*() is not part of it.
12 years ago
void MAGNUM_LOCAL parameterImplementationDefault(GLenum parameter, const GLfloat* values);
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Renamed internal function to avoid name clashes.
12 years ago
void MAGNUM_LOCAL parameterIImplementationDefault(GLenum parameter, const GLuint* values);
void MAGNUM_LOCAL parameterIImplementationDefault(GLenum parameter, const GLint* values);
Updated OpenGL ES support in textures.
14 years ago
#endif
#ifndef MAGNUM_TARGET_GLES
Support for setting border color on integer textures. EXT_texture_integer implementation is now complete. Just GL 3.0 subset, though, as apparently glClearColorI*() is not part of it.
12 years ago
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, GLint value);
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, GLfloat value);
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, const GLfloat* values);
Renamed internal function to avoid name clashes.
12 years ago
void MAGNUM_LOCAL parameterIImplementationDSA(GLenum parameter, const GLuint* values);
void MAGNUM_LOCAL parameterIImplementationDSA(GLenum parameter, const GLint* values);
Updated OpenGL ES support in textures.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Added no-op fallback for unsupported EXT_texture_filter_anisotropic. This extension is ubiquitous, but to make users' life even easier we now provide no-op fallback for both Sampler::maxAnisotropy() and Texture::setMaxAnisotropy().
13 years ago
void MAGNUM_LOCAL setMaxAnisotropyImplementationNoOp(GLfloat);
void MAGNUM_LOCAL setMaxAnisotropyImplementationExt(GLfloat anisotropy);
Implementation for texture level parameter query.
13 years ago
#ifndef MAGNUM_TARGET_GLES
void MAGNUM_LOCAL getLevelParameterImplementationDefault(GLenum target, GLint level, GLenum parameter, GLint* values);
void MAGNUM_LOCAL getLevelParameterImplementationDSA(GLenum target, GLint level, GLenum parameter, GLint* values);
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL mipmapImplementationDefault();
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL mipmapImplementationDSA();
Updated OpenGL ES support in textures.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Fallback for texture storage feature. It's now possible to call *Texture::setStorage() even if OpenGL 4.2, ARB_texture_storage, OpenGL ES 3.0 or EXT_texture_storage in ES 2.0 is not available, the function will internally use sequence of setImage() calls as fallback. It seems to me that this behavior is better than forcing the user to always check for extension presence and then implementing this functionality again and again. The huge switches for setting proper image format and type are ugly though, but according to specs they must be set even if we are sending no data (which is weird).
13 years ago
void MAGNUM_LOCAL storageImplementationFallback(GLenum target, GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDefault(GLenum target, GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
void MAGNUM_LOCAL storageImplementationDSA(GLenum target, GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#endif
Fallback for texture storage feature. It's now possible to call *Texture::setStorage() even if OpenGL 4.2, ARB_texture_storage, OpenGL ES 3.0 or EXT_texture_storage in ES 2.0 is not available, the function will internally use sequence of setImage() calls as fallback. It seems to me that this behavior is better than forcing the user to always check for extension presence and then implementing this functionality again and again. The huge switches for setting proper image format and type are ugly though, but according to specs they must be set even if we are sending no data (which is weird).
13 years ago
void MAGNUM_LOCAL storageImplementationFallback(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector2i& size);
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDefault(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector2i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDSA(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector2i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#endif
Fallback for texture storage feature. It's now possible to call *Texture::setStorage() even if OpenGL 4.2, ARB_texture_storage, OpenGL ES 3.0 or EXT_texture_storage in ES 2.0 is not available, the function will internally use sequence of setImage() calls as fallback. It seems to me that this behavior is better than forcing the user to always check for extension presence and then implementing this functionality again and again. The huge switches for setting proper image format and type are ugly though, but according to specs they must be set even if we are sending no data (which is weird).
13 years ago
void MAGNUM_LOCAL storageImplementationFallback(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector3i& size);
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDefault(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector3i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDSA(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector3i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#endif
Added MultisampleTexture::setStorage(). With this function multisample texture implementation is pretty much done. Also implemented all the tests.
12 years ago
#ifndef MAGNUM_TARGET_GLES
void MAGNUM_LOCAL storageMultisampleImplementationFallback(GLenum target, GLsizei samples, TextureFormat internalFormat, const Vector2i& size, GLboolean fixedsamplelocations);
void MAGNUM_LOCAL storageMultisampleImplementationDefault(GLenum target, GLsizei samples, TextureFormat internalFormat, const Vector2i& size, GLboolean fixedsamplelocations);
void MAGNUM_LOCAL storageMultisampleImplementationDSA(GLenum target, GLsizei samples, TextureFormat internalFormat, const Vector2i& size, GLboolean fixedsamplelocations);
void MAGNUM_LOCAL storageMultisampleImplementationFallback(GLenum target, GLsizei samples, TextureFormat internalFormat, const Vector3i& size, GLboolean fixedsamplelocations);
void MAGNUM_LOCAL storageMultisampleImplementationDefault(GLenum target, GLsizei samples, TextureFormat internalFormat, const Vector3i& size, GLboolean fixedsamplelocations);
void MAGNUM_LOCAL storageMultisampleImplementationDSA(GLenum target, GLsizei samples, TextureFormat internalFormat, const Vector3i& size, GLboolean fixedsamplelocations);
#endif
Ability to retrieve texture images.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL getImageImplementationDefault(GLenum target, GLint level, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationDSA(GLenum target, GLint level, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationRobustness(GLenum target, GLint level, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
Ability to retrieve texture images.
13 years ago
#endif
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint level, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size, ColorFormat format, ColorType type, const GLvoid* data);
void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint level, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size, ColorFormat format, ColorType type, const GLvoid* data);
Updated OpenGL ES support in textures.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint level, TextureFormat internalFormat, const Vector2i& size, ColorFormat format, ColorType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint level, TextureFormat internalFormat, const Vector2i& size, ColorFormat format, ColorType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint level, TextureFormat internalFormat, const Vector3i& size, ColorFormat format, ColorType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint level, TextureFormat internalFormat, const Vector3i& size, ColorFormat format, ColorType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, ColorFormat format, ColorType type, const GLvoid* data);
void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, ColorFormat format, ColorType type, const GLvoid* data);
Updated OpenGL ES support in textures.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint level, const Vector2i& offset, const Vector2i& size, ColorFormat format, ColorType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint level, const Vector2i& offset, const Vector2i& size, ColorFormat format, ColorType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint level, const Vector3i& offset, const Vector3i& size, ColorFormat format, ColorType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint level, const Vector3i& offset, const Vector3i& size, ColorFormat format, ColorType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
void MAGNUM_LOCAL invalidateImageImplementationNoOp(GLint level);
Extension-aware Buffer and *Texture data invalidation. If ARB_invalidate_subdata is not available, these functions do nothing, instead of crashing on null pointer dereference. It results in more convenient usage, enabling users to call them whenever they want, improving performance on implementations which supports that.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
void MAGNUM_LOCAL invalidateImageImplementationARB(GLint level);
Extension-aware Buffer and *Texture data invalidation. If ARB_invalidate_subdata is not available, these functions do nothing, instead of crashing on null pointer dereference. It results in more convenient usage, enabling users to call them whenever they want, improving performance on implementations which supports that.
14 years ago
#endif
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
void MAGNUM_LOCAL invalidateSubImageImplementationNoOp(GLint level, const Vector3i& offset, const Vector3i& size);
Extension-aware Buffer and *Texture data invalidation. If ARB_invalidate_subdata is not available, these functions do nothing, instead of crashing on null pointer dereference. It results in more convenient usage, enabling users to call them whenever they want, improving performance on implementations which supports that.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
void MAGNUM_LOCAL invalidateSubImageImplementationARB(GLint level, const Vector3i& offset, const Vector3i& size);
Extension-aware Buffer and *Texture data invalidation. If ARB_invalidate_subdata is not available, these functions do nothing, instead of crashing on null pointer dereference. It results in more convenient usage, enabling users to call them whenever they want, improving performance on implementations which supports that.
14 years ago
#endif
Renamed ImageType and ImageFormat to ColorType and ColorFormat. Makes more sense. Added aliases and header file for backwards compatibility, will be removed in future versions.
13 years ago
ColorFormat MAGNUM_LOCAL imageFormatForInternalFormat(TextureFormat internalFormat);
ColorType MAGNUM_LOCAL imageTypeForInternalFormat(TextureFormat internalFormat);
Move constructor and move assignment for textures.
14 years ago
Refactoring of internal OpenGL object names.
14 years ago
GLuint _id;
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
};
Fixed wrong automagic texture target for 3D textures. While GL_TEXTURE_2D == GL_TEXTURE_1D + 1, GL_TEXTURE_3D is something absolutely different and cannot be computed like this. Now done via AbstractTexture::DataHelper, which is cleaner and better readable.
15 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
Port to OpenGL ES 2. Desktop OpenGL and OpenGL ES 2 support can be switched using CMake TARGET_GLES option. All functionality not supported in ES is marked in documentation. If targetting OpenGL ES, GLES2/gl2.h is included instead of GLEW. Mesh class now uses VAOs only in desktop OpenGL, in ES the buffers are bound on each draw call.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Pass image as reference, not pointer to *Texture::set*Image(). Avoids some nullptr-related errors and leads to simpler implementation, as we need to only handle ImageReference and BufferImage types. All other Image classes are implicitly convertible to ImageReference and implicit conversion works only with references, not with pointers. The usage might be clumsy at this point, as Trade::*Importer classes return pointer to Trade::ImageData which then needs to be dereferenced. Hopefully introducing C++14's std::optional (or equivalent) might help solve that issue. Also removed "convenience" overloads for setting e.g. 2D subdata of 3D texture. The convenience overload doesn't cover all subdata cases (only XY plane, not YZ or XZ ones) and overly complicates the implementation. This can be done in the future in Image classes themselves.
13 years ago
template<> struct MAGNUM_EXPORT AbstractTexture::DataHelper<1> {
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
Strong typed texture targets. Only those targets which are meaningful for given dimension are available.
14 years ago
enum class Target: GLenum {
Texture1D = GL_TEXTURE_1D
};
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
#endif
Fixed wrong automagic texture target for 3D textures. While GL_TEXTURE_2D == GL_TEXTURE_1D + 1, GL_TEXTURE_3D is something absolutely different and cannot be computed like this. Now done via AbstractTexture::DataHelper, which is cleaner and better readable.
15 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static Math::Vector<1, GLint> imageSize(AbstractTexture& texture, GLenum target, GLint level);
Ability to retrieve texture image size in given mip level.
13 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void setWrapping(AbstractTexture& texture, const Array1D<Sampler::Wrapping>& wrapping);
Greatly simplified Texture::setWrapping(). Temporarily removed the check for not setting repeat wrap mode on rectangle textures.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void setStorage(AbstractTexture& texture, GLenum target, GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void setImage(AbstractTexture& texture, GLenum target, GLint level, TextureFormat internalFormat, const ImageReference1D& image);
static void setImage(AbstractTexture& texture, GLenum target, GLint level, TextureFormat internalFormat, BufferImage1D& image);
Added classes Image and BufferedImage. These classes are meant to be used in the same texture updating functions as Trade::ImageData due to static polymorphism. In addition to Trade::ImageData, which is read-only, these classes support updating the dimensions and data. Image2D and ImageBuffer2D can update the data also from framebuffer.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void setSubImage(AbstractTexture& texture, GLenum target, GLint level, const Math::Vector<1, GLint>& offset, const ImageReference1D& image);
static void setSubImage(AbstractTexture& texture, GLenum target, GLint level, const Math::Vector<1, GLint>& offset, BufferImage1D& image);
Implemented ARB_invalidate_subdata GL 4.3 extension. Framebuffer invalidation is also available in OpenGL ES 3.0 and ES 2.0 using EXT_discard_framebuffer extension.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void invalidateSubImage(AbstractTexture& texture, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLint>& size);
Fixed wrong automagic texture target for 3D textures. While GL_TEXTURE_2D == GL_TEXTURE_1D + 1, GL_TEXTURE_3D is something absolutely different and cannot be computed like this. Now done via AbstractTexture::DataHelper, which is cleaner and better readable.
15 years ago
};
Port to OpenGL ES 2. Desktop OpenGL and OpenGL ES 2 support can be switched using CMake TARGET_GLES option. All functionality not supported in ES is marked in documentation. If targetting OpenGL ES, GLES2/gl2.h is included instead of GLEW. Mesh class now uses VAOs only in desktop OpenGL, in ES the buffers are bound on each draw call.
14 years ago
#endif
Windows build fixes.
14 years ago
template<> struct MAGNUM_EXPORT AbstractTexture::DataHelper<2> {
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
Strong typed texture targets. Only those targets which are meaningful for given dimension are available.
14 years ago
enum class Target: GLenum {
Updated, documented and added missing texture targets. Nothing else except the target is done for multisample textures.
13 years ago
Texture2D = GL_TEXTURE_2D,
Port to OpenGL ES 2. Desktop OpenGL and OpenGL ES 2 support can be switched using CMake TARGET_GLES option. All functionality not supported in ES is marked in documentation. If targetting OpenGL ES, GLES2/gl2.h is included instead of GLEW. Mesh class now uses VAOs only in desktop OpenGL, in ES the buffers are bound on each draw call.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Updated, documented and added missing texture targets. Nothing else except the target is done for multisample textures.
13 years ago
Texture2DMultisample = GL_TEXTURE_2D_MULTISAMPLE,
Reworded array textures to be consistent with CubeMapTextureArray.
14 years ago
Texture1DArray = GL_TEXTURE_1D_ARRAY,
Fixed CubeMapTexture wrapping, simplified code of texture classes. Texture now doesn't have it's own redundant copy of target, but uses the one from AbstractTexture. Subsequently, all DataHelper functions now accept "untyped" GLenum as target for better flexibility. CubeMapTexture is not based on Texture2D anymore, all references to cube map textures were removed from Target enums, so it's now not possible to create cube map texture other way than using CubeMapTexture class, which is how it should be done in first place. The wrapping mode fix is thus now trivial.
14 years ago
Rectangle = GL_TEXTURE_RECTANGLE
Port to OpenGL ES 2. Desktop OpenGL and OpenGL ES 2 support can be switched using CMake TARGET_GLES option. All functionality not supported in ES is marked in documentation. If targetting OpenGL ES, GLES2/gl2.h is included instead of GLEW. Mesh class now uses VAOs only in desktop OpenGL, in ES the buffers are bound on each draw call.
14 years ago
#endif
Strong typed texture targets. Only those targets which are meaningful for given dimension are available.
14 years ago
};
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
#endif
Strong typed texture targets. Only those targets which are meaningful for given dimension are available.
14 years ago
Ability to retrieve texture image size in given mip level.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Get rid of pointers in internal texture implementation.
12 years ago
static Vector2i imageSize(AbstractTexture& texture, GLenum target, GLint level);
Ability to retrieve texture image size in given mip level.
13 years ago
#endif
Get rid of pointers in internal texture implementation.
12 years ago
static void setWrapping(AbstractTexture& texture, const Array2D<Sampler::Wrapping>& wrapping);
Greatly simplified Texture::setWrapping(). Temporarily removed the check for not setting repeat wrap mode on rectangle textures.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void setStorage(AbstractTexture& texture, GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector2i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
Added MultisampleTexture::setStorage(). With this function multisample texture implementation is pretty much done. Also implemented all the tests.
12 years ago
static void setStorageMultisample(AbstractTexture& texture, GLenum target, GLsizei samples, TextureFormat internalFormat, const Vector2i& size, GLboolean fixedSampleLocations);
Get rid of pointers in internal texture implementation.
12 years ago
static void setImage(AbstractTexture& texture, GLenum target, GLint level, TextureFormat internalFormat, const ImageReference2D& image);
Pass image as reference, not pointer to *Texture::set*Image(). Avoids some nullptr-related errors and leads to simpler implementation, as we need to only handle ImageReference and BufferImage types. All other Image classes are implicitly convertible to ImageReference and implicit conversion works only with references, not with pointers. The usage might be clumsy at this point, as Trade::*Importer classes return pointer to Trade::ImageData which then needs to be dereferenced. Hopefully introducing C++14's std::optional (or equivalent) might help solve that issue. Also removed "convenience" overloads for setting e.g. 2D subdata of 3D texture. The convenience overload doesn't cover all subdata cases (only XY plane, not YZ or XZ ones) and overly complicates the implementation. This can be done in the future in Image classes themselves.
13 years ago
#ifndef MAGNUM_TARGET_GLES2
Get rid of pointers in internal texture implementation.
12 years ago
static void setImage(AbstractTexture& texture, GLenum target, GLint level, TextureFormat internalFormat, BufferImage2D& image);
Pass image as reference, not pointer to *Texture::set*Image(). Avoids some nullptr-related errors and leads to simpler implementation, as we need to only handle ImageReference and BufferImage types. All other Image classes are implicitly convertible to ImageReference and implicit conversion works only with references, not with pointers. The usage might be clumsy at this point, as Trade::*Importer classes return pointer to Trade::ImageData which then needs to be dereferenced. Hopefully introducing C++14's std::optional (or equivalent) might help solve that issue. Also removed "convenience" overloads for setting e.g. 2D subdata of 3D texture. The convenience overload doesn't cover all subdata cases (only XY plane, not YZ or XZ ones) and overly complicates the implementation. This can be done in the future in Image classes themselves.
13 years ago
#endif
Ability to set texture subdata from image with one less dimensions. It is now possible to call Texture2D::setSubData() with 1D image and Texture3D::setSubData() with 2D image.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void setSubImage(AbstractTexture& texture, GLenum target, GLint level, const Vector2i& offset, const ImageReference2D& image);
Pass image as reference, not pointer to *Texture::set*Image(). Avoids some nullptr-related errors and leads to simpler implementation, as we need to only handle ImageReference and BufferImage types. All other Image classes are implicitly convertible to ImageReference and implicit conversion works only with references, not with pointers. The usage might be clumsy at this point, as Trade::*Importer classes return pointer to Trade::ImageData which then needs to be dereferenced. Hopefully introducing C++14's std::optional (or equivalent) might help solve that issue. Also removed "convenience" overloads for setting e.g. 2D subdata of 3D texture. The convenience overload doesn't cover all subdata cases (only XY plane, not YZ or XZ ones) and overly complicates the implementation. This can be done in the future in Image classes themselves.
13 years ago
#ifndef MAGNUM_TARGET_GLES2
Get rid of pointers in internal texture implementation.
12 years ago
static void setSubImage(AbstractTexture& texture, GLenum target, GLint level, const Vector2i& offset, BufferImage2D& image);
Pass image as reference, not pointer to *Texture::set*Image(). Avoids some nullptr-related errors and leads to simpler implementation, as we need to only handle ImageReference and BufferImage types. All other Image classes are implicitly convertible to ImageReference and implicit conversion works only with references, not with pointers. The usage might be clumsy at this point, as Trade::*Importer classes return pointer to Trade::ImageData which then needs to be dereferenced. Hopefully introducing C++14's std::optional (or equivalent) might help solve that issue. Also removed "convenience" overloads for setting e.g. 2D subdata of 3D texture. The convenience overload doesn't cover all subdata cases (only XY plane, not YZ or XZ ones) and overly complicates the implementation. This can be done in the future in Image classes themselves.
13 years ago
#endif
Implemented ARB_invalidate_subdata GL 4.3 extension. Framebuffer invalidation is also available in OpenGL ES 3.0 and ES 2.0 using EXT_discard_framebuffer extension.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void invalidateSubImage(AbstractTexture& texture, GLint level, const Vector2i& offset, const Vector2i& size);
Fixed wrong automagic texture target for 3D textures. While GL_TEXTURE_2D == GL_TEXTURE_1D + 1, GL_TEXTURE_3D is something absolutely different and cannot be computed like this. Now done via AbstractTexture::DataHelper, which is cleaner and better readable.
15 years ago
};
Windows build fixes.
14 years ago
template<> struct MAGNUM_EXPORT AbstractTexture::DataHelper<3> {
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
#ifdef MAGNUM_BUILD_DEPRECATED
Strong typed texture targets. Only those targets which are meaningful for given dimension are available.
14 years ago
enum class Target: GLenum {
Use OpenGL ES 2.0 specific definitions for extension-only functionality. If targetting explicitly OpenGL ES 2.0, only gl2.h is included (not gl3.h).
14 years ago
#ifndef MAGNUM_TARGET_GLES2
Strong typed texture targets. Only those targets which are meaningful for given dimension are available.
14 years ago
Texture3D = GL_TEXTURE_3D,
Updated, documented and added missing texture targets. Nothing else except the target is done for multisample textures.
13 years ago
Texture2DArray = GL_TEXTURE_2D_ARRAY,
#ifndef MAGNUM_TARGET_GLES
Fixed comma at the end of enumeration list.
13 years ago
Texture2DMultisampleArray = GL_TEXTURE_2D_MULTISAMPLE_ARRAY
Updated, documented and added missing texture targets. Nothing else except the target is done for multisample textures.
13 years ago
#endif
Use OpenGL ES 2.0 specific definitions for extension-only functionality. If targetting explicitly OpenGL ES 2.0, only gl2.h is included (not gl3.h).
14 years ago
#else
Texture3D = GL_TEXTURE_3D_OES
#endif
Strong typed texture targets. Only those targets which are meaningful for given dimension are available.
14 years ago
};
Split Texture into TextureArray, MultisampleTexture and RectangleTexture. Each texture has slightly different usage requirements and having everything under one generic class is not worth the additional runtime checks and whatnot. The current way with Texture::Target enum (hopefully not too widely used) is now deprecated and will be removed in some future release. However general Texture1D/2D/3D usage is not changed in any way.
12 years ago
#endif
Fixed wrong automagic texture target for 3D textures. While GL_TEXTURE_2D == GL_TEXTURE_1D + 1, GL_TEXTURE_3D is something absolutely different and cannot be computed like this. Now done via AbstractTexture::DataHelper, which is cleaner and better readable.
15 years ago
Ability to retrieve texture image size in given mip level.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Get rid of pointers in internal texture implementation.
12 years ago
static Vector3i imageSize(AbstractTexture& texture, GLenum target, GLint level);
Ability to retrieve texture image size in given mip level.
13 years ago
#endif
Get rid of pointers in internal texture implementation.
12 years ago
static void setWrapping(AbstractTexture& texture, const Array3D<Sampler::Wrapping>& wrapping);
Greatly simplified Texture::setWrapping(). Temporarily removed the check for not setting repeat wrap mode on rectangle textures.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void setStorage(AbstractTexture& texture, GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector3i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
Added MultisampleTexture::setStorage(). With this function multisample texture implementation is pretty much done. Also implemented all the tests.
12 years ago
static void setStorageMultisample(AbstractTexture& texture, GLenum target, GLsizei samples, TextureFormat internalFormat, const Vector3i& size, GLboolean fixedSampleLocations);
Get rid of pointers in internal texture implementation.
12 years ago
static void setImage(AbstractTexture& texture, GLenum target, GLint level, TextureFormat internalFormat, const ImageReference3D& image);
Pass image as reference, not pointer to *Texture::set*Image(). Avoids some nullptr-related errors and leads to simpler implementation, as we need to only handle ImageReference and BufferImage types. All other Image classes are implicitly convertible to ImageReference and implicit conversion works only with references, not with pointers. The usage might be clumsy at this point, as Trade::*Importer classes return pointer to Trade::ImageData which then needs to be dereferenced. Hopefully introducing C++14's std::optional (or equivalent) might help solve that issue. Also removed "convenience" overloads for setting e.g. 2D subdata of 3D texture. The convenience overload doesn't cover all subdata cases (only XY plane, not YZ or XZ ones) and overly complicates the implementation. This can be done in the future in Image classes themselves.
13 years ago
#ifndef MAGNUM_TARGET_GLES2
Get rid of pointers in internal texture implementation.
12 years ago
static void setImage(AbstractTexture& texture, GLenum target, GLint level, TextureFormat internalFormat, BufferImage3D& image);
Pass image as reference, not pointer to *Texture::set*Image(). Avoids some nullptr-related errors and leads to simpler implementation, as we need to only handle ImageReference and BufferImage types. All other Image classes are implicitly convertible to ImageReference and implicit conversion works only with references, not with pointers. The usage might be clumsy at this point, as Trade::*Importer classes return pointer to Trade::ImageData which then needs to be dereferenced. Hopefully introducing C++14's std::optional (or equivalent) might help solve that issue. Also removed "convenience" overloads for setting e.g. 2D subdata of 3D texture. The convenience overload doesn't cover all subdata cases (only XY plane, not YZ or XZ ones) and overly complicates the implementation. This can be done in the future in Image classes themselves.
13 years ago
#endif
Ability to set texture subdata from image with one less dimensions. It is now possible to call Texture2D::setSubData() with 1D image and Texture3D::setSubData() with 2D image.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void setSubImage(AbstractTexture& texture, GLenum target, GLint level, const Vector3i& offset, const ImageReference3D& image);
Pass image as reference, not pointer to *Texture::set*Image(). Avoids some nullptr-related errors and leads to simpler implementation, as we need to only handle ImageReference and BufferImage types. All other Image classes are implicitly convertible to ImageReference and implicit conversion works only with references, not with pointers. The usage might be clumsy at this point, as Trade::*Importer classes return pointer to Trade::ImageData which then needs to be dereferenced. Hopefully introducing C++14's std::optional (or equivalent) might help solve that issue. Also removed "convenience" overloads for setting e.g. 2D subdata of 3D texture. The convenience overload doesn't cover all subdata cases (only XY plane, not YZ or XZ ones) and overly complicates the implementation. This can be done in the future in Image classes themselves.
13 years ago
#ifndef MAGNUM_TARGET_GLES2
Get rid of pointers in internal texture implementation.
12 years ago
static void setSubImage(AbstractTexture& texture, GLenum target, GLint level, const Vector3i& offset, BufferImage3D& image);
Pass image as reference, not pointer to *Texture::set*Image(). Avoids some nullptr-related errors and leads to simpler implementation, as we need to only handle ImageReference and BufferImage types. All other Image classes are implicitly convertible to ImageReference and implicit conversion works only with references, not with pointers. The usage might be clumsy at this point, as Trade::*Importer classes return pointer to Trade::ImageData which then needs to be dereferenced. Hopefully introducing C++14's std::optional (or equivalent) might help solve that issue. Also removed "convenience" overloads for setting e.g. 2D subdata of 3D texture. The convenience overload doesn't cover all subdata cases (only XY plane, not YZ or XZ ones) and overly complicates the implementation. This can be done in the future in Image classes themselves.
13 years ago
#endif
Implemented ARB_invalidate_subdata GL 4.3 extension. Framebuffer invalidation is also available in OpenGL ES 3.0 and ES 2.0 using EXT_discard_framebuffer extension.
14 years ago
Get rid of pointers in internal texture implementation.
12 years ago
static void invalidateSubImage(AbstractTexture& texture, GLint level, const Vector3i& offset, const Vector3i& size);
Fixed wrong automagic texture target for 3D textures. While GL_TEXTURE_2D == GL_TEXTURE_1D + 1, GL_TEXTURE_3D is something absolutely different and cannot be computed like this. Now done via AbstractTexture::DataHelper, which is cleaner and better readable.
15 years ago
};
#endif
Simplified and tested Texture move constructor/assignment. Move constructor and move assignment is now noexcept and it just swaps the data of the two instances instead of calling GL API, thus it can be inline. Also removed unneded limitations in BufferTexture.
13 years ago
inline AbstractTexture::AbstractTexture(AbstractTexture&& other) noexcept: _target(other._target), _id(other._id) {
other._id = 0;
}
inline AbstractTexture& AbstractTexture::operator=(AbstractTexture&& other) noexcept {
std::swap(_target, other._target);
std::swap(_id, other._id);
return *this;
}
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
}
#endif