164 lines
9.1 KiB
C++
164 lines
9.1 KiB
C++
#include <mbgl/gfx/gfx_types.hpp>
|
|
#include <mbgl/gfx/types.hpp>
|
|
#include <mbgl/gl/defines.hpp>
|
|
#include <mbgl/gl/enum.hpp>
|
|
#include <mbgl/test/util.hpp>
|
|
|
|
using namespace mbgl;
|
|
using namespace mbgl::gfx;
|
|
using namespace mbgl::gl;
|
|
|
|
TEST(GL, DrawModeType) {
|
|
ASSERT_EQ(GL_POINTS, Enum<DrawModeType>::to(DrawModeType::Points));
|
|
ASSERT_EQ(GL_LINES, Enum<DrawModeType>::to(DrawModeType::Lines));
|
|
ASSERT_EQ(GL_LINE_LOOP, Enum<DrawModeType>::to(DrawModeType::LineLoop));
|
|
ASSERT_EQ(GL_LINE_STRIP, Enum<DrawModeType>::to(DrawModeType::LineStrip));
|
|
ASSERT_EQ(GL_TRIANGLES, Enum<DrawModeType>::to(DrawModeType::Triangles));
|
|
ASSERT_EQ(GL_TRIANGLE_STRIP, Enum<DrawModeType>::to(DrawModeType::TriangleStrip));
|
|
ASSERT_EQ(GL_TRIANGLE_FAN, Enum<DrawModeType>::to(DrawModeType::TriangleFan));
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<DrawModeType>::to(static_cast<DrawModeType>(-1)));
|
|
}
|
|
|
|
namespace {
|
|
template <typename T>
|
|
auto enumIdentity(T x) {
|
|
return Enum<T>::from(Enum<T>::to(x));
|
|
}
|
|
} // namespace
|
|
|
|
TEST(GL, ColorBlendEquationType) {
|
|
// const auto identity = [](auto x){ return Enum<ColorBlendEquationType>::from(Enum<ColorBlendEquationType>::to(x));
|
|
// };
|
|
ASSERT_EQ(ColorBlendEquationType::Add, enumIdentity(ColorBlendEquationType::Add));
|
|
ASSERT_EQ(ColorBlendEquationType::Subtract, enumIdentity(ColorBlendEquationType::Subtract));
|
|
ASSERT_EQ(ColorBlendEquationType::ReverseSubtract, enumIdentity(ColorBlendEquationType::ReverseSubtract));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<ColorBlendEquationType>::to(static_cast<ColorBlendEquationType>(-1)));
|
|
ASSERT_EQ(ColorBlendEquationType{}, Enum<ColorBlendEquationType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, ColorBlendFactorType) {
|
|
ASSERT_EQ(ColorBlendFactorType::Zero, enumIdentity(ColorBlendFactorType::Zero));
|
|
ASSERT_EQ(ColorBlendFactorType::One, enumIdentity(ColorBlendFactorType::One));
|
|
ASSERT_EQ(ColorBlendFactorType::SrcColor, enumIdentity(ColorBlendFactorType::SrcColor));
|
|
ASSERT_EQ(ColorBlendFactorType::OneMinusSrcColor, enumIdentity(ColorBlendFactorType::OneMinusSrcColor));
|
|
ASSERT_EQ(ColorBlendFactorType::DstColor, enumIdentity(ColorBlendFactorType::DstColor));
|
|
ASSERT_EQ(ColorBlendFactorType::OneMinusDstColor, enumIdentity(ColorBlendFactorType::OneMinusDstColor));
|
|
ASSERT_EQ(ColorBlendFactorType::SrcAlpha, enumIdentity(ColorBlendFactorType::SrcAlpha));
|
|
ASSERT_EQ(ColorBlendFactorType::OneMinusSrcAlpha, enumIdentity(ColorBlendFactorType::OneMinusSrcAlpha));
|
|
ASSERT_EQ(ColorBlendFactorType::DstAlpha, enumIdentity(ColorBlendFactorType::DstAlpha));
|
|
ASSERT_EQ(ColorBlendFactorType::OneMinusDstAlpha, enumIdentity(ColorBlendFactorType::OneMinusDstAlpha));
|
|
ASSERT_EQ(ColorBlendFactorType::ConstantColor, enumIdentity(ColorBlendFactorType::ConstantColor));
|
|
ASSERT_EQ(ColorBlendFactorType::OneMinusConstantColor, enumIdentity(ColorBlendFactorType::OneMinusConstantColor));
|
|
ASSERT_EQ(ColorBlendFactorType::ConstantAlpha, enumIdentity(ColorBlendFactorType::ConstantAlpha));
|
|
ASSERT_EQ(ColorBlendFactorType::OneMinusConstantAlpha, enumIdentity(ColorBlendFactorType::OneMinusConstantAlpha));
|
|
ASSERT_EQ(ColorBlendFactorType::SrcAlphaSaturate, enumIdentity(ColorBlendFactorType::SrcAlphaSaturate));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<ColorBlendFactorType>::to(static_cast<ColorBlendFactorType>(-1)));
|
|
ASSERT_EQ(ColorBlendFactorType{}, Enum<ColorBlendFactorType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, DepthFunctionType) {
|
|
ASSERT_EQ(DepthFunctionType::Never, enumIdentity(DepthFunctionType::Never));
|
|
ASSERT_EQ(DepthFunctionType::Less, enumIdentity(DepthFunctionType::Less));
|
|
ASSERT_EQ(DepthFunctionType::Equal, enumIdentity(DepthFunctionType::Equal));
|
|
ASSERT_EQ(DepthFunctionType::LessEqual, enumIdentity(DepthFunctionType::LessEqual));
|
|
ASSERT_EQ(DepthFunctionType::Greater, enumIdentity(DepthFunctionType::Greater));
|
|
ASSERT_EQ(DepthFunctionType::NotEqual, enumIdentity(DepthFunctionType::NotEqual));
|
|
ASSERT_EQ(DepthFunctionType::GreaterEqual, enumIdentity(DepthFunctionType::GreaterEqual));
|
|
ASSERT_EQ(DepthFunctionType::Always, enumIdentity(DepthFunctionType::Always));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<DepthFunctionType>::to(static_cast<DepthFunctionType>(-1)));
|
|
ASSERT_EQ(DepthFunctionType{}, Enum<DepthFunctionType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, DepthMaskType) {
|
|
ASSERT_EQ(DepthMaskType::ReadOnly, enumIdentity(DepthMaskType::ReadOnly));
|
|
ASSERT_EQ(DepthMaskType::ReadWrite, enumIdentity(DepthMaskType::ReadWrite));
|
|
|
|
// anything non-zero is true, there's no way to represent invalid
|
|
ASSERT_EQ(GL_TRUE, Enum<DepthMaskType>::to(static_cast<DepthMaskType>(-1)));
|
|
}
|
|
|
|
TEST(GL, StencilFunctionType) {
|
|
ASSERT_EQ(StencilFunctionType::Never, enumIdentity(StencilFunctionType::Never));
|
|
ASSERT_EQ(StencilFunctionType::Less, enumIdentity(StencilFunctionType::Less));
|
|
ASSERT_EQ(StencilFunctionType::Equal, enumIdentity(StencilFunctionType::Equal));
|
|
ASSERT_EQ(StencilFunctionType::LessEqual, enumIdentity(StencilFunctionType::LessEqual));
|
|
ASSERT_EQ(StencilFunctionType::Greater, enumIdentity(StencilFunctionType::Greater));
|
|
ASSERT_EQ(StencilFunctionType::NotEqual, enumIdentity(StencilFunctionType::NotEqual));
|
|
ASSERT_EQ(StencilFunctionType::GreaterEqual, enumIdentity(StencilFunctionType::GreaterEqual));
|
|
ASSERT_EQ(StencilFunctionType::Always, enumIdentity(StencilFunctionType::Always));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<StencilFunctionType>::to(static_cast<StencilFunctionType>(-1)));
|
|
ASSERT_EQ(StencilFunctionType{}, Enum<StencilFunctionType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, StencilOpType) {
|
|
ASSERT_EQ(StencilOpType::Keep, enumIdentity(StencilOpType::Keep));
|
|
ASSERT_EQ(StencilOpType::Zero, enumIdentity(StencilOpType::Zero));
|
|
ASSERT_EQ(StencilOpType::Replace, enumIdentity(StencilOpType::Replace));
|
|
ASSERT_EQ(StencilOpType::Increment, enumIdentity(StencilOpType::Increment));
|
|
ASSERT_EQ(StencilOpType::IncrementWrap, enumIdentity(StencilOpType::IncrementWrap));
|
|
ASSERT_EQ(StencilOpType::Decrement, enumIdentity(StencilOpType::Decrement));
|
|
ASSERT_EQ(StencilOpType::DecrementWrap, enumIdentity(StencilOpType::DecrementWrap));
|
|
ASSERT_EQ(StencilOpType::Invert, enumIdentity(StencilOpType::Invert));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<StencilOpType>::to(static_cast<StencilOpType>(-1)));
|
|
ASSERT_EQ(StencilOpType{}, Enum<StencilOpType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, CullFaceSideType) {
|
|
ASSERT_EQ(CullFaceSideType::Front, enumIdentity(CullFaceSideType::Front));
|
|
ASSERT_EQ(CullFaceSideType::Back, enumIdentity(CullFaceSideType::Back));
|
|
ASSERT_EQ(CullFaceSideType::FrontAndBack, enumIdentity(CullFaceSideType::FrontAndBack));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<CullFaceSideType>::to(static_cast<CullFaceSideType>(-1)));
|
|
ASSERT_EQ(CullFaceSideType{}, Enum<CullFaceSideType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, CullFaceWindingType) {
|
|
ASSERT_EQ(CullFaceWindingType::Clockwise, enumIdentity(CullFaceWindingType::Clockwise));
|
|
ASSERT_EQ(CullFaceWindingType::CounterClockwise, enumIdentity(CullFaceWindingType::CounterClockwise));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<CullFaceWindingType>::to(static_cast<CullFaceWindingType>(-1)));
|
|
ASSERT_EQ(CullFaceWindingType{}, Enum<CullFaceWindingType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, BufferUsageType) {
|
|
ASSERT_EQ(BufferUsageType::StreamDraw, enumIdentity(BufferUsageType::StreamDraw));
|
|
ASSERT_EQ(BufferUsageType::StaticDraw, enumIdentity(BufferUsageType::StaticDraw));
|
|
ASSERT_EQ(BufferUsageType::DynamicDraw, enumIdentity(BufferUsageType::DynamicDraw));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<BufferUsageType>::to(static_cast<BufferUsageType>(-1)));
|
|
ASSERT_EQ(BufferUsageType{}, Enum<BufferUsageType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, TexturePixelType) {
|
|
ASSERT_EQ(TexturePixelType::RGBA, enumIdentity(TexturePixelType::RGBA));
|
|
ASSERT_EQ(TexturePixelType::Alpha, enumIdentity(TexturePixelType::Alpha));
|
|
ASSERT_EQ(TexturePixelType::Stencil, enumIdentity(TexturePixelType::Stencil));
|
|
ASSERT_EQ(TexturePixelType::Depth, enumIdentity(TexturePixelType::Depth));
|
|
ASSERT_EQ(TexturePixelType::Luminance, enumIdentity(TexturePixelType::Luminance));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<TexturePixelType>::to(static_cast<TexturePixelType>(-1)));
|
|
ASSERT_EQ(TexturePixelType{}, Enum<TexturePixelType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, TextureChannelDataType) {
|
|
ASSERT_EQ(TextureChannelDataType::UnsignedByte, enumIdentity(TextureChannelDataType::UnsignedByte));
|
|
ASSERT_EQ(TextureChannelDataType::HalfFloat, enumIdentity(TextureChannelDataType::HalfFloat));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<TextureChannelDataType>::to(static_cast<TextureChannelDataType>(-1)));
|
|
ASSERT_EQ(TextureChannelDataType{}, Enum<TextureChannelDataType>::from(GL_RGBA8));
|
|
}
|
|
|
|
TEST(GL, RenderbufferPixelType) {
|
|
ASSERT_EQ(RenderbufferPixelType::RGBA, enumIdentity(RenderbufferPixelType::RGBA));
|
|
ASSERT_EQ(RenderbufferPixelType::Depth, enumIdentity(RenderbufferPixelType::Depth));
|
|
ASSERT_EQ(RenderbufferPixelType::DepthStencil, enumIdentity(RenderbufferPixelType::DepthStencil));
|
|
|
|
ASSERT_EQ(GL_INVALID_ENUM, Enum<RenderbufferPixelType>::to(static_cast<RenderbufferPixelType>(-1)));
|
|
ASSERT_EQ(RenderbufferPixelType{}, Enum<RenderbufferPixelType>::from(GL_RGBA8));
|
|
}
|