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

650 lines
32 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.
Oh, it's 2015 already.
11 years ago
Copyright © 2010, 2011, 2012, 2013, 2014, 2015
Happy new year too.
12 years ago
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
*/
Allocation-free overloads for *::setLabel(). In most cases the label is set directly from code, e.g.: texture.setLabel("diffuse-duck"); Avoiding conversion to std::string and passing char(&)[size] directly will avoid one allocation and deallocation. Better solution would be to use std::string_view everywhere, but we're not in C++17 yet.
12 years ago
#include <Corrade/Containers/Array.h>
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/AbstractObject.h"
Support for ARB_get_texture_sub_image. Only thing missing are compressed texture queries, but that needs a lot more work.
11 years ago
#include "Magnum/DimensionTraits.h"
#include "Magnum/Sampler.h"
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
namespace Magnum {
Implemented ARB_texture_swizzle.
12 years ago
namespace Implementation {
struct TextureState;
#ifndef MAGNUM_TARGET_GLES2
template<char> struct TextureSwizzle;
template<> struct TextureSwizzle<'r'> { enum: GLint { Value = GL_RED }; };
template<> struct TextureSwizzle<'g'> { enum: GLint { Value = GL_GREEN }; };
template<> struct TextureSwizzle<'b'> { enum: GLint { Value = GL_BLUE }; };
template<> struct TextureSwizzle<'a'> { enum: GLint { Value = GL_ALPHA }; };
template<> struct TextureSwizzle<'0'> { enum: GLint { Value = GL_ZERO }; };
template<> struct TextureSwizzle<'1'> { enum: GLint { Value = GL_ONE }; };
#endif
}
Moved global data from texture classes to per-context state.
12 years ago
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: make section headers in class/function docs have sane size. Similar reasoning as in mosra/corrade@93b8308bc6a4def9d4564a6cea236cabe54fe063.
12 years ago
## WebGL restrictions
doc: document all WebGL restrictions.
12 years ago
@ref MAGNUM_TARGET_WEBGL "WebGL" puts some restrictions on type of data
submitted to @ref Texture::setSubImage() "*Texture::setSubImage()", see its
documentation for details.
doc: make section headers in class/function docs have sane size. Similar reasoning as in mosra/corrade@93b8308bc6a4def9d4564a6cea236cabe54fe063.
12 years ago
@anchor 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}.
Removed autolink-preventing % noise and unneeded HTML from root namespace.
12 years ago
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
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
If on desktop GL and @extension{ARB,direct_state_access} (part of OpenGL 4.5)
is available, @ref bind(Int) and @ref unbind(Int) use @fn_gl{BindTextureUnit}.
Otherwise, if @extension{ARB,multi_bind} (part of OpenGL 4.4) is available,
@ref bind(Int) and @ref unbind() uses @fn_gl{BindTextures}. Lastly, if
@extension{EXT,direct_state_access} is available, @fn_gl_extension{BindNamedTexture,EXT,direct_state_access}
function is used to avoid unnecessary calls to @fn_gl{ActiveTexture}.
In addition, if either @extension{ARB,direct_state_access} (part of OpenGL 4.5)
or @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.
If @extension{ARB,multi_bind} (part of OpenGL 4.5) is available,
@ref bind(Int, std::initializer_list<AbstractTexture*>) and @ref unbind(Int, std::size_t)
use @fn_gl{BindTextures} to avoid unnecessary calls to @fn_gl{ActiveTexture}.
Otherwise the feature is emulated with sequence of @ref bind(Int)/@ref unbind(Int)
calls.
If either @extension{ARB,direct_state_access} or @extension{ARB,robustness} is
available, image reading operations (such as @ref Texture::image()) are
protected from buffer overflow. However, if @extension{ARB,direct_state_access}
is not available and both @extension{EXT,direct_state_access} and
@extension{ARB,robustness} are available, the robust version is preferred over
DSA.
Ability to retrieve texture images.
13 years ago
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})
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 {
No need to use class/struct keyword in friend declarations.
12 years ago
friend Implementation::TextureState;
friend CubeMapTexture;
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}
Removed autolink-preventing % noise and unneeded HTML from root namespace.
12 years ago
* @requires_gles30 Texture LOD bias doesn't have
Implemented texture LOD parameters.
12 years ago
* implementation-defined range in OpenGL ES 2.0.
*/
static Float maxLodBias();
#endif
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
/**
* @brief Max supported color sample count
*
* The result is cached, repeated queries don't result in repeated
Enabled multisample texture limit queries in ES 3.1.
12 years ago
* OpenGL calls. If neither extension @extension{ARB,texture_multisample}
* (part of OpenGL 3.2) nor OpenGL ES 3.1 is available, returns `0`.
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
* @see @fn_gl{Get} with @def_gl{MAX_COLOR_TEXTURE_SAMPLES}
Enabled multisample texture limit queries in ES 3.1.
12 years ago
* @requires_gles30 Not defined in OpenGL ES 2.0
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
*/
static Int maxColorSamples();
/**
* @brief Max supported depth sample count
*
* The result is cached, repeated queries don't result in repeated
Enabled multisample texture limit queries in ES 3.1.
12 years ago
* OpenGL calls. If neither extension @extension{ARB,texture_multisample}
* (part of OpenGL 3.2) nor OpenGL ES 3.1 is available, returns `0`.
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
* @see @fn_gl{Get} with @def_gl{MAX_DEPTH_TEXTURE_SAMPLES}
Enabled multisample texture limit queries in ES 3.1.
12 years ago
* @requires_gles30 Not defined in OpenGL ES 2.0
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
*/
static Int maxDepthSamples();
/**
* @brief Max supported integer sample count
*
* The result is cached, repeated queries don't result in repeated
Enabled multisample texture limit queries in ES 3.1.
12 years ago
* OpenGL calls. If neither extension @extension{ARB,texture_multisample}
* (part of OpenGL 3.2) nor OpenGL ES 3.1 is available, returns `0`.
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
* @see @fn_gl{Get} with @def_gl{MAX_INTEGER_SAMPLES}
Enabled multisample texture limit queries in ES 3.1.
12 years ago
* @requires_gles30 Not defined in OpenGL ES 2.0
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
*/
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
*
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
* If on OpenGL ES or neither @extension{ARB,direct_state_access} (part
* of OpenGL 4.5), @extension{ARB,multi_bind} (part of OpenGL 4.4) nor
* @extension{EXT,direct_state_access} is available, the texture unit
* is made active before unbinding the texture.
Added *Texture::unbind(). Will be used in fallback implementation of multi-bind.
12 years ago
* @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(),
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
* @fn_gl{BindTextureUnit}, @fn_gl{BindTextures},
* @fn_gl_extension{BindMultiTexture,EXT,direct_state_access},
* eventually @fn_gl{ActiveTexture} and @fn_gl{BindTexture}
Added *Texture::unbind(). Will be used in fallback implementation of multi-bind.
12 years ago
*/
static void unbind(Int textureUnit);
Added multi-unbind function to AbstractTexture. More efficient (no allocation) and also more convenient than calling e.g. unbind(7, {nullptr, nullptr, nullptr}).
12 years ago
/**
* @brief Unbind textures in given range of texture units
*
* Unbinds all texture in the range @f$ [ firstTextureUnit ; firstTextureUnit + count ) @f$.
* If @extension{ARB,multi_bind} (part of OpenGL 4.4) is not available,
* the feature is emulated with sequence of @ref unbind(Int) calls.
* @note This function is meant to be used only internally from
* @ref AbstractShaderProgram subclasses. See its documentation
* for more information.
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
* @see @ref Shader::maxCombinedTextureImageUnits(), @fn_gl{BindTextures}
Added multi-unbind function to AbstractTexture. More efficient (no allocation) and also more convenient than calling e.g. unbind(7, {nullptr, nullptr, nullptr}).
12 years ago
*/
static void unbind(Int firstTextureUnit, std::size_t count);
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
Added multi-unbind function to AbstractTexture. More efficient (no allocation) and also more convenient than calling e.g. unbind(7, {nullptr, nullptr, nullptr}).
12 years ago
* of @ref bind(Int) / @ref unbind(Int) calls.
Doc++, minor cleanup.
12 years ago
* @note This function is meant to be used only internally from
* @ref AbstractShaderProgram subclasses. See its documentation
* for more information.
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
* @see @ref Shader::maxCombinedTextureImageUnits(), @fn_gl{BindTextures}
Support ARB_multi_bind for textures.
12 years ago
*/
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
/**
Removed autolink-preventing % noise and unneeded HTML from root namespace.
12 years ago
* @brief Texture label
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
*
* 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}
*/
Ensure that texture object is properly created before using it. As glGen*() only reserves object name without creating it, it must be ensured that the object is created before calling functions which expect already created object (such as glObjectLabel() or glBindTextures()). Allows me to remove quite a lot hacks in the tests.
12 years ago
std::string label();
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 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}
*/
Allocation-free overloads for *::setLabel(). In most cases the label is set directly from code, e.g.: texture.setLabel("diffuse-duck"); Avoiding conversion to std::string and passing char(&)[size] directly will avoid one allocation and deallocation. Better solution would be to use std::string_view everywhere, but we're not in C++17 yet.
12 years ago
AbstractTexture& setLabel(const std::string& label) {
return setLabelInternal({label.data(), label.size()});
}
/** @overload */
template<std::size_t size> AbstractTexture& setLabel(const char(&label)[size]) {
Fix off-by-one errors when converting const char[] to string. The AbstractShaderProgramGLTest now passes again.
11 years ago
return setLabelInternal({label, size - 1});
Allocation-free overloads for *::setLabel(). In most cases the label is set directly from code, e.g.: texture.setLabel("diffuse-duck"); Avoiding conversion to std::string and passing char(&)[size] directly will avoid one allocation and deallocation. Better solution would be to use std::string_view everywhere, but we're not in C++17 yet.
12 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
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
*
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
* If on OpenGL ES or neither @extension{ARB,direct_state_access} (part
* of OpenGL 4.5), @extension{ARB,multi_bind} (part of OpenGL 4.4) nor
* @extension{EXT,direct_state_access} is 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(),
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
* @fn_gl{BindTextureUnit}, @fn_gl{BindTextures},
* @fn_gl_extension{BindMultiTexture,EXT,direct_state_access},
* eventually @fn_gl{ActiveTexture} and @fn_gl{BindTexture}
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);
Allocation-free overloads for *::setLabel(). In most cases the label is set directly from code, e.g.: texture.setLabel("diffuse-duck"); Avoiding conversion to std::string and passing char(&)[size] directly will avoid one allocation and deallocation. Better solution would be to use std::string_view everywhere, but we're not in C++17 yet.
12 years ago
AbstractTexture& setLabelInternal(Containers::ArrayReference<const char> label);
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);
Support for EXT_texture_sRGB_decode.
12 years ago
void setSRGBDecode(bool decode);
Implemented ARB_texture_swizzle.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
template<char r, char g, char b, char a> void setSwizzle() {
setSwizzleInternal(Implementation::TextureSwizzle<r>::Value,
Implementation::TextureSwizzle<g>::Value,
Implementation::TextureSwizzle<b>::Value,
Implementation::TextureSwizzle<a>::Value);
}
void setSwizzleInternal(GLint r, GLint g, GLint b, GLint a);
#endif
Implemented depth texture compare mode and function.
12 years ago
void setCompareMode(Sampler::CompareMode mode);
void setCompareFunction(Sampler::CompareFunction function);
Enabled stencil texturing in ES 3.1.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
Implementation of ARB_stencil_texturing.
12 years ago
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
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
template<UnsignedInt dimensions> void image(GLint level, Image<dimensions>& image);
template<UnsignedInt dimensions> void image(GLint level, BufferImage<dimensions>& image, BufferUsage usage);
Support for ARB_get_texture_sub_image. Only thing missing are compressed texture queries, but that needs a lot more work.
11 years ago
template<UnsignedInt dimensions> void subImage(GLint level, const RangeTypeFor<dimensions, Int>& range, Image<dimensions>& image);
template<UnsignedInt dimensions> void subImage(GLint level, const RangeTypeFor<dimensions, Int>& range, 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);
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
static void MAGNUM_LOCAL unbindImplementationDSA(GLint textureUnit);
Preparation for ARB_direct_state_access GL 4.5 feature. Renamed all EXT_direct_state_access implementations to reflect the fact that these aren't using the ARB extension.
12 years ago
static void MAGNUM_LOCAL unbindImplementationDSAEXT(GLint textureUnit);
Added *Texture::unbind(). Will be used in fallback implementation of multi-bind.
12 years ago
#endif
Added multi-unbind function to AbstractTexture. More efficient (no allocation) and also more convenient than calling e.g. unbind(7, {nullptr, nullptr, nullptr}).
12 years ago
static void MAGNUM_LOCAL bindImplementationFallback(GLint firstTextureUnit, Containers::ArrayReference<AbstractTexture* const> textures);
Support ARB_multi_bind for textures.
12 years ago
#ifndef MAGNUM_TARGET_GLES
Added multi-unbind function to AbstractTexture. More efficient (no allocation) and also more convenient than calling e.g. unbind(7, {nullptr, nullptr, nullptr}).
12 years ago
static void MAGNUM_LOCAL bindImplementationMulti(GLint firstTextureUnit, Containers::ArrayReference<AbstractTexture* const> textures);
Support ARB_multi_bind for textures.
12 years ago
#endif
ARB_direct_state_access support for creating textures.
12 years ago
void MAGNUM_LOCAL createImplementationDefault();
#ifndef MAGNUM_TARGET_GLES
void MAGNUM_LOCAL createImplementationDSA();
#endif
Ensure that texture object is properly created before using it. As glGen*() only reserves object name without creating it, it must be ensured that the object is created before calling functions which expect already created object (such as glObjectLabel() or glBindTextures()). Allows me to remove quite a lot hacks in the tests.
12 years ago
void MAGNUM_LOCAL createIfNotAlready();
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);
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
void MAGNUM_LOCAL bindImplementationDSA(GLint textureUnit);
Preparation for ARB_direct_state_access GL 4.5 feature. Renamed all EXT_direct_state_access implementations to reflect the fact that these aren't using the ARB extension.
12 years ago
void MAGNUM_LOCAL bindImplementationDSAEXT(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);
Implemented ARB_texture_swizzle.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
void MAGNUM_LOCAL parameterImplementationDefault(GLenum parameter, const GLint* values);
#endif
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
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
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, GLint value);
Preparation for ARB_direct_state_access GL 4.5 feature. Renamed all EXT_direct_state_access implementations to reflect the fact that these aren't using the ARB extension.
12 years ago
void MAGNUM_LOCAL parameterImplementationDSAEXT(GLenum parameter, GLint value);
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
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, GLfloat value);
Preparation for ARB_direct_state_access GL 4.5 feature. Renamed all EXT_direct_state_access implementations to reflect the fact that these aren't using the ARB extension.
12 years ago
void MAGNUM_LOCAL parameterImplementationDSAEXT(GLenum parameter, GLfloat value);
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
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, const GLint* values);
Preparation for ARB_direct_state_access GL 4.5 feature. Renamed all EXT_direct_state_access implementations to reflect the fact that these aren't using the ARB extension.
12 years ago
void MAGNUM_LOCAL parameterImplementationDSAEXT(GLenum parameter, const GLint* values);
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
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, const GLfloat* values);
Preparation for ARB_direct_state_access GL 4.5 feature. Renamed all EXT_direct_state_access implementations to reflect the fact that these aren't using the ARB extension.
12 years ago
void MAGNUM_LOCAL parameterImplementationDSAEXT(GLenum parameter, const GLfloat* values);
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
void MAGNUM_LOCAL parameterIImplementationDSA(GLenum parameter, const GLuint* values);
Preparation for ARB_direct_state_access GL 4.5 feature. Renamed all EXT_direct_state_access implementations to reflect the fact that these aren't using the ARB extension.
12 years ago
void MAGNUM_LOCAL parameterIImplementationDSAEXT(GLenum parameter, const GLuint* values);
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
void MAGNUM_LOCAL parameterIImplementationDSA(GLenum parameter, const GLint* values);
Preparation for ARB_direct_state_access GL 4.5 feature. Renamed all EXT_direct_state_access implementations to reflect the fact that these aren't using the ARB extension.
12 years ago
void MAGNUM_LOCAL parameterIImplementationDSAEXT(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);
Enabled texture image size queries in ES 3.1.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
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
void MAGNUM_LOCAL getLevelParameterImplementationDefault(GLint level, GLenum parameter, GLint* values);
Enabled texture image size queries in ES 3.1.
12 years ago
#ifndef MAGNUM_TARGET_GLES
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
void MAGNUM_LOCAL getLevelParameterImplementationDSA(GLint level, GLenum parameter, GLint* values);
void MAGNUM_LOCAL getLevelParameterImplementationDSAEXT(GLint level, GLenum parameter, GLint* values);
Implementation for texture level parameter query.
13 years ago
#endif
Enabled texture image size queries in ES 3.1.
12 years ago
#endif
Implementation for texture level parameter query.
13 years ago
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
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
void MAGNUM_LOCAL mipmapImplementationDSA();
Preparation for ARB_direct_state_access GL 4.5 feature. Renamed all EXT_direct_state_access implementations to reflect the fact that these aren't using the ARB extension.
12 years ago
void MAGNUM_LOCAL mipmapImplementationDSAEXT();
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
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
void MAGNUM_LOCAL storageImplementationFallback(GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
void MAGNUM_LOCAL storageImplementationDefault(GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
void MAGNUM_LOCAL storageImplementationDSA(GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
void MAGNUM_LOCAL storageImplementationDSAEXT(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
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
void MAGNUM_LOCAL storageImplementationFallback(GLsizei levels, TextureFormat internalFormat, const Vector2i& size);
void MAGNUM_LOCAL storageImplementationDefault(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
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
void MAGNUM_LOCAL storageImplementationDSA(GLsizei levels, TextureFormat internalFormat, const Vector2i& size);
void MAGNUM_LOCAL storageImplementationDSAEXT(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
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
void MAGNUM_LOCAL storageImplementationFallback(GLsizei levels, TextureFormat internalFormat, const Vector3i& size);
void MAGNUM_LOCAL storageImplementationDefault(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
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
void MAGNUM_LOCAL storageImplementationDSA(GLsizei levels, TextureFormat internalFormat, const Vector3i& size);
void MAGNUM_LOCAL storageImplementationDSAEXT(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
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
void MAGNUM_LOCAL storageMultisampleImplementationFallback(GLsizei samples, TextureFormat internalFormat, const Vector2i& size, GLboolean fixedsamplelocations);
Enabled 2D multisample textures in ES 3.1.
12 years ago
#endif
#ifndef MAGNUM_TARGET_GLES2
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
void MAGNUM_LOCAL storageMultisampleImplementationDefault(GLsizei samples, TextureFormat internalFormat, const Vector2i& size, GLboolean fixedsamplelocations);
Enabled 2D multisample textures in ES 3.1.
12 years ago
#endif
#ifndef MAGNUM_TARGET_GLES
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
void MAGNUM_LOCAL storageMultisampleImplementationDSA(GLsizei samples, TextureFormat internalFormat, const Vector2i& size, GLboolean fixedsamplelocations);
void MAGNUM_LOCAL storageMultisampleImplementationDSAEXT(GLsizei samples, TextureFormat internalFormat, const Vector2i& size, GLboolean fixedsamplelocations);
Enabled 2D multisample textures in ES 3.1.
12 years ago
#endif
Added MultisampleTexture::setStorage(). With this function multisample texture implementation is pretty much done. Also implemented all the tests.
12 years ago
Enabled 2D multisample textures in ES 3.1.
12 years ago
#ifndef MAGNUM_TARGET_GLES
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
void MAGNUM_LOCAL storageMultisampleImplementationFallback(GLsizei samples, TextureFormat internalFormat, const Vector3i& size, GLboolean fixedsamplelocations);
void MAGNUM_LOCAL storageMultisampleImplementationDefault(GLsizei samples, TextureFormat internalFormat, const Vector3i& size, GLboolean fixedsamplelocations);
void MAGNUM_LOCAL storageMultisampleImplementationDSA(GLsizei samples, TextureFormat internalFormat, const Vector3i& size, GLboolean fixedsamplelocations);
void MAGNUM_LOCAL storageMultisampleImplementationDSAEXT(GLsizei samples, TextureFormat internalFormat, const Vector3i& size, GLboolean fixedsamplelocations);
Added MultisampleTexture::setStorage(). With this function multisample texture implementation is pretty much done. Also implemented all the tests.
12 years ago
#endif
Ability to retrieve texture images.
13 years ago
#ifndef MAGNUM_TARGET_GLES
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
void MAGNUM_LOCAL getImageImplementationDefault(GLint level, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationDSA(GLint level, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationDSAEXT(GLint level, ColorFormat format, ColorType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationRobustness(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
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
void MAGNUM_LOCAL subImageImplementationDefault(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(GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, ColorFormat format, ColorType type, const GLvoid* data);
void MAGNUM_LOCAL subImageImplementationDSAEXT(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
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
void MAGNUM_LOCAL subImageImplementationDefault(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
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
void MAGNUM_LOCAL subImageImplementationDSA(GLint level, const Vector2i& offset, const Vector2i& size, ColorFormat format, ColorType type, const GLvoid* data);
void MAGNUM_LOCAL subImageImplementationDSAEXT(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
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
void MAGNUM_LOCAL subImageImplementationDefault(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
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
void MAGNUM_LOCAL subImageImplementationDSA(GLint level, const Vector3i& offset, const Vector3i& size, ColorFormat format, ColorType type, const GLvoid* data);
void MAGNUM_LOCAL subImageImplementationDSAEXT(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;
Ensure that texture object is properly created before using it. As glGen*() only reserves object name without creating it, it must be ensured that the object is created before calling functions which expect already created object (such as glObjectLabel() or glBindTextures()). Allows me to remove quite a lot hacks in the tests.
12 years ago
bool _created; /* see createIfNotAlready() for details */
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
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
static Math::Vector<1, GLint> imageSize(AbstractTexture& texture, 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
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
static void setStorage(AbstractTexture& texture, 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
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
static void setImage(AbstractTexture& texture, GLint level, TextureFormat internalFormat, const ImageReference1D& image);
static void setImage(AbstractTexture& texture, 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
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
static void setSubImage(AbstractTexture& texture, GLint level, const Math::Vector<1, GLint>& offset, const ImageReference1D& image);
static void setSubImage(AbstractTexture& texture, 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
Enabled texture image size queries in ES 3.1.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
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
static Vector2i imageSize(AbstractTexture& texture, 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
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
static void setStorage(AbstractTexture& texture, 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
Enabled 2D multisample textures in ES 3.1.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
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
static void setStorageMultisample(AbstractTexture& texture, GLsizei samples, TextureFormat internalFormat, const Vector2i& size, GLboolean fixedSampleLocations);
Enabled 2D multisample textures in ES 3.1.
12 years ago
#endif
Added MultisampleTexture::setStorage(). With this function multisample texture implementation is pretty much done. Also implemented all the tests.
12 years ago
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
static void setImage(AbstractTexture& texture, GLint level, TextureFormat internalFormat, const ImageReference2D& image) {
setImage(texture, texture._target, level, internalFormat, image);
}
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
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
static void setImage(AbstractTexture& texture, GLint level, TextureFormat internalFormat, BufferImage2D& image) {
setImage(texture, texture._target, level, internalFormat, image);
}
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
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
static void setSubImage(AbstractTexture& texture, 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
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
static void setSubImage(AbstractTexture& texture, 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
Enabled texture image size queries in ES 3.1.
12 years ago
#ifndef MAGNUM_TARGET_GLES2
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
static Vector3i imageSize(AbstractTexture& texture, 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
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
static void setStorage(AbstractTexture& texture, 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
Enabled 2D multisample textures in ES 3.1.
12 years ago
#ifndef MAGNUM_TARGET_GLES
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
static void setStorageMultisample(AbstractTexture& texture, GLsizei samples, TextureFormat internalFormat, const Vector3i& size, GLboolean fixedSampleLocations);
Enabled 2D multisample textures in ES 3.1.
12 years ago
#endif
Added MultisampleTexture::setStorage(). With this function multisample texture implementation is pretty much done. Also implemented all the tests.
12 years ago
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
static void setImage(AbstractTexture& texture, 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
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
static void setImage(AbstractTexture& texture, 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
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
static void setSubImage(AbstractTexture& texture, 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
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
static void setSubImage(AbstractTexture& texture, 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
Ensure that texture object is properly created before using it. As glGen*() only reserves object name without creating it, it must be ensured that the object is created before calling functions which expect already created object (such as glObjectLabel() or glBindTextures()). Allows me to remove quite a lot hacks in the tests.
12 years ago
inline AbstractTexture::AbstractTexture(AbstractTexture&& other) noexcept: _target{other._target}, _id{other._id}, _created{other._created} {
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
other._id = 0;
}
inline AbstractTexture& AbstractTexture::operator=(AbstractTexture&& other) noexcept {
std::swap(_target, other._target);
std::swap(_id, other._id);
Ensure that texture object is properly created before using it. As glGen*() only reserves object name without creating it, it must be ensured that the object is created before calling functions which expect already created object (such as glObjectLabel() or glBindTextures()). Allows me to remove quite a lot hacks in the tests.
12 years ago
std::swap(_created, other._created);
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
return *this;
}
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
}
#endif