Add vertex formats and lookup function.

src/common/angleutils.h

@@ -14,9 +14,9 @@
 #include <climits>
 #include <cstdarg>
 #include <cstddef>
-#include <string>
 #include <set>
 #include <sstream>
+#include <string>
 #include <vector>
 
 // A helper class to disallow copy and assignment operators
@@ -31,11 +31,11 @@ class NonCopyable
 {
   protected:
     constexpr NonCopyable() = default;
-    ~NonCopyable() = default;
+    ~NonCopyable()          = default;
 
   private:
-    NonCopyable(const NonCopyable&) = delete;
-    void operator=(const NonCopyable&) = delete;
+    NonCopyable(const NonCopyable &) = delete;
+    void operator=(const NonCopyable &) = delete;
 };
 
 extern const uintptr_t DirtyPointer;
@@ -86,7 +86,7 @@ void SafeRelease(T (&resourceBlock)[N])
 }
 
 template <typename T>
-void SafeRelease(T& resource)
+void SafeRelease(T &resource)
 {
     if (resource)
     {
@@ -103,7 +103,7 @@ void SafeDelete(T *&resource)
 }
 
 template <typename T>
-void SafeDeleteContainer(T& resource)
+void SafeDeleteContainer(T &resource)
 {
     for (auto &element : resource)
     {
@@ -113,7 +113,7 @@ void SafeDeleteContainer(T& resource)
 }
 
 template <typename T>
-void SafeDeleteArray(T*& resource)
+void SafeDeleteArray(T *&resource)
 {
     delete[] resource;
     resource = nullptr;
@@ -148,7 +148,7 @@ inline bool IsMaskFlagSet(T mask, T flag)
     return (mask & flag) == flag;
 }
 
-inline const char* MakeStaticString(const std::string &str)
+inline const char *MakeStaticString(const std::string &str)
 {
     static std::set<std::string> strings;
     std::set<std::string>::iterator it = strings.find(str);
@@ -173,7 +173,7 @@ inline std::string Str(int i)
     return strstr.str();
 }
 
-size_t FormatStringIntoVector(const char *fmt, va_list vararg, std::vector<char>& buffer);
+size_t FormatStringIntoVector(const char *fmt, va_list vararg, std::vector<char> &buffer);
 
 std::string FormatString(const char *fmt, va_list vararg);
 std::string FormatString(const char *fmt, ...);
@@ -207,6 +207,52 @@ std::string ToString(const T &value)
 #define GL_BGRA8_TYPELESS_ANGLEX 0x6AC3
 #define GL_BGRA8_TYPELESS_SRGB_ANGLEX 0x6AC4
 
+#define GL_R8_SSCALED_ANGLEX 0x6AC6
+#define GL_RG8_SSCALED_ANGLEX 0x6AC7
+#define GL_RGB8_SSCALED_ANGLEX 0x6AC8
+#define GL_RGBA8_SSCALED_ANGLEX 0x6AC9
+#define GL_R8_USCALED_ANGLEX 0x6ACA
+#define GL_RG8_USCALED_ANGLEX 0x6ACB
+#define GL_RGB8_USCALED_ANGLEX 0x6ACC
+#define GL_RGBA8_USCALED_ANGLEX 0x6ACD
+
+#define GL_R16_SSCALED_ANGLEX 0x6ACE
+#define GL_RG16_SSCALED_ANGLEX 0x6ACF
+#define GL_RGB16_SSCALED_ANGLEX 0x6AD0
+#define GL_RGBA16_SSCALED_ANGLEX 0x6AD1
+#define GL_R16_USCALED_ANGLEX 0x6AD2
+#define GL_RG16_USCALED_ANGLEX 0x6AD3
+#define GL_RGB16_USCALED_ANGLEX 0x6AD4
+#define GL_RGBA16_USCALED_ANGLEX 0x6AD5
+
+#define GL_R32_SSCALED_ANGLEX 0x6AD6
+#define GL_RG32_SSCALED_ANGLEX 0x6AD7
+#define GL_RGB32_SSCALED_ANGLEX 0x6AD8
+#define GL_RGBA32_SSCALED_ANGLEX 0x6AD9
+#define GL_R32_USCALED_ANGLEX 0x6ADA
+#define GL_RG32_USCALED_ANGLEX 0x6ADB
+#define GL_RGB32_USCALED_ANGLEX 0x6ADC
+#define GL_RGBA32_USCALED_ANGLEX 0x6ADD
+
+#define GL_R32_SNORM_ANGLEX 0x6ADE
+#define GL_RG32_SNORM_ANGLEX 0x6ADF
+#define GL_RGB32_SNORM_ANGLEX 0x6AE0
+#define GL_RGBA32_SNORM_ANGLEX 0x6AE1
+#define GL_R32_UNORM_ANGLEX 0x6AE2
+#define GL_RG32_UNORM_ANGLEX 0x6AE3
+#define GL_RGB32_UNORM_ANGLEX 0x6AE4
+#define GL_RGBA32_UNORM_ANGLEX 0x6AE5
+
+#define GL_R32_FIXED_ANGLEX 0x6AE6
+#define GL_RG32_FIXED_ANGLEX 0x6AE7
+#define GL_RGB32_FIXED_ANGLEX 0x6AE8
+#define GL_RGBA32_FIXED_ANGLEX 0x6AE9
+
+#define GL_RGB10_A2_SINT_ANGLEX 0x6AEA
+#define GL_RGB10_A2_SNORM_ANGLEX 0x6AEB
+#define GL_RGB10_A2_SSCALED_ANGLEX 0x6AEC
+#define GL_RGB10_A2_USCALED_ANGLEX 0x6AED
+
 // TODO(jmadill): Clean this up at some point.
 #define EGL_PLATFORM_ANGLE_PLATFORM_METHODS_ANGLEX 0x9999
 
@@ -267,4 +313,4 @@ std::string ToString(const T &value)
 #define ANGLE_NO_DISCARD
 #endif  // __has_cpp_attribute(nodiscard)
 
-#endif // COMMON_ANGLEUTILS_H_
+#endif  // COMMON_ANGLEUTILS_H_

src/image_util/imageformats.cpp

@@ -1673,6 +1673,46 @@ void R10G10B10A2::average(R10G10B10A2 *dst, const R10G10B10A2 *src1, const R10G1
     dst->A = gl::average(src1->A, src2->A);
 }
 
+void R10G10B10A2S::readColor(gl::ColorI *dst, const R10G10B10A2S *src)
+{
+    dst->red   = src->R;
+    dst->green = src->G;
+    dst->blue  = src->B;
+    dst->alpha = src->A;
+}
+
+void R10G10B10A2S::readColor(gl::ColorF *dst, const R10G10B10A2S *src)
+{
+    dst->red   = gl::normalizedToFloat<10>(src->R);
+    dst->green = gl::normalizedToFloat<10>(src->G);
+    dst->blue  = gl::normalizedToFloat<10>(src->B);
+    dst->alpha = gl::normalizedToFloat<2>(src->A);
+}
+
+void R10G10B10A2S::writeColor(R10G10B10A2S *dst, const gl::ColorI *src)
+{
+    dst->R = static_cast<int32_t>(src->red);
+    dst->G = static_cast<int32_t>(src->green);
+    dst->B = static_cast<int32_t>(src->blue);
+    dst->A = static_cast<int32_t>(src->alpha);
+}
+
+void R10G10B10A2S::writeColor(R10G10B10A2S *dst, const gl::ColorF *src)
+{
+    dst->R = gl::floatToNormalized<10, int32_t>(src->red);
+    dst->G = gl::floatToNormalized<10, int32_t>(src->green);
+    dst->B = gl::floatToNormalized<10, int32_t>(src->blue);
+    dst->A = gl::floatToNormalized<2, int32_t>(src->alpha);
+}
+
+void R10G10B10A2S::average(R10G10B10A2S *dst, const R10G10B10A2S *src1, const R10G10B10A2S *src2)
+{
+    dst->R = gl::average(src1->R, src2->R);
+    dst->G = gl::average(src1->G, src2->G);
+    dst->B = gl::average(src1->B, src2->B);
+    dst->A = gl::average(src1->A, src2->A);
+}
+
 void R9G9B9E5::readColor(gl::ColorF *dst, const R9G9B9E5 *src)
 {
     gl::convert999E5toRGBFloats(gl::bitCast<uint32_t>(*src), &dst->red, &dst->green, &dst->blue);

src/image_util/imageformats.h

@@ -670,6 +670,21 @@ struct R10G10B10A2
 };
 static_assert(sizeof(R10G10B10A2) == 4, "R10G10B10A2 struct not 32-bits.");
 
+struct R10G10B10A2S
+{
+    int32_t R : 10;
+    int32_t G : 10;
+    int32_t B : 10;
+    int32_t A : 2;
+
+    static void readColor(gl::ColorF *dst, const R10G10B10A2S *src);
+    static void readColor(gl::ColorI *dst, const R10G10B10A2S *src);
+    static void writeColor(R10G10B10A2S *dst, const gl::ColorF *src);
+    static void writeColor(R10G10B10A2S *dst, const gl::ColorI *src);
+    static void average(R10G10B10A2S *dst, const R10G10B10A2S *src1, const R10G10B10A2S *src2);
+};
+static_assert(sizeof(R10G10B10A2S) == 4, "R10G10B10A2S struct not 32-bits.");
+
 struct R9G9B9E5
 {
     uint32_t R : 9;

src/libANGLE/formatutils.h

@@ -9,9 +9,9 @@
 #ifndef LIBANGLE_FORMATUTILS_H_
 #define LIBANGLE_FORMATUTILS_H_
 
+#include <stdint.h>
 #include <cstddef>
 #include <ostream>
-#include <stdint.h>
 
 #include "angle_gl.h"
 #include "libANGLE/Caps.h"
@@ -41,7 +41,8 @@ struct Type
     Type();
 
     GLuint bytes;
-    GLuint bytesShift; // Bit shift by this value to effectively divide/multiply by "bytes" in a more optimal way
+    GLuint bytesShift;  // Bit shift by this value to effectively divide/multiply by "bytes" in a
+                        // more optimal way
     bool specialInterpretation;
 };
 const Type &GetTypeInfo(GLenum type);
@@ -78,9 +79,9 @@ struct InternalFormat
                                            bool is3D) const;
 
     ErrorOrResult<GLuint> computePackUnpackEndByte(GLenum formatType,
-                                                       const Extents &size,
-                                                       const PixelStoreStateBase &state,
-                                                       bool is3D) const;
+                                                   const Extents &size,
+                                                   const PixelStoreStateBase &state,
+                                                   bool is3D) const;
 
     bool isLUMA() const;
     GLenum getReadPixelsFormat() const;
