Source code
Revision control
Copy as Markdown
Other Tools
//
// 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.
//
//
// Implement the top-level of interface to the compiler,
// as defined in ShaderLang.h
//
#include "GLSLANG/ShaderLang.h"
#include "compiler/translator/Compiler.h"
#include "compiler/translator/InitializeDll.h"
#include "compiler/translator/glslang_wrapper.h"
#include "compiler/translator/length_limits.h"
#ifdef ANGLE_ENABLE_HLSL
# include "compiler/translator/TranslatorHLSL.h"
#endif // ANGLE_ENABLE_HLSL
#include "angle_gl.h"
#include "compiler/translator/VariablePacker.h"
namespace sh
{
namespace
{
bool isInitialized = false;
// glslang can only be initialized/finalized once per process. Otherwise, the following EGL commands
// will call GlslangFinalize() without ever being able to GlslangInitialize() again, leading to
// crashes since GlslangFinalize() cleans up glslang for the entire process.
// dpy1 = eglGetPlatformDisplay() |
// eglInitialize(dpy1) | GlslangInitialize()
// dpy2 = eglGetPlatformDisplay() |
// eglInitialize(dpy2) | GlslangInitialize()
// eglTerminate(dpy2) | GlslangFinalize()
// eglInitialize(dpy1) | Display::isInitialized() == true, no GlslangInitialize()
int initializeGlslangRefCount = 0;
//
// This is the platform independent interface between an OGL driver
// and the shading language compiler.
//
template <typename VarT>
const std::vector<VarT> *GetVariableList(const TCompiler *compiler);
template <>
const std::vector<InterfaceBlock> *GetVariableList(const TCompiler *compiler)
{
return &compiler->getInterfaceBlocks();
}
TCompiler *GetCompilerFromHandle(ShHandle handle)
{
if (!handle)
{
return nullptr;
}
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
return base->getAsCompiler();
}
template <typename VarT>
const std::vector<VarT> *GetShaderVariables(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
if (!compiler)
{
return nullptr;
}
return GetVariableList<VarT>(compiler);
}
#ifdef ANGLE_ENABLE_HLSL
TranslatorHLSL *GetTranslatorHLSLFromHandle(ShHandle handle)
{
if (!handle)
return nullptr;
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
return base->getAsTranslatorHLSL();
}
#endif // ANGLE_ENABLE_HLSL
GLenum GetGeometryShaderPrimitiveTypeEnum(sh::TLayoutPrimitiveType primitiveType)
{
switch (primitiveType)
{
case EptPoints:
return GL_POINTS;
case EptLines:
return GL_LINES;
case EptLinesAdjacency:
return GL_LINES_ADJACENCY_EXT;
case EptTriangles:
return GL_TRIANGLES;
case EptTrianglesAdjacency:
return GL_TRIANGLES_ADJACENCY_EXT;
case EptLineStrip:
return GL_LINE_STRIP;
case EptTriangleStrip:
return GL_TRIANGLE_STRIP;
case EptUndefined:
default:
UNREACHABLE();
return GL_INVALID_VALUE;
}
}
GLenum GetTessellationShaderTypeEnum(sh::TLayoutTessEvaluationType type)
{
switch (type)
{
case EtetTriangles:
return GL_TRIANGLES;
case EtetQuads:
return GL_QUADS;
case EtetIsolines:
return GL_ISOLINES;
case EtetEqualSpacing:
return GL_EQUAL;
case EtetFractionalEvenSpacing:
return GL_FRACTIONAL_EVEN;
case EtetFractionalOddSpacing:
return GL_FRACTIONAL_ODD;
case EtetCw:
return GL_CW;
case EtetCcw:
return GL_CCW;
case EtetPointMode:
return GL_TESS_GEN_POINT_MODE;
case EtetUndefined:
default:
UNREACHABLE();
return GL_INVALID_VALUE;
}
}
} // anonymous namespace
//
// Driver must call this first, once, before doing any other compiler operations.
// Subsequent calls to this function are no-op.
//
bool Initialize()
{
if (!isInitialized)
{
isInitialized = InitProcess();
}
return isInitialized;
}
//
// Cleanup symbol tables
//
bool Finalize()
{
if (isInitialized)
{
DetachProcess();
isInitialized = false;
}
return true;
}
//
// Initialize built-in resources with minimum expected values.
//
void InitBuiltInResources(ShBuiltInResources *resources)
{
// Make comparable.
memset(resources, 0, sizeof(*resources));
// Constants.
resources->MaxVertexAttribs = 8;
resources->MaxVertexUniformVectors = 128;
resources->MaxVaryingVectors = 8;
resources->MaxVertexTextureImageUnits = 0;
resources->MaxCombinedTextureImageUnits = 8;
resources->MaxTextureImageUnits = 8;
resources->MaxFragmentUniformVectors = 16;
resources->MaxDrawBuffers = 1;
// Extensions.
resources->OES_standard_derivatives = 0;
resources->OES_EGL_image_external = 0;
resources->OES_EGL_image_external_essl3 = 0;
resources->NV_EGL_stream_consumer_external = 0;
resources->ARB_texture_rectangle = 0;
resources->EXT_blend_func_extended = 0;
resources->EXT_draw_buffers = 0;
resources->EXT_frag_depth = 0;
resources->EXT_shader_texture_lod = 0;
resources->EXT_shader_framebuffer_fetch = 0;
resources->EXT_shader_framebuffer_fetch_non_coherent = 0;
resources->NV_shader_framebuffer_fetch = 0;
resources->ARM_shader_framebuffer_fetch = 0;
resources->OVR_multiview = 0;
resources->OVR_multiview2 = 0;
resources->EXT_YUV_target = 0;
resources->EXT_geometry_shader = 0;
resources->OES_geometry_shader = 0;
resources->EXT_gpu_shader5 = 0;
resources->OES_shader_io_blocks = 0;
resources->EXT_shader_io_blocks = 0;
resources->EXT_shader_non_constant_global_initializers = 0;
resources->NV_shader_noperspective_interpolation = 0;
resources->OES_texture_storage_multisample_2d_array = 0;
resources->OES_texture_3D = 0;
resources->ANGLE_shader_pixel_local_storage = 0;
resources->ANGLE_texture_multisample = 0;
resources->ANGLE_multi_draw = 0;
resources->ANGLE_base_vertex_base_instance = 0;
resources->ANGLE_base_vertex_base_instance_shader_builtin = 0;
resources->WEBGL_video_texture = 0;
resources->APPLE_clip_distance = 0;
resources->OES_texture_cube_map_array = 0;
resources->EXT_texture_cube_map_array = 0;
resources->EXT_shadow_samplers = 0;
resources->OES_shader_multisample_interpolation = 0;
resources->NV_draw_buffers = 0;
resources->OES_shader_image_atomic = 0;
resources->EXT_tessellation_shader = 0;
resources->OES_texture_buffer = 0;
resources->EXT_texture_buffer = 0;
resources->OES_sample_variables = 0;
resources->EXT_clip_cull_distance = 0;
resources->KHR_blend_equation_advanced = 0;
resources->MaxClipDistances = 8;
resources->MaxCullDistances = 8;
resources->MaxCombinedClipAndCullDistances = 8;
// Disable highp precision in fragment shader by default.
resources->FragmentPrecisionHigh = 0;
// GLSL ES 3.0 constants.
resources->MaxVertexOutputVectors = 16;
resources->MaxFragmentInputVectors = 15;
resources->MinProgramTexelOffset = -8;
resources->MaxProgramTexelOffset = 7;
// Extensions constants.
resources->MaxDualSourceDrawBuffers = 0;
resources->MaxViewsOVR = 4;
// Disable name hashing by default.
resources->HashFunction = nullptr;
resources->MaxExpressionComplexity = 256;
resources->MaxCallStackDepth = 256;
resources->MaxFunctionParameters = 1024;
// ES 3.1 Revision 4, 7.2 Built-in Constants
// ES 3.1, Revision 4, 8.13 Texture minification
// "The value of MIN_PROGRAM_TEXTURE_GATHER_OFFSET must be less than or equal to the value of
// MIN_PROGRAM_TEXEL_OFFSET. The value of MAX_PROGRAM_TEXTURE_GATHER_OFFSET must be greater than
// or equal to the value of MAX_PROGRAM_TEXEL_OFFSET"
resources->MinProgramTextureGatherOffset = -8;
resources->MaxProgramTextureGatherOffset = 7;
resources->MaxImageUnits = 4;
resources->MaxVertexImageUniforms = 0;
resources->MaxFragmentImageUniforms = 0;
resources->MaxComputeImageUniforms = 4;
resources->MaxCombinedImageUniforms = 4;
resources->MaxUniformLocations = 1024;
resources->MaxCombinedShaderOutputResources = 4;
resources->MaxComputeWorkGroupCount[0] = 65535;
resources->MaxComputeWorkGroupCount[1] = 65535;
resources->MaxComputeWorkGroupCount[2] = 65535;
resources->MaxComputeWorkGroupSize[0] = 128;
resources->MaxComputeWorkGroupSize[1] = 128;
resources->MaxComputeWorkGroupSize[2] = 64;
resources->MaxComputeUniformComponents = 512;
resources->MaxComputeTextureImageUnits = 16;
resources->MaxComputeAtomicCounters = 8;
resources->MaxComputeAtomicCounterBuffers = 1;
resources->MaxVertexAtomicCounters = 0;
resources->MaxFragmentAtomicCounters = 0;
resources->MaxCombinedAtomicCounters = 8;
resources->MaxAtomicCounterBindings = 1;
resources->MaxVertexAtomicCounterBuffers = 0;
resources->MaxFragmentAtomicCounterBuffers = 0;
resources->MaxCombinedAtomicCounterBuffers = 1;
resources->MaxAtomicCounterBufferSize = 32;
resources->MaxUniformBufferBindings = 32;
resources->MaxShaderStorageBufferBindings = 4;
resources->MaxGeometryUniformComponents = 1024;
resources->MaxGeometryUniformBlocks = 12;
resources->MaxGeometryInputComponents = 64;
resources->MaxGeometryOutputComponents = 64;
resources->MaxGeometryOutputVertices = 256;
resources->MaxGeometryTotalOutputComponents = 1024;
resources->MaxGeometryTextureImageUnits = 16;
resources->MaxGeometryAtomicCounterBuffers = 0;
resources->MaxGeometryAtomicCounters = 0;
resources->MaxGeometryShaderStorageBlocks = 0;
resources->MaxGeometryShaderInvocations = 32;
resources->MaxGeometryImageUniforms = 0;
resources->MaxTessControlInputComponents = 64;
resources->MaxTessControlOutputComponents = 64;
resources->MaxTessControlTextureImageUnits = 16;
resources->MaxTessControlUniformComponents = 1024;
resources->MaxTessControlTotalOutputComponents = 2048;
resources->MaxTessControlImageUniforms = 0;
resources->MaxTessControlAtomicCounters = 0;
resources->MaxTessControlAtomicCounterBuffers = 0;
resources->MaxTessPatchComponents = 120;
resources->MaxPatchVertices = 32;
resources->MaxTessGenLevel = 64;
resources->MaxTessEvaluationInputComponents = 64;
resources->MaxTessEvaluationOutputComponents = 64;
resources->MaxTessEvaluationTextureImageUnits = 16;
resources->MaxTessEvaluationUniformComponents = 1024;
resources->MaxTessEvaluationImageUniforms = 0;
resources->MaxTessEvaluationAtomicCounters = 0;
resources->MaxTessEvaluationAtomicCounterBuffers = 0;
resources->SubPixelBits = 8;
resources->MaxSamples = 4;
// Arbitrarily enforce that all types declared with a size in bytes of over 2 GB will cause
// compilation failure.
//
// For local and global variables, the limit is much lower (1MB) as that much memory won't fit in
// the GPU registers anyway.
resources->MaxVariableSizeInBytes = static_cast<size_t>(2) * 1024 * 1024 * 1024;
resources->MaxPrivateVariableSizeInBytes = static_cast<size_t>(1) * 1024 * 1024;
}
//
// Driver calls these to create and destroy compiler objects.
//
ShHandle ConstructCompiler(sh::GLenum type,
ShShaderSpec spec,
ShShaderOutput output,
const ShBuiltInResources *resources)
{
TShHandleBase *base = static_cast<TShHandleBase *>(ConstructCompiler(type, spec, output));
if (base == nullptr)
{
return 0;
}
TCompiler *compiler = base->getAsCompiler();
if (compiler == nullptr)
{
return 0;
}
// Generate built-in symbol table.
if (!compiler->Init(*resources))
{
Destruct(base);
return 0;
}
return base;
}
void Destruct(ShHandle handle)
{
if (handle == 0)
return;
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
if (base->getAsCompiler())
DeleteCompiler(base->getAsCompiler());
}
ShBuiltInResources GetBuiltInResources(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
return compiler->getBuiltInResources();
}
const std::string &GetBuiltInResourcesString(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
return compiler->getBuiltInResourcesString();
}
//
// Do an actual compile on the given strings. The result is left
// in the given compile object.
//
// Return: The return value of ShCompile is really boolean, indicating
// success or failure.
//
bool Compile(const ShHandle handle,
const char *const shaderStrings[],
size_t numStrings,
const ShCompileOptions &compileOptions)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
return compiler->compile(shaderStrings, numStrings, compileOptions);
}
void ClearResults(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
compiler->clearResults();
}
int GetShaderVersion(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
return compiler->getShaderVersion();
}
ShShaderOutput GetShaderOutputType(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
return compiler->getOutputType();
}
//
// Return any compiler log of messages for the application.
//
const std::string &GetInfoLog(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
TInfoSink &infoSink = compiler->getInfoSink();
return infoSink.info.str();
}
//
// Return any object code.
//
const std::string &GetObjectCode(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
TInfoSink &infoSink = compiler->getInfoSink();
return infoSink.obj.str();
}
//
// Return any object binary code.
//
const BinaryBlob &GetObjectBinaryBlob(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
TInfoSink &infoSink = compiler->getInfoSink();
return infoSink.obj.getBinary();
}
const std::map<std::string, std::string> *GetNameHashingMap(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
return &(compiler->getNameMap());
}
const std::vector<ShaderVariable> *GetUniforms(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
if (!compiler)
{
return nullptr;
}
return &compiler->getUniforms();
}
const std::vector<ShaderVariable> *GetInputVaryings(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
if (compiler == nullptr)
{
return nullptr;
}
return &compiler->getInputVaryings();
}
const std::vector<ShaderVariable> *GetOutputVaryings(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
if (compiler == nullptr)
{
return nullptr;
}
return &compiler->getOutputVaryings();
}
const std::vector<ShaderVariable> *GetVaryings(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
if (compiler == nullptr)
{
return nullptr;
}
switch (compiler->getShaderType())
{
case GL_VERTEX_SHADER:
return &compiler->getOutputVaryings();
case GL_FRAGMENT_SHADER:
return &compiler->getInputVaryings();
case GL_COMPUTE_SHADER:
ASSERT(compiler->getOutputVaryings().empty() && compiler->getInputVaryings().empty());
return &compiler->getOutputVaryings();
// Since geometry shaders have both input and output varyings, we shouldn't call GetVaryings
// on a geometry shader.
default:
return nullptr;
}
}
const std::vector<ShaderVariable> *GetAttributes(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
if (!compiler)
{
return nullptr;
}
return &compiler->getAttributes();
}
const std::vector<ShaderVariable> *GetOutputVariables(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
if (!compiler)
{
return nullptr;
}
return &compiler->getOutputVariables();
}
const std::vector<InterfaceBlock> *GetInterfaceBlocks(const ShHandle handle)
{
return GetShaderVariables<InterfaceBlock>(handle);
}
const std::vector<InterfaceBlock> *GetUniformBlocks(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return &compiler->getUniformBlocks();
}
const std::vector<InterfaceBlock> *GetShaderStorageBlocks(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return &compiler->getShaderStorageBlocks();
}
WorkGroupSize GetComputeShaderLocalGroupSize(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getComputeShaderLocalSize();
}
int GetVertexShaderNumViews(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getNumViews();
}
bool EnablesPerSampleShading(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
if (compiler == nullptr)
{
return false;
}
return compiler->enablesPerSampleShading();
}
uint32_t GetShaderSpecConstUsageBits(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
if (compiler == nullptr)
{
return 0;
}
return compiler->getSpecConstUsageBits().bits();
}
bool CheckVariablesWithinPackingLimits(int maxVectors, const std::vector<ShaderVariable> &variables)
{
return CheckVariablesInPackingLimits(maxVectors, variables);
}
bool GetShaderStorageBlockRegister(const ShHandle handle,
const std::string &shaderStorageBlockName,
unsigned int *indexOut)
{
#ifdef ANGLE_ENABLE_HLSL
ASSERT(indexOut);
TranslatorHLSL *translator = GetTranslatorHLSLFromHandle(handle);
ASSERT(translator);
if (!translator->hasShaderStorageBlock(shaderStorageBlockName))
{
return false;
}
*indexOut = translator->getShaderStorageBlockRegister(shaderStorageBlockName);
return true;
#else
return false;
#endif // ANGLE_ENABLE_HLSL
}
bool GetUniformBlockRegister(const ShHandle handle,
const std::string &uniformBlockName,
unsigned int *indexOut)
{
#ifdef ANGLE_ENABLE_HLSL
ASSERT(indexOut);
TranslatorHLSL *translator = GetTranslatorHLSLFromHandle(handle);
ASSERT(translator);
if (!translator->hasUniformBlock(uniformBlockName))
{
return false;
}
*indexOut = translator->getUniformBlockRegister(uniformBlockName);
return true;
#else
return false;
#endif // ANGLE_ENABLE_HLSL
}
bool ShouldUniformBlockUseStructuredBuffer(const ShHandle handle,
const std::string &uniformBlockName)
{
#ifdef ANGLE_ENABLE_HLSL
TranslatorHLSL *translator = GetTranslatorHLSLFromHandle(handle);
ASSERT(translator);
return translator->shouldUniformBlockUseStructuredBuffer(uniformBlockName);
#else
return false;
#endif // ANGLE_ENABLE_HLSL
}
const std::map<std::string, unsigned int> *GetUniformRegisterMap(const ShHandle handle)
{
#ifdef ANGLE_ENABLE_HLSL
TranslatorHLSL *translator = GetTranslatorHLSLFromHandle(handle);
ASSERT(translator);
return translator->getUniformRegisterMap();
#else
return nullptr;
#endif // ANGLE_ENABLE_HLSL
}
const std::set<std::string> *GetSlowCompilingUniformBlockSet(const ShHandle handle)
{
#ifdef ANGLE_ENABLE_HLSL
TranslatorHLSL *translator = GetTranslatorHLSLFromHandle(handle);
ASSERT(translator);
return translator->getSlowCompilingUniformBlockSet();
#else
return nullptr;
#endif // ANGLE_ENABLE_HLSL
}
unsigned int GetReadonlyImage2DRegisterIndex(const ShHandle handle)
{
#ifdef ANGLE_ENABLE_HLSL
TranslatorHLSL *translator = GetTranslatorHLSLFromHandle(handle);
ASSERT(translator);
return translator->getReadonlyImage2DRegisterIndex();
#else
return 0;
#endif // ANGLE_ENABLE_HLSL
}
unsigned int GetImage2DRegisterIndex(const ShHandle handle)
{
#ifdef ANGLE_ENABLE_HLSL
TranslatorHLSL *translator = GetTranslatorHLSLFromHandle(handle);
ASSERT(translator);
return translator->getImage2DRegisterIndex();
#else
return 0;
#endif // ANGLE_ENABLE_HLSL
}
const std::set<std::string> *GetUsedImage2DFunctionNames(const ShHandle handle)
{
#ifdef ANGLE_ENABLE_HLSL
TranslatorHLSL *translator = GetTranslatorHLSLFromHandle(handle);
ASSERT(translator);
return translator->getUsedImage2DFunctionNames();
#else
return nullptr;
#endif // ANGLE_ENABLE_HLSL
}
bool HasDiscardInFragmentShader(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getShaderType() == GL_FRAGMENT_SHADER && compiler->hasDiscard();
}
bool HasValidGeometryShaderInputPrimitiveType(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getGeometryShaderInputPrimitiveType() != EptUndefined;
}
bool HasValidGeometryShaderOutputPrimitiveType(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getGeometryShaderOutputPrimitiveType() != EptUndefined;
}
bool HasValidGeometryShaderMaxVertices(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getGeometryShaderMaxVertices() >= 0;
}
bool HasValidTessGenMode(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getTessEvaluationShaderInputPrimitiveType() != EtetUndefined;
}
bool HasValidTessGenSpacing(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getTessEvaluationShaderInputVertexSpacingType() != EtetUndefined;
}
bool HasValidTessGenVertexOrder(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getTessEvaluationShaderInputOrderingType() != EtetUndefined;
}
bool HasValidTessGenPointMode(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getTessEvaluationShaderInputPointType() != EtetUndefined;
}
GLenum GetGeometryShaderInputPrimitiveType(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return GetGeometryShaderPrimitiveTypeEnum(compiler->getGeometryShaderInputPrimitiveType());
}
GLenum GetGeometryShaderOutputPrimitiveType(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return GetGeometryShaderPrimitiveTypeEnum(compiler->getGeometryShaderOutputPrimitiveType());
}
int GetGeometryShaderInvocations(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return compiler->getGeometryShaderInvocations();
}
int GetGeometryShaderMaxVertices(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
int maxVertices = compiler->getGeometryShaderMaxVertices();
ASSERT(maxVertices >= 0);
return maxVertices;
}
int GetTessControlShaderVertices(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
int vertices = compiler->getTessControlShaderOutputVertices();
return vertices;
}
GLenum GetTessGenMode(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return GetTessellationShaderTypeEnum(compiler->getTessEvaluationShaderInputPrimitiveType());
}
GLenum GetTessGenSpacing(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return GetTessellationShaderTypeEnum(compiler->getTessEvaluationShaderInputVertexSpacingType());
}
GLenum GetTessGenVertexOrder(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return GetTessellationShaderTypeEnum(compiler->getTessEvaluationShaderInputOrderingType());
}
GLenum GetTessGenPointMode(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
return GetTessellationShaderTypeEnum(compiler->getTessEvaluationShaderInputPointType());
}
unsigned int GetShaderSharedMemorySize(const ShHandle handle)
{
ASSERT(handle);
TShHandleBase *base = static_cast<TShHandleBase *>(handle);
TCompiler *compiler = base->getAsCompiler();
ASSERT(compiler);
unsigned int sharedMemorySize = compiler->getSharedMemorySize();
return sharedMemorySize;
}
uint32_t GetAdvancedBlendEquations(const ShHandle handle)
{
TCompiler *compiler = GetCompilerFromHandle(handle);
ASSERT(compiler);
return compiler->getAdvancedBlendEquations().bits();
}
void InitializeGlslang()
{
if (initializeGlslangRefCount == 0)
{
GlslangInitialize();
}
++initializeGlslangRefCount;
ASSERT(initializeGlslangRefCount < std::numeric_limits<int>::max());
}
void FinalizeGlslang()
{
--initializeGlslangRefCount;
ASSERT(initializeGlslangRefCount >= 0);
if (initializeGlslangRefCount == 0)
{
GlslangFinalize();
}
}
// Can't prefix with just _ because then we might introduce a double underscore, which is not safe
// in GLSL (ESSL 3.00.6 section 3.8: All identifiers containing a double underscore are reserved for
// use by the underlying implementation). u is short for user-defined.
const char kUserDefinedNamePrefix[] = "_u";
namespace vk
{
// Interface block name containing the aggregate default uniforms
const char kDefaultUniformsNameVS[] = "defaultUniformsVS";
const char kDefaultUniformsNameTCS[] = "defaultUniformsTCS";
const char kDefaultUniformsNameTES[] = "defaultUniformsTES";
const char kDefaultUniformsNameGS[] = "defaultUniformsGS";
const char kDefaultUniformsNameFS[] = "defaultUniformsFS";
const char kDefaultUniformsNameCS[] = "defaultUniformsCS";
// Interface block and variable names containing driver uniforms
const char kDriverUniformsBlockName[] = "ANGLEUniformBlock";
const char kDriverUniformsVarName[] = "ANGLEUniforms";
// Interface block array name used for atomic counter emulation
const char kAtomicCountersBlockName[] = "ANGLEAtomicCounters";
const char kXfbEmulationGetOffsetsFunctionName[] = "ANGLEGetXfbOffsets";
const char kXfbEmulationCaptureFunctionName[] = "ANGLECaptureXfb";
const char kXfbEmulationBufferBlockName[] = "ANGLEXfbBuffer";
const char kXfbEmulationBufferName[] = "ANGLEXfb";
const char kXfbEmulationBufferFieldName[] = "xfbOut";
const char kTransformPositionFunctionName[] = "ANGLETransformPosition";
const char kXfbExtensionPositionOutName[] = "ANGLEXfbPosition";
// EXT_shader_framebuffer_fetch / EXT_shader_framebuffer_fetch_non_coherent
const char kInputAttachmentName[] = "ANGLEInputAttachment";
} // namespace vk
const char *BlockLayoutTypeToString(BlockLayoutType type)
{
switch (type)
{
case BlockLayoutType::BLOCKLAYOUT_STD140:
return "std140";
case BlockLayoutType::BLOCKLAYOUT_STD430:
return "std430";
case BlockLayoutType::BLOCKLAYOUT_PACKED:
return "packed";
case BlockLayoutType::BLOCKLAYOUT_SHARED:
return "shared";
default:
return "invalid";
}
}
const char *BlockTypeToString(BlockType type)
{
switch (type)
{
case BlockType::BLOCK_BUFFER:
return "buffer";
case BlockType::BLOCK_UNIFORM:
return "uniform";
default:
return "invalid";
}
}
const char *InterpolationTypeToString(InterpolationType type)
{
switch (type)
{
case InterpolationType::INTERPOLATION_SMOOTH:
return "smooth";
case InterpolationType::INTERPOLATION_CENTROID:
return "centroid";
case InterpolationType::INTERPOLATION_SAMPLE:
return "sample";
case InterpolationType::INTERPOLATION_FLAT:
return "flat";
case InterpolationType::INTERPOLATION_NOPERSPECTIVE:
return "noperspective";
default:
return "invalid";
}
}
} // namespace sh
ShCompileOptions::ShCompileOptions()
{
memset(this, 0, sizeof(*this));
}
ShCompileOptions::ShCompileOptions(const ShCompileOptions &other)
{
memcpy(this, &other, sizeof(*this));
}
ShCompileOptions &ShCompileOptions::operator=(const ShCompileOptions &other)
{
memcpy(this, &other, sizeof(*this));
return *this;
}
ShBuiltInResources::ShBuiltInResources()
{
memset(this, 0, sizeof(*this));
}
ShBuiltInResources::ShBuiltInResources(const ShBuiltInResources &other)
{
memcpy(this, &other, sizeof(*this));
}
ShBuiltInResources &ShBuiltInResources::operator=(const ShBuiltInResources &other)
{
memcpy(this, &other, sizeof(*this));
return *this;
}