Add StringMap for DataFormat

src/common/StringMap.h

@@ -182,6 +182,21 @@ private:
 
 }; // StringMap
 
+#define DECLARE_STRINGMAP(type) \
+bool getConstant(const char *in, type &out); \
+bool getConstant(type in, const char *&out); \
+std::vector<std::string> getConstants(type); \
+
+#define DEFINE_STRINGMAP_BEGIN(type, count, name) \
+static StringMap<type, count>::Entry name##Entries[] =
+
+#define DEFINE_STRINGMAP_END(type, count, name) \
+; \
+static StringMap<type, count> name##s(name##Entries, sizeof(name##Entries)); \
+bool getConstant(const char *in, type &out) { return name##s.find(in, out); } \
+bool getConstant(type in, const char *&out) { return name##s.find(in, out); } \
+std::vector<std::string> getConstants(type) { return name##s.getNames(); }
+
 } // love
 
 #endif // LOVE_STRING_MAP_H

src/modules/graphics/vertex.cpp

@@ -219,8 +219,7 @@ bool isDataTypeInteger(DataType datatype)
 
 IndexDataType getIndexDataTypeFromMax(size_t maxvalue)
 {
-	IndexDataType types[] = {INDEX_UINT16, INDEX_UINT32};
-	return types[maxvalue > LOVE_UINT16_MAX ? 1 : 0];
+	return maxvalue > LOVE_UINT16_MAX ? INDEX_UINT32 : INDEX_UINT16;
 }
 
 int getIndexCount(TriangleIndexMode mode, int vertexCount)
@@ -352,51 +351,46 @@ void VertexAttributes::setCommonFormat(CommonFormat format, uint8 bufferindex)
 	}
 }
 
-static StringMap<BuiltinVertexAttribute, ATTRIB_MAX_ENUM>::Entry attribNameEntries[] =
+DEFINE_STRINGMAP_BEGIN(BuiltinVertexAttribute, ATTRIB_MAX_ENUM, attribName)
 {
 	{ "VertexPosition", ATTRIB_POS           },
 	{ "VertexTexCoord", ATTRIB_TEXCOORD      },
 	{ "VertexColor",    ATTRIB_COLOR         },
-};
-
-static StringMap<BuiltinVertexAttribute, ATTRIB_MAX_ENUM> attribNames(attribNameEntries, sizeof(attribNameEntries));
+}
+DEFINE_STRINGMAP_END(BuiltinVertexAttribute, ATTRIB_MAX_ENUM, attribName)
 
-static StringMap<IndexDataType, INDEX_MAX_ENUM>::Entry indexTypeEntries[] =
+DEFINE_STRINGMAP_BEGIN(IndexDataType, INDEX_MAX_ENUM, indexType)
 {
 	{ "uint16", INDEX_UINT16 },
 	{ "uint32", INDEX_UINT32 },
-};
-
-static StringMap<IndexDataType, INDEX_MAX_ENUM> indexTypes(indexTypeEntries, sizeof(indexTypeEntries));
+}
+DEFINE_STRINGMAP_END(IndexDataType, INDEX_MAX_ENUM, indexType)
 
-static StringMap<BufferUsage, BUFFERUSAGE_MAX_ENUM>::Entry usageEntries[] =
+DEFINE_STRINGMAP_BEGIN(BufferUsage, BUFFERUSAGE_MAX_ENUM, bufferUsage)
 {
 	{ "stream",  BUFFERUSAGE_STREAM  },
 	{ "dynamic", BUFFERUSAGE_DYNAMIC },
 	{ "static",  BUFFERUSAGE_STATIC  },
-};
-
-static StringMap<BufferUsage, BUFFERUSAGE_MAX_ENUM> usages(usageEntries, sizeof(usageEntries));
+}
+DEFINE_STRINGMAP_END(BufferUsage, BUFFERUSAGE_MAX_ENUM, bufferUsage)
 
-static StringMap<PrimitiveType, PRIMITIVE_MAX_ENUM>::Entry primitiveTypeEntries[] =
+DEFINE_STRINGMAP_BEGIN(PrimitiveType, PRIMITIVE_MAX_ENUM, primitiveType)
 {
 	{ "fan",       PRIMITIVE_TRIANGLE_FAN   },
 	{ "strip",     PRIMITIVE_TRIANGLE_STRIP },
 	{ "triangles", PRIMITIVE_TRIANGLES      },
 	{ "points",    PRIMITIVE_POINTS         },
-};
-
-static StringMap<PrimitiveType, PRIMITIVE_MAX_ENUM> primitiveTypes(primitiveTypeEntries, sizeof(primitiveTypeEntries));
+}
+DEFINE_STRINGMAP_END(PrimitiveType, PRIMITIVE_MAX_ENUM, primitiveType)
 
