diff options
Diffstat (limited to 'gfx/angle/checkout/src/common/utilities.h')
| -rw-r--r-- | gfx/angle/checkout/src/common/utilities.h | 336 |
1 files changed, 336 insertions, 0 deletions
diff --git a/gfx/angle/checkout/src/common/utilities.h b/gfx/angle/checkout/src/common/utilities.h new file mode 100644 index 0000000000..cae620d03b --- /dev/null +++ b/gfx/angle/checkout/src/common/utilities.h @@ -0,0 +1,336 @@ +// +// Copyright 2002 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// utilities.h: Conversion functions and other utility routines. + +#ifndef COMMON_UTILITIES_H_ +#define COMMON_UTILITIES_H_ + +#include <EGL/egl.h> +#include <EGL/eglext.h> +#include <GLSLANG/ShaderLang.h> + +#include <math.h> +#include <string> +#include <vector> + +#include "angle_gl.h" + +#include "common/PackedEnums.h" +#include "common/mathutil.h" +#include "common/platform.h" + +namespace sh +{ +struct ShaderVariable; +} + +constexpr bool ShPixelLocalStorageTypeUsesImages(ShPixelLocalStorageType type) +{ + return type == ShPixelLocalStorageType::ImageStoreR32PackedFormats || + type == ShPixelLocalStorageType::ImageStoreNativeFormats; +} + +namespace gl +{ + +int VariableComponentCount(GLenum type); +GLenum VariableComponentType(GLenum type); +size_t VariableComponentSize(GLenum type); +size_t VariableInternalSize(GLenum type); +size_t VariableExternalSize(GLenum type); +int VariableRowCount(GLenum type); +int VariableColumnCount(GLenum type); +bool IsSamplerType(GLenum type); +bool IsSamplerCubeType(GLenum type); +bool IsSamplerYUVType(GLenum type); +bool IsImageType(GLenum type); +bool IsImage2DType(GLenum type); +bool IsAtomicCounterType(GLenum type); +bool IsOpaqueType(GLenum type); +bool IsMatrixType(GLenum type); +GLenum TransposeMatrixType(GLenum type); +int VariableRegisterCount(GLenum type); +int MatrixRegisterCount(GLenum type, bool isRowMajorMatrix); +int MatrixComponentCount(GLenum type, bool isRowMajorMatrix); +int VariableSortOrder(GLenum type); +GLenum VariableBoolVectorType(GLenum type); +std::string GetGLSLTypeString(GLenum type); + +int AllocateFirstFreeBits(unsigned int *bits, unsigned int allocationSize, unsigned int bitsSize); + +// Parse the base resource name and array indices. Returns the base name of the resource. +// If the provided name doesn't index an array, the outSubscripts vector will be empty. +// If the provided name indexes an array, the outSubscripts vector will contain indices with +// outermost array indices in the back. If an array index is invalid, GL_INVALID_INDEX is added to +// outSubscripts. +std::string ParseResourceName(const std::string &name, std::vector<unsigned int> *outSubscripts); + +bool IsBuiltInName(const char *name); +ANGLE_INLINE bool IsBuiltInName(const std::string &name) +{ + return IsBuiltInName(name.c_str()); +} + +// Strips only the last array index from a resource name. +std::string StripLastArrayIndex(const std::string &name); + +bool SamplerNameContainsNonZeroArrayElement(const std::string &name); + +// Find the range of index values in the provided indices pointer. Primitive restart indices are +// only counted in the range if primitive restart is disabled. +IndexRange ComputeIndexRange(DrawElementsType indexType, + const GLvoid *indices, + size_t count, + bool primitiveRestartEnabled); + +// Get the primitive restart index value for the given index type. +GLuint GetPrimitiveRestartIndex(DrawElementsType indexType); + +// Get the primitive restart index value with the given C++ type. +template <typename T> +constexpr T GetPrimitiveRestartIndexFromType() +{ + return std::numeric_limits<T>::max(); +} + +static_assert(GetPrimitiveRestartIndexFromType<uint8_t>() == 0xFF, + "verify restart index for uint8_t values"); +static_assert(GetPrimitiveRestartIndexFromType<uint16_t>() == 0xFFFF, + "verify restart index for uint8_t values"); +static_assert(GetPrimitiveRestartIndexFromType<uint32_t>() == 0xFFFFFFFF, + "verify restart index for uint8_t values"); + +bool IsTriangleMode(PrimitiveMode drawMode); +bool IsPolygonMode(PrimitiveMode mode); + +namespace priv +{ +extern const angle::PackedEnumMap<PrimitiveMode, bool> gLineModes; +} // namespace priv + +ANGLE_INLINE bool IsLineMode(PrimitiveMode primitiveMode) +{ + return priv::gLineModes[primitiveMode]; +} + +bool IsIntegerFormat(GLenum unsizedFormat); + +// Returns the product of the sizes in the vector, or 1 if the vector is empty. Doesn't currently +// perform overflow checks. +unsigned int ArraySizeProduct(const std::vector<unsigned int> &arraySizes); +// Returns the product of the sizes in the vector except for the outermost dimension, or 1 if the +// vector is empty. +unsigned int InnerArraySizeProduct(const std::vector<unsigned int> &arraySizes); +// Returns the outermost array dimension, or 1 if the vector is empty. +unsigned int OutermostArraySize(const std::vector<unsigned int> &arraySizes); + +// Return the array index at the end of name, and write the length of name before the final array +// index into nameLengthWithoutArrayIndexOut. In case name doesn't include an array index, return +// GL_INVALID_INDEX and write the length of the original string. +unsigned int ParseArrayIndex(const std::string &name, size_t *nameLengthWithoutArrayIndexOut); + +enum class SamplerFormat : uint8_t +{ + Float = 0, + Unsigned = 1, + Signed = 2, + Shadow = 3, + + InvalidEnum = 4, + EnumCount = 4, +}; + +struct UniformTypeInfo final : angle::NonCopyable +{ + inline constexpr UniformTypeInfo(GLenum type, + GLenum componentType, + GLenum textureType, + GLenum transposedMatrixType, + GLenum boolVectorType, + SamplerFormat samplerFormat, + int rowCount, + int columnCount, + int componentCount, + size_t componentSize, + size_t internalSize, + size_t externalSize, + bool isSampler, + bool isMatrixType, + bool isImageType); + + GLenum type; + GLenum componentType; + GLenum textureType; + GLenum transposedMatrixType; + GLenum boolVectorType; + SamplerFormat samplerFormat; + int rowCount; + int columnCount; + int componentCount; + size_t componentSize; + size_t internalSize; + size_t externalSize; + bool isSampler; + bool isMatrixType; + bool isImageType; +}; + +inline constexpr UniformTypeInfo::UniformTypeInfo(GLenum type, + GLenum componentType, + GLenum textureType, + GLenum transposedMatrixType, + GLenum boolVectorType, + SamplerFormat samplerFormat, + int rowCount, + int columnCount, + int componentCount, + size_t componentSize, + size_t internalSize, + size_t externalSize, + bool isSampler, + bool isMatrixType, + bool isImageType) + : type(type), + componentType(componentType), + textureType(textureType), + transposedMatrixType(transposedMatrixType), + boolVectorType(boolVectorType), + samplerFormat(samplerFormat), + rowCount(rowCount), + columnCount(columnCount), + componentCount(componentCount), + componentSize(componentSize), + internalSize(internalSize), + externalSize(externalSize), + isSampler(isSampler), + isMatrixType(isMatrixType), + isImageType(isImageType) +{} + +const UniformTypeInfo &GetUniformTypeInfo(GLenum uniformType); + +const char *GetGenericErrorMessage(GLenum error); + +unsigned int ElementTypeSize(GLenum elementType); + +bool IsMipmapFiltered(GLenum minFilterMode); + +template <typename T> +T GetClampedVertexCount(size_t vertexCount) +{ + static constexpr size_t kMax = static_cast<size_t>(std::numeric_limits<T>::max()); + return static_cast<T>(vertexCount > kMax ? kMax : vertexCount); +} + +enum class PipelineType +{ + GraphicsPipeline = 0, + ComputePipeline = 1, +}; + +PipelineType GetPipelineType(ShaderType shaderType); + +// For use with KHR_debug. +const char *GetDebugMessageSourceString(GLenum source); +const char *GetDebugMessageTypeString(GLenum type); +const char *GetDebugMessageSeverityString(GLenum severity); + +// For use with EXT_texture_format_sRGB_override and EXT_texture_sRGB_decode +// A texture may be forced to decode to a nonlinear colorspace, to a linear colorspace, or to the +// default colorspace of its current format. +// +// Default corresponds to "the texture should use the imageview that corresponds to its format" +// Linear corresponds to "the texture has sRGB decoding disabled by extension, and should use a +// linear imageview even if it is in a nonlinear format" NonLinear corresponds to "the texture has +// sRGB override enabled by extension, and should use a nonlinear imageview even if it is in a +// linear format" +enum class SrgbOverride +{ + Default = 0, + SRGB, + Linear +}; + +// For use with EXT_sRGB_write_control +// A render target may be forced to convert to a linear colorspace, or may be allowed to do whatever +// colorspace conversion is appropriate for its format. There is no option to force linear->sRGB, it +// can only convert from sRGB->linear +enum class SrgbWriteControlMode +{ + Default = 0, + Linear = 1 +}; + +// For use with EXT_YUV_target +// A sampler of external YUV textures may either implicitly perform RGB conversion (regular +// samplerExternalOES) or skip the conversion and sample raw YUV values (__samplerExternal2DY2Y). +enum class YuvSamplingMode +{ + Default = 0, + Y2Y = 1 +}; + +ShaderType GetShaderTypeFromBitfield(size_t singleShaderType); +GLbitfield GetBitfieldFromShaderType(ShaderType shaderType); +bool ShaderTypeSupportsTransformFeedback(ShaderType shaderType); +// Given a set of shader stages, returns the last vertex processing stage. This is the stage that +// interfaces the fragment shader. +ShaderType GetLastPreFragmentStage(ShaderBitSet shaderTypes); + +} // namespace gl + +namespace egl +{ +static const EGLenum FirstCubeMapTextureTarget = EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR; +static const EGLenum LastCubeMapTextureTarget = EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR; +bool IsCubeMapTextureTarget(EGLenum target); +size_t CubeMapTextureTargetToLayerIndex(EGLenum target); +EGLenum LayerIndexToCubeMapTextureTarget(size_t index); +bool IsTextureTarget(EGLenum target); +bool IsRenderbufferTarget(EGLenum target); +bool IsExternalImageTarget(EGLenum target); + +const char *GetGenericErrorMessage(EGLint error); +} // namespace egl + +namespace egl_gl +{ +GLuint EGLClientBufferToGLObjectHandle(EGLClientBuffer buffer); +} + +namespace gl_egl +{ +EGLenum GLComponentTypeToEGLColorComponentType(GLenum glComponentType); +EGLClientBuffer GLObjectHandleToEGLClientBuffer(GLuint handle); +} // namespace gl_egl + +namespace angle +{ +bool IsDrawEntryPoint(EntryPoint entryPoint); +bool IsDispatchEntryPoint(EntryPoint entryPoint); +bool IsClearEntryPoint(EntryPoint entryPoint); +bool IsQueryEntryPoint(EntryPoint entryPoint); +} // namespace angle + +#if !defined(ANGLE_ENABLE_WINDOWS_UWP) +void writeFile(const char *path, const void *data, size_t size); +#endif + +#if defined(ANGLE_PLATFORM_WINDOWS) +void ScheduleYield(); +#endif + +// Get the underlying type. Useful for indexing into arrays with enum values by avoiding the clutter +// of the extraneous static_cast<>() calls. +// https://stackoverflow.com/a/8357462 +template <typename E> +constexpr typename std::underlying_type<E>::type ToUnderlying(E e) noexcept +{ + return static_cast<typename std::underlying_type<E>::type>(e); +} + +#endif // COMMON_UTILITIES_H_ |