@@ -307,7 +308,15 @@ struct VertexFormat : private angle::NonCopyable
     bool pureInteger;
 };
 
-VertexFormatType GetVertexFormatType(GLenum type, GLboolean normalized, GLuint components, bool pureInteger);
+angle::Format::ID GetVertexFormatID(GLenum type,
+                                    GLboolean normalized,
+                                    GLuint components,
+                                    bool pureInteger);
+angle::Format::ID GetVertexFormatID(const VertexAttribute &attrib);
+VertexFormatType GetVertexFormatType(GLenum type,
+                                     GLboolean normalized,
+                                     GLuint components,
+                                     bool pureInteger);
 VertexFormatType GetVertexFormatType(const VertexAttribute &attrib);
 VertexFormatType GetVertexFormatType(const VertexAttribute &attrib, GLenum currentValueType);
 const VertexFormat &GetVertexFormatFromType(VertexFormatType vertexFormatType);
@@ -327,4 +336,4 @@ bool ValidES3CopyConversion(GLenum textureFormat, GLenum framebufferFormat);
 
 }  // namespace gl
 
-#endif // LIBANGLE_FORMATUTILS_H_
+#endif  // LIBANGLE_FORMATUTILS_H_

src/libANGLE/renderer/Format_ID_autogen.inl