-static StringMap<AttributeStep, STEP_MAX_ENUM>::Entry attributeStepEntries[] =
+DEFINE_STRINGMAP_BEGIN(AttributeStep, STEP_MAX_ENUM, attributeStep)
 {
 	{ "pervertex",   STEP_PER_VERTEX   },
 	{ "perinstance", STEP_PER_INSTANCE },
-};
-
-static StringMap<AttributeStep, STEP_MAX_ENUM> attributeSteps(attributeStepEntries, sizeof(attributeStepEntries));
+}
+DEFINE_STRINGMAP_END(AttributeStep, STEP_MAX_ENUM, attributeStep)
 
-static StringMap<DataType, DATA_MAX_ENUM>::Entry dataTypeEntries[] =
+DEFINE_STRINGMAP_BEGIN(DataType, DATA_MAX_ENUM, dataType)
 {
 	{ "snorm8",  DATA_SNORM8  },
 	{ "unorm8",  DATA_UNORM8  },
@@ -409,141 +403,91 @@ static StringMap<DataType, DATA_MAX_ENUM>::Entry dataTypeEntries[] =
 	{ "int32",   DATA_INT32   },
 	{ "uint32",  DATA_UINT32  },
 	{ "float",   DATA_FLOAT   },
-};
-
-static StringMap<DataType, DATA_MAX_ENUM> dataTypes(dataTypeEntries, sizeof(dataTypeEntries));
-
-static StringMap<CullMode, CULL_MAX_ENUM>::Entry cullModeEntries[] =
-{
-	{ "none",  CULL_NONE  },
-	{ "back",  CULL_BACK  },
-	{ "front", CULL_FRONT },
-};
-
-static StringMap<CullMode, CULL_MAX_ENUM> cullModes(cullModeEntries, sizeof(cullModeEntries));
-
-static StringMap<Winding, WINDING_MAX_ENUM>::Entry windingEntries[] =
-{
-	{ "cw",  WINDING_CW  },
-	{ "ccw", WINDING_CCW },
-};
-
-static StringMap<Winding, WINDING_MAX_ENUM> windings(windingEntries, sizeof(windingEntries));
-
-bool getConstant(const char *in, BuiltinVertexAttribute &out)
-{
-	return attribNames.find(in, out);
-}
-
-bool getConstant(BuiltinVertexAttribute in, const char *&out)
-{
-	return attribNames.find(in, out);
-}
-
-bool getConstant(const char *in, IndexDataType &out)
-{
-	return indexTypes.find(in, out);
-}
-
-bool getConstant(IndexDataType in, const char *&out)
-{
-	return indexTypes.find(in, out);
-}
-
-std::vector<std::string> getConstants(IndexDataType)
-{
-	return indexTypes.getNames();
-}
-
-bool getConstant(const char *in, BufferUsage &out)
-{
-	return usages.find(in, out);
-}
-
-bool getConstant(BufferUsage in, const char *&out)
-{
-	return usages.find(in, out);
 }
+DEFINE_STRINGMAP_END(DataType, DATA_MAX_ENUM, dataType)
 
-std::vector<std::string> getConstants(BufferUsage)
+DEFINE_STRINGMAP_BEGIN(DataFormat, DATAFORMAT_MAX_ENUM, dataFormat)
 {
-	return usages.getNames();
-}
+	{ "float",     DATAFORMAT_FLOAT      },
+	{ "floatvec2", DATAFORMAT_FLOAT_VEC2 },
+	{ "floatvec3", DATAFORMAT_FLOAT_VEC3 },
+	{ "floatvec4", DATAFORMAT_FLOAT_VEC4 },
 
-bool getConstant(const char *in, PrimitiveType &out)
-{
-	return primitiveTypes.find(in, out);
-}
-
-bool getConstant(PrimitiveType in, const char *&out)
-{
-	return primitiveTypes.find(in, out);
-}
+	{ "floatmat2x2", DATAFORMAT_FLOAT_MAT2X2 },
+	{ "floatmat2x3", DATAFORMAT_FLOAT_MAT2X3 },
+	{ "floatmat2x4", DATAFORMAT_FLOAT_MAT2X4 },
 
