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

Shaders: remove CompileState members on platforms that don't need them. 

This fixes a bunch of Clang warnings saying that a private field is
unused.
pull/499/head
Vladimír Vondruš 3 years ago
parent
2e3baf1911
commit
e38664a0ce
12 changed files with 150 additions and 22 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. 6
      src/Magnum/Shaders/DistanceFieldVectorGL.cpp
  2. 12
      src/Magnum/Shaders/DistanceFieldVectorGL.h
  3. 6
      src/Magnum/Shaders/FlatGL.cpp
  4. 12
      src/Magnum/Shaders/FlatGL.h
  5. 34
      src/Magnum/Shaders/MeshVisualizerGL.cpp
  6. 48
      src/Magnum/Shaders/MeshVisualizerGL.h
  7. 6
      src/Magnum/Shaders/PhongGL.cpp
  8. 12
      src/Magnum/Shaders/PhongGL.h
  9. 6
      src/Magnum/Shaders/VectorGL.cpp
  10. 12
      src/Magnum/Shaders/VectorGL.h
  11. 6
      src/Magnum/Shaders/VertexColorGL.cpp
  12. 12
      src/Magnum/Shaders/VertexColorGL.h

6
src/Magnum/Shaders/DistanceFieldVectorGL.cpp
Unescape View File