@@ -85,68 +85,108 @@ enum class Format::ID
     L32_FLOAT,
     L8A8_UNORM,
     L8_UNORM,
+    R10G10B10A2_SINT,
+    R10G10B10A2_SNORM,
+    R10G10B10A2_SSCALED,
     R10G10B10A2_UINT,
     R10G10B10A2_UNORM,
+    R10G10B10A2_USCALED,
     R11G11B10_FLOAT,
     R16G16B16A16_FLOAT,
     R16G16B16A16_SINT,
     R16G16B16A16_SNORM,
+    R16G16B16A16_SSCALED,
     R16G16B16A16_UINT,
     R16G16B16A16_UNORM,
+    R16G16B16A16_USCALED,
     R16G16B16_FLOAT,
     R16G16B16_SINT,
     R16G16B16_SNORM,
+    R16G16B16_SSCALED,
     R16G16B16_UINT,
     R16G16B16_UNORM,
+    R16G16B16_USCALED,
     R16G16_FLOAT,
     R16G16_SINT,
     R16G16_SNORM,
+    R16G16_SSCALED,
     R16G16_UINT,
     R16G16_UNORM,
+    R16G16_USCALED,
     R16_FLOAT,
     R16_SINT,
     R16_SNORM,
+    R16_SSCALED,
     R16_UINT,
     R16_UNORM,
