From 623fda0dc7012fb441f59616e1d6c2a83deba1b1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Sun, 28 Apr 2013 19:35:47 +0200 Subject: [PATCH] Shaders: removed superfluous `*Shader` suffix from class names. --- src/DebugTools/ForceRenderer.cpp | 8 ++--- src/DebugTools/ForceRenderer.h | 2 +- .../Implementation/AbstractShapeRenderer.cpp | 10 +++--- .../Implementation/AbstractShapeRenderer.h | 2 +- .../Implementation/AxisAlignedBoxRenderer.cpp | 2 +- src/DebugTools/Implementation/BoxRenderer.cpp | 2 +- .../Implementation/LineSegmentRenderer.cpp | 2 +- .../Implementation/PointRenderer.cpp | 2 +- .../Implementation/SphereRenderer.cpp | 2 +- src/DebugTools/ObjectRenderer.cpp | 10 +++--- src/DebugTools/ObjectRenderer.h | 2 +- ...bstractVectorShader.h => AbstractVector.h} | 18 +++++------ ...torShader2D.vert => AbstractVector2D.vert} | 0 ...torShader3D.vert => AbstractVector3D.vert} | 0 src/Shaders/CMakeLists.txt | 32 +++++++++---------- ...ctorShader.cpp => DistanceFieldVector.cpp} | 20 ++++++------ ...orShader.frag => DistanceFieldVector.frag} | 0 ...ldVectorShader.h => DistanceFieldVector.h} | 28 ++++++++-------- src/Shaders/{FlatShader.cpp => Flat.cpp} | 14 ++++---- src/Shaders/{FlatShader.frag => Flat.frag} | 0 src/Shaders/{FlatShader.h => Flat.h} | 20 ++++++------ .../{FlatShader2D.vert => Flat2D.vert} | 0 .../{FlatShader3D.vert => Flat3D.vert} | 0 src/Shaders/{PhongShader.cpp => Phong.cpp} | 8 ++--- src/Shaders/{PhongShader.frag => Phong.frag} | 0 src/Shaders/{PhongShader.h => Phong.h} | 26 +++++++-------- src/Shaders/{PhongShader.vert => Phong.vert} | 0 src/Shaders/Shaders.h | 32 +++++++++---------- src/Shaders/{VectorShader.cpp => Vector.cpp} | 20 ++++++------ .../{VectorShader.frag => Vector.frag} | 0 src/Shaders/{VectorShader.h => Vector.h} | 24 +++++++------- ...{VertexColorShader.cpp => VertexColor.cpp} | 14 ++++---- ...ertexColorShader.frag => VertexColor.frag} | 0 .../{VertexColorShader.h => VertexColor.h} | 18 +++++------ ...xColorShader2D.vert => VertexColor2D.vert} | 0 ...xColorShader3D.vert => VertexColor3D.vert} | 0 src/Text/TextRenderer.cpp | 12 +++---- src/TextureTools/DistanceField.cpp | 11 ++++--- 38 files changed, 171 insertions(+), 170 deletions(-) rename src/Shaders/{AbstractVectorShader.h => AbstractVector.h} (74%) rename src/Shaders/{AbstractVectorShader2D.vert => AbstractVector2D.vert} (100%) rename src/Shaders/{AbstractVectorShader3D.vert => AbstractVector3D.vert} (100%) rename src/Shaders/{DistanceFieldVectorShader.cpp => DistanceFieldVector.cpp} (82%) rename src/Shaders/{DistanceFieldVectorShader.frag => DistanceFieldVector.frag} (100%) rename src/Shaders/{DistanceFieldVectorShader.h => DistanceFieldVector.h} (78%) rename src/Shaders/{FlatShader.cpp => Flat.cpp} (89%) rename src/Shaders/{FlatShader.frag => Flat.frag} (100%) rename src/Shaders/{FlatShader.h => Flat.h} (82%) rename src/Shaders/{FlatShader2D.vert => Flat2D.vert} (100%) rename src/Shaders/{FlatShader3D.vert => Flat3D.vert} (100%) rename src/Shaders/{PhongShader.cpp => Phong.cpp} (89%) rename src/Shaders/{PhongShader.frag => Phong.frag} (100%) rename src/Shaders/{PhongShader.h => Phong.h} (84%) rename src/Shaders/{PhongShader.vert => Phong.vert} (100%) rename src/Shaders/{VectorShader.cpp => Vector.cpp} (84%) rename src/Shaders/{VectorShader.frag => Vector.frag} (100%) rename src/Shaders/{VectorShader.h => Vector.h} (77%) rename src/Shaders/{VertexColorShader.cpp => VertexColor.cpp} (89%) rename src/Shaders/{VertexColorShader.frag => VertexColor.frag} (100%) rename src/Shaders/{VertexColorShader.h => VertexColor.h} (81%) rename src/Shaders/{VertexColorShader2D.vert => VertexColor2D.vert} (100%) rename src/Shaders/{VertexColorShader3D.vert => VertexColor3D.vert} (100%) diff --git a/src/DebugTools/ForceRenderer.cpp b/src/DebugTools/ForceRenderer.cpp index 618f97f9a..e0998962c 100644 --- a/src/DebugTools/ForceRenderer.cpp +++ b/src/DebugTools/ForceRenderer.cpp @@ -28,7 +28,7 @@ #include "Mesh.h" #include "DebugTools/ResourceManager.h" #include "SceneGraph/AbstractCamera.h" -#include "Shaders/FlatShader.h" +#include "Shaders/Flat.h" #include "DebugTools/Implementation/ForceRendererTransformation.h" @@ -66,8 +66,8 @@ const std::array indices{{ template ForceRenderer::ForceRenderer(SceneGraph::AbstractObject* object, const typename DimensionTraits::VectorType& forcePosition, const typename DimensionTraits::VectorType* force, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(object, drawables), forcePosition(forcePosition), force(force), options(ResourceManager::instance()->get(options)) { /* Shader */ - shader = ResourceManager::instance()->get>(shaderKey()); - if(!shader) ResourceManager::instance()->set(shader.key(), new Shaders::FlatShader); + shader = ResourceManager::instance()->get>(shaderKey()); + if(!shader) ResourceManager::instance()->set(shader.key(), new Shaders::Flat); /* Mesh and vertex buffer */ mesh = ResourceManager::instance()->get("force"); @@ -89,7 +89,7 @@ template ForceRenderer::ForceRenderer(SceneG mesh->setPrimitive(Mesh::Primitive::Lines) ->setIndexCount(indices.size()) ->addVertexBuffer(vertexBuffer, 0, - typename Shaders::FlatShader::Position(Shaders::FlatShader::Position::Components::Two)) + typename Shaders::Flat::Position(Shaders::Flat::Position::Components::Two)) ->setIndexBuffer(indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, positions.size()); ResourceManager::instance()->set(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual); } diff --git a/src/DebugTools/ForceRenderer.h b/src/DebugTools/ForceRenderer.h index 7af657909..ec4c370ef 100644 --- a/src/DebugTools/ForceRenderer.h +++ b/src/DebugTools/ForceRenderer.h @@ -128,7 +128,7 @@ template class MAGNUM_DEBUGTOOLS_EXPORT ForceRenderer: p const typename DimensionTraits::VectorType* const force; Resource options; - Resource> shader; + Resource> shader; Resource mesh; Resource vertexBuffer, indexBuffer; }; diff --git a/src/DebugTools/Implementation/AbstractShapeRenderer.cpp b/src/DebugTools/Implementation/AbstractShapeRenderer.cpp index b976cb576..c11985bd5 100644 --- a/src/DebugTools/Implementation/AbstractShapeRenderer.cpp +++ b/src/DebugTools/Implementation/AbstractShapeRenderer.cpp @@ -29,7 +29,7 @@ #include "Mesh.h" #include "DebugTools/ResourceManager.h" #include "MeshTools/CompressIndices.h" -#include "Shaders/FlatShader.h" +#include "Shaders/Flat.h" #include "Trade/MeshData2D.h" #include "Trade/MeshData3D.h" @@ -53,7 +53,7 @@ template<> void create<2>(Trade::MeshData2D& data, Resource& meshResource, Mesh* mesh = new Mesh; mesh->setPrimitive(data.primitive()) ->setVertexCount(data.positions(0)->size()) - ->addVertexBuffer(buffer, 0, Shaders::FlatShader2D::Position()); + ->addVertexBuffer(buffer, 0, Shaders::Flat2D::Position()); ResourceManager::instance()->set(meshResource.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual); /* Index buffer, if needed, if not, resource key doesn't have to be set */ @@ -75,7 +75,7 @@ template<> void create<3>(Trade::MeshData3D& data, Resource& meshResource, Mesh* mesh = new Mesh; mesh->setPrimitive(data.primitive()) ->setVertexCount(data.positions(0)->size()) - ->addVertexBuffer(vertexBuffer, 0, Shaders::FlatShader3D::Position()); + ->addVertexBuffer(vertexBuffer, 0, Shaders::Flat3D::Position()); ResourceManager::instance()->set(meshResource.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual); /* Index buffer, if needed, if not, resource key doesn't have to be set */ @@ -90,13 +90,13 @@ template<> void create<3>(Trade::MeshData3D& data, Resource& meshResource, } template AbstractShapeRenderer::AbstractShapeRenderer(ResourceKey meshKey, ResourceKey vertexBufferKey, ResourceKey indexBufferKey) { - wireframeShader = ResourceManager::instance()->get>(shaderKey()); + wireframeShader = ResourceManager::instance()->get>(shaderKey()); wireframeMesh = ResourceManager::instance()->get(meshKey); vertexBuffer = ResourceManager::instance()->get(vertexBufferKey); indexBuffer = ResourceManager::instance()->get(indexBufferKey); if(!wireframeShader) ResourceManager::instance()->set(shaderKey(), - new Shaders::FlatShader, ResourceDataState::Final, ResourcePolicy::Resident); + new Shaders::Flat, ResourceDataState::Final, ResourcePolicy::Resident); } template AbstractShapeRenderer::~AbstractShapeRenderer() {} diff --git a/src/DebugTools/Implementation/AbstractShapeRenderer.h b/src/DebugTools/Implementation/AbstractShapeRenderer.h index 25105f6c4..4670c0d5d 100644 --- a/src/DebugTools/Implementation/AbstractShapeRenderer.h +++ b/src/DebugTools/Implementation/AbstractShapeRenderer.h @@ -49,7 +49,7 @@ template class AbstractShapeRenderer { /* Call only if the mesh resource isn't already present */ void createResources(typename MeshData::Type data); - Resource> wireframeShader; + Resource> wireframeShader; Resource wireframeMesh; private: diff --git a/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp b/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp index 4072650b5..daaa4673e 100644 --- a/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp +++ b/src/DebugTools/Implementation/AxisAlignedBoxRenderer.cpp @@ -27,7 +27,7 @@ #include "Mesh.h" #include "DebugTools/ShapeRenderer.h" #include "Physics/AxisAlignedBox.h" -#include "Shaders/FlatShader.h" +#include "Shaders/Flat.h" namespace Magnum { namespace DebugTools { namespace Implementation { diff --git a/src/DebugTools/Implementation/BoxRenderer.cpp b/src/DebugTools/Implementation/BoxRenderer.cpp index 4e0bcb9fd..a39356a91 100644 --- a/src/DebugTools/Implementation/BoxRenderer.cpp +++ b/src/DebugTools/Implementation/BoxRenderer.cpp @@ -27,7 +27,7 @@ #include "Mesh.h" #include "DebugTools/ShapeRenderer.h" #include "Physics/Box.h" -#include "Shaders/FlatShader.h" +#include "Shaders/Flat.h" namespace Magnum { namespace DebugTools { namespace Implementation { diff --git a/src/DebugTools/Implementation/LineSegmentRenderer.cpp b/src/DebugTools/Implementation/LineSegmentRenderer.cpp index 900b96055..5ef695b9c 100644 --- a/src/DebugTools/Implementation/LineSegmentRenderer.cpp +++ b/src/DebugTools/Implementation/LineSegmentRenderer.cpp @@ -28,7 +28,7 @@ #include "DebugTools/ShapeRenderer.h" #include "Physics/Line.h" #include "Primitives/Line.h" -#include "Shaders/FlatShader.h" +#include "Shaders/Flat.h" #include "Trade/MeshData2D.h" #include "Trade/MeshData3D.h" diff --git a/src/DebugTools/Implementation/PointRenderer.cpp b/src/DebugTools/Implementation/PointRenderer.cpp index 31283541a..de84bcd2a 100644 --- a/src/DebugTools/Implementation/PointRenderer.cpp +++ b/src/DebugTools/Implementation/PointRenderer.cpp @@ -28,7 +28,7 @@ #include "DebugTools/ShapeRenderer.h" #include "Physics/Point.h" #include "Primitives/Crosshair.h" -#include "Shaders/FlatShader.h" +#include "Shaders/Flat.h" #include "Trade/MeshData2D.h" #include "Trade/MeshData3D.h" diff --git a/src/DebugTools/Implementation/SphereRenderer.cpp b/src/DebugTools/Implementation/SphereRenderer.cpp index be6f8d2f5..a45bc12ee 100644 --- a/src/DebugTools/Implementation/SphereRenderer.cpp +++ b/src/DebugTools/Implementation/SphereRenderer.cpp @@ -28,7 +28,7 @@ #include "DebugTools/ShapeRenderer.h" #include "Physics/Sphere.h" #include "Primitives/Circle.h" -#include "Shaders/FlatShader.h" +#include "Shaders/Flat.h" #include "Trade/MeshData2D.h" namespace Magnum { namespace DebugTools { namespace Implementation { diff --git a/src/DebugTools/ObjectRenderer.cpp b/src/DebugTools/ObjectRenderer.cpp index 240febe45..a54d3dbf1 100644 --- a/src/DebugTools/ObjectRenderer.cpp +++ b/src/DebugTools/ObjectRenderer.cpp @@ -28,7 +28,7 @@ #include "DebugTools/ResourceManager.h" #include "MeshTools/Interleave.h" #include "SceneGraph/AbstractCamera.h" -#include "Shaders/VertexColorShader.h" +#include "Shaders/VertexColor.h" namespace Magnum { namespace DebugTools { @@ -144,8 +144,8 @@ const std::array Renderer<3>::indices{{ template ObjectRenderer::ObjectRenderer(SceneGraph::AbstractObject* object, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(object, drawables), options(ResourceManager::instance()->get(options)) { /* Shader */ - shader = ResourceManager::instance()->get>(Renderer::shader()); - if(!shader) ResourceManager::instance()->set(shader.key(), new Shaders::VertexColorShader); + shader = ResourceManager::instance()->get>(Renderer::shader()); + if(!shader) ResourceManager::instance()->set(shader.key(), new Shaders::VertexColor); /* Mesh and vertex buffer */ mesh = ResourceManager::instance()->get(Renderer::mesh()); @@ -167,8 +167,8 @@ template ObjectRenderer::ObjectRenderer(Scen mesh->setPrimitive(Mesh::Primitive::Lines) ->setIndexCount(Renderer::indices.size()) ->addInterleavedVertexBuffer(vertexBuffer, 0, - typename Shaders::VertexColorShader::Position(), - typename Shaders::VertexColorShader::Color()) + typename Shaders::VertexColor::Position(), + typename Shaders::VertexColor::Color()) ->setIndexBuffer(indexBuffer, 0, Mesh::IndexType::UnsignedByte, 0, Renderer::positions.size()); ResourceManager::instance()->set(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual); } diff --git a/src/DebugTools/ObjectRenderer.h b/src/DebugTools/ObjectRenderer.h index cbafafd98..1955a2854 100644 --- a/src/DebugTools/ObjectRenderer.h +++ b/src/DebugTools/ObjectRenderer.h @@ -104,7 +104,7 @@ template class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer: private: Resource options; - Resource> shader; + Resource> shader; Resource mesh; Resource vertexBuffer, indexBuffer; }; diff --git a/src/Shaders/AbstractVectorShader.h b/src/Shaders/AbstractVector.h similarity index 74% rename from src/Shaders/AbstractVectorShader.h rename to src/Shaders/AbstractVector.h index 75d2f6e23..1337e7ae0 100644 --- a/src/Shaders/AbstractVectorShader.h +++ b/src/Shaders/AbstractVector.h @@ -1,5 +1,5 @@ -#ifndef Magnum_Shaders_AbstractVectorShader_h -#define Magnum_Shaders_AbstractVectorShader_h +#ifndef Magnum_Shaders_AbstractVector_h +#define Magnum_Shaders_AbstractVector_h /* This file is part of Magnum. @@ -25,7 +25,7 @@ */ /** @file - * @brief Class Magnum::Shaders::AbstractVectorShader, typedef Magnum::Shaders::AbstractVectorShader2D, Magnum::Shaders::AbstractVectorShader3D + * @brief Class Magnum::Shaders::AbstractVector, typedef Magnum::Shaders::AbstractVector2D, Magnum::Shaders::AbstractVector3D */ #include "AbstractShaderProgram.h" @@ -37,9 +37,9 @@ namespace Magnum { namespace Shaders { /** @brief Base for vector shaders -@see AbstractVectorShader2D, AbstractVectorShader3D +@see AbstractVector2D, AbstractVector3D */ -template class AbstractVectorShader: public AbstractShaderProgram { +template class AbstractVector: public AbstractShaderProgram { public: /** @brief Vertex position */ typedef Attribute<0, typename DimensionTraits::VectorType> Position; @@ -51,16 +51,16 @@ template class AbstractVectorShader: public AbstractShad VectorTextureLayer = 16 /**< Layer for vector texture */ }; - virtual ~AbstractVectorShader() = 0; + virtual ~AbstractVector() = 0; }; -template inline AbstractVectorShader::~AbstractVectorShader() {} +template inline AbstractVector::~AbstractVector() {} /** @brief Base for two-dimensional text shaders */ -typedef AbstractVectorShader<2> AbstractVectorShader2D; +typedef AbstractVector<2> AbstractVector2D; /** @brief Base for three-dimensional text shader */ -typedef AbstractVectorShader<3> AbstractVectorShader3D; +typedef AbstractVector<3> AbstractVector3D; }} diff --git a/src/Shaders/AbstractVectorShader2D.vert b/src/Shaders/AbstractVector2D.vert similarity index 100% rename from src/Shaders/AbstractVectorShader2D.vert rename to src/Shaders/AbstractVector2D.vert diff --git a/src/Shaders/AbstractVectorShader3D.vert b/src/Shaders/AbstractVector3D.vert similarity index 100% rename from src/Shaders/AbstractVectorShader3D.vert rename to src/Shaders/AbstractVector3D.vert diff --git a/src/Shaders/CMakeLists.txt b/src/Shaders/CMakeLists.txt index d5eff9498..35939575c 100644 --- a/src/Shaders/CMakeLists.txt +++ b/src/Shaders/CMakeLists.txt @@ -23,29 +23,29 @@ # corrade_add_resource(MagnumShaders_RCS MagnumShaders - AbstractVectorShader2D.vert AbstractVectorShader3D.vert - FlatShader2D.vert FlatShader3D.vert FlatShader.frag - PhongShader.vert PhongShader.frag - VectorShader.frag DistanceFieldVectorShader.frag - VertexColorShader2D.vert VertexColorShader3D.vert VertexColorShader.frag + AbstractVector2D.vert AbstractVector3D.vert + Flat2D.vert Flat3D.vert Flat.frag + Phong.vert Phong.frag + Vector.frag DistanceFieldVector.frag + VertexColor2D.vert VertexColor3D.vert VertexColor.frag compatibility.glsl) set(MagnumShaders_SRCS - DistanceFieldVectorShader.cpp - FlatShader.cpp - PhongShader.cpp - VectorShader.cpp - VertexColorShader.cpp + DistanceFieldVector.cpp + Flat.cpp + Phong.cpp + Vector.cpp + VertexColor.cpp ${MagnumShaders_RCS}) set(MagnumShaders_HEADERS - DistanceFieldVectorShader.h - AbstractVectorShader.h - FlatShader.h - PhongShader.h + DistanceFieldVector.h + AbstractVector.h + Flat.h + Phong.h Shaders.h - VectorShader.h - VertexColorShader.h + Vector.h + VertexColor.h magnumShadersVisibility.h) diff --git a/src/Shaders/DistanceFieldVectorShader.cpp b/src/Shaders/DistanceFieldVector.cpp similarity index 82% rename from src/Shaders/DistanceFieldVectorShader.cpp rename to src/Shaders/DistanceFieldVector.cpp index e3ec1c106..94ab352dc 100644 --- a/src/Shaders/DistanceFieldVectorShader.cpp +++ b/src/Shaders/DistanceFieldVector.cpp @@ -22,7 +22,7 @@ DEALINGS IN THE SOFTWARE. */ -#include "DistanceFieldVectorShader.h" +#include "DistanceFieldVector.h" #include @@ -34,11 +34,11 @@ namespace Magnum { namespace Shaders { namespace { template constexpr const char* vertexShaderName(); - template<> constexpr const char* vertexShaderName<2>() { return "AbstractVectorShader2D.vert"; } - template<> constexpr const char* vertexShaderName<3>() { return "AbstractVectorShader3D.vert"; } + template<> constexpr const char* vertexShaderName<2>() { return "AbstractVector2D.vert"; } + template<> constexpr const char* vertexShaderName<3>() { return "AbstractVector3D.vert"; } } -template DistanceFieldVectorShader::DistanceFieldVectorShader(): transformationProjectionMatrixUniform(0), colorUniform(1), outlineColorUniform(2), outlineRangeUniform(3), smoothnessUniform(4) { +template DistanceFieldVector::DistanceFieldVector(): transformationProjectionMatrixUniform(0), colorUniform(1), outlineColorUniform(2), outlineRangeUniform(3), smoothnessUniform(4) { Corrade::Utility::Resource rs("MagnumShaders"); #ifndef MAGNUM_TARGET_GLES @@ -54,7 +54,7 @@ template DistanceFieldVectorShader::Distance Shader fragmentShader(v, Shader::Type::Fragment); fragmentShader.addSource(rs.get("compatibility.glsl")); - fragmentShader.addSource(rs.get("DistanceFieldVectorShader.frag")); + fragmentShader.addSource(rs.get("DistanceFieldVector.frag")); AbstractShaderProgram::attachShader(fragmentShader); #ifndef MAGNUM_TARGET_GLES @@ -64,8 +64,8 @@ template DistanceFieldVectorShader::Distance if(!Context::current()->isVersionSupported(Version::GLES300)) #endif { - AbstractShaderProgram::bindAttributeLocation(AbstractVectorShader::Position::Location, "position"); - AbstractShaderProgram::bindAttributeLocation(AbstractVectorShader::TextureCoordinates::Location, "textureCoordinates"); + AbstractShaderProgram::bindAttributeLocation(AbstractVector::Position::Location, "position"); + AbstractShaderProgram::bindAttributeLocation(AbstractVector::TextureCoordinates::Location, "textureCoordinates"); } AbstractShaderProgram::link(); @@ -84,11 +84,11 @@ template DistanceFieldVectorShader::Distance #ifndef MAGNUM_TARGET_GLES if(!Context::current()->isExtensionSupported()) AbstractShaderProgram::setUniform(AbstractShaderProgram::uniformLocation("vectorTexture"), - AbstractVectorShader::VectorTextureLayer); + AbstractVector::VectorTextureLayer); #endif } -template class DistanceFieldVectorShader<2>; -template class DistanceFieldVectorShader<3>; +template class DistanceFieldVector<2>; +template class DistanceFieldVector<3>; }} diff --git a/src/Shaders/DistanceFieldVectorShader.frag b/src/Shaders/DistanceFieldVector.frag similarity index 100% rename from src/Shaders/DistanceFieldVectorShader.frag rename to src/Shaders/DistanceFieldVector.frag diff --git a/src/Shaders/DistanceFieldVectorShader.h b/src/Shaders/DistanceFieldVector.h similarity index 78% rename from src/Shaders/DistanceFieldVectorShader.h rename to src/Shaders/DistanceFieldVector.h index e938ee695..544557fd0 100644 --- a/src/Shaders/DistanceFieldVectorShader.h +++ b/src/Shaders/DistanceFieldVector.h @@ -1,5 +1,5 @@ -#ifndef Magnum_Shaders_DistanceFieldVectorShader_h -#define Magnum_Shaders_DistanceFieldVectorShader_h +#ifndef Magnum_Shaders_DistanceFieldVector_h +#define Magnum_Shaders_DistanceFieldVector_h /* This file is part of Magnum. @@ -25,12 +25,12 @@ */ /** @file - * @brief Class Magnum::Shaders::DistanceFieldVectorShader, typedef Magnum::Shaders::DistanceFieldVectorShader2D, Magnum::Shaders::DistanceFieldVectorShader3D + * @brief Class Magnum::Shaders::DistanceFieldVector, typedef Magnum::Shaders::DistanceFieldVector2D, Magnum::Shaders::DistanceFieldVector3D */ #include "Math/Matrix3.h" #include "Math/Matrix4.h" -#include "AbstractVectorShader.h" +#include "AbstractVector.h" #include "magnumShadersVisibility.h" @@ -42,14 +42,14 @@ namespace Magnum { namespace Shaders { Renders vector art in form of signed distance field. See TextureTools::distanceField() for more information. Note that the final rendered outlook will greatly depend on radius of input distance field and value passed to setSmoothness(). -@see DistanceFieldVectorShader2D, DistanceFieldVectorShader3D +@see DistanceFieldVector2D, DistanceFieldVector3D */ -template class MAGNUM_SHADERS_EXPORT DistanceFieldVectorShader: public AbstractVectorShader { +template class MAGNUM_SHADERS_EXPORT DistanceFieldVector: public AbstractVector { public: - DistanceFieldVectorShader(); + DistanceFieldVector(); /** @brief Set transformation and projection matrix */ - inline DistanceFieldVectorShader* setTransformationProjectionMatrix(const typename DimensionTraits::MatrixType& matrix) { + inline DistanceFieldVector* setTransformationProjectionMatrix(const typename DimensionTraits::MatrixType& matrix) { AbstractShaderProgram::setUniform(transformationProjectionMatrixUniform, matrix); return this; } @@ -60,7 +60,7 @@ template class MAGNUM_SHADERS_EXPORT DistanceFieldVector * * @see setOutlineColor() */ - inline DistanceFieldVectorShader* setColor(const Color4<>& color) { + inline DistanceFieldVector* setColor(const Color4<>& color) { AbstractShaderProgram::setUniform(colorUniform, color); return this; } @@ -71,7 +71,7 @@ template class MAGNUM_SHADERS_EXPORT DistanceFieldVector * * @see setOutlineRange(), setColor() */ - inline DistanceFieldVectorShader* setOutlineColor(const Color4<>& color) { + inline DistanceFieldVector* setOutlineColor(const Color4<>& color) { AbstractShaderProgram::setUniform(outlineColorUniform, color); return this; } @@ -90,7 +90,7 @@ template class MAGNUM_SHADERS_EXPORT DistanceFieldVector * * @see setOutlineColor() */ - inline DistanceFieldVectorShader* setOutlineRange(Float start, Float end) { + inline DistanceFieldVector* setOutlineRange(Float start, Float end) { AbstractShaderProgram::setUniform(outlineRangeUniform, Vector2(start, end)); return this; } @@ -103,7 +103,7 @@ template class MAGNUM_SHADERS_EXPORT DistanceFieldVector * values will make them look more crisp (but possibly aliased). Initial * value is `0.04f`. */ - inline DistanceFieldVectorShader* setSmoothness(Float value) { + inline DistanceFieldVector* setSmoothness(Float value) { AbstractShaderProgram::setUniform(smoothnessUniform, value); return this; } @@ -117,10 +117,10 @@ template class MAGNUM_SHADERS_EXPORT DistanceFieldVector }; /** @brief Two-dimensional distance field vector shader */ -typedef DistanceFieldVectorShader<2> DistanceFieldVectorShader2D; +typedef DistanceFieldVector<2> DistanceFieldVector2D; /** @brief Three-dimensional distance field vector shader */ -typedef DistanceFieldVectorShader<3> DistanceFieldVectorShader3D; +typedef DistanceFieldVector<3> DistanceFieldVector3D; }} diff --git a/src/Shaders/FlatShader.cpp b/src/Shaders/Flat.cpp similarity index 89% rename from src/Shaders/FlatShader.cpp rename to src/Shaders/Flat.cpp index afbdb8731..1eebdd955 100644 --- a/src/Shaders/FlatShader.cpp +++ b/src/Shaders/Flat.cpp @@ -22,7 +22,7 @@ DEALINGS IN THE SOFTWARE. */ -#include "FlatShader.h" +#include "Flat.h" #include @@ -33,11 +33,11 @@ namespace Magnum { namespace Shaders { namespace { template constexpr const char* vertexShaderName(); - template<> constexpr const char* vertexShaderName<2>() { return "FlatShader2D.vert"; } - template<> constexpr const char* vertexShaderName<3>() { return "FlatShader3D.vert"; } + template<> constexpr const char* vertexShaderName<2>() { return "Flat2D.vert"; } + template<> constexpr const char* vertexShaderName<3>() { return "Flat3D.vert"; } } -template FlatShader::FlatShader(): transformationProjectionMatrixUniform(0), colorUniform(1) { +template Flat::Flat(): transformationProjectionMatrixUniform(0), colorUniform(1) { Corrade::Utility::Resource rs("MagnumShaders"); #ifndef MAGNUM_TARGET_GLES @@ -53,7 +53,7 @@ template FlatShader::FlatShader(): transform Shader fragmentShader(v, Shader::Type::Fragment); fragmentShader.addSource(rs.get("compatibility.glsl")); - fragmentShader.addSource(rs.get("FlatShader.frag")); + fragmentShader.addSource(rs.get("Flat.frag")); attachShader(fragmentShader); #ifndef MAGNUM_TARGET_GLES @@ -77,7 +77,7 @@ template FlatShader::FlatShader(): transform } } -template class FlatShader<2>; -template class FlatShader<3>; +template class Flat<2>; +template class Flat<3>; }} diff --git a/src/Shaders/FlatShader.frag b/src/Shaders/Flat.frag similarity index 100% rename from src/Shaders/FlatShader.frag rename to src/Shaders/Flat.frag diff --git a/src/Shaders/FlatShader.h b/src/Shaders/Flat.h similarity index 82% rename from src/Shaders/FlatShader.h rename to src/Shaders/Flat.h index 71f5e7d49..be01877fd 100644 --- a/src/Shaders/FlatShader.h +++ b/src/Shaders/Flat.h @@ -1,5 +1,5 @@ -#ifndef Magnum_Shaders_FlatShader_h -#define Magnum_Shaders_FlatShader_h +#ifndef Magnum_Shaders_Flat_h +#define Magnum_Shaders_Flat_h /* This file is part of Magnum. @@ -25,7 +25,7 @@ */ /** @file - * @brief Class Magnum::Shaders::FlatShader + * @brief Class Magnum::Shaders::Flat */ #include "Math/Matrix3.h" @@ -42,20 +42,20 @@ namespace Magnum { namespace Shaders { @brief Flat shader Draws whole mesh with one color. -@see FlatShader2D, FlatShader3D +@see Flat2D, Flat3D */ -template class MAGNUM_SHADERS_EXPORT FlatShader: public AbstractShaderProgram { +template class MAGNUM_SHADERS_EXPORT Flat: public AbstractShaderProgram { public: /** @brief Vertex position */ typedef Attribute<0, typename DimensionTraits::VectorType> Position; - explicit FlatShader(); + explicit Flat(); /** * @brief Set transformation and projection matrix * @return Pointer to self (for method chaining) */ - FlatShader* setTransformationProjectionMatrix(const typename DimensionTraits::MatrixType& matrix) { + Flat* setTransformationProjectionMatrix(const typename DimensionTraits::MatrixType& matrix) { setUniform(transformationProjectionMatrixUniform, matrix); return this; } @@ -64,7 +64,7 @@ template class MAGNUM_SHADERS_EXPORT FlatShader: public * @brief Set color * @return Pointer to self (for method chaining) */ - FlatShader* setColor(const Color4<>& color) { + Flat* setColor(const Color4<>& color) { setUniform(colorUniform, color); return this; } @@ -75,10 +75,10 @@ template class MAGNUM_SHADERS_EXPORT FlatShader: public }; /** @brief 2D flat shader */ -typedef FlatShader<2> FlatShader2D; +typedef Flat<2> Flat2D; /** @brief 3D flat shader */ -typedef FlatShader<3> FlatShader3D; +typedef Flat<3> Flat3D; }} diff --git a/src/Shaders/FlatShader2D.vert b/src/Shaders/Flat2D.vert similarity index 100% rename from src/Shaders/FlatShader2D.vert rename to src/Shaders/Flat2D.vert diff --git a/src/Shaders/FlatShader3D.vert b/src/Shaders/Flat3D.vert similarity index 100% rename from src/Shaders/FlatShader3D.vert rename to src/Shaders/Flat3D.vert diff --git a/src/Shaders/PhongShader.cpp b/src/Shaders/Phong.cpp similarity index 89% rename from src/Shaders/PhongShader.cpp rename to src/Shaders/Phong.cpp index a953c3d8a..5a1c8c24e 100644 --- a/src/Shaders/PhongShader.cpp +++ b/src/Shaders/Phong.cpp @@ -22,7 +22,7 @@ DEALINGS IN THE SOFTWARE. */ -#include "PhongShader.h" +#include "Phong.h" #include @@ -31,7 +31,7 @@ namespace Magnum { namespace Shaders { -PhongShader::PhongShader(): transformationMatrixUniform(0), projectionMatrixUniform(1), normalMatrixUniform(2), lightUniform(3), diffuseColorUniform(4), ambientColorUniform(5), specularColorUniform(6), lightColorUniform(7), shininessUniform(8) { +Phong::Phong(): transformationMatrixUniform(0), projectionMatrixUniform(1), normalMatrixUniform(2), lightUniform(3), diffuseColorUniform(4), ambientColorUniform(5), specularColorUniform(6), lightColorUniform(7), shininessUniform(8) { Corrade::Utility::Resource rs("MagnumShaders"); #ifndef MAGNUM_TARGET_GLES @@ -42,12 +42,12 @@ PhongShader::PhongShader(): transformationMatrixUniform(0), projectionMatrixUnif Shader vertexShader(v, Shader::Type::Vertex); vertexShader.addSource(rs.get("compatibility.glsl")); - vertexShader.addSource(rs.get("PhongShader.vert")); + vertexShader.addSource(rs.get("Phong.vert")); attachShader(vertexShader); Shader fragmentShader(v, Shader::Type::Fragment); fragmentShader.addSource(rs.get("compatibility.glsl")); - fragmentShader.addSource(rs.get("PhongShader.frag")); + fragmentShader.addSource(rs.get("Phong.frag")); attachShader(fragmentShader); #ifndef MAGNUM_TARGET_GLES diff --git a/src/Shaders/PhongShader.frag b/src/Shaders/Phong.frag similarity index 100% rename from src/Shaders/PhongShader.frag rename to src/Shaders/Phong.frag diff --git a/src/Shaders/PhongShader.h b/src/Shaders/Phong.h similarity index 84% rename from src/Shaders/PhongShader.h rename to src/Shaders/Phong.h index 98b3312d6..2768db0a2 100644 --- a/src/Shaders/PhongShader.h +++ b/src/Shaders/Phong.h @@ -1,5 +1,5 @@ -#ifndef Magnum_Shaders_PhongShader_h -#define Magnum_Shaders_PhongShader_h +#ifndef Magnum_Shaders_Phong_h +#define Magnum_Shaders_Phong_h /* This file is part of Magnum. @@ -25,7 +25,7 @@ */ /** @file - * @brief Class Magnum::Shaders::PhongShader + * @brief Class Magnum::Shaders::Phong */ #include "Math/Matrix4.h" @@ -42,12 +42,12 @@ namespace Magnum { namespace Shaders { If supported, uses GLSL 3.20 and @extension{ARB,explicit_attrib_location}, otherwise falls back to GLSL 1.20. */ -class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram { +class MAGNUM_SHADERS_EXPORT Phong: public AbstractShaderProgram { public: typedef Attribute<0, Vector3> Position; /**< @brief Vertex position */ typedef Attribute<1, Vector3> Normal; /**< @brief Normal direction */ - explicit PhongShader(); + explicit Phong(); /** * @brief Set ambient color @@ -55,7 +55,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram { * * If not set, default value is `(0.0f, 0.0f, 0.0f)`. */ - inline PhongShader* setAmbientColor(const Color3<>& color) { + inline Phong* setAmbientColor(const Color3<>& color) { setUniform(ambientColorUniform, color); return this; } @@ -64,7 +64,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram { * @brief Set diffuse color * @return Pointer to self (for method chaining) */ - inline PhongShader* setDiffuseColor(const Color3<>& color) { + inline Phong* setDiffuseColor(const Color3<>& color) { setUniform(diffuseColorUniform, color); return this; } @@ -75,7 +75,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram { * * If not set, default value is `(1.0f, 1.0f, 1.0f)`. */ - inline PhongShader* setSpecularColor(const Color3<>& color) { + inline Phong* setSpecularColor(const Color3<>& color) { setUniform(specularColorUniform, color); return this; } @@ -87,7 +87,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram { * The larger value, the harder surface (smaller specular highlight). * If not set, default value is `80.0f`. */ - inline PhongShader* setShininess(Float shininess) { + inline Phong* setShininess(Float shininess) { setUniform(shininessUniform, shininess); return this; } @@ -96,7 +96,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram { * @brief Set transformation and normal matrix * @return Pointer to self (for method chaining) */ - inline PhongShader* setTransformationMatrix(const Matrix4& matrix) { + inline Phong* setTransformationMatrix(const Matrix4& matrix) { setUniform(transformationMatrixUniform, matrix); setUniform(normalMatrixUniform, matrix.rotation()); return this; @@ -106,7 +106,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram { * @brief Set projection matrix * @return Pointer to self (for method chaining) */ - inline PhongShader* setProjectionMatrix(const Matrix4& matrix) { + inline Phong* setProjectionMatrix(const Matrix4& matrix) { setUniform(projectionMatrixUniform, matrix); return this; } @@ -115,7 +115,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram { * @brief Set light position * @return Pointer to self (for method chaining) */ - inline PhongShader* setLightPosition(const Vector3& light) { + inline Phong* setLightPosition(const Vector3& light) { setUniform(lightUniform, light); return this; } @@ -126,7 +126,7 @@ class MAGNUM_SHADERS_EXPORT PhongShader: public AbstractShaderProgram { * * If not set, default value is `(1.0f, 1.0f, 1.0f)`. */ - inline PhongShader* setLightColor(const Color3<>& color) { + inline Phong* setLightColor(const Color3<>& color) { setUniform(lightColorUniform, color); return this; } diff --git a/src/Shaders/PhongShader.vert b/src/Shaders/Phong.vert similarity index 100% rename from src/Shaders/PhongShader.vert rename to src/Shaders/Phong.vert diff --git a/src/Shaders/Shaders.h b/src/Shaders/Shaders.h index 855c3d0c3..ae344e30c 100644 --- a/src/Shaders/Shaders.h +++ b/src/Shaders/Shaders.h @@ -35,27 +35,27 @@ namespace Magnum { namespace Shaders { /** @todoc remove when doxygen is sane again */ #ifndef DOXYGEN_GENERATING_OUTPUT -template class DistanceFieldVectorShader; -typedef DistanceFieldVectorShader<2> DistanceFieldVectorShader2D; -typedef DistanceFieldVectorShader<3> DistanceFieldVectorShader3D; +template class DistanceFieldVector; +typedef DistanceFieldVector<2> DistanceFieldVector2D; +typedef DistanceFieldVector<3> DistanceFieldVector3D; -template class AbstractVectorShader; -typedef AbstractVectorShader<2> AbstractVectorShader2D; -typedef AbstractVectorShader<3> AbstractVectorShader3D; +template class AbstractVector; +typedef AbstractVector<2> AbstractVector2D; +typedef AbstractVector<3> AbstractVector3D; -template class FlatShader; -typedef FlatShader<2> FlatShader2D; -typedef FlatShader<3> FlatShader3D; +template class Flat; +typedef Flat<2> Flat2D; +typedef Flat<3> Flat3D; -class PhongShader; +class Phong; -template class VectorShader; -typedef VectorShader<2> VectorShader2D; -typedef VectorShader<3> VectorShader3D; +template class Vector; +typedef Vector<2> Vector2D; +typedef Vector<3> Vector3D; -template class VertexColorShader; -typedef VertexColorShader<2> VertexColorShader2D; -typedef VertexColorShader<3> VertexColorShader3D; +template class VertexColor; +typedef VertexColor<2> VertexColor2D; +typedef VertexColor<3> VertexColor3D; #endif }} diff --git a/src/Shaders/VectorShader.cpp b/src/Shaders/Vector.cpp similarity index 84% rename from src/Shaders/VectorShader.cpp rename to src/Shaders/Vector.cpp index 11e48d1dc..461015fe4 100644 --- a/src/Shaders/VectorShader.cpp +++ b/src/Shaders/Vector.cpp @@ -22,7 +22,7 @@ DEALINGS IN THE SOFTWARE. */ -#include "VectorShader.h" +#include "Vector.h" #include @@ -34,11 +34,11 @@ namespace Magnum { namespace Shaders { namespace { template constexpr const char* vertexShaderName(); - template<> constexpr const char* vertexShaderName<2>() { return "AbstractVectorShader2D.vert"; } - template<> constexpr const char* vertexShaderName<3>() { return "AbstractVectorShader3D.vert"; } + template<> constexpr const char* vertexShaderName<2>() { return "AbstractVector2D.vert"; } + template<> constexpr const char* vertexShaderName<3>() { return "AbstractVector3D.vert"; } } -template VectorShader::VectorShader(): transformationProjectionMatrixUniform(0), colorUniform(1) { +template Vector::Vector(): transformationProjectionMatrixUniform(0), colorUniform(1) { Corrade::Utility::Resource rs("MagnumShaders"); #ifndef MAGNUM_TARGET_GLES @@ -54,7 +54,7 @@ template VectorShader::VectorShader(): trans Shader fragmentShader(v, Shader::Type::Fragment); fragmentShader.addSource(rs.get("compatibility.glsl")); - fragmentShader.addSource(rs.get("VectorShader.frag")); + fragmentShader.addSource(rs.get("Vector.frag")); AbstractShaderProgram::attachShader(fragmentShader); #ifndef MAGNUM_TARGET_GLES @@ -64,8 +64,8 @@ template VectorShader::VectorShader(): trans if(!Context::current()->isVersionSupported(Version::GLES300)) #endif { - AbstractShaderProgram::bindAttributeLocation(AbstractVectorShader::Position::Location, "position"); - AbstractShaderProgram::bindAttributeLocation(AbstractVectorShader::TextureCoordinates::Location, "textureCoordinates"); + AbstractShaderProgram::bindAttributeLocation(AbstractVector::Position::Location, "position"); + AbstractShaderProgram::bindAttributeLocation(AbstractVector::TextureCoordinates::Location, "textureCoordinates"); } AbstractShaderProgram::link(); @@ -80,11 +80,11 @@ template VectorShader::VectorShader(): trans #ifndef MAGNUM_TARGET_GLES if(!Context::current()->isExtensionSupported()) - AbstractShaderProgram::setUniform(AbstractShaderProgram::uniformLocation("vectorTexture"), AbstractVectorShader::VectorTextureLayer); + AbstractShaderProgram::setUniform(AbstractShaderProgram::uniformLocation("vectorTexture"), AbstractVector::VectorTextureLayer); #endif } -template class VectorShader<2>; -template class VectorShader<3>; +template class Vector<2>; +template class Vector<3>; }} diff --git a/src/Shaders/VectorShader.frag b/src/Shaders/Vector.frag similarity index 100% rename from src/Shaders/VectorShader.frag rename to src/Shaders/Vector.frag diff --git a/src/Shaders/VectorShader.h b/src/Shaders/Vector.h similarity index 77% rename from src/Shaders/VectorShader.h rename to src/Shaders/Vector.h index 64ebba832..16539e02b 100644 --- a/src/Shaders/VectorShader.h +++ b/src/Shaders/Vector.h @@ -1,5 +1,5 @@ -#ifndef Magnum_Shaders_VectorShader_h -#define Magnum_Shaders_VectorShader_h +#ifndef Magnum_Shaders_Vector_h +#define Magnum_Shaders_Vector_h /* This file is part of Magnum. @@ -25,12 +25,12 @@ */ /** @file - * @brief Class Magnum::Shaders::VectorShader, typedef Magnum::Shaders::VectorShader2D, Magnum::Shaders::VectorShader3D + * @brief Class Magnum::Shaders::Vector, typedef Magnum::Shaders::Vector2D, Magnum::Shaders::Vector3D */ #include "Math/Matrix3.h" #include "Math/Matrix4.h" -#include "AbstractVectorShader.h" +#include "AbstractVector.h" #include "magnumShadersVisibility.h" @@ -39,19 +39,19 @@ namespace Magnum { namespace Shaders { /** @brief Vector shader -Renders vector art in plain grayscale form. See also DistanceFieldVectorShader +Renders vector art in plain grayscale form. See also DistanceFieldVector for more advanced effects. -@see VectorShader2D, VectorShader3D +@see Vector2D, Vector3D */ -template class MAGNUM_SHADERS_EXPORT VectorShader: public AbstractVectorShader { +template class MAGNUM_SHADERS_EXPORT Vector: public AbstractVector { public: - VectorShader(); + Vector(); /** * @brief Set transformation and projection matrix * @return Pointer to self (for method chaining) */ - inline VectorShader* setTransformationProjectionMatrix(const typename DimensionTraits::MatrixType& matrix) { + inline Vector* setTransformationProjectionMatrix(const typename DimensionTraits::MatrixType& matrix) { AbstractShaderProgram::setUniform(transformationProjectionMatrixUniform, matrix); return this; } @@ -60,7 +60,7 @@ template class MAGNUM_SHADERS_EXPORT VectorShader: publi * @brief Set fill color * @return Pointer to self (for method chaining) */ - inline VectorShader* setColor(const Color4<>& color) { + inline Vector* setColor(const Color4<>& color) { AbstractShaderProgram::setUniform(colorUniform, color); return this; } @@ -71,10 +71,10 @@ template class MAGNUM_SHADERS_EXPORT VectorShader: publi }; /** @brief Two-dimensional vector shader */ -typedef VectorShader<2> VectorShader2D; +typedef Vector<2> Vector2D; /** @brief Three-dimensional vector shader */ -typedef VectorShader<3> VectorShader3D; +typedef Vector<3> Vector3D; }} diff --git a/src/Shaders/VertexColorShader.cpp b/src/Shaders/VertexColor.cpp similarity index 89% rename from src/Shaders/VertexColorShader.cpp rename to src/Shaders/VertexColor.cpp index 748036744..444932bd5 100644 --- a/src/Shaders/VertexColorShader.cpp +++ b/src/Shaders/VertexColor.cpp @@ -22,7 +22,7 @@ DEALINGS IN THE SOFTWARE. */ -#include "VertexColorShader.h" +#include "VertexColor.h" #include @@ -33,11 +33,11 @@ namespace Magnum { namespace Shaders { namespace { template constexpr const char* vertexShaderName(); - template<> constexpr const char* vertexShaderName<2>() { return "VertexColorShader2D.vert"; } - template<> constexpr const char* vertexShaderName<3>() { return "VertexColorShader3D.vert"; } + template<> constexpr const char* vertexShaderName<2>() { return "VertexColor2D.vert"; } + template<> constexpr const char* vertexShaderName<3>() { return "VertexColor3D.vert"; } } -template VertexColorShader::VertexColorShader(): transformationProjectionMatrixUniform(0) { +template VertexColor::VertexColor(): transformationProjectionMatrixUniform(0) { Corrade::Utility::Resource rs("MagnumShaders"); #ifndef MAGNUM_TARGET_GLES @@ -53,7 +53,7 @@ template VertexColorShader::VertexColorShade Shader fragmentShader(v, Shader::Type::Fragment); fragmentShader.addSource(rs.get("compatibility.glsl")); - fragmentShader.addSource(rs.get("VertexColorShader.frag")); + fragmentShader.addSource(rs.get("VertexColor.frag")); attachShader(fragmentShader); #ifndef MAGNUM_TARGET_GLES @@ -82,7 +82,7 @@ template VertexColorShader::VertexColorShade #endif } -template class VertexColorShader<2>; -template class VertexColorShader<3>; +template class VertexColor<2>; +template class VertexColor<3>; }} diff --git a/src/Shaders/VertexColorShader.frag b/src/Shaders/VertexColor.frag similarity index 100% rename from src/Shaders/VertexColorShader.frag rename to src/Shaders/VertexColor.frag diff --git a/src/Shaders/VertexColorShader.h b/src/Shaders/VertexColor.h similarity index 81% rename from src/Shaders/VertexColorShader.h rename to src/Shaders/VertexColor.h index a68697f90..9d9b22c3c 100644 --- a/src/Shaders/VertexColorShader.h +++ b/src/Shaders/VertexColor.h @@ -1,5 +1,5 @@ -#ifndef Magnum_Shaders_VertexColorShader_h -#define Magnum_Shaders_VertexColorShader_h +#ifndef Magnum_Shaders_VertexColor_h +#define Magnum_Shaders_VertexColor_h /* This file is part of Magnum. @@ -25,7 +25,7 @@ */ /** @file - * @brief Class Magnum::Shaders::VertexColorShader + * @brief Class Magnum::Shaders::VertexColor */ #include "Math/Matrix3.h" @@ -42,9 +42,9 @@ namespace Magnum { namespace Shaders { @brief Vertex color shader Draws vertex-colored mesh. -@see VertexColorShader2D, VertexColorShader3D +@see VertexColor2D, VertexColor3D */ -template class MAGNUM_SHADERS_EXPORT VertexColorShader: public AbstractShaderProgram { +template class MAGNUM_SHADERS_EXPORT VertexColor: public AbstractShaderProgram { public: /** @brief Vertex position */ typedef Attribute<0, typename DimensionTraits::VectorType> Position; @@ -52,7 +52,7 @@ template class MAGNUM_SHADERS_EXPORT VertexColorShader: /** @brief Vertex color */ typedef Attribute<1, Color3<>> Color; - explicit VertexColorShader(); + explicit VertexColor(); /** * @brief Set transformation and projection matrix @@ -60,7 +60,7 @@ template class MAGNUM_SHADERS_EXPORT VertexColorShader: * * Default is identity matrix. */ - inline VertexColorShader* setTransformationProjectionMatrix(const typename DimensionTraits::MatrixType& matrix) { + inline VertexColor* setTransformationProjectionMatrix(const typename DimensionTraits::MatrixType& matrix) { setUniform(transformationProjectionMatrixUniform, matrix); return this; } @@ -70,10 +70,10 @@ template class MAGNUM_SHADERS_EXPORT VertexColorShader: }; /** @brief 2D vertex color shader */ -typedef VertexColorShader<2> VertexColorShader2D; +typedef VertexColor<2> VertexColor2D; /** @brief 3D vertex color shader */ -typedef VertexColorShader<3> VertexColorShader3D; +typedef VertexColor<3> VertexColor3D; }} diff --git a/src/Shaders/VertexColorShader2D.vert b/src/Shaders/VertexColor2D.vert similarity index 100% rename from src/Shaders/VertexColorShader2D.vert rename to src/Shaders/VertexColor2D.vert diff --git a/src/Shaders/VertexColorShader3D.vert b/src/Shaders/VertexColor3D.vert similarity index 100% rename from src/Shaders/VertexColorShader3D.vert rename to src/Shaders/VertexColor3D.vert diff --git a/src/Text/TextRenderer.cpp b/src/Text/TextRenderer.cpp index a0ee125d6..8ef22ea3a 100644 --- a/src/Text/TextRenderer.cpp +++ b/src/Text/TextRenderer.cpp @@ -27,7 +27,7 @@ #include "Context.h" #include "Extensions.h" #include "Mesh.h" -#include "Shaders/AbstractVectorShader.h" +#include "Shaders/AbstractVector.h" #include "Text/AbstractFont.h" namespace Magnum { namespace Text { @@ -179,9 +179,9 @@ template std::tuple TextRenderer(r); mesh.addInterleavedVertexBuffer(vertexBuffer, 0, - typename Shaders::AbstractVectorShader::Position( - Shaders::AbstractVectorShader::Position::Components::Two), - typename Shaders::AbstractVectorShader::TextureCoordinates()); + typename Shaders::AbstractVector::Position( + Shaders::AbstractVector::Position::Components::Two), + typename Shaders::AbstractVector::TextureCoordinates()); return std::move(r); } @@ -203,8 +203,8 @@ AbstractTextRenderer::~AbstractTextRenderer() {} template TextRenderer::TextRenderer(AbstractFont* const font, const GlyphCache* const cache, const Float size): AbstractTextRenderer(font, cache, size) { /* Finalize mesh configuration */ _mesh.addInterleavedVertexBuffer(&vertexBuffer, 0, - typename Shaders::AbstractVectorShader::Position(Shaders::AbstractVectorShader::Position::Components::Two), - typename Shaders::AbstractVectorShader::TextureCoordinates()); + typename Shaders::AbstractVector::Position(Shaders::AbstractVector::Position::Components::Two), + typename Shaders::AbstractVector::TextureCoordinates()); } void AbstractTextRenderer::reserve(const uint32_t glyphCount, const Buffer::Usage vertexBufferUsage, const Buffer::Usage indexBufferUsage) { diff --git a/src/TextureTools/DistanceField.cpp b/src/TextureTools/DistanceField.cpp index c2804541c..7ad59323e 100644 --- a/src/TextureTools/DistanceField.cpp +++ b/src/TextureTools/DistanceField.cpp @@ -69,12 +69,13 @@ DistanceFieldShader::DistanceFieldShader() { /** @todo compatibility! */ Corrade::Utility::Resource rs("MagnumTextureTools"); - attachShader(Shader::fromData(Version::GL330, Shader::Type::Vertex, rs.get("DistanceFieldShader.vert"))); - Shader fragmentShader(Version::GL330, Shader::Type::Fragment); - fragmentShader.addSource(rs.get("compatibility.glsl")); - fragmentShader.addSource(rs.get("DistanceFieldShader.frag")); - attachShader(fragmentShader); + attachShader(Shader(Version::GL330, Shader::Type::Vertex) + .addSource(rs.get("DistanceFieldShader.vert"))); + + attachShader(Shader(Version::GL330, Shader::Type::Fragment) + .addSource(rs.get("compatibility.glsl")) + .addSource(rs.get("DistanceFieldShader.frag"))); link(); }