// // 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. // #ifndef GLSLANG_SHADERLANG_H_ #define GLSLANG_SHADERLANG_H_ #include #include "KHR/khrplatform.h" #include #include #include #include #include // // This is the platform independent interface between an OGL driver // and the shading language compiler. // // Note: make sure to increment ANGLE_SH_VERSION when changing ShaderVars.h #include "ShaderVars.h" // Version number for shader translation API. // It is incremented every time the API changes. #define ANGLE_SH_VERSION 308 enum ShShaderSpec { SH_GLES2_SPEC, SH_WEBGL_SPEC, SH_GLES3_SPEC, SH_WEBGL2_SPEC, SH_GLES3_1_SPEC, SH_WEBGL3_SPEC, SH_GLES3_2_SPEC, SH_GL_CORE_SPEC, SH_GL_COMPATIBILITY_SPEC, }; enum ShShaderOutput { // ESSL output only supported in some configurations. SH_ESSL_OUTPUT = 0x8B45, // GLSL output only supported in some configurations. SH_GLSL_COMPATIBILITY_OUTPUT = 0x8B46, // Note: GL introduced core profiles in 1.5. SH_GLSL_130_OUTPUT = 0x8B47, SH_GLSL_140_OUTPUT = 0x8B80, SH_GLSL_150_CORE_OUTPUT = 0x8B81, SH_GLSL_330_CORE_OUTPUT = 0x8B82, SH_GLSL_400_CORE_OUTPUT = 0x8B83, SH_GLSL_410_CORE_OUTPUT = 0x8B84, SH_GLSL_420_CORE_OUTPUT = 0x8B85, SH_GLSL_430_CORE_OUTPUT = 0x8B86, SH_GLSL_440_CORE_OUTPUT = 0x8B87, SH_GLSL_450_CORE_OUTPUT = 0x8B88, // Prefer using these to specify HLSL output type: SH_HLSL_3_0_OUTPUT = 0x8B48, // D3D 9 SH_HLSL_4_1_OUTPUT = 0x8B49, // D3D 11 SH_HLSL_4_0_FL9_3_OUTPUT = 0x8B4A, // D3D 11 feature level 9_3 // Output SPIR-V for the Vulkan backend. SH_SPIRV_VULKAN_OUTPUT = 0x8B4B, // Output SPIR-V to be cross compiled to Metal. SH_SPIRV_METAL_OUTPUT = 0x8B4C, // Output for MSL SH_MSL_METAL_OUTPUT = 0x8B4D, }; // For ANGLE_shader_pixel_local_storage. // Instructs the compiler which pixel local storage configuration to generate code for. enum class ShPixelLocalStorageType { NotSupported, ImageStoreR32PackedFormats, ImageStoreNativeFormats, FramebufferFetch }; // For ANGLE_shader_pixel_local_storage_coherent. // Instructs the compiler which fragment synchronization method to use, if any. enum class ShFragmentSynchronizationType { NotSupported, // Fragments cannot be ordered or synchronized. Automatic, // Fragments are automatically raster-ordered and synchronized. FragmentShaderInterlock_NV_GL, FragmentShaderOrdering_INTEL_GL, FragmentShaderInterlock_ARB_GL, // Also compiles to SPV_EXT_fragment_shader_interlock. RasterizerOrderViews_D3D, RasterOrderGroups_Metal, InvalidEnum, EnumCount = InvalidEnum, }; // Compile options. struct ShCompileOptionsMetal { // Direct-to-metal backend constants: // Binding index for driver uniforms: int driverUniformsBindingIndex; // Binding index for default uniforms: int defaultUniformsBindingIndex; // Binding index for UBO's argument buffer int UBOArgumentBufferBindingIndex; }; struct ShCompileOptionsPLS { ShPixelLocalStorageType type = ShPixelLocalStorageType::NotSupported; // For ANGLE_shader_pixel_local_storage_coherent. ShFragmentSynchronizationType fragmentSynchronizationType = ShFragmentSynchronizationType::NotSupported; }; struct ShCompileOptions { ShCompileOptions(); ShCompileOptions(const ShCompileOptions &other); ShCompileOptions &operator=(const ShCompileOptions &other); // Translates intermediate tree to glsl, hlsl, msl, or SPIR-V binary. Can be queried by // calling sh::GetObjectCode(). uint64_t objectCode : 1; // Extracts attributes, uniforms, and varyings. Can be queried by calling ShGetVariableInfo(). uint64_t variables : 1; // Tracks the source path for shaders. Can be queried with getSourcePath(). uint64_t sourcePath : 1; // Whether the internal representation of the AST should be output. uint64_t intermediateTree : 1; // If requested, validates the AST after every transformation. Useful for debugging. uint64_t validateAST : 1; // Validates loop and indexing in the shader to ensure that they do not exceed the minimum // functionality mandated in GLSL 1.0 spec, Appendix A, Section 4 and 5. There is no need to // specify this parameter when compiling for WebGL - it is implied. uint64_t validateLoopIndexing : 1; // Emits #line directives in HLSL. uint64_t lineDirectives : 1; // Due to spec difference between GLSL 4.1 or lower and ESSL3, some platforms (for example, Mac // OSX core profile) require a variable's "invariant"/"centroid" qualifiers to match between // vertex and fragment shader. A simple solution to allow such shaders to link is to omit the // two qualifiers. AMD driver in Linux requires invariant qualifier to match between vertex and // fragment shaders, while ESSL3 disallows invariant qualifier in fragment shader and GLSL >= // 4.2 doesn't require invariant qualifier to match between shaders. Remove invariant qualifier // from vertex shader to workaround AMD driver bug. // Note that the two flags take effect on ESSL3 input shaders translated to GLSL 4.1 or lower // and to GLSL 4.2 or newer on Linux AMD. // TODO(zmo): This is not a good long-term solution. Simply dropping these qualifiers may break // some developers' content. A more complex workaround of dynamically generating, compiling, and // re-linking shaders that use these qualifiers should be implemented. uint64_t removeInvariantAndCentroidForESSL3 : 1; // This flag works around bug in Intel Mac drivers related to abs(i) where i is an integer. uint64_t emulateAbsIntFunction : 1; // Enforce the GLSL 1.017 Appendix A section 7 packing restrictions. This flag only enforces // (and can only enforce) the packing restrictions for uniform variables in both vertex and // fragment shaders. ShCheckVariablesWithinPackingLimits() lets embedders enforce the packing // restrictions for varying variables during program link time. uint64_t enforcePackingRestrictions : 1; // This flag ensures all indirect (expression-based) array indexing is clamped to the bounds of // the array. This ensures, for example, that you cannot read off the end of a uniform, whether // an array vec234, or mat234 type. uint64_t clampIndirectArrayBounds : 1; // This flag limits the complexity of an expression. uint64_t limitExpressionComplexity : 1; // This flag limits the depth of the call stack. uint64_t limitCallStackDepth : 1; // This flag initializes gl_Position to vec4(0,0,0,0) at the beginning of the vertex shader's // main(), and has no effect in the fragment shader. It is intended as a workaround for drivers // which incorrectly fail to link programs if gl_Position is not written. uint64_t initGLPosition : 1; // This flag initializes gl_PointSize to 0.0f at the beginning of the vertex shader's // main(), and has no effect in the fragment shader. It is intended to assist in working around // bugs on some drivers when this is left written and then POINTS are drawn. uint64_t initGLPointSize : 1; // This flag replaces // "a && b" with "a ? b : false", // "a || b" with "a ? true : b". // This is to work around a MacOSX driver bug that |b| is executed independent of |a|'s value. uint64_t unfoldShortCircuit : 1; // This flag initializes output variables to 0 at the beginning of main(). It is to avoid // undefined behaviors. uint64_t initOutputVariables : 1; // This flag scalarizes vec/ivec/bvec/mat constructor args. It is intended as a workaround for // Linux/Mac driver bugs. uint64_t scalarizeVecAndMatConstructorArgs : 1; // This flag overwrites a struct name with a unique prefix. It is intended as a workaround for // drivers that do not handle struct scopes correctly, including all Mac drivers and Linux AMD. uint64_t regenerateStructNames : 1; // This flag works around bugs in Mac drivers related to do-while by transforming them into an // other construct. uint64_t rewriteDoWhileLoops : 1; // This flag works around a bug in the HLSL compiler optimizer that folds certain constant pow // expressions incorrectly. Only applies to the HLSL back-end. It works by expanding the integer // pow expressions into a series of multiplies. uint64_t expandSelectHLSLIntegerPowExpressions : 1; // Flatten "#pragma STDGL invariant(all)" into the declarations of varying variables and // built-in GLSL variables. This compiler option is enabled automatically when needed. uint64_t flattenPragmaSTDGLInvariantAll : 1; // Some drivers do not take into account the base level of the texture in the results of the // HLSL GetDimensions builtin. This flag instructs the compiler to manually add the base level // offsetting. uint64_t HLSLGetDimensionsIgnoresBaseLevel : 1; // This flag works around an issue in translating GLSL function texelFetchOffset on INTEL // drivers. It works by translating texelFetchOffset into texelFetch. uint64_t rewriteTexelFetchOffsetToTexelFetch : 1; // This flag works around condition bug of for and while loops in Intel Mac OSX drivers. // Condition calculation is not correct. Rewrite it from "CONDITION" to "CONDITION && true". uint64_t addAndTrueToLoopCondition : 1; // This flag works around a bug in evaluating unary minus operator on integer on some INTEL // drivers. It works by translating -(int) into ~(int) + 1. uint64_t rewriteIntegerUnaryMinusOperator : 1; // This flag works around a bug in evaluating isnan() on some INTEL D3D and Mac OSX drivers. It // works by using an expression to emulate this function. uint64_t emulateIsnanFloatFunction : 1; // This flag will use all uniforms of unused std140 and shared uniform blocks at the beginning // of the vertex/fragment shader's main(). It is intended as a workaround for Mac drivers with // shader version 4.10. In those drivers, they will treat unused std140 and shared uniform // blocks' members as inactive. However, WebGL2.0 based on OpenGL ES3.0.4 requires all members // of a named uniform block declared with a shared or std140 layout qualifier to be considered // active. The uniform block itself is also considered active. uint64_t useUnusedStandardSharedBlocks : 1; // This flag works around a bug in unary minus operator on float numbers on Intel Mac OSX 10.11 // drivers. It works by translating -float into 0.0 - float. uint64_t rewriteFloatUnaryMinusOperator : 1; // This flag works around a bug in evaluating atan(y, x) on some NVIDIA OpenGL drivers. It // works by using an expression to emulate this function. uint64_t emulateAtan2FloatFunction : 1; // Set to initialize uninitialized local and global temporary variables. Should only be used // with GLSL output. In HLSL output variables are initialized regardless of if this flag is set. uint64_t initializeUninitializedLocals : 1; // The flag modifies the shader in the following way: // // Every occurrence of gl_InstanceID is replaced by the global temporary variable InstanceID. // Every occurrence of gl_ViewID_OVR is replaced by the varying variable ViewID_OVR. // At the beginning of the body of main() in a vertex shader the following initializers are // added: // ViewID_OVR = uint(gl_InstanceID) % num_views; // InstanceID = gl_InstanceID / num_views; // ViewID_OVR is added as a varying variable to both the vertex and fragment shaders. uint64_t initializeBuiltinsForInstancedMultiview : 1; // With the flag enabled the GLSL/ESSL vertex shader is modified to include code for viewport // selection in the following way: // - Code to enable the extension ARB_shader_viewport_layer_array/NV_viewport_array2 is // included. // - Code to select the viewport index or layer is inserted at the beginning of main after // ViewID_OVR's initialization. // - A declaration of the uniform multiviewBaseViewLayerIndex. // Note: The initializeBuiltinsForInstancedMultiview flag also has to be enabled to have the // temporary variable ViewID_OVR declared and initialized. uint64_t selectViewInNvGLSLVertexShader : 1; // If the flag is enabled, gl_PointSize is clamped to the maximum point size specified in // ShBuiltInResources in vertex shaders. uint64_t clampPointSize : 1; // This flag indicates whether advanced blend equation should be emulated. Currently only // implemented for the Vulkan backend. uint64_t addAdvancedBlendEquationsEmulation : 1; // Don't use loops to initialize uninitialized variables. Only has an effect if some kind of // variable initialization is turned on. uint64_t dontUseLoopsToInitializeVariables : 1; // Don't use D3D constant register zero when allocating space for uniforms. This is targeted to // work around a bug in NVIDIA D3D driver version 388.59 where in very specific cases the driver // would not handle constant register zero correctly. Only has an effect on HLSL translation. uint64_t skipD3DConstantRegisterZero : 1; // Clamp gl_FragDepth to the range [0.0, 1.0] in case it is statically used. uint64_t clampFragDepth : 1; // Rewrite expressions like "v.x = z = expression;". Works around a bug in NVIDIA OpenGL drivers // prior to version 397.31. uint64_t rewriteRepeatedAssignToSwizzled : 1; // Rewrite gl_DrawID as a uniform int uint64_t emulateGLDrawID : 1; // This flag initializes shared variables to 0. It is to avoid ompute shaders being able to // read undefined values that could be coming from another webpage/application. uint64_t initSharedVariables : 1; // Forces the value returned from an atomic operations to be always be resolved. This is // targeted to workaround a bug in NVIDIA D3D driver where the return value from // RWByteAddressBuffer.InterlockedAdd does not get resolved when used in the .yzw components of // a RWByteAddressBuffer.Store operation. Only has an effect on HLSL translation. // http://anglebug.com/3246 uint64_t forceAtomicValueResolution : 1; // Rewrite gl_BaseVertex and gl_BaseInstance as uniform int uint64_t emulateGLBaseVertexBaseInstance : 1; // Emulate seamful cube map sampling for OpenGL ES2.0. Currently only applies to the Vulkan // backend, as is done after samplers are moved out of structs. Can likely be made to work on // the other backends as well. uint64_t emulateSeamfulCubeMapSampling : 1; // This flag controls how to translate WEBGL_video_texture sampling function. uint64_t takeVideoTextureAsExternalOES : 1; // This flag works around a inconsistent behavior in Mac AMD driver where gl_VertexID doesn't // include base vertex value. It replaces gl_VertexID with (gl_VertexID + angle_BaseVertex) when // angle_BaseVertex is available. uint64_t addBaseVertexToVertexID : 1; // This works around the dynamic lvalue indexing of swizzled vectors on various platforms. uint64_t removeDynamicIndexingOfSwizzledVector : 1; // This flag works around a slow fxc compile performance issue with dynamic uniform indexing. uint64_t allowTranslateUniformBlockToStructuredBuffer : 1; // This flag allows us to add a decoration for layout(yuv) in shaders. uint64_t addVulkanYUVLayoutQualifier : 1; // This flag allows disabling ARB_texture_rectangle on a per-compile basis. This is necessary // for WebGL contexts becuase ARB_texture_rectangle may be necessary for the WebGL // implementation internally but shouldn't be exposed to WebGL user code. uint64_t disableARBTextureRectangle : 1; // This flag works around a driver bug by rewriting uses of row-major matrices as column-major // in ESSL 3.00 and greater shaders. uint64_t rewriteRowMajorMatrices : 1; // Drop any explicit precision qualifiers from shader. uint64_t ignorePrecisionQualifiers : 1; // Ask compiler to generate code for depth correction to conform to the Vulkan clip space. If // VK_EXT_depth_clip_control is supported, this code is not generated, saving a uniform look up. uint64_t addVulkanDepthCorrection : 1; uint64_t forceShaderPrecisionHighpToMediump : 1; // Allow compiler to use specialization constant to do pre-rotation and y flip. uint64_t useSpecializationConstant : 1; // Ask compiler to generate Vulkan transform feedback emulation support code. uint64_t addVulkanXfbEmulationSupportCode : 1; // Ask compiler to generate Vulkan transform feedback support code when using the // VK_EXT_transform_feedback extension. uint64_t addVulkanXfbExtensionSupportCode : 1; // This flag initializes fragment shader's output variables to zero at the beginning of the // fragment shader's main(). It is intended as a workaround for drivers which get context lost // if gl_FragColor is not written. uint64_t initFragmentOutputVariables : 1; // Transitory flag to select between producing SPIR-V directly vs using glslang. Ignored in // non-assert-enabled builds to avoid increasing ANGLE's binary size. uint64_t generateSpirvThroughGlslang : 1; // Insert explicit casts for float/double/unsigned/signed int on macOS 10.15 with Intel driver uint64_t addExplicitBoolCasts : 1; // Add round() after applying dither. This works around a Qualcomm quirk where values can get // ceil()ed instead. uint64_t roundOutputAfterDithering : 1; // Even when the dividend and divisor have the same value some platforms do not return 1.0f. // Need to emit different division code for such platforms. uint64_t precisionSafeDivision : 1; // anglebug.com/7527: packUnorm4x8 fails on Pixel 4 if it is not passed a highp vec4. // TODO(anglebug.com/7527): This workaround is currently only applied for pixel local storage. // We may want to apply it generally. uint64_t passHighpToPackUnormSnormBuiltins : 1; ShCompileOptionsMetal metal; ShCompileOptionsPLS pls; }; // The 64 bits hash function. The first parameter is the input string; the // second parameter is the string length. using ShHashFunction64 = khronos_uint64_t (*)(const char *, size_t); // // Implementation dependent built-in resources (constants and extensions). // The names for these resources has been obtained by stripping gl_/GL_. // struct ShBuiltInResources { ShBuiltInResources(); ShBuiltInResources(const ShBuiltInResources &other); ShBuiltInResources &operator=(const ShBuiltInResources &other); // Constants. int MaxVertexAttribs; int MaxVertexUniformVectors; int MaxVaryingVectors; int MaxVertexTextureImageUnits; int MaxCombinedTextureImageUnits; int MaxTextureImageUnits; int MaxFragmentUniformVectors; int MaxDrawBuffers; // Extensions. // Set to 1 to enable the extension, else 0. int OES_standard_derivatives; int OES_EGL_image_external; int OES_EGL_image_external_essl3; int NV_EGL_stream_consumer_external; int ARB_texture_rectangle; int EXT_blend_func_extended; int EXT_draw_buffers; int EXT_frag_depth; int EXT_shader_texture_lod; int EXT_shader_framebuffer_fetch; int EXT_shader_framebuffer_fetch_non_coherent; int NV_shader_framebuffer_fetch; int NV_shader_noperspective_interpolation; int ARM_shader_framebuffer_fetch; int OVR_multiview; int OVR_multiview2; int EXT_multisampled_render_to_texture; int EXT_multisampled_render_to_texture2; int EXT_YUV_target; int EXT_geometry_shader; int OES_geometry_shader; int OES_shader_io_blocks; int EXT_shader_io_blocks; int EXT_gpu_shader5; int EXT_shader_non_constant_global_initializers; int OES_texture_storage_multisample_2d_array; int OES_texture_3D; int ANGLE_shader_pixel_local_storage; int ANGLE_texture_multisample; int ANGLE_multi_draw; // TODO(angleproject:3402) remove after chromium side removal to pass compilation int ANGLE_base_vertex_base_instance; int WEBGL_video_texture; int APPLE_clip_distance; int OES_texture_cube_map_array; int EXT_texture_cube_map_array; int EXT_shadow_samplers; int OES_shader_multisample_interpolation; int OES_shader_image_atomic; int EXT_tessellation_shader; int OES_texture_buffer; int EXT_texture_buffer; int OES_sample_variables; int EXT_clip_cull_distance; int EXT_primitive_bounding_box; int OES_primitive_bounding_box; int ANGLE_base_vertex_base_instance_shader_builtin; int ANDROID_extension_pack_es31a; int KHR_blend_equation_advanced; // Set to 1 to enable replacing GL_EXT_draw_buffers #extension directives // with GL_NV_draw_buffers in ESSL output. This flag can be used to emulate // EXT_draw_buffers by using it in combination with GLES3.0 glDrawBuffers // function. This applies to Tegra K1 devices. int NV_draw_buffers; // Set to 1 if highp precision is supported in the ESSL 1.00 version of the // fragment language. Does not affect versions of the language where highp // support is mandatory. // Default is 0. int FragmentPrecisionHigh; // GLSL ES 3.0 constants. int MaxVertexOutputVectors; int MaxFragmentInputVectors; int MinProgramTexelOffset; int MaxProgramTexelOffset; // Extension constants. // Value of GL_MAX_DUAL_SOURCE_DRAW_BUFFERS_EXT for OpenGL ES output context. // Value of GL_MAX_DUAL_SOURCE_DRAW_BUFFERS for OpenGL output context. // GLES SL version 100 gl_MaxDualSourceDrawBuffersEXT value for EXT_blend_func_extended. int MaxDualSourceDrawBuffers; // Value of GL_MAX_VIEWS_OVR. int MaxViewsOVR; // Name Hashing. // Set a 64 bit hash function to enable user-defined name hashing. // Default is NULL. ShHashFunction64 HashFunction; // The maximum complexity an expression can be when limitExpressionComplexity is turned on. int MaxExpressionComplexity; // The maximum depth a call stack can be. int MaxCallStackDepth; // The maximum number of parameters a function can have when limitExpressionComplexity is turned // on. int MaxFunctionParameters; // GLES 3.1 constants // texture gather offset constraints. int MinProgramTextureGatherOffset; int MaxProgramTextureGatherOffset; // maximum number of available image units int MaxImageUnits; // OES_sample_variables constant // maximum number of available samples int MaxSamples; // maximum number of image uniforms in a vertex shader int MaxVertexImageUniforms; // maximum number of image uniforms in a fragment shader int MaxFragmentImageUniforms; // maximum number of image uniforms in a compute shader int MaxComputeImageUniforms; // maximum total number of image uniforms in a program int MaxCombinedImageUniforms; // maximum number of uniform locations int MaxUniformLocations; // maximum number of ssbos and images in a shader int MaxCombinedShaderOutputResources; // maximum number of groups in each dimension std::array MaxComputeWorkGroupCount; // maximum number of threads per work group in each dimension std::array MaxComputeWorkGroupSize; // maximum number of total uniform components int MaxComputeUniformComponents; // maximum number of texture image units in a compute shader int MaxComputeTextureImageUnits; // maximum number of atomic counters in a compute shader int MaxComputeAtomicCounters; // maximum number of atomic counter buffers in a compute shader int MaxComputeAtomicCounterBuffers; // maximum number of atomic counters in a vertex shader int MaxVertexAtomicCounters; // maximum number of atomic counters in a fragment shader int MaxFragmentAtomicCounters; // maximum number of atomic counters in a program int MaxCombinedAtomicCounters; // maximum binding for an atomic counter int MaxAtomicCounterBindings; // maximum number of atomic counter buffers in a vertex shader int MaxVertexAtomicCounterBuffers; // maximum number of atomic counter buffers in a fragment shader int MaxFragmentAtomicCounterBuffers; // maximum number of atomic counter buffers in a program int MaxCombinedAtomicCounterBuffers; // maximum number of buffer object storage in machine units int MaxAtomicCounterBufferSize; // maximum number of uniform block bindings int MaxUniformBufferBindings; // maximum number of shader storage buffer bindings int MaxShaderStorageBufferBindings; // maximum point size (higher limit from ALIASED_POINT_SIZE_RANGE) float MaxPointSize; // EXT_geometry_shader constants int MaxGeometryUniformComponents; int MaxGeometryUniformBlocks; int MaxGeometryInputComponents; int MaxGeometryOutputComponents; int MaxGeometryOutputVertices; int MaxGeometryTotalOutputComponents; int MaxGeometryTextureImageUnits; int MaxGeometryAtomicCounterBuffers; int MaxGeometryAtomicCounters; int MaxGeometryShaderStorageBlocks; int MaxGeometryShaderInvocations; int MaxGeometryImageUniforms; // EXT_tessellation_shader constants int MaxTessControlInputComponents; int MaxTessControlOutputComponents; int MaxTessControlTextureImageUnits; int MaxTessControlUniformComponents; int MaxTessControlTotalOutputComponents; int MaxTessControlImageUniforms; int MaxTessControlAtomicCounters; int MaxTessControlAtomicCounterBuffers; int MaxTessPatchComponents; int MaxPatchVertices; int MaxTessGenLevel; int MaxTessEvaluationInputComponents; int MaxTessEvaluationOutputComponents; int MaxTessEvaluationTextureImageUnits; int MaxTessEvaluationUniformComponents; int MaxTessEvaluationImageUniforms; int MaxTessEvaluationAtomicCounters; int MaxTessEvaluationAtomicCounterBuffers; // Subpixel bits used in rasterization. int SubPixelBits; // APPLE_clip_distance/EXT_clip_cull_distance constant int MaxClipDistances; int MaxCullDistances; int MaxCombinedClipAndCullDistances; // ANGLE_shader_pixel_local_storage. int MaxPixelLocalStoragePlanes; int MaxColorAttachmentsWithActivePixelLocalStorage; int MaxCombinedDrawBuffersAndPixelLocalStoragePlanes; }; // // ShHandle held by but opaque to the driver. It is allocated, // managed, and de-allocated by the compiler. Its contents // are defined by and used by the compiler. // // If handle creation fails, 0 will be returned. // using ShHandle = void *; namespace sh { using BinaryBlob = std::vector; // // Driver must call this first, once, before doing any other compiler operations. // If the function succeeds, the return value is true, else false. // bool Initialize(); // // Driver should call this at shutdown. // If the function succeeds, the return value is true, else false. // bool Finalize(); // // Initialize built-in resources with minimum expected values. // Parameters: // resources: The object to initialize. Will be comparable with memcmp. // void InitBuiltInResources(ShBuiltInResources *resources); // // Returns a copy of the current ShBuiltInResources stored in the compiler. // Parameters: // handle: Specifies the handle of the compiler to be used. ShBuiltInResources GetBuiltInResources(const ShHandle handle); // // Returns the a concatenated list of the items in ShBuiltInResources as a null-terminated string. // This function must be updated whenever ShBuiltInResources is changed. // Parameters: // handle: Specifies the handle of the compiler to be used. const std::string &GetBuiltInResourcesString(const ShHandle handle); // // Driver calls these to create and destroy compiler objects. // // Returns the handle of constructed compiler, null if the requested compiler is not supported. // Parameters: // type: Specifies the type of shader - GL_FRAGMENT_SHADER or GL_VERTEX_SHADER. // spec: Specifies the language spec the compiler must conform to - SH_GLES2_SPEC or SH_WEBGL_SPEC. // output: Specifies the output code type - for example SH_ESSL_OUTPUT, SH_GLSL_OUTPUT, // SH_HLSL_3_0_OUTPUT or SH_HLSL_4_1_OUTPUT. Note: Each output type may only // be supported in some configurations. // resources: Specifies the built-in resources. ShHandle ConstructCompiler(sh::GLenum type, ShShaderSpec spec, ShShaderOutput output, const ShBuiltInResources *resources); void Destruct(ShHandle handle); // // Compiles the given shader source. // If the function succeeds, the return value is true, else false. // Parameters: // handle: Specifies the handle of compiler to be used. // shaderStrings: Specifies an array of pointers to null-terminated strings containing the shader // source code. // numStrings: Specifies the number of elements in shaderStrings array. // compileOptions: A mask of compile options defined above. bool Compile(const ShHandle handle, const char *const shaderStrings[], size_t numStrings, const ShCompileOptions &compileOptions); // Clears the results from the previous compilation. void ClearResults(const ShHandle handle); // Return the version of the shader language. int GetShaderVersion(const ShHandle handle); // Return the currently set language output type. ShShaderOutput GetShaderOutputType(const ShHandle handle); // Returns null-terminated information log for a compiled shader. // Parameters: // handle: Specifies the compiler const std::string &GetInfoLog(const ShHandle handle); // Returns null-terminated object code for a compiled shader. Only valid for output types that // generate human-readable code (GLSL, ESSL or HLSL). // Parameters: // handle: Specifies the compiler const std::string &GetObjectCode(const ShHandle handle); // Returns object binary blob for a compiled shader. Only valid for output types that // generate binary blob (SPIR-V). // Parameters: // handle: Specifies the compiler const BinaryBlob &GetObjectBinaryBlob(const ShHandle handle); // Returns a (original_name, hash) map containing all the user defined names in the shader, // including variable names, function names, struct names, and struct field names. // Parameters: // handle: Specifies the compiler const std::map *GetNameHashingMap(const ShHandle handle); // Shader variable inspection. // Returns a pointer to a list of variables of the designated type. // (See ShaderVars.h for type definitions, included above) // Returns NULL on failure. // Parameters: // handle: Specifies the compiler const std::vector *GetUniforms(const ShHandle handle); const std::vector *GetVaryings(const ShHandle handle); const std::vector *GetInputVaryings(const ShHandle handle); const std::vector *GetOutputVaryings(const ShHandle handle); const std::vector *GetAttributes(const ShHandle handle); const std::vector *GetOutputVariables(const ShHandle handle); const std::vector *GetInterfaceBlocks(const ShHandle handle); const std::vector *GetUniformBlocks(const ShHandle handle); const std::vector *GetShaderStorageBlocks(const ShHandle handle); sh::WorkGroupSize GetComputeShaderLocalGroupSize(const ShHandle handle); // Returns the number of views specified through the num_views layout qualifier. If num_views is // not set, the function returns -1. int GetVertexShaderNumViews(const ShHandle handle); // Returns true if the shader has specified the |sample| qualifier, implying that per-sample shading // should be enabled bool EnablesPerSampleShading(const ShHandle handle); // Returns specialization constant usage bits uint32_t GetShaderSpecConstUsageBits(const ShHandle handle); // Returns true if the passed in variables pack in maxVectors followingthe packing rules from the // GLSL 1.017 spec, Appendix A, section 7. // Returns false otherwise. Also look at the enforcePackingRestrictions flag above. // Parameters: // maxVectors: the available rows of registers. // variables: an array of variables. bool CheckVariablesWithinPackingLimits(int maxVectors, const std::vector &variables); // Gives the compiler-assigned register for a shader storage block. // The method writes the value to the output variable "indexOut". // Returns true if it found a valid shader storage block, false otherwise. // Parameters: // handle: Specifies the compiler // shaderStorageBlockName: Specifies the shader storage block // indexOut: output variable that stores the assigned register bool GetShaderStorageBlockRegister(const ShHandle handle, const std::string &shaderStorageBlockName, unsigned int *indexOut); // Gives the compiler-assigned register for a uniform block. // The method writes the value to the output variable "indexOut". // Returns true if it found a valid uniform block, false otherwise. // Parameters: // handle: Specifies the compiler // uniformBlockName: Specifies the uniform block // indexOut: output variable that stores the assigned register bool GetUniformBlockRegister(const ShHandle handle, const std::string &uniformBlockName, unsigned int *indexOut); bool ShouldUniformBlockUseStructuredBuffer(const ShHandle handle, const std::string &uniformBlockName); const std::set *GetSlowCompilingUniformBlockSet(const ShHandle handle); // Gives a map from uniform names to compiler-assigned registers in the default uniform block. // Note that the map contains also registers of samplers that have been extracted from structs. const std::map *GetUniformRegisterMap(const ShHandle handle); // Sampler, image and atomic counters share registers(t type and u type), // GetReadonlyImage2DRegisterIndex and GetImage2DRegisterIndex return the first index into // a range of reserved registers for image2D/iimage2D/uimage2D variables. // Parameters: handle: Specifies the compiler unsigned int GetReadonlyImage2DRegisterIndex(const ShHandle handle); unsigned int GetImage2DRegisterIndex(const ShHandle handle); // The method records these used function names related with image2D/iimage2D/uimage2D, these // functions will be dynamically generated. // Parameters: // handle: Specifies the compiler const std::set *GetUsedImage2DFunctionNames(const ShHandle handle); bool HasDiscardInFragmentShader(const ShHandle handle); bool HasValidGeometryShaderInputPrimitiveType(const ShHandle handle); bool HasValidGeometryShaderOutputPrimitiveType(const ShHandle handle); bool HasValidGeometryShaderMaxVertices(const ShHandle handle); bool HasValidTessGenMode(const ShHandle handle); bool HasValidTessGenSpacing(const ShHandle handle); bool HasValidTessGenVertexOrder(const ShHandle handle); bool HasValidTessGenPointMode(const ShHandle handle); GLenum GetGeometryShaderInputPrimitiveType(const ShHandle handle); GLenum GetGeometryShaderOutputPrimitiveType(const ShHandle handle); int GetGeometryShaderInvocations(const ShHandle handle); int GetGeometryShaderMaxVertices(const ShHandle handle); unsigned int GetShaderSharedMemorySize(const ShHandle handle); int GetTessControlShaderVertices(const ShHandle handle); GLenum GetTessGenMode(const ShHandle handle); GLenum GetTessGenSpacing(const ShHandle handle); GLenum GetTessGenVertexOrder(const ShHandle handle); GLenum GetTessGenPointMode(const ShHandle handle); // Returns the blend equation list supported in the fragment shader. This is a bitset of // gl::BlendEquationType, and can only include bits from KHR_blend_equation_advanced. uint32_t GetAdvancedBlendEquations(const ShHandle handle); // // Helper function to identify specs that are based on the WebGL spec. // inline bool IsWebGLBasedSpec(ShShaderSpec spec) { return (spec == SH_WEBGL_SPEC || spec == SH_WEBGL2_SPEC || spec == SH_WEBGL3_SPEC); } // // Helper function to identify DesktopGL specs // inline bool IsDesktopGLSpec(ShShaderSpec spec) { return spec == SH_GL_CORE_SPEC || spec == SH_GL_COMPATIBILITY_SPEC; } // 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. extern const char kUserDefinedNamePrefix[]; namespace vk { // Specialization constant ids enum class SpecializationConstantId : uint32_t { SurfaceRotation = 0, Dither = 1, InvalidEnum = 2, EnumCount = InvalidEnum, }; enum class SpecConstUsage : uint32_t { Rotation = 0, Dither = 1, InvalidEnum = 2, EnumCount = InvalidEnum, }; enum ColorAttachmentDitherControl { // See comments in ContextVk::updateDither and EmulateDithering.cpp kDitherControlNoDither = 0, kDitherControlDither4444 = 1, kDitherControlDither5551 = 2, kDitherControlDither565 = 3, }; // Interface block name containing the aggregate default uniforms extern const char kDefaultUniformsNameVS[]; extern const char kDefaultUniformsNameTCS[]; extern const char kDefaultUniformsNameTES[]; extern const char kDefaultUniformsNameGS[]; extern const char kDefaultUniformsNameFS[]; extern const char kDefaultUniformsNameCS[]; // Interface block and variable names containing driver uniforms extern const char kDriverUniformsBlockName[]; extern const char kDriverUniformsVarName[]; // Packing information for driver uniform's misc field: // - 1 bit for whether surface rotation results in swapped axes // - 5 bits for advanced blend equation // - 6 bits for sample count // - 8 bits for enabled clip planes // - 1 bit for whether depth should be transformed to Vulkan clip space // - 11 bits unused constexpr uint32_t kDriverUniformsMiscSwapXYMask = 0x1; constexpr uint32_t kDriverUniformsMiscAdvancedBlendEquationOffset = 1; constexpr uint32_t kDriverUniformsMiscAdvancedBlendEquationMask = 0x1F; constexpr uint32_t kDriverUniformsMiscSampleCountOffset = 6; constexpr uint32_t kDriverUniformsMiscSampleCountMask = 0x3F; constexpr uint32_t kDriverUniformsMiscEnabledClipPlanesOffset = 12; constexpr uint32_t kDriverUniformsMiscEnabledClipPlanesMask = 0xFF; constexpr uint32_t kDriverUniformsMiscTransformDepthOffset = 20; constexpr uint32_t kDriverUniformsMiscTransformDepthMask = 0x1; // Interface block array name used for atomic counter emulation extern const char kAtomicCountersBlockName[]; // Transform feedback emulation support extern const char kXfbEmulationGetOffsetsFunctionName[]; extern const char kXfbEmulationCaptureFunctionName[]; extern const char kXfbEmulationBufferBlockName[]; extern const char kXfbEmulationBufferName[]; extern const char kXfbEmulationBufferFieldName[]; // Transform feedback extension support extern const char kXfbExtensionPositionOutName[]; // Pre-rotation support extern const char kTransformPositionFunctionName[]; // EXT_shader_framebuffer_fetch and EXT_shader_framebuffer_fetch_non_coherent extern const char kInputAttachmentName[]; } // namespace vk namespace mtl { // Specialization constant to enable GL_SAMPLE_COVERAGE_VALUE emulation. extern const char kCoverageMaskEnabledConstName[]; // Specialization constant to emulate rasterizer discard. extern const char kRasterizerDiscardEnabledConstName[]; // Specialization constant to enable depth write in fragment shaders. extern const char kDepthWriteEnabledConstName[]; } // namespace mtl // For backends that use glslang (the Vulkan shader compiler), i.e. Vulkan and Metal, call these to // initialize and finalize glslang itself. This can be called independently from Initialize() and // Finalize(). void InitializeGlslang(); void FinalizeGlslang(); } // namespace sh #endif // GLSLANG_SHADERLANG_H_