├── .travis.yml ├── CMakeLists.txt ├── LICENSE ├── README.md ├── VkResample.cpp ├── glslang-master ├── .appveyor.yml ├── .clang-format ├── .gitattributes ├── .gitignore ├── .gn ├── .travis.yml ├── Android.mk ├── BUILD.bazel ├── BUILD.gn ├── CHANGES.md ├── CMakeLists.txt ├── CODE_OF_CONDUCT.md ├── ChooseMSVCCRT.cmake ├── DEPS ├── External │ └── CMakeLists.txt ├── LICENSE.txt ├── OGLCompilersDLL │ ├── CMakeLists.txt │ ├── InitializeDll.cpp │ └── InitializeDll.h ├── README-spirv-remap.txt ├── README.md ├── SPIRV │ ├── CInterface │ │ └── spirv_c_interface.cpp │ ├── CMakeLists.txt │ ├── GLSL.ext.AMD.h │ ├── GLSL.ext.EXT.h │ ├── GLSL.ext.KHR.h │ ├── GLSL.ext.NV.h │ ├── GLSL.std.450.h │ ├── GlslangToSpv.cpp │ ├── GlslangToSpv.h │ ├── InReadableOrder.cpp │ ├── Logger.cpp │ ├── Logger.h │ ├── NonSemanticDebugPrintf.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.hpp │ └── spvIR.h ├── StandAlone │ ├── CMakeLists.txt │ ├── DirStackFileIncluder.h │ ├── ResourceLimits.cpp │ ├── ResourceLimits.h │ ├── StandAlone.cpp │ ├── Worklist.h │ ├── resource_limits_c.cpp │ ├── resource_limits_c.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 │ ├── Operations.frag │ ├── aggOps.frag │ ├── always-discard.frag │ ├── always-discard2.frag │ ├── array.frag │ ├── array100.frag │ ├── 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.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 │ │ ├── Operations.frag.out │ │ ├── aggOps.frag.out │ │ ├── always-discard.frag.out │ │ ├── always-discard2.frag.out │ │ ├── array.frag.out │ │ ├── array100.frag.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 │ │ ├── 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 │ │ ├── errors.frag.out │ │ ├── es-link1.frag.out │ │ ├── findFunction.frag.out │ │ ├── flowControl.frag.out │ │ ├── forLoop.frag.out │ │ ├── forwardRef.frag.out │ │ ├── functionCall.frag.out │ │ ├── functionSemantics.frag.out │ │ ├── glsl.-D-U.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.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.entryPointRename.vert.bad.out │ │ ├── glsl.entryPointRename.vert.out │ │ ├── glsl.entryPointRename2.vert.out │ │ ├── glsl.es300.layoutOffset.error.vert.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.subgroupShuffle.comp.out │ │ ├── glsl.es320.subgroupShuffleRelative.comp.out │ │ ├── glsl.es320.subgroupVote.comp.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.basic.comp.out │ │ ├── hlsl.basic.geom.out │ │ ├── hlsl.boolConv.vert.out │ │ ├── hlsl.buffer.frag.out │ │ ├── hlsl.calculatelod.dx10.frag.out │ │ ├── hlsl.calculatelodunclamped.dx10.frag.out │ │ ├── hlsl.cast.frag.out │ │ ├── hlsl.cbuffer-identifier.vert.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.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.vert.out │ │ ├── hlsl.entry-in.frag.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.implicitBool.frag.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.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.evalfns.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.namespace.frag.out │ │ ├── hlsl.noSemantic.functionality1.comp.out │ │ ├── hlsl.nonint-index.frag.out │ │ ├── hlsl.nonstaticMemberFunction.frag.out │ │ ├── hlsl.numericsuffixes.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.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.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.structin.vert.out │ │ ├── hlsl.subpass.frag.out │ │ ├── hlsl.switch.frag.out │ │ ├── hlsl.swizzle.frag.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.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 │ │ ├── implicitInnerAtomicUint.frag.out │ │ ├── include.vert.out │ │ ├── invalidSwizzle.vert.out │ │ ├── length.frag.out │ │ ├── lineContinuation.vert.out │ │ ├── lineContinuation100.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.vk.differentPC.0.0.frag.out │ │ ├── link.vk.differentPC.1.0.frag.out │ │ ├── link.vk.matchingPC.0.0.frag.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 │ │ ├── localAggregates.frag.out │ │ ├── loops.frag.out │ │ ├── loopsArtificial.frag.out │ │ ├── mains1.frag.out │ │ ├── matrix.frag.out │ │ ├── matrix2.frag.out │ │ ├── matrixError.vert.out │ │ ├── maxClipDistances.vert.out │ │ ├── max_vertices_0.geom.out │ │ ├── missingBodies.vert.out │ │ ├── mixedArrayDecls.frag.out │ │ ├── negativeArraySize.comp.out │ │ ├── newTexture.frag.out │ │ ├── noMain.vert.out │ │ ├── nonSquare.vert.out │ │ ├── nonVulkan.frag.out │ │ ├── nonuniform.frag.out │ │ ├── nosuffix.out │ │ ├── numeral.frag.out │ │ ├── nvShaderNoperspectiveInterpolation.frag.out │ │ ├── overlongLiteral.frag.out │ │ ├── pointCoord.frag.out │ │ ├── precise.tesc.out │ │ ├── precise_struct_block.vert.out │ │ ├── precision.frag.out │ │ ├── precision.vert.out │ │ ├── prepost.frag.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 │ │ ├── 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.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.image.frag.out │ │ ├── spv.1.4.sparseTexture.frag.out │ │ ├── spv.1.4.texture.frag.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.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.AnyHitShader.rahit.out │ │ ├── spv.AnyHitShader_Errors.rahit.out │ │ ├── spv.AofA.frag.out │ │ ├── spv.ClosestHitShader.rchit.out │ │ ├── spv.ClosestHitShader_Errors.rchit.out │ │ ├── spv.GeometryShaderPassthrough.geom.out │ │ ├── spv.IntersectShader.rint.out │ │ ├── spv.IntersectShader_Errors.rint.out │ │ ├── spv.MissShader.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.RayGenShader_Errors.rgen.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.atomic.comp.out │ │ ├── spv.atomicCounter.comp.out │ │ ├── spv.atomicFloat.comp.out │ │ ├── spv.atomicFloat_Error.comp.out │ │ ├── spv.atomicInt64.comp.out │ │ ├── spv.barrier.vert.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.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.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.coopmat_Error.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.deepRvalue.frag.out │ │ ├── spv.demoteDisabled.frag.out │ │ ├── spv.depthOut.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.earlyReturnDiscard.frag.out │ │ ├── spv.explicittypes.frag.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.World3x4.rahit.out │ │ ├── spv.extPostDepthCoverage.frag.out │ │ ├── spv.extPostDepthCoverage_Error.frag.out │ │ ├── spv.float16.frag.out │ │ ├── spv.float16Fetch.frag.out │ │ ├── spv.float16convertonlyarith.comp.out │ │ ├── spv.float16convertonlystorage.comp.out │ │ ├── spv.float32.frag.out │ │ ├── spv.float64.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.fsi.frag.out │ │ ├── spv.fsi_Error.frag.out │ │ ├── spv.fullyCovered.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.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.intcoopmat.comp.out │ │ ├── spv.interpOps.frag.out │ │ ├── spv.layer.tese.out │ │ ├── spv.layoutNested.vert.out │ │ ├── spv.length.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.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.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.nonSquare.vert.out │ │ ├── spv.nonuniform.frag.out │ │ ├── spv.nonuniform2.frag.out │ │ ├── spv.nonuniform3.frag.out │ │ ├── spv.nonuniform4.frag.out │ │ ├── spv.nonuniform5.frag.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.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.rw.autoassign.frag.out │ │ ├── spv.sample.frag.out │ │ ├── spv.sampleId.frag.out │ │ ├── spv.sampleMaskOverrideCoverage.frag.out │ │ ├── spv.samplePosition.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.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.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.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.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.subgroupShuffle.comp.out │ │ ├── spv.subgroupShuffleRelative.comp.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.textureGatherBiasLod.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 │ │ ├── structAssignment.frag.out │ │ ├── structDeref.frag.out │ │ ├── structure.frag.out │ │ ├── switch.frag.out │ │ ├── swizzle.frag.out │ │ ├── syntaxError.frag.out │ │ ├── terminate.frag.out │ │ ├── terminate.vert.out │ │ ├── test.conf │ │ ├── test.frag.out │ │ ├── texture.frag.out │ │ ├── tokenLength.vert.out │ │ ├── tokenPaste.vert.out │ │ ├── types.frag.out │ │ ├── uint.frag.out │ │ ├── uniformArray.frag.out │ │ ├── variableArrayIndex.frag.out │ │ ├── varyingArray.frag.out │ │ ├── varyingArrayIndirect.frag.out │ │ ├── versionsClean.frag.out │ │ ├── versionsClean.vert.out │ │ ├── versionsErrors.frag.out │ │ ├── versionsErrors.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.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 │ ├── 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 │ ├── errors.frag │ ├── es-link1.frag │ ├── es-link2.frag │ ├── findFunction.frag │ ├── flowControl.frag │ ├── foo.h │ ├── forLoop.frag │ ├── forwardRef.frag │ ├── functionCall.frag │ ├── functionSemantics.frag │ ├── glsl.-D-U.frag │ ├── 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.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.entryPointRename.vert │ ├── glsl.entryPointRename2.vert │ ├── glsl.es300.layoutOffset.error.vert │ ├── 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.subgroupShuffle.comp │ ├── glsl.es320.subgroupShuffleRelative.comp │ ├── glsl.es320.subgroupVote.comp │ ├── 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.basic.comp │ ├── hlsl.basic.geom │ ├── hlsl.boolConv.vert │ ├── hlsl.buffer.frag │ ├── hlsl.calculatelod.dx10.frag │ ├── hlsl.calculatelodunclamped.dx10.frag │ ├── hlsl.cast.frag │ ├── hlsl.cbuffer-identifier.vert │ ├── 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.vert │ ├── hlsl.entry-in.frag │ ├── 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.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.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.namespace.frag │ ├── hlsl.noSemantic.functionality1.comp │ ├── hlsl.nonint-index.frag │ ├── hlsl.nonstaticMemberFunction.frag │ ├── hlsl.numericsuffixes.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.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.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.structin.vert │ ├── hlsl.subpass.frag │ ├── hlsl.switch.frag │ ├── hlsl.swizzle.frag │ ├── 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.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 │ ├── 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 │ ├── invalidSwizzle.vert │ ├── length.frag │ ├── lineContinuation.vert │ ├── lineContinuation100.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.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.matchingPC.0.0.frag │ ├── link.vk.matchingPC.0.1.frag │ ├── link.vk.matchingPC.0.2.frag │ ├── 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 │ ├── localAggregates.frag │ ├── loops.frag │ ├── loopsArtificial.frag │ ├── mains.frag │ ├── mains1.frag │ ├── mains2.frag │ ├── makeDoc │ ├── matrix.frag │ ├── matrix2.frag │ ├── matrixError.vert │ ├── maxClipDistances.vert │ ├── max_vertices_0.geom │ ├── missingBodies.vert │ ├── mixedArrayDecls.frag │ ├── negativeArraySize.comp │ ├── newTexture.frag │ ├── noMain.vert │ ├── noMain1.geom │ ├── noMain2.geom │ ├── nonSquare.vert │ ├── nonVulkan.frag │ ├── nonuniform.frag │ ├── nosuffix │ ├── numeral.frag │ ├── nvShaderNoperspectiveInterpolation.frag │ ├── overlongLiteral.frag │ ├── parent.h │ ├── parentBad │ ├── pointCoord.frag │ ├── precise.tesc │ ├── precise_struct_block.vert │ ├── precision.frag │ ├── precision.vert │ ├── prepost.frag │ ├── 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 │ ├── 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.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.image.frag │ ├── spv.1.4.sparseTexture.frag │ ├── spv.1.4.texture.frag │ ├── 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.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.AnyHitShader.rahit │ ├── spv.AnyHitShader_Errors.rahit │ ├── spv.AofA.frag │ ├── spv.ClosestHitShader.rchit │ ├── spv.ClosestHitShader_Errors.rchit │ ├── spv.GeometryShaderPassthrough.geom │ ├── spv.IntersectShader.rint │ ├── spv.IntersectShader_Errors.rint │ ├── spv.MissShader.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.RayGenShader_Errors.rgen │ ├── spv.accessChain.frag │ ├── spv.aggOps.frag │ ├── spv.always-discard.frag │ ├── spv.always-discard2.frag │ ├── spv.arbPostDepthCoverage.frag │ ├── spv.arbPostDepthCoverage_Error.frag │ ├── spv.atomic.comp │ ├── spv.atomicCounter.comp │ ├── spv.atomicFloat.comp │ ├── spv.atomicFloat_Error.comp │ ├── spv.atomicInt64.comp │ ├── spv.barrier.vert │ ├── 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.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.conditionalDemote.frag │ ├── spv.conditionalDiscard.frag │ ├── spv.constConstruct.vert │ ├── spv.constStruct.vert │ ├── spv.constructComposite.comp │ ├── spv.controlFlowAttributes.frag │ ├── spv.conversion.frag │ ├── spv.coopmat.comp │ ├── spv.coopmat_Error.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.deepRvalue.frag │ ├── spv.demoteDisabled.frag │ ├── spv.depthOut.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.earlyReturnDiscard.frag │ ├── spv.explicittypes.frag │ ├── 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.World3x4.rahit │ ├── spv.extPostDepthCoverage.frag │ ├── spv.extPostDepthCoverage_Error.frag │ ├── spv.float16.frag │ ├── spv.float16Fetch.frag │ ├── spv.float16convertonlyarith.comp │ ├── spv.float16convertonlystorage.comp │ ├── spv.float32.frag │ ├── spv.float64.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.fsi.frag │ ├── spv.fsi_Error.frag │ ├── spv.fullyCovered.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.frag │ ├── spv.imageLoadStoreLod.frag │ ├── spv.int16.amd.frag │ ├── spv.int16.frag │ ├── spv.int32.frag │ ├── spv.int64.frag │ ├── spv.int8.frag │ ├── spv.intOps.vert │ ├── spv.intcoopmat.comp │ ├── spv.interpOps.frag │ ├── spv.layer.tese │ ├── spv.layoutNested.vert │ ├── spv.length.frag │ ├── spv.localAggregates.frag │ ├── spv.loops.frag │ ├── spv.loopsArtificial.frag │ ├── spv.looseUniformNoLoc.vert │ ├── spv.matFun.vert │ ├── spv.matrix.frag │ ├── spv.matrix2.frag │ ├── 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.multiviewPerViewAttributes.tesc │ ├── spv.multiviewPerViewAttributes.vert │ ├── spv.newTexture.frag │ ├── spv.noBuiltInLoc.vert │ ├── spv.noDeadDecorations.vert │ ├── spv.noLocation.vert │ ├── spv.noWorkgroup.comp │ ├── spv.nonSquare.vert │ ├── spv.nonuniform.frag │ ├── spv.nonuniform2.frag │ ├── spv.nonuniform3.frag │ ├── spv.nonuniform4.frag │ ├── spv.nonuniform5.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.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.rw.autoassign.frag │ ├── spv.sample.frag │ ├── spv.sampleId.frag │ ├── spv.sampleMaskOverrideCoverage.frag │ ├── spv.samplePosition.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.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.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.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.subgroupExtendedTypesShuffle.comp │ ├── spv.subgroupExtendedTypesShuffleNeg.comp │ ├── spv.subgroupExtendedTypesShuffleRelative.comp │ ├── spv.subgroupExtendedTypesShuffleRelativeNeg.comp │ ├── spv.subgroupExtendedTypesVote.comp │ ├── spv.subgroupExtendedTypesVoteNeg.comp │ ├── spv.subgroupPartitioned.comp │ ├── spv.subgroupQuad.comp │ ├── spv.subgroupShuffle.comp │ ├── spv.subgroupShuffleRelative.comp │ ├── 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.textureGatherBiasLod.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 │ ├── structAssignment.frag │ ├── structDeref.frag │ ├── structure.frag │ ├── switch.frag │ ├── swizzle.frag │ ├── syntaxError.frag │ ├── terminate.frag │ ├── terminate.vert │ ├── test.frag │ ├── texture.frag │ ├── 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 │ ├── 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.vert ├── WORKSPACE ├── _config.yml ├── build_info.h.tmpl ├── build_info.py ├── build_overrides │ ├── build.gni │ ├── glslang.gni │ └── spirv_tools.gni ├── glslang │ ├── CInterface │ │ └── glslang_c_interface.cpp │ ├── CMakeLists.txt │ ├── 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 │ │ ├── Types.h │ │ ├── arrays.h │ │ ├── glslang_c_interface.h │ │ ├── glslang_c_shader_types.h │ │ └── intermediate.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 │ │ ├── SymbolTable.cpp │ │ ├── SymbolTable.h │ │ ├── Versions.cpp │ │ ├── Versions.h │ │ ├── attribute.cpp │ │ ├── attribute.h │ │ ├── gl_types.h │ │ ├── glslang.m4 │ │ ├── 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 │ ├── OSDependent │ │ ├── Unix │ │ │ ├── CMakeLists.txt │ │ │ └── ossource.cpp │ │ ├── Web │ │ │ ├── CMakeLists.txt │ │ │ ├── glslang.after.js │ │ │ ├── glslang.js.cpp │ │ │ └── glslang.pre.js │ │ ├── Windows │ │ │ ├── CMakeLists.txt │ │ │ ├── main.cpp │ │ │ └── ossource.cpp │ │ └── osinclude.h │ ├── Public │ │ └── ShaderLang.h │ └── updateGrammar ├── gtests │ ├── AST.FromFile.cpp │ ├── BuiltInResource.FromFile.cpp │ ├── CMakeLists.txt │ ├── Config.FromFile.cpp │ ├── HexFloat.cpp │ ├── Hlsl.FromFile.cpp │ ├── Initializer.h │ ├── Link.FromFile.Vk.cpp │ ├── Link.FromFile.cpp │ ├── Pp.FromFile.cpp │ ├── README.md │ ├── Remap.FromFile.cpp │ ├── Settings.cpp │ ├── Settings.h │ ├── Spv.FromFile.cpp │ ├── TestFixture.cpp │ ├── TestFixture.h │ ├── main.cpp │ └── pch.h ├── hlsl │ ├── CMakeLists.txt │ └── stub.cpp ├── known_good.json ├── known_good_khr.json ├── kokoro │ ├── android-ndk-build │ │ ├── build-docker.sh │ │ ├── build.sh │ │ ├── continuous.cfg │ │ └── presubmit.cfg │ ├── license-check │ │ ├── build-docker.sh │ │ ├── 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-clang-release-bazel │ │ ├── build.sh │ │ ├── continuous.cfg │ │ └── presubmit.cfg │ ├── linux-gcc-cmake │ │ ├── build-docker.sh │ │ ├── build.sh │ │ ├── shared │ │ │ ├── continuous.cfg │ │ │ └── presubmit.cfg │ │ └── static │ │ │ ├── continuous.cfg │ │ │ └── presubmit.cfg │ ├── macos-clang-release-bazel │ │ ├── build.sh │ │ ├── continuous.cfg │ │ └── presubmit.cfg │ └── windows-msvc-2015-release-bazel │ │ ├── build.bat │ │ ├── continuous.cfg │ │ └── presubmit.cfg ├── license-checker.cfg ├── ndk_test │ ├── Android.mk │ ├── jni │ │ └── Application.mk │ └── test.cpp ├── standalone.gclient └── update_glslang_sources.py ├── half_lib └── half.hpp ├── samples ├── FFT_upscaled.png ├── FFT_upscaled_2.png ├── car.png ├── close_people.png ├── distant_people.png ├── native_4k.png ├── native_4k_2.png ├── no_upscaling.png ├── no_upscaling_2.png ├── skyscraper.png └── trees.png ├── stb_image ├── stb_image.h └── stb_image_write.h └── vkFFT └── vkFFT.h /glslang-master/.clang-format: -------------------------------------------------------------------------------- 1 | Language: Cpp 2 | IndentWidth: 4 3 | PointerAlignment: Left 4 | BreakBeforeBraces: Custom 5 | BraceWrapping: { AfterFunction: true, AfterControlStatement: false } 6 | IndentCaseLabels: false 7 | ReflowComments: false 8 | ColumnLimit: 120 9 | AccessModifierOffset: -4 10 | AlignTrailingComments: true 11 | AllowShortBlocksOnASingleLine: false 12 | AllowShortIfStatementsOnASingleLine: false 13 | AllowShortLoopsOnASingleLine: false 14 | -------------------------------------------------------------------------------- /glslang-master/.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | *.a 3 | *.so 4 | *.exe 5 | .vscode/ 6 | tags 7 | TAGS 8 | bazel-* 9 | build/ 10 | Test/localResults/ 11 | External/googletest 12 | External/spirv-tools 13 | out/ 14 | 15 | # GN generated files 16 | .cipd/ 17 | *.gclient_entries 18 | third_party/ 19 | buildtools/ 20 | tools/ 21 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/300link3.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | precision highp float; 4 | 5 | out vec4 color1; 6 | 7 | void main() {} 8 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/435.vert: -------------------------------------------------------------------------------- 1 | #version 435 2 | void main() {} -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/450.geom: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | in gl_PerVertex { 4 | float gl_CullDistance[3]; 5 | } gl_in[]; 6 | 7 | out gl_PerVertex { 8 | float gl_CullDistance[3]; 9 | }; 10 | 11 | layout(triangles) in; 12 | 13 | void main() 14 | { 15 | gl_in[3].gl_Position; // ERROR, out of range 16 | gl_CullDistance[2] = gl_in[1].gl_CullDistance[2]; 17 | } 18 | 19 | layout(points) in float f[3]; // ERROR, must be standalone 20 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/badChars.frag: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/badChars.frag -------------------------------------------------------------------------------- /glslang-master/Test/badMacroArgs.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | #define m(a) a 4 | m() -------------------------------------------------------------------------------- /glslang-master/Test/bar.h: -------------------------------------------------------------------------------- 1 | float4 i1; 2 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/badChars.frag.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/badChars.frag.out -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/hlsl.includeNegative.vert.out: -------------------------------------------------------------------------------- 1 | hlsl.includeNegative.vert 2 | ERROR: ./foo.h:1: '#error' : should not be included 3 | ERROR: ./inc2/../foo.h:1: '#error' : should not be included 4 | ERROR: ./parentBad:3: '#error' : bad parent 5 | ERROR: hlsl.includeNegative.vert:7: '#error' : in main 6 | hlsl.includeNegative.vert(8): error at column 0, HLSL parsing failed. 7 | ERROR: 5 compilation errors. No code generated. 8 | 9 | 10 | SPIR-V is not generated for failed compile or link 11 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/hlsl.pp.expand.frag.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/hlsl.pp.expand.frag.err -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/hlsl.reflection.binding.vert.out: -------------------------------------------------------------------------------- 1 | hlsl.reflection.binding.vert 2 | 3 | Linked vertex stage: 4 | 5 | 6 | Uniform reflection: 7 | t1: offset -1, type 8b5d, size 1, index -1, binding 15 8 | s1: offset -1, type 0, size 1, index -1, binding 5 9 | t1a: offset -1, type 8b5d, size 1, index -1, binding 16 10 | s1a: offset -1, type 0, size 1, index -1, binding 6 11 | 12 | Uniform block reflection: 13 | 14 | Vertex attribute reflection: 15 | 16 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.bad_arg.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.bad_arg.vert.out -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.cpp_style___FILE__.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.cpp_style___FILE__.vert.err -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.cpp_style_line_directive.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.cpp_style_line_directive.vert.out -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.defined.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.defined.vert.out -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.edge_cases.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.edge_cases.vert.err -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.eof_missing.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.eof_missing.vert.err -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.eof_missing.vert.out: -------------------------------------------------------------------------------- 1 | noEOF 2 | 3 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.errors.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.errors.vert.out -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.extensions.vert.err: -------------------------------------------------------------------------------- 1 | WARNING: 0:6: '#extension' : extension not supported: GL_EXT_shader_texture_image_samples 2 | 3 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.function_macro.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.function_macro.vert.err -------------------------------------------------------------------------------- /glslang-master/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 | int main(){ 17 | gl_Position = vec4(3 + 1, 3 + 4, 3 + 1); 18 | gl_Position = vec4(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12); 19 | gl_Position = vec4(4 + 3 + 3); 20 | } 21 | 22 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.include.disabled.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.include.disabled.vert.out -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.include.enabled.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.include.enabled.vert.out -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.line.frag.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.line.frag.err -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.line.frag.out: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | #line 1 2 3 | #pragma something 4 | void main(){ } 5 | 6 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.line.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.line.vert.err -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.many.endif.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.many.endif.vert.out -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.pragma.vert.err: -------------------------------------------------------------------------------- 1 | WARNING: 0:10: '#pragma once' : not implemented 2 | 3 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.simple.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.simple.vert.err -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.success_if_parse_would_fail.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/baseResults/preprocessor.success_if_parse_would_fail.vert.err -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/preprocessor.success_if_parse_would_fail.vert.out: -------------------------------------------------------------------------------- 1 | int x(){ 2 | something that shouldnt compile; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/remap.invalid-spirv-1.out: -------------------------------------------------------------------------------- 1 | ID out of range: 4160749568 2 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/remap.invalid-spirv-2.out: -------------------------------------------------------------------------------- 1 | ID not found 2 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/size: -------------------------------------------------------------------------------- 1 | 399360 ../build/install/bin/glslangValidator.exe 2 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/spv.AnyHitShader_Errors.rahit.out: -------------------------------------------------------------------------------- 1 | spv.AnyHitShader_Errors.rahit 2 | ERROR: 0:8: 'assign' : l-value required "payload" (cannot modify hitAttributeNV in this stage) 3 | ERROR: 0:9: 'reportIntersectionNV' : no matching overloaded function found 4 | ERROR: 0:10: 'traceNV' : no matching overloaded function found 5 | ERROR: 3 compilation errors. No code generated. 6 | 7 | 8 | SPIR-V is not generated for failed compile or link 9 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/spv.ext.AnyHitShader_Errors.rahit.out: -------------------------------------------------------------------------------- 1 | spv.ext.AnyHitShader_Errors.rahit 2 | ERROR: 0:8: 'assign' : l-value required "payload" (cannot modify hitAttributeNV in this stage) 3 | ERROR: 0:9: 'reportIntersectionEXT' : no matching overloaded function found 4 | ERROR: 0:10: 'traceRayEXT' : no matching overloaded function found 5 | ERROR: 3 compilation errors. No code generated. 6 | 7 | 8 | SPIR-V is not generated for failed compile or link 9 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/baseResults/vulkan.comp.out: -------------------------------------------------------------------------------- 1 | vulkan.comp 2 | ERROR: 0:5: 'local_size' : cannot change previously set size 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /glslang-master/Test/bump: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | cp localResults/* baseResults/ 3 | 4 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/compoundsuffix.frag.hlsl: -------------------------------------------------------------------------------- 1 | void main(out float4 fragColor : SV_TARGET0) 2 | { 3 | fragColor = 1; 4 | } 5 | 6 | 7 | -------------------------------------------------------------------------------- /glslang-master/Test/compoundsuffix.vert.glsl: -------------------------------------------------------------------------------- 1 | void main() 2 | { 3 | gl_Position = vec4(1.0); 4 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/constFoldIntMin.frag: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | #extension GL_AMD_gpu_shader_int16 : enable 3 | #extension GL_ARB_gpu_shader_int64 : enable 4 | 5 | void a(){ 6 | int16_t u = -32768S / -1S; // SHRT_MIN 7 | int v = -2147483648 / -1; // INT_MIN 8 | int64_t w = -9223372036854775808L / -1L; // LLONG_MIN 9 | int16_t x = -32768S % -1S; // SHRT_MIN 10 | int y = -2147483648 % -1; // INT_MIN 11 | int64_t z = -9223372036854775808L % -1L; // LLONG_MIN 12 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/cppBad.vert: -------------------------------------------------------------------------------- 1 | #define n#0# 2 | #define m #0# 3 | #if m 4 | #endif 5 | #define n() 6 | int n" -------------------------------------------------------------------------------- /glslang-master/Test/cppBad2.vert: -------------------------------------------------------------------------------- 1 | #define a b( 2 | #define b(x) 3 | b(a) -------------------------------------------------------------------------------- /glslang-master/Test/cppBad3.vert: -------------------------------------------------------------------------------- 1 | #define f =y(. 2 | #define y(m) 3 | y(f) -------------------------------------------------------------------------------- /glslang-master/Test/cppBad4.vert: -------------------------------------------------------------------------------- 1 | int,i= 2 | #define f g(#g(y 3 | #define g(m) 4 | g(f) 5 | -------------------------------------------------------------------------------- /glslang-master/Test/cppBad5.vert: -------------------------------------------------------------------------------- 1 | int,i= 2 | #define f g($g(y 3 | #define g(m) 4 | g(f) 5 | -------------------------------------------------------------------------------- /glslang-master/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 -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/dataOut.frag: -------------------------------------------------------------------------------- 1 | #version 130 2 | 3 | varying vec4 Color; 4 | 5 | void main() 6 | { 7 | gl_FragData[1] = Color; 8 | } 9 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/empty.frag: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/empty.frag -------------------------------------------------------------------------------- /glslang-master/Test/empty2.frag: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /glslang-master/Test/empty3.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | -------------------------------------------------------------------------------- /glslang-master/Test/errors.frag: -------------------------------------------------------------------------------- 1 | int main(int foo) 2 | { 3 | return 1; 4 | } 5 | -------------------------------------------------------------------------------- /glslang-master/Test/es-link1.frag: -------------------------------------------------------------------------------- 1 | #version 100 2 | 3 | mediump vec4 calculateColor(); 4 | 5 | void main() 6 | { 7 | gl_FragColor = calculateColor(); 8 | } 9 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/flowControl.frag: -------------------------------------------------------------------------------- 1 | #version 120 2 | 3 | uniform float d; 4 | uniform vec4 bigColor, smallColor; 5 | uniform vec4 otherColor; 6 | 7 | varying float c; 8 | varying vec4 BaseColor; 9 | 10 | void main() 11 | { 12 | vec4 color = BaseColor; 13 | vec4 color2; 14 | 15 | color2 = otherColor; 16 | 17 | if (c > d) 18 | color += bigColor; 19 | else 20 | color += smallColor; 21 | 22 | gl_FragColor = color * color2; 23 | } 24 | -------------------------------------------------------------------------------- /glslang-master/Test/foo.h: -------------------------------------------------------------------------------- 1 | #error should not be included 2 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/glsl.entryPointRename2.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void bar() 4 | { 5 | gl_Position = vec4(1); 6 | } 7 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/glslangValidator: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | ../build/install/bin/glslangValidator $* 3 | -------------------------------------------------------------------------------- /glslang-master/Test/glspv.esversion.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /glslang-master/Test/glspv.version.frag: -------------------------------------------------------------------------------- 1 | #version 330 compatibility 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /glslang-master/Test/glspv.version.vert: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.-D-U.frag: -------------------------------------------------------------------------------- 1 | 2 | #define IN_SHADER 3 | 4 | static float4 color; 5 | 6 | void main() 7 | { 8 | #if FOO==200 9 | color = 1.0; 10 | #else 11 | #error expected FOO 200 12 | #endif 13 | 14 | #ifdef FOO 15 | color -= 5.0; 16 | #else 17 | #error expected FOO 200 18 | #endif 19 | 20 | #ifdef IN_SHADER 21 | color++; 22 | #else 23 | #error IN_SHADER was undef 24 | #endif 25 | 26 | #ifdef UNDEFED 27 | #error UNDEFED defined 28 | #else 29 | color *= 3.0; 30 | #endif 31 | } 32 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.PointSize.vert: -------------------------------------------------------------------------------- 1 | [[vk::builtin("PointSize")]] float main() 2 | { 3 | return 2.3; 4 | } -------------------------------------------------------------------------------- /glslang-master/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; -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.array.multidim.frag: -------------------------------------------------------------------------------- 1 | 2 | float float_array[5][4][3]; 3 | 4 | struct PS_OUTPUT 5 | { 6 | float4 Color : SV_Target0; 7 | }; 8 | 9 | PS_OUTPUT main() 10 | { 11 | float4 float4_array_1[2][3]; 12 | float4 float4_array_2[5][3]; 13 | 14 | float4_array_1[1][2] = float_array[2][3][1]; 15 | float4_array_2[1] = float4_array_1[0]; 16 | 17 | PS_OUTPUT psout; 18 | psout.Color = float4_array_1[1][2]; 19 | return psout; 20 | } 21 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | float4 main() : SV_TARGET 9 | { 10 | [unroll(5*2 + 1) ] 11 | for (int x=0; x> b; 18 | 19 | return r; 20 | } 21 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.cast.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | return (float4)input + (int4)input + (float4)1.198; 4 | } 5 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.clipdistance-2.vert: -------------------------------------------------------------------------------- 1 | void main(out float4 pos : SV_Position, 2 | out float2 clip[2] : SV_ClipDistance, // array of vector float 3 | out float2 cull[2] : SV_CullDistance) // array of vector float 4 | { 5 | pos = 1.0f.xxxx; 6 | clip[0].x = 0.5f; 7 | clip[0].y = 0.6f; 8 | clip[1].x = 0.7f; 9 | clip[1].y = 0.8f; 10 | 11 | cull[0].x = 0.525f; 12 | cull[0].y = 0.625f; 13 | cull[1].x = 0.725f; 14 | cull[1].y = 0.825f; 15 | } 16 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.constantbuffer.frag: -------------------------------------------------------------------------------- 1 | 2 | struct c1_t { 3 | float4 x; 4 | }; 5 | 6 | struct c2_t { 7 | bool x; 8 | float y; 9 | }; 10 | 11 | ConstantBuffer cb1 : register(b12); 12 | ConstantBuffer cb2[3]; 13 | ConstantBuffer cb3[2][4]; 14 | 15 | cbuffer cbuff { 16 | int c1; 17 | }; 18 | 19 | float4 main() : SV_Target0 20 | { 21 | if (cb3[1][2].x) 22 | return cb1.x + cb2[1].y + c1; 23 | else 24 | return cb3[1][3].y; 25 | } 26 | 27 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.constructexpr.frag: -------------------------------------------------------------------------------- 1 | struct PS_OUTPUT { float4 color : SV_Target0; }; 2 | 3 | PS_OUTPUT main() 4 | { 5 | // Evaluates to a sequence: 3, 4, 5, 6, 7, 8, and a float2(9,10), float2(11,12) sequence 6 | (int(3)); 7 | (int(3) + int(1)); 8 | (int(3) + int(1) + int(1)); 9 | (((int(6)))); 10 | (int(7.0)); 11 | ((int((2)) ? 8 : 8)); 12 | (float2(9, 10), float2(11, 12)); 13 | 14 | PS_OUTPUT ps_output; 15 | ps_output.color = 1.0; 16 | return ps_output; 17 | } 18 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.coverage.frag: -------------------------------------------------------------------------------- 1 | 2 | // Verify that coverage mask is an array, as required by SPIR-V. 3 | 4 | struct PS_INPUT 5 | { 6 | }; 7 | 8 | struct PS_OUTPUT 9 | { 10 | float4 vColor : SV_Target0; 11 | uint nCoverageMask : SV_Coverage; 12 | }; 13 | 14 | PS_OUTPUT main( PS_INPUT i ) 15 | { 16 | PS_OUTPUT o; 17 | o.vColor = float4(1.0, 0.0, 0.0, 1.0); 18 | o.nCoverageMask = 0; 19 | return o; 20 | } 21 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.dashI.vert: -------------------------------------------------------------------------------- 1 | // For -Iinc1/path1 -Iinc1/path2 2 | // bar.h from local directory will define i1, while the ones from inc1/path1 and inc1/path2 will not. 3 | // notHere.h is only in inc1/path1 and inc2/path2, and only inc1/path1 defines p1, p2, and p3 4 | // parent.h is local again, and defines i4 5 | 6 | #include "bar.h" 7 | #include "notHere.h" 8 | #include "parent.h" 9 | 10 | float4 main() : SV_Position 11 | { 12 | return i1 + i4 + p1 + p2 + p3; 13 | } 14 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.depthGreater.frag: -------------------------------------------------------------------------------- 1 | void PixelShaderFunction(out float depth : SV_DepthGreaterEqual) 2 | { 3 | depth = 0.2; 4 | } 5 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.depthLess.frag: -------------------------------------------------------------------------------- 1 | float PixelShaderFunction() : SV_DepthLessEqual 2 | { 3 | return 0.2; 4 | } 5 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.entry-in.frag: -------------------------------------------------------------------------------- 1 | struct InParam { 2 | float2 v; 3 | float4 fragCoord : SV_POSITION; 4 | int2 i2; 5 | }; 6 | 7 | float fun(InParam p) 8 | { 9 | return p.v.y + p.fragCoord.x; 10 | } 11 | 12 | float4 PixelShaderFunction(InParam i) : COLOR0 13 | { 14 | InParam local; 15 | local = i; 16 | float ret1 = fun(local); 17 | float ret2 = fun(i); 18 | 19 | return local.fragCoord * ret1 * ret2; 20 | } 21 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.entry-out.frag: -------------------------------------------------------------------------------- 1 | struct OutParam { 2 | float2 v; 3 | int2 i; 4 | }; 5 | 6 | void fun(out OutParam op) 7 | { 8 | op.v = float2(0.4); 9 | op.i = int2(7); 10 | } 11 | 12 | float4 PixelShaderFunction(float4 input, out float4 out1, out OutParam out2, out OutParam out3) : COLOR0 13 | { 14 | out1 = input; 15 | out2.v = 2.0; 16 | out2.i = 3; 17 | OutParam local; 18 | local.v = 12.0; 19 | local.i = 13; 20 | fun(out3); 21 | 22 | return out1; 23 | } 24 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.flattenOpaqueInitMix.vert: -------------------------------------------------------------------------------- 1 | struct FxaaTex { SamplerState smpl; Texture2D tex; float f; }; 2 | SamplerState g_tInputTexture_sampler; Texture2D g_tInputTexture; 3 | 4 | float4 lookUp(FxaaTex tex) 5 | { 6 | return tex.tex.Sample(tex.smpl, float2(tex.f, tex.f)); 7 | } 8 | 9 | float4 main() : SV_TARGET0 10 | { 11 | FxaaTex tex = { g_tInputTexture_sampler, g_tInputTexture, 0.5 }; 12 | return lookUp(tex); 13 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.fraggeom.frag: -------------------------------------------------------------------------------- 1 | // test geometry shader in fragment shader. GS attributes should be successfully ignored. 2 | 3 | struct myVertex { 4 | float4 pos : SV_Position; 5 | }; 6 | 7 | [maxvertexcount(1)] 8 | void GS_Draw(point myVertex IN, inout PointStream OutputStream) 9 | { 10 | OutputStream.Append(IN); 11 | OutputStream.RestartStrip(); 12 | } 13 | 14 | float4 main() : SV_TARGET 15 | { 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.function.frag: -------------------------------------------------------------------------------- 1 | float4 fun0() 2 | { 3 | return 1.0f; 4 | } 5 | 6 | uint fun2(float4 col) 7 | { 8 | return 7; 9 | } 10 | 11 | float4 fun4(uint id1, uniform uint id2) 12 | { 13 | return id1 * id2; 14 | } 15 | 16 | float4 fun1(int index) 17 | { 18 | uint entityId = fun2(fun0()); 19 | return fun4(entityId, entityId); 20 | } 21 | 22 | int main() : SV_TARGET 23 | { 24 | return fun1; 25 | } -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.global-const-init.frag: -------------------------------------------------------------------------------- 1 | 2 | cbuffer CB { 3 | float4 foo; 4 | }; 5 | 6 | static const float4 bar = foo; // test const (in the immutable sense) initializer from non-const. 7 | 8 | static const float2 a1[2] = { { 1, 2 }, { foo.x, 4 } }; // not entirely constant 9 | static const float2 a2[2] = { { 5, 6 }, { 7, 8 } }; // entirely constant 10 | 11 | float4 main() : SV_Target0 12 | { 13 | return bar; 14 | } 15 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.hlslOffset.vert: -------------------------------------------------------------------------------- 1 | cbuffer b { 2 | float m0; 3 | float3 m4; 4 | ////// 5 | float m16; 6 | float3 m20 : packoffset(c1.y); 7 | ///// 8 | float3 m36 : packoffset(c2.y); 9 | ///// 10 | float2 m56 : packoffset(c3.z); 11 | ///// 12 | float m64; 13 | float2 m68; 14 | float m76; 15 | ////// 16 | float m80; 17 | float2 m96[1]; 18 | }; 19 | 20 | void main() {} 21 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.imagefetch-subvec4.comp: -------------------------------------------------------------------------------- 1 | Texture3D IN: register(t0); 2 | RWTexture3D OUT: register(u1); 3 | 4 | [numthreads(8,8,8)] 5 | void main(uint3 tid: SV_DispatchThreadID) 6 | { 7 | OUT[tid] = IN[tid]; 8 | } 9 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.inf.vert: -------------------------------------------------------------------------------- 1 | float4 main() : SV_Position 2 | { 3 | float f1 = -1.#INF; 4 | float f2 = 1.#INF; 5 | float f3 = +1.#INF; 6 | float f4 = f2 * 1.#INF + 1.#INF; 7 | const float f5 = -1.#INF; 8 | const float f6 = f5 * 0.0f; 9 | 10 | return (float4)(f1 + f2 + f3 + f4 + f5 + f6); 11 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.intrinsics.barriers.comp: -------------------------------------------------------------------------------- 1 | 2 | float ComputeShaderFunction() 3 | { 4 | AllMemoryBarrier(); 5 | AllMemoryBarrierWithGroupSync(); 6 | DeviceMemoryBarrier(); 7 | DeviceMemoryBarrierWithGroupSync(); 8 | GroupMemoryBarrier(); 9 | GroupMemoryBarrierWithGroupSync(); 10 | 11 | return 0.0; 12 | } 13 | 14 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.intrinsics.d3dcolortoubyte4.frag: -------------------------------------------------------------------------------- 1 | 2 | uniform float4 col4; 3 | 4 | int4 main() : SV_Target0 5 | { 6 | return D3DCOLORtoUBYTE4(col4); 7 | } 8 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.intrinsics.evalfns.frag: -------------------------------------------------------------------------------- 1 | 2 | void main(float inF1, float2 inF2, float3 inF3, float4 inF4, int2 inI2) : COLOR 3 | { 4 | EvaluateAttributeSnapped(inF1, int2(8,15)); 5 | EvaluateAttributeSnapped(inF2, int2(0,1)); 6 | EvaluateAttributeSnapped(inF3, int2(3,10)); 7 | EvaluateAttributeSnapped(inF4, int2(7,8)); 8 | 9 | EvaluateAttributeSnapped(inF1, inI2); 10 | } 11 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.intrinsics.promote.down.frag: -------------------------------------------------------------------------------- 1 | 2 | struct PS_OUTPUT { float4 color : SV_Target0; }; 3 | 4 | int i; 5 | uint u; 6 | float f; 7 | bool b; 8 | 9 | int2 i2; 10 | uint2 u2; 11 | float2 f2; 12 | bool2 b2; 13 | 14 | PS_OUTPUT main() 15 | { 16 | uint r00 = countbits(f); 17 | uint2 r01 = reversebits(f2); 18 | 19 | PS_OUTPUT ps_output; 20 | ps_output.color = float4(0,0,0,0); 21 | return ps_output; 22 | }; 23 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.localStructuredBuffer.comp: -------------------------------------------------------------------------------- 1 | RWStructuredBuffer srt0; 2 | void main() { 3 | RWStructuredBuffer srt0Local = srt0; 4 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.max.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input1, float4 input2) : COLOR0 2 | { 3 | return max(input1, input2); 4 | } 5 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.memberFunCall.frag: -------------------------------------------------------------------------------- 1 | float method3(float a) { return 1.0; } 2 | 3 | struct myContext { 4 | float method1() { return method2(); } 5 | float method2() { return method3(1.0); } 6 | float method3(float a) { return method4(a, a); } 7 | float method4(float a, float b) { return a + b + f; } 8 | float f; 9 | }; 10 | 11 | float4 main() : SV_TARGET0 12 | { 13 | myContext context; 14 | context.f = 3.0; 15 | return (float4)context.method1(); 16 | } 17 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.opaque-type-bug.frag: -------------------------------------------------------------------------------- 1 | 2 | Texture2D MyTexture : register(t0); 3 | 4 | //---------------------------------------------------------------------------------------- 5 | void TexFunc(in const Texture2D t2D, out float3 RGB) 6 | { 7 | RGB = 0; 8 | } 9 | 10 | //----------------------------------------------------------------------------------- 11 | void main() 12 | { 13 | float3 final_RGB; 14 | 15 | TexFunc(MyTexture, final_RGB); 16 | } 17 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.pp.line.frag: -------------------------------------------------------------------------------- 1 | 2 | #line 1 3 | 4 | struct PS_OUTPUT 5 | { 6 | float4 Color : SV_Target0; 7 | float Depth : SV_Depth; 8 | }; 9 | 10 | #line 2 11 | 12 | PS_OUTPUT main() 13 | { 14 | PS_OUTPUT psout; 15 | 16 | #line 123 "SomeFile.frag" 17 | 18 | int thisLineIs = __LINE__; // gets 124 19 | 20 | psout.Color = float4(thisLineIs, 0, 0, 1); 21 | psout.Depth = 1.0; 22 | 23 | return psout; 24 | } 25 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.samplecmp.dualmode.frag: -------------------------------------------------------------------------------- 1 | SamplerState g_sSamp : register(s0); 2 | SamplerComparisonState g_sSampCmp : register(s1); 3 | 4 | uniform Texture1D g_tTex : register(t3); 5 | 6 | float4 main() : SV_Target0 7 | { 8 | // This texture is used with both shadow modes. It will need post-compilation 9 | // legalization. 10 | g_tTex.SampleCmp(g_sSampCmp, 0.1, 0.75); 11 | g_tTex.Sample(g_sSamp, 0.1); 12 | 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.samplecmp.negative.frag: -------------------------------------------------------------------------------- 1 | 2 | Texture2D g_nonShadowTex; 3 | Texture2D g_shadowTex; 4 | SamplerState g_shadowSampler; 5 | SamplerComparisonState g_shadowSamplerComp; 6 | 7 | float4 main() : SV_Target0 8 | { 9 | g_shadowTex.SampleCmp(g_shadowSamplerComp, float2(0,0), 0); // OK 10 | g_nonShadowTex.SampleCmp(g_shadowSampler, float2(0,0), 0); // ERROR (should be comparison sampler) 11 | 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.self_cast.frag: -------------------------------------------------------------------------------- 1 | struct Test0 {}; 2 | struct Test1 { float f; }; 3 | 4 | void main() 5 | { 6 | { 7 | Test0 a; 8 | Test0 b = (Test0)a; 9 | } 10 | 11 | { 12 | Test1 a; 13 | Test1 b = (Test1)a; 14 | } 15 | 16 | { 17 | Test0 a[2]; 18 | Test0 b[2] = (Test0[2])a; 19 | } 20 | 21 | { 22 | Test1 a[2]; 23 | Test1 b[2] = (Test1[2])a; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.shapeConvRet.frag: -------------------------------------------------------------------------------- 1 | int3 foo() 2 | { 3 | return 13; 4 | } 5 | 6 | float4 main(float f) 7 | { 8 | return f; 9 | } 10 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.sin.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | return sin(input); 4 | } 5 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.singleArgIntPromo.vert: -------------------------------------------------------------------------------- 1 | float main(): SV_Target0 2 | { 3 | int d = 4; 4 | int2 d2 = int2(5,d); 5 | float f1 = log2(5); 6 | float2 f2 = log(d2); 7 | float3 f3 = log(int3(7,2,3)); 8 | float2 f22 = log(int2(5,d)); // This case does not work yet, due to a different bug that turns this into 2 args. 9 | 10 | int a = 5; 11 | min16float b = min16float(f16tof32(a)); 12 | b *= b; 13 | uint c = f32tof16(b); 14 | 15 | return f1 + f2.x + f3.z + f22.y + c; 16 | } -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.snorm.uav.comp: -------------------------------------------------------------------------------- 1 | 2 | unorm float4 uf4; 3 | 4 | Texture3D ResultInU: register(t0); 5 | RWTexture3D ResultOutU: register(u0); 6 | 7 | Texture3D ResultInS: register(t1); 8 | RWTexture3D ResultOutS: register(u1); 9 | 10 | [numthreads(16, 16, 1)] 11 | void main(uint3 tid: SV_DispatchThreadID) 12 | { 13 | ResultOutS[tid] = ResultInS[tid] + uf4; 14 | ResultOutU[tid] = ResultInU[tid]; 15 | } 16 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.stringtoken.frag: -------------------------------------------------------------------------------- 1 | 2 | struct PS_OUTPUT 3 | { 4 | float4 Color : SV_Target0; 5 | }; 6 | 7 | Texture2D TestTexture < 8 | string TestAttribute1 = "TestAttribute"; 9 | string TestAttribute2 = "false"; 10 | int TestAttribute3 = 3; 11 | >; 12 | 13 | uniform float4 TestUF ; 14 | 15 | PS_OUTPUT main() 16 | { 17 | PS_OUTPUT psout; 18 | psout.Color = float4(0,0,0,1); 19 | return psout; 20 | } 21 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.struct.split.trivial.geom: -------------------------------------------------------------------------------- 1 | 2 | struct PS_IN 3 | { 4 | float4 pos : SV_Position; 5 | }; 6 | 7 | struct GS_OUT 8 | { 9 | float4 pos : SV_Position; 10 | }; 11 | 12 | [maxvertexcount(3)] 13 | void main(triangle PS_IN i[3], inout TriangleStream ts) 14 | { 15 | GS_OUT o; 16 | 17 | for (int x=0; x<3; ++x) { 18 | o.pos = i[x].pos; 19 | ts.Append(o); 20 | } 21 | } 22 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.structStructName.frag: -------------------------------------------------------------------------------- 1 | struct S { int s; }; 2 | 3 | int main() 4 | { 5 | struct S t; 6 | return t.s; 7 | } 8 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.structbuffer.floatidx.comp: -------------------------------------------------------------------------------- 1 | struct sb_t 2 | { 3 | float4 color; 4 | uint2 threadId; 5 | }; 6 | 7 | RWTexture2D outtx; 8 | ConsumeStructuredBuffer csb : register(u1); 9 | RWStructuredBuffer rwsb; 10 | 11 | [numthreads(1, 1, 1)] 12 | void main(uint3 nThreadId : SV_DispatchThreadID) 13 | { 14 | sb_t data = csb.Consume(); 15 | float2 coord = float2(data.threadId.xy); 16 | outtx[coord] = data.color; 17 | 18 | rwsb[coord.x] = rwsb.Load(coord.y); 19 | } 20 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.structbuffer.fn2.comp: -------------------------------------------------------------------------------- 1 | ByteAddressBuffer g_input: register(t0); 2 | RWBuffer g_output : register(u1); 3 | 4 | uint2 testLoad(uint loc, ByteAddressBuffer buffer) 5 | { 6 | uint2 result = buffer.Load2(loc); 7 | return result; 8 | } 9 | 10 | [numthreads(256, 1, 1)] 11 | void main(uint dispatchId : SV_DispatchThreadID) 12 | { 13 | uint2 result = testLoad(dispatchId, g_input); 14 | g_output[dispatchId] = result; 15 | } 16 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.structbuffer.rw.frag: -------------------------------------------------------------------------------- 1 | struct sb_t 2 | { 3 | float3 color; 4 | bool test; 5 | }; 6 | 7 | 8 | RWStructuredBuffer sbuf; 9 | RWStructuredBuffer sbuf2; 10 | 11 | float4 main(uint pos : FOO) : SV_Target0 12 | { 13 | sbuf2[pos+1] = 42; 14 | 15 | uint size; 16 | uint stride; 17 | sbuf.GetDimensions(size, stride); 18 | 19 | if (sbuf[pos].test) 20 | return float4(sbuf[pos].color + sbuf2[pos], 0); 21 | else 22 | return size + stride; 23 | } 24 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.structin.vert: -------------------------------------------------------------------------------- 1 | struct VI { 2 | float4 m[2] : mysemA; 3 | float4 coord : SV_POSITION; 4 | linear float4 b : mysemB; 5 | }; 6 | 7 | VI main(float4 d : mysem, VI vi, float4 e : mysem) 8 | { 9 | VI local; 10 | 11 | local.b = vi.m[1] + vi.m[0] + (float4)vi.coord.x + d + e; 12 | local.coord = (float4)1; 13 | local.m[0] = (float4)2; 14 | local.m[1] = (float4)3; 15 | 16 | return local; 17 | } 18 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.targetStruct1.frag: -------------------------------------------------------------------------------- 1 | struct PSInput { 2 | float interp; 3 | uint no_interp; 4 | }; 5 | 6 | struct PSOutput { 7 | float4 o1 : SV_TARGET2; 8 | float4 o2 : SV_TARGET1; 9 | }; 10 | 11 | PSOutput main(PSInput input : INPUT, out float4 po : SV_TARGET0) 12 | { 13 | PSOutput pso; 14 | pso.o1 = float4(float(input.no_interp), input.interp, 0, 1); 15 | pso.o2 = 1; 16 | po = 0; 17 | 18 | return pso; 19 | } -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.targetStruct2.frag: -------------------------------------------------------------------------------- 1 | struct PSInput { 2 | float interp; 3 | uint no_interp; 4 | }; 5 | 6 | struct PSOutput { 7 | float4 o1 : SV_TARGET1; 8 | float4 o2 : SV_TARGET0; 9 | }; 10 | 11 | PSOutput main(PSInput input : INPUT, out float4 po : SV_TARGET0) : SV_TARGET2 12 | { 13 | PSOutput pso; 14 | pso.o1 = float4(float(input.no_interp), input.interp, 0, 1); 15 | pso.o2 = 1; 16 | po = 0; 17 | 18 | return pso; 19 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/hlsl.wavevote.comp: -------------------------------------------------------------------------------- 1 | RWStructuredBuffer data; 2 | 3 | [numthreads(32, 16, 1)] 4 | void CSMain(uint3 dti : SV_DispatchThreadID) 5 | { 6 | data[dti.x] = WaveActiveBallot(WaveActiveAnyTrue(dti.x == 0)); 7 | data[dti.y] = WaveActiveBallot(WaveActiveAllTrue(dti.y == 0)); 8 | data[dti.z] = WaveActiveBallot(WaveActiveAllEqualBool(dti.z == 0)); 9 | data[dti.z] = WaveActiveBallot(WaveActiveAllEqual(dti.z)); 10 | } 11 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/i1.h: -------------------------------------------------------------------------------- 1 | u = g_nDataIdx; 2 | -------------------------------------------------------------------------------- /glslang-master/Test/implicitInnerAtomicUint.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | layout(binding = 0) uniform atomic_uint c[1][]; -------------------------------------------------------------------------------- /glslang-master/Test/inc1/badInc.h: -------------------------------------------------------------------------------- 1 | #include "parentBad" 2 | -------------------------------------------------------------------------------- /glslang-master/Test/inc1/bar.h: -------------------------------------------------------------------------------- 1 | float4 i2; 2 | 3 | #include "foo.h" 4 | -------------------------------------------------------------------------------- /glslang-master/Test/inc1/foo.h: -------------------------------------------------------------------------------- 1 | #include "parent.h" 2 | 3 | float4 i3; 4 | -------------------------------------------------------------------------------- /glslang-master/Test/inc1/path1/bar.h: -------------------------------------------------------------------------------- 1 | float4 i9991; 2 | -------------------------------------------------------------------------------- /glslang-master/Test/inc1/path1/local.h: -------------------------------------------------------------------------------- 1 | float4 p2; 2 | -------------------------------------------------------------------------------- /glslang-master/Test/inc1/path1/notHere.h: -------------------------------------------------------------------------------- 1 | float4 p1; 2 | 3 | #include "local.h" 4 | #include "remote.h" 5 | -------------------------------------------------------------------------------- /glslang-master/Test/inc1/path2/bar.h: -------------------------------------------------------------------------------- 1 | float4 i9991; 2 | -------------------------------------------------------------------------------- /glslang-master/Test/inc1/path2/notHere.h: -------------------------------------------------------------------------------- 1 | float4 paoeu1; 2 | -------------------------------------------------------------------------------- /glslang-master/Test/inc1/path2/remote.h: -------------------------------------------------------------------------------- 1 | float4 p3; 2 | -------------------------------------------------------------------------------- /glslang-master/Test/inc2/bar.h: -------------------------------------------------------------------------------- 1 | #include "foo.h" 2 | float4 i5; 3 | -------------------------------------------------------------------------------- /glslang-master/Test/inc2/foo.h: -------------------------------------------------------------------------------- 1 | float4 i6; 2 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/link.multiAnonBlocksValid.0.1.vert: -------------------------------------------------------------------------------- 1 | #version 430 2 | 3 | layout (std140) uniform ColorBlock 4 | { 5 | vec4 color1; 6 | vec4 color2; 7 | }; 8 | 9 | layout (std140) uniform Block 10 | { 11 | mat4 uProj; 12 | mat4 uWorld; 13 | }; 14 | 15 | out Vertex 16 | { 17 | vec4 v1; 18 | vec4 v2; 19 | }; 20 | 21 | 22 | in vec4 P; 23 | 24 | vec4 getColor2() 25 | { 26 | return color2; 27 | } 28 | 29 | vec4 getWorld() 30 | { 31 | return uWorld * P; 32 | v2 = vec4(1); 33 | } 34 | 35 | -------------------------------------------------------------------------------- /glslang-master/Test/link.multiBlocksInvalid.0.1.vert: -------------------------------------------------------------------------------- 1 | #version 430 2 | 3 | layout (std140) uniform ColorBlock 4 | { 5 | vec4 color2; 6 | } uColorB; 7 | 8 | layout (std140) uniform Block 9 | { 10 | mat4 uWorld; 11 | } uDefaultB; 12 | 13 | out Vertex 14 | { 15 | vec4 v2; 16 | } oVert; 17 | 18 | 19 | in vec4 P; 20 | 21 | vec4 getColor2() 22 | { 23 | return uColorB.color2; 24 | } 25 | 26 | vec4 getWorld() 27 | { 28 | return uDefaultB.uWorld * P; 29 | oVert.v2 = vec4(1); 30 | } 31 | 32 | -------------------------------------------------------------------------------- /glslang-master/Test/link.multiBlocksValid.1.1.vert: -------------------------------------------------------------------------------- 1 | #version 430 2 | 3 | layout (std140) uniform ColorBlock 4 | { 5 | vec4 color1; 6 | vec4 color2; 7 | } a; 8 | 9 | layout (std140) uniform Block 10 | { 11 | mat4 uProj; 12 | mat4 uWorld; 13 | } b; 14 | 15 | out Vertex 16 | { 17 | vec4 v1; 18 | vec4 v2; 19 | } c; 20 | 21 | 22 | in vec4 P; 23 | 24 | vec4 getColor2() 25 | { 26 | return a.color2; 27 | } 28 | 29 | vec4 getWorld() 30 | { 31 | return b.uWorld * P; 32 | c.v2 = vec4(1); 33 | } 34 | 35 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/mains.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | void main() 4 | { 5 | } 6 | 7 | void main() 8 | { 9 | } 10 | -------------------------------------------------------------------------------- /glslang-master/Test/mains1.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /glslang-master/Test/mains2.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /glslang-master/Test/makeDoc: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | ./glslangValidator -p > instDesc 3 | asciidoc --backend=html5 instDesc 4 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/noMain.vert: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | void foo() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /glslang-master/Test/noMain1.geom: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | void foo() 4 | { 5 | } 6 | 7 | layout(points) out; -------------------------------------------------------------------------------- /glslang-master/Test/noMain2.geom: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | void bar() 4 | { 5 | } 6 | 7 | layout(line_strip) out; 8 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/nosuffix: -------------------------------------------------------------------------------- 1 | void main() 2 | { 3 | gl_Position = vec4(1.0); 4 | } -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/Test/parent.h: -------------------------------------------------------------------------------- 1 | float4 i4; 2 | -------------------------------------------------------------------------------- /glslang-master/Test/parentBad: -------------------------------------------------------------------------------- 1 | int a; 2 | 3 | #error bad parent 4 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/preprocessor.defined.vert: -------------------------------------------------------------------------------- 1 | #define defined_not_really 2 | #define defined // ERROR: "defined" can't be (un)defined: 3 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/preprocessor.eof_missing.vert: -------------------------------------------------------------------------------- 1 | noEOF -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/preprocessor.include.disabled.vert: -------------------------------------------------------------------------------- 1 | #line 8000 2 | #include 3 | #include 123 4 | #include "foo" 5 | #include "foo" garbage 6 | #include "no-eol" -------------------------------------------------------------------------------- /glslang-master/Test/preprocessor.line.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | #line 1 2 3 | #pragma something 4 | void main() {} 5 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/preprocessor.success_if_parse_would_fail.vert: -------------------------------------------------------------------------------- 1 | int x() { 2 | something that shouldnt compile; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/Test/recurse2.frag: -------------------------------------------------------------------------------- 1 | #version 330 core 2 | 3 | // cross-unit recursion 4 | 5 | // two-level recursion 6 | 7 | void cfoo(float); 8 | 9 | float cbar(int) 10 | { 11 | cfoo(4.2); 12 | 13 | return 3.2; 14 | } 15 | 16 | // four-level, out of order 17 | 18 | void CA(); 19 | void CC(); 20 | void CB() { CC(); } 21 | void CD() { CA(); } 22 | 23 | // high degree 24 | 25 | void CAT(); 26 | void CCT(); 27 | void CBT() { CCT(); CCT(); CCT(); } 28 | void CDT() { CAT(); } 29 | -------------------------------------------------------------------------------- /glslang-master/Test/reflection.frag: -------------------------------------------------------------------------------- 1 | #version 440 core 2 | 3 | in float inval; 4 | 5 | void main() 6 | { 7 | float f = inval; 8 | } 9 | -------------------------------------------------------------------------------- /glslang-master/Test/reflection.linked.frag: -------------------------------------------------------------------------------- 1 | #version 440 core 2 | 3 | layout(binding = 0, std140) uniform ubo_block { 4 | float unused_uniform; 5 | float shared_uniform; 6 | float vsonly_uniform; 7 | float fsonly_uniform; 8 | } ubo; 9 | 10 | in float vertout; 11 | 12 | out float fragout; 13 | 14 | void main() 15 | { 16 | fragout = vertout; 17 | fragout += ubo.shared_uniform; 18 | fragout += ubo.fsonly_uniform; 19 | } 20 | -------------------------------------------------------------------------------- /glslang-master/Test/reflection.linked.vert: -------------------------------------------------------------------------------- 1 | #version 440 core 2 | 3 | layout(binding = 0, std140) uniform ubo_block { 4 | float unused_uniform; 5 | float shared_uniform; 6 | float vsonly_uniform; 7 | float fsonly_uniform; 8 | } ubo; 9 | 10 | in float vertin; 11 | 12 | out float vertout; 13 | 14 | void main() 15 | { 16 | vertout = vertin; 17 | vertout += ubo.shared_uniform; 18 | vertout += ubo.vsonly_uniform; 19 | } 20 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/remap.invalid-spirv-1.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/remap.invalid-spirv-1.spv -------------------------------------------------------------------------------- /glslang-master/Test/remap.invalid-spirv-2.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/remap.invalid-spirv-2.spv -------------------------------------------------------------------------------- /glslang-master/Test/remap.literal64.everything.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/remap.literal64.everything.spv -------------------------------------------------------------------------------- /glslang-master/Test/remap.literal64.none.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/remap.literal64.none.spv -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/remap.switch.everything.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | precision highp float; 4 | 5 | layout(location = 0) out mediump vec4 FragColor; 6 | layout(location = 0) in vec4 in0; 7 | 8 | void main() 9 | { 10 | switch(int(in0.w)) { 11 | case 0: FragColor = vec4(in0.x + 0); break; 12 | case 1: FragColor = vec4(in0.y + 1); break; 13 | case 2: FragColor = vec4(in0.z + 2); break; 14 | default: FragColor = vec4(-1); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /glslang-master/Test/remap.switch.none.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | precision highp float; 4 | 5 | layout(location = 0) out mediump vec4 FragColor; 6 | layout(location = 0) in vec4 in0; 7 | 8 | void main() 9 | { 10 | switch(int(in0.w)) { 11 | case 0: FragColor = vec4(in0.x + 0); break; 12 | case 1: FragColor = vec4(in0.y + 1); break; 13 | case 2: FragColor = vec4(in0.z + 2); break; 14 | default: FragColor = vec4(-1); 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/specExamples.frag: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/specExamples.frag -------------------------------------------------------------------------------- /glslang-master/Test/specExamples.vert: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/glslang-master/Test/specExamples.vert -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.1.4.OpCopyLogical.funcall.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | struct S { mat4 m; }; 4 | buffer blockName { S s1; }; // need an S with decoration 5 | S s2; // no decorations on S 6 | 7 | void fooConst(const in S s) { } 8 | void foo(in S s) { } 9 | void fooOut(inout S s) { } 10 | 11 | void main() 12 | { 13 | fooConst(s1); 14 | fooConst(s2); 15 | 16 | foo(s1); 17 | foo(s2); 18 | 19 | fooOut(s1); 20 | fooOut(s2); 21 | } -------------------------------------------------------------------------------- /glslang-master/Test/spv.1.4.OpEntryPoint.opaqueParams.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(binding = 0) uniform sampler2D s2D; 4 | layout(binding = 1) uniform texture2D t2D; 5 | layout(binding = 3) uniform sampler s; 6 | 7 | vec2 funOpaque(in sampler2D s2D, texture2D t2D, sampler s) 8 | { 9 | return textureSize(s2D, 0) * texture(sampler2D(t2D, s), vec2(0.5)).xy; 10 | } 11 | 12 | void main() 13 | { 14 | vec2 size = funOpaque(s2D, t2D, s); 15 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.460.frag: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | 3 | layout(binding = 0) uniform atomic_uint aui; 4 | uint ui; 5 | 6 | void main() 7 | { 8 | atomicCounterAdd(aui, ui); 9 | atomicCounterSubtract(aui, ui); 10 | atomicCounterMin(aui, ui); 11 | atomicCounterMax(aui, ui); 12 | atomicCounterAnd(aui, ui); 13 | atomicCounterOr(aui, ui); 14 | atomicCounterXor(aui, ui); 15 | atomicCounterExchange(aui, ui); 16 | atomicCounterCompSwap(aui, ui, ui); 17 | } 18 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.460.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void main() 4 | { 5 | int a = gl_BaseVertex + gl_BaseInstance + gl_DrawID; 6 | } 7 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.ClosestHitShader_Errors.rchit: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_NV_ray_tracing : enable 3 | hitAttributeNV vec4 payload; 4 | layout(binding = 0, set = 0) uniform accelerationStructureNV accNV; 5 | 6 | void main() 7 | { 8 | payload.x = 1.0f; // ERROR, cannot write to hitattributeNV in stage 9 | reportIntersectionNV(1.0, 1U); // ERROR, unsupported builtin in stage 10 | terminateRayNV(); 11 | ignoreIntersectionNV(); 12 | } 13 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.arbPostDepthCoverage.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_ARB_post_depth_coverage : enable 4 | #extension GL_EXT_post_depth_coverage : enable //according to ARB_post_depth_coverage, 5 | //if both enabled, this one should be ignored 6 | precision highp int; 7 | layout(post_depth_coverage) in; 8 | 9 | layout (location = 0) out int readSampleMaskIn; 10 | 11 | void main () { 12 | readSampleMaskIn = gl_SampleMaskIn[0]; 13 | } 14 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.arbPostDepthCoverage_Error.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | #extension GL_ARB_post_depth_coverage : enable 4 | 5 | precision highp float; 6 | 7 | layout(post_depth_coverage, location = 0) in float a; // should fail since post_depth_coverage may only 8 | // be declared on in only (not with variable declarations) 9 | 10 | void main () { 11 | 12 | } 13 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.bufferhandle17_Errors.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_shader_explicit_arithmetic_types_int64 : enable 4 | #extension GL_EXT_buffer_reference : enable 5 | #extension GL_EXT_scalar_block_layout : enable 6 | 7 | layout(buffer_reference) buffer T1 { 8 | int x; 9 | }; 10 | 11 | const T1 a = T1(uint64_t(2)); 12 | 13 | void main() 14 | { 15 | T1 b, c; 16 | const T1 d = b; 17 | 18 | b == c; 19 | b != c; 20 | } 21 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.conditionalDemote.frag: -------------------------------------------------------------------------------- 1 | #version 460 core 2 | #extension GL_EXT_demote_to_helper_invocation : enable 3 | 4 | layout(set = 0, binding = 0) uniform sampler2D tex; 5 | layout(location = 0) in vec2 coord; 6 | layout(location = 0) out vec4 o; 7 | 8 | void main (void) 9 | { 10 | vec4 v = texture(tex, coord); 11 | 12 | if (v == vec4(0.1,0.2,0.3,0.4)) 13 | demote; 14 | 15 | bool x = helperInvocationEXT(); 16 | 17 | o = v; 18 | } 19 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.dataOut.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | in vec4 Color; 4 | 5 | void main() 6 | { 7 | gl_FragData[1] = Color; 8 | } 9 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.dead-complex-merge-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 | int i = 0; 8 | o = 1; 9 | do { 10 | o = 2; 11 | return; 12 | o = 3; 13 | } while(i++ < 5); 14 | 15 | // All this is a dead merge block. 16 | o = 4; 17 | if (c==4) { 18 | o = 100; 19 | } else { 20 | o = 200; 21 | } 22 | o = 300; 23 | } 24 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.ext.AccelDecl.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_ARB_separate_shader_objects : enable 3 | #extension GL_EXT_nonuniform_qualifier : enable 4 | #extension GL_GOOGLE_include_directive : enable 5 | #extension GL_EXT_scalar_block_layout : enable 6 | #extension GL_EXT_ray_query : enable 7 | 8 | layout(location = 0) out vec4 outColor; 9 | 10 | layout(binding = 1, set = 0) uniform accelerationStructureEXT topLevelAS; 11 | 12 | void main() { 13 | outColor = vec4(0.0); 14 | } 15 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.ext.RayQueryDecl.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | #extension GL_ARB_separate_shader_objects : enable 3 | #extension GL_EXT_nonuniform_qualifier : enable 4 | #extension GL_GOOGLE_include_directive : enable 5 | #extension GL_EXT_scalar_block_layout : enable 6 | #extension GL_EXT_ray_query : enable 7 | 8 | layout(location = 0) out vec4 outColor; 9 | 10 | rayQueryEXT rq; 11 | 12 | void main() { 13 | outColor = vec4(0.0); 14 | } 15 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/Test/spv.flowControl.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | in float d; 4 | in vec4 bigColor, smallColor; 5 | in vec4 otherColor; 6 | 7 | in float c; 8 | in vec4 BaseColor; 9 | 10 | void main() 11 | { 12 | vec4 color = BaseColor; 13 | vec4 color2; 14 | 15 | color2 = otherColor; 16 | 17 | if (c > d) 18 | color += bigColor; 19 | else 20 | color += smallColor; 21 | 22 | gl_FragColor = color * color2; 23 | } 24 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.fragmentDensity-neg.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | //make sure the builtins don't exist if the extension isn't enabled. 4 | //#extension GL_EXT_fragment_invocation_density : require 5 | 6 | layout (location = 0) out vec2 FragSize; 7 | layout (location = 2) out int FragInvocationCount; 8 | 9 | void main () { 10 | FragSize = gl_FragSizeEXT; 11 | FragInvocationCount = gl_FragInvocationCountEXT; 12 | } 13 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.fragmentShaderBarycentric.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_NV_fragment_shader_barycentric : require 3 | 4 | layout(location = 0) pervertexNV in vertices { 5 | float attrib; 6 | } v[]; 7 | 8 | layout(location = 1) out float value; 9 | 10 | void main () { 11 | value = (gl_BaryCoordNV.x * v[0].attrib + 12 | gl_BaryCoordNV.y * v[1].attrib + 13 | gl_BaryCoordNV.z * v[2].attrib); 14 | 15 | } 16 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.fragmentShaderBarycentric2.frag: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | #extension GL_NV_fragment_shader_barycentric : require 3 | 4 | precision highp float; 5 | 6 | layout(location = 0) pervertexNV in float vertexIDs[3]; 7 | 8 | layout(location = 1) out float value; 9 | 10 | void main () { 11 | value = (gl_BaryCoordNoPerspNV.x * vertexIDs[0] + 12 | gl_BaryCoordNoPerspNV.y * vertexIDs[1] + 13 | gl_BaryCoordNoPerspNV.z * vertexIDs[2]); 14 | 15 | } 16 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.glFragColor.frag: -------------------------------------------------------------------------------- 1 | #version 330 2 | 3 | void main() 4 | { 5 | gl_FragColor = vec4(1.0); 6 | } 7 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.hlslDebugInfo.vert: -------------------------------------------------------------------------------- 1 | float4 origMain() : SV_Position 2 | { 3 | return (float4)0; 4 | } 5 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.multiStructFuncall.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | struct S { mat4 m; }; 4 | buffer blockName { S s1; }; // need an S with decoration 5 | S s2; // no decorations on S 6 | 7 | void fooConst(const in S s) { } 8 | void foo(in S s) { } 9 | void fooOut(inout S s) { } 10 | 11 | void main() 12 | { 13 | fooConst(s1); 14 | fooConst(s2); 15 | 16 | foo(s1); 17 | foo(s2); 18 | 19 | fooOut(s1); 20 | fooOut(s2); 21 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.multiviewPerViewAttributes.tesc: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_NVX_multiview_per_view_attributes :require 4 | 5 | layout(vertices = 4) out; 6 | out gl_PerVertex { 7 | int gl_ViewportMaskPerViewNV[]; 8 | vec4 gl_PositionPerViewNV[]; 9 | } gl_out[]; 10 | void main() 11 | { 12 | gl_out[gl_InvocationID].gl_ViewportMaskPerViewNV[0] = 1; 13 | gl_out[gl_InvocationID].gl_PositionPerViewNV[0] = gl_in[1].gl_Position + gl_in[1].gl_PositionPerViewNV[0]; 14 | } 15 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | void main() 6 | { 7 | } 8 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.nonuniform3.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_nonuniform_qualifier : require 3 | layout(set = 0, binding = 0) uniform texture2D uTex[]; 4 | layout(set = 1, binding = 0) uniform sampler uSamp; 5 | layout(location = 0) flat in int Index; 6 | layout(location = 0) out vec4 FragColor; 7 | void main() 8 | { 9 | FragColor = texture(nonuniformEXT(sampler2D(uTex[Index], uSamp)), vec2(0.5)); 10 | } 11 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.offsets.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(set = 0, binding = 0, std140) uniform n1 { 4 | layout(offset = 8) int a; 5 | layout(offset = 4) int b; 6 | layout(offset = 0) int c; 7 | layout(offset = 12) int d; 8 | } i1; 9 | 10 | layout(set = 0, binding = 1, std430) buffer n2 { 11 | layout(offset = 32) vec3 e; 12 | vec3 f; 13 | layout(offset = 16) vec3 g; 14 | layout(offset = 0) vec3 h; 15 | } i2; 16 | 17 | void main() {} -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.shaderDrawParams.vert: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | 3 | #extension GL_ARB_shader_draw_parameters: enable 4 | 5 | layout(binding = 0) uniform Block 6 | { 7 | vec4 pos[2][4]; 8 | } block; 9 | 10 | void main() 11 | { 12 | if ((gl_BaseVertexARB > 0) || (gl_BaseInstanceARB > 0)) 13 | gl_Position = block.pos[0][gl_DrawIDARB % 4]; 14 | else 15 | gl_Position = block.pos[1][gl_DrawIDARB % 4]; 16 | } 17 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.shaderGroupVote.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_ARB_shader_group_vote : enable 4 | 5 | layout(local_size_x = 4, local_size_y = 4) in; 6 | 7 | layout(std430, binding = 0) buffer Buffers 8 | { 9 | bool b; 10 | }; 11 | 12 | void main() 13 | { 14 | bool b1 = b; 15 | 16 | b1 = anyInvocationARB(b1); 17 | b1 = allInvocationsARB(b1); 18 | b1 = allInvocationsEqualARB(b1); 19 | 20 | b = b1; 21 | } 22 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.specConstant.float16.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_shader_explicit_arithmetic_types_float16 : require 3 | 4 | layout(constant_id = 1) const float16_t sc0 = 9.5hf; 5 | layout(constant_id = 2) const float16_t sc1 = -14.25hf; 6 | 7 | layout (set = 0, binding = 0, std430) writeonly buffer Output { 8 | float16_t r0; 9 | float16_t r1; 10 | } sb_out; 11 | 12 | 13 | void main (void) 14 | { 15 | sb_out.r0 = sc0; 16 | sb_out.r1 = sc1; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.specConstant.int16.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_shader_explicit_arithmetic_types_int16 : require 3 | 4 | layout(constant_id = 1) const int16_t sc0 = 20000s; 5 | layout(constant_id = 2) const int16_t sc1 = -20000s; 6 | 7 | layout (set = 0, binding = 0, std430) writeonly buffer Output { 8 | int16_t r0; 9 | int16_t r1; 10 | } sb_out; 11 | 12 | 13 | void main (void) 14 | { 15 | sb_out.r0 = sc0; 16 | sb_out.r1 = sc1; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.specConstant.int8.comp: -------------------------------------------------------------------------------- 1 | #version 450 2 | #extension GL_EXT_shader_explicit_arithmetic_types_int8 : require 3 | 4 | layout(constant_id = 1) const int8_t sc0 = int8_t(127); 5 | layout(constant_id = 2) const int8_t sc1 = int8_t(-127); 6 | 7 | layout (set = 0, binding = 0, std430) writeonly buffer Output { 8 | int8_t r0; 9 | int8_t r1; 10 | } sb_out; 11 | 12 | 13 | void main (void) 14 | { 15 | sb_out.r0 = sc0; 16 | sb_out.r1 = sc1; 17 | } 18 | 19 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.terminate.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | #extension GL_EXT_terminate_invocation : enable 4 | 5 | void main() 6 | { 7 | terminateInvocation; 8 | } 9 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.test.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | uniform sampler2D texSampler2D; 4 | uniform sampler3D texSampler3D; 5 | 6 | in float blend; 7 | in vec2 scale; 8 | in vec4 u; 9 | 10 | in vec2 t; 11 | in vec3 coords; 12 | 13 | void main() 14 | { 15 | float blendscale = 1.789; 16 | 17 | vec4 v = texture(texSampler2D, (t + scale) / scale ).wzyx; 18 | 19 | vec4 w = texture(texSampler3D, coords) + v; 20 | 21 | gl_FragColor = mix(w, u, blend * blendscale); 22 | } 23 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.textureBuffer.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | uniform textureBuffer tBuf; 4 | uniform sampler s; 5 | uniform samplerBuffer sBuf; 6 | 7 | uniform utextureBuffer utBuf; 8 | uniform itextureBuffer itBuf; 9 | 10 | void main() 11 | { 12 | texelFetch(samplerBuffer(tBuf, s), 13); 13 | texelFetch(sBuf, 13); 14 | texelFetch(tBuf, 13); 15 | texelFetch(utBuf, 13); 16 | texelFetch(itBuf, 13); 17 | } 18 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.uniformInitializerStruct.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (location = 0) out vec4 color; 4 | 5 | layout (location = 0) uniform struct { 6 | float r; 7 | float g; 8 | float b; 9 | } parts[2] = { { 1.0, 1.0, 1.0}, { 0.0, 1.0, 0.0 } }; 10 | 11 | void main() { 12 | color = vec4(0.0, 0.0, 0.0, 1.0); 13 | 14 | for (int i = 0; i < 2; i++) { 15 | color.r += parts[i].r; 16 | color.g += parts[i].g; 17 | color.b += parts[i].b; 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.varyingArray.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | uniform sampler2D texSampler2D; 3 | in vec4 color; 4 | in float alpha; 5 | 6 | in vec4 TexCoord[6]; 7 | 8 | in vec4 foo[3]; 9 | 10 | void main() 11 | { 12 | vec4 texColor = texture(texSampler2D, vec2(TexCoord[4] + TexCoord[5])); 13 | 14 | texColor += color; 15 | 16 | texColor.a = alpha; 17 | 18 | gl_FragColor = foo[1] + TexCoord[0] + TexCoord[4] + texColor; 19 | } 20 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.varyingArrayIndirect.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | uniform sampler2D texSampler2D; 3 | in vec4 color; 4 | in float alpha; 5 | 6 | in vec4 TexCoord[6]; 7 | 8 | in vec4 userIn[2]; 9 | 10 | flat in int a, b; 11 | 12 | void main() 13 | { 14 | vec4 texColor = texture(texSampler2D, vec2(userIn[b] + TexCoord[a] + TexCoord[5])); 15 | 16 | texColor += color; 17 | 18 | texColor.a = alpha; 19 | 20 | gl_FragColor = TexCoord[0] + TexCoord[b] + texColor + userIn[a]; 21 | } 22 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.viewportArray2.tesc: -------------------------------------------------------------------------------- 1 | #version 450 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 | gl_ViewportIndex = 2; 16 | } 17 | -------------------------------------------------------------------------------- /glslang-master/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 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.voidFunction.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | in vec4 bigColor; 4 | in vec4 BaseColor; 5 | in float d; 6 | 7 | float bar = 2.0; 8 | 9 | void foo() 10 | { 11 | bar++; 12 | 13 | return; 14 | } 15 | 16 | void foo2() 17 | { 18 | bar++; 19 | } 20 | 21 | void main() 22 | { 23 | vec4 outColor = bigColor; 24 | 25 | foo(); 26 | 27 | foo2(); 28 | 29 | outColor.x += bar; 30 | 31 | gl_FragColor = outColor; 32 | 33 | return; 34 | } 35 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/spv.xfb2.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (location = 0) in vec4 position; 4 | layout (binding = 5) uniform ComponentsBlock 5 | { 6 | vec4 c1; 7 | vec2 c2; 8 | } components; 9 | 10 | layout (xfb_buffer = 3, xfb_offset = 16) out gl_PerVertex 11 | { 12 | vec4 gl_Position; 13 | }; 14 | 15 | void main() 16 | { 17 | gl_Position = position + components.c1 + vec4(components.c2, 0.0, 0.0); 18 | } -------------------------------------------------------------------------------- /glslang-master/Test/spv.xfb3.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout (location = 0) in vec4 position; 4 | layout (binding = 5) uniform ComponentsBlock 5 | { 6 | vec4 c1; 7 | vec2 c2; 8 | } components; 9 | 10 | layout (xfb_buffer = 3, xfb_offset = 16) out gl_PerVertex 11 | { 12 | layout(xfb_stride = 80) vec4 gl_Position; 13 | }; 14 | 15 | void main() 16 | { 17 | gl_Position = position + components.c1 + vec4(components.c2, 0.0, 0.0); 18 | } -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/Test/varyingArray.frag: -------------------------------------------------------------------------------- 1 | #version 130 2 | uniform sampler2D texSampler2D; 3 | varying vec4 color; 4 | varying float alpha; 5 | 6 | varying vec4 gl_TexCoord[6]; 7 | 8 | varying vec4 foo[3]; 9 | 10 | void main() 11 | { 12 | vec4 texColor = texture2D(texSampler2D, vec2(gl_TexCoord[4] + gl_TexCoord[5])); 13 | 14 | texColor += color; 15 | 16 | texColor.a = alpha; 17 | 18 | gl_FragColor = foo[1] + gl_TexCoord[0] + gl_TexCoord[4] + texColor; 19 | } 20 | -------------------------------------------------------------------------------- /glslang-master/Test/voidFunction.frag: -------------------------------------------------------------------------------- 1 | #version 120 2 | 3 | uniform vec4 bigColor; 4 | varying vec4 BaseColor; 5 | uniform float d; 6 | 7 | float bar = 2.0; 8 | 9 | void foo() 10 | { 11 | bar++; 12 | 13 | return; 14 | } 15 | 16 | void foo2() 17 | { 18 | bar++; 19 | } 20 | 21 | void main() 22 | { 23 | vec4 outColor = bigColor; 24 | 25 | foo(); 26 | 27 | foo2(); 28 | 29 | outColor.x += bar; 30 | 31 | gl_FragColor = outColor; 32 | 33 | return; 34 | } 35 | -------------------------------------------------------------------------------- /glslang-master/Test/vulkan.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 | layout(local_size_z_id = 14) in; // ERROR, can't change this 6 | 7 | void main() 8 | { 9 | gl_WorkGroupSize; 10 | } 11 | 12 | layout(local_size_y_id = 19) in; // ERROR, already used: TODO not yet reported 13 | -------------------------------------------------------------------------------- /glslang-master/Test/web.array.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | precision highp float; 4 | 5 | float g4[4]; 6 | float g5[5]; 7 | 8 | layout(location = 0) out vec2 colorOut; 9 | 10 | float[4] foo(float a[5]) 11 | { 12 | return float[](a[0], a[1], a[2], a[3]); 13 | } 14 | 15 | void main() 16 | { 17 | g4 = foo(g5); 18 | 19 | if (float[4](1.0, 2.0, 3.0, 4.0) == g4) 20 | ; 21 | 22 | float u[5]; 23 | foo(u); 24 | 25 | colorOut = vec2(g4.length(), g5.length()); 26 | } 27 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/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 | -------------------------------------------------------------------------------- /glslang-master/_config.yml: -------------------------------------------------------------------------------- 1 | theme: jekyll-theme-merlot 2 | -------------------------------------------------------------------------------- /samples/FFT_upscaled.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/FFT_upscaled.png -------------------------------------------------------------------------------- /samples/FFT_upscaled_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/FFT_upscaled_2.png -------------------------------------------------------------------------------- /samples/car.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/car.png -------------------------------------------------------------------------------- /samples/close_people.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/close_people.png -------------------------------------------------------------------------------- /samples/distant_people.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/distant_people.png -------------------------------------------------------------------------------- /samples/native_4k.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/native_4k.png -------------------------------------------------------------------------------- /samples/native_4k_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/native_4k_2.png -------------------------------------------------------------------------------- /samples/no_upscaling.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/no_upscaling.png -------------------------------------------------------------------------------- /samples/no_upscaling_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/no_upscaling_2.png -------------------------------------------------------------------------------- /samples/skyscraper.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/skyscraper.png -------------------------------------------------------------------------------- /samples/trees.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/DTolm/VkResample/27b3dafab3c6c7d558c11adcf42d123aa96411d7/samples/trees.png --------------------------------------------------------------------------------