-std::vector<std::string> getConstants(PrimitiveType)
-{
-	return primitiveTypes.getNames();
-}
+	{ "floatmat3x2", DATAFORMAT_FLOAT_MAT3X2 },
+	{ "floatmat3x3", DATAFORMAT_FLOAT_MAT3X3 },
+	{ "floatmat3x4", DATAFORMAT_FLOAT_MAT3X4 },
 
-bool getConstant(const char *in, AttributeStep &out)
-{
-	return attributeSteps.find(in, out);
-}
+	{ "floatmat4x2", DATAFORMAT_FLOAT_MAT4X2 },
+	{ "floatmat4x3", DATAFORMAT_FLOAT_MAT4X3 },
+	{ "floatmat4x4", DATAFORMAT_FLOAT_MAT4X4 },
 
-bool getConstant(AttributeStep in, const char *&out)
-{
-	return attributeSteps.find(in, out);
-}
+	{ "int32",     DATAFORMAT_INT32      },
+	{ "int32vec2", DATAFORMAT_INT32_VEC2 },
+	{ "int32vec3", DATAFORMAT_INT32_VEC3 },
+	{ "int32vec4", DATAFORMAT_INT32_VEC4 },
 
-std::vector<std::string> getConstants(AttributeStep)
-{
-	return attributeSteps.getNames();
-}
+	{ "uint32",     DATAFORMAT_UINT32      },
+	{ "uint32vec2", DATAFORMAT_UINT32_VEC2 },
+	{ "uint32vec3", DATAFORMAT_UINT32_VEC3 },
+	{ "uint32vec4", DATAFORMAT_UINT32_VEC4 },
 
-bool getConstant(const char *in, DataType &out)
-{
-	return dataTypes.find(in, out);
-}
+	{ "snorm8vec4", DATAFORMAT_SNORM8_VEC4 },
+	{ "unorm8vec4", DATAFORMAT_UNORM8_VEC4 },
+	{ "int8vec4",   DATAFORMAT_INT8_VEC4   },
+	{ "uint8vec4",  DATAFORMAT_UINT8_VEC4  },
 
-bool getConstant(DataType in, const char *&out)
-{
-	return dataTypes.find(in, out);
-}
+	{ "snorm16",     DATAFORMAT_SNORM16      },
+	{ "snorm16vec2", DATAFORMAT_SNORM16_VEC2 },
+	{ "snorm16vec4", DATAFORMAT_SNORM16_VEC4 },
 
-std::vector<std::string> getConstants(DataType)
-{
-	return dataTypes.getNames();
-}
+	{ "unorm16",     DATAFORMAT_UNORM16      },
+	{ "unorm16vec2", DATAFORMAT_UNORM16_VEC2 },
+	{ "unorm16vec4", DATAFORMAT_UNORM16_VEC4 },
 
-bool getConstant(const char *in, CullMode &out)
-{
-	return cullModes.find(in, out);
-}
+	{ "int16",     DATAFORMAT_INT16      },
+	{ "int16vec2", DATAFORMAT_INT16_VEC2 },
+	{ "int16vec4", DATAFORMAT_INT16_VEC4 },
 
-bool getConstant(CullMode in, const char *&out)
-{
-	return cullModes.find(in, out);
-}
+	{ "uint16",     DATAFORMAT_UINT16      },
+	{ "uint16vec2", DATAFORMAT_UINT16_VEC2 },
+	{ "uint16vec4", DATAFORMAT_UINT16_VEC4 },
 
-std::vector<std::string> getConstants(CullMode)
-{
-	return cullModes.getNames();
+	{ "bool",     DATAFORMAT_BOOL      },
+	{ "boolvec2", DATAFORMAT_BOOL_VEC2 },
+	{ "boolvec3", DATAFORMAT_BOOL_VEC3 },
+	{ "boolvec4", DATAFORMAT_BOOL_VEC4 },
 }
+DEFINE_STRINGMAP_END(DataFormat, DATAFORMAT_MAX_ENUM, dataFormat)
 
