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

554 lines
29 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.
Relicensing to MIT/Expat license, part 2: headers.
13 years ago
Copyright © 2010, 2011, 2012, 2013 Vladimír Vondruš <mosra@centrum.cz>
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
* @brief Class Magnum::AbstractTexture
*/
Using Array instead of Vector for *Texture::setWrapping(). Allows simple and convenient call with one value for all axes instead of that unholy mess: texture.setWrapping(Texture2D::Wrapping::ClampToEdge); Previous way (for entertainment purposes): textute.setWrapping(Math::Vector2<Texture2D::Wrapping>( Texture2D::Wrapping::ClampToEdge));
14 years ago
#include "Array.h"
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
#ifndef MAGNUM_TARGET_GLES2
#include "Buffer.h"
#endif
Added Color3 and Color4 classes with HSV conversion. They can be used for both floating-point (normalized) and integral (denormalized) representation and support conversion between them. HSV conversion is done always using floating-point types. Getters for RGB(A) were removed from Vector3 and Vector4, they are now part of Color3 and Color4. Because of this, Framebuffer now accepts Color instead of Vector.
14 years ago
#include "Color.h"
Moved sampler state enums into new Sampler class. Solves another trivial choice (similar to the one with TextureFormat etc. in 7de45c98b1aea3ecd530b819d9649d5f5a4628e5), less typing and also preparation for ARB_sampler_objects extension.
13 years ago
#include "Sampler.h"
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
namespace Magnum {
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
Cube map texture array.
14 years ago
See Texture, CubeMapTexture and CubeMapTextureArray documentation for more
Documentation and example usage of textures. Mentions some not-yet-done features such as Vector2i or proper texture formats.
14 years ago
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
Ability to retrieve texture images.
13 years ago
@section AbstractTexture-performance-optimization Performance optimizations and security
Documentation and example usage of textures. Mentions some not-yet-done features such as Vector2i or proper texture formats.
14 years ago
Tracking texture state - bindings and limits.
14 years ago
The engine tracks currently bound textures in all available layers to avoid
unnecessary calls to @fn_gl{ActiveTexture} and @fn_gl{BindTexture}. %Texture
configuration functions use dedicated highest available texture layer to not
affect active bindings in user layers. %Texture limits (such as
maxSupportedLayerCount()) are cached, so repeated queries don't result in
repeated @fn_gl{Get} calls.
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
If extension @extension{EXT,direct_state_access} is available, bind() uses DSA
function to avoid unnecessary calls to @fn_gl{ActiveTexture}. Also all texture
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
configuration and data updating functions use DSA functions to avoid
unnecessary calls to @fn_gl{ActiveTexture} and @fn_gl{BindTexture}. See
respective function documentation for more information.
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
Ability to retrieve texture images.
13 years ago
If extension @extension{ARB,robustness} is available, image reading operations
(such as Texture::image()) are protected from buffer overflow. However, if both
@extension{EXT,direct_state_access} and @extension{ARB,robustness} are
available, the DSA version is used, because it is better for performance and
there isn't any function combining both features.
Tracking texture state - bindings and limits.
14 years ago
To achieve least state changes, fully configure each texture in one run --
method chaining comes in handy -- and try to have often used textures in
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
dedicated layers, not occupied by other textures. First configure the texture
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.
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
You can use functions invalidateImage() and @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 @extension{ARB,invalidate_subdata} is not available, these functions
do nothing.
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
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*/
Added dllimport/dllexport macros for Windows builds.
14 years ago
class MAGNUM_EXPORT AbstractTexture {
Tracking texture state - bindings and limits.
14 years ago
friend class Context;
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
public:
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
/**
* @brief Max supported layer count
*
Doc++, minor cleanup.
14 years ago
* The result is cached, repeated queries don't result in repeated
* OpenGL calls.
Using new type aliases in whole root Magnum namespace.
13 years ago
* @see @ref AbstractShaderProgram-subclassing, bind(Int),
Doc++, minor cleanup.
14 years ago
* @fn_gl{Get} with @def_gl{MAX_COMBINED_TEXTURE_IMAGE_UNITS},
Tracking texture state - bindings and limits.
14 years ago
* @fn_gl{ActiveTexture}
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
*/
Using new type aliases in whole root Magnum namespace.
13 years ago
static Int maxSupportedLayerCount();
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
Doc++ Not using @copydoc for Texture derivatives but linking manually instead. It looks better and doesn't have mixed up irrelevant information.
14 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
explicit AbstractTexture(GLenum target): _target(target) {
Refactoring of internal OpenGL object names.
14 years ago
glGenTextures(1, &_id);
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
}
Doc++ Not using @copydoc for Texture derivatives but linking manually instead. It looks better and doesn't have mixed up irrelevant information.
14 years ago
#endif
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
/**
* @brief Destructor
*
* Deletes assigned OpenGL texture.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{DeleteTextures}
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*/
Disable instantiation of all Abstract* classes. For classes which already have pure virtual functions instantiation is not allowed, but for other there needs to be at least one pure virtual method: the destructor. Pure virtual functions actually can have implementations, but they must be called explicitly. Destructors are called explicitly, so for them it works.
14 years ago
virtual ~AbstractTexture() = 0;
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
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(const AbstractTexture&) = delete;
Move constructor and move assignment for textures.
14 years ago
/** @brief Move constructor */
AbstractTexture(AbstractTexture&& other);
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 */
AbstractTexture& operator=(AbstractTexture&& other);
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
/**
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
* @brief Bind texture for rendering
Doc++
14 years ago
*
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
* Sets current texture as active in given layer. The layer must be
* between 0 and maxSupportedLayerCount(). Note that only one texture
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
* can be bound to given layer. If @extension{EXT,direct_state_access}
* is not available, the layer is made active before binding the
* texture.
* @see @fn_gl{ActiveTexture}, @fn_gl{BindTexture} or
* @fn_gl_extension{BindMultiTexture,EXT,direct_state_access}
Doc++
14 years ago
*/
Using new type aliases in whole root Magnum namespace.
13 years ago
void bind(Int layer);
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
/**
* @brief Set minification filter
* @param filter Filter
* @param mipmap Mipmap filtering. If set to anything else than
* BaseMipLevel, make sure textures for all mip levels are set or
* call generateMipmap().
Method chaining for textures.
14 years ago
* @return Pointer to self (for method chaining)
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*
* Sets filter used when the object pixel size is smaller than the
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
* texture size. If @extension{EXT,direct_state_access} is not
* available, the texture is bound to some layer before the operation.
Moved sampler state enums into new Sampler class. Solves another trivial choice (similar to the one with TextureFormat etc. in 7de45c98b1aea3ecd530b819d9649d5f5a4628e5), less typing and also preparation for ARB_sampler_objects extension.
13 years ago
* Initial value is (@ref Sampler::Filter "Sampler::Filter::Nearest",
* @ref Sampler::Mipmap "Sampler::Mipmap::Linear").
Rectangle texture safety guards, doc++ * Added asserts for unsupported mipmap and wrapping modes instead of previous blind behavior, moved more-than-one-liner functions into *.cpp * Updated documentation to reflect the rectangle texture inabilities to user, changed "unusable" to "incomplete" to be consistent with OpenGL terminology. * Removed some unneeded rows in documentation.
14 years ago
* @attention For rectangle textures only some modes are supported,
Moved sampler state enums into new Sampler class. Solves another trivial choice (similar to the one with TextureFormat etc. in 7de45c98b1aea3ecd530b819d9649d5f5a4628e5), less typing and also preparation for ARB_sampler_objects extension.
13 years ago
* see @ref Sampler::Filter "Sampler::Filter" and @ref Sampler::Mipmap "Sampler::Mipmap"
* documentation for more information.
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
* @see @fn_gl{ActiveTexture}, @fn_gl{BindTexture} and @fn_gl{TexParameter}
* or @fn_gl_extension{TextureParameter,EXT,direct_state_access}
* with @def_gl{TEXTURE_MIN_FILTER}
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*/
Moved sampler state enums into new Sampler class. Solves another trivial choice (similar to the one with TextureFormat etc. in 7de45c98b1aea3ecd530b819d9649d5f5a4628e5), less typing and also preparation for ARB_sampler_objects extension.
13 years ago
AbstractTexture* setMinificationFilter(Sampler::Filter filter, Sampler::Mipmap mipmap = Sampler::Mipmap::Base);
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
/**
* @brief Set magnification filter
* @param filter Filter
Method chaining for textures.
14 years ago
* @return Pointer to self (for method chaining)
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*
* Sets filter used when the object pixel size is larger than largest
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
* texture size. If @extension{EXT,direct_state_access} is not
* available, the texture is bound to some layer before the operation.
Moved sampler state enums into new Sampler class. Solves another trivial choice (similar to the one with TextureFormat etc. in 7de45c98b1aea3ecd530b819d9649d5f5a4628e5), less typing and also preparation for ARB_sampler_objects extension.
13 years ago
* Initial value is @ref Sampler::Filter "Sampler::Filter::Linear".
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
* @see @fn_gl{ActiveTexture}, @fn_gl{BindTexture} and @fn_gl{TexParameter}
* or @fn_gl_extension{TextureParameter,EXT,direct_state_access}
* with @def_gl{TEXTURE_MAG_FILTER}
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*/
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
AbstractTexture* setMagnificationFilter(Sampler::Filter filter) {
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
(this->*parameteriImplementation)(GL_TEXTURE_MAG_FILTER, static_cast<GLint>(filter));
Method chaining for textures.
14 years ago
return this;
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
}
Texture border & anisotropy is available only as ES2 extension.
13 years ago
#ifndef MAGNUM_TARGET_GLES3
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
/**
* @brief Set border color
Method chaining for textures.
14 years ago
* @return Pointer to self (for method chaining)
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*
Moved sampler state enums into new Sampler class. Solves another trivial choice (similar to the one with TextureFormat etc. in 7de45c98b1aea3ecd530b819d9649d5f5a4628e5), less typing and also preparation for ARB_sampler_objects extension.
13 years ago
* Border color when wrapping is set to @ref Sampler::Wrapping "Sampler::Wrapping::ClampToBorder".
* If @extension{EXT,direct_state_access} is not available, the texture
* is bound to some layer before the operation. Initial value is
* `{0.0f, 0.0f, 0.0f, 0.0f}`.
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
* @see @fn_gl{ActiveTexture}, @fn_gl{BindTexture} and @fn_gl{TexParameter}
* or @fn_gl_extension{TextureParameter,EXT,direct_state_access}
* with @def_gl{TEXTURE_BORDER_COLOR}
Support for ES2 extension NV_texture_border_clamp.
13 years ago
* @requires_es_extension %Extension @es_extension{NV,texture_border_clamp}
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*/
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
AbstractTexture* setBorderColor(const Color4<>& color) {
Support for ES2 extension NV_texture_border_clamp.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
(this->*parameterfvImplementation)(GL_TEXTURE_BORDER_COLOR, color.data());
Support for ES2 extension NV_texture_border_clamp.
13 years ago
#else
(this->*parameterfvImplementation)(GL_TEXTURE_BORDER_COLOR_NV, color.data());
#endif
Method chaining for textures.
14 years ago
return this;
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
}
Support for anisotropic filtering.
14 years ago
/**
* @brief Set max anisotropy
Method chaining for textures.
14 years ago
* @return Pointer to self (for method chaining)
Support for anisotropic filtering.
14 years ago
*
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
* Default value is `1.0f`, which means no anisotropy. Set to value
* greater than `1.0f` for anisotropic filtering. If
* @extension{EXT,direct_state_access} is not available, the texture
* is bound to some layer before the operation.
* @see maxSupportedAnisotropy(), @fn_gl{ActiveTexture},
* @fn_gl{BindTexture} and @fn_gl{TexParameter} or
* @fn_gl_extension{TextureParameter,EXT,direct_state_access} with
* @def_gl{TEXTURE_MAX_ANISOTROPY_EXT}
Updated OpenGL ES support in textures.
14 years ago
* @requires_extension %Extension @extension{EXT,texture_filter_anisotropic}
* @requires_es_extension %Extension @es_extension2{EXT,texture_filter_anisotropic,texture_filter_anisotropic}
Support for anisotropic filtering.
14 years ago
*/
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
AbstractTexture* setMaxAnisotropy(Float anisotropy) {
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
(this->*parameterfImplementation)(GL_TEXTURE_MAX_ANISOTROPY_EXT, anisotropy);
Method chaining for textures.
14 years ago
return this;
Support for anisotropic filtering.
14 years ago
}
Texture border & anisotropy is available only as ES2 extension.
13 years ago
#endif
Support for anisotropic filtering.
14 years ago
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
/**
* @brief Invalidate texture image
* @param level Mip 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
* If running on OpenGL ES or extension @extension{ARB,invalidate_subdata}
* is not available, this function does nothing.
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
* @see @ref Texture::invalidateSubImage() "invalidateSubImage()",
* @fn_gl{InvalidateTexImage}
*/
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
void invalidateImage(Int level) {
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
(this->*invalidateImageImplementation)(level);
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
}
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
/**
* @brief Generate mipmap
Method chaining for textures.
14 years ago
* @return Pointer to self (for method chaining)
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
* Can not be used for rectangle textures. If
* @extension{EXT,direct_state_access} is not available, the texture
* is bound to some layer before the operation.
* @see setMinificationFilter(), @fn_gl{ActiveTexture},
* @fn_gl{BindTexture} and @fn_gl{GenerateMipmap} or
* @fn_gl_extension{GenerateTextureMipmap,EXT,direct_state_access}
Use proper ARB_framebuffer_object extension. Separated EXT_framebuffer_object, EXT_framebuffer_blit, EXT_framebuffer_multisample and EXT_packed_depth_stencil don't have the same functionality as ARB_framebuffer_object (e.g. missing GL_FRAMEBUFFER_UNDEFINED in glCheckFramebufferStatus()) and separated read/draw binding is only in EXT_framebuffer_blit, which complicates the internals. Checked with Mesa 8/9 and OpenGL 2.1, current one has ARB_framebuffer_object and also all these four, Mesa 7.7 didn't have EXT_framebuffer_multisample, but that's a long time ago, so not supporting these separate extensions shouldn't be an issue. The problem with unavailable separate binding points remains on OpenGL ES 2.0, there are three different extensions bringing that functionality, thus the code managing the available binding points remains there.
13 years ago
* @requires_gl30 %Extension @extension{ARB,framebuffer_object}
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
*/
Method chaining for textures.
14 years ago
AbstractTexture* generateMipmap();
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
Tracking texture state - bindings and limits.
14 years ago
/* Unlike bind() this also sets the binding layer 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 retrieve texture images.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Don't hide publicly used functions. I desperately need tests for GL functionality.
13 years ago
template<UnsignedInt dimensions> void image(GLenum target, GLint level, Image<dimensions>* image);
template<UnsignedInt dimensions> void image(GLenum target, GLint level, BufferImage<dimensions>* image, Buffer::Usage 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:
Don't export private symbols.
14 years ago
static void MAGNUM_LOCAL initializeContextBasedFunctionality(Context* context);
Tracking texture state - bindings and limits.
14 years ago
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
typedef void(AbstractTexture::*BindImplementation)(GLint);
void MAGNUM_LOCAL bindImplementationDefault(GLint layer);
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL bindImplementationDSA(GLint layer);
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
static MAGNUM_LOCAL BindImplementation bindImplementation;
typedef void(AbstractTexture::*ParameteriImplementation)(GLenum, GLint);
void MAGNUM_LOCAL parameterImplementationDefault(GLenum parameter, GLint value);
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, GLint value);
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
static ParameteriImplementation parameteriImplementation;
typedef void(AbstractTexture::*ParameterfImplementation)(GLenum, GLfloat);
void MAGNUM_LOCAL parameterImplementationDefault(GLenum parameter, GLfloat value);
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, GLfloat value);
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
static ParameterfImplementation parameterfImplementation;
typedef void(AbstractTexture::*ParameterfvImplementation)(GLenum, const GLfloat*);
void MAGNUM_LOCAL parameterImplementationDefault(GLenum parameter, const GLfloat* values);
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL parameterImplementationDSA(GLenum parameter, const GLfloat* 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
static ParameterfvImplementation parameterfvImplementation;
Implementation for texture level parameter query.
13 years ago
#ifndef MAGNUM_TARGET_GLES
typedef void(AbstractTexture::*GetLevelParameterivImplementation)(GLenum, GLint, GLenum, GLint*);
void MAGNUM_LOCAL getLevelParameterImplementationDefault(GLenum target, GLint level, GLenum parameter, GLint* values);
void MAGNUM_LOCAL getLevelParameterImplementationDSA(GLenum target, GLint level, GLenum parameter, GLint* values);
static MAGNUM_LOCAL GetLevelParameterivImplementation getLevelParameterivImplementation;
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
typedef void(AbstractTexture::*MipmapImplementation)();
void MAGNUM_LOCAL mipmapImplementationDefault();
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
void MAGNUM_LOCAL mipmapImplementationDSA();
Updated OpenGL ES support in textures.
14 years ago
#endif
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
static MAGNUM_LOCAL MipmapImplementation mipmapImplementation;
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*Storage1DImplementation)(GLenum, GLsizei, TextureFormat, const Math::Vector<1, GLsizei>&);
Fallback for texture storage feature. It's now possible to call *Texture::setStorage() even if OpenGL 4.2, ARB_texture_storage, OpenGL ES 3.0 or EXT_texture_storage in ES 2.0 is not available, the function will internally use sequence of setImage() calls as fallback. It seems to me that this behavior is better than forcing the user to always check for extension presence and then implementing this functionality again and again. The huge switches for setting proper image format and type are ugly though, but according to specs they must be set even if we are sending no data (which is weird).
13 years ago
void MAGNUM_LOCAL storageImplementationFallback(GLenum target, GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDefault(GLenum target, GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
void MAGNUM_LOCAL storageImplementationDSA(GLenum target, GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
static Storage1DImplementation storage1DImplementation;
#endif
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*Storage2DImplementation)(GLenum, GLsizei, TextureFormat, const Vector2i&);
Fallback for texture storage feature. It's now possible to call *Texture::setStorage() even if OpenGL 4.2, ARB_texture_storage, OpenGL ES 3.0 or EXT_texture_storage in ES 2.0 is not available, the function will internally use sequence of setImage() calls as fallback. It seems to me that this behavior is better than forcing the user to always check for extension presence and then implementing this functionality again and again. The huge switches for setting proper image format and type are ugly though, but according to specs they must be set even if we are sending no data (which is weird).
13 years ago
void MAGNUM_LOCAL storageImplementationFallback(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector2i& size);
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDefault(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector2i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDSA(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector2i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#endif
static Storage2DImplementation storage2DImplementation;
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*Storage3DImplementation)(GLenum, GLsizei, TextureFormat, const Vector3i&);
Fallback for texture storage feature. It's now possible to call *Texture::setStorage() even if OpenGL 4.2, ARB_texture_storage, OpenGL ES 3.0 or EXT_texture_storage in ES 2.0 is not available, the function will internally use sequence of setImage() calls as fallback. It seems to me that this behavior is better than forcing the user to always check for extension presence and then implementing this functionality again and again. The huge switches for setting proper image format and type are ugly though, but according to specs they must be set even if we are sending no data (which is weird).
13 years ago
void MAGNUM_LOCAL storageImplementationFallback(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector3i& size);
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDefault(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector3i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL storageImplementationDSA(GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector3i& size);
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
#endif
static Storage3DImplementation storage3DImplementation;
Ability to retrieve texture images.
13 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*GetImageImplementation)(GLenum, GLint, ImageFormat, ImageType, std::size_t, GLvoid*);
void MAGNUM_LOCAL getImageImplementationDefault(GLenum target, GLint level, ImageFormat format, ImageType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationDSA(GLenum target, GLint level, ImageFormat format, ImageType type, std::size_t dataSize, GLvoid* data);
void MAGNUM_LOCAL getImageImplementationRobustness(GLenum target, GLint level, ImageFormat format, ImageType type, std::size_t dataSize, GLvoid* data);
Ability to retrieve texture images.
13 years ago
static MAGNUM_LOCAL GetImageImplementation getImageImplementation;
#endif
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*Image1DImplementation)(GLenum, GLint, TextureFormat, const Math::Vector<1, GLsizei>&, ImageFormat, ImageType, const GLvoid*);
void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint level, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size, ImageFormat format, ImageType type, const GLvoid* data);
void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint level, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size, ImageFormat format, ImageType type, const GLvoid* data);
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
static Image1DImplementation image1DImplementation;
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
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*Image2DImplementation)(GLenum, GLint, TextureFormat, const Vector2i&, ImageFormat, ImageType, const GLvoid*);
void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint level, TextureFormat internalFormat, const Vector2i& size, ImageFormat format, ImageType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint level, TextureFormat internalFormat, const Vector2i& size, ImageFormat format, ImageType 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
static Image2DImplementation image2DImplementation;
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*Image3DImplementation)(GLenum, GLint, TextureFormat, const Vector3i&, ImageFormat, ImageType, const GLvoid*);
void MAGNUM_LOCAL imageImplementationDefault(GLenum target, GLint level, TextureFormat internalFormat, const Vector3i& size, ImageFormat format, ImageType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL imageImplementationDSA(GLenum target, GLint level, TextureFormat internalFormat, const Vector3i& size, ImageFormat format, ImageType 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
static Image3DImplementation image3DImplementation;
Updated OpenGL ES support in textures.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*SubImage1DImplementation)(GLenum, GLint, const Math::Vector<1, GLint>&, const Math::Vector<1, GLsizei>&, ImageFormat, ImageType, const GLvoid*);
void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, ImageFormat format, ImageType type, const GLvoid* data);
void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLsizei>& size, ImageFormat format, ImageType type, const GLvoid* data);
Using EXT_direct_state_access in textures. Saves unnecessary calls to glActiveTexture() and glBindTexture().
14 years ago
static SubImage1DImplementation subImage1DImplementation;
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
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*SubImage2DImplementation)(GLenum, GLint, const Vector2i&, const Vector2i&, ImageFormat, ImageType, const GLvoid*);
void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint level, const Vector2i& offset, const Vector2i& size, ImageFormat format, ImageType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint level, const Vector2i& offset, const Vector2i& size, ImageFormat format, ImageType 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
static SubImage2DImplementation subImage2DImplementation;
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
typedef void(AbstractTexture::*SubImage3DImplementation)(GLenum, GLint, const Vector3i&, const Vector3i&, ImageFormat, ImageType, const GLvoid*);
void MAGNUM_LOCAL subImageImplementationDefault(GLenum target, GLint level, const Vector3i& offset, const Vector3i& size, ImageFormat format, ImageType type, const GLvoid* data);
Forgot to hide DSA functions when targetting ES.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Moved texture and image formats out of the classes. Advantages: * The enums were large (600-800 lines) and they polluted the header, now they are in separate files (except for BufferTexture, which has the enum small enough to be left in the same file). * Image classes now don't need to include OpenGL headers, as they were needed only for the enum values. With advantage of C++11's forward enum declarations there is no need to include the enum headers anywhere in implementation, only when particular values are needed. * The values are now less verbose: AbstractTexture::InternalFormat::RGB8 // before TextureFormat::RGB8 // now * Resolved another "trivial choice" problem (thanks @JanDupal for introducing this term to me): how to specify the format if there are ten ways to do it (some being massively confusing): Image2D::Format f = AbstractImage::Format::RGB; // too long... Image2D::Format f = Image3D::Format::RGBA; // why 3D? this works? Image2D::Format f = BufferImage1D::Format::RGBA; // wat? It is even worse (and more verbose) with textures: Texture2D::InternalFormat f = CubeMapTextureArray::InternalFormat::RGB8; // this is allowed? To have consistent naming this change was done also with BufferTexture::InternalFormat (now BufferTextureFormat), although there were no trivial choice issues and the enum isn't too large. But at least it is now less typing.
13 years ago
void MAGNUM_LOCAL subImageImplementationDSA(GLenum target, GLint level, const Vector3i& offset, const Vector3i& size, ImageFormat format, ImageType 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
static SubImage3DImplementation subImage3DImplementation;
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
typedef void(AbstractTexture::*InvalidateImageImplementation)(GLint);
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
static InvalidateImageImplementation invalidateImageImplementation;
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
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
typedef void(AbstractTexture::*InvalidateSubImageImplementation)(GLint, const Vector3i&, const Vector3i&);
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
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
static InvalidateSubImageImplementation invalidateSubImageImplementation;
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
Move constructor and move assignment for textures.
14 years ago
void MAGNUM_LOCAL destroy();
void MAGNUM_LOCAL move();
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
ImageFormat MAGNUM_LOCAL imageFormatForInternalFormat(TextureFormat internalFormat);
ImageType MAGNUM_LOCAL imageTypeForInternalFormat(TextureFormat internalFormat);
Move constructor and move assignment for textures.
14 years ago
Refactoring of internal OpenGL object names.
14 years ago
GLuint _id;
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
};
Fixed wrong automagic texture target for 3D textures. While GL_TEXTURE_2D == GL_TEXTURE_1D + 1, GL_TEXTURE_3D is something absolutely different and cannot be computed like this. Now done via AbstractTexture::DataHelper, which is cleaner and better readable.
15 years ago
#ifndef DOXYGEN_GENERATING_OUTPUT
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
namespace Implementation {
template<class Image> struct ImageHelper {
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
static const GLvoid* dataOrPixelUnpackBuffer(Image* image) {
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
#ifndef MAGNUM_TARGET_GLES2
Buffer::unbind(Buffer::Target::PixelUnpack);
#endif
return image->data();
}
};
#ifndef MAGNUM_TARGET_GLES2
Using new type aliases in whole root Magnum namespace.
13 years ago
template<UnsignedInt dimensions> struct MAGNUM_EXPORT ImageHelper<BufferImage<dimensions>> {
Added missing const.
13 years ago
static const GLvoid* dataOrPixelUnpackBuffer(BufferImage<dimensions>* image);
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
};
#endif
}
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
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
template<> struct AbstractTexture::DataHelper<1> {
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
};
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
constexpr static Target target() { return Target::Texture1D; }
Fixed wrong automagic texture target for 3D textures. While GL_TEXTURE_2D == GL_TEXTURE_1D + 1, GL_TEXTURE_3D is something absolutely different and cannot be computed like this. Now done via AbstractTexture::DataHelper, which is cleaner and better readable.
15 years ago
Ability to retrieve texture image size in given mip level.
13 years ago
static Math::Vector<1, GLint> imageSize(AbstractTexture* texture, GLenum target, GLint level);
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
static void setWrapping(AbstractTexture* texture, const Array1D<Sampler::Wrapping>& wrapping) {
Using Array instead of Vector for *Texture::setWrapping(). Allows simple and convenient call with one value for all axes instead of that unholy mess: texture.setWrapping(Texture2D::Wrapping::ClampToEdge); Previous way (for entertainment purposes): textute.setWrapping(Math::Vector2<Texture2D::Wrapping>( Texture2D::Wrapping::ClampToEdge));
14 years ago
(texture->*parameteriImplementation)(GL_TEXTURE_WRAP_S, static_cast<GLint>(wrapping.x()));
Greatly simplified Texture::setWrapping(). Temporarily removed the check for not setting repeat wrap mode on rectangle textures.
14 years ago
}
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
static void setStorage(AbstractTexture* texture, GLenum target, GLsizei levels, TextureFormat internalFormat, const Math::Vector<1, GLsizei>& size) {
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
(texture->*storage1DImplementation)(target, levels, internalFormat, size);
}
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
template<class Image> static typename std::enable_if<Image::Dimensions == 1, void>::type setImage(AbstractTexture* texture, GLenum target, GLint level, TextureFormat internalFormat, Image* image) {
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
(texture->*image1DImplementation)(target, level, internalFormat, image->size(), image->format(), image->type(), Implementation::ImageHelper<Image>::dataOrPixelUnpackBuffer(image));
Support for setting texture subdata.
15 years ago
}
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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
template<class Image> static typename std::enable_if<Image::Dimensions == 1, void>::type setSubImage(AbstractTexture* texture, GLenum target, GLint level, const Math::Vector<1, GLint>& offset, Image* image) {
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
(texture->*subImage1DImplementation)(target, level, offset, image->size(), image->format(), image->type(), Implementation::ImageHelper<Image>::dataOrPixelUnpackBuffer(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
}
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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
static void invalidateSubImage(AbstractTexture* texture, GLint level, const Math::Vector<1, GLint>& offset, const Math::Vector<1, GLint>& size) {
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
(texture->*invalidateSubImageImplementation)(level, {offset[0], 0, 0}, {size[0], 1, 1});
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
}
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> {
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
};
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
constexpr static Target target() { return Target::Texture2D; }
Strong typed texture targets. Only those targets which are meaningful for given dimension are available.
14 years ago
Ability to retrieve texture image size in given mip level.
13 years ago
#ifndef MAGNUM_TARGET_GLES
static Vector2i imageSize(AbstractTexture* texture, GLenum target, GLint level);
#endif
Moved sampler state enums into new Sampler class. Solves another trivial choice (similar to the one with TextureFormat etc. in 7de45c98b1aea3ecd530b819d9649d5f5a4628e5), less typing and also preparation for ARB_sampler_objects extension.
13 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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
static void setStorage(AbstractTexture* texture, GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector2i& size) {
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
(texture->*storage2DImplementation)(target, levels, internalFormat, size);
}
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
template<class Image> static typename std::enable_if<Image::Dimensions == 2, void>::type setImage(AbstractTexture* texture, GLenum target, GLint level, TextureFormat internalFormat, Image* image) {
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
(texture->*image2DImplementation)(target, level, internalFormat, image->size(), image->format(), image->type(), Implementation::ImageHelper<Image>::dataOrPixelUnpackBuffer(image));
Support for setting texture subdata.
15 years ago
}
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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
template<class Image> static typename std::enable_if<Image::Dimensions == 2, void>::type setSubImage(AbstractTexture* texture, GLenum target, GLint level, const Vector2i& offset, Image* image) {
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
(texture->*subImage2DImplementation)(target, level, offset, image->size(), image->format(), image->type(), Implementation::ImageHelper<Image>::dataOrPixelUnpackBuffer(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
}
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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
template<class Image> static typename std::enable_if<Image::Dimensions == 1, void>::type setSubImage(AbstractTexture* texture, GLenum target, GLint level, const Vector2i& offset, Image* image) {
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
(texture->*subImage2DImplementation)(target, level, offset, Vector2i(image->size(), 1), image->format(), image->type(), Implementation::ImageHelper<Image>::dataOrPixelUnpackBuffer(image));
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
}
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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
static void invalidateSubImage(AbstractTexture* texture, GLint level, const Vector2i& offset, const Vector2i& size) {
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
(texture->*invalidateSubImageImplementation)(level, {offset, 0}, {size, 1});
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
}
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> {
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
};
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
constexpr static Target target() { return Target::Texture3D; }
Fixed wrong automagic texture target for 3D textures. While GL_TEXTURE_2D == GL_TEXTURE_1D + 1, GL_TEXTURE_3D is something absolutely different and cannot be computed like this. Now done via AbstractTexture::DataHelper, which is cleaner and better readable.
15 years ago
Ability to retrieve texture image size in given mip level.
13 years ago
#ifndef MAGNUM_TARGET_GLES
static Vector3i imageSize(AbstractTexture* texture, GLenum target, GLint level);
#endif
Moved sampler state enums into new Sampler class. Solves another trivial choice (similar to the one with TextureFormat etc. in 7de45c98b1aea3ecd530b819d9649d5f5a4628e5), less typing and also preparation for ARB_sampler_objects extension.
13 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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
static void setStorage(AbstractTexture* texture, GLenum target, GLsizei levels, TextureFormat internalFormat, const Vector3i& size) {
Implemented ARB_texture_storage. Equivalent functionality is in ES3 and also EXT_texture_storage ES2 extension.
14 years ago
(texture->*storage3DImplementation)(target, levels, internalFormat, size);
}
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
template<class Image> static typename std::enable_if<Image::Dimensions == 3, void>::type setImage(AbstractTexture* texture, GLenum target, GLint level, TextureFormat internalFormat, Image* image) {
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
(texture->*image3DImplementation)(target, level, internalFormat, image->size(), image->format(), image->type(), Implementation::ImageHelper<Image>::dataOrPixelUnpackBuffer(image));
Support for setting texture subdata.
15 years ago
}
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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
template<class Image> static typename std::enable_if<Image::Dimensions == 3, void>::type setSubImage(AbstractTexture* texture, GLenum target, GLint level, const Vector3i& offset, Image* image) {
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
(texture->*subImage3DImplementation)(target, level, offset, image->size(), image->format(), image->type(), Implementation::ImageHelper<Image>::dataOrPixelUnpackBuffer(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
}
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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
template<class Image> static typename std::enable_if<Image::Dimensions == 2, void>::type setSubImage(AbstractTexture* texture, GLenum target, GLint level, const Vector3i& offset, Image* image) {
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
(texture->*subImage3DImplementation)(target, level, offset, Vector3i(image->size(), 1), image->format(), image->type(), Implementation::ImageHelper<Image>::dataOrPixelUnpackBuffer(image));
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
}
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
Deinlined heavy functions and removed redundant `inline` everywhere else.
13 years ago
static void invalidateSubImage(AbstractTexture* texture, GLint level, const Vector3i& offset, const Vector3i& size) {
Refactored AbstractTexture internals. Naming implementation functions similarly to GL function they are wrapping, naming internal API functions similarly to public API.
13 years ago
(texture->*invalidateSubImageImplementation)(level, offset, size);
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
}
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
Splitting non-templated things from Texture to AbstractTexture.
15 years ago
}
#endif