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
Unified 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}; return CompileState{std::move(out), std::move(vert), std::move(frag), version};
} }
template<UnsignedInt dimensions> DistanceFieldVectorGL<dimensions>::DistanceFieldVectorGL(CompileState&& cs) template<UnsignedInt dimensions> DistanceFieldVectorGL<dimensions>::DistanceFieldVectorGL(CompileState&& cs): DistanceFieldVectorGL{static_cast<DistanceFieldVectorGL&&>(std::move(cs))} {
: DistanceFieldVectorGL{static_cast<DistanceFieldVectorGL&&>(std::move(cs))} {
if (id() == 0) return; if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink()); CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -237,7 +236,8 @@ template<UnsignedInt dimensions> typename DistanceFieldVectorGL<dimensions>::Com
return compile(flags, 1, 1); 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 #endif
template<UnsignedInt dimensions> DistanceFieldVectorGL<dimensions>& DistanceFieldVectorGL<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) { 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: private:
friend class DistanceFieldVectorGL; 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} {} DistanceFieldVectorGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
GL::Shader _vert, _frag; 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}; return CompileState{std::move(out), std::move(vert), std::move(frag), version};
} }
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(CompileState&& cs) template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(CompileState&& cs): FlatGL{static_cast<FlatGL&&>(std::move(cs))} {
: FlatGL{static_cast<FlatGL&&>(std::move(cs))} {
if (id() == 0) return; if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink()); CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -312,15 +311,15 @@ template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(CompileState&& cs)
static_cast<void>(context); 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 #ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> typename FlatGL<dimensions>::CompileState FlatGL<dimensions>::compile(Flags flags) { template<UnsignedInt dimensions> typename FlatGL<dimensions>::CompileState FlatGL<dimensions>::compile(Flags flags) {
return compile(flags, 1, 1); return compile(flags, 1, 1);
} }
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(Flags flags, UnsignedInt materialCount, UnsignedInt drawCount) template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(Flags flags, UnsignedInt materialCount, UnsignedInt drawCount):
: FlatGL{compile(flags, materialCount, drawCount)} {} FlatGL{compile(flags, materialCount, drawCount)} {}
#endif #endif
template<UnsignedInt dimensions> FlatGL<dimensions>::FlatGL(NoInitT) {} 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 #endif
}; };
template<UnsignedInt dimensions> class FlatGL<dimensions>::CompileState : public FlatGL<dimensions> { template<UnsignedInt dimensions> class FlatGL<dimensions>::CompileState: public FlatGL<dimensions> {
private: private:
friend class FlatGL; 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} {} FlatGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
GL::Shader _vert, _frag; 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}; return CompileState{std::move(out), std::move(vert), std::move(frag), version};
} }
PhongGL::PhongGL(CompileState&& cs) PhongGL::PhongGL(CompileState&& cs): PhongGL{static_cast<PhongGL&&>(std::move(cs))} {
: PhongGL{static_cast<PhongGL&&>(std::move(cs))} {
if (id() == 0) return; if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink()); CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -464,15 +463,15 @@ PhongGL::PhongGL(CompileState&& cs)
static_cast<void>(version); 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 #ifndef MAGNUM_TARGET_GLES2
PhongGL::CompileState PhongGL::compile(Flags flags, UnsignedInt lightCount) { PhongGL::CompileState PhongGL::compile(Flags flags, UnsignedInt lightCount) {
return compile(flags, lightCount, 1, 1); return compile(flags, lightCount, 1, 1);
} }
PhongGL::PhongGL(Flags flags, UnsignedInt lightCount, UnsignedInt materialCount, UnsignedInt drawCount) PhongGL::PhongGL(Flags flags, UnsignedInt lightCount, UnsignedInt materialCount, UnsignedInt drawCount):
: PhongGL{compile(flags, lightCount, materialCount, drawCount)} {} PhongGL{compile(flags, lightCount, materialCount, drawCount)} {}
#endif #endif
PhongGL& PhongGL::setAmbientColor(const Magnum::Color4& color) { 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 #endif
}; };
class PhongGL::CompileState : public PhongGL { class PhongGL::CompileState: public PhongGL {
private: private:
friend class PhongGL; 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} {} PhongGL{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
GL::Shader _vert, _frag; 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}; return CompileState{std::move(out), std::move(vert), std::move(frag), version};
} }
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(CompileState&& cs) template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(CompileState&& cs): VectorGL{static_cast<VectorGL&&>(std::move(cs))} {
: VectorGL{static_cast<VectorGL&&>(std::move(cs))} {
if (id() == 0) return; if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink()); CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -230,20 +229,19 @@ template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(CompileState&& c
static_cast<void>(version); 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 #ifndef MAGNUM_TARGET_GLES2
template<UnsignedInt dimensions> typename VectorGL<dimensions>::CompileState VectorGL<dimensions>::compile(Flags flags) { template<UnsignedInt dimensions> typename VectorGL<dimensions>::CompileState VectorGL<dimensions>::compile(Flags flags) {
return compile(flags, 1, 1); return compile(flags, 1, 1);
} }
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(Flags flags, UnsignedInt materialCount, UnsignedInt drawCount) template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(Flags flags, UnsignedInt materialCount, UnsignedInt drawCount):
: VectorGL{compile(flags, materialCount, drawCount)} {} VectorGL{compile(flags, materialCount, drawCount)} {}
#endif #endif
template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(NoInitT) {} template<UnsignedInt dimensions> VectorGL<dimensions>::VectorGL(NoInitT) {}
template<UnsignedInt dimensions> VectorGL<dimensions>& VectorGL<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) { template<UnsignedInt dimensions> VectorGL<dimensions>& VectorGL<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
#ifndef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers), 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 #endif
}; };
template<UnsignedInt dimensions> class VectorGL<dimensions>::CompileState : public VectorGL<dimensions> { template<UnsignedInt dimensions> class VectorGL<dimensions>::CompileState: public VectorGL<dimensions> {
private: private:
friend class VectorGL; 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} {} VectorGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
GL::Shader _vert, _frag; 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}; return CompileState{std::move(out), std::move(vert), std::move(frag), version};
} }
template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(CompileState&& cs): template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(CompileState&& cs): VertexColorGL{static_cast<VertexColorGL&&>(std::move(cs))} {
VertexColorGL{static_cast<VertexColorGL&&>(std::move(cs))} {
if (id() == 0) return; if (id() == 0) return;
CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink()); CORRADE_INTERNAL_ASSERT_OUTPUT(checkLink());
@ -200,13 +199,12 @@ template<UnsignedInt dimensions> typename VertexColorGL<dimensions>::CompileStat
return compile(flags, 1); return compile(flags, 1);
} }
template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(Flags flags, UnsignedInt drawCount) template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(Flags flags, UnsignedInt drawCount):
: VertexColorGL{compile(flags, drawCount)} {} VertexColorGL{compile(flags, drawCount)} {}
#endif #endif
template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(NoInitT) {} template<UnsignedInt dimensions> VertexColorGL<dimensions>::VertexColorGL(NoInitT) {}
template<UnsignedInt dimensions> VertexColorGL<dimensions>& VertexColorGL<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) { template<UnsignedInt dimensions> VertexColorGL<dimensions>& VertexColorGL<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) {
#ifndef MAGNUM_TARGET_GLES2 #ifndef MAGNUM_TARGET_GLES2
CORRADE_ASSERT(!(_flags >= Flag::UniformBuffers), 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 #endif
}; };
template<UnsignedInt dimensions> class VertexColorGL<dimensions>::CompileState : public VertexColorGL<dimensions> { template<UnsignedInt dimensions> class VertexColorGL<dimensions>::CompileState: public VertexColorGL<dimensions> {
private: private:
friend class VertexColorGL; 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} {} VertexColorGL<dimensions>{std::move(shader)}, _vert{std::move(vert)}, _frag{std::move(frag)}, _version{version} {}
GL::Shader _vert, _frag; GL::Shader _vert, _frag;

Write Preview
Loading…
Cancel
Save