+    R16_USCALED,
+    R32G32B32A32_FIXED,
     R32G32B32A32_FLOAT,
     R32G32B32A32_SINT,
+    R32G32B32A32_SNORM,
+    R32G32B32A32_SSCALED,
     R32G32B32A32_UINT,
+    R32G32B32A32_UNORM,
+    R32G32B32A32_USCALED,
+    R32G32B32_FIXED,
     R32G32B32_FLOAT,
     R32G32B32_SINT,
+    R32G32B32_SNORM,
+    R32G32B32_SSCALED,
     R32G32B32_UINT,
+    R32G32B32_UNORM,
+    R32G32B32_USCALED,
+    R32G32_FIXED,
     R32G32_FLOAT,
     R32G32_SINT,
+    R32G32_SNORM,
+    R32G32_SSCALED,
     R32G32_UINT,
+    R32G32_UNORM,
+    R32G32_USCALED,
+    R32_FIXED,
     R32_FLOAT,
     R32_SINT,
+    R32_SNORM,
+    R32_SSCALED,
     R32_UINT,
+    R32_UNORM,
+    R32_USCALED,
     R4G4B4A4_UNORM,
     R5G5B5A1_UNORM,
     R5G6B5_UNORM,
     R8G8B8A8_SINT,
     R8G8B8A8_SNORM,
+    R8G8B8A8_SSCALED,
     R8G8B8A8_TYPELESS,
     R8G8B8A8_TYPELESS_SRGB,
     R8G8B8A8_UINT,
     R8G8B8A8_UNORM,
     R8G8B8A8_UNORM_SRGB,
+    R8G8B8A8_USCALED,
     R8G8B8_SINT,
     R8G8B8_SNORM,
+    R8G8B8_SSCALED,
     R8G8B8_UINT,
     R8G8B8_UNORM,
     R8G8B8_UNORM_SRGB,
+    R8G8B8_USCALED,
     R8G8_SINT,
     R8G8_SNORM,
+    R8G8_SSCALED,
     R8G8_UINT,
     R8G8_UNORM,
+    R8G8_USCALED,
     R8_SINT,
     R8_SNORM,
+    R8_SSCALED,
     R8_UINT,
     R8_UNORM,
+    R8_USCALED,
     R9G9B9E5_SHAREDEXP,
     S8_UINT
 };
 
-constexpr uint32_t kNumANGLEFormats = 133;
+constexpr uint32_t kNumANGLEFormats = 173;
 
 }  // namespace angle

src/libANGLE/renderer/angle_format.py

@@ -60,10 +60,16 @@ def get_component_type(format_id):
         return "unorm"
     elif "FLOAT" in format_id:
         return "float"
+    elif "FIXED" in format_id:
+        return "float"
     elif "UINT" in format_id:
         return "uint"
     elif "SINT" in format_id:
         return "int"
+    elif "USCALED" in format_id:
+        return "uint"
+    elif "SSCALED" in format_id:
+        return "int"
     elif format_id == "NONE":
         return "none"
     elif "SRGB" in format_id:

src/libANGLE/renderer/angle_format_map.json

@@ -93,6 +93,10 @@
   [ "GL_RGB", "R8G8B8_UNORM" ],
   [ "GL_RGB10_A2", "R10G10B10A2_UNORM" ],
   [ "GL_RGB10_A2UI", "R10G10B10A2_UINT" ],
+  [ "GL_RGB10_A2_USCALED_ANGLEX", "R10G10B10A2_USCALED" ],
+  [ "GL_RGB10_A2_SNORM_ANGLEX", "R10G10B10A2_SNORM" ],
+  [ "GL_RGB10_A2_SINT_ANGLEX", "R10G10B10A2_SINT" ],
+  [ "GL_RGB10_A2_SSCALED_ANGLEX", "R10G10B10A2_SSCALED" ],
   [ "GL_RGB16F", "R16G16B16_FLOAT" ],
   [ "GL_RGB16I", "R16G16B16_SINT" ],
   [ "GL_RGB16UI", "R16G16B16_UINT" ],
