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

Fix formatting

pull/576/head
Vladislav Oleshko 4 years ago
parent
3ab4b6fef3
commit
b592fcbff3
10 changed files with 33 additions and 39 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. 6
      src/Magnum/Shaders/DistanceFieldVectorGL.h
  3. 9
      src/Magnum/Shaders/FlatGL.cpp
  4. 6
      src/Magnum/Shaders/FlatGL.h
  5. 9
      src/Magnum/Shaders/PhongGL.cpp
  6. 6
      src/Magnum/Shaders/PhongGL.h
  7. 10
      src/Magnum/Shaders/VectorGL.cpp
  8. 6
      src/Magnum/Shaders/VectorGL.h
  9. 8
      src/Magnum/Shaders/VertexColorGL.cpp
  10. 6
      src/Magnum/Shaders/VertexColorGL.h

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

@ -162,8 +162,7 @@ template<UnsignedInt dimensions> typename DistanceFieldVectorGL<dimensions>::Com
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
}
template<UnsignedInt dimensions> DistanceFieldVectorGL<dimensions>::DistanceFieldVectorGL(CompileState&& cs)
: DistanceFieldVectorGL{static_cast<DistanceFieldVectorGL&&>(std::move(cs))} {
template<UnsignedInt dimensions> DistanceFieldVectorGL<dimensions>::DistanceFieldVectorGL(CompileState&& cs): DistanceFieldVectorGL{static_cast<DistanceFieldVectorGL&&>(std::move(cs))} {
if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -237,7 +236,8 @@ template<UnsignedInt dimensions> typename DistanceFieldVectorGL<dimensions>::Com
return compile(flags, 1, 1);
}
template<UnsignedInt dimensions> DistanceFieldVectorGL<dimensions>::DistanceFieldVectorGL(const Flags flags, UnsignedInt materialCount, UnsignedInt drawCount): DistanceFieldVectorGL{compile(flags, materialCount, drawCount)} {}
template<UnsignedInt dimensions> DistanceFieldVectorGL<dimensions>::DistanceFieldVectorGL(const Flags flags, UnsignedInt materialCount, UnsignedInt drawCount):
DistanceFieldVectorGL{compile(flags, materialCount, drawCount)} {}
#endif
template<UnsignedInt dimensions> DistanceFieldVectorGL<dimensions>& DistanceFieldVectorGL<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {

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

@ -645,13 +645,13 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
};
template<UnsignedInt dimensions> class DistanceFieldVectorGL<dimensions>::CompileState : public DistanceFieldVectorGL<dimensions> {
template<UnsignedInt dimensions> class DistanceFieldVectorGL<dimensions>::CompileState: public DistanceFieldVectorGL<dimensions> {
private:
friend class DistanceFieldVectorGL;
explicit CompileState(NoCreateT) : DistanceFieldVectorGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(NoCreateT): DistanceFieldVectorGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
CompileState(DistanceFieldVectorGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version) :
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} {}
GL::Shader _vert, _frag;

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

@ -237,8 +237,7 @@ template<UnsignedInt dimensions> typename FlatGL<dimensions>::CompileState FlatG
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
}
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(CompileState&& cs)
: FlatGL{static_cast<FlatGL&&>(std::move(cs))} {
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(CompileState&& cs): FlatGL{static_cast<FlatGL&&>(std::move(cs))} {
if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -312,15 +311,15 @@ template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(CompileState&& cs)
static_cast<void>(context);
}
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(Flags flags) : FlatGL{compile(flags)} {}
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(Flags flags): FlatGL{compile(flags)} {}
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> typename FlatGL<dimensions>::CompileState FlatGL<dimensions>::compile(Flags flags) {
return compile(flags, 1, 1);
}
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)
: FlatGL{compile(flags, materialCount, drawCount)} {}
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(Flags flags, UnsignedInt materialCount, UnsignedInt drawCount):
FlatGL{compile(flags, materialCount, drawCount)} {}
#endif
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(NoInitT) {}

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

@ -1056,13 +1056,13 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT FlatGL: public GL::
#endif
};
template<UnsignedInt dimensions> class FlatGL<dimensions>::CompileState : public FlatGL<dimensions> {
template<UnsignedInt dimensions> class FlatGL<dimensions>::CompileState: public FlatGL<dimensions> {
private:
friend class FlatGL;
explicit CompileState(NoCreateT) : FlatGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(NoCreateT): FlatGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
CompileState(FlatGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version) :
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} {}
GL::Shader _vert, _frag;

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

@ -347,8 +347,7 @@ PhongGL::CompileState PhongGL::compile(const Flags flags, const UnsignedInt ligh
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
}
PhongGL::PhongGL(CompileState&& cs)
: PhongGL{static_cast<PhongGL&&>(std::move(cs))} {
PhongGL::PhongGL(CompileState&& cs): PhongGL{static_cast<PhongGL&&>(std::move(cs))} {
if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -464,15 +463,15 @@ PhongGL::PhongGL(CompileState&& cs)
static_cast<void>(version);
}
PhongGL::PhongGL(Flags flags, UnsignedInt lightCount) : PhongGL{compile(flags, lightCount)} {}
PhongGL::PhongGL(Flags flags, UnsignedInt lightCount): PhongGL{compile(flags, lightCount)} {}
#ifndef MAGNUM_TARGET_GLES2
PhongGL::CompileState PhongGL::compile(Flags flags, UnsignedInt lightCount) {
return compile(flags, lightCount, 1, 1);
}
PhongGL::PhongGL(Flags flags, UnsignedInt lightCount, UnsignedInt materialCount, UnsignedInt drawCount)
: PhongGL{compile(flags, lightCount, materialCount, drawCount)} {}
PhongGL::PhongGL(Flags flags, UnsignedInt lightCount, UnsignedInt materialCount, UnsignedInt drawCount):
PhongGL{compile(flags, lightCount, materialCount, drawCount)} {}
#endif
PhongGL& PhongGL::setAmbientColor(const Magnum::Color4& color) {

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

@ -1801,13 +1801,13 @@ class MAGNUM_SHADERS_EXPORT PhongGL: public GL::AbstractShaderProgram {
#endif
};
class PhongGL::CompileState : public PhongGL {
class PhongGL::CompileState: public PhongGL {
private:
friend class PhongGL;
explicit CompileState(NoCreateT) : PhongGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(NoCreateT): PhongGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
CompileState(PhongGL&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version) :
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} {}
GL::Shader _vert, _frag;

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

@ -164,8 +164,7 @@ template<UnsignedInt dimensions> typename VectorGL<dimensions>::CompileState Vec
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
}
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(CompileState&& cs)
: VectorGL{static_cast<VectorGL&&>(std::move(cs))} {
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(CompileState&& cs): VectorGL{static_cast<VectorGL&&>(std::move(cs))} {
if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -230,20 +229,19 @@ template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(CompileState&& c
static_cast<void>(version);
}
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(Flags flags) : VectorGL{compile(flags)} {}
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(Flags flags): VectorGL{compile(flags)} {}
#ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> typename VectorGL<dimensions>::CompileState VectorGL<dimensions>::compile(Flags flags) {
return compile(flags, 1, 1);
}
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(Flags flags, UnsignedInt materialCount, UnsignedInt drawCount)
: VectorGL{compile(flags, materialCount, drawCount)} {}
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(Flags flags, UnsignedInt materialCount, UnsignedInt drawCount):
VectorGL{compile(flags, materialCount, drawCount)} {}
#endif
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(NoInitT) {}
template<UnsignedInt dimensions> VectorGL<dimensions>& VectorGL<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),

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

@ -595,13 +595,13 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VectorGL: public GL
#endif
};
template<UnsignedInt dimensions> class VectorGL<dimensions>::CompileState : public VectorGL<dimensions> {
template<UnsignedInt dimensions> class VectorGL<dimensions>::CompileState: public VectorGL<dimensions> {
private:
friend class VectorGL;
explicit CompileState(NoCreateT) : VectorGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(NoCreateT): VectorGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
CompileState(VectorGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version) :
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} {}
GL::Shader _vert, _frag;

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

@ -142,8 +142,7 @@ template<UnsignedInt dimensions> typename VertexColorGL<dimensions>::CompileStat
return CompileState{std::move(out), std::move(vert), std::move(frag), version};
}
template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(CompileState&& cs):
VertexColorGL{static_cast<VertexColorGL&&>(std::move(cs))} {
template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(CompileState&& cs): VertexColorGL{static_cast<VertexColorGL&&>(std::move(cs))} {
if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -200,13 +199,12 @@ template<UnsignedInt dimensions> typename VertexColorGL<dimensions>::CompileStat
return compile(flags, 1);
}
template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(Flags flags, UnsignedInt drawCount)
: VertexColorGL{compile(flags, drawCount)} {}
template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(Flags flags, UnsignedInt drawCount):
VertexColorGL{compile(flags, drawCount)} {}
#endif
template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(NoInitT) {}
template<UnsignedInt dimensions> VertexColorGL<dimensions>& VertexColorGL<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
#ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers),

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

@ -443,13 +443,13 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColorGL: publ
#endif
};
template<UnsignedInt dimensions> class VertexColorGL<dimensions>::CompileState : public VertexColorGL<dimensions> {
template<UnsignedInt dimensions> class VertexColorGL<dimensions>::CompileState: public VertexColorGL<dimensions> {
private:
friend class VertexColorGL;
explicit CompileState(NoCreateT) : VertexColorGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
explicit CompileState(NoCreateT): VertexColorGL{NoCreate}, _vert{NoCreate}, _frag{NoCreate} {}
CompileState(VertexColorGL<dimensions>&& shader, GL::Shader&& vert, GL::Shader&& frag, GL::Version version) :
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} {}
GL::Shader _vert, _frag;

Write Preview
Loading…
Cancel
Save