ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Split the OpenGL layer out, pt 21: adapted DebugTools.

pull/233/head
Vladimír Vondruš 8 years ago
parent
adb4547ba0
commit
7785698d35
35 changed files with 226 additions and 220 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      src/Magnum/DebugTools/BufferData.cpp
  2. 16
      src/Magnum/DebugTools/BufferData.h
  3. 1
      src/Magnum/DebugTools/CompareImage.h
  4. 30
      src/Magnum/DebugTools/ForceRenderer.cpp
  5. 7
      src/Magnum/DebugTools/ForceRenderer.h
  6. 2
      src/Magnum/DebugTools/Implementation/AbstractBoxRenderer.cpp
  7. 46
      src/Magnum/DebugTools/Implementation/AbstractShapeRenderer.cpp
  8. 7
      src/Magnum/DebugTools/Implementation/AbstractShapeRenderer.h
  9. 2
      src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
  10. 2
      src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.h
  11. 2
      src/Magnum/DebugTools/Implementation/BoxRenderer.cpp
  12. 2
      src/Magnum/DebugTools/Implementation/BoxRenderer.h
  13. 30
      src/Magnum/DebugTools/Implementation/CapsuleRenderer.cpp
  14. 6
      src/Magnum/DebugTools/Implementation/CapsuleRenderer.h
  15. 2
      src/Magnum/DebugTools/Implementation/CylinderRenderer.cpp
  16. 4
      src/Magnum/DebugTools/Implementation/LineSegmentRenderer.cpp
  17. 2
      src/Magnum/DebugTools/Implementation/LineSegmentRenderer.h
  18. 2
      src/Magnum/DebugTools/Implementation/PointRenderer.cpp
  19. 2
      src/Magnum/DebugTools/Implementation/PointRenderer.h
  20. 4
      src/Magnum/DebugTools/Implementation/SphereRenderer.cpp
  21. 2
      src/Magnum/DebugTools/Implementation/SphereRenderer.h
  22. 30
      src/Magnum/DebugTools/ObjectRenderer.cpp
  23. 9
      src/Magnum/DebugTools/ObjectRenderer.h
  24. 10
      src/Magnum/DebugTools/ResourceManager.cpp
  25. 11
      src/Magnum/DebugTools/ResourceManager.h
  26. 14
      src/Magnum/DebugTools/ShapeRenderer.cpp
  27. 16
      src/Magnum/DebugTools/Test/BufferDataGLTest.cpp
  28. 2
      src/Magnum/DebugTools/Test/CapsuleRendererTest.cpp
  29. 2
      src/Magnum/DebugTools/Test/CompareImageTest.cpp
  30. 2
      src/Magnum/DebugTools/Test/CylinderRendererTest.cpp
  31. 2
      src/Magnum/DebugTools/Test/ForceRendererTest.cpp
  32. 2
      src/Magnum/DebugTools/Test/LineSegmentRendererTest.cpp
  33. 96
      src/Magnum/DebugTools/Test/TextureImageGLTest.cpp
  34. 60
      src/Magnum/DebugTools/TextureImage.cpp
  35. 17
      src/Magnum/DebugTools/TextureImage.h

2
src/Magnum/DebugTools/BufferData.cpp
Unescape View File

