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

Getting rid of <>, part 1: Color classes. 

Inspired in STL, base templated class is renamed to BasicColor{3,4} and
typedef'd with Float type to Color{3, 4}. It is much nicer to write
this:

    Color3(1.0f)
    Color3::fromHSV(25.0_degf, 0.5f, 0.9f);

instead of this:

    Color3<>(1.0f);
    Color3<>::fromHSV(25.0_degf, 0.5f, 0.9f);
pull/278/head
Vladimír Vondruš 13 years ago
parent
bb6e08ef1c
commit
a7f5bef038
24 changed files with 166 additions and 164 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. 4
      src/AbstractShaderProgram.h
  2. 2
      src/AbstractTexture.h
  3. 138
      src/Color.h
  4. 2
      src/CubeMapTexture.h
  5. 2
      src/CubeMapTextureArray.h
  6. 8
      src/DebugTools/ForceRenderer.h
  7. 8
      src/DebugTools/ObjectRenderer.cpp
  8. 6
      src/DebugTools/ShapeRenderer.h
  9. 6
      src/Magnum.h
  10. 2
      src/Mesh.h
  11. 2
      src/MeshTools/Interleave.h
  12. 4
      src/Renderer.cpp
  13. 4
      src/Renderer.h
  14. 4
      src/Shaders/DistanceFieldVector.h
  15. 2
      src/Shaders/Flat.h
  16. 4
      src/Shaders/MeshVisualizer.cpp
  17. 4
      src/Shaders/MeshVisualizer.h
  18. 8
      src/Shaders/Phong.h
  19. 2
      src/Shaders/Vector.h
  20. 2
      src/Shaders/VertexColor.h
  21. 8
      src/Swizzle.h
  22. 94
      src/Test/ColorTest.cpp
  23. 12
      src/Test/SwizzleTest.cpp
  24. 2
      src/Texture.h

4
src/AbstractShaderProgram.h
Unescape View File

@ -1392,8 +1392,8 @@ template<std::size_t size_> struct Attribute<Math::Vector<size_, Double>>: Doubl
template<class T> struct Attribute<Math::Vector2<T>>: Attribute<Math::Vector<2, T>> {};
template<class T> struct Attribute<Math::Vector3<T>>: Attribute<Math::Vector<3, T>> {};
template<class T> struct Attribute<Math::Vector4<T>>: Attribute<Math::Vector<4, T>> {};
template<class T> struct Attribute<Color3<T>>: Attribute<Math::Vector3<T>> {};
template<class T> struct Attribute<Color4<T>>: Attribute<Math::Vector4<T>> {};
template<class T> struct Attribute<BasicColor3<T>>: Attribute<Math::Vector3<T>> {};
template<class T> struct Attribute<BasicColor4<T>>: Attribute<Math::Vector4<T>> {};
/* Common float and double rectangular matrix attributes */
template<std::size_t cols, std::size_t rows> struct Attribute<Math::RectangularMatrix<cols, rows, Float>>: FloatAttribute, SizedAttribute<cols, rows> {};

2
src/AbstractTexture.h
Unescape View File

