590 lines
20 KiB
C++
590 lines
20 KiB
C++
//
|
|
// Copyright (C) 2002-2005 3Dlabs Inc. Ltd.
|
|
// Copyright (C) 2012-2013 LunarG, Inc.
|
|
// Copyright (C) 2017 ARM Limited.
|
|
// Modifications Copyright (C) 2020 Advanced Micro Devices, Inc. All rights reserved.
|
|
//
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions
|
|
// are met:
|
|
//
|
|
// Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
//
|
|
// Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following
|
|
// disclaimer in the documentation and/or other materials provided
|
|
// with the distribution.
|
|
//
|
|
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
|
|
// contributors may be used to endorse or promote products derived
|
|
// from this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
//
|
|
|
|
#ifndef _BASICTYPES_INCLUDED_
|
|
#define _BASICTYPES_INCLUDED_
|
|
|
|
namespace glslang {
|
|
|
|
//
|
|
// Basic type. Arrays, vectors, sampler details, etc., are orthogonal to this.
|
|
//
|
|
enum TBasicType {
|
|
EbtVoid,
|
|
EbtFloat,
|
|
EbtDouble,
|
|
EbtFloat16,
|
|
EbtInt8,
|
|
EbtUint8,
|
|
EbtInt16,
|
|
EbtUint16,
|
|
EbtInt,
|
|
EbtUint,
|
|
EbtInt64,
|
|
EbtUint64,
|
|
EbtBool,
|
|
EbtAtomicUint,
|
|
EbtSampler,
|
|
EbtStruct,
|
|
EbtBlock,
|
|
EbtAccStruct,
|
|
EbtReference,
|
|
EbtRayQuery,
|
|
#ifndef GLSLANG_WEB
|
|
// SPIR-V type defined by spirv_type
|
|
EbtSpirvType,
|
|
#endif
|
|
|
|
// HLSL types that live only temporarily.
|
|
EbtString,
|
|
|
|
EbtNumTypes
|
|
};
|
|
|
|
//
|
|
// Storage qualifiers. Should align with different kinds of storage or
|
|
// resource or GLSL storage qualifier. Expansion is deprecated.
|
|
//
|
|
// N.B.: You probably DON'T want to add anything here, but rather just add it
|
|
// to the built-in variables. See the comment above TBuiltInVariable.
|
|
//
|
|
// A new built-in variable will normally be an existing qualifier, like 'in', 'out', etc.
|
|
// DO NOT follow the design pattern of, say EvqInstanceId, etc.
|
|
//
|
|
enum TStorageQualifier {
|
|
EvqTemporary, // For temporaries (within a function), read/write
|
|
EvqGlobal, // For globals read/write
|
|
EvqConst, // User-defined constant values, will be semantically constant and constant folded
|
|
EvqVaryingIn, // pipeline input, read only, also supercategory for all built-ins not included in this enum (see TBuiltInVariable)
|
|
EvqVaryingOut, // pipeline output, read/write, also supercategory for all built-ins not included in this enum (see TBuiltInVariable)
|
|
EvqUniform, // read only, shared with app
|
|
EvqBuffer, // read/write, shared with app
|
|
EvqShared, // compute shader's read/write 'shared' qualifier
|
|
#ifndef GLSLANG_WEB
|
|
EvqSpirvStorageClass, // spirv_storage_class
|
|
#endif
|
|
|
|
EvqPayload,
|
|
EvqPayloadIn,
|
|
EvqHitAttr,
|
|
EvqCallableData,
|
|
EvqCallableDataIn,
|
|
|
|
// parameters
|
|
EvqIn, // also, for 'in' in the grammar before we know if it's a pipeline input or an 'in' parameter
|
|
EvqOut, // also, for 'out' in the grammar before we know if it's a pipeline output or an 'out' parameter
|
|
EvqInOut,
|
|
EvqConstReadOnly, // input; also other read-only types having neither a constant value nor constant-value semantics
|
|
|
|
// built-ins read by vertex shader
|
|
EvqVertexId,
|
|
EvqInstanceId,
|
|
|
|
// built-ins written by vertex shader
|
|
EvqPosition,
|
|
EvqPointSize,
|
|
EvqClipVertex,
|
|
|
|
// built-ins read by fragment shader
|
|
EvqFace,
|
|
EvqFragCoord,
|
|
EvqPointCoord,
|
|
|
|
// built-ins written by fragment shader
|
|
EvqFragColor,
|
|
EvqFragDepth,
|
|
|
|
// end of list
|
|
EvqLast
|
|
};
|
|
|
|
//
|
|
// Subcategories of the TStorageQualifier, simply to give a direct mapping
|
|
// between built-in variable names and an numerical value (the enum).
|
|
//
|
|
// For backward compatibility, there is some redundancy between the
|
|
// TStorageQualifier and these. Existing members should both be maintained accurately.
|
|
// However, any new built-in variable (and any existing non-redundant one)
|
|
// must follow the pattern that the specific built-in is here, and only its
|
|
// general qualifier is in TStorageQualifier.
|
|
//
|
|
// Something like gl_Position, which is sometimes 'in' and sometimes 'out'
|
|
// shows up as two different built-in variables in a single stage, but
|
|
// only has a single enum in TBuiltInVariable, so both the
|
|
// TStorageQualifier and the TBuitinVariable are needed to distinguish
|
|
// between them.
|
|
//
|
|
enum TBuiltInVariable {
|
|
EbvNone,
|
|
EbvNumWorkGroups,
|
|
EbvWorkGroupSize,
|
|
EbvWorkGroupId,
|
|
EbvLocalInvocationId,
|
|
EbvGlobalInvocationId,
|
|
EbvLocalInvocationIndex,
|
|
EbvNumSubgroups,
|
|
EbvSubgroupID,
|
|
EbvSubGroupSize,
|
|
EbvSubGroupInvocation,
|
|
EbvSubGroupEqMask,
|
|
EbvSubGroupGeMask,
|
|
EbvSubGroupGtMask,
|
|
EbvSubGroupLeMask,
|
|
EbvSubGroupLtMask,
|
|
EbvSubgroupSize2,
|
|
EbvSubgroupInvocation2,
|
|
EbvSubgroupEqMask2,
|
|
EbvSubgroupGeMask2,
|
|
EbvSubgroupGtMask2,
|
|
EbvSubgroupLeMask2,
|
|
EbvSubgroupLtMask2,
|
|
EbvVertexId,
|
|
EbvInstanceId,
|
|
EbvVertexIndex,
|
|
EbvInstanceIndex,
|
|
EbvBaseVertex,
|
|
EbvBaseInstance,
|
|
EbvDrawId,
|
|
EbvPosition,
|
|
EbvPointSize,
|
|
EbvClipVertex,
|
|
EbvClipDistance,
|
|
EbvCullDistance,
|
|
EbvNormal,
|
|
EbvVertex,
|
|
EbvMultiTexCoord0,
|
|
EbvMultiTexCoord1,
|
|
EbvMultiTexCoord2,
|
|
EbvMultiTexCoord3,
|
|
EbvMultiTexCoord4,
|
|
EbvMultiTexCoord5,
|
|
EbvMultiTexCoord6,
|
|
EbvMultiTexCoord7,
|
|
EbvFrontColor,
|
|
EbvBackColor,
|
|
EbvFrontSecondaryColor,
|
|
EbvBackSecondaryColor,
|
|
EbvTexCoord,
|
|
EbvFogFragCoord,
|
|
EbvInvocationId,
|
|
EbvPrimitiveId,
|
|
EbvLayer,
|
|
EbvViewportIndex,
|
|
EbvPatchVertices,
|
|
EbvTessLevelOuter,
|
|
EbvTessLevelInner,
|
|
EbvBoundingBox,
|
|
EbvTessCoord,
|
|
EbvColor,
|
|
EbvSecondaryColor,
|
|
EbvFace,
|
|
EbvFragCoord,
|
|
EbvPointCoord,
|
|
EbvFragColor,
|
|
EbvFragData,
|
|
EbvFragDepth,
|
|
EbvFragStencilRef,
|
|
EbvSampleId,
|
|
EbvSamplePosition,
|
|
EbvSampleMask,
|
|
EbvHelperInvocation,
|
|
|
|
EbvBaryCoordNoPersp,
|
|
EbvBaryCoordNoPerspCentroid,
|
|
EbvBaryCoordNoPerspSample,
|
|
EbvBaryCoordSmooth,
|
|
EbvBaryCoordSmoothCentroid,
|
|
EbvBaryCoordSmoothSample,
|
|
EbvBaryCoordPullModel,
|
|
|
|
EbvViewIndex,
|
|
EbvDeviceIndex,
|
|
|
|
EbvShadingRateKHR,
|
|
EbvPrimitiveShadingRateKHR,
|
|
|
|
EbvFragSizeEXT,
|
|
EbvFragInvocationCountEXT,
|
|
|
|
EbvSecondaryFragDataEXT,
|
|
EbvSecondaryFragColorEXT,
|
|
|
|
EbvViewportMaskNV,
|
|
EbvSecondaryPositionNV,
|
|
EbvSecondaryViewportMaskNV,
|
|
EbvPositionPerViewNV,
|
|
EbvViewportMaskPerViewNV,
|
|
EbvFragFullyCoveredNV,
|
|
EbvFragmentSizeNV,
|
|
EbvInvocationsPerPixelNV,
|
|
// ray tracing
|
|
EbvLaunchId,
|
|
EbvLaunchSize,
|
|
EbvInstanceCustomIndex,
|
|
EbvGeometryIndex,
|
|
EbvWorldRayOrigin,
|
|
EbvWorldRayDirection,
|
|
EbvObjectRayOrigin,
|
|
EbvObjectRayDirection,
|
|
EbvRayTmin,
|
|
EbvRayTmax,
|
|
EbvHitT,
|
|
EbvHitKind,
|
|
EbvObjectToWorld,
|
|
EbvObjectToWorld3x4,
|
|
EbvWorldToObject,
|
|
EbvWorldToObject3x4,
|
|
EbvIncomingRayFlags,
|
|
EbvCurrentRayTimeNV,
|
|
// barycentrics
|
|
EbvBaryCoordNV,
|
|
EbvBaryCoordNoPerspNV,
|
|
// mesh shaders
|
|
EbvTaskCountNV,
|
|
EbvPrimitiveCountNV,
|
|
EbvPrimitiveIndicesNV,
|
|
EbvClipDistancePerViewNV,
|
|
EbvCullDistancePerViewNV,
|
|
EbvLayerPerViewNV,
|
|
EbvMeshViewCountNV,
|
|
EbvMeshViewIndicesNV,
|
|
|
|
// sm builtins
|
|
EbvWarpsPerSM,
|
|
EbvSMCount,
|
|
EbvWarpID,
|
|
EbvSMID,
|
|
|
|
// HLSL built-ins that live only temporarily, until they get remapped
|
|
// to one of the above.
|
|
EbvFragDepthGreater,
|
|
EbvFragDepthLesser,
|
|
EbvGsOutputStream,
|
|
EbvOutputPatch,
|
|
EbvInputPatch,
|
|
|
|
// structbuffer types
|
|
EbvAppendConsume, // no need to differentiate append and consume
|
|
EbvRWStructuredBuffer,
|
|
EbvStructuredBuffer,
|
|
EbvByteAddressBuffer,
|
|
EbvRWByteAddressBuffer,
|
|
|
|
EbvLast
|
|
};
|
|
|
|
// In this enum, order matters; users can assume higher precision is a bigger value
|
|
// and EpqNone is 0.
|
|
enum TPrecisionQualifier {
|
|
EpqNone = 0,
|
|
EpqLow,
|
|
EpqMedium,
|
|
EpqHigh
|
|
};
|
|
|
|
#ifdef GLSLANG_WEB
|
|
__inline const char* GetStorageQualifierString(TStorageQualifier q) { return ""; }
|
|
__inline const char* GetPrecisionQualifierString(TPrecisionQualifier p) { return ""; }
|
|
#else
|
|
// These will show up in error messages
|
|
__inline const char* GetStorageQualifierString(TStorageQualifier q)
|
|
{
|
|
switch (q) {
|
|
case EvqTemporary: return "temp"; break;
|
|
case EvqGlobal: return "global"; break;
|
|
case EvqConst: return "const"; break;
|
|
case EvqConstReadOnly: return "const (read only)"; break;
|
|
#ifndef GLSLANG_WEB
|
|
case EvqSpirvStorageClass: return "spirv_storage_class"; break;
|
|
#endif
|
|
case EvqVaryingIn: return "in"; break;
|
|
case EvqVaryingOut: return "out"; break;
|
|
case EvqUniform: return "uniform"; break;
|
|
case EvqBuffer: return "buffer"; break;
|
|
case EvqShared: return "shared"; break;
|
|
case EvqIn: return "in"; break;
|
|
case EvqOut: return "out"; break;
|
|
case EvqInOut: return "inout"; break;
|
|
case EvqVertexId: return "gl_VertexId"; break;
|
|
case EvqInstanceId: return "gl_InstanceId"; break;
|
|
case EvqPosition: return "gl_Position"; break;
|
|
case EvqPointSize: return "gl_PointSize"; break;
|
|
case EvqClipVertex: return "gl_ClipVertex"; break;
|
|
case EvqFace: return "gl_FrontFacing"; break;
|
|
case EvqFragCoord: return "gl_FragCoord"; break;
|
|
case EvqPointCoord: return "gl_PointCoord"; break;
|
|
case EvqFragColor: return "fragColor"; break;
|
|
case EvqFragDepth: return "gl_FragDepth"; break;
|
|
case EvqPayload: return "rayPayloadNV"; break;
|
|
case EvqPayloadIn: return "rayPayloadInNV"; break;
|
|
case EvqHitAttr: return "hitAttributeNV"; break;
|
|
case EvqCallableData: return "callableDataNV"; break;
|
|
case EvqCallableDataIn: return "callableDataInNV"; break;
|
|
default: return "unknown qualifier";
|
|
}
|
|
}
|
|
|
|
__inline const char* GetBuiltInVariableString(TBuiltInVariable v)
|
|
{
|
|
switch (v) {
|
|
case EbvNone: return "";
|
|
case EbvNumWorkGroups: return "NumWorkGroups";
|
|
case EbvWorkGroupSize: return "WorkGroupSize";
|
|
case EbvWorkGroupId: return "WorkGroupID";
|
|
case EbvLocalInvocationId: return "LocalInvocationID";
|
|
case EbvGlobalInvocationId: return "GlobalInvocationID";
|
|
case EbvLocalInvocationIndex: return "LocalInvocationIndex";
|
|
case EbvNumSubgroups: return "NumSubgroups";
|
|
case EbvSubgroupID: return "SubgroupID";
|
|
case EbvSubGroupSize: return "SubGroupSize";
|
|
case EbvSubGroupInvocation: return "SubGroupInvocation";
|
|
case EbvSubGroupEqMask: return "SubGroupEqMask";
|
|
case EbvSubGroupGeMask: return "SubGroupGeMask";
|
|
case EbvSubGroupGtMask: return "SubGroupGtMask";
|
|
case EbvSubGroupLeMask: return "SubGroupLeMask";
|
|
case EbvSubGroupLtMask: return "SubGroupLtMask";
|
|
case EbvSubgroupSize2: return "SubgroupSize";
|
|
case EbvSubgroupInvocation2: return "SubgroupInvocationID";
|
|
case EbvSubgroupEqMask2: return "SubgroupEqMask";
|
|
case EbvSubgroupGeMask2: return "SubgroupGeMask";
|
|
case EbvSubgroupGtMask2: return "SubgroupGtMask";
|
|
case EbvSubgroupLeMask2: return "SubgroupLeMask";
|
|
case EbvSubgroupLtMask2: return "SubgroupLtMask";
|
|
case EbvVertexId: return "VertexId";
|
|
case EbvInstanceId: return "InstanceId";
|
|
case EbvVertexIndex: return "VertexIndex";
|
|
case EbvInstanceIndex: return "InstanceIndex";
|
|
case EbvBaseVertex: return "BaseVertex";
|
|
case EbvBaseInstance: return "BaseInstance";
|
|
case EbvDrawId: return "DrawId";
|
|
case EbvPosition: return "Position";
|
|
case EbvPointSize: return "PointSize";
|
|
case EbvClipVertex: return "ClipVertex";
|
|
case EbvClipDistance: return "ClipDistance";
|
|
case EbvCullDistance: return "CullDistance";
|
|
case EbvNormal: return "Normal";
|
|
case EbvVertex: return "Vertex";
|
|
case EbvMultiTexCoord0: return "MultiTexCoord0";
|
|
case EbvMultiTexCoord1: return "MultiTexCoord1";
|
|
case EbvMultiTexCoord2: return "MultiTexCoord2";
|
|
case EbvMultiTexCoord3: return "MultiTexCoord3";
|
|
case EbvMultiTexCoord4: return "MultiTexCoord4";
|
|
case EbvMultiTexCoord5: return "MultiTexCoord5";
|
|
case EbvMultiTexCoord6: return "MultiTexCoord6";
|
|
case EbvMultiTexCoord7: return "MultiTexCoord7";
|
|
case EbvFrontColor: return "FrontColor";
|
|
case EbvBackColor: return "BackColor";
|
|
case EbvFrontSecondaryColor: return "FrontSecondaryColor";
|
|
case EbvBackSecondaryColor: return "BackSecondaryColor";
|
|
case EbvTexCoord: return "TexCoord";
|
|
case EbvFogFragCoord: return "FogFragCoord";
|
|
case EbvInvocationId: return "InvocationID";
|
|
case EbvPrimitiveId: return "PrimitiveID";
|
|
case EbvLayer: return "Layer";
|
|
case EbvViewportIndex: return "ViewportIndex";
|
|
case EbvPatchVertices: return "PatchVertices";
|
|
case EbvTessLevelOuter: return "TessLevelOuter";
|
|
case EbvTessLevelInner: return "TessLevelInner";
|
|
case EbvBoundingBox: return "BoundingBox";
|
|
case EbvTessCoord: return "TessCoord";
|
|
case EbvColor: return "Color";
|
|
case EbvSecondaryColor: return "SecondaryColor";
|
|
case EbvFace: return "Face";
|
|
case EbvFragCoord: return "FragCoord";
|
|
case EbvPointCoord: return "PointCoord";
|
|
case EbvFragColor: return "FragColor";
|
|
case EbvFragData: return "FragData";
|
|
case EbvFragDepth: return "FragDepth";
|
|
case EbvFragStencilRef: return "FragStencilRef";
|
|
case EbvSampleId: return "SampleId";
|
|
case EbvSamplePosition: return "SamplePosition";
|
|
case EbvSampleMask: return "SampleMaskIn";
|
|
case EbvHelperInvocation: return "HelperInvocation";
|
|
|
|
case EbvBaryCoordNoPersp: return "BaryCoordNoPersp";
|
|
case EbvBaryCoordNoPerspCentroid: return "BaryCoordNoPerspCentroid";
|
|
case EbvBaryCoordNoPerspSample: return "BaryCoordNoPerspSample";
|
|
case EbvBaryCoordSmooth: return "BaryCoordSmooth";
|
|
case EbvBaryCoordSmoothCentroid: return "BaryCoordSmoothCentroid";
|
|
case EbvBaryCoordSmoothSample: return "BaryCoordSmoothSample";
|
|
case EbvBaryCoordPullModel: return "BaryCoordPullModel";
|
|
|
|
case EbvViewIndex: return "ViewIndex";
|
|
case EbvDeviceIndex: return "DeviceIndex";
|
|
|
|
case EbvFragSizeEXT: return "FragSizeEXT";
|
|
case EbvFragInvocationCountEXT: return "FragInvocationCountEXT";
|
|
|
|
case EbvSecondaryFragDataEXT: return "SecondaryFragDataEXT";
|
|
case EbvSecondaryFragColorEXT: return "SecondaryFragColorEXT";
|
|
|
|
case EbvViewportMaskNV: return "ViewportMaskNV";
|
|
case EbvSecondaryPositionNV: return "SecondaryPositionNV";
|
|
case EbvSecondaryViewportMaskNV: return "SecondaryViewportMaskNV";
|
|
case EbvPositionPerViewNV: return "PositionPerViewNV";
|
|
case EbvViewportMaskPerViewNV: return "ViewportMaskPerViewNV";
|
|
case EbvFragFullyCoveredNV: return "FragFullyCoveredNV";
|
|
case EbvFragmentSizeNV: return "FragmentSizeNV";
|
|
case EbvInvocationsPerPixelNV: return "InvocationsPerPixelNV";
|
|
case EbvLaunchId: return "LaunchIdNV";
|
|
case EbvLaunchSize: return "LaunchSizeNV";
|
|
case EbvInstanceCustomIndex: return "InstanceCustomIndexNV";
|
|
case EbvGeometryIndex: return "GeometryIndexEXT";
|
|
case EbvWorldRayOrigin: return "WorldRayOriginNV";
|
|
case EbvWorldRayDirection: return "WorldRayDirectionNV";
|
|
case EbvObjectRayOrigin: return "ObjectRayOriginNV";
|
|
case EbvObjectRayDirection: return "ObjectRayDirectionNV";
|
|
case EbvRayTmin: return "ObjectRayTminNV";
|
|
case EbvRayTmax: return "ObjectRayTmaxNV";
|
|
case EbvHitT: return "HitTNV";
|
|
case EbvHitKind: return "HitKindNV";
|
|
case EbvIncomingRayFlags: return "IncomingRayFlagsNV";
|
|
case EbvObjectToWorld: return "ObjectToWorldNV";
|
|
case EbvWorldToObject: return "WorldToObjectNV";
|
|
case EbvCurrentRayTimeNV: return "CurrentRayTimeNV";
|
|
|
|
case EbvBaryCoordNV: return "BaryCoordNV";
|
|
case EbvBaryCoordNoPerspNV: return "BaryCoordNoPerspNV";
|
|
|
|
case EbvTaskCountNV: return "TaskCountNV";
|
|
case EbvPrimitiveCountNV: return "PrimitiveCountNV";
|
|
case EbvPrimitiveIndicesNV: return "PrimitiveIndicesNV";
|
|
case EbvClipDistancePerViewNV: return "ClipDistancePerViewNV";
|
|
case EbvCullDistancePerViewNV: return "CullDistancePerViewNV";
|
|
case EbvLayerPerViewNV: return "LayerPerViewNV";
|
|
case EbvMeshViewCountNV: return "MeshViewCountNV";
|
|
case EbvMeshViewIndicesNV: return "MeshViewIndicesNV";
|
|
|
|
case EbvWarpsPerSM: return "WarpsPerSMNV";
|
|
case EbvSMCount: return "SMCountNV";
|
|
case EbvWarpID: return "WarpIDNV";
|
|
case EbvSMID: return "SMIDNV";
|
|
|
|
case EbvShadingRateKHR: return "ShadingRateKHR";
|
|
case EbvPrimitiveShadingRateKHR: return "PrimitiveShadingRateKHR";
|
|
|
|
default: return "unknown built-in variable";
|
|
}
|
|
}
|
|
|
|
__inline const char* GetPrecisionQualifierString(TPrecisionQualifier p)
|
|
{
|
|
switch (p) {
|
|
case EpqNone: return ""; break;
|
|
case EpqLow: return "lowp"; break;
|
|
case EpqMedium: return "mediump"; break;
|
|
case EpqHigh: return "highp"; break;
|
|
default: return "unknown precision qualifier";
|
|
}
|
|
}
|
|
#endif
|
|
|
|
__inline bool isTypeSignedInt(TBasicType type)
|
|
{
|
|
switch (type) {
|
|
case EbtInt8:
|
|
case EbtInt16:
|
|
case EbtInt:
|
|
case EbtInt64:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
__inline bool isTypeUnsignedInt(TBasicType type)
|
|
{
|
|
switch (type) {
|
|
case EbtUint8:
|
|
case EbtUint16:
|
|
case EbtUint:
|
|
case EbtUint64:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
__inline bool isTypeInt(TBasicType type)
|
|
{
|
|
return isTypeSignedInt(type) || isTypeUnsignedInt(type);
|
|
}
|
|
|
|
__inline bool isTypeFloat(TBasicType type)
|
|
{
|
|
switch (type) {
|
|
case EbtFloat:
|
|
case EbtDouble:
|
|
case EbtFloat16:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
__inline int getTypeRank(TBasicType type)
|
|
{
|
|
int res = -1;
|
|
switch(type) {
|
|
case EbtInt8:
|
|
case EbtUint8:
|
|
res = 0;
|
|
break;
|
|
case EbtInt16:
|
|
case EbtUint16:
|
|
res = 1;
|
|
break;
|
|
case EbtInt:
|
|
case EbtUint:
|
|
res = 2;
|
|
break;
|
|
case EbtInt64:
|
|
case EbtUint64:
|
|
res = 3;
|
|
break;
|
|
default:
|
|
assert(false);
|
|
break;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
} // end namespace glslang
|
|
|
|
#endif // _BASICTYPES_INCLUDED_
|