@ -28,7 +28,7 @@
#ifndef MAGNUM_TARGET_WEBGL
namespace Magnum { namespace DebugTools { namespace Implementation {
void bufferSubData(Buffer& buffer, GLintptr offset, GLsizeiptr size, void* output) {
void bufferSubData(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size, void* output) {
Containers::ArrayView<const char> data = buffer.mapRead(offset, size);
std::copy(data.begin(), data.end(), reinterpret_cast<char*>(output));
buffer.unmap();

16
src/Magnum/DebugTools/BufferData.h
Unescape View File

@ -33,26 +33,26 @@
#include <Corrade/Containers/Array.h>
#include "Magnum/Buffer.h"
#include "Magnum/GL/Buffer.h"
#include "Magnum/DebugTools/visibility.h"
#ifndef MAGNUM_TARGET_WEBGL
namespace Magnum { namespace DebugTools {
namespace Implementation {
MAGNUM_DEBUGTOOLS_EXPORT void bufferSubData(Buffer& buffer, GLintptr offset, GLsizeiptr size, void* output);
MAGNUM_DEBUGTOOLS_EXPORT void bufferSubData(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size, void* output);
}
/**
@brief Buffer subdata
Emulates @ref Buffer::subData() call on platforms that don't support it (such
as OpenGL ES) by using @ref Buffer::map().
Emulates @ref GL::Buffer::subData() call on platforms that don't support it
(such as OpenGL ES) by using @ref GL::Buffer::map().
@requires_gles30 Extension @extension{EXT,map_buffer_range} in OpenGL ES
2.0.
@requires_gles Buffer mapping is not available in WebGL.
*/
template<class T> Containers::Array<T> inline bufferSubData(Buffer& buffer, GLintptr offset, GLsizeiptr size) {
template<class T> Containers::Array<T> inline bufferSubData(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size) {
Containers::Array<T> data{std::size_t(size)};
if(size) Implementation::bufferSubData(buffer, offset, size*sizeof(T), data);
return data;
@ -61,13 +61,13 @@ template<class T> Containers::Array<T> inline bufferSubData(Buffer& buffer, GLin
/**
@brief Buffer data
Emulates @ref Buffer::data() call on platforms that don't support it (such as
OpenGL ES) by using @ref Buffer::map().
Emulates @ref GL::Buffer::data() call on platforms that don't support it (such
as OpenGL ES) by using @ref GL::Buffer::map().
@requires_gles30 Extension @extension{EXT,map_buffer_range} in OpenGL ES
2.0.
@requires_gles Buffer mapping is not available in WebGL.
*/
template<class T = char> Containers::Array<T> inline bufferData(Buffer& buffer) {
template<class T = char> Containers::Array<T> inline bufferData(GL::Buffer& buffer) {
const Int bufferSize = buffer.size();
CORRADE_ASSERT(bufferSize%sizeof(T) == 0, "Buffer::data(): the buffer size is" << bufferSize << "bytes, which can't be expressed as array of types with size" << sizeof(T), nullptr);
return bufferSubData<T>(buffer, 0, bufferSize/sizeof(T));

1
src/Magnum/DebugTools/CompareImage.h
Unescape View File

@ -33,6 +33,7 @@
#include <Corrade/TestSuite/Comparator.h>
#include "Magnum/Magnum.h"
#include "Magnum/GL/GL.h"
#include "Magnum/Math/Vector2.h"
#include "Magnum/DebugTools/visibility.h"

30
src/Magnum/DebugTools/ForceRenderer.cpp
Unescape View File

@ -25,13 +25,13 @@
#include "ForceRenderer.h"
#include "Magnum/Buffer.h"
#include "Magnum/Mesh.h"
#include "Magnum/GL/Buffer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/DebugTools/ResourceManager.h"
#include "Magnum/SceneGraph/Camera.h"
#include "Magnum/Shaders/Flat.h"
#include "Implementation/ForceRendererTransformation.h"
#include "Magnum/DebugTools/Implementation/ForceRendererTransformation.h"
namespace Magnum { namespace DebugTools {
@ -58,31 +58,31 @@ constexpr std::array<UnsignedByte, 6> indices{{
template<UnsignedInt dimensions> ForceRenderer<dimensions>::ForceRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, const VectorTypeFor<dimensions, Float>& forcePosition, const VectorTypeFor<dimensions, Float>& force, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>(object, drawables), _forcePosition(forcePosition), _force(force), _options(ResourceManager::instance().get<ForceRendererOptions>(options)) {
/* Shader */
_shader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
if(!_shader) ResourceManager::instance().set<AbstractShaderProgram>(_shader.key(), new Shaders::Flat<dimensions>);
_shader = ResourceManager::instance().get<GL::AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
if(!_shader) ResourceManager::instance().set<GL::AbstractShaderProgram>(_shader.key(), new Shaders::Flat<dimensions>);
/* Mesh and vertex buffer */
_mesh = ResourceManager::instance().get<Mesh>("force");
_vertexBuffer = ResourceManager::instance().get<Buffer>("force-vertices");
_indexBuffer = ResourceManager::instance().get<Buffer>("force-indices");
_mesh = ResourceManager::instance().get<GL::Mesh>("force");
_vertexBuffer = ResourceManager::instance().get<GL::Buffer>("force-vertices");
_indexBuffer = ResourceManager::instance().get<GL::Buffer>("force-indices");
if(_mesh) return;
/* Create the mesh */
Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array};
Buffer* indexBuffer = new Buffer{Buffer::TargetHint::ElementArray};
GL::Buffer* vertexBuffer = new GL::Buffer{GL::Buffer::TargetHint::Array};
GL::Buffer* indexBuffer = new GL::Buffer{GL::Buffer::TargetHint::ElementArray};
_vertexBuffer->setData(positions, BufferUsage::StaticDraw);
_vertexBuffer->setData(positions, GL::BufferUsage::StaticDraw);
ResourceManager::instance().set(_vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
_indexBuffer->setData(indices, BufferUsage::StaticDraw);
_indexBuffer->setData(indices, GL::BufferUsage::StaticDraw);
ResourceManager::instance().set(_indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
Mesh* mesh = new Mesh;
mesh->setPrimitive(MeshPrimitive::Lines)
GL::Mesh* mesh = new GL::Mesh;
mesh->setPrimitive(GL::MeshPrimitive::Lines)
.setCount(indices.size())
.addVertexBuffer(*vertexBuffer, 0,
typename Shaders::Flat<dimensions>::Position(Shaders::Flat<dimensions>::Position::Components::Two))
.setIndexBuffer(*indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, positions.size());
.setIndexBuffer(*indexBuffer, 0, GL::MeshIndexType::UnsignedByte, 0, positions.size());
ResourceManager::instance().set(_mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
}

7
src/Magnum/DebugTools/ForceRenderer.h
Unescape View File

@ -30,6 +30,7 @@
*/
#include "Magnum/Resource.h"
#include "Magnum/GL/GL.h"
#include "Magnum/Math/Color.h"
#include "Magnum/SceneGraph/Drawable.h"
#include "Magnum/Shaders/Shaders.h"
@ -135,9 +136,9 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ForceRenderer: p
const VectorTypeFor<dimensions, Float>& _force;
Resource<ForceRendererOptions> _options;
Resource<AbstractShaderProgram, Shaders::Flat<dimensions>> _shader;
Resource<Mesh> _mesh;
Resource<Buffer> _vertexBuffer, _indexBuffer;
Resource<GL::AbstractShaderProgram, Shaders::Flat<dimensions>> _shader;
Resource<GL::Mesh> _mesh;
Resource<GL::Buffer> _vertexBuffer, _indexBuffer;
};
/** @brief Two-dimensional force renderer */

2
src/Magnum/DebugTools/Implementation/AbstractBoxRenderer.cpp
Unescape View File

@ -25,7 +25,7 @@
#include "AbstractBoxRenderer.h"
#include "Magnum/Mesh.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/Primitives/Cube.h"
#include "Magnum/Primitives/Square.h"
#include "Magnum/Trade/MeshData2D.h"

46
src/Magnum/DebugTools/Implementation/AbstractShapeRenderer.cpp
Unescape View File

@ -27,10 +27,10 @@
#include <Corrade/Containers/Array.h>
#include "Magnum/AbstractShaderProgram.h"
#include "Magnum/Buffer.h"
#include "Magnum/Mesh.h"
#include "Magnum/DebugTools/ResourceManager.h"
#include "Magnum/GL/AbstractShaderProgram.h"
#include "Magnum/GL/Buffer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/MeshTools/CompressIndices.h"
#include "Magnum/Shaders/Flat.h"
#include "Magnum/Trade/MeshData2D.h"
@ -44,16 +44,16 @@ template<UnsignedInt dimensions> ResourceKey shaderKey();
template<> inline ResourceKey shaderKey<2>() { return ResourceKey("FlatShader2D"); }
template<> inline ResourceKey shaderKey<3>() { return ResourceKey("FlatShader3D"); }
template<UnsignedInt dimensions> void create(typename MeshData<dimensions>::Type&, Resource<Mesh>&, Resource<Buffer>&, Resource<Buffer>&);
template<UnsignedInt dimensions> void create(typename MeshData<dimensions>::Type&, Resource<GL::Mesh>&, Resource<GL::Buffer>&, Resource<GL::Buffer>&);
template<> void create<2>(Trade::MeshData2D& data, Resource<Mesh>& meshResource, Resource<Buffer>& vertexBufferResource, Resource<Buffer>& indexBufferResource) {
template<> void create<2>(Trade::MeshData2D& data, Resource<GL::Mesh>& meshResource, Resource<GL::Buffer>& vertexBufferResource, Resource<GL::Buffer>& indexBufferResource) {
/* Vertex buffer */
Buffer* buffer = new Buffer{Buffer::TargetHint::Array};
buffer->setData(data.positions(0), BufferUsage::StaticDraw);
GL::Buffer* buffer = new GL::Buffer{GL::Buffer::TargetHint::Array};
buffer->setData(data.positions(0), GL::BufferUsage::StaticDraw);
ResourceManager::instance().set(vertexBufferResource.key(), buffer, ResourceDataState::Final, ResourcePolicy::Manual);
/* Mesh configuration */
Mesh* mesh = new Mesh;
GL::Mesh* mesh = new GL::Mesh;
mesh->setPrimitive(data.primitive())
.addVertexBuffer(*buffer, 0, Shaders::Flat2D::Position());
ResourceManager::instance().set(meshResource.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
@ -63,12 +63,12 @@ template<> void create<2>(Trade::MeshData2D& data, Resource<Mesh>& meshResource,
CORRADE_INTERNAL_ASSERT(indexBufferResource.key() != ResourceKey());
Containers::Array<char> indexData;
Mesh::IndexType indexType;
MeshIndexType indexType;
UnsignedInt indexStart, indexEnd;
std::tie(indexData, indexType, indexStart, indexEnd) = MeshTools::compressIndices(data.indices());
Buffer* indexBuffer = new Buffer{Buffer::TargetHint::ElementArray};
indexBuffer->setData(indexData, BufferUsage::StaticDraw);
GL::Buffer* indexBuffer = new GL::Buffer{GL::Buffer::TargetHint::ElementArray};
indexBuffer->setData(indexData, GL::BufferUsage::StaticDraw);
mesh->setCount(data.indices().size())
.setIndexBuffer(*indexBuffer, 0, indexType, indexStart, indexEnd);
@ -78,14 +78,14 @@ template<> void create<2>(Trade::MeshData2D& data, Resource<Mesh>& meshResource,
} else mesh->setCount(data.positions(0).size());
}
template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource, Resource<Buffer>& vertexBufferResource, Resource<Buffer>& indexBufferResource) {
template<> void create<3>(Trade::MeshData3D& data, Resource<GL::Mesh>& meshResource, Resource<GL::Buffer>& vertexBufferResource, Resource<GL::Buffer>& indexBufferResource) {
/* Vertex buffer */
Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array};
vertexBuffer->setData(data.positions(0), BufferUsage::StaticDraw);
GL::Buffer* vertexBuffer = new GL::Buffer{GL::Buffer::TargetHint::Array};
vertexBuffer->setData(data.positions(0), GL::BufferUsage::StaticDraw);
ResourceManager::instance().set(vertexBufferResource.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
/* Mesh configuration */
Mesh* mesh = new Mesh;
GL::Mesh* mesh = new GL::Mesh;
mesh->setPrimitive(data.primitive())
.addVertexBuffer(*vertexBuffer, 0, Shaders::Flat3D::Position());
ResourceManager::instance().set(meshResource.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
@ -95,12 +95,12 @@ template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource,
CORRADE_INTERNAL_ASSERT(indexBufferResource.key() != ResourceKey());
Containers::Array<char> indexData;
Mesh::IndexType indexType;
MeshIndexType indexType;
UnsignedInt indexStart, indexEnd;
std::tie(indexData, indexType, indexStart, indexEnd) = MeshTools::compressIndices(data.indices());
Buffer* indexBuffer = new Buffer{Buffer::TargetHint::ElementArray};
indexBuffer->setData(indexData, BufferUsage::StaticDraw);
GL::Buffer* indexBuffer = new GL::Buffer{GL::Buffer::TargetHint::ElementArray};
indexBuffer->setData(indexData, GL::BufferUsage::StaticDraw);
mesh->setCount(data.indices().size())
.setIndexBuffer(*indexBuffer, 0, indexType, indexStart, indexEnd);
@ -113,12 +113,12 @@ template<> void create<3>(Trade::MeshData3D& data, Resource<Mesh>& meshResource,
}
template<UnsignedInt dimensions> AbstractShapeRenderer<dimensions>::AbstractShapeRenderer(ResourceKey meshKey, ResourceKey vertexBufferKey, ResourceKey indexBufferKey) {
wireframeShader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
wireframeMesh = ResourceManager::instance().get<Mesh>(meshKey);
vertexBuffer = ResourceManager::instance().get<Buffer>(vertexBufferKey);
indexBuffer = ResourceManager::instance().get<Buffer>(indexBufferKey);
wireframeShader = ResourceManager::instance().get<GL::AbstractShaderProgram, Shaders::Flat<dimensions>>(shaderKey<dimensions>());
wireframeMesh = ResourceManager::instance().get<GL::Mesh>(meshKey);
vertexBuffer = ResourceManager::instance().get<GL::Buffer>(vertexBufferKey);
indexBuffer = ResourceManager::instance().get<GL::Buffer>(indexBufferKey);
if(!wireframeShader) ResourceManager::instance().set<AbstractShaderProgram>(shaderKey<dimensions>(),
if(!wireframeShader) ResourceManager::instance().set<GL::AbstractShaderProgram>(shaderKey<dimensions>(),
new Shaders::Flat<dimensions>, ResourceDataState::Final, ResourcePolicy::Resident);
}

7
src/Magnum/DebugTools/Implementation/AbstractShapeRenderer.h
Unescape View File

@ -28,6 +28,7 @@
#include "Magnum/DimensionTraits.h"
#include "Magnum/Resource.h"
#include "Magnum/DebugTools/DebugTools.h"
#include "Magnum/GL/GL.h"
#include "Magnum/SceneGraph/SceneGraph.h"
#include "Magnum/Shaders/Shaders.h"
#include "Magnum/Trade/Trade.h"
@ -56,11 +57,11 @@ template<UnsignedInt dimensions> class AbstractShapeRenderer {
/* Call only if the mesh resource isn't already present */
void createResources(typename MeshData<dimensions>::Type data);
Resource<AbstractShaderProgram, Shaders::Flat<dimensions>> wireframeShader;
Resource<Mesh> wireframeMesh;
Resource<GL::AbstractShaderProgram, Shaders::Flat<dimensions>> wireframeShader;
Resource<GL::Mesh> wireframeMesh;
private:
Resource<Buffer> indexBuffer, vertexBuffer;
Resource<GL::Buffer> indexBuffer, vertexBuffer;
};
}}}

2
src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp
Unescape View File

@ -25,7 +25,7 @@
#include "AxisAlignedBoxRenderer.h"
#include "Magnum/Mesh.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/DebugTools/ShapeRenderer.h"
#include "Magnum/Shapes/AxisAlignedBox.h"
#include "Magnum/Shaders/Flat.h"

2
src/Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.h
Unescape View File

@ -27,7 +27,7 @@
#include "Magnum/Shapes/Shapes.h"
#include "AbstractBoxRenderer.h"
#include "Magnum/DebugTools/Implementation/AbstractBoxRenderer.h"
namespace Magnum { namespace DebugTools { namespace Implementation {

2
src/Magnum/DebugTools/Implementation/BoxRenderer.cpp
Unescape View File

@ -25,7 +25,7 @@
#include "BoxRenderer.h"
#include "Magnum/Mesh.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/DebugTools/ShapeRenderer.h"
#include "Magnum/Shapes/Box.h"
#include "Magnum/Shaders/Flat.h"

2
src/Magnum/DebugTools/Implementation/BoxRenderer.h
Unescape View File

@ -27,7 +27,7 @@
#include "Magnum/Shapes/Shapes.h"
#include "AbstractBoxRenderer.h"
#include "Magnum/DebugTools/Implementation/AbstractBoxRenderer.h"
namespace Magnum { namespace DebugTools { namespace Implementation {

30
src/Magnum/DebugTools/Implementation/CapsuleRenderer.cpp
Unescape View File

@ -25,17 +25,17 @@
#include "CapsuleRenderer.h"
#include "Magnum/Mesh.h"
#include "Magnum/MeshView.h"
#include "Magnum/DebugTools/ResourceManager.h"
#include "Magnum/DebugTools/ShapeRenderer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/GL/MeshView.h"
#include "Magnum/Primitives/Capsule.h"
#include "Magnum/Shapes/Capsule.h"
#include "Magnum/Shaders/Flat.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"
#include "CapsuleRendererTransformation.h"
#include "Magnum/DebugTools/Implementation/CapsuleRendererTransformation.h"
namespace Magnum { namespace DebugTools { namespace Implementation {
@ -44,24 +44,24 @@ AbstractCapsuleRenderer<2>::AbstractCapsuleRenderer(): AbstractShapeRenderer<2>(
if(!wireframeMesh) createResources(Primitives::capsule2DWireframe(rings, 1, 1.0f));
/* Bottom hemisphere */
if(!(bottom = ResourceManager::instance().get<MeshView>("capsule2d-bottom"))) {
auto view = new MeshView(*wireframeMesh);
if(!(bottom = ResourceManager::instance().get<GL::MeshView>("capsule2d-bottom"))) {
auto view = new GL::MeshView(*wireframeMesh);
view->setCount(rings*4)
.setIndexRange(0, 0, rings*2+1);
ResourceManager::instance().set(bottom.key(), view, ResourceDataState::Final, ResourcePolicy::Manual);
}
/* Cylinder */
if(!(cylinder = ResourceManager::instance().get<MeshView>("capsule2d-cylinder"))) {
auto view = new MeshView(*wireframeMesh);
if(!(cylinder = ResourceManager::instance().get<GL::MeshView>("capsule2d-cylinder"))) {
auto view = new GL::MeshView(*wireframeMesh);
view->setCount(4)
.setIndexRange(rings*4, rings*2+1, rings*2+3);
ResourceManager::instance().set(cylinder.key(), view, ResourceDataState::Final, ResourcePolicy::Manual);
}
/* Top hemisphere */
if(!(top = ResourceManager::instance().get<MeshView>("capsule2d-top"))) {
auto view = new MeshView(*wireframeMesh);
if(!(top = ResourceManager::instance().get<GL::MeshView>("capsule2d-top"))) {
auto view = new GL::MeshView(*wireframeMesh);
view->setCount(rings*4)
.setIndexRange(rings*4+4, rings*2+3, rings*4+4);
ResourceManager::instance().set(top.key(), view, ResourceDataState::Final, ResourcePolicy::Manual);
@ -74,24 +74,24 @@ AbstractCapsuleRenderer<3>::AbstractCapsuleRenderer(): AbstractShapeRenderer<3>(
if(!wireframeMesh) createResources(Primitives::capsule3DWireframe(rings, 1, segments, 1.0f));
/* Bottom hemisphere */
if(!(bottom = ResourceManager::instance().get<MeshView>("capsule3d-bottom"))) {
auto view = new MeshView(*wireframeMesh);
if(!(bottom = ResourceManager::instance().get<GL::MeshView>("capsule3d-bottom"))) {
auto view = new GL::MeshView(*wireframeMesh);
view->setCount(rings*8)
.setIndexRange(0, 0, rings*4+1);
ResourceManager::instance().set(bottom.key(), view, ResourceDataState::Final, ResourcePolicy::Manual);
}
/* Cylinder */
if(!(cylinder = ResourceManager::instance().get<MeshView>("capsule3d-cylinder"))) {
auto view = new MeshView(*wireframeMesh);
if(!(cylinder = ResourceManager::instance().get<GL::MeshView>("capsule3d-cylinder"))) {
auto view = new GL::MeshView(*wireframeMesh);
view->setCount(segments*4+8)
.setIndexRange(rings*8, rings*4+1, rings*4+segments*2+5);
ResourceManager::instance().set(cylinder.key(), view, ResourceDataState::Final, ResourcePolicy::Manual);
}
/* Top */
if(!(top = ResourceManager::instance().get<MeshView>("capsule3d-top"))) {
auto view = new MeshView(*wireframeMesh);
if(!(top = ResourceManager::instance().get<GL::MeshView>("capsule3d-top"))) {
auto view = new GL::MeshView(*wireframeMesh);
view->setCount(rings*8)
.setIndexRange(rings*8+segments*4+8, rings*4+segments*2+5, rings*8+segments*2+6);
ResourceManager::instance().set(top.key(), view, ResourceDataState::Final, ResourcePolicy::Manual);

6
src/Magnum/DebugTools/Implementation/CapsuleRenderer.h
Unescape View File

@ -27,7 +27,7 @@
#include "Magnum/Shapes/Shapes.h"
#include "AbstractShapeRenderer.h"
#include "Magnum/DebugTools/Implementation/AbstractShapeRenderer.h"
namespace Magnum { namespace DebugTools { namespace Implementation {
@ -39,7 +39,7 @@ template<> class AbstractCapsuleRenderer<2>: public AbstractShapeRenderer<2> {
~AbstractCapsuleRenderer();
protected:
Resource<MeshView> bottom, cylinder, top;
Resource<GL::MeshView> bottom, cylinder, top;
};
template<> class AbstractCapsuleRenderer<3>: public AbstractShapeRenderer<3> {
@ -48,7 +48,7 @@ template<> class AbstractCapsuleRenderer<3>: public AbstractShapeRenderer<3> {
~AbstractCapsuleRenderer();
protected:
Resource<MeshView> bottom, cylinder, top;
Resource<GL::MeshView> bottom, cylinder, top;
};
template<UnsignedInt dimensions> class CapsuleRenderer: public AbstractCapsuleRenderer<dimensions> {

2
src/Magnum/DebugTools/Implementation/CylinderRenderer.cpp
Unescape View File

@ -25,8 +25,8 @@
#include "CylinderRenderer.h"
#include "Magnum/Mesh.h"
#include "Magnum/DebugTools/ShapeRenderer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/Shapes/Cylinder.h"
#include "Magnum/Primitives/Cylinder.h"
#include "Magnum/Primitives/Square.h"

4
src/Magnum/DebugTools/Implementation/LineSegmentRenderer.cpp
Unescape View File

@ -25,15 +25,15 @@
#include "LineSegmentRenderer.h"
#include "Magnum/Mesh.h"
#include "Magnum/DebugTools/ShapeRenderer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/Shapes/LineSegment.h"
#include "Magnum/Primitives/Line.h"
#include "Magnum/Shaders/Flat.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"
#include "LineSegmentRendererTransformation.h"
#include "Magnum/DebugTools/Implementation/LineSegmentRendererTransformation.h"
namespace Magnum { namespace DebugTools { namespace Implementation {

2
src/Magnum/DebugTools/Implementation/LineSegmentRenderer.h
Unescape View File

@ -27,7 +27,7 @@
#include "Magnum/Shapes/Shapes.h"
#include "AbstractShapeRenderer.h"
#include "Magnum/DebugTools/Implementation/AbstractShapeRenderer.h"
namespace Magnum { namespace DebugTools { namespace Implementation {

2
src/Magnum/DebugTools/Implementation/PointRenderer.cpp
Unescape View File

@ -25,8 +25,8 @@
#include "PointRenderer.h"
#include "Magnum/Mesh.h"
#include "Magnum/DebugTools/ShapeRenderer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/Shapes/Point.h"
#include "Magnum/Primitives/Crosshair.h"
#include "Magnum/Shaders/Flat.h"

2
src/Magnum/DebugTools/Implementation/PointRenderer.h
Unescape View File

@ -27,7 +27,7 @@
#include "Magnum/Shapes/Shapes.h"
#include "AbstractShapeRenderer.h"
#include "Magnum/DebugTools/Implementation/AbstractShapeRenderer.h"
namespace Magnum { namespace DebugTools { namespace Implementation {

4
src/Magnum/DebugTools/Implementation/SphereRenderer.cpp
Unescape View File

@ -25,12 +25,12 @@
#include "SphereRenderer.h"
#include "Magnum/Mesh.h"
#include "Magnum/DebugTools/ShapeRenderer.h"
#include "Magnum/Shapes/Sphere.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/Primitives/Circle.h"
#include "Magnum/Primitives/UVSphere.h"
#include "Magnum/Shaders/Flat.h"
#include "Magnum/Shapes/Sphere.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"

2
src/Magnum/DebugTools/Implementation/SphereRenderer.h
Unescape View File

@ -27,7 +27,7 @@
#include "Magnum/Shapes/Shapes.h"
#include "AbstractShapeRenderer.h"
#include "Magnum/DebugTools/Implementation/AbstractShapeRenderer.h"
namespace Magnum { namespace DebugTools { namespace Implementation {

30
src/Magnum/DebugTools/ObjectRenderer.cpp
Unescape View File

@ -25,9 +25,9 @@
#include "ObjectRenderer.h"
#include "Magnum/Buffer.h"
#include "Magnum/Mesh.h"
#include "Magnum/DebugTools/ResourceManager.h"
#include "Magnum/GL/Buffer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/MeshTools/CompressIndices.h"
#include "Magnum/MeshTools/Interleave.h"
#include "Magnum/Primitives/Axis.h"
@ -63,35 +63,35 @@ template<> struct Renderer<3> {
/* Doxygen gets confused when using {} to initialize parent object */
template<UnsignedInt dimensions> ObjectRenderer<dimensions>::ObjectRenderer(SceneGraph::AbstractObject<dimensions, Float>& object, ResourceKey options, SceneGraph::DrawableGroup<dimensions, Float>* drawables): SceneGraph::Drawable<dimensions, Float>(object, drawables), _options{ResourceManager::instance().get<ObjectRendererOptions>(options)} {
/* Shader */
_shader = ResourceManager::instance().get<AbstractShaderProgram, Shaders::VertexColor<dimensions>>(Renderer<dimensions>::shader());
if(!_shader) ResourceManager::instance().set<AbstractShaderProgram>(_shader.key(), new Shaders::VertexColor<dimensions>);
_shader = ResourceManager::instance().get<GL::AbstractShaderProgram, Shaders::VertexColor<dimensions>>(Renderer<dimensions>::shader());
if(!_shader) ResourceManager::instance().set<GL::AbstractShaderProgram>(_shader.key(), new Shaders::VertexColor<dimensions>);
/* Mesh and vertex buffer */
_mesh = ResourceManager::instance().get<Mesh>(Renderer<dimensions>::mesh());
_vertexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::vertexBuffer());
_indexBuffer = ResourceManager::instance().get<Buffer>(Renderer<dimensions>::indexBuffer());
_mesh = ResourceManager::instance().get<GL::Mesh>(Renderer<dimensions>::mesh());
_vertexBuffer = ResourceManager::instance().get<GL::Buffer>(Renderer<dimensions>::vertexBuffer());
_indexBuffer = ResourceManager::instance().get<GL::Buffer>(Renderer<dimensions>::indexBuffer());
if(_mesh) return;
/* Create the mesh */
Buffer* vertexBuffer = new Buffer{Buffer::TargetHint::Array};
Buffer* indexBuffer = new Buffer{Buffer::TargetHint::ElementArray};
Mesh* mesh = new Mesh;
GL::Buffer* vertexBuffer = new GL::Buffer{GL::Buffer::TargetHint::Array};
GL::Buffer* indexBuffer = new GL::Buffer{GL::Buffer::TargetHint::ElementArray};
GL::Mesh* mesh = new GL::Mesh;
auto data = Renderer<dimensions>::meshData();
vertexBuffer->setData(MeshTools::interleave(data.positions(0), data.colors(0)), BufferUsage::StaticDraw);
vertexBuffer->setData(MeshTools::interleave(data.positions(0), data.colors(0)), GL::BufferUsage::StaticDraw);
ResourceManager::instance().set(_vertexBuffer.key(), vertexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
indexBuffer->setData(MeshTools::compressIndicesAs<UnsignedByte>(data.indices()), BufferUsage::StaticDraw);
indexBuffer->setData(MeshTools::compressIndicesAs<UnsignedByte>(data.indices()), GL::BufferUsage::StaticDraw);
ResourceManager::instance().set(_indexBuffer.key(), indexBuffer, ResourceDataState::Final, ResourcePolicy::Manual);
mesh->setPrimitive(MeshPrimitive::Lines)
mesh->setPrimitive(GL::MeshPrimitive::Lines)
.setCount(data.indices().size())
.addVertexBuffer(*vertexBuffer, 0,
typename Shaders::VertexColor<dimensions>::Position(),
typename Shaders::VertexColor<dimensions>::Color{Shaders::VertexColor<dimensions>::Color::Components::Four})
.setIndexBuffer(*indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, data.positions(0).size());
ResourceManager::instance().set<Mesh>(_mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
.setIndexBuffer(*indexBuffer, 0, GL::MeshIndexType::UnsignedByte, 0, data.positions(0).size());
ResourceManager::instance().set<GL::Mesh>(_mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual);
}
/* To avoid deleting pointers to incomplete type on destruction of Resource members */

9
src/Magnum/DebugTools/ObjectRenderer.h
Unescape View File

@ -30,9 +30,10 @@
*/
#include "Magnum/Resource.h"
#include "Magnum/DebugTools/visibility.h"
#include "Magnum/GL/GL.h"
#include "Magnum/SceneGraph/Drawable.h"
#include "Magnum/Shaders/Shaders.h"
#include "Magnum/DebugTools/visibility.h"
namespace Magnum { namespace DebugTools {
@ -104,9 +105,9 @@ template<UnsignedInt dimensions> class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer:
void draw(const MatrixTypeFor<dimensions, Float>& transformationMatrix, SceneGraph::Camera<dimensions, Float>& camera) override;
Resource<ObjectRendererOptions> _options;
Resource<AbstractShaderProgram, Shaders::VertexColor<dimensions>> _shader;
Resource<Mesh> _mesh;
Resource<Buffer> _vertexBuffer, _indexBuffer;
Resource<GL::AbstractShaderProgram, Shaders::VertexColor<dimensions>> _shader;
Resource<GL::Mesh> _mesh;
Resource<GL::Buffer> _vertexBuffer, _indexBuffer;
};
/** @brief Two-dimensional object renderer */

10
src/Magnum/DebugTools/ResourceManager.cpp
Unescape View File

@ -25,19 +25,19 @@
#include "ResourceManager.h"
#include "Magnum/AbstractShaderProgram.h"
#include "Magnum/Buffer.h"
#include "Magnum/Mesh.h"
#include "Magnum/MeshView.h"
#include "Magnum/ResourceManager.hpp"
#include "Magnum/DebugTools/ForceRenderer.h"
#include "Magnum/DebugTools/ObjectRenderer.h"
#include "Magnum/DebugTools/ShapeRenderer.h"
#include "Magnum/GL/AbstractShaderProgram.h"
#include "Magnum/GL/Buffer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/GL/MeshView.h"
namespace Magnum {
namespace Implementation {
template struct MAGNUM_DEBUGTOOLS_EXPORT ResourceManagerLocalInstanceImplementation<ResourceManagerLocalInstance, AbstractShaderProgram, Buffer, Mesh, MeshView, DebugTools::ForceRendererOptions, DebugTools::ObjectRendererOptions, DebugTools::ShapeRendererOptions>;
template struct MAGNUM_DEBUGTOOLS_EXPORT ResourceManagerLocalInstanceImplementation<ResourceManagerLocalInstance, GL::AbstractShaderProgram, GL::Buffer, GL::Mesh, GL::MeshView, DebugTools::ForceRendererOptions, DebugTools::ObjectRendererOptions, DebugTools::ShapeRendererOptions>;
}
namespace DebugTools {

11
src/Magnum/DebugTools/ResourceManager.h
Unescape View File

@ -34,18 +34,19 @@
#include "Magnum/Magnum.h"
#include "Magnum/DebugTools/DebugTools.h"
#include "Magnum/DebugTools/visibility.h"
#include "Magnum/GL/GL.h"
#include "Magnum/SceneGraph/SceneGraph.h"
#include "Magnum/Shapes/Shapes.h"
/** @todo fix this better */
#ifdef CORRADE_MSVC2017_COMPATIBILITY
#include "Magnum/AbstractShaderProgram.h"
#include "Magnum/Buffer.h"
#include "Magnum/Mesh.h"
#include "Magnum/MeshView.h"
#include "Magnum/DebugTools/ForceRenderer.h"
#include "Magnum/DebugTools/ObjectRenderer.h"
#include "Magnum/DebugTools/ShapeRenderer.h"
#include "Magnum/GL/AbstractShaderProgram.h"
#include "Magnum/GL/Buffer.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/GL/MeshView.h"
#endif
namespace Magnum {
@ -58,7 +59,7 @@ namespace DebugTools {
Stores various data used by debug renderers. See @ref debug-tools for more
information.
*/
class MAGNUM_DEBUGTOOLS_EXPORT ResourceManager: public Magnum::ResourceManager<Magnum::Implementation::ResourceManagerLocalInstance, AbstractShaderProgram, Buffer, Mesh, MeshView, DebugTools::ForceRendererOptions, DebugTools::ObjectRendererOptions, DebugTools::ShapeRendererOptions> {
class MAGNUM_DEBUGTOOLS_EXPORT ResourceManager: public Magnum::ResourceManager<Magnum::Implementation::ResourceManagerLocalInstance, GL::AbstractShaderProgram, GL::Buffer, GL::Mesh, GL::MeshView, DebugTools::ForceRendererOptions, DebugTools::ObjectRendererOptions, DebugTools::ShapeRendererOptions> {
public:
explicit ResourceManager();
~ResourceManager();

14
src/Magnum/DebugTools/ShapeRenderer.cpp
Unescape View File

@ -30,13 +30,13 @@
#include "Magnum/Shapes/Shape.h"
#include "Magnum/SceneGraph/Camera.h"
#include "Implementation/AxisAlignedBoxRenderer.h"
#include "Implementation/BoxRenderer.h"
#include "Implementation/CapsuleRenderer.h"
#include "Implementation/CylinderRenderer.h"
#include "Implementation/LineSegmentRenderer.h"
#include "Implementation/PointRenderer.h"
#include "Implementation/SphereRenderer.h"
#include "Magnum/DebugTools/Implementation/AxisAlignedBoxRenderer.h"
#include "Magnum/DebugTools/Implementation/BoxRenderer.h"
#include "Magnum/DebugTools/Implementation/CapsuleRenderer.h"
#include "Magnum/DebugTools/Implementation/CylinderRenderer.h"
#include "Magnum/DebugTools/Implementation/LineSegmentRenderer.h"
#include "Magnum/DebugTools/Implementation/PointRenderer.h"
#include "Magnum/DebugTools/Implementation/SphereRenderer.h"
namespace Magnum { namespace DebugTools {

16
src/Magnum/DebugTools/Test/BufferDataGLTest.cpp
Unescape View File

@ -25,12 +25,12 @@
#include <Corrade/TestSuite/Compare/Container.h>
#include "Magnum/OpenGLTester.h"
#include "Magnum/DebugTools/BufferData.h"
#include "Magnum/GL/OpenGLTester.h"
namespace Magnum { namespace DebugTools { namespace Test {
struct BufferDataGLTest: Magnum::OpenGLTester {
struct BufferDataGLTest: Magnum::GL::OpenGLTester {
explicit BufferDataGLTest();
void data();
@ -47,19 +47,19 @@ namespace {
}
void BufferDataGLTest::data() {
Buffer buffer;
buffer.setData(Data, BufferUsage::StaticDraw);
GL::Buffer buffer;
buffer.setData(Data, GL::BufferUsage::StaticDraw);
const Containers::Array<Int> contents = bufferData<Int>(buffer);
MAGNUM_VERIFY_NO_ERROR();
MAGNUM_VERIFY_NO_GL_ERROR();
CORRADE_COMPARE_AS(contents, Containers::arrayView(Data),
TestSuite::Compare::Container);
}
void BufferDataGLTest::subData() {
Buffer buffer;
buffer.setData(Data, BufferUsage::StaticDraw);
GL::Buffer buffer;
buffer.setData(Data, GL::BufferUsage::StaticDraw);
const Containers::Array<Int> contents = bufferSubData<Int>(buffer, 4, 3);
MAGNUM_VERIFY_NO_ERROR();
MAGNUM_VERIFY_NO_GL_ERROR();
CORRADE_COMPARE_AS(contents, Containers::arrayView(Data).slice(1, 4),
TestSuite::Compare::Container);
}

2
src/Magnum/DebugTools/Test/CapsuleRendererTest.cpp
Unescape View File

@ -25,7 +25,7 @@
#include <Corrade/TestSuite/Tester.h>
#include "../Implementation/CapsuleRendererTransformation.h"
#include "Magnum/DebugTools/Implementation/CapsuleRendererTransformation.h"
namespace Magnum { namespace DebugTools { namespace Test {

2
src/Magnum/DebugTools/Test/CompareImageTest.cpp
Unescape View File

@ -29,8 +29,8 @@
#include <Corrade/TestSuite/Compare/Container.h>
#include "Magnum/ImageView.h"
#include "Magnum/PixelFormat.h"
#include "Magnum/DebugTools/CompareImage.h"
#include "Magnum/GL/PixelFormat.h"
#include "Magnum/Math/Functions.h"
#include "Magnum/Math/Color.h"

2
src/Magnum/DebugTools/Test/CylinderRendererTest.cpp
Unescape View File

@ -25,7 +25,7 @@
#include <Corrade/TestSuite/Tester.h>
#include "../Implementation/CylinderRendererTransformation.h"
#include "Magnum/DebugTools/Implementation/CylinderRendererTransformation.h"
namespace Magnum { namespace DebugTools { namespace Test {

2
src/Magnum/DebugTools/Test/ForceRendererTest.cpp
Unescape View File

@ -26,7 +26,7 @@
#include <Corrade/TestSuite/Tester.h>
#include <Corrade/TestSuite/Compare/Numeric.h>
#include "../Implementation/ForceRendererTransformation.h"
#include "Magnum/DebugTools/Implementation/ForceRendererTransformation.h"
namespace Magnum { namespace DebugTools { namespace Implementation { namespace Test {

2
src/Magnum/DebugTools/Test/LineSegmentRendererTest.cpp
Unescape View File

@ -29,7 +29,7 @@
#include "Magnum/Math/Matrix3.h"
#include "Magnum/Math/Matrix4.h"
#include "../Implementation/LineSegmentRendererTransformation.h"
#include "Magnum/DebugTools/Implementation/LineSegmentRendererTransformation.h"
namespace Magnum { namespace DebugTools { namespace Test {

96
src/Magnum/DebugTools/Test/TextureImageGLTest.cpp
Unescape View File

@ -25,23 +25,23 @@
#include <Corrade/TestSuite/Compare/Container.h>
#include "Magnum/CubeMapTexture.h"
#include "Magnum/Image.h"
#include "Magnum/OpenGLTester.h"
#include "Magnum/PixelFormat.h"
#include "Magnum/Texture.h"
#include "Magnum/TextureFormat.h"
#include "Magnum/DebugTools/TextureImage.h"
#include "Magnum/GL/CubeMapTexture.h"
#include "Magnum/GL/OpenGLTester.h"
#include "Magnum/GL/PixelFormat.h"
#include "Magnum/GL/Texture.h"
#include "Magnum/GL/TextureFormat.h"
#include "Magnum/Math/Range.h"
#ifndef MAGNUM_TARGET_GLES2
#include "Magnum/DebugTools/BufferData.h"
#include "Magnum/BufferImage.h"
#include "Magnum/GL/BufferImage.h"
#endif
namespace Magnum { namespace DebugTools { namespace Test {
struct TextureImageGLTest: OpenGLTester {
struct TextureImageGLTest: GL::OpenGLTester {
explicit TextureImageGLTest();
void subImage2D();
@ -86,17 +86,17 @@ namespace {
}
void TextureImageGLTest::subImage2D() {
Texture2D texture;
GL::Texture2D texture;
texture.setImage(0,
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
TextureFormat::RGBA8,
GL::TextureFormat::RGBA8,
#else
TextureFormat::RGBA,
GL::TextureFormat::RGBA,
#endif
ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, Data2D});
ImageView2D{GL::PixelFormat::RGBA, GL::PixelType::UnsignedByte, Vector2i{2}, Data2D});
Image2D image = textureSubImage(texture, 0, {{}, Vector2i{2}}, {PixelFormat::RGBA, PixelType::UnsignedByte});
MAGNUM_VERIFY_NO_ERROR();
Image2D image = textureSubImage(texture, 0, {{}, Vector2i{2}}, {GL::PixelFormat::RGBA, GL::PixelType::UnsignedByte});
MAGNUM_VERIFY_NO_GL_ERROR();
CORRADE_COMPARE(image.size(), Vector2i{2});
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()),
Containers::arrayView(Data2D), TestSuite::Compare::Container);
@ -104,12 +104,12 @@ void TextureImageGLTest::subImage2D() {
#ifndef MAGNUM_TARGET_GLES2
void TextureImageGLTest::subImage2DBuffer() {
Texture2D texture;
texture.setImage(0, TextureFormat::RGBA8, ImageView2D{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, Data2D});
GL::Texture2D texture;
texture.setImage(0, GL::TextureFormat::RGBA8, ImageView2D{GL::PixelFormat::RGBA, GL::PixelType::UnsignedByte, Vector2i{2}, Data2D});
BufferImage2D image = textureSubImage(texture, 0, {{}, Vector2i{2}}, {PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
GL::BufferImage2D image = textureSubImage(texture, 0, {{}, Vector2i{2}}, {GL::PixelFormat::RGBA, GL::PixelType::UnsignedByte}, GL::BufferUsage::StaticRead);
Containers::Array<UnsignedByte> data = bufferData<UnsignedByte>(image.buffer());
MAGNUM_VERIFY_NO_ERROR();
MAGNUM_VERIFY_NO_GL_ERROR();
CORRADE_COMPARE(image.size(), Vector2i{2});
CORRADE_COMPARE_AS(data, Containers::arrayView(Data2D),
TestSuite::Compare::Container);
@ -117,24 +117,24 @@ void TextureImageGLTest::subImage2DBuffer() {
#endif
void TextureImageGLTest::subImageCube() {
ImageView2D view{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, Data2D};
ImageView2D view{GL::PixelFormat::RGBA, GL::PixelType::UnsignedByte, Vector2i{2}, Data2D};
#if !(defined(MAGNUM_TARGET_GLES2) && defined(MAGNUM_TARGET_WEBGL))
constexpr TextureFormat format = TextureFormat::RGBA8;
constexpr GL::TextureFormat format = GL::TextureFormat::RGBA8;
#else
constexpr TextureFormat format = TextureFormat::RGBA;
constexpr GL::TextureFormat format = GL::TextureFormat::RGBA;
#endif
CubeMapTexture texture;
texture.setImage(CubeMapCoordinate::PositiveX, 0, format, view)
.setImage(CubeMapCoordinate::NegativeX, 0, format, view)
.setImage(CubeMapCoordinate::PositiveY, 0, format, view)
.setImage(CubeMapCoordinate::NegativeY, 0, format, view)
.setImage(CubeMapCoordinate::PositiveZ, 0, format, view)
.setImage(CubeMapCoordinate::NegativeZ, 0, format, view);
GL::CubeMapTexture texture;
texture.setImage(GL::CubeMapCoordinate::PositiveX, 0, format, view)
.setImage(GL::CubeMapCoordinate::NegativeX, 0, format, view)
.setImage(GL::CubeMapCoordinate::PositiveY, 0, format, view)
.setImage(GL::CubeMapCoordinate::NegativeY, 0, format, view)
.setImage(GL::CubeMapCoordinate::PositiveZ, 0, format, view)
.setImage(GL::CubeMapCoordinate::NegativeZ, 0, format, view);
Image2D image = textureSubImage(texture, CubeMapCoordinate::PositiveX, 0, {{}, Vector2i{2}}, {PixelFormat::RGBA, PixelType::UnsignedByte});
MAGNUM_VERIFY_NO_ERROR();
Image2D image = textureSubImage(texture, GL::CubeMapCoordinate::PositiveX, 0, {{}, Vector2i{2}}, {GL::PixelFormat::RGBA, GL::PixelType::UnsignedByte});
MAGNUM_VERIFY_NO_GL_ERROR();
CORRADE_COMPARE(image.size(), Vector2i{2});
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedByte>(image.data()),
Containers::arrayView(Data2D), TestSuite::Compare::Container);
@ -142,19 +142,19 @@ void TextureImageGLTest::subImageCube() {
#ifndef MAGNUM_TARGET_GLES2
void TextureImageGLTest::subImageCubeBuffer() {
ImageView2D view{PixelFormat::RGBA, PixelType::UnsignedByte, Vector2i{2}, Data2D};
ImageView2D view{GL::PixelFormat::RGBA, GL::PixelType::UnsignedByte, Vector2i{2}, Data2D};
CubeMapTexture texture;
texture.setImage(CubeMapCoordinate::PositiveX, 0, TextureFormat::RGBA8, view)
.setImage(CubeMapCoordinate::NegativeX, 0, TextureFormat::RGBA8, view)
.setImage(CubeMapCoordinate::PositiveY, 0, TextureFormat::RGBA8, view)
.setImage(CubeMapCoordinate::NegativeY, 0, TextureFormat::RGBA8, view)
.setImage(CubeMapCoordinate::PositiveZ, 0, TextureFormat::RGBA8, view)
.setImage(CubeMapCoordinate::NegativeZ, 0, TextureFormat::RGBA8, view);
GL::CubeMapTexture texture;
texture.setImage(GL::CubeMapCoordinate::PositiveX, 0, GL::TextureFormat::RGBA8, view)
.setImage(GL::CubeMapCoordinate::NegativeX, 0, GL::TextureFormat::RGBA8, view)
.setImage(GL::CubeMapCoordinate::PositiveY, 0, GL::TextureFormat::RGBA8, view)
.setImage(GL::CubeMapCoordinate::NegativeY, 0, GL::TextureFormat::RGBA8, view)
.setImage(GL::CubeMapCoordinate::PositiveZ, 0, GL::TextureFormat::RGBA8, view)
.setImage(GL::CubeMapCoordinate::NegativeZ, 0, GL::TextureFormat::RGBA8, view);
BufferImage2D image = textureSubImage(texture, CubeMapCoordinate::PositiveX, 0, {{}, Vector2i{2}}, {PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
GL::BufferImage2D image = textureSubImage(texture, GL::CubeMapCoordinate::PositiveX, 0, {{}, Vector2i{2}}, {GL::PixelFormat::RGBA, GL::PixelType::UnsignedByte}, GL::BufferUsage::StaticRead);
Containers::Array<UnsignedByte> data = bufferData<UnsignedByte>(image.buffer());
MAGNUM_VERIFY_NO_ERROR();
MAGNUM_VERIFY_NO_GL_ERROR();
CORRADE_COMPARE(image.size(), Vector2i{2});
CORRADE_COMPARE_AS(data, Containers::arrayView(Data2D),
TestSuite::Compare::Container);
@ -170,11 +170,11 @@ namespace {
}
void TextureImageGLTest::subImage2DUInt() {
Texture2D texture;
texture.setImage(0, TextureFormat::R32UI, ImageView2D{PixelFormat::RedInteger, PixelType::UnsignedInt, Vector2i{2}, Data2DUInt});
GL::Texture2D texture;
texture.setImage(0, GL::TextureFormat::R32UI, ImageView2D{GL::PixelFormat::RedInteger, GL::PixelType::UnsignedInt, Vector2i{2}, Data2DUInt});
Image2D image = textureSubImage(texture, 0, {{}, Vector2i{2}}, {PixelFormat::RedInteger, PixelType::UnsignedInt});
MAGNUM_VERIFY_NO_ERROR();
Image2D image = textureSubImage(texture, 0, {{}, Vector2i{2}}, {GL::PixelFormat::RedInteger, GL::PixelType::UnsignedInt});
MAGNUM_VERIFY_NO_GL_ERROR();
CORRADE_COMPARE(image.size(), Vector2i{2});
CORRADE_COMPARE_AS(Containers::arrayCast<UnsignedInt>(image.data()),
Containers::arrayView(Data2DUInt),
@ -189,12 +189,12 @@ namespace {
}
void TextureImageGLTest::subImage2DFloat() {
Texture2D texture;
texture.setStorage(1, TextureFormat::R32F, Vector2i{2})
.setSubImage(0, {}, ImageView2D{PixelFormat::Red, PixelType::Float, Vector2i{2}, Data2DFloat});
GL::Texture2D texture;
texture.setStorage(1, GL::TextureFormat::R32F, Vector2i{2})
.setSubImage(0, {}, ImageView2D{GL::PixelFormat::Red, GL::PixelType::Float, Vector2i{2}, Data2DFloat});
Image2D image = textureSubImage(texture, 0, {{}, Vector2i{2}}, {PixelFormat::Red, PixelType::Float});
MAGNUM_VERIFY_NO_ERROR();
Image2D image = textureSubImage(texture, 0, {{}, Vector2i{2}}, {GL::PixelFormat::Red, GL::PixelType::Float});
MAGNUM_VERIFY_NO_GL_ERROR();
CORRADE_COMPARE(image.size(), Vector2i{2});
CORRADE_COMPARE_AS(Containers::arrayCast<Float>(image.data()),
Containers::arrayView(Data2DFloat),

60
src/Magnum/DebugTools/TextureImage.cpp
Unescape View File

@ -25,24 +25,24 @@
#include "TextureImage.h"
#include "Magnum/Image.h"
#ifndef MAGNUM_TARGET_GLES2
#include "Magnum/BufferImage.h"
#include "Magnum/GL/BufferImage.h"
#endif
#include "Magnum/Context.h"
#include "Magnum/Extensions.h"
#include "Magnum/Framebuffer.h"
#include "Magnum/Image.h"
#include "Magnum/Texture.h"
#include "Magnum/GL/Context.h"
#include "Magnum/GL/Extensions.h"
#include "Magnum/GL/Framebuffer.h"
#include "Magnum/GL/Texture.h"
#if defined(MAGNUM_TARGET_GLES) && !defined(MAGNUM_TARGET_GLES2)
#include <Corrade/Utility/Resource.h>
#include "Magnum/AbstractShaderProgram.h"
#include "Magnum/Mesh.h"
#include "Magnum/PixelFormat.h"
#include "Magnum/Shader.h"
#include "Magnum/TextureFormat.h"
#include "Magnum/Version.h"
#include "Magnum/GL/AbstractShaderProgram.h"
#include "Magnum/GL/Mesh.h"
#include "Magnum/GL/PixelFormat.h"
#include "Magnum/GL/Shader.h"
#include "Magnum/GL/TextureFormat.h"
#include "Magnum/GL/Version.h"
#ifdef MAGNUM_BUILD_STATIC
static void importDebugToolsResources() {
@ -95,9 +95,9 @@ FloatReinterpretShader::FloatReinterpretShader() {
}
#endif
void textureSubImage(Texture2D& texture, const Int level, const Range2Di& range, Image2D& image) {
void textureSubImage(GL::Texture2D& texture, const Int level, const Range2Di& range, Image2D& image) {
#ifndef MAGNUM_TARGET_GLES
if(Context::current().isExtensionSupported<Extensions::GL::ARB::get_texture_sub_image>()) {
if(Context::current().isExtensionSupported<GL::Extensions::ARB::get_texture_sub_image>()) {
texture.subImage(level, range, image);
return;
}
@ -163,55 +163,55 @@ void textureSubImage(Texture2D& texture, const Int level, const Range2Di& range,
}
#endif
Framebuffer fb{range};
fb.attachTexture(Framebuffer::ColorAttachment{0}, texture, level)
GL::Framebuffer fb{range};
fb.attachTexture(GL::Framebuffer::ColorAttachment{0}, texture, level)
.read(range, image);
}
Image2D textureSubImage(Texture2D& texture, const Int level, const Range2Di& range, Image2D&& image) {
Image2D textureSubImage(GL::Texture2D& texture, const Int level, const Range2Di& range, Image2D&& image) {
textureSubImage(texture, level, range, image);
return std::move(image);
}
#ifndef MAGNUM_TARGET_GLES2
void textureSubImage(Texture2D& texture, const Int level, const Range2Di& range, BufferImage2D& image, const BufferUsage usage) {
void textureSubImage(GL::Texture2D& texture, const Int level, const Range2Di& range, GL::BufferImage2D& image, const GL::BufferUsage usage) {
#ifndef MAGNUM_TARGET_GLES
if(Context::current().isExtensionSupported<Extensions::GL::ARB::get_texture_sub_image>()) {
if(Context::current().isExtensionSupported<GL::Extensions::ARB::get_texture_sub_image>()) {
texture.subImage(level, range, image, usage);
return;
}
#endif
Framebuffer fb{range};
fb.attachTexture(Framebuffer::ColorAttachment{0}, texture, level)
GL::Framebuffer fb{range};
fb.attachTexture(GL::Framebuffer::ColorAttachment{0}, texture, level)
.read(range, image, usage);
}
BufferImage2D textureSubImage(Texture2D& texture, const Int level, const Range2Di& range, BufferImage2D&& image, const BufferUsage usage) {
GL::BufferImage2D textureSubImage(GL::Texture2D& texture, const Int level, const Range2Di& range, GL::BufferImage2D&& image, const GL::BufferUsage usage) {
textureSubImage(texture, level, range, image, usage);
return std::move(image);
}
#endif
void textureSubImage(CubeMapTexture& texture, const CubeMapCoordinate coordinate, const Int level, const Range2Di& range, Image2D& image) {
Framebuffer fb{range};
fb.attachCubeMapTexture(Framebuffer::ColorAttachment{0}, texture, coordinate, level)
void textureSubImage(GL::CubeMapTexture& texture, const GL::CubeMapCoordinate coordinate, const Int level, const Range2Di& range, Image2D& image) {
GL::Framebuffer fb{range};
fb.attachCubeMapTexture(GL::Framebuffer::ColorAttachment{0}, texture, coordinate, level)
.read(range, image);
}
Image2D textureSubImage(CubeMapTexture& texture, const CubeMapCoordinate coordinate, const Int level, const Range2Di& range, Image2D&& image) {
Image2D textureSubImage(GL::CubeMapTexture& texture, const GL::CubeMapCoordinate coordinate, const Int level, const Range2Di& range, Image2D&& image) {
textureSubImage(texture, coordinate, level, range, image);
return std::move(image);
}
#ifndef MAGNUM_TARGET_GLES2
void textureSubImage(CubeMapTexture& texture, const CubeMapCoordinate coordinate, const Int level, const Range2Di& range, BufferImage2D& image, const BufferUsage usage) {
Framebuffer fb{range};
fb.attachCubeMapTexture(Framebuffer::ColorAttachment{0}, texture, coordinate, level)
void textureSubImage(GL::CubeMapTexture& texture, const GL::CubeMapCoordinate coordinate, const Int level, const Range2Di& range, GL::BufferImage2D& image, const GL::BufferUsage usage) {
GL::Framebuffer fb{range};
fb.attachCubeMapTexture(GL::Framebuffer::ColorAttachment{0}, texture, coordinate, level)
.read(range, image, usage);
}
BufferImage2D textureSubImage(CubeMapTexture& texture, const CubeMapCoordinate coordinate, const Int level, const Range2Di& range, BufferImage2D&& image, const BufferUsage usage) {
GL::BufferImage2D textureSubImage(GL::CubeMapTexture& texture, const GL::CubeMapCoordinate coordinate, const Int level, const Range2Di& range, GL::BufferImage2D&& image, const GL::BufferUsage usage) {
textureSubImage(texture, coordinate, level, range, image, usage);
return std::move(image);
}

17
src/Magnum/DebugTools/TextureImage.h
Unescape View File

@ -31,6 +31,7 @@
#include "Magnum/Magnum.h"
#include "Magnum/DebugTools/visibility.h"
#include "Magnum/GL/GL.h"
namespace Magnum { namespace DebugTools {
@ -49,7 +50,7 @@ reinterpreted as @ref PixelType::UnsignedInt using additional shader and
`floatBitsToUint()` GLSL function and then reinterpreted back to
@ref PixelType::Float when read to client memory.
*/
MAGNUM_DEBUGTOOLS_EXPORT void textureSubImage(Texture2D& texture, Int level, const Range2Di& range, Image2D& image);
MAGNUM_DEBUGTOOLS_EXPORT void textureSubImage(GL::Texture2D& texture, Int level, const Range2Di& range, Image2D& image);
/**
@brief Read range of given texture mip level to image
@ -60,7 +61,7 @@ Convenience alternative to the above, example usage:
Image2D image = DebugTools::textureSubImage(texture, 0, rect, {PixelFormat::RGBA, PixelType::UnsignedByte});
@endcode
*/
MAGNUM_DEBUGTOOLS_EXPORT Image2D textureSubImage(Texture2D& texture, Int level, const Range2Di& range, Image2D&& image);
MAGNUM_DEBUGTOOLS_EXPORT Image2D textureSubImage(GL::Texture2D& texture, Int level, const Range2Di& range, Image2D&& image);
/**
@brief Read range of given cube map texture coordinate mip level to image
@ -72,7 +73,7 @@ it (such as OpenGL ES) by creating a framebuffer object and using
Note that only @ref Magnum::PixelFormat "PixelFormat" and @ref PixelType values
that are marked as framebuffer readable are supported.
*/
MAGNUM_DEBUGTOOLS_EXPORT void textureSubImage(CubeMapTexture& texture, CubeMapCoordinate coordinate, Int level, const Range2Di& range, Image2D& image);
MAGNUM_DEBUGTOOLS_EXPORT void textureSubImage(GL::CubeMapTexture& texture, GL::CubeMapCoordinate coordinate, Int level, const Range2Di& range, Image2D& image);
/**
@brief Read range of given cube map texture coordinate mip level to image
@ -83,7 +84,7 @@ Convenience alternative to the above, example usage:
Image2D image = DebugTools::textureSubImage(texture, CubeMapCoordinate::PositiveX, 0, rect, {PixelFormat::RGBA, PixelType::UnsignedByte});
@endcode
*/
MAGNUM_DEBUGTOOLS_EXPORT Image2D textureSubImage(CubeMapTexture& texture, CubeMapCoordinate coordinate, Int level, const Range2Di& range, Image2D&& image);
MAGNUM_DEBUGTOOLS_EXPORT Image2D textureSubImage(GL::CubeMapTexture& texture, GL::CubeMapCoordinate coordinate, Int level, const Range2Di& range, Image2D&& image);
#ifndef MAGNUM_TARGET_GLES2
/**
@ -99,7 +100,7 @@ that are marked as framebuffer readable are supported.
@requires_gles30 Pixel buffer objects are not available in OpenGL ES 2.0.
@requires_webgl20 Pixel buffer objects are not available in WebGL 1.0.
*/
MAGNUM_DEBUGTOOLS_EXPORT void textureSubImage(Texture2D& texture, Int level, const Range2Di& range, BufferImage2D& image, BufferUsage usage);
MAGNUM_DEBUGTOOLS_EXPORT void textureSubImage(GL::Texture2D& texture, Int level, const Range2Di& range, GL::BufferImage2D& image, GL::BufferUsage usage);
/**
@brief Read range of given texture mip level to buffer image
@ -110,7 +111,7 @@ Convenience alternative to the above, example usage:
BufferImage2D image = DebugTools::textureSubImage(texture, 0, rect, {PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
@endcode
*/
MAGNUM_DEBUGTOOLS_EXPORT BufferImage2D textureSubImage(Texture2D& texture, Int level, const Range2Di& range, BufferImage2D&& image, BufferUsage usage);
MAGNUM_DEBUGTOOLS_EXPORT GL::BufferImage2D textureSubImage(GL::Texture2D& texture, Int level, const Range2Di& range, GL::BufferImage2D&& image, GL::BufferUsage usage);
/**
@brief Read range of given cube map texture coordinate mip level to buffer image
@ -124,7 +125,7 @@ that are marked as framebuffer readable are supported.
@requires_gles30 Pixel buffer objects are not available in OpenGL ES 2.0.
@requires_webgl20 Pixel buffer objects are not available in WebGL 1.0.
*/
MAGNUM_DEBUGTOOLS_EXPORT void textureSubImage(CubeMapTexture& texture, CubeMapCoordinate coordinate, Int level, const Range2Di& range, BufferImage2D& image, BufferUsage usage);
MAGNUM_DEBUGTOOLS_EXPORT void textureSubImage(GL::CubeMapTexture& texture, GL::CubeMapCoordinate coordinate, Int level, const Range2Di& range, GL::BufferImage2D& image, GL::BufferUsage usage);
/**
@brief Read range of given cube map texture coordinate mip level to buffer image
@ -135,7 +136,7 @@ Convenience alternative to the above, example usage:
BufferImage2D image = DebugTools::textureSubImage(texture, CubeMapCoordinate::PositiveX, 0, rect, {PixelFormat::RGBA, PixelType::UnsignedByte}, BufferUsage::StaticRead);
@endcode
*/
MAGNUM_DEBUGTOOLS_EXPORT BufferImage2D textureSubImage(CubeMapTexture& texture, CubeMapCoordinate coordinate, Int level, const Range2Di& range, BufferImage2D&& image, BufferUsage usage);
MAGNUM_DEBUGTOOLS_EXPORT GL::BufferImage2D textureSubImage(GL::CubeMapTexture& texture, GL::CubeMapCoordinate coordinate, Int level, const Range2Di& range, GL::BufferImage2D&& image, GL::BufferUsage usage);
#endif
}}

Write Preview
Loading…
Cancel
Save