@ -203,7 +203,7 @@ class MAGNUM_EXPORT AbstractTexture {
* with @def_gl{TEXTURE_BORDER_COLOR}
* @requires_es_extension %Extension @es_extension{NV,texture_border_clamp}
*/
AbstractTexture* setBorderColor(const Color4<>& color) {
AbstractTexture* setBorderColor(const Color4& color) {
#ifndef MAGNUM_TARGET_GLES
(this->*parameterfvImplementation)(GL_TEXTURE_BORDER_COLOR, color.data());
#else

138
src/Color.h
Unescape View File

@ -25,7 +25,7 @@
*/
/** @file
* @brief Class Magnum::Color3, Magnum::Color4
* @brief Class Magnum::BasicColor3, Magnum::BasicColor4, typedef Magnum::Color3, Magnum::Color4
*/
#include <tuple>
@ -39,7 +39,7 @@ namespace Magnum {
namespace Implementation {
/* Convert color from HSV */
template<class T> typename std::enable_if<std::is_floating_point<T>::value, Color3<T>>::type fromHSV(typename Color3<T>::HSV hsv) {
template<class T> typename std::enable_if<std::is_floating_point<T>::value, BasicColor3<T>>::type fromHSV(typename BasicColor3<T>::HSV hsv) {
Math::Deg<T> hue;
T saturation, value;
std::tie(hue, saturation, value) = hsv;
@ -65,12 +65,12 @@ template<class T> typename std::enable_if<std::is_floating_point<T>::value, Colo
default: CORRADE_ASSERT_UNREACHABLE();
}
}
template<class T> inline typename std::enable_if<std::is_integral<T>::value, Color3<T>>::type fromHSV(typename Color3<T>::HSV hsv) {
return Math::denormalize<Color3<T>>(fromHSV<typename Color3<T>::FloatingPointType>(hsv));
template<class T> inline typename std::enable_if<std::is_integral<T>::value, BasicColor3<T>>::type fromHSV(typename BasicColor3<T>::HSV hsv) {
return Math::denormalize<BasicColor3<T>>(fromHSV<typename BasicColor3<T>::FloatingPointType>(hsv));
}
/* Internal hue computing function */
template<class T> Math::Deg<T> hue(const Color3<T>& color, T max, T delta) {
template<class T> Math::Deg<T> hue(const BasicColor3<T>& color, T max, T delta) {
T deltaInv60 = T(60)/delta;
T hue(0);
@ -87,40 +87,40 @@ template<class T> Math::Deg<T> hue(const Color3<T>& color, T max, T delta) {
}
/* Hue, saturation, value for floating-point types */
template<class T> inline Math::Deg<T> hue(typename std::enable_if<std::is_floating_point<T>::value, const Color3<T>&>::type color) {
template<class T> inline Math::Deg<T> hue(typename std::enable_if<std::is_floating_point<T>::value, const BasicColor3<T>&>::type color) {
T max = color.max();
T delta = max - color.min();
return hue(color, max, delta);
}
template<class T> inline T saturation(typename std::enable_if<std::is_floating_point<T>::value, const Color3<T>&>::type color) {
template<class T> inline T saturation(typename std::enable_if<std::is_floating_point<T>::value, const BasicColor3<T>&>::type color) {
T max = color.max();
T delta = max - color.min();
return max != T(0) ? delta/max : T(0);
}
template<class T> inline T value(typename std::enable_if<std::is_floating_point<T>::value, const Color3<T>&>::type color) {
template<class T> inline T value(typename std::enable_if<std::is_floating_point<T>::value, const BasicColor3<T>&>::type color) {
return color.max();
}
/* Hue, saturation, value for integral types */
template<class T> inline Math::Deg<typename Color3<T>::FloatingPointType> hue(typename std::enable_if<std::is_integral<T>::value, const Color3<T>&>::type color) {
return hue<typename Color3<T>::FloatingPointType>(Math::normalize<Color3<typename Color3<T>::FloatingPointType>>(color));
template<class T> inline Math::Deg<typename BasicColor3<T>::FloatingPointType> hue(typename std::enable_if<std::is_integral<T>::value, const BasicColor3<T>&>::type color) {
return hue<typename BasicColor3<T>::FloatingPointType>(Math::normalize<BasicColor3<typename BasicColor3<T>::FloatingPointType>>(color));
}
template<class T> inline typename Color3<T>::FloatingPointType saturation(typename std::enable_if<std::is_integral<T>::value, const Color3<T>&>::type& color) {
return saturation<typename Color3<T>::FloatingPointType>(Math::normalize<Color3<typename Color3<T>::FloatingPointType>>(color));
template<class T> inline typename BasicColor3<T>::FloatingPointType saturation(typename std::enable_if<std::is_integral<T>::value, const BasicColor3<T>&>::type& color) {
return saturation<typename BasicColor3<T>::FloatingPointType>(Math::normalize<BasicColor3<typename BasicColor3<T>::FloatingPointType>>(color));
}
template<class T> inline typename Color3<T>::FloatingPointType value(typename std::enable_if<std::is_integral<T>::value, const Color3<T>&>::type color) {
return Math::normalize<typename Color3<T>::FloatingPointType>(color.max());
template<class T> inline typename BasicColor3<T>::FloatingPointType value(typename std::enable_if<std::is_integral<T>::value, const BasicColor3<T>&>::type color) {
return Math::normalize<typename BasicColor3<T>::FloatingPointType>(color.max());
}
/* Convert color to HSV */
template<class T> inline typename Color3<T>::HSV toHSV(typename std::enable_if<std::is_floating_point<T>::value, const Color3<T>&>::type color) {
template<class T> inline typename BasicColor3<T>::HSV toHSV(typename std::enable_if<std::is_floating_point<T>::value, const BasicColor3<T>&>::type color) {
T max = color.max();
T delta = max - color.min();
return typename Color3<T>::HSV(hue<typename Color3<T>::FloatingPointType>(color, max, delta), max != T(0) ? delta/max : T(0), max);
return typename BasicColor3<T>::HSV(hue<typename BasicColor3<T>::FloatingPointType>(color, max, delta), max != T(0) ? delta/max : T(0), max);
}
template<class T> inline typename Color3<T>::HSV toHSV(typename std::enable_if<std::is_integral<T>::value, const Color3<T>&>::type color) {
return toHSV<typename Color3<T>::FloatingPointType>(Math::normalize<Color3<typename Color3<T>::FloatingPointType>>(color));
template<class T> inline typename BasicColor3<T>::HSV toHSV(typename std::enable_if<std::is_integral<T>::value, const BasicColor3<T>&>::type color) {
return toHSV<typename BasicColor3<T>::FloatingPointType>(Math::normalize<BasicColor3<typename BasicColor3<T>::FloatingPointType>>(color));
}
/* Default alpha value */
@ -144,16 +144,11 @@ Conversion from and to HSV is done always using floating-point types, so hue
is always in range in range @f$ [0.0, 360.0] @f$, saturation and value in
range @f$ [0.0, 1.0] @f$.
@see Color4
@see @ref Color3, @ref BasicColor4
*/
/* Not using template specialization because some internal functions are
impossible to explicitly instantiate */
#ifndef DOXYGEN_GENERATING_OUTPUT
template<class T>
#else
template<class T = Float>
#endif
class Color3: public Math::Vector3<T> {
template<class T> class BasicColor3: public Math::Vector3<T> {
public:
/** @brief Corresponding floating-point type for HSV computation */
typedef typename Math::TypeTraits<T>::FloatingPointType FloatingPointType;
@ -172,11 +167,11 @@ class Color3: public Math::Vector3<T> {
*
* Hue can overflow the range @f$ [0.0, 360.0] @f$.
*/
constexpr static Color3<T> fromHSV(HSV hsv) {
constexpr static BasicColor3<T> fromHSV(HSV hsv) {
return Implementation::fromHSV<T>(hsv);
}
/** @overload */
constexpr static Color3<T> fromHSV(Math::Deg<FloatingPointType> hue, FloatingPointType saturation, FloatingPointType value) {
constexpr static BasicColor3<T> fromHSV(Math::Deg<FloatingPointType> hue, FloatingPointType saturation, FloatingPointType value) {
return fromHSV(std::make_tuple(hue, saturation, value));
}
@ -185,13 +180,13 @@ class Color3: public Math::Vector3<T> {
*
* All components are set to zero.
*/
constexpr /*implicit*/ Color3() {}
constexpr /*implicit*/ BasicColor3() {}
/**
* @brief Gray constructor
* @param rgb RGB value
*/
constexpr explicit Color3(T rgb): Math::Vector3<T>(rgb) {}
constexpr explicit BasicColor3(T rgb): Math::Vector3<T>(rgb) {}
/**
* @brief Constructor
@ -199,13 +194,13 @@ class Color3: public Math::Vector3<T> {
* @param g G value
* @param b B value
*/
constexpr /*implicit*/ Color3(T r, T g, T b): Math::Vector3<T>(r, g, b) {}
constexpr /*implicit*/ BasicColor3(T r, T g, T b): Math::Vector3<T>(r, g, b) {}
/** @copydoc Math::Vector::Vector(const Vector<size, U>&) */
template<class U> constexpr explicit Color3(const Math::Vector<3, U>& other): Math::Vector3<T>(other) {}
template<class U> constexpr explicit BasicColor3(const Math::Vector<3, U>& other): Math::Vector3<T>(other) {}
/** @brief Copy constructor */
constexpr Color3(const Math::Vector<3, T>& other): Math::Vector3<T>(other) {}
constexpr BasicColor3(const Math::Vector<3, T>& other): Math::Vector3<T>(other) {}
T& r() { return Math::Vector3<T>::x(); } /**< @brief R component */
constexpr T r() const { return Math::Vector3<T>::x(); } /**< @overload */
@ -259,15 +254,19 @@ class Color3: public Math::Vector3<T> {
return Implementation::value<T>(*this);
}
MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(Color3, 3)
MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(BasicColor3, 3)
};
MAGNUM_VECTOR_SUBCLASS_OPERATOR_IMPLEMENTATION(Color3, 3)
/** @brief Three-component (RGB) float color */
typedef BasicColor3<Float> Color3;
MAGNUM_VECTOR_SUBCLASS_OPERATOR_IMPLEMENTATION(BasicColor3, 3)
/**
@brief Four-component (RGBA) color
See Color3 for more information.
See @ref BasicColor3 for more information.
@see @ref Color4
*/
/* Not using template specialization because some internal functions are
impossible to explicitly instantiate */
@ -276,24 +275,24 @@ template<class T>
#else
template<class T = Float>
#endif
class Color4: public Math::Vector4<T> {
class BasicColor4: public Math::Vector4<T> {
public:
/** @copydoc Color3::FloatingPointType */
typedef typename Color3<T>::FloatingPointType FloatingPointType;
/** @copydoc BasicColor3::FloatingPointType */
typedef typename BasicColor3<T>::FloatingPointType FloatingPointType;
/** @copydoc Color3::HSV */
typedef typename Color3<T>::HSV HSV;
/** @copydoc BasicColor3::HSV */
typedef typename BasicColor3<T>::HSV HSV;
/**
* @copydoc Color3::fromHSV()
* @copydoc BasicColor3::fromHSV()
* @param a Alpha value, defaults to 1.0 for floating-point types
* and maximum positive value for integral types.
*/
constexpr static Color4<T> fromHSV(HSV hsv, T a = Implementation::defaultAlpha<T>()) {
return Color4<T>(Implementation::fromHSV<T>(hsv), a);
constexpr static BasicColor4<T> fromHSV(HSV hsv, T a = Implementation::defaultAlpha<T>()) {
return BasicColor4<T>(Implementation::fromHSV<T>(hsv), a);
}
/** @overload */
constexpr static Color4<T> fromHSV(Math::Deg<FloatingPointType> hue, FloatingPointType saturation, FloatingPointType value, T alpha) {
constexpr static BasicColor4<T> fromHSV(Math::Deg<FloatingPointType> hue, FloatingPointType saturation, FloatingPointType value, T alpha) {
return fromHSV(std::make_tuple(hue, saturation, value), alpha);
}
@ -303,14 +302,14 @@ class Color4: public Math::Vector4<T> {
* RGB components are set to zero, A component is set to 1.0 for
* floating-point types and maximum positive value for integral types.
*/
constexpr /*implicit*/ Color4(): Math::Vector4<T>(T(0), T(0), T(0), Implementation::defaultAlpha<T>()) {}
constexpr /*implicit*/ BasicColor4(): Math::Vector4<T>(T(0), T(0), T(0), Implementation::defaultAlpha<T>()) {}
/**
* @copydoc Color3::Color3(T)
* @copydoc BasicColor3::BasicColor3(T)
* @param alpha Alpha value, defaults to 1.0 for floating-point types
* and maximum positive value for integral types.
*/
constexpr explicit Color4(T rgb, T alpha = Implementation::defaultAlpha<T>()): Math::Vector4<T>(rgb, rgb, rgb, alpha) {}
constexpr explicit BasicColor4(T rgb, T alpha = Implementation::defaultAlpha<T>()): Math::Vector4<T>(rgb, rgb, rgb, alpha) {}
/**
* @brief Constructor
@ -320,22 +319,22 @@ class Color4: public Math::Vector4<T> {
* @param a A value, defaults to 1.0 for floating-point types and
* maximum positive value for integral types.
*/
constexpr /*implicit*/ Color4(T r, T g, T b, T a = Implementation::defaultAlpha<T>()): Math::Vector4<T>(r, g, b, a) {}
constexpr /*implicit*/ BasicColor4(T r, T g, T b, T a = Implementation::defaultAlpha<T>()): Math::Vector4<T>(r, g, b, a) {}
/**
* @brief Constructor
* @param rgb Three-component color
* @param a A value
*/
/* Not marked as explicit, because conversion from Color3 to Color4
/* Not marked as explicit, because conversion from BasicColor3 to BasicColor4
is fairly common, nearly always with A set to 1 */
constexpr /*implicit*/ Color4(const Math::Vector3<T>& rgb, T a = Implementation::defaultAlpha<T>()): Math::Vector4<T>(rgb[0], rgb[1], rgb[2], a) {}
constexpr /*implicit*/ BasicColor4(const Math::Vector3<T>& rgb, T a = Implementation::defaultAlpha<T>()): Math::Vector4<T>(rgb[0], rgb[1], rgb[2], a) {}
/** @copydoc Math::Vector::Vector(const Vector<size, U>&) */
template<class U> constexpr explicit Color4(const Math::Vector<4, U>& other): Math::Vector4<T>(other) {}
template<class U> constexpr explicit BasicColor4(const Math::Vector<4, U>& other): Math::Vector4<T>(other) {}
/** @brief Copy constructor */
constexpr Color4(const Math::Vector<4, T>& other): Math::Vector4<T>(other) {}
constexpr BasicColor4(const Math::Vector<4, T>& other): Math::Vector4<T>(other) {}
T& r() { return Math::Vector4<T>::x(); } /**< @brief R component */
constexpr T r() const { return Math::Vector4<T>::x(); } /**< @overload */
@ -352,52 +351,55 @@ class Color4: public Math::Vector4<T> {
*
* @see swizzle()
*/
Color3<T>& rgb() { return Color3<T>::from(Math::Vector4<T>::data()); }
constexpr Color3<T> rgb() const { return Color3<T>::from(Math::Vector4<T>::data()); } /**< @overload */
BasicColor3<T>& rgb() { return BasicColor3<T>::from(Math::Vector4<T>::data()); }
constexpr BasicColor3<T> rgb() const { return BasicColor3<T>::from(Math::Vector4<T>::data()); } /**< @overload */
/** @copydoc Color3::toHSV() */
/** @copydoc BasicColor3::toHSV() */
constexpr HSV toHSV() const {
return Implementation::toHSV<T>(rgb());
}
/** @copydoc Color3::hue() */
/** @copydoc BasicColor3::hue() */
constexpr Math::Deg<FloatingPointType> hue() const {
return Implementation::hue<T>(rgb());
}
/** @copydoc Color3::saturation() */
/** @copydoc BasicColor3::saturation() */
constexpr FloatingPointType saturation() const {
return Implementation::saturation<T>(rgb());
}
/** @copydoc Color3::value() */
/** @copydoc BasicColor3::value() */
constexpr FloatingPointType value() const {
return Implementation::value<T>(rgb());
}
MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(Color4, 4)
MAGNUM_VECTOR_SUBCLASS_IMPLEMENTATION(BasicColor4, 4)
};
MAGNUM_VECTOR_SUBCLASS_OPERATOR_IMPLEMENTATION(Color4, 4)
/** @brief Four-component (RGBA) float color */
typedef BasicColor4<Float> Color4;
MAGNUM_VECTOR_SUBCLASS_OPERATOR_IMPLEMENTATION(BasicColor4, 4)
/** @debugoperator{Magnum::Color3} */
template<class T> inline Debug operator<<(Debug debug, const Color3<T>& value) {
/** @debugoperator{Magnum::BasicColor3} */
template<class T> inline Debug operator<<(Debug debug, const BasicColor3<T>& value) {
return debug << static_cast<const Math::Vector3<T>&>(value);
}
/** @debugoperator{Magnum::Color4} */
template<class T> inline Debug operator<<(Debug debug, const Color4<T>& value) {
/** @debugoperator{Magnum::BasicColor4} */
template<class T> inline Debug operator<<(Debug debug, const BasicColor4<T>& value) {
return debug << static_cast<const Math::Vector4<T>&>(value);
}
}
namespace Corrade { namespace Utility {
/** @configurationvalue{Magnum::Color3} */
template<class T> struct ConfigurationValue<Magnum::Color3<T>>: public ConfigurationValue<Magnum::Math::Vector<3, T>> {};
/** @configurationvalue{Magnum::BasicColor3} */
template<class T> struct ConfigurationValue<Magnum::BasicColor3<T>>: public ConfigurationValue<Magnum::Math::Vector<3, T>> {};
/** @configurationvalue{Magnum::Color4} */
template<class T> struct ConfigurationValue<Magnum::Color4<T>>: public ConfigurationValue<Magnum::Math::Vector<4, T>> {};
/** @configurationvalue{Magnum::BasicColor4} */
template<class T> struct ConfigurationValue<Magnum::BasicColor4<T>>: public ConfigurationValue<Magnum::Math::Vector<4, T>> {};
}}
#endif

2
src/CubeMapTexture.h
Unescape View File

@ -233,7 +233,7 @@ class CubeMapTexture: public AbstractTexture {
return this;
}
#ifndef MAGNUM_TARGET_GLES3
CubeMapTexture* setBorderColor(const Color4<>& color) {
CubeMapTexture* setBorderColor(const Color4& color) {
AbstractTexture::setBorderColor(color);
return this;
}

2
src/CubeMapTextureArray.h
Unescape View File

@ -243,7 +243,7 @@ class CubeMapTextureArray: public AbstractTexture {
return this;
}
#ifndef MAGNUM_TARGET_GLES3
CubeMapTextureArray* setBorderColor(const Color4<>& color) {
CubeMapTextureArray* setBorderColor(const Color4& color) {
AbstractTexture::setBorderColor(color);
return this;
}

8
src/DebugTools/ForceRenderer.h
Unescape View File

@ -47,7 +47,7 @@ class ForceRendererOptions {
constexpr ForceRendererOptions(): _color(1.0f), _size(1.0f) {}
/** @brief Color of rendered arrow */
constexpr Color4<> color() const { return _color; }
constexpr Color4 color() const { return _color; }
/**
* @brief Set color of rendered arrow
@ -55,7 +55,7 @@ class ForceRendererOptions {
*
* Default is 100% opaque white.
*/
ForceRendererOptions* setColor(const Color4<>& color) {
ForceRendererOptions* setColor(const Color4& color) {
_color = color;
return this;
}
@ -75,7 +75,7 @@ class ForceRendererOptions {
}
private:
Color4<> _color;
Color4 _color;
Float _size;
};
@ -91,7 +91,7 @@ Example code:
@code
// Create some options
DebugTools::ResourceManager::instance()->set("my", (new DebugTools::ForceRendererOptions)
->setScale(5.0f)->setColor(Color3<>::fromHSV(120.0_degf, 1.0f, 0.7f)));
->setScale(5.0f)->setColor(Color3::fromHSV(120.0_degf, 1.0f, 0.7f)));
// Create debug renderer for given object, use "my" options for it
Object3D* object;

8
src/DebugTools/ObjectRenderer.cpp
Unescape View File

@ -43,7 +43,7 @@ template<> struct Renderer<2> {
static ResourceKey mesh() { return {"object2d"}; }
static const std::array<Vector2, 8> positions;
static const std::array<Color3<>, 8> colors;
static const std::array<Color3, 8> colors;
static const std::array<UnsignedByte, 12> indices;
};
@ -59,7 +59,7 @@ const std::array<Vector2, 8> Renderer<2>::positions{{
{-0.1f, 0.9f}
}};
const std::array<Color3<>, 8> Renderer<2>::colors{{
const std::array<Color3, 8> Renderer<2>::colors{{
{1.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f}, /* X axis */
{1.0f, 0.0f, 0.0f},
@ -88,7 +88,7 @@ template<> struct Renderer<3> {
static ResourceKey mesh() { return {"object3d"}; }
static const std::array<Vector3, 12> positions;
static const std::array<Color3<>, 12> colors;
static const std::array<Color3, 12> colors;
static const std::array<uint8_t, 18> indices;
};
@ -109,7 +109,7 @@ const std::array<Vector3, 12> Renderer<3>::positions{{
{-0.1f, 0.0f, 0.9f}
}};
const std::array<Color3<>, 12> Renderer<3>::colors{{
const std::array<Color3, 12> Renderer<3>::colors{{
{1.0f, 0.0f, 0.0f},
{1.0f, 0.0f, 0.0f}, /* X axis */
{1.0f, 0.0f, 0.0f},

6
src/DebugTools/ShapeRenderer.h
Unescape View File

@ -83,7 +83,7 @@ class ShapeRendererOptions {
}
/** @brief Color of rendered shape */
constexpr Color4<> color() const { return _color; }
constexpr Color4 color() const { return _color; }
/**
* @brief Set color of rendered shape
@ -91,7 +91,7 @@ class ShapeRendererOptions {
*
* Default is 100% opaque white.
*/
ShapeRendererOptions* setColor(const Color4<>& color) {
ShapeRendererOptions* setColor(const Color4& color) {
_color = color;
return this;
}
@ -112,7 +112,7 @@ class ShapeRendererOptions {
}
private:
Color4<> _color;
Color4 _color;
Float _pointSize;
RenderMode _renderMode;
};

6
src/Magnum.h
Unescape View File

@ -352,8 +352,10 @@ class BufferTexture;
enum class BufferTextureFormat: GLenum;
#endif
template<class T = Float> class Color3;
template<class T = Float> class Color4;
template<class> class BasicColor3;
template<class> class BasicColor4;
typedef BasicColor3<Float> Color3;
typedef BasicColor4<Float> Color4;
enum class Version: Int;
class Context;

2
src/Mesh.h
Unescape View File

@ -173,7 +173,7 @@ mesh->setPrimitive(plane.primitive())
class MyShader: public AbstractShaderProgram {
public:
typedef Attribute<0, Vector3> Position;
typedef Attribute<1, Color4<>> Color;
typedef Attribute<1, Color4> Color;
// ...
};

2
src/MeshTools/Interleave.h
Unescape View File

@ -160,7 +160,7 @@ achieve that, you can specify gaps between the attributes:
@code
std::vector<Vector4> positions;
std::vector<GLushort> weights;
std::vector<Color3<GLubyte>> vertexColors;
std::vector<BasicColor3<GLubyte>> vertexColors;
std::size_t attributeCount;
std::size_t stride;
char* data;

4
src/Renderer.cpp
Unescape View File

@ -50,7 +50,7 @@ void Renderer::setHint(const Hint target, const HintMode mode) {
glHint(GLenum(target), GLenum(mode));
}
void Renderer::setClearColor(const Color4<>& color) {
void Renderer::setClearColor(const Color4& color) {
glClearColor(color.r(), color.g(), color.b(), color.a());
}
@ -152,7 +152,7 @@ void Renderer::setBlendFunction(const BlendFunction sourceRgb, const BlendFuncti
glBlendFuncSeparate(GLenum(sourceRgb), GLenum(destinationRgb), GLenum(sourceAlpha), GLenum(destinationAlpha));
}
void Renderer::setBlendColor(const Color4<>& color) {
void Renderer::setBlendColor(const Color4& color) {
glBlendColor(color.r(), color.g(), color.b(), color.a());
}

4
src/Renderer.h
Unescape View File

@ -238,7 +238,7 @@ class MAGNUM_EXPORT Renderer {
* Initial value is fully opaque black.
* @see @fn_gl{ClearColor}
*/
static void setClearColor(const Color4<>& color);
static void setClearColor(const Color4& color);
#ifndef MAGNUM_TARGET_GLES
/**
@ -809,7 +809,7 @@ class MAGNUM_EXPORT Renderer {
* @see @ref Feature "Feature::Blending", setBlendEquation(),
* setBlendFunction(), @fn_gl{BlendColor}
*/
static void setBlendColor(const Color4<>& color);
static void setBlendColor(const Color4& color);
/*@}*/

4
src/Shaders/DistanceFieldVector.h
Unescape View File

@ -63,7 +63,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
*
* @see setOutlineColor()
*/
DistanceFieldVector* setColor(const Color4<>& color) {
DistanceFieldVector* setColor(const Color4& color) {
AbstractShaderProgram::setUniform(colorUniform, color);
return this;
}
@ -74,7 +74,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT DistanceFieldVector
*
* @see setOutlineRange(), setColor()
*/
DistanceFieldVector* setOutlineColor(const Color4<>& color) {
DistanceFieldVector* setOutlineColor(const Color4& color) {
AbstractShaderProgram::setUniform(outlineColorUniform, color);
return this;
}

2
src/Shaders/Flat.h
Unescape View File

@ -64,7 +64,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Flat: public Abstra
* @brief Set color
* @return Pointer to self (for method chaining)
*/
Flat<dimensions>* setColor(const Color4<>& color) {
Flat<dimensions>* setColor(const Color4& color) {
setUniform(colorUniform, color);
return this;
}

4
src/Shaders/MeshVisualizer.cpp
Unescape View File

@ -115,9 +115,9 @@ MeshVisualizer::MeshVisualizer(const Flags flags): flags(flags), transformationP
/* Set defaults in OpenGL ES (for desktop they are set in shader code itself) */
#ifdef MAGNUM_TARGET_GLES
setColor(Color3<>(1.0f));
setColor(Color3(1.0f));
if(flags & Flag::Wireframe) {
setWireframeColor(Color3<>(0.0f));
setWireframeColor(Color3(0.0f));
setWireframeWidth(1.0f);
setSmoothness(2.0f);
}

4
src/Shaders/MeshVisualizer.h
Unescape View File

@ -138,7 +138,7 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizer: public AbstractShaderProgram {
*
* Initial value is fully opaque white.
*/
MeshVisualizer* setColor(const Color4<>& color) {
MeshVisualizer* setColor(const Color4& color) {
setUniform(colorUniform, color);
return this;
}
@ -150,7 +150,7 @@ class MAGNUM_SHADERS_EXPORT MeshVisualizer: public AbstractShaderProgram {
* Initial value is fully opaque black. Has effect only if
* @ref Flag "Flag::Wireframe" is enabled.
*/
MeshVisualizer* setWireframeColor(const Color4<>& color) {
MeshVisualizer* setWireframeColor(const Color4& color) {
if(flags & Flag::Wireframe) setUniform(wireframeColorUniform, color);
return this;
}

8
src/Shaders/Phong.h
Unescape View File

@ -55,7 +55,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public AbstractShaderProgram {
*
* If not set, default value is `(0.0f, 0.0f, 0.0f)`.
*/
Phong* setAmbientColor(const Color3<>& color) {
Phong* setAmbientColor(const Color3& color) {
setUniform(ambientColorUniform, color);
return this;
}
@ -64,7 +64,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public AbstractShaderProgram {
* @brief Set diffuse color
* @return Pointer to self (for method chaining)
*/
Phong* setDiffuseColor(const Color3<>& color) {
Phong* setDiffuseColor(const Color3& color) {
setUniform(diffuseColorUniform, color);
return this;
}
@ -75,7 +75,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public AbstractShaderProgram {
*
* If not set, default value is `(1.0f, 1.0f, 1.0f)`.
*/
Phong* setSpecularColor(const Color3<>& color) {
Phong* setSpecularColor(const Color3& color) {
setUniform(specularColorUniform, color);
return this;
}
@ -126,7 +126,7 @@ class MAGNUM_SHADERS_EXPORT Phong: public AbstractShaderProgram {
*
* If not set, default value is `(1.0f, 1.0f, 1.0f)`.
*/
Phong* setLightColor(const Color3<>& color) {
Phong* setLightColor(const Color3& color) {
setUniform(lightColorUniform, color);
return this;
}

2
src/Shaders/Vector.h
Unescape View File

@ -60,7 +60,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT Vector: public Abst
* @brief Set fill color
* @return Pointer to self (for method chaining)
*/
Vector* setColor(const Color4<>& color) {
Vector* setColor(const Color4& color) {
AbstractShaderProgram::setUniform(colorUniform, color);
return this;
}

2
src/Shaders/VertexColor.h
Unescape View File

@ -50,7 +50,7 @@ template<UnsignedInt dimensions> class MAGNUM_SHADERS_EXPORT VertexColor: public
typedef Attribute<0, typename DimensionTraits<dimensions>::VectorType> Position;
/** @brief Vertex color */
typedef Attribute<1, Color3<>> Color;
typedef Attribute<1, Color3> Color;
explicit VertexColor();

8
src/Swizzle.h
Unescape View File

@ -47,10 +47,10 @@ namespace Implementation {
template<class T> struct TypeForSize<2, T> { typedef Math::Vector2<typename T::Type> Type; };
template<class T> struct TypeForSize<3, T> { typedef Math::Vector3<typename T::Type> Type; };
template<class T> struct TypeForSize<4, T> { typedef Math::Vector4<typename T::Type> Type; };
template<class T> struct TypeForSize<3, Color3<T>> { typedef Color3<T> Type; };
template<class T> struct TypeForSize<3, Color4<T>> { typedef Color3<T> Type; };
template<class T> struct TypeForSize<4, Color3<T>> { typedef Color4<T> Type; };
template<class T> struct TypeForSize<4, Color4<T>> { typedef Color4<T> Type; };
template<class T> struct TypeForSize<3, BasicColor3<T>> { typedef BasicColor3<T> Type; };
template<class T> struct TypeForSize<3, BasicColor4<T>> { typedef BasicColor3<T> Type; };
template<class T> struct TypeForSize<4, BasicColor3<T>> { typedef BasicColor4<T> Type; };
template<class T> struct TypeForSize<4, BasicColor4<T>> { typedef BasicColor4<T> Type; };
}
/**

94
src/Test/ColorTest.cpp
Unescape View File

@ -52,10 +52,8 @@ class ColorTest: public TestSuite::Tester {
void configuration();
};
typedef Magnum::Color3<UnsignedByte> Color3;
typedef Magnum::Color4<UnsignedByte> Color4;
typedef Magnum::Color3<Float> Color3f;
typedef Magnum::Color4<Float> Color4f;
typedef Magnum::BasicColor3<UnsignedByte> Color3ub;
typedef Magnum::BasicColor4<UnsignedByte> Color4ub;
ColorTest::ColorTest() {
addTests({&ColorTest::access,
@ -77,8 +75,8 @@ ColorTest::ColorTest() {
}
void ColorTest::access() {
Color3f c3(15, 255, 10);
const Color3f cc3(15, 255, 10);
Color3ub c3(15, 255, 10);
const Color3ub cc3(15, 255, 10);
CORRADE_COMPARE(c3.r(), 15);
CORRADE_COMPARE(c3.g(), 255);
@ -87,8 +85,8 @@ void ColorTest::access() {
CORRADE_COMPARE(cc3.g(), 255);
CORRADE_COMPARE(cc3.b(), 10);
Color4 c4(125, 98, 51, 22);
const Color4f cc4(125, 98, 51, 22);
Color4ub c4(125, 98, 51, 22);
const Color4ub cc4(125, 98, 51, 22);
CORRADE_COMPARE(c4.r(), 125);
CORRADE_COMPARE(c4.g(), 98);
@ -101,98 +99,98 @@ void ColorTest::access() {
}
void ColorTest::fromHue() {
CORRADE_COMPARE(Color3::fromHSV(Deg(27.0f), 1.0f, 1.0f), Color3(255, 114, 0));
CORRADE_COMPARE(Color3::fromHSV(Deg(86.0f), 1.0f, 1.0f), Color3(144, 255, 0));
CORRADE_COMPARE(Color3::fromHSV(Deg(134.0f), 1.0f, 1.0f), Color3(0, 255, 59));
CORRADE_COMPARE(Color3::fromHSV(Deg(191.0f), 1.0f, 1.0f), Color3(0, 208, 255));
CORRADE_COMPARE(Color3::fromHSV(Deg(269.0f), 1.0f, 1.0f), Color3(123, 0, 255));
CORRADE_COMPARE(Color3::fromHSV(Deg(317.0f), 1.0f, 1.0f), Color3(255, 0, 182));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(27.0f), 1.0f, 1.0f), Color3ub(255, 114, 0));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(86.0f), 1.0f, 1.0f), Color3ub(144, 255, 0));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(134.0f), 1.0f, 1.0f), Color3ub(0, 255, 59));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(191.0f), 1.0f, 1.0f), Color3ub(0, 208, 255));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(269.0f), 1.0f, 1.0f), Color3ub(123, 0, 255));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(317.0f), 1.0f, 1.0f), Color3ub(255, 0, 182));
}
void ColorTest::hue() {
CORRADE_COMPARE(Color3(255, 115, 0).hue(), Deg(27.058824f));
CORRADE_COMPARE(Color3(145, 255, 0).hue(), Deg(85.882353f));
CORRADE_COMPARE(Color3(0, 255, 60).hue(), Deg(134.11765f));
CORRADE_COMPARE(Color3(0, 208, 255).hue(), Deg(191.05882f));
CORRADE_COMPARE(Color3(123, 0, 255).hue(), Deg(268.94117f));
CORRADE_COMPARE(Color3(255, 0, 183).hue(), Deg(316.94117f));
CORRADE_COMPARE(Color3ub(255, 115, 0).hue(), Deg(27.058824f));
CORRADE_COMPARE(Color3ub(145, 255, 0).hue(), Deg(85.882353f));
CORRADE_COMPARE(Color3ub(0, 255, 60).hue(), Deg(134.11765f));
CORRADE_COMPARE(Color3ub(0, 208, 255).hue(), Deg(191.05882f));
CORRADE_COMPARE(Color3ub(123, 0, 255).hue(), Deg(268.94117f));
CORRADE_COMPARE(Color3ub(255, 0, 183).hue(), Deg(316.94117f));
}
void ColorTest::fromSaturation() {
CORRADE_COMPARE(Color3::fromHSV(Deg(0.0f), 0.702f, 1.0f), Color3(255, 75, 75));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(0.0f), 0.702f, 1.0f), Color3ub(255, 75, 75));
}
void ColorTest::saturation() {
CORRADE_COMPARE(Color3(255, 76, 76).saturation(), 0.701961f);
CORRADE_COMPARE(Color3().saturation(), 0.0f);
CORRADE_COMPARE(Color3ub(255, 76, 76).saturation(), 0.701961f);
CORRADE_COMPARE(Color3ub().saturation(), 0.0f);
}
void ColorTest::fromValue() {
CORRADE_COMPARE(Color3::fromHSV(Deg(0.0f), 1.0f, 0.522f), Color3(133, 0, 0));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(0.0f), 1.0f, 0.522f), Color3ub(133, 0, 0));
}
void ColorTest::value() {
CORRADE_COMPARE(Color3(133, 0, 0).value(), 0.521569f);
CORRADE_COMPARE(Color3ub(133, 0, 0).value(), 0.521569f);
}
void ColorTest::hsv() {
CORRADE_COMPARE(Color3::fromHSV(Deg(230.0f), 0.749f, 0.427f), Color3(27, 40, 108));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(230.0f), 0.749f, 0.427f), Color3ub(27, 40, 108));
Deg hue;
Float saturation, value;
std::tie(hue, saturation, value) = Color3(27, 41, 109).toHSV();
std::tie(hue, saturation, value) = Color3ub(27, 41, 109).toHSV();
CORRADE_COMPARE(hue, Deg(229.756106f));
CORRADE_COMPARE(saturation, 0.752294f);
CORRADE_COMPARE(value, 0.427451f);
}
void ColorTest::hsvOverflow() {
CORRADE_COMPARE(Color3::fromHSV(Deg(27.0f-360.0f), 1.0f, 1.0f), Color3(255, 114, 0));
CORRADE_COMPARE(Color3::fromHSV(Deg(86.0f-360.0f), 1.0f, 1.0f), Color3(144, 255, 0));
CORRADE_COMPARE(Color3::fromHSV(Deg(134.0f-360.0f), 1.0f, 1.0f), Color3(0, 255, 59));
CORRADE_COMPARE(Color3::fromHSV(Deg(191.0f-360.0f), 1.0f, 1.0f), Color3(0, 208, 255));
CORRADE_COMPARE(Color3::fromHSV(Deg(269.0f-360.0f), 1.0f, 1.0f), Color3(123, 0, 255));
CORRADE_COMPARE(Color3::fromHSV(Deg(317.0f-360.0f), 1.0f, 1.0f), Color3(255, 0, 182));
CORRADE_COMPARE(Color3::fromHSV(Deg(360.0f+27.0f), 1.0f, 1.0f), Color3(255, 114, 0));
CORRADE_COMPARE(Color3::fromHSV(Deg(360.0f+86.0f), 1.0f, 1.0f), Color3(144, 255, 0));
CORRADE_COMPARE(Color3::fromHSV(Deg(360.0f+134.0f), 1.0f, 1.0f), Color3(0, 255, 59));
CORRADE_COMPARE(Color3::fromHSV(Deg(360.0f+191.0f), 1.0f, 1.0f), Color3(0, 208, 255));
CORRADE_COMPARE(Color3::fromHSV(Deg(360.0f+269.0f), 1.0f, 1.0f), Color3(123, 0, 255));
CORRADE_COMPARE(Color3::fromHSV(Deg(360.0f+317.0f), 1.0f, 1.0f), Color3(255, 0, 182));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(27.0f-360.0f), 1.0f, 1.0f), Color3ub(255, 114, 0));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(86.0f-360.0f), 1.0f, 1.0f), Color3ub(144, 255, 0));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(134.0f-360.0f), 1.0f, 1.0f), Color3ub(0, 255, 59));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(191.0f-360.0f), 1.0f, 1.0f), Color3ub(0, 208, 255));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(269.0f-360.0f), 1.0f, 1.0f), Color3ub(123, 0, 255));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(317.0f-360.0f), 1.0f, 1.0f), Color3ub(255, 0, 182));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(360.0f+27.0f), 1.0f, 1.0f), Color3ub(255, 114, 0));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(360.0f+86.0f), 1.0f, 1.0f), Color3ub(144, 255, 0));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(360.0f+134.0f), 1.0f, 1.0f), Color3ub(0, 255, 59));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(360.0f+191.0f), 1.0f, 1.0f), Color3ub(0, 208, 255));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(360.0f+269.0f), 1.0f, 1.0f), Color3ub(123, 0, 255));
CORRADE_COMPARE(Color3ub::fromHSV(Deg(360.0f+317.0f), 1.0f, 1.0f), Color3ub(255, 0, 182));
}
void ColorTest::hsvAlpha() {
CORRADE_COMPARE(Color4::fromHSV(std::make_tuple(Deg(230.0f), 0.749f, 0.427f), 23), Color4(27, 40, 108, 23));
CORRADE_COMPARE(Color4::fromHSV(Deg(230.0f), 0.749f, 0.427f, 23), Color4(27, 40, 108, 23));
CORRADE_COMPARE(Color4ub::fromHSV(std::make_tuple(Deg(230.0f), 0.749f, 0.427f), 23), Color4ub(27, 40, 108, 23));
CORRADE_COMPARE(Color4ub::fromHSV(Deg(230.0f), 0.749f, 0.427f, 23), Color4ub(27, 40, 108, 23));
}
void ColorTest::debug() {
std::ostringstream o;
Debug(&o) << Color3f(0.5f, 0.75f, 1.0f);
Debug(&o) << Color3(0.5f, 0.75f, 1.0f);
CORRADE_COMPARE(o.str(), "Vector(0.5, 0.75, 1)\n");
o.str({});
Debug(&o) << Color4f(0.5f, 0.75f, 0.0f, 1.0f);
Debug(&o) << Color4(0.5f, 0.75f, 0.0f, 1.0f);
CORRADE_COMPARE(o.str(), "Vector(0.5, 0.75, 0, 1)\n");
}
void ColorTest::configuration() {
Utility::Configuration c;
Color3f color3(0.5f, 0.75f, 1.0f);
Color3 color3(0.5f, 0.75f, 1.0f);
std::string value3("0.5 0.75 1");
c.setValue("color3", color3);
CORRADE_COMPARE(c.value("color3"), value3);
CORRADE_COMPARE(c.value<Color3f>("color3"), color3);
CORRADE_COMPARE(c.value<Color3>("color3"), color3);
Color4f color4(0.5f, 0.75f, 0.0f, 1.0f);
Color4 color4(0.5f, 0.75f, 0.0f, 1.0f);
std::string value4("0.5 0.75 0 1");
c.setValue("color4", color4);
CORRADE_COMPARE(c.value("color4"), value4);
CORRADE_COMPARE(c.value<Color4f>("color4"), color4);
CORRADE_COMPARE(c.value<Color4>("color4"), color4);
}
}}

12
src/Test/SwizzleTest.cpp
Unescape View File

@ -50,8 +50,8 @@ void SwizzleTest::rgba() {
void SwizzleTest::type() {
constexpr Vector4i orig;
constexpr Color3<Float> origColor3;
constexpr Color4<UnsignedByte> origColor4;
constexpr Color3 origColor3;
constexpr BasicColor4<UnsignedByte> origColor4;
constexpr auto a = swizzle<'y', 'a'>(orig);
CORRADE_VERIFY((std::is_same<decltype(a), const Vector2i>::value));
@ -63,16 +63,16 @@ void SwizzleTest::type() {
CORRADE_VERIFY((std::is_same<decltype(c), const Vector4i>::value));
constexpr auto d = swizzle<'y', 'z', 'r'>(origColor3);
CORRADE_VERIFY((std::is_same<decltype(d), const Color3<Float>>::value));
CORRADE_VERIFY((std::is_same<decltype(d), const Color3>::value));
constexpr auto e = swizzle<'y', 'z', 'a'>(origColor4);
CORRADE_VERIFY((std::is_same<decltype(e), const Color3<UnsignedByte>>::value));
CORRADE_VERIFY((std::is_same<decltype(e), const BasicColor3<UnsignedByte>>::value));
constexpr auto f = swizzle<'y', 'z', 'y', 'x'>(origColor3);
CORRADE_VERIFY((std::is_same<decltype(f), const Color4<Float>>::value));
CORRADE_VERIFY((std::is_same<decltype(f), const Color4>::value));
constexpr auto g = swizzle<'y', 'a', 'y', 'x'>(origColor4);
CORRADE_VERIFY((std::is_same<decltype(g), const Color4<UnsignedByte>>::value));
CORRADE_VERIFY((std::is_same<decltype(g), const BasicColor4<UnsignedByte>>::value));
}
void SwizzleTest::defaultType() {

2
src/Texture.h
Unescape View File

@ -427,7 +427,7 @@ template<UnsignedInt dimensions> class Texture: public AbstractTexture {
return this;
}
#ifndef MAGNUM_TARGET_GLES3
Texture<Dimensions>* setBorderColor(const Color4<>& color) {
Texture<Dimensions>* setBorderColor(const Color4& color) {
AbstractTexture::setBorderColor(color);
return this;
}

Write Preview
Loading…
Cancel
Save