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

Add packed, half and double types to VertexFormat. 

Intentionally not enabling / documenting the double types for use with
positions / normals / ... yet. Might come later (or never).
pull/371/head
Vladimír Vondruš 6 years ago
parent
274fdc3813
commit
84ee4f3cc7
4 changed files with 797 additions and 12 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. 42
      src/Magnum/Implementation/vertexFormatMapping.hpp
  2. 157
      src/Magnum/Test/VertexFormatTest.cpp
  3. 301
      src/Magnum/VertexFormat.cpp
  4. 309
      src/Magnum/VertexFormat.h

42
src/Magnum/Implementation/vertexFormatMapping.hpp
Unescape View File

@ -26,13 +26,55 @@
/* Each entry is just the name, for debug output and configuration to string */
#ifdef _c
_c(Float)
_c(Half)
_c(Double)
_c(UnsignedByte)
_c(UnsignedByteNormalized)
_c(Byte)
_c(ByteNormalized)
_c(UnsignedShort)
_c(UnsignedShortNormalized)
_c(Short)
_c(ShortNormalized)
_c(UnsignedInt)
_c(Int)
_c(Vector2)
_c(Vector2h)
_c(Vector2d)
_c(Vector2ub)
_c(Vector2ubNormalized)
_c(Vector2b)
_c(Vector2bNormalized)
_c(Vector2us)
_c(Vector2usNormalized)
_c(Vector2s)
_c(Vector2sNormalized)
_c(Vector2ui)
_c(Vector2i)
_c(Vector3)
_c(Vector3h)
_c(Vector3d)
_c(Vector3ub)
_c(Vector3ubNormalized)
_c(Vector3b)
_c(Vector3bNormalized)
_c(Vector3us)
_c(Vector3usNormalized)
_c(Vector3s)
_c(Vector3sNormalized)
_c(Vector3ui)
_c(Vector3i)
_c(Vector4)
_c(Vector4h)
_c(Vector4d)
_c(Vector4ub)
_c(Vector4ubNormalized)
_c(Vector4b)
_c(Vector4bNormalized)
_c(Vector4us)
_c(Vector4usNormalized)
_c(Vector4s)
_c(Vector4sNormalized)
_c(Vector4ui)
_c(Vector4i)
#endif

157
src/Magnum/Test/VertexFormatTest.cpp
Unescape View File