@@ -133,5 +137,41 @@
   [ "GL_RGBA8_TYPELESS_ANGLEX", "R8G8B8A8_TYPELESS" ],
   [ "GL_RGBA8_TYPELESS_SRGB_ANGLEX", "R8G8B8A8_TYPELESS_SRGB" ],
   [ "GL_BGRA8_TYPELESS_ANGLEX", "B8G8R8A8_TYPELESS" ],
-  [ "GL_BGRA8_TYPELESS_SRGB_ANGLEX", "B8G8R8A8_TYPELESS_SRGB" ]
+  [ "GL_BGRA8_TYPELESS_SRGB_ANGLEX", "B8G8R8A8_TYPELESS_SRGB" ],
+  [ "GL_R8_SSCALED_ANGLEX", "R8_SSCALED" ],
+  [ "GL_RG8_SSCALED_ANGLEX", "R8G8_SSCALED" ],
+  [ "GL_RGB8_SSCALED_ANGLEX", "R8G8B8_SSCALED" ],
+  [ "GL_RGBA8_SSCALED_ANGLEX", "R8G8B8A8_SSCALED" ],
+  [ "GL_R8_USCALED_ANGLEX", "R8_USCALED" ],
+  [ "GL_RG8_USCALED_ANGLEX", "R8G8_USCALED" ],
+  [ "GL_RGB8_USCALED_ANGLEX", "R8G8B8_USCALED" ],
+  [ "GL_RGBA8_USCALED_ANGLEX", "R8G8B8A8_USCALED" ],
+  [ "GL_R16_SSCALED_ANGLEX", "R16_SSCALED" ],
+  [ "GL_RG16_SSCALED_ANGLEX", "R16G16_SSCALED" ],
+  [ "GL_RGB16_SSCALED_ANGLEX", "R16G16B16_SSCALED" ],
+  [ "GL_RGBA16_SSCALED_ANGLEX", "R16G16B16A16_SSCALED" ],
+  [ "GL_R16_USCALED_ANGLEX", "R16_USCALED" ],
+  [ "GL_RG16_USCALED_ANGLEX", "R16G16_USCALED" ],
+  [ "GL_RGB16_USCALED_ANGLEX", "R16G16B16_USCALED" ],
+  [ "GL_RGBA16_USCALED_ANGLEX", "R16G16B16A16_USCALED" ],
+  [ "GL_R32_SNORM_ANGLEX", "R32_SNORM" ],
+  [ "GL_RG32_SNORM_ANGLEX", "R32G32_SNORM" ],
+  [ "GL_RGB32_SNORM_ANGLEX", "R32G32B32_SNORM" ],
+  [ "GL_RGBA32_SNORM_ANGLEX", "R32G32B32A32_SNORM" ],
+  [ "GL_R32_UNORM_ANGLEX", "R32_UNORM" ],
+  [ "GL_RG32_UNORM_ANGLEX", "R32G32_UNORM" ],
+  [ "GL_RGB32_UNORM_ANGLEX", "R32G32B32_UNORM" ],
+  [ "GL_RGBA32_UNORM_ANGLEX", "R32G32B32A32_UNORM" ],
+  [ "GL_R32_SSCALED_ANGLEX", "R32_SSCALED" ],
+  [ "GL_RG32_SSCALED_ANGLEX", "R32G32_SSCALED" ],
+  [ "GL_RGB32_SSCALED_ANGLEX", "R32G32B32_SSCALED" ],
+  [ "GL_RGBA32_SSCALED_ANGLEX", "R32G32B32A32_SSCALED" ],
+  [ "GL_R32_USCALED_ANGLEX", "R32_USCALED" ],
+  [ "GL_RG32_USCALED_ANGLEX", "R32G32_USCALED" ],
+  [ "GL_RGB32_USCALED_ANGLEX", "R32G32B32_USCALED" ],
+  [ "GL_RGBA32_USCALED_ANGLEX", "R32G32B32A32_USCALED" ],
+  [ "GL_R32_FIXED_ANGLEX", "R32_FIXED" ],
+  [ "GL_RG32_FIXED_ANGLEX", "R32G32_FIXED" ],
+  [ "GL_RGB32_FIXED_ANGLEX", "R32G32B32_FIXED" ],
+  [ "GL_RGBA32_FIXED_ANGLEX", "R32G32B32A32_FIXED" ]
 ]