├── .clang-format ├── .gitattributes ├── .github ├── dependabot.yml └── workflows │ ├── continuous_deployment.yml │ ├── continuous_integration.yml │ ├── deploy.js │ └── scorecard.yml ├── .gitignore ├── .gn ├── .mailmap ├── Android.mk ├── BUILD.gn ├── CHANGES.md ├── CMakeLists.txt ├── CODE_OF_CONDUCT.md ├── DEPS ├── External └── CMakeLists.txt ├── LICENSE.txt ├── README-spirv-remap.txt ├── README.md ├── SECURITY.md ├── SPIRV ├── CInterface │ └── spirv_c_interface.cpp ├── CMakeLists.txt ├── GLSL.ext.AMD.h ├── GLSL.ext.ARM.h ├── GLSL.ext.EXT.h ├── GLSL.ext.KHR.h ├── GLSL.ext.NV.h ├── GLSL.ext.QCOM.h ├── GLSL.std.450.h ├── GlslangToSpv.cpp ├── GlslangToSpv.h ├── InReadableOrder.cpp ├── Logger.cpp ├── Logger.h ├── NonSemanticDebugPrintf.h ├── NonSemanticShaderDebugInfo100.h ├── SPVRemapper.cpp ├── SPVRemapper.h ├── SpvBuilder.cpp ├── SpvBuilder.h ├── SpvPostProcess.cpp ├── SpvTools.cpp ├── SpvTools.h ├── bitutils.h ├── disassemble.cpp ├── disassemble.h ├── doc.cpp ├── doc.h ├── hex_float.h ├── spirv.hpp11 ├── spvIR.h └── spvUtil.h ├── StandAlone ├── CMakeLists.txt ├── DirStackFileIncluder.h ├── StandAlone.cpp ├── Worklist.h └── spirv-remap.cpp ├── Test ├── 100.conf ├── 100.frag ├── 100Limits.vert ├── 100samplerExternal.frag ├── 100scope.vert ├── 110scope.vert ├── 120.frag ├── 120.vert ├── 130.frag ├── 130.vert ├── 140.frag ├── 140.vert ├── 150.frag ├── 150.geom ├── 150.tesc ├── 150.tese ├── 150.vert ├── 300.frag ├── 300.vert ├── 300BuiltIns.frag ├── 300block.frag ├── 300layout.frag ├── 300layout.vert ├── 300link.frag ├── 300link2.frag ├── 300link3.frag ├── 300operations.frag ├── 300samplerExternal.frag ├── 300samplerExternalYUV.frag ├── 300scope.vert ├── 310.comp ├── 310.frag ├── 310.geom ├── 310.inheritMemory.frag ├── 310.tesc ├── 310.tese ├── 310.vert ├── 310AofA.vert ├── 310implicitSizeArrayError.vert ├── 310runtimeArray.vert ├── 320.comp ├── 320.frag ├── 320.geom ├── 320.tesc ├── 320.tese ├── 320.vert ├── 330.frag ├── 330comp.frag ├── 400.frag ├── 400.geom ├── 400.tesc ├── 400.tese ├── 400.vert ├── 410.geom ├── 410.tesc ├── 410.vert ├── 420.comp ├── 420.frag ├── 420.geom ├── 420.tesc ├── 420.tese ├── 420.vert ├── 420_size_gl_in.geom ├── 430.comp ├── 430.vert ├── 430AofA.frag ├── 430scope.vert ├── 435.vert ├── 440.frag ├── 440.vert ├── 450.comp ├── 450.frag ├── 450.geom ├── 450.tesc ├── 450.tese ├── 450.vert ├── 460.frag ├── 460.vert ├── BestMatchFunction.vert ├── EndStreamPrimitive.geom ├── GL_ARB_bindless_texture.frag ├── GL_ARB_draw_instanced.vert ├── GL_ARB_fragment_coord_conventions.vert ├── GL_ARB_gpu_shader5.u2i.vert ├── GL_ARB_texture_multisample.vert ├── GL_EXT_draw_instanced.vert ├── GL_EXT_shader_integer_mix.vert ├── GL_EXT_texture_array.frag ├── Operations.frag ├── UTF8BOM.vert ├── aggOps.frag ├── always-discard.frag ├── always-discard2.frag ├── array.frag ├── array100.frag ├── atomicAdd.comp ├── atomicCounterARBOps.vert ├── atomic_uint.frag ├── badChars.frag ├── badMacroArgs.frag ├── bar.h ├── baseLegalResults │ ├── hlsl.aliasOpaque.frag.out │ ├── hlsl.flattenOpaque.frag.out │ ├── hlsl.flattenOpaqueInit.vert.out │ ├── hlsl.flattenOpaqueInitMix.vert.out │ ├── hlsl.flattenSubset.frag.out │ ├── hlsl.flattenSubset2.frag.out │ ├── hlsl.intrinsics.evalfns.frag.out │ ├── hlsl.partialFlattenLocal.vert.out │ └── hlsl.partialFlattenMixed.vert.out ├── baseResults │ ├── 100.frag.out │ ├── 100Limits.vert.out │ ├── 100LimitsConf.vert.out │ ├── 100samplerExternal.frag.out │ ├── 100scope.vert.out │ ├── 110scope.vert.out │ ├── 120.frag.out │ ├── 120.vert.out │ ├── 130.frag.out │ ├── 130.vert.out │ ├── 140.frag.out │ ├── 140.vert.out │ ├── 150.frag.out │ ├── 150.geom.out │ ├── 150.tesc.out │ ├── 150.vert.out │ ├── 300.frag.out │ ├── 300.vert.out │ ├── 300BuiltIns.frag.out │ ├── 300block.frag.out │ ├── 300layout.frag.out │ ├── 300layout.vert.out │ ├── 300link.frag.out │ ├── 300link2.frag.out │ ├── 300link3.frag.out │ ├── 300operations.frag.out │ ├── 300samplerExternal.frag.out │ ├── 300samplerExternalYUV.frag.out │ ├── 300scope.vert.out │ ├── 310.comp.out │ ├── 310.frag.out │ ├── 310.geom.out │ ├── 310.inheritMemory.frag.out │ ├── 310.tesc.out │ ├── 310.tese.out │ ├── 310.vert.out │ ├── 310AofA.vert.out │ ├── 310implicitSizeArrayError.vert.out │ ├── 310runtimeArray.vert.out │ ├── 320.comp.out │ ├── 320.frag.out │ ├── 320.geom.out │ ├── 320.tesc.out │ ├── 320.tese.out │ ├── 320.vert.out │ ├── 330.frag.out │ ├── 330comp.frag.out │ ├── 400.frag.out │ ├── 400.geom.out │ ├── 400.tesc.out │ ├── 400.tese.out │ ├── 400.vert.out │ ├── 410.geom.out │ ├── 410.tesc.out │ ├── 410.vert.out │ ├── 420.comp.out │ ├── 420.frag.out │ ├── 420.geom.out │ ├── 420.tesc.out │ ├── 420.tese.out │ ├── 420.vert.out │ ├── 420_size_gl_in.geom.out │ ├── 430.comp.out │ ├── 430.vert.out │ ├── 430AofA.frag.out │ ├── 430scope.vert.out │ ├── 435.vert.out │ ├── 440.frag.out │ ├── 440.vert.out │ ├── 450.comp.out │ ├── 450.frag.out │ ├── 450.geom.out │ ├── 450.tesc.out │ ├── 450.tese.out │ ├── 450.vert.out │ ├── 460.frag.out │ ├── 460.vert.out │ ├── BestMatchFunction.vert.out │ ├── EndStreamPrimitive.geom.out │ ├── GL_ARB_bindless_texture.frag.out │ ├── GL_ARB_draw_instanced.vert.out │ ├── GL_ARB_fragment_coord_conventions.vert.out │ ├── GL_ARB_gpu_shader5.u2i.vert.out │ ├── GL_ARB_texture_multisample.vert.out │ ├── GL_EXT_draw_instanced.vert.out │ ├── GL_EXT_shader_integer_mix.vert.out │ ├── GL_EXT_texture_array.frag.out │ ├── Operations.frag.out │ ├── UTF8BOM.vert.out │ ├── aggOps.frag.out │ ├── always-discard.frag.out │ ├── always-discard2.frag.out │ ├── array.frag.out │ ├── array100.frag.out │ ├── atomicAdd.comp.out │ ├── atomicCounterARBOps.vert.out │ ├── atomic_uint.frag.out │ ├── badChars.frag.out │ ├── badMacroArgs.frag.out │ ├── comment.frag.out │ ├── compoundsuffix.frag.hlsl │ ├── compoundsuffix.vert.glsl │ ├── conditionalDiscard.frag.out │ ├── constErrors.frag.out │ ├── constFold.frag.out │ ├── constFoldIntMin.frag.out │ ├── constantUnaryConversion.comp.out │ ├── contradict_0.geom.out │ ├── conversion.frag.out │ ├── coord_conventions.frag.out │ ├── cppBad.vert.out │ ├── cppBad2.vert.out │ ├── cppBad3.vert.out │ ├── cppBad4.vert.out │ ├── cppBad5.vert.out │ ├── cppComplexExpr.vert.out │ ├── cppDeepNest.frag.out │ ├── cppIndent.vert.out │ ├── cppIntMinOverNegativeOne.frag.out │ ├── cppMerge.frag.out │ ├── cppNest.vert.out │ ├── cppPassMacroName.frag.out │ ├── cppRelaxSkipTokensErrors.vert.out │ ├── cppSimple.vert.out │ ├── dataOut.frag.out │ ├── dataOutIndirect.frag.out │ ├── dce.frag.out │ ├── decls.frag.out │ ├── deepRvalue.frag.out │ ├── depthOut.frag.out │ ├── discard-dce.frag.out │ ├── doWhileLoop.frag.out │ ├── earlyReturnDiscard.frag.out │ ├── empty.frag.out │ ├── enhanced.0.frag.out │ ├── enhanced.1.frag.out │ ├── enhanced.2.frag.out │ ├── enhanced.3.link.out │ ├── enhanced.4.link.out │ ├── enhanced.5.link.out │ ├── enhanced.6.link.out │ ├── enhanced.7.link.out │ ├── error-column.vert.out │ ├── errors.frag.out │ ├── es-link1.frag.out │ ├── findFunction.frag.out │ ├── floatBitsToInt.vert.out │ ├── flowControl.frag.out │ ├── forLoop.frag.out │ ├── forwardRef.frag.out │ ├── functionCall.frag.out │ ├── functionSemantics.frag.out │ ├── gl_FragCoord.frag.out │ ├── gl_samplemask_array_size.frag.out │ ├── gl_samplemask_array_size_32.frag.out │ ├── gl_samplemask_array_size_64.frag.out │ ├── glsl.-D-U.frag.out │ ├── glsl.-P.frag.out │ ├── glsl.-P.function.frag.out │ ├── glsl.-P.include.frag.out │ ├── glsl.140.layoutOffset.error.vert.out │ ├── glsl.430.layoutOffset.error.vert.out │ ├── glsl.450.subgroup.frag.out │ ├── glsl.450.subgroup.geom.out │ ├── glsl.450.subgroup.tesc.out │ ├── glsl.450.subgroup.tese.out │ ├── glsl.450.subgroup.vert.out │ ├── glsl.450.subgroupArithmetic.comp.out │ ├── glsl.450.subgroupBallot.comp.out │ ├── glsl.450.subgroupBallotNeg.comp.out │ ├── glsl.450.subgroupBasic.comp.out │ ├── glsl.450.subgroupClustered.comp.out │ ├── glsl.450.subgroupClusteredNeg.comp.out │ ├── glsl.450.subgroupPartitioned.comp.out │ ├── glsl.450.subgroupQuad.comp.out │ ├── glsl.450.subgroupRotate.comp.out │ ├── glsl.450.subgroupShuffle.comp.out │ ├── glsl.450.subgroupShuffleRelative.comp.out │ ├── glsl.450.subgroupVote.comp.out │ ├── glsl.460.subgroup.mesh.out │ ├── glsl.460.subgroup.rahit.out │ ├── glsl.460.subgroup.rcall.out │ ├── glsl.460.subgroup.rchit.out │ ├── glsl.460.subgroup.rgen.out │ ├── glsl.460.subgroup.rint.out │ ├── glsl.460.subgroup.rmiss.out │ ├── glsl.460.subgroup.task.out │ ├── glsl.460.subgroupEXT.mesh.out │ ├── glsl.460.subgroupEXT.task.out │ ├── glsl.arbgpushader5.frag.out │ ├── glsl.autosampledtextures.frag.out │ ├── glsl.entryPointRename.vert.bad.out │ ├── glsl.entryPointRename.vert.out │ ├── glsl.entryPointRename2.vert.out │ ├── glsl.es300.layoutOffset.error.vert.out │ ├── glsl.es320.extTextureShadowLod.frag.out │ ├── glsl.es320.subgroup.frag.out │ ├── glsl.es320.subgroup.geom.out │ ├── glsl.es320.subgroup.tesc.out │ ├── glsl.es320.subgroup.tese.out │ ├── glsl.es320.subgroup.vert.out │ ├── glsl.es320.subgroupArithmetic.comp.out │ ├── glsl.es320.subgroupBallot.comp.out │ ├── glsl.es320.subgroupBallotNeg.comp.out │ ├── glsl.es320.subgroupBasic.comp.out │ ├── glsl.es320.subgroupClustered.comp.out │ ├── glsl.es320.subgroupClusteredNeg.comp.out │ ├── glsl.es320.subgroupPartitioned.comp.out │ ├── glsl.es320.subgroupQuad.comp.out │ ├── glsl.es320.subgroupRotate.comp.out │ ├── glsl.es320.subgroupShuffle.comp.out │ ├── glsl.es320.subgroupShuffleRelative.comp.out │ ├── glsl.es320.subgroupVote.comp.out │ ├── glsl.ext.textureShadowLod.frag.out │ ├── glsl.interpOp.error.frag.out │ ├── glsl.nvgpushader5.frag.out │ ├── glsl.nvgpushader5.geom.out │ ├── glsl.nvgpushader5.vert.out │ ├── glsl.versionOverride.comp.out │ ├── glsl.versionOverride.frag.out │ ├── glsl.versionOverride.geom.out │ ├── glsl.versionOverride.tesc.out │ ├── glsl.versionOverride.tese.out │ ├── glsl.versionOverride.vert.out │ ├── glspv.esversion.vert.out │ ├── glspv.frag.out │ ├── glspv.version.frag.out │ ├── glspv.version.vert.out │ ├── glspv.vert.out │ ├── hlsl.-D-U.frag.out │ ├── hlsl.PointSize.geom.out │ ├── hlsl.PointSize.vert.out │ ├── hlsl.aliasOpaque.frag.out │ ├── hlsl.amend.frag.out │ ├── hlsl.array.flatten.frag.out │ ├── hlsl.array.frag.out │ ├── hlsl.array.implicit-size.frag.out │ ├── hlsl.array.multidim.frag.out │ ├── hlsl.assoc.frag.out │ ├── hlsl.attribute.expression.comp.out │ ├── hlsl.attribute.frag.out │ ├── hlsl.attributeC11.frag.out │ ├── hlsl.attributeGlobalBuffer.frag.out │ ├── hlsl.automap.frag.out │ ├── hlsl.autosampledtextures.frag.out │ ├── hlsl.basic.comp.out │ ├── hlsl.basic.geom.out │ ├── hlsl.boolConv.vert.out │ ├── hlsl.buffer-offsets.comp.out │ ├── hlsl.buffer.frag.out │ ├── hlsl.buffer_ref_parameter.comp.out │ ├── hlsl.calculatelod.dx10.frag.out │ ├── hlsl.calculatelodunclamped.dx10.frag.out │ ├── hlsl.cast.frag.out │ ├── hlsl.cbuffer-identifier.vert.out │ ├── hlsl.cbuffer-offsets.comp.out │ ├── hlsl.charLit.vert.out │ ├── hlsl.clip.frag.out │ ├── hlsl.clipdistance-1.frag.out │ ├── hlsl.clipdistance-1.geom.out │ ├── hlsl.clipdistance-1.vert.out │ ├── hlsl.clipdistance-2.frag.out │ ├── hlsl.clipdistance-2.geom.out │ ├── hlsl.clipdistance-2.vert.out │ ├── hlsl.clipdistance-3.frag.out │ ├── hlsl.clipdistance-3.geom.out │ ├── hlsl.clipdistance-3.vert.out │ ├── hlsl.clipdistance-4.frag.out │ ├── hlsl.clipdistance-4.geom.out │ ├── hlsl.clipdistance-4.vert.out │ ├── hlsl.clipdistance-5.frag.out │ ├── hlsl.clipdistance-5.vert.out │ ├── hlsl.clipdistance-6.frag.out │ ├── hlsl.clipdistance-6.vert.out │ ├── hlsl.clipdistance-7.frag.out │ ├── hlsl.clipdistance-7.vert.out │ ├── hlsl.clipdistance-8.frag.out │ ├── hlsl.clipdistance-8.vert.out │ ├── hlsl.clipdistance-9.frag.out │ ├── hlsl.clipdistance-9.vert.out │ ├── hlsl.color.hull.tesc.out │ ├── hlsl.comparison.vec.frag.out │ ├── hlsl.conditional.frag.out │ ├── hlsl.constantbuffer.frag.out │ ├── hlsl.constructArray.vert.out │ ├── hlsl.constructexpr.frag.out │ ├── hlsl.constructimat.frag.out │ ├── hlsl.coverage.frag.out │ ├── hlsl.dashI.vert.d.out │ ├── hlsl.dashI.vert.out │ ├── hlsl.deadFunctionMissingBody.vert.out │ ├── hlsl.depthGreater.frag.out │ ├── hlsl.depthLess.frag.out │ ├── hlsl.discard.frag.out │ ├── hlsl.doLoop.frag.out │ ├── hlsl.domain.1.tese.out │ ├── hlsl.domain.2.tese.out │ ├── hlsl.domain.3.tese.out │ ├── hlsl.earlydepthstencil.frag.out │ ├── hlsl.emptystruct.init.vert.out │ ├── hlsl.emptystructreturn.frag.out │ ├── hlsl.emptystructreturn.tesc.out │ ├── hlsl.emptystructreturn.vert.out │ ├── hlsl.entry-in.frag.out │ ├── hlsl.entry-inout.vert.out │ ├── hlsl.entry-out.frag.out │ ├── hlsl.entry.rename.frag.out │ ├── hlsl.explicitDescriptorSet-2.frag.out │ ├── hlsl.explicitDescriptorSet.frag.out │ ├── hlsl.flatten.return.frag.out │ ├── hlsl.flattenOpaque.frag.out │ ├── hlsl.flattenOpaqueInit.vert.out │ ├── hlsl.flattenOpaqueInitMix.vert.out │ ├── hlsl.flattenSubset.frag.out │ ├── hlsl.flattenSubset2.frag.out │ ├── hlsl.float1.frag.out │ ├── hlsl.float4.frag.out │ ├── hlsl.forLoop.frag.out │ ├── hlsl.format.rwtexture.frag.out │ ├── hlsl.frag.out │ ├── hlsl.fraggeom.frag.out │ ├── hlsl.function.frag.out │ ├── hlsl.gather.array.dx10.frag.out │ ├── hlsl.gather.basic.dx10.frag.out │ ├── hlsl.gather.basic.dx10.vert.out │ ├── hlsl.gather.offset.dx10.frag.out │ ├── hlsl.gather.offsetarray.dx10.frag.out │ ├── hlsl.gatherRGBA.array.dx10.frag.out │ ├── hlsl.gatherRGBA.basic.dx10.frag.out │ ├── hlsl.gatherRGBA.offset.dx10.frag.out │ ├── hlsl.gatherRGBA.offsetarray.dx10.frag.out │ ├── hlsl.gathercmpRGBA.offset.dx10.frag.out │ ├── hlsl.getdimensions.dx10.frag.out │ ├── hlsl.getdimensions.dx10.vert.out │ ├── hlsl.getdimensions.rw.dx10.frag.out │ ├── hlsl.getsampleposition.dx10.frag.out │ ├── hlsl.global-const-init.frag.out │ ├── hlsl.groupid.comp.out │ ├── hlsl.gs-hs-mix.tesc.out │ ├── hlsl.hlslOffset.vert.out │ ├── hlsl.hull.1.tesc.out │ ├── hlsl.hull.2.tesc.out │ ├── hlsl.hull.3.tesc.out │ ├── hlsl.hull.4.tesc.out │ ├── hlsl.hull.5.tesc.out │ ├── hlsl.hull.6.tesc.out │ ├── hlsl.hull.ctrlpt-1.tesc.out │ ├── hlsl.hull.ctrlpt-2.tesc.out │ ├── hlsl.hull.void.tesc.out │ ├── hlsl.identifier.sample.frag.out │ ├── hlsl.if.frag.out │ ├── hlsl.imagefetch-subvec4.comp.out │ ├── hlsl.imageload-subvec4.comp.out │ ├── hlsl.implicitBool.frag.out │ ├── hlsl.include.vert.d.out │ ├── hlsl.include.vert.out │ ├── hlsl.includeNegative.vert.out │ ├── hlsl.inf.vert.out │ ├── hlsl.init.frag.out │ ├── hlsl.init2.frag.out │ ├── hlsl.inoutquals.frag.out │ ├── hlsl.inoutquals.negative.frag.out │ ├── hlsl.instance.geom.out │ ├── hlsl.int.dot.frag.out │ ├── hlsl.intrinsic.frexp.frag.out │ ├── hlsl.intrinsic.frexp.vert.out │ ├── hlsl.intrinsics.barriers.comp.out │ ├── hlsl.intrinsics.comp.out │ ├── hlsl.intrinsics.d3dcolortoubyte4.frag.out │ ├── hlsl.intrinsics.double.frag.out │ ├── hlsl.intrinsics.f1632.frag.out │ ├── hlsl.intrinsics.f3216.frag.out │ ├── hlsl.intrinsics.frag.out │ ├── hlsl.intrinsics.lit.frag.out │ ├── hlsl.intrinsics.negative.comp.out │ ├── hlsl.intrinsics.negative.frag.out │ ├── hlsl.intrinsics.negative.vert.out │ ├── hlsl.intrinsics.promote.down.frag.out │ ├── hlsl.intrinsics.promote.frag.out │ ├── hlsl.intrinsics.promote.outputs.frag.out │ ├── hlsl.intrinsics.vert.out │ ├── hlsl.isfinite.frag.out │ ├── hlsl.layout.frag.out │ ├── hlsl.layoutOverride.vert.out │ ├── hlsl.load.2dms.dx10.frag.out │ ├── hlsl.load.array.dx10.frag.out │ ├── hlsl.load.basic.dx10.frag.out │ ├── hlsl.load.basic.dx10.vert.out │ ├── hlsl.load.buffer.dx10.frag.out │ ├── hlsl.load.buffer.float.dx10.frag.out │ ├── hlsl.load.offset.dx10.frag.out │ ├── hlsl.load.offsetarray.dx10.frag.out │ ├── hlsl.load.rwbuffer.dx10.frag.out │ ├── hlsl.load.rwtexture.array.dx10.frag.out │ ├── hlsl.load.rwtexture.dx10.frag.out │ ├── hlsl.localStructuredBuffer.comp.out │ ├── hlsl.logical.binary.frag.out │ ├── hlsl.logical.binary.vec.frag.out │ ├── hlsl.logical.unary.frag.out │ ├── hlsl.logicalConvert.frag.out │ ├── hlsl.loopattr.frag.out │ ├── hlsl.matNx1.frag.out │ ├── hlsl.matType.bool.frag.out │ ├── hlsl.matType.frag.out │ ├── hlsl.matType.int.frag.out │ ├── hlsl.matpack-1.frag.out │ ├── hlsl.matpack-pragma-global.frag.out │ ├── hlsl.matpack-pragma.frag.out │ ├── hlsl.matrixSwizzle.vert.out │ ├── hlsl.matrixindex.frag.out │ ├── hlsl.max.frag.out │ ├── hlsl.memberFunCall.frag.out │ ├── hlsl.mintypes.frag.out │ ├── hlsl.mip.negative.frag.out │ ├── hlsl.mip.negative2.frag.out │ ├── hlsl.mip.operator.frag.out │ ├── hlsl.mul-truncate.frag.out │ ├── hlsl.multiDescriptorSet.frag.out │ ├── hlsl.multiEntry.vert.out │ ├── hlsl.multiReturn.frag.out │ ├── hlsl.multiView.frag.out │ ├── hlsl.namespace.frag.out │ ├── hlsl.nested-runtimeArray.frag.out │ ├── hlsl.noSemantic.functionality1.comp.out │ ├── hlsl.nonint-index.frag.out │ ├── hlsl.nonstaticMemberFunction.frag.out │ ├── hlsl.numericsuffixes.frag.out │ ├── hlsl.numericsuffixes.negative.frag.out │ ├── hlsl.numthreads.comp.out │ ├── hlsl.opaque-type-bug.frag.out │ ├── hlsl.overload.frag.out │ ├── hlsl.params.default.frag.out │ ├── hlsl.params.default.negative.frag.out │ ├── hlsl.partialFlattenLocal.vert.out │ ├── hlsl.partialFlattenMixed.vert.out │ ├── hlsl.partialInit.frag.out │ ├── hlsl.pp.expand.frag.err │ ├── hlsl.pp.expand.frag.out │ ├── hlsl.pp.line.frag.out │ ├── hlsl.pp.line2.frag.out │ ├── hlsl.pp.line3.frag.out │ ├── hlsl.pp.line4.frag.out │ ├── hlsl.pp.vert.out │ ├── hlsl.precedence.frag.out │ ├── hlsl.precedence2.frag.out │ ├── hlsl.precise.frag.out │ ├── hlsl.preprocessor.frag.out │ ├── hlsl.printf.comp.out │ ├── hlsl.promote.atomic.frag.out │ ├── hlsl.promote.binary.frag.out │ ├── hlsl.promote.vec1.frag.out │ ├── hlsl.promotions.frag.out │ ├── hlsl.reflection.binding.frag.out │ ├── hlsl.reflection.binding.vert.out │ ├── hlsl.reflection.vert.out │ ├── hlsl.round.dx10.frag.out │ ├── hlsl.round.dx9.frag.out │ ├── hlsl.rw.atomics.frag.out │ ├── hlsl.rw.bracket.frag.out │ ├── hlsl.rw.register.frag.out │ ├── hlsl.rw.scalar.bracket.frag.out │ ├── hlsl.rw.swizzle.frag.out │ ├── hlsl.rw.vec2.bracket.frag.out │ ├── hlsl.sample.array.dx10.frag.out │ ├── hlsl.sample.basic.dx10.frag.out │ ├── hlsl.sample.dx9.frag.out │ ├── hlsl.sample.dx9.vert.out │ ├── hlsl.sample.offset.dx10.frag.out │ ├── hlsl.sample.offsetarray.dx10.frag.out │ ├── hlsl.sample.sub-vec4.dx10.frag.out │ ├── hlsl.samplebias.array.dx10.frag.out │ ├── hlsl.samplebias.basic.dx10.frag.out │ ├── hlsl.samplebias.offset.dx10.frag.out │ ├── hlsl.samplebias.offsetarray.dx10.frag.out │ ├── hlsl.samplecmp.array.dx10.frag.out │ ├── hlsl.samplecmp.basic.dx10.frag.out │ ├── hlsl.samplecmp.dualmode.frag.out │ ├── hlsl.samplecmp.negative.frag.out │ ├── hlsl.samplecmp.negative2.frag.out │ ├── hlsl.samplecmp.offset.dx10.frag.out │ ├── hlsl.samplecmp.offsetarray.dx10.frag.out │ ├── hlsl.samplecmplevelzero.array.dx10.frag.out │ ├── hlsl.samplecmplevelzero.basic.dx10.frag.out │ ├── hlsl.samplecmplevelzero.offset.dx10.frag.out │ ├── hlsl.samplecmplevelzero.offsetarray.dx10.frag.out │ ├── hlsl.samplegrad.array.dx10.frag.out │ ├── hlsl.samplegrad.basic.dx10.frag.out │ ├── hlsl.samplegrad.basic.dx10.vert.out │ ├── hlsl.samplegrad.offset.dx10.frag.out │ ├── hlsl.samplegrad.offsetarray.dx10.frag.out │ ├── hlsl.samplelevel.array.dx10.frag.out │ ├── hlsl.samplelevel.basic.dx10.frag.out │ ├── hlsl.samplelevel.basic.dx10.vert.out │ ├── hlsl.samplelevel.offset.dx10.frag.out │ ├── hlsl.samplelevel.offsetarray.dx10.frag.out │ ├── hlsl.scalar-length.frag.out │ ├── hlsl.scalar2matrix.frag.out │ ├── hlsl.scalarCast.vert.out │ ├── hlsl.scope.frag.out │ ├── hlsl.self_cast.frag.out │ ├── hlsl.semantic-1.vert.out │ ├── hlsl.semantic.geom.out │ ├── hlsl.semantic.vert.out │ ├── hlsl.semicolons.frag.out │ ├── hlsl.shapeConv.frag.out │ ├── hlsl.shapeConvRet.frag.out │ ├── hlsl.shift.per-set.frag.out │ ├── hlsl.sin.frag.out │ ├── hlsl.singleArgIntPromo.vert.out │ ├── hlsl.snorm.uav.comp.out │ ├── hlsl.specConstant.frag.out │ ├── hlsl.spv.1.6.discard.frag.out │ ├── hlsl.staticFuncInit.frag.out │ ├── hlsl.staticMemberFunction.frag.out │ ├── hlsl.store.rwbyteaddressbuffer.type.comp.out │ ├── hlsl.string.frag.out │ ├── hlsl.stringtoken.frag.out │ ├── hlsl.struct.frag.out │ ├── hlsl.struct.split-1.vert.out │ ├── hlsl.struct.split.array.geom.out │ ├── hlsl.struct.split.assign.frag.out │ ├── hlsl.struct.split.call.vert.out │ ├── hlsl.struct.split.nested.geom.out │ ├── hlsl.struct.split.trivial.geom.out │ ├── hlsl.struct.split.trivial.vert.out │ ├── hlsl.structIoFourWay.frag.out │ ├── hlsl.structStructName.frag.out │ ├── hlsl.structarray.flatten.frag.out │ ├── hlsl.structarray.flatten.geom.out │ ├── hlsl.structbuffer.append.fn.frag.out │ ├── hlsl.structbuffer.append.frag.out │ ├── hlsl.structbuffer.atomics.frag.out │ ├── hlsl.structbuffer.byte.frag.out │ ├── hlsl.structbuffer.coherent.frag.out │ ├── hlsl.structbuffer.floatidx.comp.out │ ├── hlsl.structbuffer.fn.frag.out │ ├── hlsl.structbuffer.fn2.comp.out │ ├── hlsl.structbuffer.frag.out │ ├── hlsl.structbuffer.incdec.frag.hlslfun1.out │ ├── hlsl.structbuffer.incdec.frag.out │ ├── hlsl.structbuffer.rw.frag.out │ ├── hlsl.structbuffer.rwbyte.frag.out │ ├── hlsl.structbuffer.rwbyte2.comp.out │ ├── hlsl.structcopy.comp.out │ ├── hlsl.structcopylogical.comp.out │ ├── hlsl.structin.vert.out │ ├── hlsl.subpass.frag.out │ ├── hlsl.switch.frag.out │ ├── hlsl.swizzle.frag.out │ ├── hlsl.swizzle.vec1.comp.out │ ├── hlsl.synthesizeInput.frag.out │ ├── hlsl.target.frag.out │ ├── hlsl.targetStruct1.frag.out │ ├── hlsl.targetStruct2.frag.out │ ├── hlsl.templatetypes.frag.out │ ├── hlsl.texture.struct.frag.out │ ├── hlsl.texture.subvec4.frag.out │ ├── hlsl.texturebuffer.frag.out │ ├── hlsl.this.frag.out │ ├── hlsl.tristream-append.geom.out │ ├── hlsl.tx.bracket.frag.out │ ├── hlsl.tx.overload.frag.out │ ├── hlsl.type.half.frag.out │ ├── hlsl.type.identifier.frag.out │ ├── hlsl.type.type.conversion.all.frag.out │ ├── hlsl.type.type.conversion.valid.frag.out │ ├── hlsl.typeGraphCopy.vert.out │ ├── hlsl.typedef.frag.out │ ├── hlsl.void.frag.out │ ├── hlsl.w-recip.frag.out │ ├── hlsl.w-recip2.frag.out │ ├── hlsl.wavebroadcast.comp.out │ ├── hlsl.waveprefix.comp.out │ ├── hlsl.wavequad.comp.out │ ├── hlsl.wavequery.comp.out │ ├── hlsl.wavequery.frag.out │ ├── hlsl.wavereduction.comp.out │ ├── hlsl.wavevote.comp.out │ ├── hlsl.whileLoop.frag.out │ ├── hlsl.y-negate-1.vert.out │ ├── hlsl.y-negate-2.vert.out │ ├── hlsl.y-negate-3.vert.out │ ├── implicitArraySize.vert.out │ ├── implicitArraySize1.geom.out │ ├── implicitArraySizeBuiltin.vert.out │ ├── implicitArraySizeUniform.vert.out │ ├── implicitArraySizeUniformContradict.vert.out │ ├── implicitInnerAtomicUint.frag.out │ ├── include.vert.out │ ├── index_outside_sample_mask_range.frag.out │ ├── invalidSwizzle.vert.out │ ├── iomap.blockOutVariableIn.2.vert.out │ ├── iomap.blockOutVariableIn.vert.out │ ├── iomap.crossStage.2.vert.out │ ├── iomap.crossStage.vert.out │ ├── iomap.crossStage.vk.vert.out │ ├── iomap.mismatchedBufferTypes.vert.out │ ├── iomap.variableOutBlockIn.2.vert.out │ ├── iomap.variableOutBlockIn.vert.out │ ├── length.frag.out │ ├── lineContinuation.vert.out │ ├── lineContinuation100.vert.out │ ├── link.crossStageIO.0.vert.out │ ├── link.crossStageIO.1.vert.out │ ├── link.crossStageOptimization.out │ ├── link.missingCrossStageIO.0.vert.out │ ├── link.multiAnonBlocksInvalid.0.0.vert.out │ ├── link.multiAnonBlocksValid.0.0.vert.out │ ├── link.multiBlocksInvalid.0.0.vert.out │ ├── link.multiBlocksValid.1.0.vert.out │ ├── link.redeclareBuiltin.vert.out │ ├── link.tesselation.tese.out │ ├── link.tesselation.vert.out │ ├── link.vk.crossStageIO.0.vert.out │ ├── link.vk.crossStageIO.1.vert.out │ ├── link.vk.differentPC.0.0.frag.out │ ├── link.vk.differentPC.1.0.frag.out │ ├── link.vk.inconsistentGLPerVertex.0.vert.out │ ├── link.vk.matchingPC.0.0.frag.out │ ├── link.vk.missingCrossStageIO.0.vert.out │ ├── link.vk.multiBlocksValid.0.0.vert.out │ ├── link.vk.multiBlocksValid.1.0.geom.out │ ├── link.vk.pcNamingInvalid.0.0.vert.out │ ├── link.vk.pcNamingValid.0.0.vert.out │ ├── link1.frag.out │ ├── link1.vk.frag.out │ ├── liveTraverser.switch.vert.out │ ├── localAggregates.frag.out │ ├── location_aliasing.tesc.out │ ├── location_aliasing1.frag.out │ ├── loops.frag.out │ ├── loopsArtificial.frag.out │ ├── mains1.frag.out │ ├── matrix.frag.out │ ├── matrix2.frag.out │ ├── matrixCompMult.vert.out │ ├── matrixError.vert.out │ ├── maxClipDistances.vert.out │ ├── max_vertices_0.geom.out │ ├── missingBodies.vert.out │ ├── mixedArrayDecls.frag.out │ ├── negativeArraySize.comp.out │ ├── negativeWorkGroupSize.comp.out │ ├── newTexture.frag.out │ ├── noMain.vert.out │ ├── noMatchingFunction.frag.out │ ├── nonSquare.vert.out │ ├── nonVulkan.frag.out │ ├── nonuniform.frag.out │ ├── nosuffix.out │ ├── numeral.frag.out │ ├── nvShaderNoperspectiveInterpolation.frag.out │ ├── overflow_underflow_toinf_0.frag.out │ ├── overlongLiteral.frag.out │ ├── pointCoord.frag.out │ ├── positive_infinity.frag.out │ ├── precise.tesc.out │ ├── precise_struct_block.vert.out │ ├── precision.frag.out │ ├── precision.vert.out │ ├── prepost.frag.out │ ├── preprocess.arb_shading_language_include.vert.err │ ├── preprocess.arb_shading_language_include.vert.out │ ├── preprocess.inactive_stringify.vert.err │ ├── preprocess.inactive_stringify.vert.out │ ├── preprocess.include_directive_missing_extension.vert.err │ ├── preprocess.include_directive_missing_extension.vert.out │ ├── preprocessor.bad_arg.vert.err │ ├── preprocessor.bad_arg.vert.out │ ├── preprocessor.cpp_style___FILE__.vert.err │ ├── preprocessor.cpp_style___FILE__.vert.out │ ├── preprocessor.cpp_style_line_directive.vert.err │ ├── preprocessor.cpp_style_line_directive.vert.out │ ├── preprocessor.defined.vert.err │ ├── preprocessor.defined.vert.out │ ├── preprocessor.edge_cases.vert.err │ ├── preprocessor.edge_cases.vert.out │ ├── preprocessor.eof_missing.vert.err │ ├── preprocessor.eof_missing.vert.out │ ├── preprocessor.errors.vert.err │ ├── preprocessor.errors.vert.out │ ├── preprocessor.extensions.vert.err │ ├── preprocessor.extensions.vert.out │ ├── preprocessor.function_macro.vert.err │ ├── preprocessor.function_macro.vert.out │ ├── preprocessor.include.disabled.vert.err │ ├── preprocessor.include.disabled.vert.out │ ├── preprocessor.include.enabled.vert.err │ ├── preprocessor.include.enabled.vert.out │ ├── preprocessor.line.frag.err │ ├── preprocessor.line.frag.out │ ├── preprocessor.line.vert.err │ ├── preprocessor.line.vert.out │ ├── preprocessor.many.endif.vert.err │ ├── preprocessor.many.endif.vert.out │ ├── preprocessor.pragma.vert.err │ ├── preprocessor.pragma.vert.out │ ├── preprocessor.simple.vert.err │ ├── preprocessor.simple.vert.out │ ├── preprocessor.success_if_parse_would_fail.vert.err │ ├── preprocessor.success_if_parse_would_fail.vert.out │ ├── ps_sample.frag.out │ ├── ps_uint_int.frag.out │ ├── rayQuery-OpConvertUToAccelerationStructureKHR.comp.out │ ├── rayQuery-allOps.Error.rgen.out │ ├── rayQuery-allOps.comp.out │ ├── rayQuery-allOps.frag.out │ ├── rayQuery-allOps.rgen.out │ ├── rayQuery-committed.Error.rgen.out │ ├── rayQuery-global.rgen.out │ ├── rayQuery-initialization.Error.comp.out │ ├── rayQuery-initialize.rgen.out │ ├── rayQuery-no-cse.rgen.out │ ├── rayQuery-types.comp.out │ ├── rayQuery.rgen.out │ ├── recurse1.vert.out │ ├── reflection.frag.out │ ├── reflection.linked.options.out │ ├── reflection.linked.out │ ├── reflection.options.frag.out │ ├── reflection.options.geom.out │ ├── reflection.options.vert.out │ ├── reflection.vert.out │ ├── remap.basic.dcefunc.frag.out │ ├── remap.basic.dcevartype.frag.out │ ├── remap.basic.everything.frag.out │ ├── remap.basic.none.frag.out │ ├── remap.basic.strip.frag.out │ ├── remap.hlsl.sample.basic.everything.frag.out │ ├── remap.hlsl.sample.basic.none.frag.out │ ├── remap.hlsl.sample.basic.strip.frag.out │ ├── remap.hlsl.templatetypes.everything.frag.out │ ├── remap.hlsl.templatetypes.none.frag.out │ ├── remap.if.everything.frag.out │ ├── remap.if.none.frag.out │ ├── remap.invalid-spirv-1.out │ ├── remap.invalid-spirv-2.out │ ├── remap.literal64.everything.spv.out │ ├── remap.literal64.none.spv.out │ ├── remap.similar_1a.everything.frag.out │ ├── remap.similar_1a.none.frag.out │ ├── remap.similar_1b.everything.frag.out │ ├── remap.similar_1b.none.frag.out │ ├── remap.specconst.comp.out │ ├── remap.switch.everything.frag.out │ ├── remap.switch.none.frag.out │ ├── remap.uniformarray.everything.frag.out │ ├── remap.uniformarray.none.frag.out │ ├── runtimeArray.vert.out │ ├── sample.frag.out │ ├── sample.vert.out │ ├── samplerlessTextureFunctions.frag.out │ ├── simpleFunctionCall.frag.out │ ├── size │ ├── specExamples.frag.out │ ├── specExamples.vert.out │ ├── specExamplesConf.vert.out │ ├── spv.1.3.8bitstorage-ssbo.vert.out │ ├── spv.1.3.8bitstorage-ubo.vert.out │ ├── spv.1.3.coopmat.comp.out │ ├── spv.1.4.LoopControl.frag.out │ ├── spv.1.4.NonWritable.frag.out │ ├── spv.1.4.OpCopyLogical.comp.out │ ├── spv.1.4.OpCopyLogical.funcall.frag.out │ ├── spv.1.4.OpCopyLogicalBool.comp.out │ ├── spv.1.4.OpEntryPoint.frag.out │ ├── spv.1.4.OpEntryPoint.opaqueParams.vert.out │ ├── spv.1.4.OpSelect.frag.out │ ├── spv.1.4.constructComposite.comp.out │ ├── spv.1.4.funcall.array.frag.out │ ├── spv.1.4.image.frag.out │ ├── spv.1.4.load.bool.array.interface.block.frag.out │ ├── spv.1.4.sparseTexture.frag.out │ ├── spv.1.4.texture.frag.out │ ├── spv.1.6.conditionalDiscard.frag.out │ ├── spv.1.6.helperInvocation.frag.out │ ├── spv.1.6.helperInvocation.memmodel.frag.out │ ├── spv.1.6.nontemporalimage.frag.out │ ├── spv.1.6.quad.frag.out │ ├── spv.1.6.samplerBuffer.frag.out │ ├── spv.1.6.separate.frag.out │ ├── spv.1.6.specConstant.comp.out │ ├── spv.100ops.frag.out │ ├── spv.130.frag.out │ ├── spv.140.frag.out │ ├── spv.150.geom.out │ ├── spv.150.vert.out │ ├── spv.16bitstorage-int.frag.out │ ├── spv.16bitstorage-uint.frag.out │ ├── spv.16bitstorage.frag.out │ ├── spv.16bitstorage_Error-int.frag.out │ ├── spv.16bitstorage_Error-uint.frag.out │ ├── spv.16bitstorage_Error.frag.out │ ├── spv.16bitxfb.vert.out │ ├── spv.300BuiltIns.vert.out │ ├── spv.300layout.frag.out │ ├── spv.300layout.vert.out │ ├── spv.300layoutp.vert.out │ ├── spv.310.bitcast.frag.out │ ├── spv.310.comp.out │ ├── spv.320.meshShaderUserDefined.mesh.out │ ├── spv.330.geom.out │ ├── spv.400.frag.nanclamp.out │ ├── spv.400.frag.out │ ├── spv.400.tesc.out │ ├── spv.400.tese.out │ ├── spv.420.geom.out │ ├── spv.430.frag.out │ ├── spv.430.vert.out │ ├── spv.450.geom.out │ ├── spv.450.noRedecl.tesc.out │ ├── spv.450.tesc.out │ ├── spv.460.comp.out │ ├── spv.460.frag.out │ ├── spv.460.subgroupEXT.mesh.out │ ├── spv.460.subgroupEXT.task.out │ ├── spv.460.vert.out │ ├── spv.8bit-16bit-construction.frag.out │ ├── spv.8bitstorage-int.frag.out │ ├── spv.8bitstorage-ssbo.vert.out │ ├── spv.8bitstorage-ubo.vert.out │ ├── spv.8bitstorage-uint.frag.out │ ├── spv.8bitstorage_Error-int.frag.out │ ├── spv.8bitstorage_Error-uint.frag.out │ ├── spv.ARMCoreBuiltIns.frag.out │ ├── spv.ARMCoreBuiltIns.vert.out │ ├── spv.AnyHitShader.rahit.out │ ├── spv.AnyHitShaderMotion.rahit.out │ ├── spv.AnyHitShader_Errors.rahit.out │ ├── spv.AofA.frag.out │ ├── spv.ClosestHitShader.rchit.out │ ├── spv.ClosestHitShaderMotion.rchit.out │ ├── spv.ClosestHitShader_Errors.rchit.out │ ├── spv.GeometryShaderPassthrough.geom.out │ ├── spv.IntersectShader.rint.out │ ├── spv.IntersectShaderMotion.rint.out │ ├── spv.IntersectShader_Errors.rint.out │ ├── spv.MissShader.rmiss.out │ ├── spv.MissShaderMotion.rmiss.out │ ├── spv.MissShader_Errors.rmiss.out │ ├── spv.OVR_multiview.vert.out │ ├── spv.Operations.frag.out │ ├── spv.RayCallable.rcall.out │ ├── spv.RayCallable_Errors.rcall.out │ ├── spv.RayConstants.rgen.out │ ├── spv.RayGenShader.rgen.out │ ├── spv.RayGenShader11.rgen.out │ ├── spv.RayGenShaderArray.rgen.out │ ├── spv.RayGenShaderMotion.rgen.out │ ├── spv.RayGenShader_Errors.rgen.out │ ├── spv.WorkgroupMemoryExplicitLayout.16BitAccess.comp.out │ ├── spv.WorkgroupMemoryExplicitLayout.8BitAccess.comp.out │ ├── spv.WorkgroupMemoryExplicitLayout.MixBlockNonBlock_Errors.comp.out │ ├── spv.WorkgroupMemoryExplicitLayout.MultiBlock.comp.out │ ├── spv.WorkgroupMemoryExplicitLayout.NonBlock.comp.out │ ├── spv.WorkgroupMemoryExplicitLayout.SingleBlock.comp.out │ ├── spv.WorkgroupMemoryExplicitLayout.scalar.comp.out │ ├── spv.WorkgroupMemoryExplicitLayout.std140.comp.out │ ├── spv.WorkgroupMemoryExplicitLayout.std430.comp.out │ ├── spv.accessChain.frag.out │ ├── spv.aggOps.frag.out │ ├── spv.always-discard.frag.out │ ├── spv.always-discard2.frag.out │ ├── spv.arbPostDepthCoverage.frag.out │ ├── spv.arbPostDepthCoverage_Error.frag.out │ ├── spv.atomiAddEXT.error.mesh.out │ ├── spv.atomiAddEXT.task.out │ ├── spv.atomic.comp.out │ ├── spv.atomicAdd.bufferReference.comp.out │ ├── spv.atomicCounter.comp.out │ ├── spv.atomicFloat.comp.out │ ├── spv.atomicFloat_Error.comp.out │ ├── spv.atomicInt64.comp.out │ ├── spv.atomicRvalue.error.vert.out │ ├── spv.atomicStoreInt64.comp.out │ ├── spv.barrier.vert.out │ ├── spv.bfloat16.comp.out │ ├── spv.bfloat16_error.comp.out │ ├── spv.bfloat16_error.frag.out │ ├── spv.bitCast.frag.out │ ├── spv.bool.vert.out │ ├── spv.boolInBlock.frag.out │ ├── spv.branch-return.vert.out │ ├── spv.buffer.autoassign.frag.out │ ├── spv.bufferhandle1.frag.out │ ├── spv.bufferhandle10.frag.out │ ├── spv.bufferhandle11.frag.out │ ├── spv.bufferhandle12.frag.out │ ├── spv.bufferhandle13.frag.out │ ├── spv.bufferhandle14.frag.out │ ├── spv.bufferhandle15.frag.out │ ├── spv.bufferhandle16.frag.out │ ├── spv.bufferhandle17_Errors.frag.out │ ├── spv.bufferhandle18.frag.out │ ├── spv.bufferhandle19_Errors.frag.out │ ├── spv.bufferhandle2.frag.out │ ├── spv.bufferhandle3_Errors.frag.out │ ├── spv.bufferhandle4.frag.out │ ├── spv.bufferhandle5.frag.out │ ├── spv.bufferhandle6.frag.out │ ├── spv.bufferhandle7.frag.out │ ├── spv.bufferhandle8.frag.out │ ├── spv.bufferhandle9.frag.out │ ├── spv.bufferhandleUvec2.frag.out │ ├── spv.bufferhandle_Error.frag.out │ ├── spv.builtInXFB.vert.out │ ├── spv.builtin.PrimitiveShadingRateEXT.vert.out │ ├── spv.builtin.ShadingRateEXT.frag.out │ ├── spv.computeShaderDerivatives.comp.out │ ├── spv.computeShaderDerivatives2.comp.out │ ├── spv.computeShaderDerivativesSpec.comp.out │ ├── spv.computeShaderDerivativesSpec2.comp.out │ ├── spv.conditionalDemote.frag.out │ ├── spv.conditionalDiscard.frag.out │ ├── spv.constConstruct.vert.out │ ├── spv.constStruct.vert.out │ ├── spv.constructComposite.comp.out │ ├── spv.controlFlowAttributes.frag.out │ ├── spv.conversion.frag.out │ ├── spv.coopmat.comp.out │ ├── spv.coopmat2_constructor.comp.out │ ├── spv.coopmat2_error.comp.out │ ├── spv.coopmat2_tensor.comp.out │ ├── spv.coopmatKHR.comp.out │ ├── spv.coopmatKHR_Error.comp.out │ ├── spv.coopmatKHR_arithmetic.comp.out │ ├── spv.coopmatKHR_arithmeticError.comp.out │ ├── spv.coopmatKHR_constructor.comp.out │ ├── spv.coopmatKHR_constructorError.comp.out │ ├── spv.coopmat_Error.comp.out │ ├── spv.coopmat_armlayout.comp.out │ ├── spv.coopvec.comp.out │ ├── spv.coopvec2.comp.out │ ├── spv.coopvecTraining.comp.out │ ├── spv.coopvecTraining_Error.comp.out │ ├── spv.coopvec_Error.comp.out │ ├── spv.coopvecloadstore.comp.out │ ├── spv.dataOut.frag.out │ ├── spv.dataOutIndirect.frag.out │ ├── spv.dataOutIndirect.vert.out │ ├── spv.dead-after-continue.vert.out │ ├── spv.dead-after-discard.frag.out │ ├── spv.dead-after-loop-break.vert.out │ ├── spv.dead-after-return.vert.out │ ├── spv.dead-after-switch-break.vert.out │ ├── spv.dead-complex-continue-after-return.vert.out │ ├── spv.dead-complex-merge-after-return.vert.out │ ├── spv.debugInfo.1.1.frag.out │ ├── spv.debugInfo.frag.out │ ├── spv.debugPrintf.frag.out │ ├── spv.debugPrintf_Error.frag.out │ ├── spv.debuginfo.bufferref.glsl.frag.out │ ├── spv.debuginfo.const_params.glsl.comp.out │ ├── spv.debuginfo.continued.glsl.vert.out │ ├── spv.debuginfo.coopmatKHR.comp.out │ ├── spv.debuginfo.glsl.comp.out │ ├── spv.debuginfo.glsl.frag.out │ ├── spv.debuginfo.glsl.geom.out │ ├── spv.debuginfo.glsl.tesc.out │ ├── spv.debuginfo.glsl.tese.out │ ├── spv.debuginfo.glsl.vert.out │ ├── spv.debuginfo.hlsl.comp.out │ ├── spv.debuginfo.hlsl.frag.out │ ├── spv.debuginfo.hlsl.geom.out │ ├── spv.debuginfo.hlsl.tesc.out │ ├── spv.debuginfo.hlsl.tese.out │ ├── spv.debuginfo.hlsl.vert.out │ ├── spv.debuginfo.implicit_br.glsl.frag.out │ ├── spv.debuginfo.include.glsl.frag.out │ ├── spv.debuginfo.multiline.glsl.frag.out │ ├── spv.debuginfo.non_ascii.glsl.frag.out │ ├── spv.debuginfo.rt_types.glsl.rgen.out │ ├── spv.debuginfo.scalar_types.glsl.frag.out │ ├── spv.deepRvalue.frag.out │ ├── spv.demoteDisabled.frag.out │ ├── spv.depthOut.frag.out │ ├── spv.depthUnchanged.frag.out │ ├── spv.deviceGroup.frag.out │ ├── spv.discard-dce.frag.out │ ├── spv.do-simple.vert.out │ ├── spv.do-while-continue-break.vert.out │ ├── spv.doWhileLoop.frag.out │ ├── spv.double.comp.out │ ├── spv.drawParams.vert.out │ ├── spv.earlyAndlateFragmentTests.frag.out │ ├── spv.earlyReturnDiscard.frag.out │ ├── spv.expect_assume.assumeEXT.comp.out │ ├── spv.expect_assume.expectEXT.comp.out │ ├── spv.expect_assume.expectEXT.exttypes.comp.out │ ├── spv.explicittypes.frag.out │ ├── spv.exportFunctions.comp.out │ ├── spv.ext.AccelDecl.frag.out │ ├── spv.ext.AnyHitShader.rahit.out │ ├── spv.ext.AnyHitShader_Errors.rahit.out │ ├── spv.ext.ClosestHitShader.rchit.out │ ├── spv.ext.ClosestHitShader_Errors.rchit.out │ ├── spv.ext.ClosestHitShader_Subgroup.rchit.out │ ├── spv.ext.IntersectShader.rint.out │ ├── spv.ext.IntersectShader_Errors.rint.out │ ├── spv.ext.MissShader.rmiss.out │ ├── spv.ext.MissShader_Errors.rmiss.out │ ├── spv.ext.RayCallable.rcall.out │ ├── spv.ext.RayCallable_Errors.rcall.out │ ├── spv.ext.RayConstants.rgen.out │ ├── spv.ext.RayGenSBTlayout.rgen.out │ ├── spv.ext.RayGenSBTlayout140.rgen.out │ ├── spv.ext.RayGenSBTlayout430.rgen.out │ ├── spv.ext.RayGenSBTlayoutscalar.rgen.out │ ├── spv.ext.RayGenShader.rgen.out │ ├── spv.ext.RayGenShader11.rgen.out │ ├── spv.ext.RayGenShaderArray.rgen.out │ ├── spv.ext.RayGenShader_Errors.rgen.out │ ├── spv.ext.RayPrimCull_Errors.rgen.out │ ├── spv.ext.RayQueryDecl.frag.out │ ├── spv.ext.ShaderTileImage.color.frag.out │ ├── spv.ext.ShaderTileImage.depth_stencil.frag.out │ ├── spv.ext.ShaderTileImage.overlap.frag.out │ ├── spv.ext.ShaderTileImage.subpassinput.frag.out │ ├── spv.ext.ShaderTileImage.typemismatch.frag.out │ ├── spv.ext.ShaderTileImage.wronglayout.frag.out │ ├── spv.ext.World3x4.rahit.out │ ├── spv.ext.meshShaderBuiltins.mesh.out │ ├── spv.ext.meshShaderBuiltinsShadingRate.mesh.out │ ├── spv.ext.meshShaderRedeclBuiltins.mesh.out │ ├── spv.ext.meshShaderTaskMem.mesh.out │ ├── spv.ext.meshShaderUserDefined.mesh.out │ ├── spv.ext.meshTaskShader.task.out │ ├── spv.ext.textureShadowLod.error.frag.out │ ├── spv.ext.textureShadowLod.frag.out │ ├── spv.extPostDepthCoverage.frag.out │ ├── spv.extPostDepthCoverage_Error.frag.out │ ├── spv.float16.frag.out │ ├── spv.float16Fetch.frag.out │ ├── spv.float16NoRelaxed.vert.out │ ├── spv.float16convertonlyarith.comp.out │ ├── spv.float16convertonlystorage.comp.out │ ├── spv.float32.frag.out │ ├── spv.float64.frag.out │ ├── spv.floatFetch.frag.out │ ├── spv.flowControl.frag.out │ ├── spv.for-complex-condition.vert.out │ ├── spv.for-continue-break.vert.out │ ├── spv.for-nobody.vert.out │ ├── spv.for-notest.vert.out │ ├── spv.for-simple.vert.out │ ├── spv.forLoop.frag.out │ ├── spv.forwardFun.frag.out │ ├── spv.fragmentDensity-es.frag.out │ ├── spv.fragmentDensity-neg.frag.out │ ├── spv.fragmentDensity.frag.out │ ├── spv.fragmentDensity.vert.out │ ├── spv.fragmentShaderBarycentric.frag.out │ ├── spv.fragmentShaderBarycentric2.frag.out │ ├── spv.fragmentShaderBarycentric3.frag.out │ ├── spv.fragmentShaderBarycentric4.frag.out │ ├── spv.fsi.frag.out │ ├── spv.fsi_Error.frag.out │ ├── spv.fullyCovered.frag.out │ ├── spv.funcall.array.frag.out │ ├── spv.functionCall.frag.out │ ├── spv.functionNestedOpaque.vert.out │ ├── spv.functionParameterTypes.frag.out │ ├── spv.functionSemantics.frag.out │ ├── spv.glFragColor.frag.out │ ├── spv.glsl.register.autoassign.frag.out │ ├── spv.glsl.register.noautoassign.frag.out │ ├── spv.hlslDebugInfo.frag.out │ ├── spv.hlslOffsets.vert.out │ ├── spv.image.frag.out │ ├── spv.image.load-formatted.frag.out │ ├── spv.imageAtomic64.comp.out │ ├── spv.imageAtomic64.frag.out │ ├── spv.imageLoadStoreLod.frag.out │ ├── spv.int16.amd.frag.out │ ├── spv.int16.frag.out │ ├── spv.int32.frag.out │ ├── spv.int64.frag.out │ ├── spv.int8.frag.out │ ├── spv.intOps.vert.out │ ├── spv.int_dot.frag.out │ ├── spv.int_dot_Error.frag.out │ ├── spv.intcoopmat.comp.out │ ├── spv.interpOps.frag.out │ ├── spv.intrinsicsDebugBreak.frag.out │ ├── spv.intrinsicsFakeEnable.vert.out │ ├── spv.intrinsicsInteractWithCoopMat.comp.out │ ├── spv.intrinsicsSpirvByReference.vert.out │ ├── spv.intrinsicsSpirvDecorate.frag.out │ ├── spv.intrinsicsSpirvDecorateId.comp.out │ ├── spv.intrinsicsSpirvDecorateString.comp.out │ ├── spv.intrinsicsSpirvExecutionMode.frag.out │ ├── spv.intrinsicsSpirvInstruction.vert.out │ ├── spv.intrinsicsSpirvLiteral.vert.out │ ├── spv.intrinsicsSpirvStorageClass.rchit.out │ ├── spv.intrinsicsSpirvType.rgen.out │ ├── spv.intrinsicsSpirvTypeLocalVar.vert.out │ ├── spv.intrinsicsSpirvTypeWithTypeSpecifier.vert.out │ ├── spv.invariantAll.vert.out │ ├── spv.layer.tese.out │ ├── spv.layoutNested.vert.out │ ├── spv.length.frag.out │ ├── spv.load.bool.array.interface.block.frag.out │ ├── spv.localAggregates.frag.out │ ├── spv.loops.frag.out │ ├── spv.loopsArtificial.frag.out │ ├── spv.looseUniformNoLoc.vert.out │ ├── spv.matFun.vert.out │ ├── spv.matrix.frag.out │ ├── spv.matrix2.frag.out │ ├── spv.maximalReconvergence.vert.out │ ├── spv.memoryQualifier.frag.out │ ├── spv.memoryScopeSemantics.comp.out │ ├── spv.memoryScopeSemantics_Error.comp.out │ ├── spv.merge-unreachable.frag.out │ ├── spv.meshShaderBuiltins.mesh.out │ ├── spv.meshShaderPerViewBuiltins.mesh.out │ ├── spv.meshShaderPerViewUserDefined.mesh.out │ ├── spv.meshShaderPerView_Errors.mesh.out │ ├── spv.meshShaderRedeclBuiltins.mesh.out │ ├── spv.meshShaderRedeclPerViewBuiltins.mesh.out │ ├── spv.meshShaderSharedMem.mesh.out │ ├── spv.meshShaderTaskMem.mesh.out │ ├── spv.meshShaderUserDefined.mesh.out │ ├── spv.meshTaskShader.task.out │ ├── spv.multiStruct.comp.out │ ├── spv.multiStructFuncall.frag.out │ ├── spv.multiView.frag.out │ ├── spv.multiple.var.same.const.frag.out │ ├── spv.multiviewPerViewAttributes.tesc.out │ ├── spv.multiviewPerViewAttributes.vert.out │ ├── spv.newTexture.frag.out │ ├── spv.noBuiltInLoc.vert.out │ ├── spv.noDeadDecorations.vert.out │ ├── spv.noLocation.vert.out │ ├── spv.noWorkgroup.comp.out │ ├── spv.noexplicitlayout.comp.out │ ├── spv.nonSquare.vert.out │ ├── spv.nontemporalbuffer.frag.out │ ├── spv.nonuniform.frag.out │ ├── spv.nonuniform2.frag.out │ ├── spv.nonuniform3.frag.out │ ├── spv.nonuniform4.frag.out │ ├── spv.nonuniform5.frag.out │ ├── spv.nullInit.comp.out │ ├── spv.nv.cluster-allops.frag.out │ ├── spv.nv.cluster-allops.rahit.out │ ├── spv.nv.cluster-allops.rchit.out │ ├── spv.nv.cluster-allops.rgen.out │ ├── spv.nv.cluster-allops.rmiss.out │ ├── spv.nv.dmm-allops.comp.out │ ├── spv.nv.dmm-allops.mesh.out │ ├── spv.nv.dmm-allops.rahit.out │ ├── spv.nv.dmm-allops.rchit.out │ ├── spv.nv.dmm-allops.rgen.out │ ├── spv.nv.hitobject-allops.rchit.out │ ├── spv.nv.hitobject-allops.rgen.out │ ├── spv.nv.hitobject-allops.rmiss.out │ ├── spv.nv.hitobject-errors.rgen.out │ ├── spv.nv.lss-allops.frag.out │ ├── spv.nv.lss-allops.rchit.out │ ├── spv.nv.lss-allops.rgen.out │ ├── spv.nv.lss-allops.rmiss.out │ ├── spv.nvAtomicFp16Vec.frag.out │ ├── spv.nvgpushader5.frag.out │ ├── spv.nvgpushader5.geom.out │ ├── spv.nvgpushader5.vert.out │ ├── spv.offsets.frag.out │ ├── spv.paramMemory.420.frag.out │ ├── spv.paramMemory.frag.out │ ├── spv.perprimitiveNV.frag.out │ ├── spv.pp.line.frag.out │ ├── spv.precise.tesc.out │ ├── spv.precise.tese.out │ ├── spv.precision.frag.out │ ├── spv.precisionArgs.frag.out │ ├── spv.precisionNonESSamp.frag.out │ ├── spv.precisionTexture.frag.out │ ├── spv.prepost.frag.out │ ├── spv.privateVariableTypes.frag.out │ ├── spv.pushConstant.vert.out │ ├── spv.pushConstantAnon.vert.out │ ├── spv.qualifiers.vert.out │ ├── spv.queryL.frag.out │ ├── spv.queueFamilyScope.comp.out │ ├── spv.rankShift.comp.out │ ├── spv.register.autoassign-2.frag.out │ ├── spv.register.autoassign.frag.out │ ├── spv.register.autoassign.rangetest.frag.out │ ├── spv.register.noautoassign.frag.out │ ├── spv.register.subpass.frag.out │ ├── spv.replicate.comp.out │ ├── spv.replicatespec.comp.out │ ├── spv.rw.autoassign.frag.out │ ├── spv.sample.frag.out │ ├── spv.sampleId.frag.out │ ├── spv.sampleMaskOverrideCoverage.frag.out │ ├── spv.samplePosition.frag.out │ ├── spv.sampledImageBlock.frag.out │ ├── spv.samplerlessTextureFunctions.frag.out │ ├── spv.scalarlayout.frag.out │ ├── spv.scalarlayoutfloat16.frag.out │ ├── spv.separate.frag.out │ ├── spv.set.vert.out │ ├── spv.shaderBallot.comp.out │ ├── spv.shaderBallotAMD.comp.out │ ├── spv.shaderDrawParams.vert.out │ ├── spv.shaderFragMaskAMD.frag.out │ ├── spv.shaderGroupVote.comp.out │ ├── spv.shaderImageFootprint.frag.out │ ├── spv.shaderStencilExport.frag.out │ ├── spv.shadingRate.frag.out │ ├── spv.shiftOps.frag.out │ ├── spv.shortCircuit.frag.out │ ├── spv.simpleFunctionCall.frag.out │ ├── spv.simpleMat.vert.out │ ├── spv.smBuiltins.frag.out │ ├── spv.smBuiltins.vert.out │ ├── spv.sparseTexture.frag.out │ ├── spv.sparseTextureClamp.frag.out │ ├── spv.sparsetextureoffset_non_const.vert.out │ ├── spv.sparsetextureoffset_non_const_fail.vert.out │ ├── spv.specConst.vert.out │ ├── spv.specConstArrayCheck.vert.out │ ├── spv.specConstant.comp.out │ ├── spv.specConstant.float16.comp.out │ ├── spv.specConstant.int16.comp.out │ ├── spv.specConstant.int8.comp.out │ ├── spv.specConstant.vert.out │ ├── spv.specConstantComposite.vert.out │ ├── spv.specConstantComposite2.vert.out │ ├── spv.specConstantOp.float16.comp.out │ ├── spv.specConstantOp.int16.comp.out │ ├── spv.specConstantOp.int8.comp.out │ ├── spv.specConstantOperations.vert.out │ ├── spv.specTexture.frag.out │ ├── spv.ssbo.autoassign.frag.out │ ├── spv.ssboAlias.frag.out │ ├── spv.stereoViewRendering.tesc.out │ ├── spv.stereoViewRendering.vert.out │ ├── spv.storageBuffer.vert.out │ ├── spv.structAssignment.frag.out │ ├── spv.structCopy.comp.out │ ├── spv.structDeref.frag.out │ ├── spv.structure.frag.out │ ├── spv.subgroup.frag.out │ ├── spv.subgroup.geom.out │ ├── spv.subgroup.tesc.out │ ├── spv.subgroup.tese.out │ ├── spv.subgroup.vert.out │ ├── spv.subgroupArithmetic.comp.out │ ├── spv.subgroupBallot.comp.out │ ├── spv.subgroupBallotNeg.comp.out │ ├── spv.subgroupBasic.comp.out │ ├── spv.subgroupClustered.comp.out │ ├── spv.subgroupClusteredNeg.comp.out │ ├── spv.subgroupExtendedTypesArithmetic.comp.out │ ├── spv.subgroupExtendedTypesArithmeticNeg.comp.out │ ├── spv.subgroupExtendedTypesBallot.comp.out │ ├── spv.subgroupExtendedTypesBallotNeg.comp.out │ ├── spv.subgroupExtendedTypesBasic.comp.out │ ├── spv.subgroupExtendedTypesClustered.comp.out │ ├── spv.subgroupExtendedTypesClusteredNeg.comp.out │ ├── spv.subgroupExtendedTypesPartitioned.comp.out │ ├── spv.subgroupExtendedTypesPartitionedNeg.comp.out │ ├── spv.subgroupExtendedTypesQuad.comp.out │ ├── spv.subgroupExtendedTypesQuadNeg.comp.out │ ├── spv.subgroupExtendedTypesRotate.comp.out │ ├── spv.subgroupExtendedTypesRotateNeg.comp.out │ ├── spv.subgroupExtendedTypesShuffle.comp.out │ ├── spv.subgroupExtendedTypesShuffleNeg.comp.out │ ├── spv.subgroupExtendedTypesShuffleRelative.comp.out │ ├── spv.subgroupExtendedTypesShuffleRelativeNeg.comp.out │ ├── spv.subgroupExtendedTypesVote.comp.out │ ├── spv.subgroupExtendedTypesVoteNeg.comp.out │ ├── spv.subgroupPartitioned.comp.out │ ├── spv.subgroupQuad.comp.out │ ├── spv.subgroupRotate.comp.out │ ├── spv.subgroupShuffle.comp.out │ ├── spv.subgroupShuffleRelative.comp.out │ ├── spv.subgroupSizeARB.frag.out │ ├── spv.subgroupUniformControlFlow.vert.out │ ├── spv.subgroupVote.comp.out │ ├── spv.subpass.frag.out │ ├── spv.switch.frag.out │ ├── spv.swizzle.frag.out │ ├── spv.swizzleInversion.frag.out │ ├── spv.terminate.frag.out │ ├── spv.test.frag.out │ ├── spv.test.vert.out │ ├── spv.texture.frag.out │ ├── spv.texture.sampler.transform.frag.out │ ├── spv.texture.vert.out │ ├── spv.textureBuffer.vert.out │ ├── spv.textureError.frag.out │ ├── spv.textureGatherBiasLod.frag.out │ ├── spv.textureoffset_non_const.vert.out │ ├── spv.tpipBlockMatchGatherSAD.frag.out │ ├── spv.tpipBlockMatchGatherSSD.frag.out │ ├── spv.tpipBlockMatchSAD.frag.out │ ├── spv.tpipBlockMatchSSD.frag.out │ ├── spv.tpipBlockMatchWindowSAD.frag.out │ ├── spv.tpipBlockMatchWindowSSD.frag.out │ ├── spv.tpipBoxFilter.frag.out │ ├── spv.tpipSampleWeighted.frag.out │ ├── spv.tpipTextureArrays.frag.out │ ├── spv.types.frag.out │ ├── spv.uint.frag.out │ ├── spv.uniformArray.frag.out │ ├── spv.uniformInitializer.frag.out │ ├── spv.uniformInitializerSpecConstant.frag.out │ ├── spv.uniformInitializerStruct.frag.out │ ├── spv.unit1.frag.out │ ├── spv.variableArrayIndex.frag.out │ ├── spv.varyingArray.frag.out │ ├── spv.varyingArrayIndirect.frag.out │ ├── spv.vecMatConstruct.frag.out │ ├── spv.viewportArray2.tesc.out │ ├── spv.viewportArray2.vert.out │ ├── spv.viewportindex.tese.out │ ├── spv.voidFunction.frag.out │ ├── spv.volatileAtomic.comp.out │ ├── spv.vulkan100.subgroupArithmetic.comp.out │ ├── spv.vulkan100.subgroupPartitioned.comp.out │ ├── spv.vulkan110.int16.frag.out │ ├── spv.vulkan110.storageBuffer.vert.out │ ├── spv.while-continue-break.vert.out │ ├── spv.while-simple.vert.out │ ├── spv.whileLoop.frag.out │ ├── spv.xfb.vert.out │ ├── spv.xfb2.vert.out │ ├── spv.xfb3.vert.out │ ├── spv.xfbOffsetOnBlockMembersAssignment.vert.out │ ├── spv.xfbOffsetOnStructMembersAssignment.vert.out │ ├── spv.xfbOverlapOffsetCheckWithBlockAndMember.vert.out │ ├── spv.xfbStrideJustOnce.vert.out │ ├── stringToDouble.vert.out │ ├── struct.error.frag.out │ ├── structAssignment.frag.out │ ├── structDeref.frag.out │ ├── structure.frag.out │ ├── switch.frag.out │ ├── swizzle.frag.out │ ├── syntaxError.frag.out │ ├── terminate.frag.out │ ├── terminate.vert.out │ ├── tes_patch.tese.out │ ├── test.conf │ ├── test.frag.out │ ├── texture.frag.out │ ├── textureQueryLOD.frag.out │ ├── textureoffset_sampler2darrayshadow.vert.out │ ├── tokenLength.vert.out │ ├── tokenPaste.vert.out │ ├── types.frag.out │ ├── uint.frag.out │ ├── uniformArray.frag.out │ ├── validation_fails.txt │ ├── variableArrayIndex.frag.out │ ├── varyingArray.frag.out │ ├── varyingArrayIndirect.frag.out │ ├── versionsClean.frag.out │ ├── versionsClean.vert.out │ ├── versionsErrors.frag.out │ ├── versionsErrors.vert.out │ ├── vk.relaxed.changeSet.vert.out │ ├── vk.relaxed.errorcheck.vert.out │ ├── vk.relaxed.frag.out │ ├── vk.relaxed.link1.frag.out │ ├── vk.relaxed.stagelink.0.0.vert.out │ ├── vk.relaxed.stagelink.vert.out │ ├── voidFunction.frag.out │ ├── vulkan.ast.vert.out │ ├── vulkan.comp.out │ ├── vulkan.frag.out │ ├── vulkan.vert.out │ ├── web.array.frag.out │ ├── web.basic.vert.out │ ├── web.builtins.frag.out │ ├── web.builtins.vert.out │ ├── web.comp.out │ ├── web.controlFlow.frag.out │ ├── web.operations.frag.out │ ├── web.separate.frag.out │ ├── web.texture.frag.out │ ├── whileLoop.frag.out │ ├── xfbUnsizedArray.error.tese.out │ └── xfbUnsizedArray.error.vert.out ├── bump ├── comment.frag ├── compoundsuffix.frag.hlsl ├── compoundsuffix.vert.glsl ├── conditionalDiscard.frag ├── constErrors.frag ├── constFold.frag ├── constFoldIntMin.frag ├── constantUnaryConversion.comp ├── contradict_0.geom ├── contradict_1.geom ├── conversion.frag ├── coord_conventions.frag ├── cppBad.vert ├── cppBad2.vert ├── cppBad3.vert ├── cppBad4.vert ├── cppBad5.vert ├── cppComplexExpr.vert ├── cppDeepNest.frag ├── cppIndent.vert ├── cppIntMinOverNegativeOne.frag ├── cppMerge.frag ├── cppNest.vert ├── cppPassMacroName.frag ├── cppRelaxSkipTokensErrors.vert ├── cppSimple.vert ├── dataOut.frag ├── dataOutIndirect.frag ├── dce.frag ├── decls.frag ├── deepRvalue.frag ├── depthOut.frag ├── discard-dce.frag ├── doWhileLoop.frag ├── earlyReturnDiscard.frag ├── empty.frag ├── empty2.frag ├── empty3.frag ├── enhanced.0.frag ├── enhanced.1.frag ├── enhanced.2.frag ├── enhanced.3.frag ├── enhanced.3.vert ├── enhanced.4.frag ├── enhanced.4.vert ├── enhanced.5.frag ├── enhanced.5.vert ├── enhanced.6.frag ├── enhanced.6.vert ├── enhanced.7.frag ├── enhanced.7.vert ├── error-column.vert ├── errors.frag ├── es-link1.frag ├── es-link2.frag ├── findFunction.frag ├── find_package │ ├── CMakeLists.txt │ ├── example.c │ └── stub.cpp ├── floatBitsToInt.vert ├── flowControl.frag ├── foo.h ├── forLoop.frag ├── forwardRef.frag ├── functionCall.frag ├── functionSemantics.frag ├── gl_FragCoord.frag ├── gl_MaxSamples_32.conf ├── gl_MaxSamples_64.conf ├── gl_samplemask_array_size.frag ├── glsl.-D-U.frag ├── glsl.-P.frag ├── glsl.-P.function.frag ├── glsl.-P.include.frag ├── glsl.-P.included.glsl ├── glsl.140.layoutOffset.error.vert ├── glsl.430.layoutOffset.error.vert ├── glsl.450.subgroup.frag ├── glsl.450.subgroup.geom ├── glsl.450.subgroup.tesc ├── glsl.450.subgroup.tese ├── glsl.450.subgroup.vert ├── glsl.450.subgroupArithmetic.comp ├── glsl.450.subgroupBallot.comp ├── glsl.450.subgroupBallotNeg.comp ├── glsl.450.subgroupBasic.comp ├── glsl.450.subgroupClustered.comp ├── glsl.450.subgroupClusteredNeg.comp ├── glsl.450.subgroupPartitioned.comp ├── glsl.450.subgroupQuad.comp ├── glsl.450.subgroupRotate.comp ├── glsl.450.subgroupShuffle.comp ├── glsl.450.subgroupShuffleRelative.comp ├── glsl.450.subgroupVote.comp ├── glsl.460.subgroup.mesh ├── glsl.460.subgroup.rahit ├── glsl.460.subgroup.rcall ├── glsl.460.subgroup.rchit ├── glsl.460.subgroup.rgen ├── glsl.460.subgroup.rint ├── glsl.460.subgroup.rmiss ├── glsl.460.subgroup.task ├── glsl.arbgpushader5.frag ├── glsl.autosampledtextures.frag ├── glsl.entryPointRename.vert ├── glsl.entryPointRename2.vert ├── glsl.es300.layoutOffset.error.vert ├── glsl.es320.extTextureShadowLod.frag ├── glsl.es320.subgroup.frag ├── glsl.es320.subgroup.geom ├── glsl.es320.subgroup.tesc ├── glsl.es320.subgroup.tese ├── glsl.es320.subgroup.vert ├── glsl.es320.subgroupArithmetic.comp ├── glsl.es320.subgroupBallot.comp ├── glsl.es320.subgroupBallotNeg.comp ├── glsl.es320.subgroupBasic.comp ├── glsl.es320.subgroupClustered.comp ├── glsl.es320.subgroupClusteredNeg.comp ├── glsl.es320.subgroupPartitioned.comp ├── glsl.es320.subgroupQuad.comp ├── glsl.es320.subgroupRotate.comp ├── glsl.es320.subgroupShuffle.comp ├── glsl.es320.subgroupShuffleRelative.comp ├── glsl.es320.subgroupVote.comp ├── glsl.ext.textureShadowLod.frag ├── glsl.interpOp.error.frag ├── glsl.nvgpushader5.frag ├── glsl.nvgpushader5.geom ├── glsl.nvgpushader5.vert ├── glsl.versionOverride.comp ├── glsl.versionOverride.frag ├── glsl.versionOverride.geom ├── glsl.versionOverride.tesc ├── glsl.versionOverride.tese ├── glsl.versionOverride.vert ├── glslangValidator ├── glspv.esversion.vert ├── glspv.frag ├── glspv.version.frag ├── glspv.version.vert ├── glspv.vert ├── hlsl.-D-U.frag ├── hlsl.PointSize.geom ├── hlsl.PointSize.vert ├── hlsl.aliasOpaque.frag ├── hlsl.amend.frag ├── hlsl.array.flatten.frag ├── hlsl.array.frag ├── hlsl.array.implicit-size.frag ├── hlsl.array.multidim.frag ├── hlsl.assoc.frag ├── hlsl.attribute.expression.comp ├── hlsl.attribute.frag ├── hlsl.attributeC11.frag ├── hlsl.attributeGlobalBuffer.frag ├── hlsl.automap.frag ├── hlsl.autosampledtextures.frag ├── hlsl.basic.comp ├── hlsl.basic.geom ├── hlsl.boolConv.vert ├── hlsl.buffer-offsets.comp ├── hlsl.buffer.frag ├── hlsl.buffer_ref_parameter.comp ├── hlsl.calculatelod.dx10.frag ├── hlsl.calculatelodunclamped.dx10.frag ├── hlsl.cast.frag ├── hlsl.cbuffer-identifier.vert ├── hlsl.cbuffer-offsets.comp ├── hlsl.charLit.vert ├── hlsl.clip.frag ├── hlsl.clipdistance-1.frag ├── hlsl.clipdistance-1.geom ├── hlsl.clipdistance-1.vert ├── hlsl.clipdistance-2.frag ├── hlsl.clipdistance-2.geom ├── hlsl.clipdistance-2.vert ├── hlsl.clipdistance-3.frag ├── hlsl.clipdistance-3.geom ├── hlsl.clipdistance-3.vert ├── hlsl.clipdistance-4.frag ├── hlsl.clipdistance-4.geom ├── hlsl.clipdistance-4.vert ├── hlsl.clipdistance-5.frag ├── hlsl.clipdistance-5.vert ├── hlsl.clipdistance-6.frag ├── hlsl.clipdistance-6.vert ├── hlsl.clipdistance-7.frag ├── hlsl.clipdistance-7.vert ├── hlsl.clipdistance-8.frag ├── hlsl.clipdistance-8.vert ├── hlsl.clipdistance-9.frag ├── hlsl.clipdistance-9.vert ├── hlsl.color.hull.tesc ├── hlsl.comparison.vec.frag ├── hlsl.conditional.frag ├── hlsl.constantbuffer.frag ├── hlsl.constructArray.vert ├── hlsl.constructexpr.frag ├── hlsl.constructimat.frag ├── hlsl.coverage.frag ├── hlsl.dashI.vert ├── hlsl.deadFunctionMissingBody.vert ├── hlsl.depthGreater.frag ├── hlsl.depthLess.frag ├── hlsl.discard.frag ├── hlsl.doLoop.frag ├── hlsl.domain.1.tese ├── hlsl.domain.2.tese ├── hlsl.domain.3.tese ├── hlsl.earlydepthstencil.frag ├── hlsl.emptystruct.init.vert ├── hlsl.emptystructreturn.frag ├── hlsl.emptystructreturn.tesc ├── hlsl.emptystructreturn.vert ├── hlsl.entry-in.frag ├── hlsl.entry-inout.vert ├── hlsl.entry-out.frag ├── hlsl.entry.rename.frag ├── hlsl.explicitDescriptorSet.frag ├── hlsl.flatten.return.frag ├── hlsl.flattenOpaque.frag ├── hlsl.flattenOpaqueInit.vert ├── hlsl.flattenOpaqueInitMix.vert ├── hlsl.flattenSubset.frag ├── hlsl.flattenSubset2.frag ├── hlsl.float1.frag ├── hlsl.float4.frag ├── hlsl.forLoop.frag ├── hlsl.format.rwtexture.frag ├── hlsl.frag ├── hlsl.fraggeom.frag ├── hlsl.function.frag ├── hlsl.gather.array.dx10.frag ├── hlsl.gather.basic.dx10.frag ├── hlsl.gather.basic.dx10.vert ├── hlsl.gather.offset.dx10.frag ├── hlsl.gather.offsetarray.dx10.frag ├── hlsl.gatherRGBA.array.dx10.frag ├── hlsl.gatherRGBA.basic.dx10.frag ├── hlsl.gatherRGBA.offset.dx10.frag ├── hlsl.gatherRGBA.offsetarray.dx10.frag ├── hlsl.gathercmpRGBA.array.dx10.frag ├── hlsl.gathercmpRGBA.basic.dx10.frag ├── hlsl.gathercmpRGBA.offset.dx10.frag ├── hlsl.gathercmpRGBA.offsetarray.dx10.frag ├── hlsl.getdimensions.dx10.frag ├── hlsl.getdimensions.dx10.vert ├── hlsl.getdimensions.rw.dx10.frag ├── hlsl.getsampleposition.dx10.frag ├── hlsl.global-const-init.frag ├── hlsl.groupid.comp ├── hlsl.gs-hs-mix.tesc ├── hlsl.hlslOffset.vert ├── hlsl.hull.1.tesc ├── hlsl.hull.2.tesc ├── hlsl.hull.3.tesc ├── hlsl.hull.4.tesc ├── hlsl.hull.5.tesc ├── hlsl.hull.6.tesc ├── hlsl.hull.ctrlpt-1.tesc ├── hlsl.hull.ctrlpt-2.tesc ├── hlsl.hull.void.tesc ├── hlsl.identifier.sample.frag ├── hlsl.if.frag ├── hlsl.imagefetch-subvec4.comp ├── hlsl.imageload-subvec4.comp ├── hlsl.implicitBool.frag ├── hlsl.include.vert ├── hlsl.includeNegative.vert ├── hlsl.inf.vert ├── hlsl.init.frag ├── hlsl.init2.frag ├── hlsl.inoutquals.frag ├── hlsl.inoutquals.negative.frag ├── hlsl.instance.geom ├── hlsl.int.dot.frag ├── hlsl.intrinsic.frexp.frag ├── hlsl.intrinsic.frexp.vert ├── hlsl.intrinsics.barriers.comp ├── hlsl.intrinsics.comp ├── hlsl.intrinsics.d3dcolortoubyte4.frag ├── hlsl.intrinsics.double.frag ├── hlsl.intrinsics.evalfns.frag ├── hlsl.intrinsics.f1632.frag ├── hlsl.intrinsics.f3216.frag ├── hlsl.intrinsics.frag ├── hlsl.intrinsics.lit.frag ├── hlsl.intrinsics.negative.comp ├── hlsl.intrinsics.negative.frag ├── hlsl.intrinsics.negative.vert ├── hlsl.intrinsics.promote.down.frag ├── hlsl.intrinsics.promote.frag ├── hlsl.intrinsics.promote.outputs.frag ├── hlsl.intrinsics.vert ├── hlsl.isfinite.frag ├── hlsl.layout.frag ├── hlsl.layoutOverride.vert ├── hlsl.load.2dms.dx10.frag ├── hlsl.load.array.dx10.frag ├── hlsl.load.basic.dx10.frag ├── hlsl.load.basic.dx10.vert ├── hlsl.load.buffer.dx10.frag ├── hlsl.load.buffer.float.dx10.frag ├── hlsl.load.offset.dx10.frag ├── hlsl.load.offsetarray.dx10.frag ├── hlsl.load.rwbuffer.dx10.frag ├── hlsl.load.rwtexture.array.dx10.frag ├── hlsl.load.rwtexture.dx10.frag ├── hlsl.localStructuredBuffer.comp ├── hlsl.logical.binary.frag ├── hlsl.logical.binary.vec.frag ├── hlsl.logical.unary.frag ├── hlsl.logicalConvert.frag ├── hlsl.loopattr.frag ├── hlsl.matNx1.frag ├── hlsl.matType.bool.frag ├── hlsl.matType.frag ├── hlsl.matType.int.frag ├── hlsl.matpack-1.frag ├── hlsl.matpack-pragma-global.frag ├── hlsl.matpack-pragma.frag ├── hlsl.matrixSwizzle.vert ├── hlsl.matrixindex.frag ├── hlsl.max.frag ├── hlsl.memberFunCall.frag ├── hlsl.mintypes.frag ├── hlsl.mip.negative.frag ├── hlsl.mip.negative2.frag ├── hlsl.mip.operator.frag ├── hlsl.mul-truncate.frag ├── hlsl.multiDescriptorSet.frag ├── hlsl.multiEntry.vert ├── hlsl.multiReturn.frag ├── hlsl.multiView.frag ├── hlsl.namespace.frag ├── hlsl.nested-runtimeArray.frag ├── hlsl.noSemantic.functionality1.comp ├── hlsl.nonint-index.frag ├── hlsl.nonstaticMemberFunction.frag ├── hlsl.numericsuffixes.frag ├── hlsl.numericsuffixes.negative.frag ├── hlsl.numthreads.comp ├── hlsl.opaque-type-bug.frag ├── hlsl.overload.frag ├── hlsl.params.default.frag ├── hlsl.params.default.negative.frag ├── hlsl.partialFlattenLocal.vert ├── hlsl.partialFlattenMixed.vert ├── hlsl.partialInit.frag ├── hlsl.pp.expand.frag ├── hlsl.pp.line.frag ├── hlsl.pp.line2.frag ├── hlsl.pp.line3.frag ├── hlsl.pp.line4.frag ├── hlsl.pp.tokenpasting.frag ├── hlsl.pp.vert ├── hlsl.precedence.frag ├── hlsl.precedence2.frag ├── hlsl.precise.frag ├── hlsl.preprocessor.frag ├── hlsl.printf.comp ├── hlsl.promote.atomic.frag ├── hlsl.promote.binary.frag ├── hlsl.promote.vec1.frag ├── hlsl.promotions.frag ├── hlsl.reflection.binding.frag ├── hlsl.reflection.vert ├── hlsl.round.dx10.frag ├── hlsl.round.dx9.frag ├── hlsl.rw.atomics.frag ├── hlsl.rw.bracket.frag ├── hlsl.rw.register.frag ├── hlsl.rw.scalar.bracket.frag ├── hlsl.rw.swizzle.frag ├── hlsl.rw.vec2.bracket.frag ├── hlsl.sample.array.dx10.frag ├── hlsl.sample.basic.dx10.frag ├── hlsl.sample.dx9.frag ├── hlsl.sample.dx9.vert ├── hlsl.sample.offset.dx10.frag ├── hlsl.sample.offsetarray.dx10.frag ├── hlsl.sample.sub-vec4.dx10.frag ├── hlsl.samplebias.array.dx10.frag ├── hlsl.samplebias.basic.dx10.frag ├── hlsl.samplebias.offset.dx10.frag ├── hlsl.samplebias.offsetarray.dx10.frag ├── hlsl.samplecmp.array.dx10.frag ├── hlsl.samplecmp.basic.dx10.frag ├── hlsl.samplecmp.dualmode.frag ├── hlsl.samplecmp.negative.frag ├── hlsl.samplecmp.negative2.frag ├── hlsl.samplecmp.offset.dx10.frag ├── hlsl.samplecmp.offsetarray.dx10.frag ├── hlsl.samplecmplevelzero.array.dx10.frag ├── hlsl.samplecmplevelzero.basic.dx10.frag ├── hlsl.samplecmplevelzero.offset.dx10.frag ├── hlsl.samplecmplevelzero.offsetarray.dx10.frag ├── hlsl.samplegrad.array.dx10.frag ├── hlsl.samplegrad.basic.dx10.frag ├── hlsl.samplegrad.basic.dx10.vert ├── hlsl.samplegrad.offset.dx10.frag ├── hlsl.samplegrad.offsetarray.dx10.frag ├── hlsl.samplelevel.array.dx10.frag ├── hlsl.samplelevel.basic.dx10.frag ├── hlsl.samplelevel.basic.dx10.vert ├── hlsl.samplelevel.offset.dx10.frag ├── hlsl.samplelevel.offsetarray.dx10.frag ├── hlsl.scalar-length.frag ├── hlsl.scalar2matrix.frag ├── hlsl.scalarCast.vert ├── hlsl.scope.frag ├── hlsl.self_cast.frag ├── hlsl.semantic-1.vert ├── hlsl.semantic.geom ├── hlsl.semantic.vert ├── hlsl.semicolons.frag ├── hlsl.shapeConv.frag ├── hlsl.shapeConvRet.frag ├── hlsl.shift.per-set.frag ├── hlsl.sin.frag ├── hlsl.singleArgIntPromo.vert ├── hlsl.snorm.uav.comp ├── hlsl.specConstant.frag ├── hlsl.spv.1.6.discard.frag ├── hlsl.staticFuncInit.frag ├── hlsl.staticMemberFunction.frag ├── hlsl.store.rwbyteaddressbuffer.type.comp ├── hlsl.string.frag ├── hlsl.stringtoken.frag ├── hlsl.struct.frag ├── hlsl.struct.split-1.vert ├── hlsl.struct.split.array.geom ├── hlsl.struct.split.assign.frag ├── hlsl.struct.split.call.vert ├── hlsl.struct.split.nested.geom ├── hlsl.struct.split.trivial.geom ├── hlsl.struct.split.trivial.vert ├── hlsl.structIoFourWay.frag ├── hlsl.structStructName.frag ├── hlsl.structarray.flatten.frag ├── hlsl.structarray.flatten.geom ├── hlsl.structbuffer.append.fn.frag ├── hlsl.structbuffer.append.frag ├── hlsl.structbuffer.atomics.frag ├── hlsl.structbuffer.byte.frag ├── hlsl.structbuffer.coherent.frag ├── hlsl.structbuffer.floatidx.comp ├── hlsl.structbuffer.fn.frag ├── hlsl.structbuffer.fn2.comp ├── hlsl.structbuffer.frag ├── hlsl.structbuffer.incdec.frag ├── hlsl.structbuffer.rw.frag ├── hlsl.structbuffer.rwbyte.frag ├── hlsl.structbuffer.rwbyte2.comp ├── hlsl.structcopy.comp ├── hlsl.structcopylogical.comp ├── hlsl.structin.vert ├── hlsl.subpass.frag ├── hlsl.switch.frag ├── hlsl.swizzle.frag ├── hlsl.swizzle.vec1.comp ├── hlsl.synthesizeInput.frag ├── hlsl.target.frag ├── hlsl.targetStruct1.frag ├── hlsl.targetStruct2.frag ├── hlsl.templatetypes.frag ├── hlsl.templatetypes.negative.frag ├── hlsl.texture.struct.frag ├── hlsl.texture.subvec4.frag ├── hlsl.texturebuffer.frag ├── hlsl.this.frag ├── hlsl.tristream-append.geom ├── hlsl.tx.bracket.frag ├── hlsl.tx.overload.frag ├── hlsl.type.half.frag ├── hlsl.type.identifier.frag ├── hlsl.type.type.conversion.all.frag ├── hlsl.type.type.conversion.valid.frag ├── hlsl.typeGraphCopy.vert ├── hlsl.typedef.frag ├── hlsl.void.frag ├── hlsl.w-recip.frag ├── hlsl.w-recip2.frag ├── hlsl.wavebroadcast.comp ├── hlsl.waveprefix.comp ├── hlsl.wavequad.comp ├── hlsl.wavequery.comp ├── hlsl.wavequery.frag ├── hlsl.wavereduction.comp ├── hlsl.wavevote.comp ├── hlsl.whileLoop.frag ├── hlsl.y-negate-1.vert ├── hlsl.y-negate-2.vert ├── hlsl.y-negate-3.vert ├── i1.h ├── implicitArraySize.frag ├── implicitArraySize.vert ├── implicitArraySize1.geom ├── implicitArraySize2.geom ├── implicitArraySizeBuiltin.geom ├── implicitArraySizeBuiltin.vert ├── implicitArraySizeUniform.frag ├── implicitArraySizeUniform.vert ├── implicitArraySizeUniformContradict.frag ├── implicitArraySizeUniformContradict.vert ├── implicitInnerAtomicUint.frag ├── inc1 │ ├── badInc.h │ ├── bar.h │ ├── foo.h │ ├── path1 │ │ ├── bar.h │ │ ├── local.h │ │ └── notHere.h │ └── path2 │ │ ├── bar.h │ │ ├── notHere.h │ │ └── remote.h ├── inc2 │ ├── bar.h │ └── foo.h ├── include.vert ├── index_outside_sample_mask_range.frag ├── invalidSwizzle.vert ├── iomap.blockOutVariableIn.2.vert ├── iomap.blockOutVariableIn.frag ├── iomap.blockOutVariableIn.geom ├── iomap.blockOutVariableIn.vert ├── iomap.crossStage.2.frag ├── iomap.crossStage.2.geom ├── iomap.crossStage.2.vert ├── iomap.crossStage.frag ├── iomap.crossStage.vert ├── iomap.crossStage.vk.frag ├── iomap.crossStage.vk.geom ├── iomap.crossStage.vk.vert ├── iomap.mismatchedBufferTypes.frag ├── iomap.mismatchedBufferTypes.vert ├── iomap.variableOutBlockIn.2.vert ├── iomap.variableOutBlockIn.frag ├── iomap.variableOutBlockIn.geom ├── iomap.variableOutBlockIn.vert ├── length.frag ├── lineContinuation.vert ├── lineContinuation100.vert ├── link.crossStageIO.0.frag ├── link.crossStageIO.0.vert ├── link.crossStageIO.1.frag ├── link.crossStageIO.1.geom ├── link.crossStageIO.1.vert ├── link.crossStageOptimization.frag ├── link.crossStageOptimization.vert ├── link.missingCrossStageIO.0.frag ├── link.missingCrossStageIO.0.vert ├── link.multiAnonBlocksInvalid.0.0.vert ├── link.multiAnonBlocksInvalid.0.1.vert ├── link.multiAnonBlocksValid.0.0.vert ├── link.multiAnonBlocksValid.0.1.vert ├── link.multiBlocksInvalid.0.0.vert ├── link.multiBlocksInvalid.0.1.vert ├── link.multiBlocksValid.1.0.vert ├── link.multiBlocksValid.1.1.vert ├── link.redeclareBuiltin.geom ├── link.redeclareBuiltin.vert ├── link.tesselation.frag ├── link.tesselation.tesc ├── link.tesselation.tese ├── link.tesselation.vert ├── link.vk.crossStageIO.0.frag ├── link.vk.crossStageIO.0.vert ├── link.vk.crossStageIO.1.frag ├── link.vk.crossStageIO.1.geom ├── link.vk.crossStageIO.1.vert ├── link.vk.differentPC.0.0.frag ├── link.vk.differentPC.0.1.frag ├── link.vk.differentPC.0.2.frag ├── link.vk.differentPC.1.0.frag ├── link.vk.differentPC.1.1.frag ├── link.vk.differentPC.1.2.frag ├── link.vk.inconsistentGLPerVertex.0.geom ├── link.vk.inconsistentGLPerVertex.0.vert ├── link.vk.matchingPC.0.0.frag ├── link.vk.matchingPC.0.1.frag ├── link.vk.matchingPC.0.2.frag ├── link.vk.missingCrossStageIO.0.frag ├── link.vk.missingCrossStageIO.0.vert ├── link.vk.multiBlocksValid.0.0.vert ├── link.vk.multiBlocksValid.0.1.vert ├── link.vk.multiBlocksValid.1.0.geom ├── link.vk.multiBlocksValid.1.1.geom ├── link.vk.pcNamingInvalid.0.0.vert ├── link.vk.pcNamingInvalid.0.1.vert ├── link.vk.pcNamingValid.0.0.vert ├── link.vk.pcNamingValid.0.1.vert ├── link1.frag ├── link1.vk.frag ├── link2.frag ├── link2.vk.frag ├── link3.frag ├── liveTraverser.switch.vert ├── localAggregates.frag ├── location_aliasing.tesc ├── location_aliasing1.frag ├── loops.frag ├── loopsArtificial.frag ├── mains.frag ├── mains1.frag ├── mains2.frag ├── matrix.frag ├── matrix2.frag ├── matrixCompMult.vert ├── matrixError.vert ├── maxClipDistances.vert ├── max_vertices_0.geom ├── missingBodies.vert ├── mixedArrayDecls.frag ├── negativeArraySize.comp ├── negativeWorkGroupSize.comp ├── newTexture.frag ├── noMain.vert ├── noMain1.geom ├── noMain2.geom ├── noMatchingFunction.frag ├── nonSquare.vert ├── nonVulkan.frag ├── nonuniform.frag ├── nosuffix ├── numeral.frag ├── nvShaderNoperspectiveInterpolation.frag ├── overflow_underflow_toinf_0.frag ├── overlongLiteral.frag ├── parent.h ├── parentBad ├── pointCoord.frag ├── positive_infinity.frag ├── precise.tesc ├── precise_struct_block.vert ├── precision.frag ├── precision.vert ├── prepost.frag ├── preprocess.arb_shading_language_include.vert ├── preprocess.inactive_stringify.vert ├── preprocess.include_directive_missing_extension.vert ├── preprocessor.bad_arg.vert ├── preprocessor.cpp_style___FILE__.vert ├── preprocessor.cpp_style_line_directive.vert ├── preprocessor.defined.vert ├── preprocessor.edge_cases.vert ├── preprocessor.eof_missing.vert ├── preprocessor.errors.vert ├── preprocessor.extensions.vert ├── preprocessor.function_macro.vert ├── preprocessor.include.disabled.vert ├── preprocessor.include.enabled.vert ├── preprocessor.line.frag ├── preprocessor.line.vert ├── preprocessor.many.endif.vert ├── preprocessor.pragma.vert ├── preprocessor.simple.vert ├── preprocessor.success_if_parse_would_fail.vert ├── ps_sample.frag ├── ps_uint_int.frag ├── rayQuery-OpConvertUToAccelerationStructureKHR.comp ├── rayQuery-allOps.Error.rgen ├── rayQuery-allOps.comp ├── rayQuery-allOps.frag ├── rayQuery-allOps.rgen ├── rayQuery-committed.Error.rgen ├── rayQuery-global.rgen ├── rayQuery-initialization.Error.comp ├── rayQuery-initialize.rgen ├── rayQuery-no-cse.rgen ├── rayQuery-types.comp ├── rayQuery.rgen ├── recurse1.frag ├── recurse1.vert ├── recurse2.frag ├── reflection.frag ├── reflection.linked.frag ├── reflection.linked.vert ├── reflection.options.geom ├── reflection.options.vert ├── reflection.vert ├── remap.basic.dcefunc.frag ├── remap.basic.everything.frag ├── remap.basic.none.frag ├── remap.basic.strip.frag ├── remap.hlsl.sample.basic.everything.frag ├── remap.hlsl.sample.basic.none.frag ├── remap.hlsl.sample.basic.strip.frag ├── remap.hlsl.templatetypes.everything.frag ├── remap.hlsl.templatetypes.none.frag ├── remap.if.everything.frag ├── remap.if.none.frag ├── remap.invalid-spirv-1.spv ├── remap.invalid-spirv-2.spv ├── remap.literal64.everything.spv ├── remap.literal64.none.spv ├── remap.similar_1a.everything.frag ├── remap.similar_1a.none.frag ├── remap.similar_1b.everything.frag ├── remap.similar_1b.none.frag ├── remap.specconst.comp ├── remap.switch.everything.frag ├── remap.switch.none.frag ├── remap.uniformarray.everything.frag ├── remap.uniformarray.none.frag ├── runtests ├── runtimeArray.vert ├── sample.frag ├── sample.frag.out ├── sample.vert ├── sample.vert.out ├── samplerlessTextureFunctions.frag ├── simpleFunctionCall.frag ├── specExamples.frag ├── specExamples.vert ├── spv.1.3.8bitstorage-ssbo.vert ├── spv.1.3.8bitstorage-ubo.vert ├── spv.1.3.coopmat.comp ├── spv.1.4.LoopControl.frag ├── spv.1.4.NonWritable.frag ├── spv.1.4.OpCopyLogical.comp ├── spv.1.4.OpCopyLogical.funcall.frag ├── spv.1.4.OpCopyLogicalBool.comp ├── spv.1.4.OpEntryPoint.frag ├── spv.1.4.OpEntryPoint.opaqueParams.vert ├── spv.1.4.OpSelect.frag ├── spv.1.4.constructComposite.comp ├── spv.1.4.funcall.array.frag ├── spv.1.4.image.frag ├── spv.1.4.load.bool.array.interface.block.frag ├── spv.1.4.sparseTexture.frag ├── spv.1.4.texture.frag ├── spv.1.6.conditionalDiscard.frag ├── spv.1.6.helperInvocation.frag ├── spv.1.6.helperInvocation.memmodel.frag ├── spv.1.6.nontemporalimage.frag ├── spv.1.6.quad.frag ├── spv.1.6.samplerBuffer.frag ├── spv.1.6.separate.frag ├── spv.1.6.specConstant.comp ├── spv.100ops.frag ├── spv.130.frag ├── spv.140.frag ├── spv.150.geom ├── spv.150.vert ├── spv.16bitstorage-int.frag ├── spv.16bitstorage-uint.frag ├── spv.16bitstorage.frag ├── spv.16bitstorage_Error-int.frag ├── spv.16bitstorage_Error-uint.frag ├── spv.16bitstorage_Error.frag ├── spv.16bitxfb.vert ├── spv.300BuiltIns.vert ├── spv.300layout.frag ├── spv.300layout.vert ├── spv.300layoutp.vert ├── spv.310.bitcast.frag ├── spv.310.comp ├── spv.320.meshShaderUserDefined.mesh ├── spv.330.geom ├── spv.400.frag ├── spv.400.tesc ├── spv.400.tese ├── spv.420.geom ├── spv.430.frag ├── spv.430.vert ├── spv.450.geom ├── spv.450.noRedecl.tesc ├── spv.450.tesc ├── spv.460.comp ├── spv.460.frag ├── spv.460.subgroupEXT.mesh ├── spv.460.subgroupEXT.task ├── spv.460.vert ├── spv.8bit-16bit-construction.frag ├── spv.8bitstorage-int.frag ├── spv.8bitstorage-ssbo.vert ├── spv.8bitstorage-ubo.vert ├── spv.8bitstorage-uint.frag ├── spv.8bitstorage_Error-int.frag ├── spv.8bitstorage_Error-uint.frag ├── spv.ARMCoreBuiltIns.frag ├── spv.ARMCoreBuiltIns.vert ├── spv.AnyHitShader.rahit ├── spv.AnyHitShaderMotion.rahit ├── spv.AnyHitShader_Errors.rahit ├── spv.AofA.frag ├── spv.ClosestHitShader.rchit ├── spv.ClosestHitShaderMotion.rchit ├── spv.ClosestHitShader_Errors.rchit ├── spv.GeometryShaderPassthrough.geom ├── spv.IntersectShader.rint ├── spv.IntersectShaderMotion.rint ├── spv.IntersectShader_Errors.rint ├── spv.MissShader.rmiss ├── spv.MissShaderMotion.rmiss ├── spv.MissShader_Errors.rmiss ├── spv.OVR_multiview.vert ├── spv.Operations.frag ├── spv.RayCallable.rcall ├── spv.RayCallable_Errors.rcall ├── spv.RayConstants.rgen ├── spv.RayGenShader.rgen ├── spv.RayGenShader11.rgen ├── spv.RayGenShaderArray.rgen ├── spv.RayGenShaderMotion.rgen ├── spv.RayGenShader_Errors.rgen ├── spv.WorkgroupMemoryExplicitLayout.16BitAccess.comp ├── spv.WorkgroupMemoryExplicitLayout.8BitAccess.comp ├── spv.WorkgroupMemoryExplicitLayout.MixBlockNonBlock_Errors.comp ├── spv.WorkgroupMemoryExplicitLayout.MultiBlock.comp ├── spv.WorkgroupMemoryExplicitLayout.NonBlock.comp ├── spv.WorkgroupMemoryExplicitLayout.SingleBlock.comp ├── spv.WorkgroupMemoryExplicitLayout.scalar.comp ├── spv.WorkgroupMemoryExplicitLayout.std140.comp ├── spv.WorkgroupMemoryExplicitLayout.std430.comp ├── spv.accessChain.frag ├── spv.aggOps.frag ├── spv.always-discard.frag ├── spv.always-discard2.frag ├── spv.arbPostDepthCoverage.frag ├── spv.arbPostDepthCoverage_Error.frag ├── spv.atomiAddEXT.error.mesh ├── spv.atomiAddEXT.task ├── spv.atomic.comp ├── spv.atomicAdd.bufferReference.comp ├── spv.atomicCounter.comp ├── spv.atomicFloat.comp ├── spv.atomicFloat2.comp ├── spv.atomicFloat_Error.comp ├── spv.atomicInt64.comp ├── spv.atomicRvalue.error.vert ├── spv.atomicStoreInt64.comp ├── spv.barrier.vert ├── spv.bfloat16.comp ├── spv.bfloat16_error.comp ├── spv.bfloat16_error.frag ├── spv.bitCast.frag ├── spv.bool.vert ├── spv.boolInBlock.frag ├── spv.branch-return.vert ├── spv.buffer.autoassign.frag ├── spv.bufferhandle1.frag ├── spv.bufferhandle10.frag ├── spv.bufferhandle11.frag ├── spv.bufferhandle12.frag ├── spv.bufferhandle13.frag ├── spv.bufferhandle14.frag ├── spv.bufferhandle15.frag ├── spv.bufferhandle16.frag ├── spv.bufferhandle17_Errors.frag ├── spv.bufferhandle18.frag ├── spv.bufferhandle19_Errors.frag ├── spv.bufferhandle2.frag ├── spv.bufferhandle3_Errors.frag ├── spv.bufferhandle4.frag ├── spv.bufferhandle5.frag ├── spv.bufferhandle6.frag ├── spv.bufferhandle7.frag ├── spv.bufferhandle8.frag ├── spv.bufferhandle9.frag ├── spv.bufferhandleUvec2.frag ├── spv.bufferhandle_Error.frag ├── spv.builtInXFB.vert ├── spv.builtin.PrimitiveShadingRateEXT.vert ├── spv.builtin.ShadingRateEXT.frag ├── spv.computeShaderDerivatives.comp ├── spv.computeShaderDerivatives2.comp ├── spv.computeShaderDerivativesSpec.comp ├── spv.computeShaderDerivativesSpec2.comp ├── spv.conditionalDemote.frag ├── spv.conditionalDiscard.frag ├── spv.constConstruct.vert ├── spv.constStruct.vert ├── spv.constructComposite.comp ├── spv.controlFlowAttributes.frag ├── spv.conversion.frag ├── spv.coopmat.comp ├── spv.coopmat2_constructor.comp ├── spv.coopmat2_error.comp ├── spv.coopmat2_tensor.comp ├── spv.coopmatKHR.comp ├── spv.coopmatKHR_Error.comp ├── spv.coopmatKHR_arithmetic.comp ├── spv.coopmatKHR_arithmeticError.comp ├── spv.coopmatKHR_constructor.comp ├── spv.coopmatKHR_constructorError.comp ├── spv.coopmat_Error.comp ├── spv.coopmat_armlayout.comp ├── spv.coopvec.comp ├── spv.coopvec2.comp ├── spv.coopvecTraining.comp ├── spv.coopvecTraining_Error.comp ├── spv.coopvec_Error.comp ├── spv.coopvecloadstore.comp ├── spv.dataOut.frag ├── spv.dataOutIndirect.frag ├── spv.dataOutIndirect.vert ├── spv.dead-after-continue.vert ├── spv.dead-after-discard.frag ├── spv.dead-after-loop-break.vert ├── spv.dead-after-return.vert ├── spv.dead-after-switch-break.vert ├── spv.dead-complex-continue-after-return.vert ├── spv.dead-complex-merge-after-return.vert ├── spv.debugInfo.frag ├── spv.debugPrintf.frag ├── spv.debugPrintf_Error.frag ├── spv.debuginfo.bufferref.glsl.frag ├── spv.debuginfo.const_params.glsl.comp ├── spv.debuginfo.continued.glsl.vert ├── spv.debuginfo.coopmatKHR.comp ├── spv.debuginfo.glsl.comp ├── spv.debuginfo.glsl.frag ├── spv.debuginfo.glsl.geom ├── spv.debuginfo.glsl.tesc ├── spv.debuginfo.glsl.tese ├── spv.debuginfo.glsl.vert ├── spv.debuginfo.hlsl.comp ├── spv.debuginfo.hlsl.frag ├── spv.debuginfo.hlsl.geom ├── spv.debuginfo.hlsl.tesc ├── spv.debuginfo.hlsl.tese ├── spv.debuginfo.hlsl.vert ├── spv.debuginfo.implicit_br.glsl.frag ├── spv.debuginfo.include.glsl.frag ├── spv.debuginfo.include.glsl.h ├── spv.debuginfo.multiline.glsl.frag ├── spv.debuginfo.non_ascii.glsl.frag ├── spv.debuginfo.rt_types.glsl.rgen ├── spv.debuginfo.scalar_types.glsl.frag ├── spv.deepRvalue.frag ├── spv.demoteDisabled.frag ├── spv.depthOut.frag ├── spv.depthUnchanged.frag ├── spv.deviceGroup.frag ├── spv.discard-dce.frag ├── spv.do-simple.vert ├── spv.do-while-continue-break.vert ├── spv.doWhileLoop.frag ├── spv.double.comp ├── spv.drawParams.vert ├── spv.earlyAndlateFragmentTests.frag ├── spv.earlyReturnDiscard.frag ├── spv.expect_assume.assumeEXT.comp ├── spv.expect_assume.expectEXT.comp ├── spv.expect_assume.expectEXT.exttypes.comp ├── spv.explicittypes.frag ├── spv.exportFunctions.comp ├── spv.ext.AccelDecl.frag ├── spv.ext.AnyHitShader.rahit ├── spv.ext.AnyHitShader_Errors.rahit ├── spv.ext.ClosestHitShader.rchit ├── spv.ext.ClosestHitShader_Errors.rchit ├── spv.ext.ClosestHitShader_Subgroup.rchit ├── spv.ext.IntersectShader.rint ├── spv.ext.IntersectShader_Errors.rint ├── spv.ext.MissShader.rmiss ├── spv.ext.MissShader_Errors.rmiss ├── spv.ext.RayCallable.rcall ├── spv.ext.RayCallable_Errors.rcall ├── spv.ext.RayConstants.rgen ├── spv.ext.RayGenSBTlayout.rgen ├── spv.ext.RayGenSBTlayout140.rgen ├── spv.ext.RayGenSBTlayout430.rgen ├── spv.ext.RayGenSBTlayoutscalar.rgen ├── spv.ext.RayGenShader.rgen ├── spv.ext.RayGenShader11.rgen ├── spv.ext.RayGenShaderArray.rgen ├── spv.ext.RayGenShader_Errors.rgen ├── spv.ext.RayPrimCull_Errors.rgen ├── spv.ext.RayQueryDecl.frag ├── spv.ext.ShaderTileImage.color.frag ├── spv.ext.ShaderTileImage.depth_stencil.frag ├── spv.ext.ShaderTileImage.overlap.frag ├── spv.ext.ShaderTileImage.subpassinput.frag ├── spv.ext.ShaderTileImage.typemismatch.frag ├── spv.ext.ShaderTileImage.wronglayout.frag ├── spv.ext.World3x4.rahit ├── spv.ext.meshShaderBuiltins.mesh ├── spv.ext.meshShaderBuiltinsShadingRate.mesh ├── spv.ext.meshShaderRedeclBuiltins.mesh ├── spv.ext.meshShaderTaskMem.mesh ├── spv.ext.meshShaderUserDefined.mesh ├── spv.ext.meshTaskShader.task ├── spv.ext.textureShadowLod.error.frag ├── spv.ext.textureShadowLod.frag ├── spv.extPostDepthCoverage.frag ├── spv.extPostDepthCoverage_Error.frag ├── spv.float16.frag ├── spv.float16Fetch.frag ├── spv.float16NoRelaxed.vert ├── spv.float16convertonlyarith.comp ├── spv.float16convertonlystorage.comp ├── spv.float32.frag ├── spv.float64.frag ├── spv.floatFetch.frag ├── spv.flowControl.frag ├── spv.for-complex-condition.vert ├── spv.for-continue-break.vert ├── spv.for-nobody.vert ├── spv.for-notest.vert ├── spv.for-simple.vert ├── spv.forLoop.frag ├── spv.forwardFun.frag ├── spv.fragmentDensity-es.frag ├── spv.fragmentDensity-neg.frag ├── spv.fragmentDensity.frag ├── spv.fragmentDensity.vert ├── spv.fragmentShaderBarycentric.frag ├── spv.fragmentShaderBarycentric2.frag ├── spv.fragmentShaderBarycentric3.frag ├── spv.fragmentShaderBarycentric4.frag ├── spv.fsi.frag ├── spv.fsi_Error.frag ├── spv.fullyCovered.frag ├── spv.funcall.array.frag ├── spv.functionCall.frag ├── spv.functionNestedOpaque.vert ├── spv.functionParameterTypes.frag ├── spv.functionSemantics.frag ├── spv.glFragColor.frag ├── spv.glsl.register.autoassign.frag ├── spv.glsl.register.noautoassign.frag ├── spv.hlslDebugInfo.vert ├── spv.hlslOffsets.vert ├── spv.image.frag ├── spv.image.load-formatted.frag ├── spv.imageAtomic64.comp ├── spv.imageAtomic64.frag ├── spv.imageLoadStoreLod.frag ├── spv.int16.amd.frag ├── spv.int16.frag ├── spv.int32.frag ├── spv.int64.frag ├── spv.int8.frag ├── spv.intOps.vert ├── spv.int_dot.frag ├── spv.int_dot_Error.frag ├── spv.intcoopmat.comp ├── spv.interpOps.frag ├── spv.intrinsicsDebugBreak.frag ├── spv.intrinsicsFakeEnable.vert ├── spv.intrinsicsInteractWithCoopMat.comp ├── spv.intrinsicsSpirvByReference.vert ├── spv.intrinsicsSpirvDecorate.frag ├── spv.intrinsicsSpirvDecorateId.comp ├── spv.intrinsicsSpirvDecorateString.comp ├── spv.intrinsicsSpirvExecutionMode.frag ├── spv.intrinsicsSpirvInstruction.vert ├── spv.intrinsicsSpirvLiteral.vert ├── spv.intrinsicsSpirvStorageClass.rchit ├── spv.intrinsicsSpirvType.rgen ├── spv.intrinsicsSpirvTypeLocalVar.vert ├── spv.intrinsicsSpirvTypeWithTypeSpecifier.vert ├── spv.invariantAll.vert ├── spv.layer.tese ├── spv.layoutNested.vert ├── spv.length.frag ├── spv.load.bool.array.interface.block.frag ├── spv.localAggregates.frag ├── spv.loops.frag ├── spv.loopsArtificial.frag ├── spv.looseUniformNoLoc.vert ├── spv.matFun.vert ├── spv.matrix.frag ├── spv.matrix2.frag ├── spv.maximalReconvergence.vert ├── spv.memoryQualifier.frag ├── spv.memoryScopeSemantics.comp ├── spv.memoryScopeSemantics_Error.comp ├── spv.merge-unreachable.frag ├── spv.meshShaderBuiltins.mesh ├── spv.meshShaderPerViewBuiltins.mesh ├── spv.meshShaderPerViewUserDefined.mesh ├── spv.meshShaderPerView_Errors.mesh ├── spv.meshShaderRedeclBuiltins.mesh ├── spv.meshShaderRedeclPerViewBuiltins.mesh ├── spv.meshShaderSharedMem.mesh ├── spv.meshShaderTaskMem.mesh ├── spv.meshShaderUserDefined.mesh ├── spv.meshTaskShader.task ├── spv.multiStruct.comp ├── spv.multiStructFuncall.frag ├── spv.multiView.frag ├── spv.multiple.var.same.const.frag ├── spv.multiviewPerViewAttributes.tesc ├── spv.multiviewPerViewAttributes.vert ├── spv.newTexture.frag ├── spv.noBuiltInLoc.vert ├── spv.noDeadDecorations.vert ├── spv.noLocation.vert ├── spv.noWorkgroup.comp ├── spv.noexplicitlayout.comp ├── spv.nonSquare.vert ├── spv.nontemporalbuffer.frag ├── spv.nonuniform.frag ├── spv.nonuniform2.frag ├── spv.nonuniform3.frag ├── spv.nonuniform4.frag ├── spv.nonuniform5.frag ├── spv.nullInit.comp ├── spv.nv.cluster-allops.frag ├── spv.nv.cluster-allops.rahit ├── spv.nv.cluster-allops.rchit ├── spv.nv.cluster-allops.rgen ├── spv.nv.cluster-allops.rmiss ├── spv.nv.dmm-allops.comp ├── spv.nv.dmm-allops.mesh ├── spv.nv.dmm-allops.rahit ├── spv.nv.dmm-allops.rchit ├── spv.nv.dmm-allops.rgen ├── spv.nv.hitobject-allops.rchit ├── spv.nv.hitobject-allops.rgen ├── spv.nv.hitobject-allops.rmiss ├── spv.nv.hitobject-errors.rgen ├── spv.nv.lss-allops.frag ├── spv.nv.lss-allops.rchit ├── spv.nv.lss-allops.rgen ├── spv.nv.lss-allops.rmiss ├── spv.nvAtomicFp16Vec.frag ├── spv.nvgpushader5.frag ├── spv.offsets.frag ├── spv.paramMemory.420.frag ├── spv.paramMemory.frag ├── spv.perprimitiveNV.frag ├── spv.pp.line.frag ├── spv.precise.tesc ├── spv.precise.tese ├── spv.precision.frag ├── spv.precisionArgs.frag ├── spv.precisionNonESSamp.frag ├── spv.precisionTexture.frag ├── spv.prepost.frag ├── spv.privateVariableTypes.frag ├── spv.pushConstant.vert ├── spv.pushConstantAnon.vert ├── spv.qualifiers.vert ├── spv.queryL.frag ├── spv.queueFamilyScope.comp ├── spv.rankShift.comp ├── spv.register.autoassign-2.frag ├── spv.register.autoassign.frag ├── spv.register.autoassign.rangetest.frag ├── spv.register.noautoassign.frag ├── spv.register.subpass.frag ├── spv.replicate.comp ├── spv.replicatespec.comp ├── spv.rw.autoassign.frag ├── spv.sample.frag ├── spv.sampleId.frag ├── spv.sampleMaskOverrideCoverage.frag ├── spv.samplePosition.frag ├── spv.sampledImageBlock.frag ├── spv.samplerlessTextureFunctions.frag ├── spv.scalarlayout.frag ├── spv.scalarlayoutfloat16.frag ├── spv.separate.frag ├── spv.set.vert ├── spv.shaderBallot.comp ├── spv.shaderBallotAMD.comp ├── spv.shaderDrawParams.vert ├── spv.shaderFragMaskAMD.frag ├── spv.shaderGroupVote.comp ├── spv.shaderImageFootprint.frag ├── spv.shaderStencilExport.frag ├── spv.shadingRate.frag ├── spv.shiftOps.frag ├── spv.shortCircuit.frag ├── spv.simpleFunctionCall.frag ├── spv.simpleMat.vert ├── spv.smBuiltins.frag ├── spv.smBuiltins.vert ├── spv.sparseTexture.frag ├── spv.sparseTextureClamp.frag ├── spv.sparsetextureoffset_non_const.vert ├── spv.sparsetextureoffset_non_const_fail.vert ├── spv.specConst.vert ├── spv.specConstArrayCheck.vert ├── spv.specConstant.comp ├── spv.specConstant.float16.comp ├── spv.specConstant.int16.comp ├── spv.specConstant.int8.comp ├── spv.specConstant.vert ├── spv.specConstantComposite.vert ├── spv.specConstantComposite2.vert ├── spv.specConstantOp.float16.comp ├── spv.specConstantOp.int16.comp ├── spv.specConstantOp.int8.comp ├── spv.specConstantOperations.vert ├── spv.specTexture.frag ├── spv.ssbo.autoassign.frag ├── spv.ssboAlias.frag ├── spv.stereoViewRendering.tesc ├── spv.stereoViewRendering.vert ├── spv.storageBuffer.vert ├── spv.structAssignment.frag ├── spv.structCopy.comp ├── spv.structDeref.frag ├── spv.structure.frag ├── spv.subgroup.frag ├── spv.subgroup.geom ├── spv.subgroup.tesc ├── spv.subgroup.tese ├── spv.subgroup.vert ├── spv.subgroupArithmetic.comp ├── spv.subgroupBallot.comp ├── spv.subgroupBallotNeg.comp ├── spv.subgroupBasic.comp ├── spv.subgroupClustered.comp ├── spv.subgroupClusteredNeg.comp ├── spv.subgroupExtendedTypesArithmetic.comp ├── spv.subgroupExtendedTypesArithmeticNeg.comp ├── spv.subgroupExtendedTypesBallot.comp ├── spv.subgroupExtendedTypesBallotNeg.comp ├── spv.subgroupExtendedTypesClustered.comp ├── spv.subgroupExtendedTypesClusteredNeg.comp ├── spv.subgroupExtendedTypesPartitioned.comp ├── spv.subgroupExtendedTypesPartitionedNeg.comp ├── spv.subgroupExtendedTypesQuad.comp ├── spv.subgroupExtendedTypesQuadNeg.comp ├── spv.subgroupExtendedTypesRotate.comp ├── spv.subgroupExtendedTypesRotateNeg.comp ├── spv.subgroupExtendedTypesShuffle.comp ├── spv.subgroupExtendedTypesShuffleNeg.comp ├── spv.subgroupExtendedTypesShuffleRelative.comp ├── spv.subgroupExtendedTypesShuffleRelativeNeg.comp ├── spv.subgroupExtendedTypesVote.comp ├── spv.subgroupExtendedTypesVoteNeg.comp ├── spv.subgroupPartitioned.comp ├── spv.subgroupQuad.comp ├── spv.subgroupRotate.comp ├── spv.subgroupShuffle.comp ├── spv.subgroupShuffleRelative.comp ├── spv.subgroupSizeARB.frag ├── spv.subgroupUniformControlFlow.vert ├── spv.subgroupVote.comp ├── spv.subpass.frag ├── spv.switch.frag ├── spv.swizzle.frag ├── spv.swizzleInversion.frag ├── spv.targetOpenGL.vert ├── spv.targetVulkan.vert ├── spv.terminate.frag ├── spv.test.frag ├── spv.test.vert ├── spv.texture.frag ├── spv.texture.sampler.transform.frag ├── spv.texture.vert ├── spv.textureBuffer.vert ├── spv.textureError.frag ├── spv.textureGatherBiasLod.frag ├── spv.textureoffset_non_const.vert ├── spv.tpipBlockMatchGatherSAD.frag ├── spv.tpipBlockMatchGatherSSD.frag ├── spv.tpipBlockMatchSAD.frag ├── spv.tpipBlockMatchSSD.frag ├── spv.tpipBlockMatchWindowSAD.frag ├── spv.tpipBlockMatchWindowSSD.frag ├── spv.tpipBoxFilter.frag ├── spv.tpipSampleWeighted.frag ├── spv.tpipTextureArrays.frag ├── spv.types.frag ├── spv.uint.frag ├── spv.uniformArray.frag ├── spv.uniformInitializer.frag ├── spv.uniformInitializerSpecConstant.frag ├── spv.uniformInitializerStruct.frag ├── spv.unit1.frag ├── spv.unit2.frag ├── spv.unit3.frag ├── spv.variableArrayIndex.frag ├── spv.varyingArray.frag ├── spv.varyingArrayIndirect.frag ├── spv.vecMatConstruct.frag ├── spv.viewportArray2.tesc ├── spv.viewportArray2.vert ├── spv.viewportindex.tese ├── spv.voidFunction.frag ├── spv.volatileAtomic.comp ├── spv.vulkan100.subgroupArithmetic.comp ├── spv.vulkan100.subgroupPartitioned.comp ├── spv.vulkan110.int16.frag ├── spv.vulkan110.storageBuffer.vert ├── spv.while-continue-break.vert ├── spv.while-simple.vert ├── spv.whileLoop.frag ├── spv.xfb.vert ├── spv.xfb2.vert ├── spv.xfb3.vert ├── spv.xfbOffsetOnBlockMembersAssignment.vert ├── spv.xfbOffsetOnStructMembersAssignment.vert ├── spv.xfbOverlapOffsetCheckWithBlockAndMember.vert ├── spv.xfbStrideJustOnce.vert ├── stringToDouble.vert ├── struct.error.frag ├── structAssignment.frag ├── structDeref.frag ├── structure.frag ├── switch.frag ├── swizzle.frag ├── syntaxError.frag ├── terminate.frag ├── terminate.vert ├── tes_patch.tese ├── test.frag ├── texture.frag ├── textureQueryLOD.frag ├── textureoffset_sampler2darrayshadow.vert ├── tokenLength.vert ├── tokenPaste.vert ├── types.frag ├── uint.frag ├── uniformArray.frag ├── validate-shaders.sh ├── variableArrayIndex.frag ├── varyingArray.frag ├── varyingArrayIndirect.frag ├── versionsClean.frag ├── versionsClean.vert ├── versionsErrors.frag ├── versionsErrors.vert ├── vk.relaxed.changeSet.frag ├── vk.relaxed.changeSet.vert ├── vk.relaxed.errorcheck.frag ├── vk.relaxed.errorcheck.vert ├── vk.relaxed.frag ├── vk.relaxed.link1.frag ├── vk.relaxed.link2.frag ├── vk.relaxed.stagelink.0.0.frag ├── vk.relaxed.stagelink.0.0.vert ├── vk.relaxed.stagelink.0.1.frag ├── vk.relaxed.stagelink.0.1.vert ├── vk.relaxed.stagelink.0.2.frag ├── vk.relaxed.stagelink.0.2.vert ├── vk.relaxed.stagelink.frag ├── vk.relaxed.stagelink.vert ├── voidFunction.frag ├── vulkan.ast.vert ├── vulkan.comp ├── vulkan.frag ├── vulkan.vert ├── web.array.frag ├── web.basic.vert ├── web.builtins.frag ├── web.builtins.vert ├── web.comp ├── web.controlFlow.frag ├── web.operations.frag ├── web.runtests ├── web.separate.frag ├── web.testlist ├── web.texture.frag ├── whileLoop.frag ├── xfbUnsizedArray.error.tese └── xfbUnsizedArray.error.vert ├── _config.yml ├── build_info.h.tmpl ├── build_info.py ├── build_overrides ├── build.gni ├── glslang.gni └── spirv_tools.gni ├── gen_extension_headers.py ├── glslang ├── CInterface │ └── glslang_c_interface.cpp ├── CMakeLists.txt ├── ExtensionHeaders │ └── GL_EXT_shader_realtime_clock.glsl ├── GenericCodeGen │ ├── CodeGen.cpp │ └── Link.cpp ├── HLSL │ ├── hlslAttributes.cpp │ ├── hlslAttributes.h │ ├── hlslGrammar.cpp │ ├── hlslGrammar.h │ ├── hlslOpMap.cpp │ ├── hlslOpMap.h │ ├── hlslParseHelper.cpp │ ├── hlslParseHelper.h │ ├── hlslParseables.cpp │ ├── hlslParseables.h │ ├── hlslScanContext.cpp │ ├── hlslScanContext.h │ ├── hlslTokenStream.cpp │ ├── hlslTokenStream.h │ ├── hlslTokens.h │ └── pch.h ├── Include │ ├── BaseTypes.h │ ├── Common.h │ ├── ConstantUnion.h │ ├── InfoSink.h │ ├── InitializeGlobals.h │ ├── PoolAlloc.h │ ├── ResourceLimits.h │ ├── ShHandle.h │ ├── SpirvIntrinsics.h │ ├── Types.h │ ├── arrays.h │ ├── glslang_c_interface.h │ ├── glslang_c_shader_types.h │ ├── intermediate.h │ └── visibility.h ├── MachineIndependent │ ├── Constant.cpp │ ├── InfoSink.cpp │ ├── Initialize.cpp │ ├── Initialize.h │ ├── IntermTraverse.cpp │ ├── Intermediate.cpp │ ├── LiveTraverser.h │ ├── ParseContextBase.cpp │ ├── ParseHelper.cpp │ ├── ParseHelper.h │ ├── PoolAlloc.cpp │ ├── RemoveTree.cpp │ ├── RemoveTree.h │ ├── Scan.cpp │ ├── Scan.h │ ├── ScanContext.h │ ├── ShaderLang.cpp │ ├── SpirvIntrinsics.cpp │ ├── SymbolTable.cpp │ ├── SymbolTable.h │ ├── Versions.cpp │ ├── Versions.h │ ├── attribute.cpp │ ├── attribute.h │ ├── gl_types.h │ ├── glslang.y │ ├── glslang_tab.cpp │ ├── glslang_tab.cpp.h │ ├── intermOut.cpp │ ├── iomapper.cpp │ ├── iomapper.h │ ├── limits.cpp │ ├── linkValidate.cpp │ ├── localintermediate.h │ ├── parseConst.cpp │ ├── parseVersions.h │ ├── pch.h │ ├── preprocessor │ │ ├── Pp.cpp │ │ ├── PpAtom.cpp │ │ ├── PpContext.cpp │ │ ├── PpContext.h │ │ ├── PpScanner.cpp │ │ ├── PpTokens.cpp │ │ └── PpTokens.h │ ├── propagateNoContraction.cpp │ ├── propagateNoContraction.h │ ├── reflection.cpp │ ├── reflection.h │ └── span.h ├── OSDependent │ ├── Unix │ │ ├── CMakeLists.txt │ │ └── ossource.cpp │ ├── Web │ │ ├── CMakeLists.txt │ │ ├── glslang.after.js │ │ ├── glslang.js.cpp │ │ └── glslang.pre.js │ ├── Windows │ │ ├── CMakeLists.txt │ │ └── ossource.cpp │ └── osinclude.h ├── Public │ ├── ResourceLimits.h │ ├── ShaderLang.h │ └── resource_limits_c.h ├── ResourceLimits │ ├── ResourceLimits.cpp │ └── resource_limits_c.cpp ├── stub.cpp └── updateGrammar ├── gtests ├── AST.FromFile.cpp ├── BuiltInResource.FromFile.cpp ├── CMakeLists.txt ├── Common.cpp ├── Config.FromFile.cpp ├── GlslMapIO.FromFile.cpp ├── HexFloat.cpp ├── Hlsl.FromFile.cpp ├── Initializer.h ├── Link.FromFile.Vk.cpp ├── Link.FromFile.cpp ├── LiveTraverser.FromFile.cpp ├── Pp.FromFile.cpp ├── README.md ├── Remap.FromFile.cpp ├── Settings.cpp ├── Settings.h ├── Spv.FromFile.cpp ├── TestFixture.cpp ├── TestFixture.h ├── VkRelaxed.FromFile.cpp ├── main.cpp └── pch.h ├── known_good.json ├── known_good_khr.json ├── kokoro ├── android-ndk-build │ ├── build-docker.sh │ ├── build.sh │ ├── continuous.cfg │ └── presubmit.cfg ├── license-check │ ├── build.sh │ ├── continuous.cfg │ └── presubmit.cfg ├── linux-clang-cmake │ ├── build-docker.sh │ ├── build.sh │ ├── shared │ │ ├── continuous.cfg │ │ └── presubmit.cfg │ └── static │ │ ├── continuous.cfg │ │ └── presubmit.cfg ├── linux-clang-gn │ ├── build-docker.sh │ ├── build.sh │ ├── continuous.cfg │ └── presubmit.cfg └── linux-gcc-cmake │ ├── build-docker.sh │ ├── build.sh │ ├── shared │ ├── continuous.cfg │ └── presubmit.cfg │ └── static │ ├── continuous.cfg │ └── presubmit.cfg ├── license-checker.cfg ├── ndk_test ├── Android.mk ├── jni │ └── Application.mk └── test.cpp ├── parse_version.cmake ├── standalone.gclient └── update_glslang_sources.py /.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | *.a 3 | *.so 4 | *.exe 5 | .cache/ 6 | .vscode/ 7 | .vs/ 8 | tags 9 | TAGS 10 | bazel-* 11 | build/ 12 | Test/localResults/ 13 | External/googletest 14 | External/spirv-tools 15 | out/ 16 | CMakeUserPresets.json 17 | 18 | # GN generated files 19 | .cipd/ 20 | *.gclient_entries 21 | third_party/ 22 | buildtools/ 23 | tools/ 24 | 25 | # Random OS stuff 26 | .DS_Store 27 | ._* 28 | -------------------------------------------------------------------------------- /.mailmap: -------------------------------------------------------------------------------- 1 | Faith Ekstrand 2 | Faith Ekstrand 3 | Faith Ekstrand 4 | -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | A reminder that this issue tracker is managed by the Khronos Group. Interactions here should follow the Khronos Code of Conduct (https://www.khronos.org/developers/code-of-conduct), which prohibits aggressive or derogatory language. Please keep the discussion friendly and civil. 2 | -------------------------------------------------------------------------------- /SECURITY.md: -------------------------------------------------------------------------------- 1 | # Security Policy 2 | 3 | To report a security issue, please disclose it at [security advisory](https://github.com/KhronosGroup/glslang/security/advisories/new). 4 | 5 | This project is maintained by a team of volunteers on a reasonable-effort basis. As 6 | such, please give us at least 90 days to work on a fix before public exposure. 7 | -------------------------------------------------------------------------------- /Test/300link.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | precision highp float; 4 | 5 | out vec4 color1; 6 | out vec4 color2; 7 | 8 | void main() {} 9 | -------------------------------------------------------------------------------- /Test/300link2.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | precision mediump float; 3 | in vec4 pos; 4 | 5 | layout(location = 1) out vec4 c; 6 | layout(location = 5) out vec4 p; 7 | layout(location = 9) out vec4 q[2]; 8 | 9 | void main() 10 | { 11 | } 12 | -------------------------------------------------------------------------------- /Test/300link3.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | precision highp float; 4 | 5 | out vec4 color1; 6 | 7 | void main() {} 8 | -------------------------------------------------------------------------------- /Test/310implicitSizeArrayError.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | layout (binding=0) uniform Block { 3 | highp int a[]; 4 | } uni; 5 | layout (location=0) out highp int o; 6 | void main() { 7 | o = uni.a[2]; 8 | } 9 | -------------------------------------------------------------------------------- /Test/310runtimeArray.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | precision highp float; 4 | layout(location=0) out float o; 5 | 6 | struct S { float f; }; 7 | buffer b1 { S s[]; }; 8 | buffer b2 { S s[]; } b2name; 9 | buffer b3 { S s[]; } b3name[]; 10 | buffer b4 { S s[]; } b4name[4]; 11 | 12 | void main() 13 | { 14 | o = s[5].f; 15 | o += b2name.s[6].f; 16 | o += b3name[3].s[7].f; 17 | o += b4name[2].s[8].f; 18 | } 19 | -------------------------------------------------------------------------------- /Test/320.comp: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | 3 | float fX; 4 | float fY; 5 | 6 | void main() 7 | { 8 | dFdx(fX); 9 | dFdy(fY); 10 | fwidth(fX); 11 | dFdxCoarse(fX); 12 | dFdyCoarse(fY); 13 | fwidthCoarse(fX); 14 | dFdxFine(fX); 15 | dFdyFine(fY); 16 | fwidthFine(fX); 17 | } 18 | -------------------------------------------------------------------------------- /Test/330comp.frag: -------------------------------------------------------------------------------- 1 | #version 330 compatibility 2 | 3 | in vec4 inVar; 4 | out vec4 outVar; 5 | 6 | varying vec4 varyingVar; 7 | 8 | void main() 9 | { 10 | gl_FragColor = varyingVar; 11 | gl_FragData[1] = inVar * gl_ModelViewMatrix; 12 | } 13 | -------------------------------------------------------------------------------- /Test/410.tesc: -------------------------------------------------------------------------------- 1 | #version 400 core 2 | 3 | // no layout(vertices = ...) out; 4 | int outa[gl_out.length()]; // ERROR 5 | 6 | patch out vec4 patchOut; 7 | 8 | void main() 9 | { 10 | 11 | } 12 | -------------------------------------------------------------------------------- /Test/410.vert: -------------------------------------------------------------------------------- 1 | #version 410 core 2 | 3 | in double d; 4 | in dvec3 d3; 5 | in dmat4 dm4; 6 | 7 | void main() 8 | { 9 | int test = gl_MaxFragmentUniformVectors; 10 | } 11 | -------------------------------------------------------------------------------- /Test/435.vert: -------------------------------------------------------------------------------- 1 | #version 435 2 | void main() {} -------------------------------------------------------------------------------- /Test/450.comp: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | layout(local_size_x = 0) in; // ERROR, 0 not allowed 3 | 4 | layout(binding=10000) uniform atomic_uint; // ERROR 5 | 6 | void main() 7 | { 8 | shared float f; // ERROR shared must be global 9 | } 10 | -------------------------------------------------------------------------------- /Test/460.vert: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | int i; 4 | ; // extraneous semicolon okay 5 | float f;;; 6 | 7 | void main() 8 | { 9 | bool b1; 10 | float array[int(mod(float (7.1), float (4.0)))]; 11 | b1 = anyInvocation(b1); 12 | b1 = allInvocations(b1); 13 | b1 = allInvocationsEqual(b1); 14 | } 15 | ; 16 | ; 17 | -------------------------------------------------------------------------------- /Test/GL_ARB_gpu_shader5.u2i.vert: -------------------------------------------------------------------------------- 1 | #version 150 2 | #extension GL_ARB_gpu_shader5 : require 3 | 4 | uniform int u1; 5 | uniform int u2; 6 | out vec4 result; 7 | void main() 8 | { 9 | uint v = 0; 10 | v = uint(u2) - u1; // implicit conversions 11 | } 12 | -------------------------------------------------------------------------------- /Test/GL_EXT_shader_integer_mix.vert: -------------------------------------------------------------------------------- 1 | #version 330 2 | #extension GL_EXT_shader_integer_mix: require 3 | 4 | 5 | #if !defined GL_EXT_shader_integer_mix 6 | # error GL_EXT_shader_integer_mix is not defined 7 | #elif GL_EXT_shader_integer_mix != 1 8 | # error GL_EXT_shader_integer_mix is not equal to 1 9 | #endif 10 | 11 | void main(void) { 12 | gl_Position = vec4(0); 13 | } 14 | -------------------------------------------------------------------------------- /Test/UTF8BOM.vert: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | glslangValidator.exe --glsl-version 410 -V -S vert -o UTF8BOM.vert.out UTF8BOM.vert 4 | 5 | */ 6 | 7 | #version 110 8 | 9 | void main() 10 | { 11 | } 12 | -------------------------------------------------------------------------------- /Test/always-discard2.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | varying vec2 tex_coord; 3 | 4 | void main (void) 5 | { 6 | vec4 white = vec4(1.0); 7 | vec4 black = vec4(0.2); 8 | vec4 color = white; 9 | 10 | // First, cut out our circle 11 | float x = tex_coord.x*2.0 - 1.0; 12 | float y = tex_coord.y*2.0 - 1.0; 13 | 14 | discard; 15 | 16 | 17 | gl_FragColor = color; 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Test/atomicAdd.comp: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | layout(local_size_x = 1) in; 3 | 4 | struct structType{ 5 | int y[3]; 6 | }; 7 | 8 | layout(std430) buffer t2 { 9 | structType f; 10 | } t; 11 | 12 | buffer coherent Buffer { int x; }; 13 | int z; 14 | 15 | void main() { 16 | atomicAdd(x, 1); 17 | atomicAdd(t.f.y[1], 1); 18 | atomicAdd(z, 1); 19 | } -------------------------------------------------------------------------------- /Test/badChars.frag: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/badChars.frag -------------------------------------------------------------------------------- /Test/badMacroArgs.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | #define m(a) a 4 | m() -------------------------------------------------------------------------------- /Test/bar.h: -------------------------------------------------------------------------------- 1 | float4 i1; 2 | -------------------------------------------------------------------------------- /Test/baseResults/UTF8BOM.vert.out: -------------------------------------------------------------------------------- 1 | UTF8BOM.vert 2 | -------------------------------------------------------------------------------- /Test/baseResults/badChars.frag.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/badChars.frag.out -------------------------------------------------------------------------------- /Test/baseResults/badMacroArgs.frag.out: -------------------------------------------------------------------------------- 1 | badMacroArgs.frag 2 | ERROR: 0:4: 'macro expansion' : Too few args in Macro m 3 | ERROR: 0:4: '' : compilation terminated 4 | ERROR: 2 compilation errors. No code generated. 5 | 6 | 7 | -------------------------------------------------------------------------------- /Test/baseResults/cppIntMinOverNegativeOne.frag.out: -------------------------------------------------------------------------------- 1 | cppIntMinOverNegativeOne.frag 2 | Shader version: 100 3 | 0:? Sequence 4 | 0:? Linker Objects 5 | 6 | 7 | Linked fragment stage: 8 | 9 | ERROR: Linking fragment stage: Missing entry point: Each stage requires one entry point 10 | 11 | Shader version: 100 12 | 0:? Sequence 13 | 0:? Linker Objects 14 | 15 | -------------------------------------------------------------------------------- /Test/baseResults/cppRelaxSkipTokensErrors.vert.out: -------------------------------------------------------------------------------- 1 | cppRelaxSkipTokensErrors.vert 2 | Shader version: 110 3 | 0:? Sequence 4 | 0:? Linker Objects 5 | 6 | 7 | Linked vertex stage: 8 | 9 | ERROR: Linking vertex stage: Missing entry point: Each stage requires one entry point 10 | 11 | Shader version: 110 12 | 0:? Sequence 13 | 0:? Linker Objects 14 | 15 | -------------------------------------------------------------------------------- /Test/baseResults/empty.frag.out: -------------------------------------------------------------------------------- 1 | empty.frag 2 | Shader version: 100 3 | 0:? Sequence 4 | 0:? Linker Objects 5 | 6 | empty2.frag 7 | Shader version: 100 8 | 0:? Sequence 9 | 0:? Linker Objects 10 | 11 | empty3.frag 12 | Shader version: 110 13 | 0:? Sequence 14 | 0:? Linker Objects 15 | 16 | ERROR: Cannot mix ES profile with non-ES profile shaders 17 | 18 | -------------------------------------------------------------------------------- /Test/baseResults/enhanced.0.frag.out: -------------------------------------------------------------------------------- 1 | enhanced.0.frag 2 | ERROR: enhanced.0.frag:7: ' vec4 constructor' : not enough data provided for construction 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/enhanced.1.frag.out: -------------------------------------------------------------------------------- 1 | enhanced.1.frag 2 | ERROR: enhanced.1.frag:9: 'v2' : no such field in structure 'vVert' 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/enhanced.2.frag.out: -------------------------------------------------------------------------------- 1 | enhanced.2.frag 2 | ERROR: enhanced.2.frag:5: ' vec3 constructor' : too many arguments 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/enhanced.3.link.out: -------------------------------------------------------------------------------- 1 | enhanced.3.vert 2 | enhanced.3.frag 3 | ERROR: Linking vertex and fragment stages: Member names and types must match: 4 | Block: VS_OUT 5 | vertex stage: " vec2 TexCoords" 6 | fragment stage: " vec2 foobar" 7 | 8 | SPIR-V is not generated for failed compile or link 9 | -------------------------------------------------------------------------------- /Test/baseResults/enhanced.4.link.out: -------------------------------------------------------------------------------- 1 | enhanced.4.vert 2 | enhanced.4.frag 3 | ERROR: Linking vertex and fragment stages: Layout location qualifier must match: 4 | vertex stage: Block: VS_OUT Instance: vs_out: "layout( location=0) out" 5 | fragment stage: Block: VS_OUT Instance: fs_in: "layout( location=1) in" 6 | 7 | SPIR-V is not generated for failed compile or link 8 | -------------------------------------------------------------------------------- /Test/baseResults/enhanced.5.link.out: -------------------------------------------------------------------------------- 1 | enhanced.5.vert 2 | enhanced.5.frag 3 | ERROR: Linking vertex and fragment stages: Member names and types must match: 4 | Block: VS_OUT 5 | vertex stage: " vec2 TexCoords" 6 | fragment stage: " vec3 TexCoords" 7 | 8 | SPIR-V is not generated for failed compile or link 9 | -------------------------------------------------------------------------------- /Test/baseResults/enhanced.6.link.out: -------------------------------------------------------------------------------- 1 | enhanced.6.vert 2 | enhanced.6.frag 3 | ERROR: Linking vertex and fragment stages: Array sizes must be compatible: 4 | vertex stage: " VS_OUT{ vec2 TexCoords} vs_out[2]" 5 | fragment stage: " VS_OUT{ vec2 TexCoords} fs_in[1]" 6 | 7 | SPIR-V is not generated for failed compile or link 8 | -------------------------------------------------------------------------------- /Test/baseResults/enhanced.7.link.out: -------------------------------------------------------------------------------- 1 | enhanced.7.vert 2 | enhanced.7.frag 3 | ERROR: Linking vertex and fragment stages: vertex block member has no corresponding member in fragment block: 4 | vertex stage: Block: Vertex, Member: ii 5 | fragment stage: Block: Vertex, Member: n/a 6 | 7 | SPIR-V is not generated for failed compile or link 8 | -------------------------------------------------------------------------------- /Test/baseResults/glsl.entryPointRename2.vert.out: -------------------------------------------------------------------------------- 1 | glsl.entryPointRename2.vert 2 | ERROR: Linking vertex stage: Missing entry point: Each stage requires one entry point 3 | 4 | SPIR-V is not generated for failed compile or link 5 | -------------------------------------------------------------------------------- /Test/baseResults/glsl.versionOverride.comp.out: -------------------------------------------------------------------------------- 1 | glsl.versionOverride.comp 2 | -------------------------------------------------------------------------------- /Test/baseResults/glsl.versionOverride.frag.out: -------------------------------------------------------------------------------- 1 | glsl.versionOverride.frag 2 | -------------------------------------------------------------------------------- /Test/baseResults/glsl.versionOverride.geom.out: -------------------------------------------------------------------------------- 1 | glsl.versionOverride.geom 2 | -------------------------------------------------------------------------------- /Test/baseResults/glsl.versionOverride.tesc.out: -------------------------------------------------------------------------------- 1 | glsl.versionOverride.tesc 2 | -------------------------------------------------------------------------------- /Test/baseResults/glsl.versionOverride.tese.out: -------------------------------------------------------------------------------- 1 | glsl.versionOverride.tese 2 | -------------------------------------------------------------------------------- /Test/baseResults/glsl.versionOverride.vert.out: -------------------------------------------------------------------------------- 1 | glsl.versionOverride.vert 2 | -------------------------------------------------------------------------------- /Test/baseResults/glspv.version.vert.out: -------------------------------------------------------------------------------- 1 | glspv.version.vert 2 | ERROR: #version: Desktop shaders for OpenGL SPIR-V require version 330 or higher 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/hlsl.dashI.vert.d.out: -------------------------------------------------------------------------------- 1 | vert.spv: hlsl.dashI.vert ./bar.h ./parent.h inc1/path1/local.h inc1/path1/notHere.h inc1/path2/remote.h 2 | -------------------------------------------------------------------------------- /Test/baseResults/hlsl.include.vert.d.out: -------------------------------------------------------------------------------- 1 | vert.spv: ../Test/hlsl.include.vert ../Test/./inc1/bar.h ../Test/./inc1/foo.h ../Test/bar.h ../Test/inc2/bar.h ../Test/inc2/foo.h ../Test/parent.h 2 | -------------------------------------------------------------------------------- /Test/baseResults/hlsl.pp.expand.frag.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/hlsl.pp.expand.frag.err -------------------------------------------------------------------------------- /Test/baseResults/hlsl.pp.expand.frag.out: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | struct A 8 | { 9 | float4 a; 10 | float4 b; 11 | float4 c = { 1, 2, 3, 4 }; 12 | float4 d = { ({ { ( ({ 1, 2, 3, 4 })) } }) }, { { 1, 2, 3, 4 } }; 13 | }; 14 | 15 | void main() 16 | { 17 | "a string" 18 | } 19 | 20 | -------------------------------------------------------------------------------- /Test/baseResults/preprocess.arb_shading_language_include.vert.err: -------------------------------------------------------------------------------- 1 | ERROR: 0:7: '#include' : Could not process include directive for header name: bar.h 2 | ERROR: 1 compilation errors. No code generated. 3 | 4 | 5 | -------------------------------------------------------------------------------- /Test/baseResults/preprocess.arb_shading_language_include.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocess.arb_shading_language_include.vert.out -------------------------------------------------------------------------------- /Test/baseResults/preprocess.inactive_stringify.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocess.inactive_stringify.vert.err -------------------------------------------------------------------------------- /Test/baseResults/preprocess.inactive_stringify.vert.out: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | void main() 26 | { 27 | gl_Position = vec4(1.0); 28 | } 29 | 30 | -------------------------------------------------------------------------------- /Test/baseResults/preprocess.include_directive_missing_extension.vert.err: -------------------------------------------------------------------------------- 1 | ERROR: 0:3: '#include' : required extension not requested: Possible extensions include: 2 | GL_GOOGLE_include_directive 3 | GL_ARB_shading_language_include 4 | ERROR: 0:3: '#include' : Could not process include directive for header name: bar.h 5 | ERROR: 2 compilation errors. No code generated. 6 | 7 | 8 | -------------------------------------------------------------------------------- /Test/baseResults/preprocess.include_directive_missing_extension.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocess.include_directive_missing_extension.vert.out -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.bad_arg.vert.err: -------------------------------------------------------------------------------- 1 | ERROR: 0:8: 'macro expansion' : End of input in macro EXP2 2 | ERROR: 1 compilation errors. No code generated. 3 | 4 | 5 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.bad_arg.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.bad_arg.vert.out -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.cpp_style___FILE__.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.cpp_style___FILE__.vert.err -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.cpp_style_line_directive.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.cpp_style_line_directive.vert.out -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.defined.vert.err: -------------------------------------------------------------------------------- 1 | ERROR: 0:2: '#define' : "defined" can't be (un)defined: defined 2 | ERROR: 1 compilation errors. No code generated. 3 | 4 | 5 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.defined.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.defined.vert.out -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.edge_cases.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.edge_cases.vert.err -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.edge_cases.vert.out: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | void main() { 14 | gl_Position = vec4(3 + 2 + 2 * 4 + 2 + 3 * 2); 15 | } 16 | 17 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.eof_missing.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.eof_missing.vert.err -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.eof_missing.vert.out: -------------------------------------------------------------------------------- 1 | noEOF 2 | 3 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.errors.vert.err: -------------------------------------------------------------------------------- 1 | ERROR: 0:9: '#error' : This should show up in pp output . 2 | ERROR: 0:14: '#' : invalid directive: def 3 | ERROR: 0:15: 'preprocessor evaluation' : undefined macro in expression not allowed in es profile Y 4 | ERROR: 0:21: '' : missing #endif 5 | ERROR: 4 compilation errors. No code generated. 6 | 7 | 8 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.errors.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.errors.vert.out -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.extensions.vert.err: -------------------------------------------------------------------------------- 1 | WARNING: 0:6: '#extension' : extension not supported: GL_EXT_shader_texture_image_samples 2 | 3 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.extensions.vert.out: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #extension GL_EXT_geometry_shader : enable 4 | #extension GL_EXT_frag_depth : disable 5 | #extension GL_EXT_gpu_shader5 : require 6 | #extension GL_EXT_shader_texture_image_samples : warn 7 | 8 | #extension unknown_extension : require 9 | 10 | int main() { 11 | } 12 | 13 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.function_macro.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.function_macro.vert.err -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.function_macro.vert.out: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | int main() { 19 | gl_Position = vec4(3 + 1, 3 + 4, 3 + 1); 20 | gl_Position = vec4(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12); 21 | gl_Position = vec4(4 + 3 + 3); 22 | gl_Position = 4 + 3 + F.a; 23 | } 24 | 25 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.include.disabled.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.include.disabled.vert.out -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.include.enabled.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.include.enabled.vert.out -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.line.frag.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.line.frag.err -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.line.frag.out: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | #line 1 2 3 | #pragma something 4 | void main() { } 5 | 6 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.line.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.line.vert.err -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.line.vert.out: -------------------------------------------------------------------------------- 1 | #line 300 2 | 3 | #line 2 4 | 5 | 6 | 7 | 8 | 9 | #line 10 10 | 11 | 12 | #line 2 13 | 14 | #line 0 15 | 16 | 17 | 18 | #line 4 19 | 20 | 21 | 22 | 23 | 24 | #line 8 25 | 26 | void main() { 27 | gl_Position = vec4(10); 28 | } 29 | 30 | #line 8 4 31 | 32 | 33 | 34 | 35 | #line 12 3 36 | 37 | #line 1 38 | 39 | 40 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.many.endif.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.many.endif.vert.out -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.pragma.vert.err: -------------------------------------------------------------------------------- 1 | WARNING: 0:10: '#pragma once' : not implemented 2 | 3 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.pragma.vert.out: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #pragma optimize(on) 4 | #pragma optimize(off) 5 | #pragma debug(on) 6 | #pragma debug(off) 7 | 8 | #pragma undefined_pragma(x,4) 9 | 10 | #pragma once 11 | 12 | int main() { 13 | } 14 | 15 | -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.simple.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.simple.vert.err -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.success_if_parse_would_fail.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/baseResults/preprocessor.success_if_parse_would_fail.vert.err -------------------------------------------------------------------------------- /Test/baseResults/preprocessor.success_if_parse_would_fail.vert.out: -------------------------------------------------------------------------------- 1 | int x() { 2 | something that shouldnt compile; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /Test/baseResults/rayQuery-initialization.Error.comp.out: -------------------------------------------------------------------------------- 1 | rayQuery-initialization.Error.comp 2 | ERROR: 0:7: '=' : ray queries can only be initialized by using the rayQueryInitializeEXT intrinsic: bar 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/reflection.frag.out: -------------------------------------------------------------------------------- 1 | reflection.frag 2 | Uniform reflection: 3 | 4 | Uniform block reflection: 5 | 6 | Buffer variable reflection: 7 | 8 | Buffer block reflection: 9 | 10 | Pipeline input reflection: 11 | 12 | Pipeline output reflection: 13 | 14 | -------------------------------------------------------------------------------- /Test/baseResults/reflection.options.frag.out: -------------------------------------------------------------------------------- 1 | reflection.frag 2 | Uniform reflection: 3 | 4 | Uniform block reflection: 5 | 6 | Buffer variable reflection: 7 | 8 | Buffer block reflection: 9 | 10 | Pipeline input reflection: 11 | inval: offset 0, type 1406, size 1, index 0, binding -1, stages 16 12 | 13 | Pipeline output reflection: 14 | 15 | -------------------------------------------------------------------------------- /Test/baseResults/remap.invalid-spirv-1.out: -------------------------------------------------------------------------------- 1 | ID out of range: 4160749568 2 | -------------------------------------------------------------------------------- /Test/baseResults/remap.invalid-spirv-2.out: -------------------------------------------------------------------------------- 1 | ID not found 2 | -------------------------------------------------------------------------------- /Test/baseResults/remap.literal64.everything.spv.out: -------------------------------------------------------------------------------- 1 | remap.literal64.everything.spv 2 | // Module Version 10100 3 | // Generated by (magic number): 70000 4 | // Id's are bound by 0 5 | 6 | Capability Shader 7 | MemoryModel Logical GLSL450 8 | -------------------------------------------------------------------------------- /Test/baseResults/size: -------------------------------------------------------------------------------- 1 | 399360 ../build/install/bin/glslang.exe 2 | -------------------------------------------------------------------------------- /Test/baseResults/spv.WorkgroupMemoryExplicitLayout.MixBlockNonBlock_Errors.comp.out: -------------------------------------------------------------------------------- 1 | spv.WorkgroupMemoryExplicitLayout.MixBlockNonBlock_Errors.comp 2 | ERROR: Linking compute stage: cannot mix use of shared variables inside and outside blocks 3 | 4 | SPIR-V is not generated for failed compile or link 5 | -------------------------------------------------------------------------------- /Test/baseResults/spv.arbPostDepthCoverage_Error.frag.out: -------------------------------------------------------------------------------- 1 | spv.arbPostDepthCoverage_Error.frag 2 | ERROR: 0:7: 'early_fragment_tests' : can only apply to a standalone qualifier 3 | ERROR: 0:7: 'post_depth_coverage' : can only apply to a standalone qualifier 4 | ERROR: 2 compilation errors. No code generated. 5 | 6 | 7 | SPIR-V is not generated for failed compile or link 8 | -------------------------------------------------------------------------------- /Test/baseResults/spv.atomiAddEXT.error.mesh.out: -------------------------------------------------------------------------------- 1 | spv.atomiAddEXT.error.mesh 2 | ERROR: 0:21: 'assign' : l-value required "mytask" (can't modify variable with storage qualifier taskPayloadSharedEXT in mesh shaders) 3 | ERROR: 0:21: 'out' : Non-L-value cannot be passed for 'out' or 'inout' parameters. 4 | ERROR: 2 compilation errors. No code generated. 5 | 6 | 7 | SPIR-V is not generated for failed compile or link 8 | -------------------------------------------------------------------------------- /Test/baseResults/spv.bfloat16_error.frag.out: -------------------------------------------------------------------------------- 1 | spv.bfloat16_error.frag 2 | ERROR: 0:9: 'bfloat16 types not allowed as input/output' : qualifier 3 | ERROR: 0:10: 'bfloat16 types not allowed as input/output' : qualifier 4 | ERROR: 2 compilation errors. No code generated. 5 | 6 | 7 | SPIR-V is not generated for failed compile or link 8 | -------------------------------------------------------------------------------- /Test/baseResults/spv.bufferhandle3_Errors.frag.out: -------------------------------------------------------------------------------- 1 | spv.bufferhandle3_Errors.frag 2 | ERROR: 0:18: 'in' : cannot contain any structs with buffer_reference. If you want to interface shader stages with a buffer_reference cast to a uint64 or uvec2 instead. 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.debugPrintf_Error.frag.out: -------------------------------------------------------------------------------- 1 | spv.debugPrintf_Error.frag 2 | ERROR: 0:7: 'string' : Expected hex value in escape sequence 3 | ERROR: 0:10: 'string' : Invalid escape sequence 4 | ERROR: 2 compilation errors. No code generated. 5 | 6 | 7 | SPIR-V is not generated for failed compile or link 8 | -------------------------------------------------------------------------------- /Test/baseResults/spv.demoteDisabled.frag.out: -------------------------------------------------------------------------------- 1 | spv.demoteDisabled.frag 2 | ERROR: 0:9: 'demote' : undeclared identifier 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.ext.ShaderTileImage.overlap.frag.out: -------------------------------------------------------------------------------- 1 | spv.ext.ShaderTileImage.overlap.frag 2 | ERROR: 0:8: 'location' : overlapping use of location 1 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.ext.ShaderTileImage.subpassinput.frag.out: -------------------------------------------------------------------------------- 1 | spv.ext.ShaderTileImage.subpassinput.frag 2 | ERROR: 0:6: 'subpassInput' : cannot be used with GL_EXT_shader_tile_image enabled 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.ext.ShaderTileImage.typemismatch.frag.out: -------------------------------------------------------------------------------- 1 | spv.ext.ShaderTileImage.typemismatch.frag 2 | ERROR: 0:7: 'location' : the aliases sharing the location 0 must be the same basic type and interpolation qualification 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.ext.textureShadowLod.error.frag.out: -------------------------------------------------------------------------------- 1 | spv.ext.textureShadowLod.error.frag 2 | ERROR: 0:11: 'textureLod(..., float lod)' : required extension not requested: GL_EXT_texture_shadow_lod 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.extPostDepthCoverage_Error.frag.out: -------------------------------------------------------------------------------- 1 | spv.extPostDepthCoverage_Error.frag 2 | ERROR: Linking fragment stage: post_depth_coverage requires early_fragment_tests 3 | 4 | SPIR-V is not generated for failed compile or link 5 | -------------------------------------------------------------------------------- /Test/baseResults/spv.fragmentDensity-neg.frag.out: -------------------------------------------------------------------------------- 1 | spv.fragmentDensity-neg.frag 2 | ERROR: 0:10: 'gl_FragSizeEXT' : required extension not requested: GL_EXT_fragment_invocation_density 3 | ERROR: 0:11: 'gl_FragInvocationCountEXT' : required extension not requested: GL_EXT_fragment_invocation_density 4 | ERROR: 2 compilation errors. No code generated. 5 | 6 | 7 | SPIR-V is not generated for failed compile or link 8 | -------------------------------------------------------------------------------- /Test/baseResults/spv.intrinsicsFakeEnable.vert.out: -------------------------------------------------------------------------------- 1 | spv.intrinsicsFakeEnable.vert 2 | ERROR: 0:7: 'location' : overlapping use of location 0 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.looseUniformNoLoc.vert.out: -------------------------------------------------------------------------------- 1 | spv.looseUniformNoLoc.vert 2 | ERROR: spv.looseUniformNoLoc.vert:9: 'uv' : non-opaque uniform variables need a layout(location=L) 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | ERROR: Linking vertex stage: Missing entry point: Each stage requires one entry point 7 | 8 | SPIR-V is not generated for failed compile or link 9 | -------------------------------------------------------------------------------- /Test/baseResults/spv.specConstArrayCheck.vert.out: -------------------------------------------------------------------------------- 1 | spv.specConstArrayCheck.vert 2 | ERROR: 0:13: '[' : array index out of range '6' 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.subgroupBallotNeg.comp.out: -------------------------------------------------------------------------------- 1 | spv.subgroupBallotNeg.comp 2 | ERROR: 0:32: 'id' : argument must be compile-time constant 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.textureError.frag.out: -------------------------------------------------------------------------------- 1 | spv.textureError.frag 2 | ERROR: spv.textureError.frag:8: 'texture*D*' : function not supported in this version; use texture() instead 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/baseResults/spv.uniformInitializerSpecConstant.frag.out: -------------------------------------------------------------------------------- 1 | spv.uniformInitializerSpecConstant.frag 2 | ERROR: 0:9: '=' : uniform initializers must be constant 'layout( location=4) uniform float' 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /Test/bump: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | cp localResults/* baseResults/ 3 | 4 | -------------------------------------------------------------------------------- /Test/comment.frag: -------------------------------------------------------------------------------- 1 | 2 | // 3 | /* anotehn t* ontuh * / tnoahnt /* oo */ 4 | /* multi line... 5 | 6 | ao */ 7 | /* no escape \ 8 | oanot */ 9 | // escape nothing \o oeu 10 | // escape newline \ 11 | still in a comment 12 | // escape newline \ 13 | 14 | // a different comment 15 | #version 430 core 16 | in vec4 v; 17 | void main() {} 18 | 19 | 20 | -------------------------------------------------------------------------------- /Test/compoundsuffix.frag.hlsl: -------------------------------------------------------------------------------- 1 | void main(out float4 fragColor : SV_TARGET0) 2 | { 3 | fragColor = 1; 4 | } 5 | 6 | 7 | -------------------------------------------------------------------------------- /Test/compoundsuffix.vert.glsl: -------------------------------------------------------------------------------- 1 | void main() 2 | { 3 | gl_Position = vec4(1.0); 4 | } -------------------------------------------------------------------------------- /Test/conditionalDiscard.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | uniform sampler2D tex; 4 | varying vec2 coord; 5 | 6 | void main (void) 7 | { 8 | vec4 v = texture2D(tex, coord); 9 | 10 | if (v == vec4(0.1,0.2,0.3,0.4)) 11 | discard; 12 | 13 | gl_FragColor = v; 14 | } 15 | -------------------------------------------------------------------------------- /Test/contradict_0.geom: -------------------------------------------------------------------------------- 1 | #version 330 2 | 3 | layout(points) in; 4 | layout(triangle_strip, max_vertices = 4) out; 5 | 6 | float getV(); 7 | 8 | void main (void) 9 | { 10 | float v = getV(); 11 | EndPrimitive(); 12 | EndPrimitive(); 13 | } 14 | -------------------------------------------------------------------------------- /Test/contradict_1.geom: -------------------------------------------------------------------------------- 1 | #version 330 2 | 3 | layout(lines) in; 4 | layout(line_strip, max_vertices = 6) out; 5 | 6 | float getV() 7 | { 8 | return 1.0; 9 | } 10 | -------------------------------------------------------------------------------- /Test/cppBad.vert: -------------------------------------------------------------------------------- 1 | #define n#0# 2 | #define m #0# 3 | #if m 4 | #endif 5 | #define n() 6 | int n" -------------------------------------------------------------------------------- /Test/cppBad2.vert: -------------------------------------------------------------------------------- 1 | #define a b( 2 | #define b(x) 3 | b(a) -------------------------------------------------------------------------------- /Test/cppBad3.vert: -------------------------------------------------------------------------------- 1 | #define f =y(. 2 | #define y(m) 3 | y(f) -------------------------------------------------------------------------------- /Test/cppBad4.vert: -------------------------------------------------------------------------------- 1 | int,i= 2 | #define f g(#g(y 3 | #define g(m) 4 | g(f) 5 | -------------------------------------------------------------------------------- /Test/cppBad5.vert: -------------------------------------------------------------------------------- 1 | int,i= 2 | #define f g($g(y 3 | #define g(m) 4 | g(f) 5 | -------------------------------------------------------------------------------- /Test/cppIntMinOverNegativeOne.frag: -------------------------------------------------------------------------------- 1 | #if (-2147483648 / -1) != 0 2 | #error INT_MIN / -1 should yield 0, something went wrong. 3 | #endif 4 | #if (-2147483648 % -1) != 0 5 | #error INT_MIN % -1 should yield 0, something went wrong. 6 | #endif -------------------------------------------------------------------------------- /Test/cppRelaxSkipTokensErrors.vert: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | #if 0 4 | 3.5L 5 | 3.5h 6 | 2034h 7 | 1.#INF 8 | 0x1234567812345L 9 | 12323394203923879234L 10 | 0123s; 11 | 123s; 12 | 0123456712345671234L 13 | "string" 14 | #endif 15 | -------------------------------------------------------------------------------- /Test/dataOut.frag: -------------------------------------------------------------------------------- 1 | #version 130 2 | 3 | varying vec4 Color; 4 | 5 | void main() 6 | { 7 | gl_FragData[1] = Color; 8 | } 9 | -------------------------------------------------------------------------------- /Test/dataOutIndirect.frag: -------------------------------------------------------------------------------- 1 | #version 130 2 | 3 | varying vec4 Color; 4 | 5 | uniform int i; 6 | 7 | void main() 8 | { 9 | gl_FragData[i] = Color; 10 | } 11 | -------------------------------------------------------------------------------- /Test/depthOut.frag: -------------------------------------------------------------------------------- 1 | #version 130 2 | 3 | varying vec4 Color; 4 | varying float Depth; 5 | 6 | void main() 7 | { 8 | gl_FragDepth = Depth; 9 | gl_FragColor = Color; 10 | } 11 | -------------------------------------------------------------------------------- /Test/doWhileLoop.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | uniform vec4 bigColor; 4 | varying vec4 BaseColor; 5 | uniform float d; 6 | 7 | void main() 8 | { 9 | vec4 color = BaseColor; 10 | 11 | do { 12 | color += bigColor; 13 | } while (color.x < d); 14 | 15 | gl_FragColor = color; 16 | } 17 | -------------------------------------------------------------------------------- /Test/empty.frag: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/empty.frag -------------------------------------------------------------------------------- /Test/empty2.frag: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /Test/empty3.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | -------------------------------------------------------------------------------- /Test/enhanced.0.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in vec3 v; 4 | 5 | void main() 6 | { 7 | vec4 color = vec4(v); 8 | } 9 | 10 | -------------------------------------------------------------------------------- /Test/enhanced.1.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in Vertex { 4 | vec4 v; 5 | } vVert; 6 | 7 | void main() 8 | { 9 | vec4 color = vec4(vVert.v2.rgb, 1.0); 10 | } 11 | 12 | -------------------------------------------------------------------------------- /Test/enhanced.2.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | void main() 4 | { 5 | vec3 color = vec3(0.0,0.0,0.0,1.0); 6 | } 7 | 8 | -------------------------------------------------------------------------------- /Test/enhanced.3.frag: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout (location = 0) out vec4 FragColor; 4 | 5 | layout (location = 0) in VS_OUT 6 | { 7 | vec2 foobar; 8 | } fs_in; 9 | 10 | layout (binding = 1) uniform sampler2D t0; 11 | 12 | void main() 13 | { 14 | FragColor = texture(t0, fs_in.foobar); 15 | } 16 | 17 | -------------------------------------------------------------------------------- /Test/enhanced.4.frag: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout (location = 0) out vec4 FragColor; 4 | 5 | layout (location = 1) in VS_OUT 6 | { 7 | vec2 TexCoords; 8 | } fs_in; 9 | 10 | layout (binding = 1) uniform sampler2D t0; 11 | 12 | void main() 13 | { 14 | FragColor = texture(t0, fs_in.TexCoords); 15 | } 16 | 17 | -------------------------------------------------------------------------------- /Test/enhanced.5.frag: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout (location = 0) out vec4 FragColor; 4 | 5 | layout (location = 0) in VS_OUT 6 | { 7 | vec3 TexCoords; 8 | } fs_in; 9 | 10 | layout (binding = 1) uniform sampler2D t0; 11 | 12 | void main() 13 | { 14 | FragColor = texture(t0, fs_in.TexCoords.xy); 15 | } 16 | 17 | -------------------------------------------------------------------------------- /Test/enhanced.6.frag: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout (location = 0) out vec4 FragColor; 4 | 5 | layout (location = 0) in VS_OUT 6 | { 7 | vec2 TexCoords; 8 | } fs_in[1]; 9 | 10 | layout (binding = 1) uniform sampler2D t0; 11 | 12 | void main() 13 | { 14 | FragColor = texture(t0, fs_in[0].TexCoords); 15 | } 16 | 17 | -------------------------------------------------------------------------------- /Test/errors.frag: -------------------------------------------------------------------------------- 1 | int main(int foo) 2 | { 3 | return 1; 4 | } 5 | -------------------------------------------------------------------------------- /Test/es-link1.frag: -------------------------------------------------------------------------------- 1 | #version 100 2 | 3 | mediump vec4 calculateColor(); 4 | 5 | void main() 6 | { 7 | gl_FragColor = calculateColor(); 8 | } 9 | -------------------------------------------------------------------------------- /Test/es-link2.frag: -------------------------------------------------------------------------------- 1 | #version 100 2 | 3 | varying mediump vec4 varyingColor; 4 | 5 | mediump vec4 calculateColor() 6 | { 7 | return varyingColor * 0.5; 8 | } 9 | -------------------------------------------------------------------------------- /Test/foo.h: -------------------------------------------------------------------------------- 1 | #error should not be included 2 | -------------------------------------------------------------------------------- /Test/gl_samplemask_array_size.frag: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | 3 | layout(location = 0) out mediump vec4 fragColor; 4 | void main (void) 5 | { 6 | for (int i = 0; i < gl_SampleMask.length(); ++i) 7 | gl_SampleMask[i] = int(0xAAAAAAAA); 8 | 9 | fragColor = vec4(0.0, 1.0, 0.0, 1.0); 10 | } -------------------------------------------------------------------------------- /Test/glsl.-P.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location=0) out vec4 color; 4 | 5 | void main() 6 | { 7 | #ifndef TEST1 8 | #error TEST1 is not defined 9 | #endif 10 | 11 | #ifndef TEST2 12 | #error TEST2 is not defined 13 | #endif 14 | 15 | #ifndef TEST3 16 | #error TEST3 is not defined 17 | #endif 18 | 19 | color = vec4(1.0); 20 | } 21 | -------------------------------------------------------------------------------- /Test/glsl.-P.function.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location=0) out vec4 color; 4 | 5 | void main() 6 | { 7 | color = getColor(); 8 | } 9 | -------------------------------------------------------------------------------- /Test/glsl.-P.include.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #include "glsl.-P.included.glsl" 4 | 5 | layout(location=0) out vec4 color; 6 | 7 | void main() 8 | { 9 | color = getColor(); 10 | } 11 | -------------------------------------------------------------------------------- /Test/glsl.-P.included.glsl: -------------------------------------------------------------------------------- 1 | vec4 getColor() 2 | { 3 | return vec4(1.0); 4 | } 5 | -------------------------------------------------------------------------------- /Test/glsl.140.layoutOffset.error.vert: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | layout (std140) uniform UBO // offset can't use under version 140 4 | { 5 | layout(offset = 0) vec4 a; 6 | }; 7 | 8 | in vec4 in_vs; 9 | out vec4 out_vs; 10 | 11 | void main() 12 | { 13 | out_vs = in_vs + a; 14 | } 15 | -------------------------------------------------------------------------------- /Test/glsl.430.layoutOffset.error.vert: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | 3 | layout (std140) uniform UBO // offset can't use on 430 core with out extension require 4 | { 5 | layout(offset = 0) vec4 a; 6 | }; 7 | 8 | in vec4 in_vs; 9 | out vec4 out_vs; 10 | 11 | void main() 12 | { 13 | out_vs = in_vs + a; 14 | } 15 | -------------------------------------------------------------------------------- /Test/glsl.autosampledtextures.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | layout (location = 0) in vec2 in_UV; 4 | 5 | layout (set=0, binding=0) uniform texture2D u_Tex; 6 | layout (set=0, binding=0) uniform sampler u_Sampler; 7 | 8 | layout (location = 0) out vec4 out_Color; 9 | 10 | void main() { 11 | vec4 color = texture(sampler2D(u_Tex, u_Sampler), in_UV); 12 | out_Color = color; 13 | } 14 | -------------------------------------------------------------------------------- /Test/glsl.entryPointRename.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void bar() 4 | { 5 | gl_Position = vec4(1); 6 | } 7 | 8 | void main() 9 | { 10 | gl_Position = vec4(1); 11 | } 12 | -------------------------------------------------------------------------------- /Test/glsl.entryPointRename2.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void bar() 4 | { 5 | gl_Position = vec4(1); 6 | } 7 | -------------------------------------------------------------------------------- /Test/glsl.es300.layoutOffset.error.vert: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | layout (binding = 0, offset = 0) uniform UBO // offset can't use on under version es 300 4 | { 5 | vec4 a; 6 | }; 7 | 8 | in vec4 in_vs; 9 | out vec4 out_vs; 10 | 11 | void main() 12 | { 13 | out_vs = in_vs + a; 14 | } 15 | -------------------------------------------------------------------------------- /Test/glsl.es320.subgroup.frag: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(location = 0) out uvec4 data; 4 | void main (void) 5 | { 6 | data = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 7 | } 8 | -------------------------------------------------------------------------------- /Test/glsl.es320.subgroup.geom: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(points) in; 4 | layout(points, max_vertices = 1) out; 5 | layout(set = 0, binding = 0, std430) buffer Output 6 | { 7 | uvec4 result[]; 8 | }; 9 | 10 | void main (void) 11 | { 12 | result[gl_PrimitiveIDIn] = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 13 | } 14 | -------------------------------------------------------------------------------- /Test/glsl.es320.subgroup.tesc: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(vertices=1) out; 4 | layout(set = 0, binding = 0, std430) buffer Output 5 | { 6 | uvec4 result[]; 7 | }; 8 | 9 | void main (void) 10 | { 11 | result[gl_PrimitiveID] = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 12 | } 13 | -------------------------------------------------------------------------------- /Test/glsl.es320.subgroup.tese: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(isolines) in; 4 | layout(set = 0, binding = 0, std430) buffer Output 5 | { 6 | uvec4 result[]; 7 | }; 8 | 9 | void main (void) 10 | { 11 | result[gl_PrimitiveID] = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 12 | } 13 | -------------------------------------------------------------------------------- /Test/glsl.es320.subgroup.vert: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(set = 0, binding = 0, std430) buffer Output 4 | { 5 | uvec4 result[]; 6 | }; 7 | 8 | void main (void) 9 | { 10 | result[gl_VertexID] = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 11 | } 12 | -------------------------------------------------------------------------------- /Test/glsl.versionOverride.comp: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | glslangValidator.exe --glsl-version 460 -V -S comp -o glsl.versionOverride.comp.out glsl.versionOverride.comp 4 | 5 | */ 6 | 7 | #version 110 8 | 9 | void main() 10 | { 11 | } 12 | -------------------------------------------------------------------------------- /Test/glsl.versionOverride.frag: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | glslangValidator.exe --glsl-version 420 -V -S frag -o glsl.versionOverride.frag.out glsl.versionOverride.frag 4 | 5 | */ 6 | 7 | #version 110 8 | 9 | void main() 10 | { 11 | } 12 | -------------------------------------------------------------------------------- /Test/glsl.versionOverride.geom: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | glslang.exe --glsl-version 430 -V -S geom -o glsl.versionOverride.geom.out glsl.versionOverride.geom 4 | 5 | */ 6 | 7 | #version 110 8 | 9 | layout (points) in; 10 | layout (line_strip, max_vertices = 2) out; 11 | 12 | void main() { 13 | EmitVertex(); 14 | EmitVertex(); 15 | EndPrimitive(); 16 | } 17 | -------------------------------------------------------------------------------- /Test/glsl.versionOverride.tesc: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | glslang.exe --glsl-version 440 -V -S tesc -o glsl.versionOverride.tesc.out glsl.versionOverride.tesc 4 | 5 | */ 6 | 7 | #version 110 8 | 9 | layout(vertices = 3) out; 10 | 11 | void main() 12 | { 13 | } 14 | -------------------------------------------------------------------------------- /Test/glsl.versionOverride.tese: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | glslang.exe --glsl-version 450 -V -S tese -o glsl.versionOverride.tese.out glsl.versionOverride.tese 4 | 5 | */ 6 | 7 | #version 110 8 | 9 | layout(triangles) in; 10 | 11 | void main() 12 | { 13 | } 14 | -------------------------------------------------------------------------------- /Test/glsl.versionOverride.vert: -------------------------------------------------------------------------------- 1 | /* 2 | 3 | glslangValidator.exe --glsl-version 410 -V -S vert -o glsl.versionOverride.vert.out glsl.versionOverride.vert 4 | 5 | */ 6 | 7 | #version 110 8 | 9 | void main() 10 | { 11 | } 12 | -------------------------------------------------------------------------------- /Test/glslangValidator: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | ../build/install/bin/glslang $* 3 | -------------------------------------------------------------------------------- /Test/glspv.esversion.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /Test/glspv.version.frag: -------------------------------------------------------------------------------- 1 | #version 330 compatibility 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /Test/glspv.version.vert: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /Test/hlsl.PointSize.geom: -------------------------------------------------------------------------------- 1 | struct S { 2 | [[vk::builtin("PointSize")]] float ps : PSIZE; 3 | }; 4 | 5 | [maxvertexcount(4)] 6 | void main([[vk::builtin("PointSize")]] triangle in uint ps[3], 7 | inout LineStream OutputStream) 8 | { 9 | S s; 10 | OutputStream.Append(s); 11 | } 12 | -------------------------------------------------------------------------------- /Test/hlsl.PointSize.vert: -------------------------------------------------------------------------------- 1 | [[vk::builtin("PointSize")]] float main() 2 | { 3 | return 2.3; 4 | } -------------------------------------------------------------------------------- /Test/hlsl.amend.frag: -------------------------------------------------------------------------------- 1 | float4 a; 2 | float b; 3 | static float4 m = a * b; 4 | void f1() 5 | { 6 | a * b; 7 | } 8 | 9 | float3 c; 10 | 11 | void f2() 12 | { 13 | a.x + b + c.x; 14 | } 15 | 16 | void f3() 17 | { 18 | c; 19 | } 20 | 21 | int d; 22 | 23 | void f4() 24 | { 25 | d * a; 26 | } 27 | 28 | int e; -------------------------------------------------------------------------------- /Test/hlsl.assoc.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction( 2 | float4 a1, 3 | float4 a2, 4 | float4 a3, 5 | float4 a4, 6 | float4 a5 7 | ) : COLOR0 8 | { 9 | a1 = a2 = a3 = a4 = a5; 10 | return a1 + a2 + a3 + a4 + a5; 11 | } 12 | -------------------------------------------------------------------------------- /Test/hlsl.attribute.expression.comp: -------------------------------------------------------------------------------- 1 | 2 | uniform int bound; 3 | 4 | #define FOO 3 5 | #define BAR 2 6 | 7 | [numthreads(2+2, 2*3, (1+FOO)*BAR)] 8 | void main() 9 | { 10 | [unroll(5*2 + 1) ] 11 | for (int x=0; x> b; 18 | 19 | return r; 20 | } 21 | -------------------------------------------------------------------------------- /Test/hlsl.buffer-offsets.comp: -------------------------------------------------------------------------------- 1 | // See https://github.com/KhronosGroup/glslang/issues/3668 2 | 3 | struct GfxIterationData { 4 | float mIntegrationTrafo[24]; 5 | float mWind[3]; 6 | uint mIsTurning; 7 | }; 8 | 9 | StructuredBuffer bIterData : register(t2); 10 | 11 | void main() 12 | { 13 | } 14 | -------------------------------------------------------------------------------- /Test/hlsl.cast.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | return (float4)input + (int4)input + (float4)1.198; 4 | } 5 | -------------------------------------------------------------------------------- /Test/hlsl.charLit.vert: -------------------------------------------------------------------------------- 1 | float4 main() : SV_Position 2 | { 3 | uint a1 = 'A'; 4 | int a2 = '0'; 5 | 6 | int a3 = '\a'; 7 | a3 += '\b'; 8 | a3 += '\t'; 9 | a3 += '\n'; 10 | a3 += '\v'; 11 | a3 += '\f'; 12 | a3 += '\r'; 13 | 14 | int a10 = '\c'; 15 | 16 | return a1 + a2 + a3 + a10; 17 | } 18 | -------------------------------------------------------------------------------- /Test/hlsl.clip.frag: -------------------------------------------------------------------------------- 1 | 2 | float GetEntitySelectClip() 3 | { 4 | return 1.0f; 5 | } 6 | 7 | float4 main() : SV_TARGET 8 | { 9 | clip(GetEntitySelectClip()); 10 | 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-1.frag: -------------------------------------------------------------------------------- 1 | float4 main(in float4 pos : SV_Position, 2 | in float clip : SV_ClipDistance, 3 | in float cull : SV_CullDistance) : SV_Target0 4 | { 5 | return pos + clip + cull; 6 | } 7 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-1.vert: -------------------------------------------------------------------------------- 1 | void main(out float4 pos : SV_Position, 2 | out float clip : SV_ClipDistance, // scalar float 3 | out float cull : SV_CullDistance) // scalar float 4 | { 5 | pos = 1.0f.xxxx; 6 | clip = 0.5f; 7 | cull = 0.51f; 8 | } 9 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-2.frag: -------------------------------------------------------------------------------- 1 | float4 main(in float4 pos : SV_Position, 2 | in float2 clip[2] : SV_ClipDistance, // array of vector float 3 | in float2 cull[2] : SV_CullDistance) : SV_Target0 // array of vector float 4 | { 5 | 6 | return pos + clip[0][0] + cull[0][0]; 7 | } 8 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-3.frag: -------------------------------------------------------------------------------- 1 | float4 main(in float4 pos : SV_Position, 2 | in float clip[2] : SV_ClipDistance, // array of scalar float 3 | in float cull[2] : SV_CullDistance) : SV_Target0 // array of scalar float 4 | { 5 | return pos + clip[0] + cull[0]; 6 | } 7 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-3.vert: -------------------------------------------------------------------------------- 1 | void main(out float4 pos : SV_Position, 2 | out float clip[2] : SV_ClipDistance, // array of scalar float 3 | out float cull[2] : SV_CullDistance) // array of scalar float 4 | { 5 | pos = 1.0f.xxxx; 6 | clip[0] = 0.5f; 7 | clip[1] = 0.6f; 8 | 9 | cull[0] = 0.525f; 10 | cull[1] = 0.625f; 11 | } 12 | 13 | 14 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-4.frag: -------------------------------------------------------------------------------- 1 | struct VS_OUTPUT { 2 | float4 Position : SV_Position; 3 | float4 ClipRect : SV_ClipDistance0; // vector in split struct 4 | }; 5 | 6 | float4 main(const VS_OUTPUT v) : SV_Target0 7 | { 8 | return v.Position + v.ClipRect; 9 | } 10 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-5.frag: -------------------------------------------------------------------------------- 1 | struct VS_OUTPUT { 2 | float4 Position : SV_Position; 3 | float2 ClipRect[2] : SV_ClipDistance0; // array of float2 in split struct 4 | }; 5 | 6 | float4 main(const VS_OUTPUT v) : SV_Target0 7 | { 8 | return v.Position + v.ClipRect[0].x + v.ClipRect[1].x; 9 | } 10 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-6.frag: -------------------------------------------------------------------------------- 1 | struct VS_OUTPUT { 2 | float4 Position : SV_Position; 3 | float4 clip0 : SV_ClipDistance0; // multiple semantic IDs, two vec4s (no extra packing) 4 | float4 clip1 : SV_ClipDistance1; // ... 5 | }; 6 | 7 | float4 main(VS_OUTPUT v) : SV_Target0 8 | { 9 | return v.Position + v.clip0 + v.clip1; 10 | } 11 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-7.frag: -------------------------------------------------------------------------------- 1 | struct VS_OUTPUT { 2 | float4 Position : SV_Position; 3 | float3 clip0 : SV_ClipDistance0; // multiple semantic IDs, vec3+vec4 (skip) 4 | float4 clip1 : SV_ClipDistance1; // ... 5 | }; 6 | 7 | float4 main(VS_OUTPUT v) : SV_Target0 8 | { 9 | return v.Position + v.clip0.x + v.clip1.x; 10 | } 11 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-8.frag: -------------------------------------------------------------------------------- 1 | struct VS_OUTPUT { 2 | float4 Position : SV_Position; 3 | float3 clip0 : SV_ClipDistance0; // multiple semantic IDs, vec3+float (pack) 4 | float clip1 : SV_ClipDistance1; // ... 5 | }; 6 | 7 | float4 main(VS_OUTPUT v) : SV_Target0 8 | { 9 | return v.Position + v.clip0.x + v.clip1; 10 | } 11 | -------------------------------------------------------------------------------- /Test/hlsl.clipdistance-9.frag: -------------------------------------------------------------------------------- 1 | 2 | // Test packing 0 and 1 semantics into single array[4], from in fn params. 3 | float4 main(in float4 Position : SV_Position, 4 | in float3 clip0 : SV_ClipDistance0, 5 | in float clip1 : SV_ClipDistance1) : SV_Target0 6 | { 7 | return Position + clip0.x + clip1; 8 | } 9 | -------------------------------------------------------------------------------- /Test/hlsl.constructArray.vert: -------------------------------------------------------------------------------- 1 | float4 main() : SV_POSITION 2 | { 3 | int4 int4_array[3]; 4 | float4 float4_array_times[2] = (float4[2])int4_array; 5 | float2 float2_array_times2[4] = (float2[4])int4_array; 6 | int4 int4_array2[2] = (int4[2])int4_array; 7 | int int1_array[2] = (int[2])int4_array; 8 | 9 | return (float4)0.0; 10 | } 11 | -------------------------------------------------------------------------------- /Test/hlsl.deadFunctionMissingBody.vert: -------------------------------------------------------------------------------- 1 | float4 main(): SV_Target0 { return 0; } 2 | struct Surface { float3 albedo; }; 3 | Surface surfaceShader(float fade); 4 | Surface surfaceShaderExec() 5 | { 6 | float fade = 0; 7 | return surfaceShader(0); 8 | } 9 | -------------------------------------------------------------------------------- /Test/hlsl.depthGreater.frag: -------------------------------------------------------------------------------- 1 | void PixelShaderFunction(out float depth : SV_DepthGreaterEqual) 2 | { 3 | depth = 0.2; 4 | } 5 | -------------------------------------------------------------------------------- /Test/hlsl.depthLess.frag: -------------------------------------------------------------------------------- 1 | float PixelShaderFunction() : SV_DepthLessEqual 2 | { 3 | return 0.2; 4 | } 5 | -------------------------------------------------------------------------------- /Test/hlsl.discard.frag: -------------------------------------------------------------------------------- 1 | void foo(float f) 2 | { 3 | if (f < 1.0) 4 | discard; 5 | } 6 | 7 | void PixelShaderFunction(float4 input) : COLOR0 8 | { 9 | foo(input.z); 10 | if (input.x) 11 | discard; 12 | float f = input.x; 13 | discard; 14 | } 15 | -------------------------------------------------------------------------------- /Test/hlsl.earlydepthstencil.frag: -------------------------------------------------------------------------------- 1 | RWTexture2D Values; 2 | 3 | struct InputStruct { 4 | float4 Position : SV_POSITION; 5 | }; 6 | 7 | [earlydepthstencil] 8 | uint main(InputStruct input) : SV_Target { 9 | uint oldVal; 10 | InterlockedExchange(Values[uint2(input.Position.x, input.Position.y)], 1.0, oldVal); 11 | return oldVal; 12 | } 13 | -------------------------------------------------------------------------------- /Test/hlsl.emptystruct.init.vert: -------------------------------------------------------------------------------- 1 | struct Test { }; 2 | 3 | static const Test Test_Empty; 4 | 5 | float4 main(in uint vertexIndex : VERTEXID) : VS_OUT_POSITION 6 | { 7 | return 0; 8 | } 9 | -------------------------------------------------------------------------------- /Test/hlsl.emptystructreturn.frag: -------------------------------------------------------------------------------- 1 | struct ps_in 2 | { 3 | }; 4 | 5 | struct ps_out 6 | { 7 | }; 8 | 9 | ps_out main (ps_in i) 10 | { 11 | ps_out o; 12 | return o; 13 | } 14 | -------------------------------------------------------------------------------- /Test/hlsl.emptystructreturn.vert: -------------------------------------------------------------------------------- 1 | struct vs_in 2 | { 3 | }; 4 | 5 | struct vs_out 6 | { 7 | }; 8 | 9 | vs_out main (vs_in i) 10 | { 11 | vs_out o; 12 | return o; 13 | } 14 | -------------------------------------------------------------------------------- /Test/hlsl.entry-inout.vert: -------------------------------------------------------------------------------- 1 | void main(inout float4 pos : SV_Position, inout float2 uv : TEXCOORD0) {} 2 | -------------------------------------------------------------------------------- /Test/hlsl.entry.rename.frag: -------------------------------------------------------------------------------- 1 | 2 | struct PS_OUTPUT 3 | { 4 | float4 Color : SV_Target0; 5 | }; 6 | 7 | void not_the_entry_point() { } 8 | int also_not_the_entry_point; 9 | 10 | PS_OUTPUT main() 11 | { 12 | PS_OUTPUT psout; 13 | psout.Color = 0; 14 | return psout; 15 | } 16 | -------------------------------------------------------------------------------- /Test/hlsl.explicitDescriptorSet.frag: -------------------------------------------------------------------------------- 1 | SamplerState g_sSamp : register(s1); 2 | 3 | Texture1D g_tTex1df4 : register(t0); 4 | 5 | SamplerState g_sSamp2_amb; 6 | uniform float floatval_amb; 7 | 8 | Buffer floatbuff; 9 | 10 | float4 main() : SV_Target0 11 | { 12 | g_sSamp2_amb; 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /Test/hlsl.flatten.return.frag: -------------------------------------------------------------------------------- 1 | 2 | struct PS_OUTPUT 3 | { 4 | float4 color : SV_Target0; 5 | float other_struct_member1; 6 | float other_struct_member2; 7 | float other_struct_member3; 8 | }; 9 | 10 | PS_OUTPUT Func1() 11 | { 12 | return PS_OUTPUT(float4(1,1,1,1), 2, 3, 4); 13 | } 14 | 15 | PS_OUTPUT main() 16 | { 17 | return Func1(); 18 | } 19 | -------------------------------------------------------------------------------- /Test/hlsl.float1.frag: -------------------------------------------------------------------------------- 1 | static float1 f1 = float1(1.0); 2 | static float scalar = 2.0; 3 | 4 | float1 ShaderFunction(float1 inFloat1 : COLOR, float inScalar) : COLOR0 5 | { 6 | return f1 * scalar + inFloat1 * inScalar; 7 | } 8 | -------------------------------------------------------------------------------- /Test/hlsl.float4.frag: -------------------------------------------------------------------------------- 1 | float4 AmbientColor = float4(1, 0.5, 0, 1); 2 | 3 | bool ff1 : SV_IsFrontFace; 4 | float ff2 : packoffset(c1.y); 5 | float4 ff3 : packoffset(c2) : register(ps_5_0, s0) ; 6 | float4 ff4 : VPOS : packoffset(c3) : register(ps_5_0, s1) ; 7 | 8 | float4 ShaderFunction(float4 input) : COLOR0 9 | { 10 | return input * AmbientColor; 11 | } 12 | -------------------------------------------------------------------------------- /Test/hlsl.frag: -------------------------------------------------------------------------------- 1 | float4 AmbientColor = float4(1, 0.5, 0, 1); 2 | float AmbientIntensity = 0.1; 3 | 4 | float4 PixelShaderFunction(float4 input) : COLOR0 5 | { 6 | return input * AmbientIntensity + AmbientColor; 7 | return input * input + input * input; 8 | return input + input * input + input; 9 | return ++input * -+-+--input; 10 | return input++ + ++input; 11 | return sin(input); 12 | } 13 | -------------------------------------------------------------------------------- /Test/hlsl.groupid.comp: -------------------------------------------------------------------------------- 1 | RWTexture2D < float4 > OutputTexture; 2 | 3 | // Test conversion between SPIR-V required uint3 group id, and sub-vec3 shader declaration. 4 | 5 | [ numthreads ( 8 , 8 , 1 ) ] 6 | void main ( uint2 vGroupId : SV_GroupID ) 7 | { 8 | OutputTexture[ vGroupId . xy ] = float4(1.0, 0.0, 0.0, 1.0); 9 | } 10 | -------------------------------------------------------------------------------- /Test/hlsl.include.vert: -------------------------------------------------------------------------------- 1 | #include "bar.h" 2 | #include "./inc1/bar.h" 3 | #include "inc2\bar.h" 4 | 5 | float4 main() : SV_Position 6 | { 7 | return i1 + i2 + i3 + i4 + i5 + i6; 8 | } 9 | -------------------------------------------------------------------------------- /Test/hlsl.includeNegative.vert: -------------------------------------------------------------------------------- 1 | #include "foo.h" 2 | #include "inc2/../foo.h" 3 | #include "inc1/badInc.h" 4 | 5 | float4 main() : SV_Position 6 | { 7 | #error in main 8 | } 9 | -------------------------------------------------------------------------------- /Test/hlsl.inoutquals.negative.frag: -------------------------------------------------------------------------------- 1 | in float invalid1; 2 | in out float invalid2; 3 | inout float invalid3; 4 | out float invalid4; 5 | 6 | void main() { 7 | } 8 | -------------------------------------------------------------------------------- /Test/hlsl.int.dot.frag: -------------------------------------------------------------------------------- 1 | float4 main() : SV_Target { 2 | int i = 1; 3 | int1 i2 = 2; 4 | int2 i3 = 3; 5 | int3 i4 = 4; 6 | int4 i5 = 5; 7 | 8 | i = dot(i, i); 9 | i2 = dot(i2, i2); 10 | i3 = dot(i3, i3); 11 | i4 = dot(i4, i4); 12 | i5 = dot(i5, i5); 13 | return i + i2.xxxx + i3.xyxy + i4.xyzx + i5; 14 | } -------------------------------------------------------------------------------- /Test/hlsl.intrinsics.barriers.comp: -------------------------------------------------------------------------------- 1 | 2 | void ComputeShaderFunction() 3 | { 4 | AllMemoryBarrier(); 5 | AllMemoryBarrierWithGroupSync(); 6 | DeviceMemoryBarrier(); 7 | DeviceMemoryBarrierWithGroupSync(); 8 | GroupMemoryBarrier(); 9 | GroupMemoryBarrierWithGroupSync(); 10 | } 11 | 12 | -------------------------------------------------------------------------------- /Test/hlsl.intrinsics.d3dcolortoubyte4.frag: -------------------------------------------------------------------------------- 1 | 2 | uniform float4 col4; 3 | 4 | int4 main() : SV_Target0 5 | { 6 | return D3DCOLORtoUBYTE4(col4); 7 | } 8 | -------------------------------------------------------------------------------- /Test/hlsl.intrinsics.double.frag: -------------------------------------------------------------------------------- 1 | 2 | float PixelShaderFunction(double inDV1a, double inDV1b, double inDV1c, 3 | double2 inDV2, double3 inDV3, double4 inDV4, 4 | uint inU1a, uint inU1b) 5 | { 6 | double r00 = fma(inDV1a, inDV1b, inDV1c); 7 | double r01 = asdouble(inU1a, inU1b); 8 | 9 | return 0.0; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /Test/hlsl.intrinsics.lit.frag: -------------------------------------------------------------------------------- 1 | void PixelShaderFunction(float n_dot_l, float n_dot_h, float m) 2 | { 3 | float4 r0 = lit(n_dot_l, n_dot_h, m); 4 | } 5 | -------------------------------------------------------------------------------- /Test/hlsl.isfinite.frag: -------------------------------------------------------------------------------- 1 | 2 | uniform float f; 3 | uniform float2 f2; 4 | uniform float3 f3; 5 | 6 | bool test1(float v) 7 | { 8 | return !isnan(v) && isfinite(v); 9 | } 10 | 11 | float4 main() : SV_Target0 12 | { 13 | isfinite(f); 14 | isfinite(f2); 15 | isfinite(f3); 16 | 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /Test/hlsl.layoutOverride.vert: -------------------------------------------------------------------------------- 1 | layout(set=2,binding=0) Texture2D tex : register(t16); 2 | SamplerState samp; 3 | 4 | float4 main() : SV_Position 5 | { 6 | return tex.Sample(samp, float2(0.2, 0.3)); 7 | } -------------------------------------------------------------------------------- /Test/hlsl.localStructuredBuffer.comp: -------------------------------------------------------------------------------- 1 | RWStructuredBuffer srt0; 2 | void main() { 3 | RWStructuredBuffer srt0Local = srt0; 4 | } -------------------------------------------------------------------------------- /Test/hlsl.logical.binary.frag: -------------------------------------------------------------------------------- 1 | struct PS_OUTPUT 2 | { 3 | float4 Color : SV_Target0; 4 | }; 5 | 6 | uniform int ival; 7 | uniform int4 ival4; 8 | uniform float fval; 9 | uniform float4 fval4; 10 | 11 | PS_OUTPUT main() 12 | { 13 | if (ival && fval); 14 | if (ival || fval); 15 | 16 | PS_OUTPUT psout; 17 | psout.Color = 1.0; 18 | return psout; 19 | } 20 | 21 | 22 | -------------------------------------------------------------------------------- /Test/hlsl.loopattr.frag: -------------------------------------------------------------------------------- 1 | 2 | float4 main() : SV_Target0 3 | { 4 | // Unroll hint 5 | [unroll(5) ] for (int x=0; x<5; ++x); 6 | 7 | // Don't unroll hint 8 | [loop] for (int y=0; y<5; ++y); 9 | 10 | // No hint 11 | for (int z=0; z<5; ++z); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /Test/hlsl.matType.frag: -------------------------------------------------------------------------------- 1 | float1 f1 = float1(1.0); 2 | float1x1 fmat11; 3 | float4x1 fmat41; 4 | float1x2 fmat12; 5 | double2x3 dmat23; 6 | int4x4 int44; 7 | 8 | float1 ShaderFunction(float1 inFloat1, float inScalar) : COLOR0 9 | { 10 | return inFloat1; 11 | } 12 | -------------------------------------------------------------------------------- /Test/hlsl.matpack-pragma-global.frag: -------------------------------------------------------------------------------- 1 | #pragma pack_matrix(row_major) 2 | 3 | float4x4 g_GlobalMat1; 4 | 5 | float4 main() : SV_Target0 6 | { 7 | return g_GlobalMat1[0]; 8 | } 9 | -------------------------------------------------------------------------------- /Test/hlsl.max.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input1, float4 input2) : COLOR0 2 | { 3 | return max(input1, input2); 4 | } 5 | -------------------------------------------------------------------------------- /Test/hlsl.mip.negative.frag: -------------------------------------------------------------------------------- 1 | Texture2D g_tTex2df4; 2 | 3 | float4 main() : SV_Target0 4 | { 5 | g_tTex2df4.mips.mips[2][uint2(3, 4)]; // error to chain like this 6 | 7 | return 0; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /Test/hlsl.mip.negative2.frag: -------------------------------------------------------------------------------- 1 | Texture2D g_tTex2df4; 2 | 3 | float4 main() : SV_Target0 4 | { 5 | g_tTex2df4.r[2][uint2(3, 4)]; // '.r' not valid on texture object 6 | 7 | return 0; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /Test/hlsl.multiEntry.vert: -------------------------------------------------------------------------------- 1 | Buffer Position; 2 | 3 | float4 FakeEntrypoint(uint Index : SV_VERTEXID) : SV_POSITION 4 | { 5 | return Position.Load(Index); 6 | } 7 | 8 | float4 RealEntrypoint(uint Index : SV_VERTEXID) : SV_POSITION 9 | { 10 | return FakeEntrypoint(Index); 11 | } -------------------------------------------------------------------------------- /Test/hlsl.multiReturn.frag: -------------------------------------------------------------------------------- 1 | struct S { 2 | float f; 3 | float3 v; 4 | float3x3 m; 5 | }; 6 | 7 | cbuffer bufName { 8 | S s; 9 | }; 10 | 11 | S foo() 12 | { 13 | return s; 14 | } 15 | 16 | void main() 17 | { 18 | foo(); 19 | } 20 | -------------------------------------------------------------------------------- /Test/hlsl.multiView.frag: -------------------------------------------------------------------------------- 1 | 2 | float4 main(uint ViewIndex : SV_ViewID) 3 | { 4 | return float4(ViewIndex, 0.0f, 0.0f, 0.0f); 5 | } 6 | -------------------------------------------------------------------------------- /Test/hlsl.nested-runtimeArray.frag: -------------------------------------------------------------------------------- 1 | struct A { 2 | float a[]; 3 | }; 4 | 5 | RWStructuredBuffer B; 6 | 7 | float main() { 8 | return B[0].a[0]; 9 | } 10 | -------------------------------------------------------------------------------- /Test/hlsl.noSemantic.functionality1.comp: -------------------------------------------------------------------------------- 1 | AppendStructuredBuffer Buf : register(u0); 2 | 3 | [numthreads(1, 1, 1)] 4 | void main() 5 | { 6 | Buf.Append(1.0f.xxxx); 7 | } -------------------------------------------------------------------------------- /Test/hlsl.nonint-index.frag: -------------------------------------------------------------------------------- 1 | static const float array[3] = { 1, 2, 3 }; 2 | 3 | float main(float input : IN) : SV_Target0 4 | { 5 | // non-integer indexes get converted to uints: 6 | // uint(input) 3.0 2.0 1.0 7 | return array[input] + array[2.0] + array[true] + array[false]; 8 | } 9 | 10 | -------------------------------------------------------------------------------- /Test/hlsl.numthreads.comp: -------------------------------------------------------------------------------- 1 | 2 | [numthreads(8,8,1)] 3 | void main(uint3 tid : SV_DispatchThreadID ) 4 | { 5 | } 6 | 7 | [numthreads(1,4,8)] 8 | void main_aux2(uint3 tid : SV_DispatchThreadID ) 9 | { 10 | } 11 | 12 | -------------------------------------------------------------------------------- /Test/hlsl.partialFlattenMixed.vert: -------------------------------------------------------------------------------- 1 | Texture2D tex[2]; 2 | 3 | struct Packed { 4 | int a; 5 | Texture2D membTex[2]; 6 | int b; 7 | }; 8 | 9 | float4 main(float4 pos : POSITION) : SV_POSITION 10 | { 11 | Packed packed; 12 | 13 | packed.membTex = tex; 14 | 15 | return pos; 16 | } -------------------------------------------------------------------------------- /Test/hlsl.pp.tokenpasting.frag: -------------------------------------------------------------------------------- 1 | 2 | #define foobarblee zzzz 3 | 4 | #define ar qqqq 5 | 6 | #define MACRO1(x,y) foo##x##y 7 | // #define MACRO2 abc##def 8 | 9 | // #define SPACE_IN_MACRO int var1 10 | 11 | float4 main() : SV_Target0 12 | { 13 | // float MACRO2 = 10; 14 | float MACRO1(b##ar,blee) = 3; 15 | 16 | return float4(foobarblee,0,0,0); 17 | } 18 | 19 | -------------------------------------------------------------------------------- /Test/hlsl.pp.vert: -------------------------------------------------------------------------------- 1 | #define A defined(B) 2 | 3 | #if A 4 | int badGlobal1; 5 | #else 6 | int goodGlobal1; 7 | #endif 8 | 9 | #define B 10 | 11 | #if A 12 | int goodGlobal2; 13 | #else 14 | int badGlobal2; 15 | #endif 16 | 17 | void main() {} 18 | -------------------------------------------------------------------------------- /Test/hlsl.precedence.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction( 2 | float4 a1, 3 | float4 a2, 4 | float4 a3, 5 | float4 a4 6 | ) : COLOR0 7 | { 8 | return a1 + a2 * a3 + a4 + float4(a1.rgb * a2.rgb, a3.a); 9 | } 10 | -------------------------------------------------------------------------------- /Test/hlsl.precedence2.frag: -------------------------------------------------------------------------------- 1 | int PixelShaderFunction( 2 | int a1, 3 | int a2, 4 | int a3, 5 | int a4 6 | ) : COLOR0 7 | { 8 | return (a1 * a2 + a3 << a4) + (a1 << a2 + a3 * a4); 9 | } 10 | -------------------------------------------------------------------------------- /Test/hlsl.precise.frag: -------------------------------------------------------------------------------- 1 | 2 | struct PS_OUTPUT { precise float4 color : SV_Target0; }; 3 | 4 | static precise float precisefloat; 5 | 6 | void MyFunction(in precise float myfloat, out precise float3 myfloat3) { } 7 | 8 | PS_OUTPUT main() 9 | { 10 | PS_OUTPUT ps_output; 11 | ps_output.color = 1.0; 12 | return ps_output; 13 | } 14 | 15 | -------------------------------------------------------------------------------- /Test/hlsl.preprocessor.frag: -------------------------------------------------------------------------------- 1 | #define DEFINE_TEXTURE(name) Texture2D name; SamplerState name##_ss; 2 | #define SAMPLE_TEXTURE(name, uv) name.Sample(name##_ss, (uv).xy) 3 | 4 | #define test_texture2 test_texture 5 | 6 | DEFINE_TEXTURE(test_texture) 7 | 8 | float4 main(float4 input : TEXCOORD0) : SV_TARGET 9 | { 10 | float4 tex = SAMPLE_TEXTURE(test_texture2, input.xy); 11 | return tex; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /Test/hlsl.printf.comp: -------------------------------------------------------------------------------- 1 | const string first = "first string"; 2 | 3 | [numthreads(1,1,1)] 4 | void main() { 5 | printf(first); 6 | printf("please print this message."); 7 | printf("Variables are: %d %d %.2f", 1u, 2u, 1.5f); 8 | printf("Integers are: %d %d %d", 1, 2, 3); 9 | printf("More: %d %d %d %d %d %d %d %d %d %d", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); 10 | } 11 | 12 | -------------------------------------------------------------------------------- /Test/hlsl.promote.vec1.frag: -------------------------------------------------------------------------------- 1 | 2 | float4 main() : SV_Target 3 | { 4 | float f1a; 5 | float1 f1b; 6 | 7 | f1a = f1b; // convert float1 to float 8 | f1b = f1a; // convert float to float1 9 | 10 | float3 f3; 11 | step(0.0, f3); 12 | 13 | sin(f1b); // test 1-vectors in intrinsics 14 | 15 | return float4(0,0,0,0); 16 | } 17 | -------------------------------------------------------------------------------- /Test/hlsl.round.dx10.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | return round(input); 4 | } 5 | -------------------------------------------------------------------------------- /Test/hlsl.round.dx9.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | return round(input); 4 | } 5 | -------------------------------------------------------------------------------- /Test/hlsl.rw.register.frag: -------------------------------------------------------------------------------- 1 | 2 | RWTexture1D g_tTex1df1 : register(u2); 3 | RWBuffer g_tBuf1du1 : register(U3); 4 | 5 | struct PS_OUTPUT 6 | { 7 | float4 Color : SV_Target0; 8 | }; 9 | 10 | PS_OUTPUT main() 11 | { 12 | float r00 = g_tTex1df1[0]; 13 | uint r01 = g_tBuf1du1[0]; 14 | 15 | PS_OUTPUT psout; 16 | psout.Color = 1.0; 17 | return psout; 18 | } 19 | -------------------------------------------------------------------------------- /Test/hlsl.samplecmp.negative2.frag: -------------------------------------------------------------------------------- 1 | 2 | Texture2D g_shadowTex; 3 | SamplerState g_shadowSampler; 4 | 5 | float4 main() : SV_Target0 6 | { 7 | g_shadowTex.GatherCmpRed(g_shadowSampler, float2(0,0), 0, int2(0,0)); // ERROR (should be comparison sampler) 8 | 9 | return 0; 10 | } 11 | -------------------------------------------------------------------------------- /Test/hlsl.scalar-length.frag: -------------------------------------------------------------------------------- 1 | float4 main() : SV_Target0 2 | { 3 | float4 test = { 0, 1, 2, 3 }; 4 | 5 | return length(test.a); 6 | } 7 | -------------------------------------------------------------------------------- /Test/hlsl.semantic.vert: -------------------------------------------------------------------------------- 1 | struct S { 2 | float clip0 : SV_ClipDistance0; 3 | float clip1 : SV_ClipDistance1; 4 | float cull0 : SV_CullDistance0; 5 | float cull1 : SV_CullDistance1; 6 | int ii : SV_InstanceID; 7 | }; 8 | 9 | S main(S ins) 10 | { 11 | S s; 12 | return s; 13 | } 14 | -------------------------------------------------------------------------------- /Test/hlsl.semicolons.frag: -------------------------------------------------------------------------------- 1 | 2 | void MyFunc() { } 3 | 4 | ;;; 5 | ; 6 | ; ; ; // HLSL allows stray global scope semicolons. 7 | 8 | void MyFunc2() {;;;}; 9 | 10 | struct PS_OUTPUT { float4 color : SV_Target0; };;;;; 11 | 12 | ;PS_OUTPUT main() 13 | { 14 | PS_OUTPUT ps_output;;; 15 | ; 16 | ps_output.color = 1.0; 17 | return ps_output; 18 | }; 19 | 20 | -------------------------------------------------------------------------------- /Test/hlsl.shapeConvRet.frag: -------------------------------------------------------------------------------- 1 | int3 foo() 2 | { 3 | return 13; 4 | } 5 | 6 | float4 main(float f) 7 | { 8 | return f; 9 | } 10 | -------------------------------------------------------------------------------- /Test/hlsl.sin.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | return sin(input); 4 | } 5 | -------------------------------------------------------------------------------- /Test/hlsl.specConstant.frag: -------------------------------------------------------------------------------- 1 | [[vk::constant_id(0)]] const uint index = 2; 2 | 3 | static const uint array[] = { 10, 20, 30, 40 }; 4 | 5 | float4 main( ) : SV_TARGET 6 | { 7 | float4 r; 8 | for(uint i = 0; i < array[index]; i++) 9 | r = i; 10 | 11 | r += index + index; 12 | r += 2 * index; 13 | 14 | return r; 15 | } 16 | -------------------------------------------------------------------------------- /Test/hlsl.spv.1.6.discard.frag: -------------------------------------------------------------------------------- 1 | void foo(float f) 2 | { 3 | if (f < 1.0) 4 | discard; 5 | } 6 | 7 | void PixelShaderFunction(float4 input) : COLOR0 8 | { 9 | foo(input.z); 10 | if (input.x) 11 | discard; 12 | float f = input.x; 13 | discard; 14 | } 15 | -------------------------------------------------------------------------------- /Test/hlsl.staticFuncInit.frag: -------------------------------------------------------------------------------- 1 | static float x = 1.0; 2 | 3 | float f1() 4 | { 5 | static float x = 2.0; 6 | x += 10.0; 7 | return x; 8 | } 9 | 10 | float f2(float p) 11 | { 12 | static float x = 7.0; 13 | x += p; 14 | return x; 15 | } 16 | 17 | float4 main() : SV_TARGET 18 | { 19 | return x + f1() + f1() + f2(5.0) + f2(x); 20 | } 21 | -------------------------------------------------------------------------------- /Test/hlsl.store.rwbyteaddressbuffer.type.comp: -------------------------------------------------------------------------------- 1 | RWByteAddressBuffer buffer; 2 | 3 | [numthreads(64, 1, 1)] 4 | void main( uint3 dispatchThreadID : SV_DispatchThreadID) 5 | { 6 | if(dispatchThreadID.x == 0) 7 | buffer.Store(0, 2); 8 | } -------------------------------------------------------------------------------- /Test/hlsl.string.frag: -------------------------------------------------------------------------------- 1 | string s = "string1"; 2 | string e = ""; 3 | string bracket < string a = "nested" ; > ; 4 | string brackets < string b = "nest1" ; string c = "nest2" ; float test [ 4 ] = { 1.0 , 1.0 , 1.0 , 1.0 } ; vector a = float3(2.0); > ; 5 | string brackete1 < > ; 6 | string brackete2 < ; > ; 7 | string brackete3 < ; ; > ; 8 | 9 | float main(float f) 10 | { 11 | return f; 12 | } -------------------------------------------------------------------------------- /Test/hlsl.struct.split.assign.frag: -------------------------------------------------------------------------------- 1 | struct S { 2 | float f; 3 | float4 pos : SV_Position; 4 | }; 5 | 6 | float4 main(int i, S input[3]) : COLOR0 7 | { 8 | S a[3]; 9 | input = a; 10 | 11 | return a[1].pos; 12 | } 13 | -------------------------------------------------------------------------------- /Test/hlsl.structStructName.frag: -------------------------------------------------------------------------------- 1 | struct S { int s; }; 2 | 3 | int main() 4 | { 5 | struct S t; 6 | return t.s; 7 | } 8 | -------------------------------------------------------------------------------- /Test/hlsl.structbuffer.append.frag: -------------------------------------------------------------------------------- 1 | AppendStructuredBuffer sbuf_a; 2 | ConsumeStructuredBuffer sbuf_c; 3 | 4 | AppendStructuredBuffer sbuf_unused; 5 | 6 | float4 main(uint pos : FOO) : SV_Target0 7 | { 8 | sbuf_a.Append(float4(1,2,3,4)); 9 | 10 | return sbuf_c.Consume(); 11 | } 12 | -------------------------------------------------------------------------------- /Test/hlsl.structbuffer.byte.frag: -------------------------------------------------------------------------------- 1 | 2 | ByteAddressBuffer sbuf; 3 | 4 | float4 main(uint pos : FOO) : SV_Target0 5 | { 6 | uint size; 7 | sbuf.GetDimensions(size); 8 | 9 | return sbuf.Load(pos) + 10 | float4(sbuf.Load2(pos+4), 0, 0) + 11 | float4(sbuf.Load3(pos+8), 0) + 12 | sbuf.Load4(pos+12); 13 | } 14 | -------------------------------------------------------------------------------- /Test/hlsl.structbuffer.rwbyte.frag: -------------------------------------------------------------------------------- 1 | 2 | RWByteAddressBuffer sbuf; 3 | 4 | float4 main(uint pos : FOO) : SV_Target0 5 | { 6 | uint size; 7 | sbuf.GetDimensions(size); 8 | 9 | sbuf.Store(pos, sbuf.Load(pos)); 10 | sbuf.Store2(pos, sbuf.Load2(pos)); 11 | sbuf.Store3(pos, sbuf.Load3(pos)); 12 | sbuf.Store4(pos, sbuf.Load4(pos)); 13 | 14 | return sbuf.Load(pos); 15 | } 16 | -------------------------------------------------------------------------------- /Test/hlsl.structbuffer.rwbyte2.comp: -------------------------------------------------------------------------------- 1 | RWStructuredBuffer g_sbuf; 2 | RWByteAddressBuffer g_bbuf; 3 | 4 | 5 | void main() 6 | { 7 | uint f = g_bbuf.Load(16); 8 | g_sbuf[0] = f; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /Test/hlsl.swizzle.frag: -------------------------------------------------------------------------------- 1 | static float4 AmbientColor = float4(1, 0.5, 0, 1); 2 | 3 | float4 ShaderFunction(float4 input) : COLOR0 4 | { 5 | return input.wwyx * float4(AmbientColor.z); 6 | } 7 | -------------------------------------------------------------------------------- /Test/hlsl.swizzle.vec1.comp: -------------------------------------------------------------------------------- 1 | void main() 2 | { 3 | float1 f1; 4 | f1.x = 0.5; 5 | 6 | // This is not implemented 7 | // f1.xx = float2(0.6, 0.7); 8 | } 9 | -------------------------------------------------------------------------------- /Test/hlsl.synthesizeInput.frag: -------------------------------------------------------------------------------- 1 | struct PSInput { 2 | float interp; 3 | uint no_interp; 4 | }; 5 | 6 | float4 main(PSInput input : INPUT) : SV_TARGET 7 | { 8 | return float4(float(input.no_interp), input.interp, 0, 1); 9 | } -------------------------------------------------------------------------------- /Test/hlsl.target.frag: -------------------------------------------------------------------------------- 1 | struct PSInput { 2 | float interp; 3 | uint no_interp; 4 | }; 5 | 6 | void main(PSInput input : INPUT, out float4 out1 : SV_TARGET1, out float4 out2 : SV_TARGET3) 7 | { 8 | out1 = 1; 9 | out2 = 0; 10 | } -------------------------------------------------------------------------------- /Test/hlsl.texturebuffer.frag: -------------------------------------------------------------------------------- 1 | 2 | struct Data { 3 | float4 f; 4 | int4 i; 5 | }; 6 | 7 | TextureBuffer TextureBuffer_var : register(t0); 8 | 9 | tbuffer tbuf2 { 10 | float4 f2; 11 | int4 i2; 12 | }; 13 | 14 | float4 main(float4 pos : SV_POSITION) : SV_TARGET 15 | { 16 | return TextureBuffer_var.f + f2; 17 | } 18 | -------------------------------------------------------------------------------- /Test/hlsl.typeGraphCopy.vert: -------------------------------------------------------------------------------- 1 | struct N1 { 2 | int a; 3 | float b; 4 | }; 5 | 6 | struct N2 { 7 | N1 s1; 8 | N1 s2; 9 | }; 10 | 11 | struct N3 { 12 | N2 t1; 13 | N1 t2; 14 | N2 t3; 15 | }; 16 | 17 | typedef N3 T3; 18 | 19 | T3 foo; 20 | 21 | float main() 22 | { 23 | return foo.t3.s2.b; 24 | } 25 | -------------------------------------------------------------------------------- /Test/hlsl.typedef.frag: -------------------------------------------------------------------------------- 1 | typedef float4 myVec4; 2 | 3 | float4 ShaderFunction(float4 input, int ii) : COLOR0 4 | { 5 | typedef int myInt; 6 | myVec4 a1 = myVec4(1.0); 7 | myInt i = 2; 8 | typedef myInt myInt2; 9 | myInt2 j = ii; 10 | return input * a1 + myVec4(i + j); 11 | } 12 | -------------------------------------------------------------------------------- /Test/hlsl.void.frag: -------------------------------------------------------------------------------- 1 | void foo1() {} 2 | void foo2(void) {} 3 | 4 | void PixelShaderFunction(float4 input) : COLOR0 5 | { 6 | foo1(); 7 | foo2(); 8 | return; 9 | } -------------------------------------------------------------------------------- /Test/hlsl.w-recip.frag: -------------------------------------------------------------------------------- 1 | float4 AmbientColor = float4(1, 0.5, 0, 1); 2 | float4 AmbientColor2 = float4(0.5, 1, 0, 0); 3 | 4 | float4 main(float4 vpos : SV_POSITION) : SV_TARGET 5 | { 6 | float4 vpos_t = float4(vpos.xyz, 1 / vpos.w); 7 | if (vpos_t.x < 400) 8 | return AmbientColor; 9 | else 10 | return AmbientColor2; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /Test/hlsl.wavequery.comp: -------------------------------------------------------------------------------- 1 | RWStructuredBuffer data; 2 | 3 | [numthreads(32, 16, 1)] 4 | void CSMain() 5 | { 6 | data[WaveGetLaneIndex()] = (WaveIsFirstLane()) ? WaveGetLaneCount() : 0; 7 | } 8 | -------------------------------------------------------------------------------- /Test/hlsl.wavequery.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction() : COLOR0 2 | { 3 | if (WaveIsFirstLane()) 4 | { 5 | return float4(1, 2, 3, 4); 6 | } 7 | else 8 | { 9 | return float4(4, 3, 2, 1); 10 | } 11 | } 12 | -------------------------------------------------------------------------------- /Test/hlsl.whileLoop.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | while (any(input != input)) { return input; } 4 | while (false) ; 5 | [unroll] while (false) { } 6 | while ((false)) { } 7 | } 8 | -------------------------------------------------------------------------------- /Test/hlsl.y-negate-1.vert: -------------------------------------------------------------------------------- 1 | 2 | // Test Y negation from entry point return 3 | 4 | float4 pos; 5 | 6 | float4 main() : SV_Position 7 | { 8 | return pos; 9 | } 10 | -------------------------------------------------------------------------------- /Test/hlsl.y-negate-2.vert: -------------------------------------------------------------------------------- 1 | // Test Y negation from entry point out parameter 2 | 3 | float4 pos; 4 | 5 | void main(out float4 position : SV_Position) 6 | { 7 | position = pos; 8 | } 9 | -------------------------------------------------------------------------------- /Test/hlsl.y-negate-3.vert: -------------------------------------------------------------------------------- 1 | // Test Y negation from entry point out parameter 2 | 3 | float4 position; 4 | 5 | struct VS_OUT { 6 | float4 pos : SV_Position; 7 | int somethingelse; 8 | }; 9 | 10 | VS_OUT main() 11 | { 12 | VS_OUT vsout; 13 | 14 | vsout.pos = position; 15 | vsout.somethingelse = 42; 16 | 17 | return vsout; 18 | } 19 | -------------------------------------------------------------------------------- /Test/i1.h: -------------------------------------------------------------------------------- 1 | u = g_nDataIdx; 2 | -------------------------------------------------------------------------------- /Test/implicitArraySize.frag: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | in float a[]; 3 | in float c[3]; 4 | out float b[5]; 5 | 6 | void main(){ 7 | b[0] = a[1]; 8 | b[1] = c[1]; 9 | } -------------------------------------------------------------------------------- /Test/implicitArraySize.vert: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | out float a[]; 3 | out float c[]; 4 | 5 | void main(){ 6 | a[0] = 0.1; 7 | c[5] = 0.1; 8 | } -------------------------------------------------------------------------------- /Test/implicitArraySize1.geom: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | layout(triangles) in; 4 | layout(line_strip, max_vertices = 204) out; 5 | 6 | void f(); 7 | 8 | in float g[][3]; 9 | out float o[3]; 10 | 11 | void main(){ 12 | f(); 13 | o[1] = g[2][1]; 14 | } -------------------------------------------------------------------------------- /Test/implicitArraySize2.geom: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | in float g[][3]; 4 | out float o[]; 5 | 6 | void f(){ 7 | o[1] = g[1][1]; 8 | } -------------------------------------------------------------------------------- /Test/implicitArraySizeBuiltin.geom: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | layout(triangles) in; 4 | layout(line_strip, max_vertices = 204) out; 5 | 6 | void f2(float x) 7 | { 8 | gl_ClipDistance[6] = gl_in[0].gl_ClipDistance[6]; 9 | } 10 | void f3(float x) 11 | { 12 | gl_CullDistance[1] = gl_in[0].gl_CullDistance[1]; 13 | } 14 | 15 | void main(){ 16 | #if defined(CLIP) 17 | f2(0.1); 18 | #endif 19 | f3(0.1); 20 | } -------------------------------------------------------------------------------- /Test/implicitArraySizeBuiltin.vert: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | void f1(float x) 4 | { 5 | gl_ClipDistance[6] = x; 6 | gl_CullDistance[1] = x; 7 | } 8 | 9 | void main(){ 10 | f1(0.1); 11 | } -------------------------------------------------------------------------------- /Test/implicitInnerAtomicUint.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | layout(binding = 0) uniform atomic_uint c[1][]; -------------------------------------------------------------------------------- /Test/inc1/badInc.h: -------------------------------------------------------------------------------- 1 | #include "parentBad" 2 | -------------------------------------------------------------------------------- /Test/inc1/bar.h: -------------------------------------------------------------------------------- 1 | float4 i2; 2 | 3 | #include "foo.h" 4 | -------------------------------------------------------------------------------- /Test/inc1/foo.h: -------------------------------------------------------------------------------- 1 | #include "parent.h" 2 | 3 | float4 i3; 4 | -------------------------------------------------------------------------------- /Test/inc1/path1/bar.h: -------------------------------------------------------------------------------- 1 | float4 i9991; 2 | -------------------------------------------------------------------------------- /Test/inc1/path1/local.h: -------------------------------------------------------------------------------- 1 | float4 p2; 2 | -------------------------------------------------------------------------------- /Test/inc1/path1/notHere.h: -------------------------------------------------------------------------------- 1 | float4 p1; 2 | 3 | #include "local.h" 4 | #include "remote.h" 5 | -------------------------------------------------------------------------------- /Test/inc1/path2/bar.h: -------------------------------------------------------------------------------- 1 | float4 i9991; 2 | -------------------------------------------------------------------------------- /Test/inc1/path2/notHere.h: -------------------------------------------------------------------------------- 1 | float4 paoeu1; 2 | -------------------------------------------------------------------------------- /Test/inc1/path2/remote.h: -------------------------------------------------------------------------------- 1 | float4 p3; 2 | -------------------------------------------------------------------------------- /Test/inc2/bar.h: -------------------------------------------------------------------------------- 1 | #include "foo.h" 2 | float4 i5; 3 | -------------------------------------------------------------------------------- /Test/inc2/foo.h: -------------------------------------------------------------------------------- 1 | float4 i6; 2 | -------------------------------------------------------------------------------- /Test/include.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_GOOGLE_include_directive : enable 4 | 5 | #define float4 vec4 6 | 7 | #include "bar.h" 8 | #include "./inc1/bar.h" 9 | #include "inc2\bar.h" 10 | 11 | out vec4 color; 12 | 13 | void main() 14 | { 15 | color = i1 + i2 + i3 + i4 + i5 + i6; 16 | } 17 | -------------------------------------------------------------------------------- /Test/index_outside_sample_mask_range.frag: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | layout (location = 0) out mediump vec4 fs_color; 3 | void main() 4 | { 5 | const highp int invalidIndex = (gl_MaxSamples + 31) / 32; 6 | highp int invalidValue = gl_SampleMask[invalidIndex]; 7 | fs_color = vec4(1.0f, 0.0f, 0.0f, 1.0f); 8 | } 9 | -------------------------------------------------------------------------------- /Test/invalidSwizzle.vert: -------------------------------------------------------------------------------- 1 | #version 420 2 | 3 | void f(); 4 | uniform sampler2D s; 5 | 6 | void main() { 7 | vec2 v = s.rr; // Swizzles do not apply to samplers 8 | f().xx; // Scalar swizzle does not apply to void 9 | f().xy; // Vector swizzle does not apply either 10 | } -------------------------------------------------------------------------------- /Test/iomap.blockOutVariableIn.2.vert: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | layout(location = 0) out Block 4 | { 5 | vec4 a1; 6 | vec2 a2; 7 | }; 8 | 9 | void main() 10 | { 11 | a1 = vec4(1.0); 12 | a2 = vec2(0.5); 13 | gl_Position = vec4(1.0); 14 | } 15 | -------------------------------------------------------------------------------- /Test/iomap.blockOutVariableIn.frag: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | layout(location = 0) in vec4 a1; 4 | layout(location = 1) in vec2 a2; 5 | 6 | layout(location = 0) out vec4 color; 7 | 8 | void main() 9 | { 10 | color = vec4(a1.xy, a2); 11 | } 12 | -------------------------------------------------------------------------------- /Test/iomap.blockOutVariableIn.vert: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | layout(location = 0) out Block 4 | { 5 | vec4 a1; 6 | vec2 a2; 7 | }; 8 | 9 | void main() 10 | { 11 | a1 = vec4(1.0); 12 | a2 = vec2(0.5); 13 | gl_Position = vec4(1.0); 14 | } 15 | -------------------------------------------------------------------------------- /Test/iomap.mismatchedBufferTypes.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | // GLSL spec: Hence, the types, initializers, and any location specifiers of all statically used uniform 4 | // variables with the same name must match across all shaders that are linked into a single program 5 | uniform crossStageBlock { 6 | float a; 7 | // 2nd member from vert absent in frag 8 | } blockname; 9 | 10 | void main() {} -------------------------------------------------------------------------------- /Test/iomap.mismatchedBufferTypes.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | // GLSL spec: Hence, the types, initializers, and any location specifiers of all statically used uniform 4 | // variables with the same name must match across all shaders that are linked into a single program 5 | uniform crossStageBlock { 6 | float a; 7 | float b; // not present in frag 8 | } blockname; 9 | 10 | void main() {} -------------------------------------------------------------------------------- /Test/iomap.variableOutBlockIn.2.vert: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | layout(location = 0) out vec4 a1; 4 | layout(location = 1) out vec2 a2; 5 | 6 | void main() 7 | { 8 | a1 = vec4(1.0); 9 | a2 = vec2(0.5); 10 | gl_Position = vec4(1.0); 11 | } 12 | -------------------------------------------------------------------------------- /Test/iomap.variableOutBlockIn.frag: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | layout(location = 0) in Inputs { 4 | vec4 a1; 5 | vec2 a2; 6 | }; 7 | 8 | layout(location = 0) out vec4 color; 9 | 10 | void main() 11 | { 12 | color = vec4(a1.xy, a2); 13 | } 14 | -------------------------------------------------------------------------------- /Test/iomap.variableOutBlockIn.vert: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | layout(location = 0) out vec4 a1; 4 | layout(location = 1) out vec2 a2; 5 | 6 | void main() 7 | { 8 | a1 = vec4(1.0); 9 | a2 = vec2(0.5); 10 | gl_Position = vec4(1.0); 11 | } 12 | -------------------------------------------------------------------------------- /Test/length.frag: -------------------------------------------------------------------------------- 1 | #version 120 2 | 3 | uniform vec4 u[3]; 4 | 5 | #ifdef TEST_POST_110 6 | varying vec2 v[]; 7 | #else 8 | varying vec2 v[2]; 9 | #endif 10 | 11 | void main() 12 | { 13 | int a[5]; 14 | 15 | vec2 t = v[0] + v[1]; 16 | 17 | gl_FragColor = vec4(u.length() * v.length() * a.length()); 18 | } 19 | -------------------------------------------------------------------------------- /Test/link.missingCrossStageIO.0.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void main() { 4 | } 5 | -------------------------------------------------------------------------------- /Test/link.redeclareBuiltin.vert: -------------------------------------------------------------------------------- 1 | #version 410 2 | 3 | out gl_PerVertex 4 | { 5 | vec4 gl_Position; 6 | }; 7 | 8 | void main() 9 | { 10 | gl_Position = vec4(1.0); 11 | } -------------------------------------------------------------------------------- /Test/link.tesselation.frag: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | layout(location = 0) in Primitive 4 | { 5 | vec2 texCoord; 6 | } IN; 7 | 8 | layout(location = 0) out vec4 oColor; 9 | 10 | layout(binding = 0) uniform sampler2D mytex; 11 | 12 | void main() 13 | { 14 | oColor = texture(mytex, IN.texCoord); 15 | } 16 | -------------------------------------------------------------------------------- /Test/link.tesselation.vert: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | layout(location = 0) in vec4 i_Pos; 4 | layout(location = 1) in vec2 i_Tex; 5 | 6 | layout(location = 0) out Primitive 7 | { 8 | vec2 texCoord; 9 | } OUT; 10 | 11 | void main() 12 | { 13 | gl_Position = i_Pos; 14 | OUT.texCoord = i_Tex; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /Test/link.vk.differentPC.0.0.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location=0) out vec4 color; 4 | 5 | layout (push_constant) uniform PushConstantBlock 6 | { 7 | vec4 color; 8 | vec4 color2; 9 | float scale; 10 | } uPC; 11 | 12 | vec4 getColor2(); 13 | float getScale(); 14 | 15 | void main() 16 | { 17 | color = uPC.color + getColor2() * getScale(); 18 | } 19 | -------------------------------------------------------------------------------- /Test/link.vk.differentPC.0.1.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (push_constant) uniform PushConstantBlock 4 | { 5 | vec4 color; 6 | vec4 color2; 7 | float scale; 8 | } uPC; 9 | 10 | vec4 11 | getColor2() 12 | { 13 | return uPC.color2; 14 | } 15 | -------------------------------------------------------------------------------- /Test/link.vk.differentPC.0.2.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (push_constant) uniform PushConstantBlock 4 | { 5 | vec4 color; 6 | vec4 color2; 7 | float scale2; 8 | } uPC; 9 | 10 | float 11 | getScale() 12 | { 13 | return uPC.scale2; 14 | } 15 | 16 | -------------------------------------------------------------------------------- /Test/link.vk.differentPC.1.0.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (push_constant) uniform PushConstantBlock 4 | { 5 | vec4 color; 6 | vec4 color2; 7 | float scale; 8 | float scale2; 9 | } uPC; 10 | 11 | float 12 | getScale() 13 | { 14 | return uPC.scale; 15 | } 16 | 17 | -------------------------------------------------------------------------------- /Test/link.vk.differentPC.1.1.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (push_constant) uniform PushConstantBlock 4 | { 5 | vec4 color; 6 | vec4 color2; 7 | float scale; 8 | } uPC; 9 | 10 | vec4 11 | getColor2() 12 | { 13 | return uPC.color2; 14 | } 15 | -------------------------------------------------------------------------------- /Test/link.vk.differentPC.1.2.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location=0) out vec4 color; 4 | 5 | layout (push_constant) uniform PushConstantBlock 6 | { 7 | vec4 color; 8 | vec4 color2; 9 | float scale; 10 | } uPC; 11 | 12 | vec4 getColor2(); 13 | float getScale(); 14 | 15 | void main() 16 | { 17 | color = uPC.color + getColor2() * getScale(); 18 | } 19 | -------------------------------------------------------------------------------- /Test/link.vk.matchingPC.0.0.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location=0) out vec4 color; 4 | 5 | layout (push_constant) uniform PushConstantBlock 6 | { 7 | vec4 color; 8 | vec4 color2; 9 | float scale; 10 | } uPC; 11 | 12 | vec4 getColor2(); 13 | float getScale(); 14 | 15 | void main() 16 | { 17 | color = uPC.color + getColor2() * getScale(); 18 | } 19 | -------------------------------------------------------------------------------- /Test/link.vk.matchingPC.0.1.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (push_constant) uniform PushConstantBlock 4 | { 5 | vec4 color; 6 | vec4 color2; 7 | float scale; 8 | } uPC; 9 | 10 | vec4 11 | getColor2() 12 | { 13 | return uPC.color2; 14 | } 15 | -------------------------------------------------------------------------------- /Test/link.vk.matchingPC.0.2.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (push_constant) uniform PushConstantBlock 4 | { 5 | vec4 color; 6 | vec4 color2; 7 | float scale; 8 | } uPC; 9 | 10 | float 11 | getScale() 12 | { 13 | return uPC.scale; 14 | } 15 | -------------------------------------------------------------------------------- /Test/link.vk.missingCrossStageIO.0.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void main() { 4 | } 5 | -------------------------------------------------------------------------------- /Test/link.vk.pcNamingInvalid.0.0.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | layout (push_constant) uniform Block 3 | { 4 | mat4 uWorld; 5 | mat4 uProj; 6 | vec4 color1; 7 | vec4 color2; 8 | } a; 9 | 10 | vec4 getWorld(); 11 | vec4 getColor2(); 12 | 13 | out vec4 oColor; 14 | 15 | void 16 | main() 17 | { 18 | oColor = a.color1 * getColor2(); 19 | 20 | gl_Position = a.uProj * getWorld(); 21 | } 22 | -------------------------------------------------------------------------------- /Test/link.vk.pcNamingInvalid.0.1.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (push_constant) uniform Block2 4 | { 5 | mat4 uWorld; 6 | mat4 uProj; 7 | vec4 color1; 8 | vec4 color2; 9 | } a; 10 | 11 | in vec4 P; 12 | 13 | vec4 getColor2() 14 | { 15 | return a.color2; 16 | } 17 | 18 | vec4 getWorld() 19 | { 20 | return a.uWorld * P; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /Test/link.vk.pcNamingValid.0.0.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | layout (push_constant) uniform PCBlock 3 | { 4 | mat4 uWorld; 5 | mat4 uProj; 6 | vec4 color1; 7 | vec4 color2; 8 | } a; 9 | 10 | vec4 getWorld(); 11 | vec4 getColor2(); 12 | 13 | layout(location = 0) out vec4 oColor; 14 | 15 | void 16 | main() 17 | { 18 | oColor = a.color1 * getColor2(); 19 | 20 | gl_Position = a.uProj * getWorld(); 21 | } 22 | -------------------------------------------------------------------------------- /Test/link.vk.pcNamingValid.0.1.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (push_constant) uniform PCBlock 4 | { 5 | mat4 uWorld; 6 | mat4 uProj; 7 | vec4 color1; 8 | vec4 color2; 9 | } b; 10 | 11 | layout(location = 0) in vec4 P; 12 | 13 | vec4 getColor2() 14 | { 15 | return b.color2; 16 | } 17 | 18 | vec4 getWorld() 19 | { 20 | return b.uWorld * P; 21 | } 22 | 23 | -------------------------------------------------------------------------------- /Test/link3.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | precision highp float; 4 | 5 | in vec2 iv3; 6 | 7 | #extension GL_OES_standard_derivatives : enable 8 | #extension GL_OES_EGL_image_external : require 9 | #extension GL_OES_texture_3D : enable 10 | -------------------------------------------------------------------------------- /Test/location_aliasing.tesc: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | #extension GL_ARB_enhanced_layouts : require 3 | 4 | layout(vertices = 1) out; 5 | 6 | layout (location = 1, component = 0) in double gohan[]; 7 | layout (location = 1, component = 2) in float goten[]; 8 | 9 | 10 | in vec4 vs_tcs[]; 11 | out vec4 tcs_tes[]; 12 | 13 | void main() 14 | { 15 | } -------------------------------------------------------------------------------- /Test/location_aliasing1.frag: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | #extension GL_ARB_enhanced_layouts : require 3 | 4 | 5 | layout (location = 1, component = 0) in smooth float in1; 6 | layout (location = 1, component = 2) in flat float in2; 7 | 8 | void main() 9 | { 10 | } -------------------------------------------------------------------------------- /Test/mains.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | void main() 4 | { 5 | } 6 | 7 | void main() 8 | { 9 | } 10 | -------------------------------------------------------------------------------- /Test/mains1.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /Test/mains2.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /Test/maxClipDistances.vert: -------------------------------------------------------------------------------- 1 | #version 130 2 | 3 | out float gl_ClipDistance[8]; // OK, 8 is gl_MaxClipDistances 4 | 5 | void main() 6 | { 7 | } 8 | -------------------------------------------------------------------------------- /Test/max_vertices_0.geom: -------------------------------------------------------------------------------- 1 | #version 330 2 | 3 | layout(points) in; 4 | layout(triangle_strip, max_vertices = 0) out; 5 | in highp vec4 v_geom_FragColor[]; 6 | out highp vec4 v_frag_FragColor; 7 | 8 | void main (void) 9 | { 10 | EndPrimitive(); 11 | EndPrimitive(); 12 | } 13 | -------------------------------------------------------------------------------- /Test/missingBodies.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | void bar(); 4 | void foo() { bar(); } 5 | 6 | void B(); 7 | void C(int); 8 | void C(int, int) { } 9 | void C(bool); 10 | void A() { B(); C(1); C(true); C(1, 2); } 11 | 12 | void main() 13 | { 14 | foo(); 15 | C(true); 16 | } 17 | 18 | int ret1(); 19 | 20 | int f1 = ret1(); 21 | 22 | int ret2() { return 3; } 23 | 24 | int f2 = ret2(); 25 | -------------------------------------------------------------------------------- /Test/negativeArraySize.comp: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #ifdef GL_ES 4 | precision mediump float; 5 | #endif 6 | 7 | void main() 8 | { 9 | float f[-2]; // cannot declare arrays with negative size 10 | } 11 | -------------------------------------------------------------------------------- /Test/negativeWorkGroupSize.comp: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void fn(){ 4 | uvec3 wgs = gl_WorkGroupSize; // error: fixed workgroup size has not been declared 5 | } 6 | 7 | layout(local_size_x = 64) in; // declare workgroup size 8 | 9 | void main(){ 10 | fn(); 11 | uvec3 wgs = gl_WorkGroupSize; // valid 12 | } 13 | -------------------------------------------------------------------------------- /Test/noMain.vert: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | void foo() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /Test/noMain1.geom: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | void foo() 4 | { 5 | } 6 | 7 | layout(points) out; -------------------------------------------------------------------------------- /Test/noMain2.geom: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | void bar() 4 | { 5 | } 6 | 7 | layout(line_strip) out; 8 | -------------------------------------------------------------------------------- /Test/noMatchingFunction.frag: -------------------------------------------------------------------------------- 1 | #version 330 2 | 3 | struct S 4 | { 5 | float a; 6 | }; 7 | 8 | float func(S s) 9 | { 10 | return s.a; 11 | } 12 | 13 | layout(location = 0) out vec4 o_color; 14 | 15 | void main() 16 | { 17 | float c = func(1.0f); // ERROR: no matching function 18 | o_color = vec4(c); 19 | } 20 | -------------------------------------------------------------------------------- /Test/nonVulkan.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(constant_id = 17) const int arraySize = 12; // ERROR 4 | layout(input_attachment_index = 1) int foo; // ERROR 5 | layout(push_constant) uniform ubn { int a; } ubi; // ERROR 6 | 7 | #ifdef VULKAN 8 | #error VULKAN should not be defined 9 | #endif 10 | -------------------------------------------------------------------------------- /Test/nosuffix: -------------------------------------------------------------------------------- 1 | void main() 2 | { 3 | gl_Position = vec4(1.0); 4 | } -------------------------------------------------------------------------------- /Test/nvShaderNoperspectiveInterpolation.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | precision mediump float; 4 | 5 | noperspective in vec4 bad; // ERROR 6 | 7 | #extension GL_NV_shader_noperspective_interpolation : enable 8 | 9 | noperspective in vec4 color; 10 | 11 | out vec4 fragColor; 12 | 13 | void main() { 14 | fragColor = color; 15 | } -------------------------------------------------------------------------------- /Test/parent.h: -------------------------------------------------------------------------------- 1 | float4 i4; 2 | -------------------------------------------------------------------------------- /Test/parentBad: -------------------------------------------------------------------------------- 1 | int a; 2 | 3 | #error bad parent 4 | -------------------------------------------------------------------------------- /Test/pointCoord.frag: -------------------------------------------------------------------------------- 1 | precision highp float; 2 | 3 | uniform sampler2D sampler; 4 | 5 | void main() 6 | { 7 | vec4 color; 8 | 9 | if (length(gl_PointCoord) < 0.3) 10 | color = texture2D(sampler, gl_PointCoord); 11 | else 12 | color = vec4(0.0); 13 | 14 | gl_FragColor = color; 15 | } 16 | -------------------------------------------------------------------------------- /Test/preprocess.arb_shading_language_include.vert: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | #extension GL_ARB_shading_language_include : enable 4 | 5 | #define float4 vec4 6 | 7 | #include "bar.h" 8 | 9 | out vec4 color; 10 | 11 | void main() 12 | { 13 | color = i1 + vec4(1.0); 14 | } 15 | -------------------------------------------------------------------------------- /Test/preprocess.include_directive_missing_extension.vert: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | #include "bar.h" 4 | 5 | void main() {} 6 | 7 | -------------------------------------------------------------------------------- /Test/preprocessor.bad_arg.vert: -------------------------------------------------------------------------------- 1 | #define M(a) a 2 | int M(aou 3 | = 2) // Okay, one argument, split across newline 4 | ; 5 | 6 | // end of file during an argument 7 | #define EXP2(a, b) 8 | EXP2(((((1,2,3,4))), ); 9 | -------------------------------------------------------------------------------- /Test/preprocessor.defined.vert: -------------------------------------------------------------------------------- 1 | #define defined_not_really 2 | #define defined // ERROR: "defined" can't be (un)defined: 3 | -------------------------------------------------------------------------------- /Test/preprocessor.edge_cases.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | #define X(Y) /* 3 | */ Y + 2 4 | 5 | #define Y(Z) 2 * Z// asdf 6 | 7 | #define Z(Y) /* 8 | */ \ 9 | 2 /* 10 | */ + 3 \ 11 | * Y 12 | 13 | void main() { 14 | gl_Position = vec4(X(3) + Y(4) + Z(2)); 15 | } 16 | -------------------------------------------------------------------------------- /Test/preprocessor.eof_missing.vert: -------------------------------------------------------------------------------- 1 | noEOF -------------------------------------------------------------------------------- /Test/preprocessor.errors.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #define X 1 4 | 5 | #if X 6 | #ifdef Y 7 | #error This should not show up in pp output. 8 | #endif 9 | #error This should show up in pp output. 10 | #else 11 | #error This should not show up in pp output. 12 | #endif 13 | 14 | #def X 15 | #if Y 16 | 17 | #extension a 18 | 19 | int main() { 20 | } 21 | -------------------------------------------------------------------------------- /Test/preprocessor.extensions.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #extension GL_EXT_geometry_shader: enable 4 | #extension GL_EXT_frag_depth: disable 5 | #extension GL_EXT_gpu_shader5: require 6 | #extension GL_EXT_shader_texture_image_samples: warn 7 | 8 | #extension unknown_extension: require 9 | 10 | int main() { 11 | } 12 | 13 | -------------------------------------------------------------------------------- /Test/preprocessor.include.disabled.vert: -------------------------------------------------------------------------------- 1 | #line 8000 2 | #include 3 | #include 123 4 | #include "foo" 5 | #include "foo" garbage 6 | #include "no-eol" -------------------------------------------------------------------------------- /Test/preprocessor.line.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | #line 1 2 3 | #pragma something 4 | void main() {} 5 | -------------------------------------------------------------------------------- /Test/preprocessor.many.endif.vert: -------------------------------------------------------------------------------- 1 | #endif 2 | #endif 3 | #endif 4 | #endif 5 | #endif 6 | #endif 7 | #endif 8 | 9 | #if 10 | #else 11 | -------------------------------------------------------------------------------- /Test/preprocessor.pragma.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #pragma optimize(on) 4 | #pragma optimize(off) 5 | #pragma debug(on) 6 | #pragma debug(off) 7 | 8 | #pragma undefined_pragma(x, 4) 9 | 10 | #pragma once 11 | 12 | int main() { 13 | } 14 | -------------------------------------------------------------------------------- /Test/preprocessor.success_if_parse_would_fail.vert: -------------------------------------------------------------------------------- 1 | int x() { 2 | something that shouldnt compile; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /Test/ps_sample.frag: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | #extension GL_ARB_enhanced_layouts : require 3 | 4 | layout (location = 1, component = 0) flat in uint gohan; 5 | layout (location = 1, component = 2) sample flat in uvec2 goten; 6 | 7 | in vec4 gs_fs; 8 | out vec4 fs_out; 9 | 10 | void main() 11 | { 12 | vec4 result = gs_fs; 13 | 14 | 15 | 16 | fs_out = result; 17 | } 18 | -------------------------------------------------------------------------------- /Test/ps_uint_int.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location=0, component=0) flat in uint u; 4 | layout(location=0, component=1) flat in int i; 5 | 6 | void main() { 7 | } 8 | -------------------------------------------------------------------------------- /Test/rayQuery-OpConvertUToAccelerationStructureKHR.comp: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | #extension GL_EXT_ray_query : enable 4 | 5 | layout(push_constant, std140) uniform params 6 | { 7 | uvec2 tlas; 8 | }; 9 | 10 | void main() 11 | { 12 | rayQueryEXT rayQuery; 13 | rayQueryInitializeEXT(rayQuery, accelerationStructureEXT(tlas), 0, 0, vec3(0.0), 0.0, vec3(1.0), 1.0); 14 | rayQueryTerminateEXT(rayQuery); 15 | } -------------------------------------------------------------------------------- /Test/rayQuery-initialization.Error.comp: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | #extension GL_EXT_ray_query : enable 4 | 5 | void main () { 6 | rayQueryEXT foo; 7 | rayQueryEXT bar = foo; 8 | } -------------------------------------------------------------------------------- /Test/reflection.frag: -------------------------------------------------------------------------------- 1 | #version 440 core 2 | 3 | in float inval; 4 | 5 | void main() 6 | { 7 | float f = inval; 8 | } 9 | -------------------------------------------------------------------------------- /Test/remap.basic.dcefunc.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in float inf; 4 | out vec4 outf4; 5 | 6 | vec3 dead_fn() { return vec3(0); } 7 | 8 | void main() 9 | { 10 | outf4 = vec4(inf); 11 | } 12 | -------------------------------------------------------------------------------- /Test/remap.basic.everything.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in float inf; 4 | out vec4 outf4; 5 | 6 | vec3 dead_fn() { return vec3(0); } 7 | 8 | void main() 9 | { 10 | outf4 = vec4(inf); 11 | } 12 | -------------------------------------------------------------------------------- /Test/remap.basic.none.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in float inf; 4 | out vec4 outf4; 5 | 6 | vec3 dead_fn() { return vec3(0); } 7 | 8 | void main() 9 | { 10 | outf4 = vec4(inf); 11 | } 12 | -------------------------------------------------------------------------------- /Test/remap.basic.strip.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in float inf; 4 | out vec4 outf4; 5 | 6 | vec3 dead_fn() { return vec3(0); } 7 | 8 | void main() 9 | { 10 | outf4 = vec4(inf); 11 | } 12 | -------------------------------------------------------------------------------- /Test/remap.if.everything.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in float inf; 4 | out vec4 outf4; 5 | 6 | void main() 7 | { 8 | if (inf > 2.0) 9 | outf4 = vec4(inf); 10 | else 11 | outf4 = vec4(inf + -.5); 12 | } 13 | -------------------------------------------------------------------------------- /Test/remap.if.none.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in float inf; 4 | out vec4 outf4; 5 | 6 | void main() 7 | { 8 | if (inf > 2.0) 9 | outf4 = vec4(inf); 10 | else 11 | outf4 = vec4(inf + -.5); 12 | } 13 | -------------------------------------------------------------------------------- /Test/remap.invalid-spirv-1.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/remap.invalid-spirv-1.spv -------------------------------------------------------------------------------- /Test/remap.invalid-spirv-2.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/remap.invalid-spirv-2.spv -------------------------------------------------------------------------------- /Test/remap.literal64.everything.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/remap.literal64.everything.spv -------------------------------------------------------------------------------- /Test/remap.literal64.none.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/remap.literal64.none.spv -------------------------------------------------------------------------------- /Test/remap.specconst.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (local_size_x_id = 0, local_size_y_id = 1, local_size_z_id = 2) in; 4 | 5 | shared int foo[gl_WorkGroupSize.x + gl_WorkGroupSize.y * gl_WorkGroupSize.z]; 6 | 7 | void main () {} 8 | -------------------------------------------------------------------------------- /Test/remap.uniformarray.everything.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | uniform sampler2D texSampler2D; 4 | in vec3 inColor; 5 | in vec4 color[6]; 6 | in float alpha[16]; 7 | 8 | void main() 9 | { 10 | vec4 texColor = color[1] + color[1]; 11 | 12 | texColor.xyz += inColor; 13 | 14 | texColor.a += alpha[12]; 15 | 16 | gl_FragColor = texColor; 17 | } 18 | -------------------------------------------------------------------------------- /Test/remap.uniformarray.none.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | uniform sampler2D texSampler2D; 4 | in vec3 inColor; 5 | in vec4 color[6]; 6 | in float alpha[16]; 7 | 8 | void main() 9 | { 10 | vec4 texColor = color[1] + color[1]; 11 | 12 | texColor.xyz += inColor; 13 | 14 | texColor.a += alpha[12]; 15 | 16 | gl_FragColor = texColor; 17 | } 18 | -------------------------------------------------------------------------------- /Test/simpleFunctionCall.frag: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | uniform vec4 bigColor; 4 | varying vec4 BaseColor; 5 | uniform float d; 6 | 7 | vec4 foo() 8 | { 9 | return BaseColor; 10 | } 11 | 12 | void main() 13 | { 14 | gl_FragColor = foo(); 15 | } 16 | -------------------------------------------------------------------------------- /Test/specExamples.frag: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/specExamples.frag -------------------------------------------------------------------------------- /Test/specExamples.vert: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KhronosGroup/glslang/b888ebcee8ffaa59536b5f33277936536249d9be/Test/specExamples.vert -------------------------------------------------------------------------------- /Test/spv.1.3.8bitstorage-ssbo.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_shader_8bit_storage: require 4 | 5 | layout(binding = 0) readonly buffer Vertices 6 | { 7 | uint8_t vertices[]; 8 | }; 9 | 10 | layout(location = 0) out vec4 color; 11 | 12 | void main() 13 | { 14 | color = vec4(int(vertices[gl_VertexIndex])); 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.1.3.8bitstorage-ubo.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_shader_8bit_storage: require 4 | 5 | layout(binding = 0) readonly uniform Vertices 6 | { 7 | uint8_t vertices[512]; 8 | }; 9 | 10 | layout(location = 0) out vec4 color; 11 | 12 | void main() 13 | { 14 | color = vec4(int(vertices[gl_VertexIndex])); 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.1.4.NonWritable.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location = 0) flat in int index; 4 | 5 | layout(location = 0) out float color; 6 | 7 | // lookup table 8 | const float table[16] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 }; 9 | 10 | void main() 11 | { 12 | color = table[index]; 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.1.4.constructComposite.comp: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | layout(local_size_x=64) in; 4 | 5 | struct sA { 6 | int x, y; 7 | }; 8 | 9 | struct sB { 10 | sA a; 11 | }; 12 | 13 | layout(binding=0,set=0) uniform ubo { 14 | sB b; 15 | }; 16 | 17 | struct sC { 18 | sA state; 19 | } c = { 20 | b.a, 21 | }; 22 | 23 | void main() 24 | { 25 | } 26 | -------------------------------------------------------------------------------- /Test/spv.1.4.funcall.array.frag: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | uniform ub { 4 | vec4 u[9]; 5 | }; 6 | 7 | vec4 f(const vec4 a[9], int ix) { 8 | return a[ix]; 9 | } 10 | 11 | out vec4 color; 12 | 13 | void main() 14 | { 15 | color = f(u, 2); 16 | } 17 | 18 | -------------------------------------------------------------------------------- /Test/spv.1.4.load.bool.array.interface.block.frag: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout(std140, set=0, binding=0) uniform ub { 4 | bool bi[2][3]; 5 | }; 6 | layout(std430, set=0, binding=1) buffer ssbo { 7 | bool bo[2][3]; 8 | }; 9 | 10 | layout(location=0) out vec4 color; 11 | 12 | void main() 13 | { 14 | bo = bi; 15 | color = vec4(0); 16 | } 17 | 18 | -------------------------------------------------------------------------------- /Test/spv.1.6.conditionalDiscard.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | uniform sampler2D tex; 4 | in vec2 coord; 5 | 6 | void main (void) 7 | { 8 | vec4 v = texture(tex, coord); 9 | 10 | if (v == vec4(0.1,0.2,0.3,0.4)) 11 | discard; 12 | 13 | gl_FragColor = v; 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.1.6.helperInvocation.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | precision highp float; 3 | 4 | out vec4 outp; 5 | void main() 6 | { 7 | if (gl_HelperInvocation) 8 | ++outp; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /Test/spv.1.6.helperInvocation.memmodel.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #pragma use_vulkan_memory_model 4 | 5 | #extension GL_EXT_demote_to_helper_invocation : require 6 | 7 | precision highp float; 8 | 9 | layout (set=0, binding=0) buffer B { 10 | float o; 11 | }; 12 | 13 | void main() { 14 | demote; 15 | o = gl_HelperInvocation ? 1.0 : 0.0; 16 | } 17 | -------------------------------------------------------------------------------- /Test/spv.1.6.samplerBuffer.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | out vec4 o; 4 | 5 | uniform isamplerBuffer sampB; 6 | 7 | void main() 8 | { 9 | o.w = float(textureSize(sampB)) / 100.0; 10 | } 11 | 12 | -------------------------------------------------------------------------------- /Test/spv.1.6.separate.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | uniform sampler s; 4 | 5 | uniform textureBuffer texBuffer; 6 | uniform itextureBuffer itexBuffer; 7 | uniform utextureBuffer utexBuffer; 8 | 9 | void main() 10 | { 11 | samplerBuffer (texBuffer, s); 12 | isamplerBuffer (itexBuffer, s); 13 | usamplerBuffer (utexBuffer, s); 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.1.6.specConstant.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(local_size_x_id = 18, local_size_z_id = 19) in; 4 | layout(local_size_x = 32, local_size_y = 32) in; 5 | 6 | buffer bn { 7 | uint a; 8 | } bi; 9 | 10 | void foo(uvec3 wgs) 11 | { 12 | bi.a = wgs.x * gl_WorkGroupSize.y * wgs.z; 13 | } 14 | 15 | void main() 16 | { 17 | foo(gl_WorkGroupSize); 18 | } 19 | -------------------------------------------------------------------------------- /Test/spv.300BuiltIns.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | in mediump float ps; 4 | 5 | invariant gl_Position; 6 | 7 | void main() 8 | { 9 | gl_Position = vec4(ps); 10 | gl_Position *= float(4 - gl_VertexIndex); 11 | 12 | gl_PointSize = ps; 13 | gl_PointSize *= float(5 - gl_InstanceIndex); 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.300layout.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | precision mediump float; 4 | 5 | in vec4 pos; 6 | in vec3 color; 7 | 8 | layout(location = 7) out vec3 c; 9 | layout(LocatioN = 3) out vec4 p[2]; 10 | 11 | struct S { 12 | vec3 c; 13 | float f; 14 | }; 15 | 16 | in S s; 17 | 18 | void main() 19 | { 20 | c = color + s.c; 21 | p[1] = pos * s.f; 22 | } 23 | -------------------------------------------------------------------------------- /Test/spv.430.frag: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | 3 | out vec4 color; 4 | 5 | void main() 6 | { 7 | color = vec4(1.0); 8 | color *= gl_Layer; 9 | color *= gl_ViewportIndex; 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.450.geom: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout(triangles) in; 4 | 5 | layout(line_strip) out; 6 | layout(max_vertices = 127) out; 7 | layout(invocations = 4) in; 8 | 9 | void main() 10 | { 11 | gl_PointSize = gl_in[1].gl_PointSize; 12 | gl_Layer = 2; 13 | gl_ViewportIndex = 3; 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.450.noRedecl.tesc: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout(vertices = 4) out; 4 | 5 | patch out vec4 patchOut; 6 | 7 | void main() 8 | { 9 | gl_in[0].gl_PointSize; 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.460.comp: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void main() 4 | { 5 | bool b1; 6 | b1 = anyInvocation(b1); 7 | b1 = allInvocations(b1); 8 | b1 = allInvocationsEqual(b1); 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.460.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void main() 4 | { 5 | int a = gl_BaseVertex + gl_BaseInstance + gl_DrawID; 6 | } 7 | -------------------------------------------------------------------------------- /Test/spv.8bitstorage-ssbo.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_shader_8bit_storage: require 4 | 5 | layout(binding = 0) readonly buffer Vertices 6 | { 7 | uint8_t vertices[]; 8 | }; 9 | 10 | layout(location = 0) out vec4 color; 11 | 12 | void main() 13 | { 14 | color = vec4(int(vertices[gl_VertexIndex])); 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.8bitstorage-ubo.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_shader_8bit_storage: require 4 | 5 | layout(binding = 0) readonly uniform Vertices 6 | { 7 | uint8_t vertices[512]; 8 | }; 9 | 10 | layout(location = 0) out vec4 color; 11 | 12 | void main() 13 | { 14 | color = vec4(int(vertices[gl_VertexIndex])); 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.ARMCoreBuiltIns.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_ARM_shader_core_builtins: enable 3 | layout(location = 0) out uvec4 data; 4 | void main (void) 5 | { 6 | uint temp = gl_WarpMaxIDARM; 7 | data = uvec4(gl_CoreIDARM, gl_CoreCountARM, gl_CoreMaxIDARM, gl_WarpIDARM + temp); 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.ARMCoreBuiltIns.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_ARM_shader_core_builtins: enable 3 | layout(set = 0, binding = 0, std430) buffer Output 4 | { 5 | uvec4 result; 6 | }; 7 | 8 | void main (void) 9 | { 10 | uint temp = gl_WarpMaxIDARM; 11 | result = uvec4(gl_CoreIDARM, gl_CoreCountARM, gl_CoreMaxIDARM, gl_WarpIDARM + temp); 12 | } 13 | -------------------------------------------------------------------------------- /Test/spv.AnyHitShaderMotion.rahit: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_NV_ray_tracing_motion_blur : enable 3 | void main() 4 | { 5 | float time = gl_CurrentRayTimeNV + 0.5f; 6 | } 7 | -------------------------------------------------------------------------------- /Test/spv.GeometryShaderPassthrough.geom: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_NV_geometry_shader_passthrough : require 3 | 4 | layout(triangles) in; 5 | 6 | layout(passthrough) in gl_PerVertex { 7 | vec4 gl_Position; 8 | }; 9 | 10 | layout(passthrough) in Inputs { 11 | vec2 texcoord; 12 | vec4 baseColor; 13 | }; 14 | 15 | void main() 16 | { 17 | } -------------------------------------------------------------------------------- /Test/spv.IntersectShaderMotion.rint: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_NV_ray_tracing_motion_blur : enable 3 | void main() 4 | { 5 | float time = gl_CurrentRayTimeNV + 0.5f; 6 | } 7 | -------------------------------------------------------------------------------- /Test/spv.OVR_multiview.vert: -------------------------------------------------------------------------------- 1 | #version 330 2 | 3 | #extension GL_OVR_multiview : enable 4 | 5 | layout(num_views = 2) in; 6 | 7 | void main() { 8 | gl_Position = vec4(gl_ViewID_OVR, 0, 0, 0); 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.RayCallable.rcall: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_NV_ray_tracing : enable 3 | layout(location = 0) callableDataNV vec4 data0; 4 | layout(location = 1) callableDataInNV dataBlock { 5 | uint data1; 6 | }; 7 | void main() 8 | { 9 | uvec3 id = gl_LaunchIDNV; 10 | uvec3 size = gl_LaunchSizeNV; 11 | data1 = 256U; 12 | executeCallableNV(2,1); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.WorkgroupMemoryExplicitLayout.16BitAccess.comp: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | 3 | #extension GL_EXT_shared_memory_block : enable 4 | #extension GL_EXT_shader_explicit_arithmetic_types: enable 5 | 6 | layout(local_size_x = 2) in; 7 | 8 | shared first 9 | { 10 | int16_t a; 11 | float16_t f; 12 | }; 13 | 14 | void main() 15 | { 16 | a = int16_t(3); 17 | f = float16_t(12.3); 18 | } 19 | -------------------------------------------------------------------------------- /Test/spv.WorkgroupMemoryExplicitLayout.8BitAccess.comp: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | 3 | #extension GL_EXT_shared_memory_block : enable 4 | #extension GL_EXT_shader_explicit_arithmetic_types: enable 5 | 6 | layout(local_size_x = 2) in; 7 | 8 | shared first 9 | { 10 | int8_t a; 11 | }; 12 | 13 | void main() 14 | { 15 | a = int8_t(2); 16 | } 17 | -------------------------------------------------------------------------------- /Test/spv.WorkgroupMemoryExplicitLayout.MixBlockNonBlock_Errors.comp: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | 3 | #extension GL_EXT_shared_memory_block : enable 4 | 5 | layout(local_size_x = 8) in; 6 | 7 | shared first 8 | { 9 | int a; 10 | }; 11 | 12 | shared int b; 13 | 14 | // Cannot mix shared block and shared non-block, will fail at linking. 15 | 16 | void main() 17 | { 18 | a = 2; 19 | b = 3; 20 | } 21 | -------------------------------------------------------------------------------- /Test/spv.WorkgroupMemoryExplicitLayout.MultiBlock.comp: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | 3 | #extension GL_EXT_shared_memory_block : enable 4 | 5 | layout(local_size_x = 8) in; 6 | 7 | shared first 8 | { 9 | int a; 10 | }; 11 | 12 | shared second 13 | { 14 | int b; 15 | }; 16 | 17 | void main() 18 | { 19 | a = 2; 20 | b = 3; 21 | } 22 | -------------------------------------------------------------------------------- /Test/spv.WorkgroupMemoryExplicitLayout.NonBlock.comp: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | 3 | #extension GL_EXT_shared_memory_block : enable 4 | 5 | layout(local_size_x = 8) in; 6 | 7 | shared int a; 8 | shared int b; 9 | 10 | void main() 11 | { 12 | a = 2; 13 | b = 3; 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.WorkgroupMemoryExplicitLayout.SingleBlock.comp: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | 3 | #extension GL_EXT_shared_memory_block : enable 4 | 5 | layout(local_size_x = 8) in; 6 | 7 | shared first 8 | { 9 | int a; 10 | }; 11 | 12 | void main() 13 | { 14 | a = 2; 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.always-discard2.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | in vec2 tex_coord; 3 | 4 | void main (void) 5 | { 6 | vec4 white = vec4(1.0); 7 | vec4 black = vec4(0.2); 8 | vec4 color = white; 9 | 10 | // First, cut out our circle 11 | float x = tex_coord.x*2.0 - 1.0; 12 | float y = tex_coord.y*2.0 - 1.0; 13 | 14 | discard; 15 | 16 | 17 | gl_FragColor = color; 18 | 19 | } 20 | -------------------------------------------------------------------------------- /Test/spv.atomicRvalue.error.vert: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | void main() { 4 | uint a = 5; 5 | atomicAdd(a * 2, 0); 6 | atomicAdd(a, 0); 7 | } 8 | -------------------------------------------------------------------------------- /Test/spv.barrier.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location=0) out vec4 c0; 4 | layout(location=1) out vec4 c1; 5 | 6 | void main() 7 | { 8 | c0 = vec4(1.0); 9 | memoryBarrier(); 10 | c1 = vec4(1.0); 11 | memoryBarrierBuffer(); 12 | ++c0; 13 | memoryBarrierImage(); 14 | ++c0; 15 | } -------------------------------------------------------------------------------- /Test/spv.bool.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | const bool condition = false; 4 | 5 | uniform ubname { 6 | bool b; 7 | } ubinst; 8 | 9 | bool foo(bool b) 10 | { 11 | return b != condition; 12 | } 13 | 14 | void main() 15 | { 16 | gl_Position = foo(ubinst.b) ? vec4(0.0) : vec4(1.0); 17 | } 18 | -------------------------------------------------------------------------------- /Test/spv.branch-return.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | void main() { 3 | switch (gl_InstanceIndex) { 4 | case 0: return; 5 | case 1: gl_Position = vec4(0.0); break; 6 | case 2: return; 7 | case 3: return; 8 | } 9 | gl_Position.x += 0.123; 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.bufferhandle5.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_buffer_reference : enable 4 | 5 | layout(buffer_reference, std140) buffer t3 { 6 | int h; 7 | }; 8 | 9 | layout(set = 1, binding = 2, std140) uniform t4 { 10 | layout(offset = 0) int j; 11 | t3 k; 12 | } x; 13 | 14 | void main() { 15 | x.k.h = x.j; 16 | } 17 | -------------------------------------------------------------------------------- /Test/spv.builtInXFB.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(xfb_buffer = 1, xfb_stride = 64) out; 4 | 5 | layout (xfb_buffer = 1, xfb_offset = 16) out gl_PerVertex 6 | { 7 | float gl_PointSize; 8 | vec4 gl_Position; 9 | }; 10 | 11 | void main() 12 | { 13 | gl_Position = vec4(1.0); 14 | gl_PointSize = 2.0; 15 | } -------------------------------------------------------------------------------- /Test/spv.builtin.ShadingRateEXT.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_fragment_shading_rate : enable 4 | 5 | out highp int val; 6 | void main () { 7 | val = gl_ShadingRateEXT; 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.computeShaderDerivativesSpec.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_NV_compute_shader_derivatives : require 3 | 4 | layout (local_size_x_id = 0, local_size_y_id = 1) in; 5 | layout(derivative_group_quadsNV) in; 6 | 7 | void main(){ 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.computeShaderDerivativesSpec2.comp: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | #extension GL_NV_compute_shader_derivatives : require 3 | 4 | layout (local_size_x_id = 0, local_size_y_id = 1) in; 5 | layout(derivative_group_linearNV) in; 6 | 7 | void main(){ 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.conditionalDiscard.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | uniform sampler2D tex; 4 | in vec2 coord; 5 | 6 | void main (void) 7 | { 8 | vec4 v = texture(tex, coord); 9 | 10 | if (v == vec4(0.1,0.2,0.3,0.4)) 11 | discard; 12 | 13 | gl_FragColor = v; 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.constStruct.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | precision highp float; 4 | 5 | struct U { 6 | mat2 m; 7 | }; 8 | 9 | struct T { 10 | mat2 m; 11 | }; 12 | 13 | struct S { 14 | T t; 15 | U u; 16 | }; 17 | 18 | void main() 19 | { 20 | S s1 = S(T(mat2(1.0)), U(mat2(1.0))); 21 | S s2 = S(T(mat2(1.0)), U(mat2(1.0))); 22 | } 23 | -------------------------------------------------------------------------------- /Test/spv.constructComposite.comp: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | layout(local_size_x=64) in; 4 | 5 | struct sA { 6 | int x, y; 7 | }; 8 | 9 | struct sB { 10 | sA a; 11 | }; 12 | 13 | layout(binding=0,set=0) uniform ubo { 14 | sB b; 15 | }; 16 | 17 | struct sC { 18 | sA state; 19 | } c = { 20 | b.a, 21 | }; 22 | 23 | void main() 24 | { 25 | } 26 | -------------------------------------------------------------------------------- /Test/spv.dataOut.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | in vec4 Color; 4 | 5 | void main() 6 | { 7 | gl_FragData[1] = Color; 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.dataOutIndirect.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | in vec4 Color; 4 | 5 | out vec4 fcolor[4]; 6 | 7 | uniform b { int i; } bName; 8 | 9 | void main() 10 | { 11 | fcolor[bName.i] = Color; 12 | } 13 | -------------------------------------------------------------------------------- /Test/spv.dataOutIndirect.vert: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | attribute vec4 color; 4 | out vec4 colorOut[6]; 5 | 6 | void main() 7 | { 8 | for (int i = 1; i < 5; ++i) 9 | colorOut[i] = color; 10 | 11 | gl_Position = colorOut[2]; 12 | } 13 | -------------------------------------------------------------------------------- /Test/spv.dead-after-continue.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location =0 ) in int c; 4 | layout(location =0 ) out int o; 5 | 6 | void main() { 7 | int i; 8 | for (i=0; i < 5; i++) { 9 | o = 1; 10 | continue; 11 | o = 2; 12 | } 13 | o = 3; 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.dead-after-discard.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location =0 ) in float c; 4 | layout(location =0 ) out int o; 5 | 6 | void main() { 7 | o = 1; 8 | discard; 9 | o = 3; 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.dead-after-loop-break.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location =0 ) in int c; 4 | layout(location =0 ) out int o; 5 | 6 | void main() { 7 | int i; 8 | o = 1; 9 | for (i=0; i < 5; i++) { 10 | o = 2; 11 | if (i==c) { 12 | o = 3; 13 | break; 14 | o = 4; 15 | } 16 | o = 5; 17 | } 18 | o = 6; 19 | } 20 | -------------------------------------------------------------------------------- /Test/spv.dead-after-return.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location =0 ) in int c; 4 | layout(location =0 ) out int o; 5 | 6 | void main() { 7 | o = 1; 8 | return; 9 | o = 3; 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.dead-after-switch-break.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location =0 ) in int c; 4 | layout(location =0 ) out int o; 5 | 6 | void main() { 7 | int i; 8 | switch(c) { 9 | case 0: o=1; 10 | break; 11 | o=2; 12 | default: break; 13 | } 14 | o = 3; 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.debugPrintf.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_debug_printf : enable 3 | 4 | void main() 5 | { 6 | debugPrintfEXT("ASDF \\ \? \x5C %d %d %d", 1, 2, 3); 7 | 8 | // ABA{backspace}Z 9 | debugPrintfEXT("\x41\x000042\x41\x8Z"); 10 | 11 | // B#${bell, aka \a}B1Z 12 | debugPrintfEXT("\102\043\44\7\1021Z"); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.debugPrintf_Error.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_debug_printf : enable 3 | 4 | void main() 5 | { 6 | // invalid hex sequence 7 | debugPrintfEXT("\xZ"); 8 | 9 | // not an octal sequence 10 | debugPrintfEXT("\8"); 11 | } 12 | -------------------------------------------------------------------------------- /Test/spv.debuginfo.const_params.glsl.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | void function( 4 | const float f, 5 | const vec2 f2, 6 | const vec3 f3, 7 | const vec4 f4) 8 | { 9 | } 10 | 11 | void main() 12 | { 13 | function(0, vec2(0), vec3(0), vec4(0)); 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.debuginfo.include.glsl.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_GOOGLE_include_directive : require 4 | #include "spv.debuginfo.include.glsl.h" 5 | 6 | vec4 mainFileFunction(vec4 v) { 7 | return -v; 8 | } 9 | 10 | void main() { 11 | headerOut = headerFunction(mainFileFunction(headerUboItem)); 12 | } -------------------------------------------------------------------------------- /Test/spv.debuginfo.include.glsl.h: -------------------------------------------------------------------------------- 1 | 2 | out vec4 headerOut; 3 | 4 | uniform UBO { 5 | vec4 headerUboItem; 6 | }; 7 | 8 | vec4 headerFunction(vec4 a) { 9 | return -a; 10 | } -------------------------------------------------------------------------------- /Test/spv.debuginfo.multiline.glsl.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | in float inx; 4 | out float outx; 5 | 6 | float add(float x, float y, float z) { 7 | return 8 | x 9 | + 10 | y 11 | + 12 | z 13 | ; 14 | } 15 | 16 | void main() { 17 | outx 18 | = 19 | add( 20 | inx+1, 21 | inx+2, 22 | inx+3 23 | ) 24 | ; 25 | } -------------------------------------------------------------------------------- /Test/spv.debuginfo.non_ascii.glsl.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | layout(location = 0) out vec4 o; 4 | 5 | void main() 6 | { 7 | // 非 ASCII 文字をテストするコメント (a comment to test non-ASCII characters) 8 | o = vec4(1.0); 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.demoteDisabled.frag: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | void main (void) 4 | { 5 | { 6 | int demote = 0; 7 | demote; 8 | } 9 | demote; 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.depthOut.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in vec4 Color; 4 | in float Depth; 5 | 6 | layout(depth_greater) out float gl_FragDepth; 7 | 8 | void main() 9 | { 10 | gl_FragDepth = Depth; 11 | } 12 | -------------------------------------------------------------------------------- /Test/spv.depthUnchanged.frag: -------------------------------------------------------------------------------- 1 | #version 430 2 | layout(location = 0) out vec4 outColor; 3 | layout(depth_unchanged) out float gl_FragDepth; 4 | void main() { 5 | outColor = vec4(1.0, 0.0, 0.0, 1.0); 6 | gl_FragDepth = gl_FragCoord.y; 7 | } 8 | 9 | -------------------------------------------------------------------------------- /Test/spv.deviceGroup.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_device_group : enable 4 | 5 | out vec4 color; 6 | 7 | void main() { 8 | color = vec4(gl_DeviceIndex, 0, 0, 0); 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.do-simple.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | void main() { 3 | int i = 0; 4 | do { 5 | i++; 6 | } while(i<10); 7 | } 8 | -------------------------------------------------------------------------------- /Test/spv.do-while-continue-break.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | void main() { 3 | int i = 0; 4 | int A, B, C, D, E, F, G; 5 | do { 6 | A = 0; 7 | if (i == 2) { 8 | B = 1; 9 | continue; 10 | C = 2; 11 | } 12 | if (i == 5) { 13 | D = 3; 14 | break; 15 | E = 42; 16 | } 17 | F = 99; 18 | } while (++i < 19); 19 | G = 12; 20 | } 21 | -------------------------------------------------------------------------------- /Test/spv.doWhileLoop.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | in vec4 bigColor; 4 | in vec4 BaseColor; 5 | in float d; 6 | 7 | void main() 8 | { 9 | vec4 color = BaseColor; 10 | 11 | do { 12 | color += bigColor; 13 | } while (color.x < d); 14 | 15 | gl_FragColor = color; 16 | } 17 | -------------------------------------------------------------------------------- /Test/spv.drawParams.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_ARB_shader_draw_parameters : enable 4 | 5 | out vec3 pos; 6 | 7 | void main() 8 | { 9 | int a = gl_BaseVertexARB; 10 | int b = gl_BaseInstanceARB; 11 | int c = gl_DrawIDARB; 12 | pos = vec3(a, b, c); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.expect_assume.assumeEXT.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_expect_assume: enable 4 | 5 | layout (local_size_x = 8) in; 6 | 7 | readonly buffer roblock { 8 | int i; 9 | } ro; 10 | 11 | void main() { 12 | assumeEXT(ro.i > 42); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.exportFunctions.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | float add(float a, float b) { 4 | return a + b; 5 | } 6 | 7 | int foo() { 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.ext.RayCallable.rcall: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_EXT_ray_tracing : enable 3 | layout(location = 0) callableDataEXT vec4 data0; 4 | layout(location = 1) callableDataInEXT dataBlock { 5 | uint data1; 6 | }; 7 | void main() 8 | { 9 | uvec3 id = gl_LaunchIDEXT; 10 | uvec3 size = gl_LaunchSizeEXT; 11 | data1 = 256U; 12 | executeCallableEXT(2,1); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.ext.RayPrimCull_Errors.rgen: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_EXT_ray_tracing : enable 3 | layout(primitive_culling); 4 | #extension GL_EXT_ray_flags_primitive_culling : enable 5 | layout(primitive_culling) uniform; 6 | layout(primitive_culling, binding = 2) uniform accelerationStructureEXT as; 7 | layout(std140, binding = 2, primitive_culling) buffer block { int x; }; 8 | void main() 9 | { 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.ext.ShaderTileImage.color.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_EXT_shader_tile_image : require 3 | 4 | precision highp float; 5 | 6 | layout(location=1) tileImageEXT highp attachmentEXT in_color; 7 | layout(location=0) out highp vec4 out_color; 8 | 9 | void main(void) 10 | { 11 | out_color = colorAttachmentReadEXT(in_color); 12 | } 13 | -------------------------------------------------------------------------------- /Test/spv.ext.ShaderTileImage.subpassinput.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_shader_tile_image : require 3 | 4 | precision highp float; 5 | 6 | layout(set = 0, binding = 0, input_attachment_index = 0) uniform subpassInput i; 7 | 8 | layout(location = 0) out vec4 fragColor; 9 | 10 | void main() 11 | { 12 | fragColor = subpassLoad(i); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.ext.ShaderTileImage.wronglayout.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_EXT_shader_tile_image : require 3 | 4 | precision highp float; 5 | precision mediump int; 6 | 7 | layout(binding=0, set=0, input_attachment_index=0) tileImageEXT highp attachmentEXT in_color; 8 | layout(location=0) out highp vec4 out_color; 9 | 10 | void main(void) 11 | { 12 | out_color = colorAttachmentReadEXT(in_color); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.ext.textureShadowLod.error.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(binding = 0) uniform sampler2DArrayShadow s2da; 4 | 5 | layout(location = 0) out vec4 c_out; 6 | 7 | layout(location = 0) in vec4 tc; 8 | 9 | void main() 10 | { 11 | float c = textureLod(s2da, tc, 0); 12 | c_out = vec4(c); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.extPostDepthCoverage.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #extension GL_EXT_post_depth_coverage : enable 4 | 5 | layout(post_depth_coverage) in; 6 | layout(early_fragment_tests) in; 7 | 8 | void main () { 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.extPostDepthCoverage_Error.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_post_depth_coverage : enable 4 | 5 | layout(post_depth_coverage) in; // should fail since for GL_EXT_post_depth_coverage 6 | // explicit declaration of early_fragment_tests is required 7 | 8 | void main () { 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.float16convertonlyarith.comp: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | #extension GL_EXT_shader_explicit_arithmetic_types_float16 : require 4 | 5 | layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in; 6 | 7 | void main() 8 | { 9 | vec4 v = vec4(0.0); 10 | vec4(f16vec4(v)); 11 | } -------------------------------------------------------------------------------- /Test/spv.float16convertonlystorage.comp: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | #extension GL_EXT_shader_16bit_storage : require 4 | 5 | layout(local_size_x = 16, local_size_y = 16, local_size_z = 1) in; 6 | 7 | void main() 8 | { 9 | vec4 v = vec4(0.0); 10 | vec4(f16vec4(v)); 11 | } -------------------------------------------------------------------------------- /Test/spv.for-complex-condition.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | layout(location=0) out highp int r; 3 | layout(location=0) in lowp int flag; 4 | void main() { 5 | int i; 6 | for (i=0; i < (flag==1 ? 10 : 15) ; i++) { r = i; } 7 | } 8 | -------------------------------------------------------------------------------- /Test/spv.for-continue-break.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | void main() { 3 | int i; 4 | int A, B, C, D, E, F, G; 5 | for (i=0; i < 10 ; i++) { 6 | A = 1; 7 | if (i%2 ==0) { 8 | B = 1; 9 | continue; 10 | C = 1; 11 | } 12 | if (i%3 == 0) { 13 | D = 1; 14 | break; 15 | E = 1; 16 | } 17 | F = 12; 18 | } 19 | G = 99; 20 | } 21 | -------------------------------------------------------------------------------- /Test/spv.for-nobody.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | layout(location=0) out highp int r; 3 | void main() { 4 | int i; 5 | for (i=0; i<10; i++); 6 | r = i; 7 | } 8 | -------------------------------------------------------------------------------- /Test/spv.for-notest.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | layout(location=0) out highp int r; 3 | void main() { 4 | int i; 5 | for (i=0; ; i++) { r = i; } 6 | } 7 | -------------------------------------------------------------------------------- /Test/spv.for-simple.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | void main() { 3 | int i; 4 | int j; 5 | for (i=0; i < 10 ; i++) { 6 | j = 12; 7 | } 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.fragmentDensity-es.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #extension GL_EXT_fragment_invocation_density : require 4 | 5 | layout (location = 0) out highp ivec2 FragSize; 6 | layout (location = 2) out highp int FragInvocationCount; 7 | 8 | void main () { 9 | FragSize = gl_FragSizeEXT; 10 | FragInvocationCount = gl_FragInvocationCountEXT; 11 | } 12 | -------------------------------------------------------------------------------- /Test/spv.fragmentDensity.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_fragment_invocation_density : require 4 | 5 | layout (location = 0) out vec2 FragSize; 6 | layout (location = 2) out int FragInvocationCount; 7 | 8 | void main () { 9 | FragSize = gl_FragSizeEXT; 10 | FragInvocationCount = gl_FragInvocationCountEXT; 11 | } 12 | -------------------------------------------------------------------------------- /Test/spv.fragmentDensity.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | // try using a fragment-only extension in a vertex shader 4 | #extension GL_EXT_fragment_invocation_density : require 5 | 6 | layout (location = 0) out uvec2 FragSize; 7 | layout (location = 2) out int FragInvocationCount; 8 | 9 | void main () { 10 | FragSize = gl_FragSizeEXT; 11 | FragInvocationCount = gl_FragInvocationCountEXT; 12 | } 13 | -------------------------------------------------------------------------------- /Test/spv.fullyCovered.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_NV_conservative_raster_underestimation : enable 4 | 5 | out vec4 color; 6 | 7 | void main() { 8 | color = vec4(gl_FragFullyCoveredNV, 0, 0, 0); 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.funcall.array.frag: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | uniform ub { 4 | vec4 u[9]; 5 | }; 6 | 7 | vec4 f(const vec4 a[9], int ix) { 8 | return a[ix]; 9 | } 10 | 11 | out vec4 color; 12 | 13 | void main() 14 | { 15 | color = f(u, 2); 16 | } 17 | 18 | -------------------------------------------------------------------------------- /Test/spv.functionNestedOpaque.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | uniform struct S { 4 | sampler2D s; 5 | } si; 6 | 7 | void foo(sampler2D t) 8 | { 9 | texture(t, vec2(0.5)); 10 | } 11 | 12 | void barc(const S p) 13 | { 14 | foo(p.s); 15 | } 16 | 17 | void bar(S p) 18 | { 19 | foo(p.s); 20 | } 21 | 22 | void main() 23 | { 24 | barc(si); 25 | bar(si); 26 | } 27 | -------------------------------------------------------------------------------- /Test/spv.glFragColor.frag: -------------------------------------------------------------------------------- 1 | #version 330 2 | 3 | void main() 4 | { 5 | gl_FragColor = vec4(1.0); 6 | } 7 | -------------------------------------------------------------------------------- /Test/spv.hlslDebugInfo.vert: -------------------------------------------------------------------------------- 1 | float4 origMain() : SV_Position 2 | { 3 | return (float4)0; 4 | } 5 | -------------------------------------------------------------------------------- /Test/spv.intrinsicsDebugBreak.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_EXT_spirv_intrinsics : enable 3 | 4 | spirv_instruction (extensions = ["SPV_KHR_non_semantic_info"], set = "NonSemantic.DebugBreak", id = 1) 5 | void debugBreak(); 6 | 7 | void main() { 8 | debugBreak(); 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.intrinsicsFakeEnable.vert: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | #extension GL_EXT_spirv_intrinsics : enable 3 | 4 | // ERROR: Overlapped input location. Make sure it could be detected even 5 | // if GL_EXT_spirv_intrinsics is enabled. 6 | layout(location = 0) in vec4 v4; 7 | layout(location = 0) in vec3 v3; 8 | 9 | void main() { 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.intrinsicsSpirvStorageClass.rchit: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | #extension GL_EXT_spirv_intrinsics: enable 4 | 5 | #define rayPayloadEXT spirv_storage_class(extensions = ["SPV_KHR_ray_tracing"], capabilities = [5353], 5338) 6 | 7 | layout(location = 1) rayPayloadEXT vec4 payload; 8 | 9 | void main() 10 | { 11 | payload = vec4(0.0, 1.0, 0.0, 1.0); 12 | } 13 | -------------------------------------------------------------------------------- /Test/spv.intrinsicsSpirvTypeLocalVar.vert: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | #extension GL_EXT_spirv_intrinsics: enable 4 | 5 | layout(constant_id = 9) const int size = 9; 6 | 7 | #define EmptyStruct spirv_type(id = 30) 8 | void func(EmptyStruct emptyStruct) {} 9 | 10 | void main() 11 | { 12 | EmptyStruct dummy[size]; 13 | func(dummy[1]); 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.invariantAll.vert: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | #pragma STDGL invariant(all) 3 | 4 | layout(location=0) out highp float v; 5 | 6 | void main() 7 | { 8 | gl_Position = vec4(v, v, 0, 1); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /Test/spv.layer.tese: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_ARB_shader_viewport_layer_array : require 4 | 5 | layout(triangles) in; 6 | void main() { 7 | gl_Layer = 1; 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.length.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | vec4 u[3]; 4 | 5 | in vec2 v[2]; 6 | 7 | void main() 8 | { 9 | int a[5]; 10 | 11 | vec2 t = v[0] + v[1]; 12 | 13 | gl_FragColor = vec4(u.length() * v.length() * a.length()); 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.load.bool.array.interface.block.frag: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout(std140, set=0, binding=0) uniform ub { 4 | bool bi[2][3]; 5 | }; 6 | layout(std430, set=0, binding=1) buffer ssbo { 7 | bool bo[2][3]; 8 | }; 9 | 10 | layout(location=0) out vec4 color; 11 | 12 | void main() 13 | { 14 | bo = bi; 15 | color = vec4(0); 16 | } 17 | 18 | -------------------------------------------------------------------------------- /Test/spv.looseUniformNoLoc.vert: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout(location = 0) 4 | in vec4 foo; 5 | 6 | layout(location = 0) 7 | out vec4 bar; 8 | 9 | uniform vec4 uv; 10 | 11 | void main() 12 | { 13 | bar = foo; 14 | gl_Position = foo; 15 | } -------------------------------------------------------------------------------- /Test/spv.maximalReconvergence.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | #extension GL_EXT_maximal_reconvergence : enable 4 | 5 | [[random(4)]] void main() [[maximally_reconverges]] 6 | { 7 | } 8 | -------------------------------------------------------------------------------- /Test/spv.merge-unreachable.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | precision mediump int; precision highp float; 3 | layout(location=1) in highp vec4 v; 4 | void main (void) 5 | { 6 | if (v == vec4(0.1,0.2,0.3,0.4)) discard; 7 | else return; 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.multiView.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_multiview : enable 4 | 5 | out vec4 color; 6 | 7 | void main() { 8 | color = vec4(gl_ViewIndex, 0, 0, 0); 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.multiple.var.same.const.frag: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | precision mediump float; 3 | const float var0 = 1e-6; 4 | const float var1 = 1e-6; 5 | void main(){} 6 | 7 | -------------------------------------------------------------------------------- /Test/spv.multiviewPerViewAttributes.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_NVX_multiview_per_view_attributes :require 4 | 5 | void main() 6 | { 7 | gl_ViewportMaskPerViewNV[0] = 1; 8 | gl_PositionPerViewNV[0] = gl_Position; 9 | } 10 | 11 | -------------------------------------------------------------------------------- /Test/spv.noBuiltInLoc.vert: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout(location = 0) 4 | in vec4 foo; 5 | 6 | layout(location = 0) 7 | out vec4 bar; 8 | 9 | uniform vec4 uv1; 10 | uniform float uv2; 11 | uniform vec3 uv3; 12 | 13 | layout(binding = 0) uniform atomic_uint a_uint; 14 | 15 | void main() 16 | { 17 | bar = foo; 18 | gl_Position = foo; 19 | } -------------------------------------------------------------------------------- /Test/spv.noDeadDecorations.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | precision mediump float; 3 | 4 | float func(float a) 5 | { 6 | return -a; 7 | a = a * -1.0; 8 | } 9 | 10 | void main() 11 | { 12 | gl_Position.x = func(0.0); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.noWorkgroup.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(local_size_x_id = 18, local_size_y_id=10,local_size_z_id = 19) in; 4 | 5 | shared uint keys[gl_WorkGroupSize.z][gl_WorkGroupSize.x * gl_WorkGroupSize.y]; 6 | 7 | void main() 8 | { 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.nonuniform2.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_nonuniform_qualifier : require 3 | layout(set=0,binding=4,rgba32f) uniform imageBuffer data[]; 4 | layout(location = 0) out vec4 FragColor; 5 | layout(location = 3) in flat int rIndex; 6 | void main() 7 | { 8 | FragColor = imageLoad(data[nonuniformEXT(rIndex)], 0); 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.nonuniform4.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_nonuniform_qualifier : require 3 | layout(set=0,binding=4,r32ui) uniform uimageBuffer data[]; 4 | layout(location = 3) in flat int rIndex; 5 | void main() 6 | { 7 | imageAtomicAdd(data[nonuniformEXT(rIndex)], 0, 0); 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.nonuniform5.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_nonuniform_qualifier : require 3 | 4 | layout(location = 0) flat in int Index; 5 | layout(location = 0) out vec4 FragColor; 6 | 7 | layout(set = 0, binding = 0) uniform UBO 8 | { 9 | vec4 v; 10 | } ubos[]; 11 | 12 | void main() 13 | { 14 | FragColor = ubos[nonuniformEXT(Index)].v; 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.perprimitiveNV.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | #extension GL_NV_mesh_shader: require 4 | 5 | layout(location=0) 6 | in B { 7 | perprimitiveNV float f; 8 | }; 9 | 10 | layout(location=4) 11 | in C { 12 | flat centroid float h; 13 | }; 14 | 15 | layout(location=8) 16 | out float g; 17 | 18 | void main() 19 | { 20 | g = f + h; 21 | } 22 | -------------------------------------------------------------------------------- /Test/spv.pushConstant.vert: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | layout(push_constant) uniform Material { 4 | int kind; 5 | float fa[3]; 6 | } matInst; 7 | 8 | out vec4 color; 9 | 10 | void main() 11 | { 12 | switch (matInst.kind) { 13 | case 1: color = vec4(0.2); break; 14 | case 2: color = vec4(0.5); break; 15 | default: color = vec4(0.0); break; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Test/spv.pushConstantAnon.vert: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | layout(push_constant) uniform Material { 4 | int kind; 5 | float fa[3]; 6 | }; 7 | 8 | out vec4 color; 9 | 10 | void main() 11 | { 12 | switch (kind) { 13 | case 1: color = vec4(0.2); break; 14 | case 2: color = vec4(0.5); break; 15 | default: color = vec4(fa[1]); break; 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /Test/spv.qualifiers.vert: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | 3 | in vec4 inV; 4 | 5 | centroid out vec4 outVc; 6 | smooth out vec4 outVs; 7 | flat out vec4 outVf; 8 | noperspective out vec4 outVn; 9 | 10 | centroid noperspective out vec4 outVcn; 11 | 12 | void main() 13 | { 14 | outVc = inV; 15 | outVs = inV; 16 | outVf = inV; 17 | outVn = inV; 18 | outVcn = inV; 19 | } 20 | -------------------------------------------------------------------------------- /Test/spv.queueFamilyScope.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_KHR_memory_scope_semantics : require 3 | 4 | layout (binding = 0) buffer Buffer { uint a; } A; 5 | 6 | void main() 7 | { 8 | atomicLoad(A.a, gl_ScopeQueueFamily, gl_StorageSemanticsBuffer, gl_SemanticsAcquire); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /Test/spv.rankShift.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_ARB_gpu_shader_int64 : require 3 | 4 | layout(local_size_x = 54) in; 5 | 6 | layout(location=4) uniform int64_t arg0; 7 | layout(location=5) uniform uint arg1; 8 | 9 | void main() 10 | { 11 | uint64_t result = arg0 << arg1; 12 | result = arg0 >> arg1; 13 | result <<= arg1; 14 | result >>= arg1; 15 | } -------------------------------------------------------------------------------- /Test/spv.register.autoassign-2.frag: -------------------------------------------------------------------------------- 1 | 2 | SamplerState g_tSamp : register(s0); 3 | 4 | Texture2D g_tScene[2] : register(t0); 5 | 6 | struct PS_OUTPUT 7 | { 8 | float4 Color : SV_Target0; 9 | }; 10 | 11 | void main(out PS_OUTPUT psout) 12 | { 13 | psout.Color = g_tScene[0].Sample(g_tSamp, float2(0.3,0.4)) + 14 | g_tScene[1].Sample(g_tSamp, float2(0.3,0.4)); 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.register.autoassign.rangetest.frag: -------------------------------------------------------------------------------- 1 | 2 | SamplerState g_tSamp : register(s5); 3 | 4 | Texture2D g_tScene[2] : register(t5); 5 | 6 | struct PS_OUTPUT 7 | { 8 | float4 Color : SV_Target0; 9 | }; 10 | 11 | void main(out PS_OUTPUT psout) 12 | { 13 | psout.Color = g_tScene[0].Sample(g_tSamp, float2(0.3, 0.3)) + 14 | g_tScene[1].Sample(g_tSamp, float2(0.3, 0.3)); 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.rw.autoassign.frag: -------------------------------------------------------------------------------- 1 | 2 | RWTexture1D g_tTex1df1; 3 | RWBuffer g_tBuf1du1; 4 | 5 | struct PS_OUTPUT 6 | { 7 | float4 Color : SV_Target0; 8 | }; 9 | 10 | PS_OUTPUT main() 11 | { 12 | float r00 = g_tTex1df1[0]; 13 | uint r01 = g_tBuf1du1[0]; 14 | 15 | PS_OUTPUT psout; 16 | psout.Color = 0; 17 | return psout; 18 | } 19 | -------------------------------------------------------------------------------- /Test/spv.sample.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location = 0) in sample vec4 samp; 4 | layout(location = 0) out vec4 color; 5 | 6 | void main() 7 | { 8 | color = samp; 9 | } -------------------------------------------------------------------------------- /Test/spv.sampleId.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location = 0) in vec4 samp; 4 | layout(location = 0) out vec4 color; 5 | 6 | void main() 7 | { 8 | if (gl_SampleID < 3) 9 | color = samp; 10 | else 11 | color = 2 * samp; 12 | } -------------------------------------------------------------------------------- /Test/spv.sampleMaskOverrideCoverage.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_NV_sample_mask_override_coverage : enable 3 | in vec4 color; 4 | layout(override_coverage) out int gl_SampleMask[]; 5 | void main() { 6 | gl_SampleMask[0] = int(0xFFFFFFFF); 7 | } -------------------------------------------------------------------------------- /Test/spv.samplePosition.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(location = 0) in vec4 samp; 4 | layout(location = 0) out vec4 color; 5 | 6 | void main() 7 | { 8 | if (gl_SamplePosition.y < 0.5) 9 | color = samp; 10 | else 11 | color = 2 * samp; 12 | } -------------------------------------------------------------------------------- /Test/spv.set.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(set = 4, binding = 7) uniform sampler2D samp2D; 4 | 5 | layout(set = 0, binding = 8) buffer setBuf { 6 | vec4 color; 7 | } setBufInst; 8 | 9 | out vec4 color; 10 | 11 | void main() 12 | { 13 | color = setBufInst.color; 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.shaderStencilExport.frag: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | #extension GL_ARB_shader_stencil_export: enable 4 | 5 | out int gl_FragStencilRefARB; 6 | 7 | void main() 8 | { 9 | gl_FragStencilRefARB = 100; 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.shadingRate.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_NV_shading_rate_image : require 4 | 5 | layout (location = 0) out vec2 FragmentSize; 6 | layout (location = 2) out int InvocationsPerPixel; 7 | 8 | void main () { 9 | FragmentSize = gl_FragmentSizeNV; 10 | InvocationsPerPixel = gl_InvocationsPerPixelNV; 11 | } -------------------------------------------------------------------------------- /Test/spv.shiftOps.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | flat in int i1; 4 | flat in uint u1; 5 | flat in ivec3 i3; 6 | flat in uvec3 u3; 7 | 8 | out ivec3 icolor; 9 | out uvec3 ucolor; 10 | 11 | void main() 12 | { 13 | icolor = i3 << u1; 14 | icolor <<= 4u; 15 | 16 | ucolor = u3 >> i1; 17 | ucolor >>= 5; 18 | } 19 | -------------------------------------------------------------------------------- /Test/spv.simpleFunctionCall.frag: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | in vec4 BaseColor; 4 | 5 | vec4 foo() 6 | { 7 | return BaseColor; 8 | } 9 | 10 | void main() 11 | { 12 | gl_FragColor = foo(); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.simpleMat.vert: -------------------------------------------------------------------------------- 1 | #version 330 2 | 3 | varying mat4 mvp; 4 | 5 | in vec4 v; 6 | in mat3 am3; 7 | in mat4 arraym[3]; 8 | 9 | out float f; 10 | out vec4 glPos; 11 | //out mat4 mout[2]; 12 | 13 | void main() 14 | { 15 | //needs complex output blocks to work: gl_Position = mvp * v; 16 | glPos = mvp * v; 17 | f = am3[2][1] + arraym[1][2][3]; 18 | //mout[1] = arraym[2]; 19 | } 20 | -------------------------------------------------------------------------------- /Test/spv.smBuiltins.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_NV_shader_sm_builtins: enable 3 | layout(location = 0) out uvec4 data; 4 | void main (void) 5 | { 6 | data = uvec4(gl_WarpsPerSMNV, gl_SMCountNV, gl_WarpIDNV, gl_SMIDNV); 7 | } 8 | -------------------------------------------------------------------------------- /Test/spv.smBuiltins.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_NV_shader_sm_builtins: enable 3 | layout(set = 0, binding = 0, std430) buffer Output 4 | { 5 | uvec4 result[]; 6 | }; 7 | 8 | void main (void) 9 | { 10 | result[gl_VertexIndex] = uvec4(gl_WarpsPerSMNV, gl_SMCountNV, gl_WarpIDNV, gl_SMIDNV); 11 | } 12 | -------------------------------------------------------------------------------- /Test/spv.specConst.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(constant_id = 11) const int a = 8; 4 | 5 | void main() 6 | { 7 | gl_Position = vec4(1.0) / a; 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.specConstArrayCheck.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(constant_id = 0) const uint a = 1; 4 | layout(constant_id = 1) const uint b = 2; 5 | layout(location = 0) out uint o; 6 | 7 | void main() { 8 | uint arr1[a+a]; 9 | uint arr2[b]; 10 | o = arr1[1]; 11 | o = arr2[1]; 12 | o = arr1[6]; 13 | o = arr2[6]; 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.specConstant.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(local_size_x_id = 18, local_size_z_id = 19) in; 4 | layout(local_size_x = 32, local_size_y = 32) in; 5 | 6 | buffer bn { 7 | uint a; 8 | } bi; 9 | 10 | void main() 11 | { 12 | bi.a = gl_WorkGroupSize.x * gl_WorkGroupSize.y * gl_WorkGroupSize.z; 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.specConstantOp.int16.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_shader_explicit_arithmetic_types_int16 : require 3 | 4 | // Produce an OpSpecConstantOp with 16 bit integer type 5 | 6 | layout(constant_id = 0) const int c = 8; 7 | 8 | layout(binding=0) writeonly restrict buffer S { 9 | uint16_t p_out[]; 10 | }; 11 | 12 | void main() 13 | { 14 | p_out[0] = uint16_t(c); 15 | } 16 | 17 | -------------------------------------------------------------------------------- /Test/spv.specConstantOp.int8.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require 3 | 4 | // Produce an OpSpecConstantOp with 8 bit integer type 5 | 6 | layout(constant_id = 0) const int c = 8; 7 | 8 | layout(binding=0) writeonly restrict buffer S { 9 | uint8_t p_out[]; 10 | }; 11 | 12 | void main() 13 | { 14 | p_out[0] = uint8_t(c); 15 | } 16 | 17 | 18 | -------------------------------------------------------------------------------- /Test/spv.specTexture.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(constant_id = 1) const int offs = 0; 4 | layout(binding = 0) uniform sampler2D tex; 5 | layout(location = 0) out vec4 color_out; 6 | 7 | void main(void) 8 | { 9 | color_out = textureLodOffset(tex, vec2(0.0, 0.0), 0.0, ivec2(offs, offs)); 10 | } -------------------------------------------------------------------------------- /Test/spv.ssboAlias.frag: -------------------------------------------------------------------------------- 1 | AppendStructuredBuffer Buf1 : register(u1); 2 | AppendStructuredBuffer Buf2 : register(u2); 3 | AppendStructuredBuffer Buf3 : register(u1); 4 | 5 | float4 main() : SV_Target 6 | { 7 | Buf1.Append(10u); 8 | Buf2.Append(20u); 9 | return float4(1.0, 3.0, 5.0, 1.0); 10 | } -------------------------------------------------------------------------------- /Test/spv.stereoViewRendering.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_NV_viewport_array2 :require 4 | #extension GL_NV_stereo_view_rendering : require 5 | 6 | layout (viewport_relative, secondary_view_offset = 2) out highp int gl_Layer; 7 | void main() 8 | { 9 | gl_SecondaryViewportMaskNV[0] = 1; 10 | gl_SecondaryPositionNV = gl_Position; 11 | } 12 | 13 | -------------------------------------------------------------------------------- /Test/spv.storageBuffer.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #pragma use_storage_buffer 4 | 5 | uniform ub { 6 | vec4 a; 7 | } ubi; 8 | 9 | buffer bb { 10 | vec4 b; 11 | } bbi; 12 | 13 | void main() 14 | { 15 | gl_Position = ubi.a + bbi.b; 16 | } 17 | -------------------------------------------------------------------------------- /Test/spv.subgroup.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(location = 0) out uvec4 data; 4 | void main (void) 5 | { 6 | data = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 7 | } 8 | -------------------------------------------------------------------------------- /Test/spv.subgroup.geom: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(points) in; 4 | layout(points, max_vertices = 1) out; 5 | layout(set = 0, binding = 0, std430) buffer Output 6 | { 7 | uvec4 result[]; 8 | }; 9 | 10 | void main (void) 11 | { 12 | result[gl_PrimitiveIDIn] = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.subgroup.tesc: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(vertices=1) out; 4 | layout(set = 0, binding = 0, std430) buffer Output 5 | { 6 | uvec4 result[]; 7 | }; 8 | 9 | void main (void) 10 | { 11 | result[gl_PrimitiveID] = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 12 | } 13 | -------------------------------------------------------------------------------- /Test/spv.subgroup.tese: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(isolines) in; 4 | layout(set = 0, binding = 0, std430) buffer Output 5 | { 6 | uvec4 result[]; 7 | }; 8 | 9 | void main (void) 10 | { 11 | result[gl_PrimitiveID] = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 12 | } 13 | -------------------------------------------------------------------------------- /Test/spv.subgroup.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_KHR_shader_subgroup_basic: enable 3 | layout(set = 0, binding = 0, std430) buffer Output 4 | { 5 | uvec4 result[]; 6 | }; 7 | 8 | void main (void) 9 | { 10 | result[gl_VertexIndex] = uvec4(gl_SubgroupSize, gl_SubgroupInvocationID, 0, 0); 11 | } 12 | -------------------------------------------------------------------------------- /Test/spv.subgroupSizeARB.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_ARB_shader_ballot : enable 3 | #extension GL_KHR_shader_subgroup_basic : enable 4 | 5 | layout(location = 0) out uint result; 6 | 7 | void main (void) 8 | { 9 | result = gl_SubGroupSizeARB; 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.subgroupUniformControlFlow.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | #ifdef GL_EXT_subgroup_uniform_control_flow 4 | 5 | #extension GL_EXT_subgroup_uniform_control_flow : enable 6 | 7 | [[random(4)]] void main() [[subgroup_uniform_control_flow]] 8 | { 9 | } 10 | 11 | #endif 12 | -------------------------------------------------------------------------------- /Test/spv.targetOpenGL.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(constant_id = 3) const int a = 2; 4 | layout(location = 2) uniform float f; 5 | layout(location = 4, binding = 1) uniform sampler2D s1; 6 | layout(binding = 2) uniform sampler2D s2; 7 | 8 | void main() 9 | { 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.targetVulkan.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(constant_id = 3) const int a = 2; 4 | 5 | layout(push_constant) uniform pc { float f; }; 6 | 7 | void main() 8 | { 9 | } 10 | -------------------------------------------------------------------------------- /Test/spv.terminate.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | #extension GL_EXT_terminate_invocation : enable 4 | 5 | void main() 6 | { 7 | terminateInvocation; 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.test.vert: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | in mat4 transform; 4 | 5 | attribute vec4 position; 6 | in vec2 uv_in; 7 | 8 | out vec2 uv; 9 | 10 | void main() 11 | { 12 | uv = uv_in; 13 | gl_Position = transform * position; 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.texture.sampler.transform.frag: -------------------------------------------------------------------------------- 1 | #version 440 2 | 3 | uniform sampler smp; 4 | uniform texture2D tex; 5 | 6 | in vec2 coord; 7 | 8 | out vec4 color; 9 | 10 | void main() 11 | { 12 | color = texture(sampler2D(tex, smp), coord); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.textureError.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | uniform sampler2D s2D; 4 | centroid vec2 centTexCoord; 5 | 6 | void main() 7 | { 8 | gl_FragColor = texture2D(s2D, centTexCoord); 9 | } 10 | 11 | -------------------------------------------------------------------------------- /Test/spv.uniformArray.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | uniform sampler2D texSampler2D; 4 | in vec3 inColor; 5 | in vec4 color[6]; 6 | in float alpha[16]; 7 | 8 | void main() 9 | { 10 | vec4 texColor = color[1] + color[1]; 11 | 12 | texColor.xyz += inColor; 13 | 14 | texColor.a += alpha[12]; 15 | 16 | gl_FragColor = texColor; 17 | } 18 | -------------------------------------------------------------------------------- /Test/spv.uniformInitializer.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (location = 0) out vec4 color; 4 | 5 | layout (location = 0) uniform vec4 in_color = vec4(0.0, 1.0, 0.0, 1.0); 6 | 7 | void main() 8 | { 9 | color = in_color; 10 | } 11 | -------------------------------------------------------------------------------- /Test/spv.uniformInitializerSpecConstant.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (location = 0) out vec4 color; 4 | 5 | layout (constant_id = 1) const float opacity = 0.5; 6 | 7 | layout (location = 0) uniform vec3 in_color = vec3(1.0, 0.5, 0); 8 | 9 | layout (location = 4) uniform float foo = opacity; 10 | 11 | void main() 12 | { 13 | color = vec4(in_color, foo); 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.unit1.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | float f; 4 | float a1; 5 | 6 | float foo(); 7 | 8 | out float cout; 9 | 10 | void main() 11 | { 12 | f = 10; 13 | float g = foo(); 14 | f += g; 15 | f += gl_FragCoord.y; 16 | } -------------------------------------------------------------------------------- /Test/spv.unit2.frag: -------------------------------------------------------------------------------- 1 | #version 410 2 | // a different version number makes different id's for the same shared symbol 3 | 4 | float a2; 5 | float f; 6 | 7 | float bar(); 8 | 9 | out float cout; 10 | in float cin; 11 | 12 | float foo() 13 | { 14 | float h2 = 2 * f + cin; 15 | float g2 = bar(); 16 | return h2 + g2 + gl_FragCoord.y; 17 | } -------------------------------------------------------------------------------- /Test/spv.unit3.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | float f; 4 | float h3 = 3.0; 5 | 6 | out float cout; 7 | in float cin; 8 | 9 | float bar() 10 | { 11 | h3 *= f; 12 | float g3 = 2 * h3; 13 | cout = g3; 14 | return h3 + g3 + gl_FragCoord.y; 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.vecMatConstruct.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | void main() 4 | { 5 | mat4x3 m; 6 | 7 | vec2 v2 = vec2(m); 8 | vec3 v3 = vec3(m); 9 | vec4 v4 = vec4(m); 10 | 11 | ivec2 iv2 = ivec2(m); 12 | ivec3 iv3 = ivec3(m); 13 | ivec4 iv4 = ivec4(m); 14 | } 15 | -------------------------------------------------------------------------------- /Test/spv.viewportArray2.tesc: -------------------------------------------------------------------------------- 1 | #version 430 2 | #extension GL_NV_viewport_array2 :require 3 | 4 | layout(vertices = 4) out; 5 | 6 | out gl_PerVertex { 7 | int gl_ViewportMask[2]; 8 | } gl_out[4]; 9 | 10 | layout (viewport_relative) out highp int gl_Layer; 11 | 12 | void main() 13 | { 14 | gl_out[gl_InvocationID].gl_ViewportMask[0] = 1; 15 | } 16 | -------------------------------------------------------------------------------- /Test/spv.viewportArray2.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_ARB_shader_viewport_layer_array : require 3 | #extension GL_NV_viewport_array2 : require 4 | 5 | layout (viewport_relative) out highp int gl_Layer; 6 | void main() 7 | { 8 | gl_ViewportMask[0] = 1; 9 | gl_ViewportIndex = 2; 10 | } -------------------------------------------------------------------------------- /Test/spv.viewportindex.tese: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_ARB_shader_viewport_layer_array : require 4 | 5 | layout(triangles) in; 6 | void main() { 7 | gl_ViewportIndex = 1; 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.volatileAtomic.comp: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | layout(set=0, binding=3) volatile buffer D { uint d[]; } d; 4 | 5 | void main() 6 | { 7 | atomicExchange(d.d[0], 0); 8 | } 9 | -------------------------------------------------------------------------------- /Test/spv.vulkan110.storageBuffer.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #pragma use_storage_buffer 4 | 5 | uniform ub { 6 | vec4 a; 7 | } ubi; 8 | 9 | buffer bb { 10 | vec4 b; 11 | } bbi; 12 | 13 | void main() 14 | { 15 | gl_Position = ubi.a + bbi.b; 16 | } 17 | -------------------------------------------------------------------------------- /Test/spv.while-continue-break.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | void main() { 3 | int i = 0; 4 | int A, B, C, D; 5 | while (i<10) { 6 | A = 1; 7 | if (i%2 == 0) { 8 | B = 2; 9 | continue; 10 | C = 2; 11 | } 12 | if (i%5 == 0) { 13 | B = 2; 14 | break; 15 | C = 2; 16 | } 17 | i++; 18 | } 19 | D = 3; 20 | } 21 | -------------------------------------------------------------------------------- /Test/spv.while-simple.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | void main() { 3 | int i = 0; 4 | while (i<10) { 5 | i++; 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /Test/spv.whileLoop.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | in vec4 bigColor; 4 | in vec4 BaseColor; 5 | in float d; 6 | 7 | void main() 8 | { 9 | vec4 color = BaseColor; 10 | 11 | while (color.x < d) { 12 | color += bigColor; 13 | } 14 | 15 | gl_FragColor = color; 16 | } 17 | -------------------------------------------------------------------------------- /Test/spv.xfbOffsetOnBlockMembersAssignment.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(xfb_buffer=2) out; 4 | layout(location=5, xfb_offset=0) out block2 { 5 | float y1_out; 6 | vec4 y2_out; 7 | }; 8 | 9 | void main() { 10 | y1_out = 7.0; 11 | y2_out = vec4(1.0, 0.0, 0.0, 1.0); 12 | gl_Position = vec4(0.0); 13 | } 14 | -------------------------------------------------------------------------------- /Test/spv.xfbStrideJustOnce.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(xfb_buffer=2) out; 4 | 5 | layout(location=5, xfb_stride=20) out block { 6 | float y1_out; 7 | vec4 y2_out; 8 | }; 9 | 10 | void main() { 11 | y1_out = 7.0; 12 | y2_out = vec4(1.0, 0.0, 0.0, 1.0); 13 | gl_Position = vec4(0.0); 14 | } 15 | -------------------------------------------------------------------------------- /Test/struct.error.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | struct A { 4 | float x; 5 | }; 6 | 7 | A test() { 8 | return A(1.0); 9 | } 10 | 11 | void main() { 12 | test().z; // A.z does not exist, causes a crash 13 | } 14 | 15 | -------------------------------------------------------------------------------- /Test/syntaxError.frag: -------------------------------------------------------------------------------- 1 | #version 120 2 | 3 | uniform vec4 bigColor; 4 | varying vec4 BaseColor; 5 | uniform float d; 6 | 7 | void main() 8 | { 9 | vec5 color = BaseColor; 10 | 11 | do { 12 | color += bigColor; 13 | } while (color.x < d); 14 | 15 | gl_FragColor = color; 16 | } 17 | -------------------------------------------------------------------------------- /Test/terminate.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | void foo() { terminateInvocation; } // ERROR: identifier undeclared 4 | 5 | #extension GL_EXT_terminate_invocation : enable 6 | 7 | void main() 8 | { 9 | int terminateInvocation; // syntax ERROR 10 | } 11 | -------------------------------------------------------------------------------- /Test/terminate.vert: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | void foo() { terminateInvocation; } // ERROR: identifier undeclared 4 | 5 | #extension GL_EXT_terminate_invocation : enable 6 | 7 | void main() 8 | { 9 | terminateInvocation; // ERROR: wrong stage 10 | } 11 | -------------------------------------------------------------------------------- /Test/textureoffset_sampler2darrayshadow.vert: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | precision mediump float; 3 | in highp vec4 dEQP_Position; 4 | 5 | uniform mediump sampler2DArrayShadow s; 6 | 7 | void main() 8 | { 9 | gl_Position = vec4(textureOffset(s, vec4(0), ivec2(0))); 10 | gl_Position = dEQP_Position; 11 | } 12 | -------------------------------------------------------------------------------- /Test/uniformArray.frag: -------------------------------------------------------------------------------- 1 | #version 130 2 | uniform sampler2D texSampler2D; 3 | uniform vec3 inColor; 4 | uniform vec4 color[6]; 5 | uniform float alpha[16]; 6 | 7 | void main() 8 | { 9 | vec4 texColor = color[1] + color[1]; 10 | 11 | texColor.xyz += inColor; 12 | 13 | texColor.a += alpha[12]; 14 | 15 | gl_FragColor = texColor; 16 | } 17 | -------------------------------------------------------------------------------- /Test/vk.relaxed.changeSet.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | layout(location = 0) out vec4 fragColor; 4 | 5 | uniform sampler2D sTexture; 6 | 7 | in vec4 Color; 8 | in vec2 UV; 9 | 10 | void main() 11 | { 12 | fragColor = Color * texture(sTexture, UV.st).r; 13 | } 14 | -------------------------------------------------------------------------------- /Test/vk.relaxed.changeSet.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | in vec2 aPos; 4 | in vec2 aUV; 5 | in vec4 aColor; 6 | uniform mat4 projectionMatrix; 7 | 8 | out vec4 Color; 9 | out vec2 UV; 10 | 11 | void main() 12 | { 13 | Color = aColor; 14 | UV = aUV; 15 | gl_Position = projectionMatrix * vec4(aPos, 0, 1); 16 | } 17 | -------------------------------------------------------------------------------- /Test/vk.relaxed.errorcheck.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | layout (location = 0) out vec4 io; 4 | 5 | // default uniforms will be gathered into a uniform block 6 | // final global block will merge uniforms from all linked files 7 | uniform vec2 a; // declared in both stages with different type 8 | 9 | vec4 foo() { 10 | return a.xyxy; 11 | } 12 | 13 | void main() { 14 | io = foo(); 15 | } -------------------------------------------------------------------------------- /Test/vk.relaxed.stagelink.0.2.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | vec4 TDOutputSwizzle(vec4 c) 3 | { 4 | return c.rgba; 5 | } 6 | uvec4 TDOutputSwizzle(uvec4 c) 7 | { 8 | return c.rgba; 9 | } 10 | -------------------------------------------------------------------------------- /Test/web.basic.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | layout(location = 2) in vec4 inv4; 4 | layout(location = 1) out vec4 outv4; 5 | 6 | layout(binding = 3) uniform uBlock { 7 | vec4 a; 8 | ivec4 b; 9 | uvec4 c; 10 | } uInst; 11 | 12 | void main() 13 | { 14 | outv4 = normalize(inv4) * uInst.a * vec4(uInst.b) * vec4(uInst.c); 15 | } 16 | -------------------------------------------------------------------------------- /Test/web.builtins.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | layout(location = 0) in mediump float ps; 4 | 5 | invariant gl_Position; 6 | 7 | void main() 8 | { 9 | gl_Position = vec4(ps); 10 | gl_Position *= float(4 - gl_VertexIndex); 11 | 12 | gl_PointSize = ps; 13 | gl_PointSize *= float(5 - gl_InstanceIndex); 14 | } 15 | -------------------------------------------------------------------------------- /Test/web.testlist: -------------------------------------------------------------------------------- 1 | web.builtins.vert 2 | web.builtins.frag 3 | web.basic.vert 4 | web.controlFlow.frag 5 | web.operations.frag 6 | web.texture.frag 7 | web.array.frag 8 | web.separate.frag 9 | web.comp 10 | -------------------------------------------------------------------------------- /Test/whileLoop.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | uniform vec4 bigColor; 4 | varying vec4 BaseColor; 5 | uniform float d; 6 | 7 | void main() 8 | { 9 | vec4 color = BaseColor; 10 | 11 | while (color.x < d) { 12 | color += bigColor; 13 | } 14 | 15 | gl_FragColor = color; 16 | } 17 | -------------------------------------------------------------------------------- /Test/xfbUnsizedArray.error.tese: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | #extension GL_ARB_enhanced_layouts : require 3 | layout(isolines, point_mode) in; 4 | layout (xfb_offset = 0) out vec4 unsized[]; // error: unsized array 5 | 6 | void main() 7 | { 8 | } 9 | -------------------------------------------------------------------------------- /Test/xfbUnsizedArray.error.vert: -------------------------------------------------------------------------------- 1 | #version 430 core 2 | #extension GL_ARB_enhanced_layouts : require 3 | 4 | layout (xfb_offset = 0) out vec4 xfb_buffer[]; // ERROR: unsized array cannot be used for an xfb buffer? 5 | 6 | in vec4 in_vs; 7 | out vec4 out_vs; 8 | 9 | void main() 10 | { 11 | vec4 result = in_vs; 12 | 13 | xfb_buffer[0] = result / 2; 14 | 15 | out_vs = result; 16 | } 17 | -------------------------------------------------------------------------------- /_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-merlot 2 | --------------------------------------------------------------------------------