@ -40,16 +40,59 @@ struct VertexFormatTest: TestSuite::Tester {
void size();
void sizeInvalid();
void componentCount();
void componentCountInvalid();
void componentFormat();
void componentFormatInvalid();
void isNormalized();
void isNormalizedInvalid();
void assemble();
void assembleRoundtrip();
void assembleCantNormalize();
void assembleInvalidComponentCount();
void debug();
void configuration();
};
constexpr struct {
VertexFormat componentType;
bool normalized;
} CombineRoundtripData[] {
{VertexFormat::Float, false},
{VertexFormat::Double, false},
{VertexFormat::UnsignedByte, false},
{VertexFormat::UnsignedByte, true},
{VertexFormat::Byte, false},
{VertexFormat::Byte, true},
{VertexFormat::UnsignedShort, false},
{VertexFormat::UnsignedShort, true},
{VertexFormat::Short, false},
{VertexFormat::Short, true},
{VertexFormat::UnsignedInt, false},
{VertexFormat::Int, false}
};
VertexFormatTest::VertexFormatTest() {
addTests({&VertexFormatTest::mapping,
&VertexFormatTest::size,
&VertexFormatTest::sizeInvalid,
&VertexFormatTest::componentCount,
&VertexFormatTest::componentCountInvalid,
&VertexFormatTest::componentFormat,
&VertexFormatTest::componentFormatInvalid,
&VertexFormatTest::isNormalized,
&VertexFormatTest::isNormalizedInvalid,
&VertexFormatTest::assemble});
addRepeatedInstancedTests({&VertexFormatTest::assembleRoundtrip}, 4,
Containers::arraySize(CombineRoundtripData));
addTests({&VertexFormatTest::assembleCantNormalize,
&VertexFormatTest::assembleInvalidComponentCount,
&VertexFormatTest::debug,
&VertexFormatTest::configuration});
@ -112,6 +155,120 @@ void VertexFormatTest::sizeInvalid() {
"vertexFormatSize(): invalid format VertexFormat(0xdead)\n");
}
void VertexFormatTest::componentCount() {
CORRADE_COMPARE(Magnum::vertexFormatComponentCount(VertexFormat::UnsignedByteNormalized), 1);
CORRADE_COMPARE(Magnum::vertexFormatComponentCount(VertexFormat::Vector2us), 2);
CORRADE_COMPARE(Magnum::vertexFormatComponentCount(VertexFormat::Vector3bNormalized), 3);
CORRADE_COMPARE(Magnum::vertexFormatComponentCount(VertexFormat::Vector4), 4);
}
void VertexFormatTest::componentCountInvalid() {
std::ostringstream out;
Error redirectError{&out};
Magnum::vertexFormatComponentCount(VertexFormat{});
Magnum::vertexFormatComponentCount(VertexFormat(0xdead));
CORRADE_COMPARE(out.str(),
"vertexFormatComponentCount(): invalid format VertexFormat(0x0)\n"
"vertexFormatComponentCount(): invalid format VertexFormat(0xdead)\n");
}
void VertexFormatTest::componentFormat() {
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::Vector4), VertexFormat::Float);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::Vector3h), VertexFormat::Half);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::Vector2d), VertexFormat::Double);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::UnsignedByte), VertexFormat::UnsignedByte);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::UnsignedByteNormalized), VertexFormat::UnsignedByte);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::Vector3bNormalized), VertexFormat::Byte);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::Vector2us), VertexFormat::UnsignedShort);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::Vector2sNormalized), VertexFormat::Short);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::Vector2ui), VertexFormat::UnsignedInt);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(VertexFormat::Vector3i), VertexFormat::Int);
}
void VertexFormatTest::componentFormatInvalid() {
std::ostringstream out;
Error redirectError{&out};
Magnum::vertexFormatComponentFormat(VertexFormat{});
Magnum::vertexFormatComponentFormat(VertexFormat(0xdead));
CORRADE_COMPARE(out.str(),
"vertexFormatComponentType(): invalid format VertexFormat(0x0)\n"
"vertexFormatComponentType(): invalid format VertexFormat(0xdead)\n");
}
void VertexFormatTest::isNormalized() {
CORRADE_VERIFY(isVertexFormatNormalized(VertexFormat::UnsignedByteNormalized));
CORRADE_VERIFY(!isVertexFormatNormalized(VertexFormat::Vector2us));
CORRADE_VERIFY(isVertexFormatNormalized(VertexFormat::Vector3bNormalized));
CORRADE_VERIFY(!isVertexFormatNormalized(VertexFormat::Vector4));
}
void VertexFormatTest::isNormalizedInvalid() {
std::ostringstream out;
Error redirectError{&out};
isVertexFormatNormalized(VertexFormat{});
isVertexFormatNormalized(VertexFormat(0xdead));
CORRADE_COMPARE(out.str(),
"isVertexFormatNormalized(): invalid format VertexFormat(0x0)\n"
"isVertexFormatNormalized(): invalid format VertexFormat(0xdead)\n");
}
void VertexFormatTest::assemble() {
CORRADE_COMPARE(vertexFormat(VertexFormat::UnsignedShort, 3, true),
VertexFormat::Vector3usNormalized);
CORRADE_COMPARE(vertexFormat(VertexFormat::Int, 4, false),
VertexFormat::Vector4i);
CORRADE_COMPARE(vertexFormat(VertexFormat::Double, 1, false),
VertexFormat::Double);
CORRADE_COMPARE(vertexFormat(VertexFormat::Byte, 1, true),
VertexFormat::ByteNormalized);
/* Non-scalar types allowed too, as that makes the internal checking
much simpler than when requiring the type to be scalar non-normalized */
CORRADE_COMPARE(vertexFormat(VertexFormat::Vector4bNormalized, 2, false),
VertexFormat::Vector2b);
CORRADE_COMPARE(vertexFormat(VertexFormat::Vector3h, 2, false),
VertexFormat::Vector2h);
}
void VertexFormatTest::assembleRoundtrip() {
auto&& data = CombineRoundtripData[testCaseInstanceId()];
std::ostringstream out;
{
Debug d{&out, Debug::Flag::NoNewlineAtTheEnd};
d << data.componentType;
if(data.normalized) d << Debug::nospace << ", normalized";
}
setTestCaseDescription(out.str());
VertexFormat result = vertexFormat(data.componentType, testCaseRepeatId() + 1, data.normalized);
CORRADE_COMPARE(Magnum::vertexFormatComponentFormat(result), data.componentType);
CORRADE_COMPARE(Magnum::vertexFormatComponentCount(result), testCaseRepeatId() + 1);
CORRADE_COMPARE(isVertexFormatNormalized(result), data.normalized);
}
void VertexFormatTest::assembleCantNormalize() {
std::ostringstream out;
Error redirectError{&out};
vertexFormat(VertexFormat::Vector2, 1, true);
CORRADE_COMPARE(out.str(),
"vertexFormat(): VertexFormat::Vector2 can't be made normalized\n");
}
void VertexFormatTest::assembleInvalidComponentCount() {
std::ostringstream out;
Error redirectError{&out};
vertexFormat(VertexFormat::Vector3, 5, false);
CORRADE_COMPARE(out.str(),
"vertexFormat(): invalid component count 5\n");
}
void VertexFormatTest::debug() {
std::ostringstream o;
Debug(&o) << VertexFormat::Vector4 << VertexFormat(0xdead);

301
src/Magnum/VertexFormat.cpp
Unescape View File

@ -35,23 +35,318 @@ namespace Magnum {
UnsignedInt vertexFormatSize(const VertexFormat format) {
switch(format) {
case VertexFormat::UnsignedByte:
case VertexFormat::UnsignedByteNormalized:
case VertexFormat::Byte:
case VertexFormat::ByteNormalized:
return 1;
case VertexFormat::Half:
case VertexFormat::UnsignedShort:
case VertexFormat::UnsignedShortNormalized:
case VertexFormat::Short:
case VertexFormat::ShortNormalized:
case VertexFormat::Vector2ub:
case VertexFormat::Vector2ubNormalized:
case VertexFormat::Vector2b:
case VertexFormat::Vector2bNormalized:
return 2;
case VertexFormat::Vector3ub:
case VertexFormat::Vector3ubNormalized:
case VertexFormat::Vector3b:
case VertexFormat::Vector3bNormalized:
return 3;
case VertexFormat::Float:
case VertexFormat::UnsignedInt:
case VertexFormat::Int:
case VertexFormat::Vector2h:
case VertexFormat::Vector2us:
case VertexFormat::Vector2usNormalized:
case VertexFormat::Vector2s:
case VertexFormat::Vector2sNormalized:
case VertexFormat::Vector4ub:
case VertexFormat::Vector4ubNormalized:
case VertexFormat::Vector4b:
case VertexFormat::Vector4bNormalized:
return 4;
case VertexFormat::Vector2: return 8;
case VertexFormat::Vector3: return 12;
case VertexFormat::Vector4: return 16;
case VertexFormat::Vector3h:
case VertexFormat::Vector3us:
case VertexFormat::Vector3usNormalized:
case VertexFormat::Vector3s:
case VertexFormat::Vector3sNormalized:
return 6;
case VertexFormat::Double:
case VertexFormat::Vector2:
case VertexFormat::Vector2ui:
case VertexFormat::Vector2i:
case VertexFormat::Vector4h:
case VertexFormat::Vector4us:
case VertexFormat::Vector4usNormalized:
case VertexFormat::Vector4s:
case VertexFormat::Vector4sNormalized:
return 8;
case VertexFormat::Vector3:
case VertexFormat::Vector3ui:
case VertexFormat::Vector3i:
return 12;
case VertexFormat::Vector2d:
case VertexFormat::Vector4:
case VertexFormat::Vector4ui:
case VertexFormat::Vector4i:
return 16;
case VertexFormat::Vector3d:
return 24;
case VertexFormat::Vector4d:
return 32;
}
CORRADE_ASSERT(false, "vertexFormatSize(): invalid format" << format, {});
}
UnsignedInt vertexFormatComponentCount(const VertexFormat format) {
switch(format) {
case VertexFormat::Float:
case VertexFormat::Half:
case VertexFormat::Double:
case VertexFormat::UnsignedByte:
case VertexFormat::UnsignedByteNormalized:
case VertexFormat::Byte:
case VertexFormat::ByteNormalized:
case VertexFormat::UnsignedShort:
case VertexFormat::UnsignedShortNormalized:
case VertexFormat::Short:
case VertexFormat::ShortNormalized:
case VertexFormat::UnsignedInt:
case VertexFormat::Int:
return 1;
case VertexFormat::Vector2:
case VertexFormat::Vector2h:
case VertexFormat::Vector2d:
case VertexFormat::Vector2ub:
case VertexFormat::Vector2ubNormalized:
case VertexFormat::Vector2b:
case VertexFormat::Vector2bNormalized:
case VertexFormat::Vector2us:
case VertexFormat::Vector2usNormalized:
case VertexFormat::Vector2s:
case VertexFormat::Vector2sNormalized:
case VertexFormat::Vector2ui:
case VertexFormat::Vector2i:
return 2;
case VertexFormat::Vector3:
case VertexFormat::Vector3h:
case VertexFormat::Vector3d:
case VertexFormat::Vector3ub:
case VertexFormat::Vector3ubNormalized:
case VertexFormat::Vector3b:
case VertexFormat::Vector3bNormalized:
case VertexFormat::Vector3us:
case VertexFormat::Vector3usNormalized:
case VertexFormat::Vector3s:
case VertexFormat::Vector3sNormalized:
case VertexFormat::Vector3ui:
case VertexFormat::Vector3i:
return 3;
case VertexFormat::Vector4:
case VertexFormat::Vector4h:
case VertexFormat::Vector4d:
case VertexFormat::Vector4ub:
case VertexFormat::Vector4ubNormalized:
case VertexFormat::Vector4b:
case VertexFormat::Vector4bNormalized:
case VertexFormat::Vector4us:
case VertexFormat::Vector4usNormalized:
case VertexFormat::Vector4s:
case VertexFormat::Vector4sNormalized:
case VertexFormat::Vector4ui:
case VertexFormat::Vector4i:
return 4;
}
CORRADE_ASSERT(false, "vertexFormatComponentCount(): invalid format" << format, {});
}
VertexFormat vertexFormatComponentFormat(const VertexFormat format) {
switch(format) {
case VertexFormat::Float:
case VertexFormat::Vector2:
case VertexFormat::Vector3:
case VertexFormat::Vector4:
return VertexFormat::Float;
case VertexFormat::Half:
case VertexFormat::Vector2h:
case VertexFormat::Vector3h:
case VertexFormat::Vector4h:
return VertexFormat::Half;
case VertexFormat::Double:
case VertexFormat::Vector2d:
case VertexFormat::Vector3d:
case VertexFormat::Vector4d:
return VertexFormat::Double;
case VertexFormat::UnsignedByte:
case VertexFormat::UnsignedByteNormalized:
case VertexFormat::Vector2ub:
case VertexFormat::Vector2ubNormalized:
case VertexFormat::Vector3ub:
case VertexFormat::Vector3ubNormalized:
case VertexFormat::Vector4ub:
case VertexFormat::Vector4ubNormalized:
return VertexFormat::UnsignedByte;
case VertexFormat::Byte:
case VertexFormat::ByteNormalized:
case VertexFormat::Vector2b:
case VertexFormat::Vector2bNormalized:
case VertexFormat::Vector3b:
case VertexFormat::Vector3bNormalized:
case VertexFormat::Vector4b:
case VertexFormat::Vector4bNormalized:
return VertexFormat::Byte;
case VertexFormat::UnsignedShort:
case VertexFormat::UnsignedShortNormalized:
case VertexFormat::Vector2us:
case VertexFormat::Vector2usNormalized:
case VertexFormat::Vector3us:
case VertexFormat::Vector3usNormalized:
case VertexFormat::Vector4us:
case VertexFormat::Vector4usNormalized:
return VertexFormat::UnsignedShort;
case VertexFormat::Short:
case VertexFormat::ShortNormalized:
case VertexFormat::Vector2s:
case VertexFormat::Vector2sNormalized:
case VertexFormat::Vector3s:
case VertexFormat::Vector3sNormalized:
case VertexFormat::Vector4s:
case VertexFormat::Vector4sNormalized:
return VertexFormat::Short;
case VertexFormat::UnsignedInt:
case VertexFormat::Vector2ui:
case VertexFormat::Vector3ui:
case VertexFormat::Vector4ui:
return VertexFormat::UnsignedInt;
case VertexFormat::Int:
case VertexFormat::Vector2i:
case VertexFormat::Vector3i:
case VertexFormat::Vector4i:
return VertexFormat::Int;
}
CORRADE_ASSERT(false, "vertexFormatComponentType(): invalid format" << format, {});
}
bool isVertexFormatNormalized(const VertexFormat format) {
switch(format) {
case VertexFormat::Float:
case VertexFormat::Half:
case VertexFormat::Double:
case VertexFormat::UnsignedByte:
case VertexFormat::Byte:
case VertexFormat::UnsignedShort:
case VertexFormat::Short:
case VertexFormat::UnsignedInt:
case VertexFormat::Int:
case VertexFormat::Vector2:
case VertexFormat::Vector2h:
case VertexFormat::Vector2d:
case VertexFormat::Vector2ub:
case VertexFormat::Vector2b:
case VertexFormat::Vector2us:
case VertexFormat::Vector2s:
case VertexFormat::Vector2ui:
case VertexFormat::Vector2i:
case VertexFormat::Vector3:
case VertexFormat::Vector3h:
case VertexFormat::Vector3d:
case VertexFormat::Vector3ub:
case VertexFormat::Vector3b:
case VertexFormat::Vector3us:
case VertexFormat::Vector3s:
case VertexFormat::Vector3ui:
case VertexFormat::Vector3i:
case VertexFormat::Vector4:
case VertexFormat::Vector4h:
case VertexFormat::Vector4d:
case VertexFormat::Vector4ub:
case VertexFormat::Vector4b:
case VertexFormat::Vector4us:
case VertexFormat::Vector4s:
case VertexFormat::Vector4ui:
case VertexFormat::Vector4i:
return false;
case VertexFormat::UnsignedByteNormalized:
case VertexFormat::ByteNormalized:
case VertexFormat::UnsignedShortNormalized:
case VertexFormat::ShortNormalized:
case VertexFormat::Vector2ubNormalized:
case VertexFormat::Vector2bNormalized:
case VertexFormat::Vector2usNormalized:
case VertexFormat::Vector2sNormalized:
case VertexFormat::Vector3ubNormalized:
case VertexFormat::Vector3bNormalized:
case VertexFormat::Vector3usNormalized:
case VertexFormat::Vector3sNormalized:
case VertexFormat::Vector4ubNormalized:
case VertexFormat::Vector4bNormalized:
case VertexFormat::Vector4usNormalized:
case VertexFormat::Vector4sNormalized:
return true;
}
CORRADE_ASSERT(false, "isVertexFormatNormalized(): invalid format" << format, {});
}
VertexFormat vertexFormat(const VertexFormat format, UnsignedInt componentCount, bool normalized) {
VertexFormat componentFormat = vertexFormatComponentFormat(format);
/* First turn the format into a normalized one, if requested */
if(normalized) {
switch(componentFormat) {
case VertexFormat::UnsignedByte:
componentFormat = VertexFormat::UnsignedByteNormalized;
break;
case VertexFormat::Byte:
componentFormat = VertexFormat::ByteNormalized;
break;
case VertexFormat::UnsignedShort:
componentFormat = VertexFormat::UnsignedShortNormalized;
break;
case VertexFormat::Short:
componentFormat = VertexFormat::ShortNormalized;
break;
default: CORRADE_ASSERT(false,
"vertexFormat():" << format << "can't be made normalized", {});
}
}
/* Then turn them into desired component count, assuming the initial order
is the same in all cases */
if(componentCount == 1)
return componentFormat;
else if(componentCount == 2)
return VertexFormat(UnsignedInt(VertexFormat::Vector2) +
UnsignedInt(componentFormat) - UnsignedInt(VertexFormat::Float));
else if(componentCount == 3)
return VertexFormat(UnsignedInt(VertexFormat::Vector3) +
UnsignedInt(componentFormat) - UnsignedInt(VertexFormat::Float));
else if(componentCount == 4)
return VertexFormat(UnsignedInt(VertexFormat::Vector4) +
UnsignedInt(componentFormat) - UnsignedInt(VertexFormat::Float));
else CORRADE_ASSERT(false,
"vertexFormat(): invalid component count" << componentCount, {});
CORRADE_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */
}
namespace {
constexpr const char* VertexFormatNames[] {

309
src/Magnum/VertexFormat.h
Unescape View File

@ -26,7 +26,7 @@
*/
/** @file
* @brief Enum @ref Magnum::VertexFormat, function @ref Magnum::vertexFormatSize()
* @brief Enum @ref Magnum::VertexFormat, @ref Magnum::vertexFormatSize(), @ref Magnum::vertexFormatComponentCount(), @ref Magnum::vertexFormatComponentFormat(), @ref Magnum::isVertexFormatNormalized()
*/
#include <Corrade/Utility/StlForwardString.h>
@ -48,37 +48,328 @@ types and matrices.
enum class VertexFormat: UnsignedInt {
/* Zero reserved for an invalid type (but not being a named value) */
Float = 1, /**< @ref Float */
UnsignedByte, /**< @ref UnsignedByte */
Byte, /**< @ref Byte */
UnsignedShort, /**< @ref UnsignedShort */
Short, /**< @ref Short */
UnsignedInt, /**< @ref UnsignedInt */
Int, /**< @ref Int */
/** @ref Float */
Float = 1,
/** @ref Half */
Half,
/** @ref Double */
Double,
/** @ref UnsignedByte */
UnsignedByte,
/**
* @ref UnsignedByte, with range @f$ [0, 255] @f$ interpreted as
* @f$ [0.0, 1.0] @f$.
*/
UnsignedByteNormalized,
/** @ref Byte */
Byte,
/**
* @ref Byte, with range @f$ [-127, 127] @f$ interpreted as
* @f$ [-1.0, 1.0] @f$.
*/
ByteNormalized,
/** @ref UnsignedShort */
UnsignedShort,
/**
* @ref UnsignedShort, with range @f$ [0, 65535] @f$ interpreted as
* @f$ [0.0, 1.0] @f$.
*/
UnsignedShortNormalized,
/** @ref Short */
Short,
/**
* @ref Short, with range @f$ [-32767, 32767] @f$ interpreted as
* @f$ [-1.0, 1.0] @f$.
*/
ShortNormalized,
/** @ref UnsignedInt */
UnsignedInt,
/** @ref Int */
Int,
/**
* @ref Vector2. Usually used for 2D positions and 2D texture coordinates.
*/
Vector2,
/**
* @ref Vector2h. Can be used instead of @ref VertexFormat::Vector2 for 2D
* positions and 2D texture coordinates.
*/
Vector2h,
/** @ref Vector2d */
Vector2d,
/**
* @ref Vector2ub. Can be used instead of @ref VertexFormat::Vector2 for
* packed 2D positions and 2D texture coordinates, in which case the range
* @f$ [0, 255] @f$ is interpreted as @f$ [0.0, 255.0] @f$.
*/
Vector2ub,
/**
* @ref Vector2ub, with range @f$ [0, 255] @f$ interpreted as
* @f$ [0.0, 1.0] @f$. Can be used instead of @ref VertexFormat::Vector2
* for packed 2D positions and 2D texture coordinates.
*/
Vector2ubNormalized,
/**
* @ref Vector2b. Can be used instead of @ref VertexFormat::Vector2 for
* packed 2D positions and 2D texture coordinates, in which case the range
* @f$ [-128, 127] @f$ is interpreted as @f$ [-128.0, 127.0] @f$.
*/
Vector2b,
/**
* @ref Vector2b, with range @f$ [-127, 127] @f$ interpreted as
* @f$ [-1.0, 1.0] @f$. Can be used instead of @ref VertexFormat::Vector2
* for packed 2D positions and 2D texture coordinates.
*/
Vector2bNormalized,
/**
* @ref Vector2us. Can be used instead of @ref VertexFormat::Vector2 for
* packed 2D positions and 2D texture coordinates, in which case the range
* @f$ [0, 65535] @f$ is interpreted as @f$ [0.0, 65535.0] @f$.
*/
Vector2us,
/**
* @ref Vector2us, with range @f$ [0, 65535] @f$ interpreted as
* @f$ [0.0, 1.0] @f$. Can be used instead of @ref VertexFormat::Vector2
* for packed 2D positions and 2D texture coordinates.
*/
Vector2usNormalized,
/**
* @ref Vector2s. Can be used instead of @ref VertexFormat::Vector2 for
* packed 2D positions and 2D texture coordinates, in which case the range
* @f$ [-32768, 32767] @f$ is interpreted as @f$ [-32768.0, 32767.0] @f$.
*/
Vector2s,
/**
* @ref Vector2s, with range @f$ [-32767, 32767] @f$ interpreted as
* @f$ [-1.0, 1.0] @f$. Can be used instead of @ref VertexFormat::Vector2
* for packed 2D positions and 2D texture coordinates.
*/
Vector2sNormalized,
/** @ref Vector2ui */
Vector2ui,
/** @ref Vector2i */
Vector2i,
/**
* @ref Vector3 or @ref Color3. Usually used for 3D positions, normals and
* three-component colors.
*/
Vector3,
/**
* @ref Vector3h. Can be used instead of @ref VertexFormat::Vector3 for
* packed 3D positions and three-component colors.
*/
Vector3h,
/** @ref Vector3d */
Vector3d,
/**
* @ref Vector3ub. Can be used instead of @ref VertexFormat::Vector3 for
* packed 3D positions, in which case the range @f$ [0, 255] @f$ is
* interpreted as @f$ [0.0, 255.0] @f$.
*/
Vector3ub,
/**
* @ref Vector3ub, with range @f$ [0, 255] @f$ interpreted as
* @f$ [0.0, 1.0] @f$. Can be used instead of @ref VertexFormat::Vector3
* for packed 3D positions and three-component colors.
*/
Vector3ubNormalized,
/**
* @ref Vector3b. Can be used instead of @ref VertexFormat::Vector3 for
* packed 3D positions, in which case the range @f$ [-128, 127] @f$ is
* interpreted as @f$ [-128.0, 127.0] @f$.
*/
Vector3b,
/**
* @ref Vector3b, with range @f$ [-127, 127] @f$ interpreted as
* @f$ [-1.0, 1.0] @f$. Can be used instead of
* @ref VertexFormat::Vector3 for packed 3D positions and normals.
*/
Vector3bNormalized,
/**
* @ref Vector3us. Can be used instead of @ref VertexFormat::Vector3 for
* packed 2D positions, in which case the range @f$ [0, 65535] @f$ is
* interpreted as @f$ [0.0, 65535.0] @f$.
*/
Vector3us,
/**
* @ref Vector3us, with range @f$ [0, 65535] @f$ interpreted as
* @f$ [0.0, 1.0] @f$. Can be used instead of @ref VertexFormat::Vector2
* for packed 3D positions and three-component colors.
*/
Vector3usNormalized,
/**
* @ref Vector3s. Can be used instead of @ref VertexFormat::Vector3 for
* packed 3D positions, in which case the range @f$ [-32768, 32767] @f$ is
* interpreted as @f$ [-32768.0, 32767.0] @f$.
*/
Vector3s,
/**
* @ref Vector3s, with range @f$ [-32767, 32767] @f$ interpreted as
* @f$ [-1.0, 1.0] @f$. Can be used instead of @ref VertexFormat::Vector3
* for packed 3D positions and normals.
*/
Vector3sNormalized,
/** @ref Vector3ui */
Vector3ui,
/** @ref Vector3i */
Vector3i,
/**
* @ref Vector4 or @ref Color4. Usually used for four-component colors.
*/
Vector4
Vector4,
/**
* @ref Vector4h. Can be used instead of @ref VertexFormat::Vector4 for
* four-component colors.
*/
Vector4h,
/** @ref Vector4d */
Vector4d,
/** @ref Vector4ub */
Vector4ub,
/**
* @ref Vector4ub, with range @f$ [0, 255] @f$ interpreted as
* @f$ [0.0, 1.0] @f$. Can be used instead of @ref VertexFormat::Vector4
* for packed linear four-component colors.
*/
Vector4ubNormalized,
/** @ref Vector4b */
Vector4b,
/**
* @ref Vector4b, with range @f$ [-127, 127] @f$ interpreted as
* @f$ [-1.0, 1.0] @f$.
*/
Vector4bNormalized,
/** @ref Vector4us */
Vector4us,
/**
* @ref Vector4us, with range @f$ [0, 65535] @f$ interpreted as
* @f$ [0.0, 1.0] @f$. Can be used instead of @ref VertexFormat::Vector4
* for packed linear four-component colors.
*/
Vector4usNormalized,
/** @ref Vector4s */
Vector4s,
/**
* @ref Vector4s, with range @f$ [-32767, 32767] @f$ interpreted as
* @f$ [-1.0, 1.0] @f$.
*/
Vector4sNormalized,
/** @ref Vector4ui */
Vector4ui,
/** @ref Vector4i */
Vector4i
};
/**
@brief Size of given vertex format
@m_since_latest
To get size of a single component, call this function on a result of
@ref vertexFormatComponentFormat().
*/
MAGNUM_EXPORT UnsignedInt vertexFormatSize(VertexFormat format);
/**
@brief Component format of given vertex format
@m_since_latest
The function also removes the normalization aspect from the type --- use
@ref isVertexFormatNormalized() to query that. Returns for example
@ref VertexFormat::Short for @ref VertexFormat::ShortNormalized or
@ref VertexFormat::UnsignedByte for @ref VertexFormat::Vector3ub.
Calling @ref vertexFormatComponentCount() on the return value will always
give @cpp 1 @ce; calling @ref isVertexFormatNormalized() on the return
value will always give @cpp false @ce.
@see @ref vertexFormat(VertexFormat, UnsignedInt, bool)
*/
MAGNUM_EXPORT VertexFormat vertexFormatComponentFormat(VertexFormat format);
/**
@brief Component count of given vertex format
@m_since_latest
Returns @cpp 1 @ce for scalar types and e.g. @cpp 3 @ce for
@ref VertexFormat::Vector3ub.
@see @ref vertexFormat(VertexFormat, UnsignedInt, bool)
*/
MAGNUM_EXPORT UnsignedInt vertexFormatComponentCount(VertexFormat format);
/**
@brief Component count of given vertex format
@m_since_latest
Returns @cpp true @ce for `*Normalized` types, @cpp false @ce otherwise. In
particular, floating-point types are *not* treated as normalized, even though
for example colors might commonly have values only in the @f$ [0.0, 1.0] @f$
range (or normals in the @f$ [-1.0, 1.0] @f$ range).
@see @ref vertexFormat(VertexFormat, UnsignedInt, bool)
*/
MAGNUM_EXPORT bool isVertexFormatNormalized(VertexFormat format);
/**
@brief Assemble a vertex format from parts
@m_since_latest
Converts @p format to a new format of desired component count and
normalization. Expects that @p componentCount is not larger than @cpp 4 @ce and
@p normalized is @cpp true @ce only for 8- and 16-byte integer types.
@see @ref vertexFormatComponentFormat(),
@ref vertexFormatComponentCount(),
@ref isVertexFormatNormalized()
*/
MAGNUM_EXPORT VertexFormat vertexFormat(VertexFormat format, UnsignedInt componentCount, bool normalized);
/**
@debugoperatorenum{VertexFormat}
@m_since_latest

Write Preview
Loading…
Cancel
Save