@ -157,7 +157,11 @@ template<UnsignedInt dimensions> typename DistanceFieldVectorGL<dimensions>::Com
#endif
out.submitLink();
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
return CompileState{std::move(out), std::move(vert), std::move(frag)
#ifndef MAGNUM_TARGET_GLES
, version
#endif
};
}
template<UnsignedInt dimensions> typename DistanceFieldVectorGL<dimensions>::CompileState DistanceFieldVectorGL<dimensions>::compile() {

12
src/Magnum/Shaders/DistanceFieldVectorGL.h
Unescape View File

@ -748,10 +748,20 @@ template<UnsignedInt dimensions> class DistanceFieldVectorGL<dimensions>::Compil
explicit CompileState(NoCreateT): DistanceFieldVectorGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(DistanceFieldVectorGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version): DistanceFieldVectorGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
explicit CompileState(DistanceFieldVectorGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag
#ifndef MAGNUM_TARGET_GLES
, GL::Version version
#endif
): DistanceFieldVectorGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}
#ifndef MAGNUM_TARGET_GLES
, _version{version}
#endif
{}
Implementation::GLShaderWrapper _vert, _frag;
#ifndef MAGNUM_TARGET_GLES
GL::Version _version;
#endif
};
/**

6
src/Magnum/Shaders/FlatGL.cpp
Unescape View File

@ -289,7 +289,11 @@ template<UnsignedInt dimensions> typename FlatGL<dimensions>::CompileState FlatG
out.submitLink();
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
return CompileState{std::move(out), std::move(vert), std::move(frag)
#ifndef MAGNUM_TARGET_GLES
, version
#endif
};
}
template<UnsignedInt dimensions> typename FlatGL<dimensions>::CompileState FlatGL<dimensions>::compile() {

12
src/Magnum/Shaders/FlatGL.h
Unescape View File

@ -1516,10 +1516,20 @@ template<UnsignedInt dimensions> class FlatGL<dimensions>::CompileState: public
explicit CompileState(NoCreateT): FlatGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(FlatGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version): FlatGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
explicit CompileState(FlatGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag
#ifndef MAGNUM_TARGET_GLES
, GL::Version version
#endif
): FlatGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}
#ifndef MAGNUM_TARGET_GLES
, _version{version}
#endif
{}
Implementation::GLShaderWrapper _vert, _frag;
#ifndef MAGNUM_TARGET_GLES
GL::Version _version;
#endif
};
/**

34
src/Magnum/Shaders/MeshVisualizerGL.cpp
Unescape View File

@ -608,7 +608,14 @@ MeshVisualizerGL2D::CompileState MeshVisualizerGL2D::compile(const Configuration
out.submitLink();
return CompileState{std::move(out), std::move(vert), std::move(frag), geom ? &*geom : nullptr, version};
return CompileState{std::move(out), std::move(vert), std::move(frag)
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
, geom ? &*geom : nullptr
#endif
#ifndef MAGNUM_TARGET_GLES
, version
#endif
};
}
#ifdef MAGNUM_BUILD_DEPRECATED
@ -634,10 +641,14 @@ MeshVisualizerGL2D::MeshVisualizerGL2D(CompileState&& state): MeshVisualizerGL2D
if(!id()) return;
#endif
if(state._geom.id)
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
if(state._geom.id) {
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink({GL::Shader(state._vert), GL::Shader(state._frag), GL::Shader(state._geom)}));
else
} else
#endif
{
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink({GL::Shader(state._vert), GL::Shader(state._frag)}));
}
#ifndef MAGNUM_TARGET_GLES
const GL::Context& context = GL::Context::current();
@ -1091,7 +1102,14 @@ MeshVisualizerGL3D::CompileState MeshVisualizerGL3D::compile(const Configuration
out.submitLink();
return CompileState{std::move(out), std::move(vert), std::move(frag), geom ? &*geom : nullptr, version};
return CompileState{std::move(out), std::move(vert), std::move(frag)
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
, geom ? &*geom : nullptr
#endif
#ifndef MAGNUM_TARGET_GLES
, version
#endif
};
}
#ifdef MAGNUM_BUILD_DEPRECATED
@ -1117,10 +1135,14 @@ MeshVisualizerGL3D::MeshVisualizerGL3D(CompileState&& state): MeshVisualizerGL3D
if(!id()) return;
#endif
if(state._geom.id)
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
if(state._geom.id) {
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink({GL::Shader(state._vert), GL::Shader(state._frag), GL::Shader(state._geom)}));
else
} else
#endif
{
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink({GL::Shader(state._vert), GL::Shader(state._frag)}));
}
#ifndef MAGNUM_TARGET_GLES
const GL::Context& context = GL::Context::current();

48
src/Magnum/Shaders/MeshVisualizerGL.h
Unescape View File

@ -1311,14 +1311,32 @@ class MeshVisualizerGL2D::CompileState: public MeshVisualizerGL2D {
/* Everything deliberately private except for the inheritance */
friend class MeshVisualizerGL2D;
explicit CompileState(NoCreateT): MeshVisualizerGL2D{NoCreate}, _vert{NoCreate}, _frag{NoCreate}, _geom{NoCreate} {}
explicit CompileState(NoCreateT): MeshVisualizerGL2D{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(MeshVisualizerGL2D&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Shader* geom, GL::Version version): MeshVisualizerGL2D{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _geom{NoCreate}, _version{version} {
explicit CompileState(MeshVisualizerGL2D&& shader, GL::Shader&& vert, GL::Shader&& frag
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
, GL::Shader* geom
#endif
#ifndef MAGNUM_TARGET_GLES
, GL::Version version
#endif
): MeshVisualizerGL2D{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}
#ifndef MAGNUM_TARGET_GLES
, _version{version}
#endif
{
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
if(geom) _geom = Implementation::GLShaderWrapper{std::move(*geom)};
#endif
}
Implementation::GLShaderWrapper _vert, _frag, _geom;
Implementation::GLShaderWrapper _vert, _frag;
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
Implementation::GLShaderWrapper _geom{NoCreate};
#endif
#ifndef MAGNUM_TARGET_GLES
GL::Version _version;
#endif
};
/**
@ -3261,14 +3279,32 @@ class MeshVisualizerGL3D::CompileState: public MeshVisualizerGL3D {
/* Everything deliberately private except for the inheritance */
friend class MeshVisualizerGL3D;
explicit CompileState(NoCreateT): MeshVisualizerGL3D{NoCreate}, _vert{NoCreate}, _frag{NoCreate}, _geom{NoCreate} {}
explicit CompileState(NoCreateT): MeshVisualizerGL3D{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(MeshVisualizerGL3D&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Shader* geom, GL::Version version): MeshVisualizerGL3D{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _geom{NoCreate}, _version{version} {
explicit CompileState(MeshVisualizerGL3D&& shader, GL::Shader&& vert, GL::Shader&& frag
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
, GL::Shader* geom
#endif
#ifndef MAGNUM_TARGET_GLES
, GL::Version version
#endif
): MeshVisualizerGL3D{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}
#ifndef MAGNUM_TARGET_GLES
, _version{version}
#endif
{
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
if(geom) _geom = Implementation::GLShaderWrapper{std::move(*geom)};
#endif
}
Implementation::GLShaderWrapper _vert, _frag, _geom;
Implementation::GLShaderWrapper _vert, _frag;
#if !defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2)
Implementation::GLShaderWrapper _geom{NoCreate};
#endif
#ifndef MAGNUM_TARGET_GLES
GL::Version _version;
#endif
};
/** @debugoperatorclassenum{MeshVisualizerGL2D,MeshVisualizerGL2D::Flag} */

6
src/Magnum/Shaders/PhongGL.cpp
Unescape View File

@ -405,7 +405,11 @@ PhongGL::CompileState PhongGL::compile(const Configuration& configuration) {
out.submitLink();
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
return CompileState{std::move(out), std::move(vert), std::move(frag)
#ifndef MAGNUM_TARGET_GLES
, version
#endif
};
}
PhongGL::CompileState PhongGL::compile() {

12
src/Magnum/Shaders/PhongGL.h
Unescape View File

@ -2297,10 +2297,20 @@ class PhongGL::CompileState: public PhongGL {
explicit CompileState(NoCreateT): PhongGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(PhongGL&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version): PhongGL{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
explicit CompileState(PhongGL&& shader, GL::Shader&& vert, GL::Shader&& frag
#ifndef MAGNUM_TARGET_GLES
, GL::Version version
#endif
): PhongGL{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}
#ifndef MAGNUM_TARGET_GLES
, _version{version}
#endif
{}
Implementation::GLShaderWrapper _vert, _frag;
#ifndef MAGNUM_TARGET_GLES
GL::Version _version;
#endif
};
/** @debugoperatorclassenum{PhongGL,PhongGL::Flag} */

6
src/Magnum/Shaders/VectorGL.cpp
Unescape View File

@ -158,7 +158,11 @@ template<UnsignedInt dimensions> typename VectorGL<dimensions>::CompileState Vec
out.submitLink();
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
return CompileState{std::move(out), std::move(vert), std::move(frag)
#ifndef MAGNUM_TARGET_GLES
, version
#endif
};
}
template<UnsignedInt dimensions> typename VectorGL<dimensions>::CompileState VectorGL<dimensions>::compile() {

12
src/Magnum/Shaders/VectorGL.h
Unescape View File

@ -698,10 +698,20 @@ template<UnsignedInt dimensions> class VectorGL<dimensions>::CompileState: publi
explicit CompileState(NoCreateT): VectorGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(VectorGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version): VectorGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
explicit CompileState(VectorGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag
#ifndef MAGNUM_TARGET_GLES
, GL::Version version
#endif
): VectorGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}
#ifndef MAGNUM_TARGET_GLES
, _version{version}
#endif
{}
Implementation::GLShaderWrapper _vert, _frag;
#ifndef MAGNUM_TARGET_GLES
GL::Version _version;
#endif
};
/**

6
src/Magnum/Shaders/VertexColorGL.cpp
Unescape View File

@ -136,7 +136,11 @@ template<UnsignedInt dimensions> typename VertexColorGL<dimensions>::CompileStat
out.submitLink();
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
return CompileState{std::move(out), std::move(vert), std::move(frag)
#ifndef MAGNUM_TARGET_GLES
, version
#endif
};
}
template<UnsignedInt dimensions> typename VertexColorGL<dimensions>::CompileState VertexColorGL<dimensions>::compile() {

12
src/Magnum/Shaders/VertexColorGL.h
Unescape View File

@ -515,10 +515,20 @@ template<UnsignedInt dimensions> class VertexColorGL<dimensions>::CompileState:
explicit CompileState(NoCreateT): VertexColorGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(VertexColorGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version): VertexColorGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
explicit CompileState(VertexColorGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag
#ifndef MAGNUM_TARGET_GLES
, GL::Version version
#endif
): VertexColorGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}
#ifndef MAGNUM_TARGET_GLES
, _version{version}
#endif
{}
Implementation::GLShaderWrapper _vert, _frag;
#ifndef MAGNUM_TARGET_GLES
GL::Version _version;
#endif
};
/**

Write Preview
Loading…
Cancel
Save