-bool getConstant(const char *in, Winding &out)
+DEFINE_STRINGMAP_BEGIN(DataBaseType, DATA_BASETYPE_MAX_ENUM, dataBaseType)
 {
-	return windings.find(in, out);
+	{ "float", DATA_BASETYPE_FLOAT },
+	{ "int",   DATA_BASETYPE_INT   },
+	{ "uint",  DATA_BASETYPE_UINT  },
+	{ "snorm", DATA_BASETYPE_SNORM },
+	{ "unorm", DATA_BASETYPE_UNORM },
+	{ "bool",  DATA_BASETYPE_BOOL  },
 }
+DEFINE_STRINGMAP_END(DataBaseType, DATA_BASETYPE_MAX_ENUM, dataBaseType)
 
-bool getConstant(Winding in, const char *&out)
+DEFINE_STRINGMAP_BEGIN(CullMode, CULL_MAX_ENUM, cullMode)
 {
-	return windings.find(in, out);
+	{ "none",  CULL_NONE  },
+	{ "back",  CULL_BACK  },
+	{ "front", CULL_FRONT },
 }
+DEFINE_STRINGMAP_END(CullMode, CULL_MAX_ENUM, cullMode)
 
-std::vector<std::string> getConstants(Winding)
+DEFINE_STRINGMAP_BEGIN(Winding, WINDING_MAX_ENUM, winding)
 {
-	return windings.getNames();
+	{ "cw",  WINDING_CW  },
+	{ "ccw", WINDING_CCW },
 }
+DEFINE_STRINGMAP_END(Winding, WINDING_MAX_ENUM, winding)
 
 } // graphics
 } // love

src/modules/graphics/vertex.h

@@ -23,6 +23,7 @@
 // LOVE
 #include "common/int.h"
 #include "common/Color.h"
+#include "common/StringMap.h"
 
 // C
 #include <stddef.h>
@@ -131,6 +132,7 @@ enum DataType
 	DATA_MAX_ENUM
 };
 
+// Value types used when interfacing with the GPU (vertex and shader data).
 // The order of this enum affects the dataFormatInfo array.
 enum DataFormat
 {
@@ -413,36 +415,16 @@ int getIndexCount(TriangleIndexMode mode, int vertexCount);
 void fillIndices(TriangleIndexMode mode, uint16 vertexStart, uint16 vertexCount, uint16 *indices);
 void fillIndices(TriangleIndexMode mode, uint32 vertexStart, uint32 vertexCount, uint32 *indices);
 
-bool getConstant(const char *in, BuiltinVertexAttribute &out);
-bool getConstant(BuiltinVertexAttribute in, const char *&out);
-
-bool getConstant(const char *in, IndexDataType &out);
-bool getConstant(IndexDataType in, const char *&out);
-std::vector<std::string> getConstants(IndexDataType);
-
-bool getConstant(const char *in, BufferUsage &out);
-bool getConstant(BufferUsage in, const char *&out);
-std::vector<std::string> getConstants(BufferUsage);
-
-bool getConstant(const char *in, PrimitiveType &out);
-bool getConstant(PrimitiveType in, const char *&out);
-std::vector<std::string> getConstants(PrimitiveType);
-
-bool getConstant(const char *in, AttributeStep &out);
-bool getConstant(AttributeStep in, const char *&out);
-std::vector<std::string> getConstants(AttributeStep);
-
-bool getConstant(const char *in, DataType &out);
-bool getConstant(DataType in, const char *&out);
-std::vector<std::string> getConstants(DataType);
-
-bool getConstant(const char *in, CullMode &out);
-bool getConstant(CullMode in, const char *&out);
-std::vector<std::string> getConstants(CullMode);
-
-bool getConstant(const char *in, Winding &out);
-bool getConstant(Winding in, const char *&out);
-std::vector<std::string> getConstants(Winding);
+DECLARE_STRINGMAP(BuiltinVertexAttribute);
+DECLARE_STRINGMAP(IndexDataType);
+DECLARE_STRINGMAP(BufferUsage);
+DECLARE_STRINGMAP(PrimitiveType);
+DECLARE_STRINGMAP(AttributeStep);
+DECLARE_STRINGMAP(DataType);
+DECLARE_STRINGMAP(DataFormat);
+DECLARE_STRINGMAP(DataBaseType);
+DECLARE_STRINGMAP(CullMode);
+DECLARE_STRINGMAP(Winding);
 
 } // graphics
 } // love