├── .gitattributes ├── .gitignore ├── .travis.yml ├── CHANGELOG.md ├── CMakeLists.txt ├── CONTRIBUTING.md ├── HOW_TO_BUILD.txt ├── LICENSE.txt ├── README.md ├── deps ├── VulkanMemoryAllocator │ └── vk_mem_alloc.h ├── glslang │ ├── .gitattributes │ ├── .gitignore │ ├── Android.mk │ ├── BUILD.gn │ ├── CMakeLists.txt │ ├── CODE_OF_CONDUCT.md │ ├── ChooseMSVCCRT.cmake │ ├── External │ │ └── CMakeLists.txt │ ├── LICENSE.txt │ ├── OGLCompilersDLL │ │ ├── CMakeLists.txt │ │ ├── InitializeDll.cpp │ │ └── InitializeDll.h │ ├── README-spirv-remap.txt │ ├── README.md │ ├── SPIRV │ │ ├── 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 │ │ ├── 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 │ │ └── 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.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.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 │ │ │ ├── conversion.frag.out │ │ │ ├── cppBad.vert.out │ │ │ ├── cppBad2.vert.out │ │ │ ├── cppComplexExpr.vert.out │ │ │ ├── cppDeepNest.frag.out │ │ │ ├── cppIndent.vert.out │ │ │ ├── cppIntMinOverNegativeOne.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.entryPointRename.vert.bad.out │ │ │ ├── glsl.entryPointRename.vert.out │ │ │ ├── glsl.entryPointRename2.vert.out │ │ │ ├── glspv.esversion.vert.out │ │ │ ├── glspv.frag.out │ │ │ ├── glspv.version.frag.out │ │ │ ├── glspv.version.vert.out │ │ │ ├── glspv.vert.out │ │ │ ├── hlsl.-D-U.frag.out │ │ │ ├── hlsl.PointSize.geom.out │ │ │ ├── hlsl.PointSize.vert.out │ │ │ ├── hlsl.aliasOpaque.frag.out │ │ │ ├── hlsl.amend.frag.out │ │ │ ├── hlsl.array.flatten.frag.out │ │ │ ├── hlsl.array.frag.out │ │ │ ├── hlsl.array.implicit-size.frag.out │ │ │ ├── hlsl.array.multidim.frag.out │ │ │ ├── hlsl.assoc.frag.out │ │ │ ├── hlsl.attribute.expression.comp.out │ │ │ ├── hlsl.attribute.frag.out │ │ │ ├── hlsl.attributeC11.frag.out │ │ │ ├── hlsl.attributeGlobalBuffer.frag.out │ │ │ ├── hlsl.automap.frag.out │ │ │ ├── hlsl.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.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.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.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.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.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.snorm.uav.comp.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 │ │ │ ├── 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 │ │ │ ├── recurse1.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 │ │ │ ├── specExamples.frag.out │ │ │ ├── specExamples.vert.out │ │ │ ├── specExamplesConf.vert.out │ │ │ ├── spv.1.3.8bitstorage-ssbo.vert.out │ │ │ ├── spv.1.3.8bitstorage-ubo.vert.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.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.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.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.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.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.bufferhandle_Error.frag.out │ │ │ ├── spv.builtInXFB.vert.out │ │ │ ├── spv.computeShaderDerivatives.comp.out │ │ │ ├── spv.computeShaderDerivatives2.comp.out │ │ │ ├── spv.conditionalDiscard.frag.out │ │ │ ├── spv.constStruct.vert.out │ │ │ ├── spv.controlFlowAttributes.frag.out │ │ │ ├── spv.conversion.frag.out │ │ │ ├── spv.dataOut.frag.out │ │ │ ├── spv.dataOutIndirect.frag.out │ │ │ ├── spv.dataOutIndirect.vert.out │ │ │ ├── spv.debugInfo.1.1.frag.out │ │ │ ├── spv.debugInfo.frag.out │ │ │ ├── spv.deepRvalue.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.extPostDepthCoverage.frag.out │ │ │ ├── spv.extPostDepthCoverage_Error.frag.out │ │ │ ├── spv.float16.frag.out │ │ │ ├── spv.float16Fetch.frag.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.fullyCovered.frag.out │ │ │ ├── spv.functionCall.frag.out │ │ │ ├── spv.functionNestedOpaque.vert.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.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.interpOps.frag.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.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.offsets.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.precisionNonESSamp.frag.out │ │ │ ├── spv.prepost.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.sparseTexture.frag.out │ │ │ ├── spv.sparseTextureClamp.frag.out │ │ │ ├── spv.specConst.vert.out │ │ │ ├── spv.specConstant.comp.out │ │ │ ├── spv.specConstant.vert.out │ │ │ ├── spv.specConstantComposite.vert.out │ │ │ ├── spv.specConstantOperations.vert.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.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.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.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.voidFunction.frag.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 │ │ │ ├── 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 │ │ │ └── whileLoop.frag.out │ │ ├── bump │ │ ├── comment.frag │ │ ├── compoundsuffix.frag.hlsl │ │ ├── compoundsuffix.vert.glsl │ │ ├── conditionalDiscard.frag │ │ ├── constErrors.frag │ │ ├── constFold.frag │ │ ├── constFoldIntMin.frag │ │ ├── constantUnaryConversion.comp │ │ ├── conversion.frag │ │ ├── cppBad.vert │ │ ├── cppBad2.vert │ │ ├── cppComplexExpr.vert │ │ ├── cppDeepNest.frag │ │ ├── cppIndent.vert │ │ ├── cppIntMinOverNegativeOne.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.entryPointRename.vert │ │ ├── glsl.entryPointRename2.vert │ │ ├── glslangValidator │ │ ├── glspv.esversion.vert │ │ ├── glspv.frag │ │ ├── glspv.version.frag │ │ ├── glspv.version.vert │ │ ├── glspv.vert │ │ ├── hlsl.-D-U.frag │ │ ├── hlsl.PointSize.geom │ │ ├── hlsl.PointSize.vert │ │ ├── hlsl.aliasOpaque.frag │ │ ├── hlsl.amend.frag │ │ ├── hlsl.array.flatten.frag │ │ ├── hlsl.array.frag │ │ ├── hlsl.array.implicit-size.frag │ │ ├── hlsl.array.multidim.frag │ │ ├── hlsl.assoc.frag │ │ ├── hlsl.attribute.expression.comp │ │ ├── hlsl.attribute.frag │ │ ├── hlsl.attributeC11.frag │ │ ├── hlsl.attributeGlobalBuffer.frag │ │ ├── hlsl.automap.frag │ │ ├── hlsl.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.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.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.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.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.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.snorm.uav.comp │ │ ├── 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 │ │ ├── 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 │ │ ├── recurse1.frag │ │ ├── recurse1.vert │ │ ├── recurse2.frag │ │ ├── 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.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.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.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.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.bufferhandle2.frag │ │ ├── spv.bufferhandle3.frag │ │ ├── spv.bufferhandle4.frag │ │ ├── spv.bufferhandle5.frag │ │ ├── spv.bufferhandle6.frag │ │ ├── spv.bufferhandle7.frag │ │ ├── spv.bufferhandle8.frag │ │ ├── spv.bufferhandle9.frag │ │ ├── spv.bufferhandle_Error.frag │ │ ├── spv.builtInXFB.vert │ │ ├── spv.computeShaderDerivatives.comp │ │ ├── spv.computeShaderDerivatives2.comp │ │ ├── spv.conditionalDiscard.frag │ │ ├── spv.constStruct.vert │ │ ├── spv.controlFlowAttributes.frag │ │ ├── spv.conversion.frag │ │ ├── spv.dataOut.frag │ │ ├── spv.dataOutIndirect.frag │ │ ├── spv.dataOutIndirect.vert │ │ ├── spv.debugInfo.frag │ │ ├── spv.deepRvalue.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.extPostDepthCoverage.frag │ │ ├── spv.extPostDepthCoverage_Error.frag │ │ ├── spv.float16.frag │ │ ├── spv.float16Fetch.frag │ │ ├── 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.fullyCovered.frag │ │ ├── spv.functionCall.frag │ │ ├── spv.functionNestedOpaque.vert │ │ ├── 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.imageLoadStoreLod.frag │ │ ├── spv.int16.amd.frag │ │ ├── spv.int16.frag │ │ ├── spv.int32.frag │ │ ├── spv.int64.frag │ │ ├── spv.int8.frag │ │ ├── spv.intOps.vert │ │ ├── spv.interpOps.frag │ │ ├── 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.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.offsets.frag │ │ ├── spv.paramMemory.frag │ │ ├── spv.perprimitiveNV.frag │ │ ├── spv.pp.line.frag │ │ ├── spv.precise.tesc │ │ ├── spv.precise.tese │ │ ├── spv.precision.frag │ │ ├── spv.precisionNonESSamp.frag │ │ ├── spv.prepost.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.sparseTexture.frag │ │ ├── spv.sparseTextureClamp.frag │ │ ├── spv.specConst.vert │ │ ├── spv.specConstant.comp │ │ ├── spv.specConstant.vert │ │ ├── spv.specConstantComposite.vert │ │ ├── spv.specConstantOperations.vert │ │ ├── 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.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.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.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.voidFunction.frag │ │ ├── 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 │ │ ├── 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 │ │ └── whileLoop.frag │ ├── build_overrides │ │ └── glslang.gni │ ├── glslang │ │ ├── CMakeLists.txt │ │ ├── GenericCodeGen │ │ │ ├── CodeGen.cpp │ │ │ └── Link.cpp │ │ ├── Include │ │ │ ├── BaseTypes.h │ │ │ ├── Common.h │ │ │ ├── ConstantUnion.h │ │ │ ├── InfoSink.h │ │ │ ├── InitializeGlobals.h │ │ │ ├── PoolAlloc.h │ │ │ ├── ResourceLimits.h │ │ │ ├── ShHandle.h │ │ │ ├── Types.h │ │ │ ├── arrays.h │ │ │ ├── intermediate.h │ │ │ ├── revision.h │ │ │ └── revision.template │ │ ├── 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.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.cpp │ │ │ ├── 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 │ │ │ ├── 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.cpp │ │ └── pch.h │ ├── hlsl │ │ ├── CMakeLists.txt │ │ ├── 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.cpp │ │ └── pch.h │ ├── known_good.json │ ├── known_good_khr.json │ ├── make-revision │ ├── ndk_test │ │ ├── Android.mk │ │ ├── jni │ │ │ └── Application.mk │ │ └── test.cpp │ └── update_glslang_sources.py └── miniz │ └── miniz.c ├── examples ├── DynamicBuffers │ ├── CMakeLists.txt │ ├── include │ │ └── app.h │ └── src │ │ └── app.cpp ├── HOW_TO_BUILD.txt ├── MultiViewport │ ├── CMakeLists.txt │ ├── include │ │ └── app.h │ └── src │ │ └── app.cpp ├── OcclusionQuery │ ├── CMakeLists.txt │ ├── include │ │ └── app.h │ └── src │ │ └── app.cpp ├── OutOfOrderRasterization │ ├── CMakeLists.txt │ ├── include │ │ ├── app.h │ │ └── teapot_data.h │ └── src │ │ ├── app.cpp │ │ └── teapot_data.cpp └── PushConstants │ ├── CMakeLists.txt │ ├── include │ └── app.h │ └── src │ └── app.cpp ├── include ├── config.h.in ├── misc │ ├── base_pipeline_create_info.h │ ├── base_pipeline_manager.h │ ├── buffer_create_info.h │ ├── buffer_view_create_info.h │ ├── callbacks.h │ ├── compute_pipeline_create_info.h │ ├── debug.h │ ├── debug_marker.h │ ├── debug_messenger_create_info.h │ ├── descriptor_pool_create_info.h │ ├── descriptor_set_create_info.h │ ├── device_create_info.h │ ├── dummy_window.h │ ├── event_create_info.h │ ├── extensions.h │ ├── external_handle.h │ ├── fence_create_info.h │ ├── formats.h │ ├── fp16.h │ ├── framebuffer_create_info.h │ ├── glsl_to_spirv.h │ ├── graphics_pipeline_create_info.h │ ├── image_create_info.h │ ├── image_view_create_info.h │ ├── instance_create_info.h │ ├── io.h │ ├── library.h │ ├── memalloc_backends │ │ ├── backend_oneshot.h │ │ └── backend_vma.h │ ├── memory_allocator.h │ ├── memory_block_create_info.h │ ├── mt_safety.h │ ├── object_tracker.h │ ├── page_tracker.h │ ├── pools.h │ ├── ref_counter.h │ ├── render_pass_create_info.h │ ├── rendering_surface_create_info.h │ ├── sampler_create_info.h │ ├── sampler_ycbcr_conversion_create_info.h │ ├── semaphore_create_info.h │ ├── shader_module_cache.h │ ├── struct_chainer.h │ ├── swapchain_create_info.h │ ├── time.h │ ├── types.h │ ├── types_classes.h │ ├── types_enums.h │ ├── types_macro.h │ ├── types_struct.h │ ├── types_utils.h │ ├── vulkan.h │ ├── window.h │ ├── window_factory.h │ ├── window_win3264.h │ ├── window_xcb.h │ └── xcb_loader.h ├── vulkan │ ├── vk_platform.h │ ├── vulkan.h │ ├── vulkan_android.h │ ├── vulkan_core.h │ ├── vulkan_fuchsia.h │ ├── vulkan_ios.h │ ├── vulkan_macos.h │ ├── vulkan_mir.h │ ├── vulkan_vi.h │ ├── vulkan_wayland.h │ ├── vulkan_win32.h │ ├── vulkan_xcb.h │ ├── vulkan_xlib.h │ └── vulkan_xlib_xrandr.h └── wrappers │ ├── buffer.h │ ├── buffer_view.h │ ├── command_buffer.h │ ├── command_pool.h │ ├── compute_pipeline_manager.h │ ├── debug_messenger.h │ ├── descriptor_pool.h │ ├── descriptor_set.h │ ├── descriptor_set_group.h │ ├── descriptor_set_layout.h │ ├── descriptor_set_layout_manager.h │ ├── descriptor_update_template.h │ ├── device.h │ ├── event.h │ ├── fence.h │ ├── framebuffer.h │ ├── graphics_pipeline_manager.h │ ├── image.h │ ├── image_view.h │ ├── instance.h │ ├── memory_block.h │ ├── physical_device.h │ ├── pipeline_cache.h │ ├── pipeline_layout.h │ ├── pipeline_layout_manager.h │ ├── query_pool.h │ ├── queue.h │ ├── render_pass.h │ ├── rendering_surface.h │ ├── sampler.h │ ├── sampler_ycbcr_conversion.h │ ├── semaphore.h │ ├── shader_module.h │ └── swapchain.h └── src ├── misc ├── base_pipeline_create_info.cpp ├── base_pipeline_manager.cpp ├── buffer_create_info.cpp ├── buffer_view_create_info.cpp ├── compute_pipeline_create_info.cpp ├── debug.cpp ├── debug_marker.cpp ├── debug_messenger_create_info.cpp ├── descriptor_pool_create_info.cpp ├── descriptor_set_create_info.cpp ├── device_create_info.cpp ├── dummy_window.cpp ├── event_create_info.cpp ├── external_handle.cpp ├── fence_create_info.cpp ├── formats.cpp ├── fp16.cpp ├── framebuffer_create_info.cpp ├── glsl_to_spirv.cpp ├── graphics_pipeline_create_info.cpp ├── image_create_info.cpp ├── image_view_create_info.cpp ├── instance_create_info.cpp ├── io.cpp ├── library.cpp ├── memalloc_backends │ ├── backend_oneshot.cpp │ └── backend_vma.cpp ├── memory_allocator.cpp ├── memory_block_create_info.cpp ├── object_tracker.cpp ├── page_tracker.cpp ├── pools.cpp ├── render_pass_create_info.cpp ├── rendering_surface_create_info.cpp ├── sampler_create_info.cpp ├── sampler_ycbcr_conversion_create_info.cpp ├── semaphore_create_info.cpp ├── shader_module_cache.cpp ├── swapchain_create_info.cpp ├── time.cpp ├── types.cpp ├── types_classes.cpp ├── types_struct.cpp ├── types_utils.cpp ├── vulkan.cpp ├── window.cpp ├── window_factory.cpp ├── window_win3264.cpp ├── window_xcb.cpp └── xcb_loader.cpp └── wrappers ├── buffer.cpp ├── buffer_view.cpp ├── command_buffer.cpp ├── command_pool.cpp ├── compute_pipeline_manager.cpp ├── debug_messenger.cpp ├── descriptor_pool.cpp ├── descriptor_set.cpp ├── descriptor_set_group.cpp ├── descriptor_set_layout.cpp ├── descriptor_set_layout_manager.cpp ├── descriptor_update_template.cpp ├── device.cpp ├── event.cpp ├── fence.cpp ├── framebuffer.cpp ├── graphics_pipeline_manager.cpp ├── image.cpp ├── image_view.cpp ├── instance.cpp ├── memory_block.cpp ├── physical_device.cpp ├── pipeline_cache.cpp ├── pipeline_layout.cpp ├── pipeline_layout_manager.cpp ├── query_pool.cpp ├── queue.cpp ├── render_pass.cpp ├── rendering_surface.cpp ├── sampler.cpp ├── sampler_ycbcr_conversion.cpp ├── semaphore.cpp ├── shader_module.cpp └── swapchain.cpp /.gitignore: -------------------------------------------------------------------------------- 1 | build/ 2 | include/config.h 3 | -------------------------------------------------------------------------------- /deps/glslang/.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | *.a 3 | *.so 4 | *.exe 5 | tags 6 | TAGS 7 | build/ 8 | Test/localResults/ 9 | External/googletest 10 | External/spirv-tools 11 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/OGLCompilersDLL/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | set(SOURCES InitializeDll.cpp InitializeDll.h) 2 | 3 | add_library(OGLCompiler STATIC ${SOURCES}) 4 | set_property(TARGET OGLCompiler PROPERTY FOLDER glslang) 5 | set_property(TARGET OGLCompiler PROPERTY POSITION_INDEPENDENT_CODE ON) 6 | 7 | if(WIN32) 8 | source_group("Source" FILES ${SOURCES}) 9 | endif(WIN32) 10 | 11 | if(ENABLE_GLSLANG_INSTALL) 12 | install(TARGETS OGLCompiler 13 | ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}) 14 | endif(ENABLE_GLSLANG_INSTALL) 15 | -------------------------------------------------------------------------------- /deps/glslang/Test/300layout.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | precision mediump float; 3 | in vec4 pos; 4 | layout (location = 2) in vec4 color; // ERROR 5 | 6 | layout(location = 1) out vec4 c; 7 | layout(location = 3) out vec4 p; 8 | layout(location = 4) out vec4 q[2]; 9 | 10 | void main() 11 | { 12 | c = color; 13 | p = pos; 14 | q[1] = pos; 15 | } 16 | 17 | layout(location = 40) out float ca[4]; // ERROR, overlap, ERROR too big 18 | layout(location = 41) out float cb[2]; // ERROR, overlap, ERROR too big 19 | layout(location = 39) out float cc[6]; // ERROR, overlap, ERROR too big 20 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/300link3.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | precision highp float; 4 | 5 | out vec4 color1; 6 | 7 | void main() {} 8 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/320.comp: -------------------------------------------------------------------------------- 1 | #version 320 es 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } 10 | -------------------------------------------------------------------------------- /deps/glslang/Test/420.frag: -------------------------------------------------------------------------------- 1 | #version 420 core 2 | 3 | layout(depth_any) out float gl_FragDepth; 4 | layout(depth_greater) out float gl_FragDepth; // ERROR: redeclaration with different qualifier 5 | 6 | void main() 7 | { 8 | gl_FragDepth = 0.3; 9 | } 10 | 11 | layout(depth_less) in float depth; // ERROR: depth_less only applies to gl_FragDepth 12 | layout(depth_any) out float gl_FragDepth; // ERROR, done after use 13 | 14 | layout(binding=0) uniform atomic_uint a[]; 15 | -------------------------------------------------------------------------------- /deps/glslang/Test/420_size_gl_in.geom: -------------------------------------------------------------------------------- 1 | #version 420 core 2 | 3 | // testing input arrays without a gl_in[] block redeclaration, see 400.geom for with 4 | 5 | int i; 6 | 7 | layout(triangles) in; 8 | in vec4 colorun[]; 9 | in vec4 color3[3]; 10 | 11 | void foo() 12 | { 13 | gl_in.length(); 14 | gl_in[1].gl_Position; 15 | gl_in.length(); 16 | gl_in[i].gl_Position; // should be sized to 3 by 'triangles' 17 | } 18 | 19 | in gl_PerVertex { // ERROR, already used 20 | vec4 gl_Position; 21 | } gl_in[]; 22 | -------------------------------------------------------------------------------- /deps/glslang/Test/435.vert: -------------------------------------------------------------------------------- 1 | #version 435 2 | void main() {} -------------------------------------------------------------------------------- /deps/glslang/Test/450.comp: -------------------------------------------------------------------------------- 1 | #version 450 core 2 | layout(local_size_x = 0) in; // ERROR, 0 not allowed 3 | void main() 4 | { 5 | shared float f; // ERROR shared must be global 6 | } 7 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | b1 = anyInvocation(b1); 11 | b1 = allInvocations(b1); 12 | b1 = allInvocationsEqual(b1); 13 | } 14 | ; 15 | ; 16 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/badChars.frag: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/badChars.frag -------------------------------------------------------------------------------- /deps/glslang/Test/badMacroArgs.frag: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | #define m(a) a 4 | m() -------------------------------------------------------------------------------- /deps/glslang/Test/bar.h: -------------------------------------------------------------------------------- 1 | float4 i1; 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/300link3.frag.out: -------------------------------------------------------------------------------- 1 | 300link3.frag 2 | Shader version: 300 3 | 0:? Sequence 4 | 0:7 Function Definition: main( ( global void) 5 | 0:7 Function Parameters: 6 | 0:? Linker Objects 7 | 0:? 'color1' ( out highp 4-component vector of float) 8 | 9 | 10 | Linked fragment stage: 11 | 12 | 13 | Shader version: 300 14 | 0:? Sequence 15 | 0:7 Function Definition: main( ( global void) 16 | 0:7 Function Parameters: 17 | 0:? Linker Objects 18 | 0:? 'color1' ( out highp 4-component vector of float) 19 | 20 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/320.comp.out: -------------------------------------------------------------------------------- 1 | 320.comp 2 | Shader version: 320 3 | local_size = (1, 1, 1) 4 | 0:? Sequence 5 | 0:3 Function Definition: main( ( global void) 6 | 0:3 Function Parameters: 7 | 0:? Linker Objects 8 | 9 | 10 | Linked compute stage: 11 | 12 | 13 | Shader version: 320 14 | local_size = (1, 1, 1) 15 | 0:? Sequence 16 | 0:3 Function Definition: main( ( global void) 17 | 0:3 Function Parameters: 18 | 0:? Linker Objects 19 | 20 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/badChars.frag.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/badChars.frag.out -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/compoundsuffix.vert.glsl: -------------------------------------------------------------------------------- 1 | compoundsuffix.vert.glsl 2 | Shader version: 100 3 | 0:? Sequence 4 | 0:1 Function Definition: main( ( global void) 5 | 0:1 Function Parameters: 6 | 0:3 Sequence 7 | 0:3 move second child to first child ( temp highp 4-component vector of float) 8 | 0:3 'gl_Position' ( gl_Position highp 4-component vector of float Position) 9 | 0:3 Constant: 10 | 0:3 1.000000 11 | 0:3 1.000000 12 | 0:3 1.000000 13 | 0:3 1.000000 14 | 0:? Linker Objects 15 | 16 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/cppBad2.vert.out: -------------------------------------------------------------------------------- 1 | cppBad2.vert 2 | ERROR: 0:3: 'macro expansion' : End of input in macro b 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | Shader version: 100 7 | ERROR: node is still EOpNull! 8 | 0:? Linker Objects 9 | 10 | 11 | Linked vertex stage: 12 | 13 | ERROR: Linking vertex stage: Missing entry point: Each stage requires one entry point 14 | 15 | Shader version: 100 16 | ERROR: node is still EOpNull! 17 | 0:? Linker Objects 18 | 19 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/glspv.esversion.vert.out: -------------------------------------------------------------------------------- 1 | glspv.esversion.vert 2 | ERROR: #version: ES shaders for OpenGL SPIR-V are not supported 3 | ERROR: 1 compilation errors. No code generated. 4 | 5 | 6 | SPIR-V is not generated for failed compile or link 7 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/hlsl.pp.expand.frag.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/hlsl.pp.expand.frag.err -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/nosuffix.out: -------------------------------------------------------------------------------- 1 | nosuffix 2 | Shader version: 100 3 | 0:? Sequence 4 | 0:1 Function Definition: main( ( global void) 5 | 0:1 Function Parameters: 6 | 0:3 Sequence 7 | 0:3 move second child to first child ( temp highp 4-component vector of float) 8 | 0:3 'gl_Position' ( gl_Position highp 4-component vector of float Position) 9 | 0:3 Constant: 10 | 0:3 1.000000 11 | 0:3 1.000000 12 | 0:3 1.000000 13 | 0:3 1.000000 14 | 0:? Linker Objects 15 | 16 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/overlongLiteral.frag.out: -------------------------------------------------------------------------------- 1 | overlongLiteral.frag 2 | ERROR: 0:1: '' : hexadecimal literal too long 3 | ERROR: 0:1: '' : syntax error, unexpected INTCONSTANT 4 | ERROR: 2 compilation errors. No code generated. 5 | 6 | 7 | Shader version: 100 8 | ERROR: node is still EOpNull! 9 | 0:? Linker Objects 10 | 11 | 12 | Linked fragment stage: 13 | 14 | ERROR: Linking fragment stage: Missing entry point: Each stage requires one entry point 15 | 16 | Shader version: 100 17 | ERROR: node is still EOpNull! 18 | 0:? Linker Objects 19 | 20 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.bad_arg.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.bad_arg.vert.out -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.cpp_style___FILE__.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.cpp_style___FILE__.vert.err -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.cpp_style___FILE__.vert.out: -------------------------------------------------------------------------------- 1 | #extension GL_GOOGLE_cpp_style_line_directive : enable 2 | 3 | 0 4 | 5 | #line 150 "a.h" 6 | "a.h" 7 | 8 | #line 24 9 | "a.h" 10 | 11 | #line 42 12 | "a.h" 13 | 14 | #line 30 "b.cc" 15 | "b.cc" 16 | 17 | #line 10 3 18 | 3 19 | 20 | #line 48 21 | 3 22 | 23 | #line 4 24 | 3 25 | 26 | #line 55 100 27 | 100 28 | 29 | #line 1000 "c" 30 | "c" 31 | 32 | #line 42 1 33 | 1 34 | 35 | #line 42 "this-is-a-quite-long-name-maybe-i-should-shorten-it" 36 | "this-is-a-quite-long-name-maybe-i-should-shorten-it" 37 | 38 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.cpp_style_line_directive.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.cpp_style_line_directive.vert.out -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.defined.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.defined.vert.out -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.edge_cases.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.edge_cases.vert.err -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.eof_missing.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.eof_missing.vert.err -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.eof_missing.vert.out: -------------------------------------------------------------------------------- 1 | noEOF 2 | 3 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.errors.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.errors.vert.out -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.extensions.vert.err: -------------------------------------------------------------------------------- 1 | WARNING: 0:6: '#extension' : extension not supported: GL_EXT_shader_texture_image_samples 2 | 3 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.function_macro.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.function_macro.vert.err -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.include.disabled.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.include.disabled.vert.out -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.include.enabled.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.include.enabled.vert.out -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.line.frag.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.line.frag.err -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.line.frag.out: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | #line 1 2 3 | #pragma something 4 | void main(){ } 5 | 6 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.line.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.line.vert.err -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.many.endif.vert.err: -------------------------------------------------------------------------------- 1 | ERROR: 0:1: '#endif' : mismatched statements 2 | ERROR: 0:2: '#endif' : mismatched statements 3 | ERROR: 0:3: '#endif' : mismatched statements 4 | ERROR: 0:4: '#endif' : mismatched statements 5 | ERROR: 0:5: '#endif' : mismatched statements 6 | ERROR: 0:6: '#endif' : mismatched statements 7 | ERROR: 0:7: '#endif' : mismatched statements 8 | ERROR: 0:10: 'preprocessor evaluation' : bad expression 9 | ERROR: 0:11: '' : missing #endif 10 | ERROR: 9 compilation errors. No code generated. 11 | 12 | 13 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.many.endif.vert.out: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.many.endif.vert.out -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.pragma.vert.err: -------------------------------------------------------------------------------- 1 | WARNING: 0:10: '#pragma once' : not implemented 2 | 3 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.simple.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.simple.vert.err -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.success_if_parse_would_fail.vert.err: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/baseResults/preprocessor.success_if_parse_would_fail.vert.err -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/preprocessor.success_if_parse_would_fail.vert.out: -------------------------------------------------------------------------------- 1 | int x(){ 2 | something that shouldnt compile; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/remap.basic.dcevartype.frag.out: -------------------------------------------------------------------------------- 1 | remap.basic.dcevartype.frag 2 | ERROR: #version: ES shaders for Vulkan SPIR-V require version 310 or higher 3 | Warning, version 310 is not yet complete; most version-specific features are present, but some are missing. 4 | ERROR: 1 compilation errors. No code generated. 5 | 6 | 7 | 8 | Linked fragment stage: 9 | 10 | ERROR: Linking fragment stage: Missing entry point: Each stage requires one "void main()" entry point 11 | 12 | SPIR-V is not generated for failed compile or link 13 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/remap.invalid-spirv-1.out: -------------------------------------------------------------------------------- 1 | ID out of range: 4160749568 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/remap.invalid-spirv-2.out: -------------------------------------------------------------------------------- 1 | ID not found 2 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/spv.ClosestHitShader_Errors.rchit.out: -------------------------------------------------------------------------------- 1 | spv.ClosestHitShader_Errors.rchit 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: 'terminateRayNV' : no matching overloaded function found 5 | ERROR: 0:11: 'ignoreIntersectionNV' : no matching overloaded function found 6 | ERROR: 4 compilation errors. No code generated. 7 | 8 | 9 | SPIR-V is not generated for failed compile or link 10 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/spv.IntersectShader_Errors.rint.out: -------------------------------------------------------------------------------- 1 | spv.IntersectShader_Errors.rint 2 | ERROR: 0:3: 'rayPayloadInNV' : not supported in this stage: intersection 3 | ERROR: 0:4: 'rayPayloadNV' : not supported in this stage: intersection 4 | ERROR: 0:8: 'gl_HitTNV' : undeclared identifier 5 | ERROR: 0:9: 'gl_HitKindNV' : undeclared identifier 6 | ERROR: 0:10: 'traceNV' : no matching overloaded function found 7 | ERROR: 5 compilation errors. No code generated. 8 | 9 | 10 | SPIR-V is not generated for failed compile or link 11 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/spv.fragmentDensity.vert.out: -------------------------------------------------------------------------------- 1 | spv.fragmentDensity.vert 2 | ERROR: 0:10: 'gl_FragSizeEXT' : undeclared identifier 3 | ERROR: 0:10: 'assign' : cannot convert from ' temp float' to 'layout( location=0) smooth out highp 2-component vector of uint' 4 | ERROR: 0:11: 'gl_FragInvocationCountEXT' : undeclared identifier 5 | ERROR: 0:11: 'assign' : cannot convert from ' temp float' to 'layout( location=2) smooth out highp int' 6 | ERROR: 4 compilation errors. No code generated. 7 | 8 | 9 | SPIR-V is not generated for failed compile or link 10 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/baseResults/spv.register.autoassign.rangetest.frag.out: -------------------------------------------------------------------------------- 1 | spv.register.autoassign.rangetest.frag 2 | INTERNAL ERROR: mapped binding out of range: g_tSamp 3 | INTERNAL ERROR: mapped binding out of range: g_tScene 4 | 5 | SPIR-V is not generated for failed compile or link 6 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/bump: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | cp localResults/* baseResults/ 3 | 4 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/compoundsuffix.frag.hlsl: -------------------------------------------------------------------------------- 1 | void main(out float4 fragColor : SV_TARGET0) 2 | { 3 | fragColor = 1; 4 | } 5 | 6 | 7 | -------------------------------------------------------------------------------- /deps/glslang/Test/compoundsuffix.vert.glsl: -------------------------------------------------------------------------------- 1 | void main() 2 | { 3 | gl_Position = vec4(1.0); 4 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/Test/cppBad.vert: -------------------------------------------------------------------------------- 1 | #define m#0# 2 | #if m 3 | #endif 4 | #define n() 5 | int n" -------------------------------------------------------------------------------- /deps/glslang/Test/cppBad2.vert: -------------------------------------------------------------------------------- 1 | #define a b( 2 | #define b(x) 3 | b(a) -------------------------------------------------------------------------------- /deps/glslang/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 -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/dataOut.frag: -------------------------------------------------------------------------------- 1 | #version 130 2 | 3 | varying vec4 Color; 4 | 5 | void main() 6 | { 7 | gl_FragData[1] = Color; 8 | } 9 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/empty.frag: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/empty.frag -------------------------------------------------------------------------------- /deps/glslang/Test/empty2.frag: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/empty3.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/errors.frag: -------------------------------------------------------------------------------- 1 | int main(int foo) 2 | { 3 | return 1; 4 | } 5 | -------------------------------------------------------------------------------- /deps/glslang/Test/es-link1.frag: -------------------------------------------------------------------------------- 1 | #version 100 2 | 3 | mediump vec4 calculateColor(); 4 | 5 | void main() 6 | { 7 | gl_FragColor = calculateColor(); 8 | } 9 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/foo.h: -------------------------------------------------------------------------------- 1 | #error should not be included -------------------------------------------------------------------------------- /deps/glslang/Test/glsl.-D-U.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #define IN_SHADER 4 | 5 | layout(location=0) out vec4 color; 6 | 7 | void main() 8 | { 9 | #if FOO==200 10 | color = vec4(1.0); 11 | #else 12 | #error expected FOO 200 13 | #endif 14 | 15 | #ifdef IN_SHADER 16 | color++; 17 | #else 18 | #error IN_SHADER was undef 19 | #endif 20 | 21 | #ifdef UNDEFED 22 | #error UNDEFED defined 23 | #else 24 | color *= 3.0; 25 | #endif 26 | 27 | #if MUL == 400 28 | color *= MUL; 29 | #else 30 | #error bad MUL 31 | #endif 32 | } 33 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/glsl.entryPointRename2.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void bar() 4 | { 5 | gl_Position = vec4(1); 6 | } 7 | -------------------------------------------------------------------------------- /deps/glslang/Test/glslangValidator: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | ../build/install/bin/glslangValidator $* 3 | -------------------------------------------------------------------------------- /deps/glslang/Test/glspv.esversion.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /deps/glslang/Test/glspv.version.frag: -------------------------------------------------------------------------------- 1 | #version 330 compatibility 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /deps/glslang/Test/glspv.version.vert: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.PointSize.vert: -------------------------------------------------------------------------------- 1 | [[vk::builtin("PointSize")]] float main() 2 | { 3 | return 2.3; 4 | } -------------------------------------------------------------------------------- /deps/glslang/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; -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 buffer1; 7 | 8 | [[vk::binding(3, 2)]] 9 | StructuredBuffer buffer3; 10 | 11 | [[vk::input_attachment_index(4)]] 12 | Texture2D attach; 13 | 14 | [[vk::constant_id(13)]] const int ci = 11; 15 | 16 | [[vk::push_constant]] cbuffer pcBuf { int a; }; 17 | 18 | [[vk::location(7)]] float4 19 | main([[vk::location(8)]] float4 input: A) : B 20 | { 21 | return input + attach.Load(float2(0.5));// * a; 22 | } 23 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.attributeGlobalBuffer.frag: -------------------------------------------------------------------------------- 1 | [[vk::global_cbuffer_binding(5, 2)]] 2 | float4 u1; 3 | float4 u2; 4 | 5 | float4 main() : SV_Target0 6 | { 7 | return u1 + u2; 8 | } -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.basic.comp: -------------------------------------------------------------------------------- 1 | groupshared float4 a[100]; 2 | 3 | void main(int dti : SV_DispatchThreadID, int gti : SV_GroupThreadID) 4 | { 5 | dti - gti; 6 | } 7 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.boolConv.vert: -------------------------------------------------------------------------------- 1 | static bool a, b = true; 2 | float4 main() : SV_Position 3 | { 4 | int r = 0; 5 | 6 | r += a + b; 7 | r += a - b; 8 | r += a * b; 9 | r += a / b; 10 | r += a % b; 11 | 12 | r += a & b; 13 | r += a | b; 14 | r += a ^ b; 15 | 16 | r += a << b; 17 | r += a >> b; 18 | 19 | return r; 20 | } 21 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.cast.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | return (float4)input + (int4)input + (float4)1.198; 4 | } 5 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.clipdistance-1.geom: -------------------------------------------------------------------------------- 1 | struct S { 2 | float4 pos : SV_Position; 3 | float2 clip : SV_ClipDistance0; 4 | }; 5 | 6 | [maxvertexcount(3)] 7 | void main(triangle in float4 pos[3] : SV_Position, 8 | triangle in uint VertexID[3] : VertexID, 9 | inout LineStream OutputStream, 10 | triangle in float4 clip[3] : SV_ClipDistance) // externally: an array 3 of array 4 (not vec4!) of float. 11 | { 12 | S s; 13 | 14 | s.pos = pos[0]; 15 | s.clip = clip[0].xy; 16 | 17 | OutputStream.Append(s); 18 | } 19 | 20 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.clipdistance-2.geom: -------------------------------------------------------------------------------- 1 | struct S { 2 | float4 pos : SV_Position; 3 | float2 clip[2] : SV_ClipDistance0; 4 | }; 5 | 6 | [maxvertexcount(3)] 7 | void main(triangle in float4 pos[3] : SV_Position, 8 | triangle in uint VertexID[3] : VertexID, 9 | inout LineStream OutputStream, 10 | triangle in float2 clip[3][2] : SV_ClipDistance) // externally: an array 3 of array 4 of float. 11 | { 12 | S s; 13 | 14 | s.pos = pos[0]; 15 | s.clip[0] = clip[0][0]; 16 | s.clip[1] = clip[0][1]; 17 | 18 | OutputStream.Append(s); 19 | } 20 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.clipdistance-4.vert: -------------------------------------------------------------------------------- 1 | struct VS_INPUT { 2 | float4 Position : POSITION; 3 | }; 4 | 5 | struct VS_OUTPUT { 6 | float4 Position : SV_Position; 7 | float4 ClipRect : SV_ClipDistance0; // vector in split struct 8 | }; 9 | 10 | VS_OUTPUT main(const VS_INPUT v) 11 | { 12 | VS_OUTPUT Output; 13 | Output.Position = 0; 14 | 15 | Output.ClipRect.x = 1; 16 | Output.ClipRect.y = 2; 17 | Output.ClipRect.z = 3; 18 | Output.ClipRect.w = 4; 19 | 20 | return Output; 21 | } 22 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.clipdistance-9.vert: -------------------------------------------------------------------------------- 1 | struct VS_OUTPUT { 2 | float4 Position : SV_Position; 3 | }; 4 | 5 | // Test packing 0 and 1 semantics into single array[4] output, from out fn params. 6 | VS_OUTPUT main(out float3 clip0 : SV_ClipDistance0, out float clip1 : SV_ClipDistance1) 7 | { 8 | VS_OUTPUT Output; 9 | Output.Position = 0; 10 | 11 | clip0.x = 0; 12 | clip0.y = 1; 13 | clip0.z = 2; 14 | 15 | // Position 3 is packed from clip1's float 16 | clip1 = 3; 17 | 18 | return Output; 19 | } 20 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.depthGreater.frag: -------------------------------------------------------------------------------- 1 | void PixelShaderFunction(out float depth : SV_DepthGreaterEqual) 2 | { 3 | depth = 0.2; 4 | } 5 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.depthLess.frag: -------------------------------------------------------------------------------- 1 | float PixelShaderFunction() : SV_DepthLessEqual 2 | { 3 | return 0.2; 4 | } 5 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.doLoop.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float input) : COLOR0 2 | { 3 | [unroll] do {} while (false); 4 | [unroll] do {;} while (false); 5 | do { return (float4)input; } while (input > 2.0); 6 | do ++input; while (input < 10.0); 7 | do while (++input < 10.0); while (++input < 10.0); // nest while inside do-while 8 | return (float4)input; 9 | } 10 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.getsampleposition.dx10.frag: -------------------------------------------------------------------------------- 1 | SamplerState g_sSamp : register(s0); 2 | 3 | Texture2DMS g_tTex2dmsf4; 4 | Texture2DMSArray g_tTex2dmsf4a; 5 | 6 | struct PS_OUTPUT 7 | { 8 | float4 Color : SV_Target0; 9 | float Depth : SV_Depth; 10 | }; 11 | 12 | PS_OUTPUT main(int sample : SAMPLE) 13 | { 14 | PS_OUTPUT psout; 15 | 16 | float2 r00 = g_tTex2dmsf4.GetSamplePosition(sample); 17 | float2 r01 = g_tTex2dmsf4a.GetSamplePosition(sample); 18 | 19 | psout.Color = 1.0; 20 | psout.Depth = 1.0; 21 | 22 | return psout; 23 | } 24 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.identifier.sample.frag: -------------------------------------------------------------------------------- 1 | 2 | struct MyStruct { 3 | sample float a; 4 | noperspective float b; 5 | linear float c; 6 | centroid float d; 7 | }; 8 | 9 | int sample(int x) { return x; } // HLSL allows this as an identifier as well. 10 | 11 | float4 main() : SV_Target0 12 | { 13 | // HLSL allows this as an identifier as well. 14 | // However, this is not true of other qualifier keywords such as "linear". 15 | float4 sample = float4(3,4,5,6); 16 | 17 | return sample.rgba; // 'sample' can participate in an expression. 18 | } 19 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.intrinsics.d3dcolortoubyte4.frag: -------------------------------------------------------------------------------- 1 | 2 | uniform float4 col4; 3 | 4 | int4 main() : SV_Target0 5 | { 6 | return D3DCOLORtoUBYTE4(col4); 7 | } 8 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.intrinsics.f1632.frag: -------------------------------------------------------------------------------- 1 | float PixelShaderFunctionS(uint inF0) 2 | { 3 | return f16tof32(inF0); 4 | } 5 | 6 | float1 PixelShaderFunction1(uint1 inF0) 7 | { 8 | return f16tof32(inF0); 9 | } 10 | 11 | float2 PixelShaderFunction2(uint2 inF0) 12 | { 13 | return f16tof32(inF0); 14 | } 15 | 16 | float3 PixelShaderFunction3(uint3 inF0) 17 | { 18 | return f16tof32(inF0); 19 | } 20 | 21 | float4 PixelShaderFunction(uint4 inF0) 22 | { 23 | return f16tof32(inF0); 24 | } 25 | 26 | float4 main() : SV_Target0 27 | { 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.intrinsics.f3216.frag: -------------------------------------------------------------------------------- 1 | uint PixelShaderFunctionS(float inF0) 2 | { 3 | return f32tof16(inF0); 4 | } 5 | 6 | uint1 PixelShaderFunction1(float1 inF0) 7 | { 8 | return f32tof16(inF0); 9 | } 10 | 11 | uint2 PixelShaderFunction2(float2 inF0) 12 | { 13 | return f32tof16(inF0); 14 | } 15 | 16 | uint3 PixelShaderFunction3(float3 inF0) 17 | { 18 | return f32tof16(inF0); 19 | } 20 | 21 | uint4 PixelShaderFunction(float4 inF0) 22 | { 23 | return f32tof16(inF0); 24 | } 25 | 26 | float4 main() : SV_Target0 27 | { 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.layout.frag: -------------------------------------------------------------------------------- 1 | layout(set=3,binding=5) tbuffer tbufName { 2 | layout(offset = 16) float4 v1; 3 | }; 4 | 5 | layout(push_constant) tbuffer tbufName2 { 6 | float4 v5; 7 | }; 8 | 9 | layout(constant_id=17) const int specConst = 10; 10 | 11 | tbuffer tbufName2 : layout(set=4,binding=7) { 12 | layout(offset = 16) float4 v1PostLayout; 13 | }; 14 | 15 | float4 PixelShaderFunction(float4 input) : COLOR0 16 | { 17 | float4 layout = 2.0; 18 | return input + v1 + v5 + v1PostLayout * layout; 19 | } 20 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.localStructuredBuffer.comp: -------------------------------------------------------------------------------- 1 | RWStructuredBuffer srt0; 2 | void main() { 3 | RWStructuredBuffer srt0Local = srt0; 4 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.logical.unary.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 | !ival; // scalar int 14 | !ival4; // vector int 15 | 16 | !fval; // scalar float 17 | !fval4; // vector float 18 | 19 | if (ival); 20 | if (fval); 21 | if (!ival); 22 | if (!fval); 23 | 24 | PS_OUTPUT psout; 25 | psout.Color = 1.0; 26 | return psout; 27 | } 28 | 29 | 30 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.logicalConvert.frag: -------------------------------------------------------------------------------- 1 | float4 main() : SV_TARGET 2 | { 3 | if (!(0) && (0) || (!1)) 4 | return 0.0.xxxx; 5 | if (0) 6 | return 0.0.xxxx; 7 | if (!(bool)0) 8 | return 0.0.xxxx; 9 | if (!0) 10 | return 0.0.xxxx; 11 | if (!(bool)1) 12 | return 0.0.xxxx; 13 | if (!1) 14 | return 0.0.xxxx; 15 | if (0 || 1) 16 | return 0.0.xxxx; 17 | if (1 && 0) 18 | return 0.0.xxxx; 19 | if (1 || false) 20 | return 0.0.xxxx; 21 | if (true && 1) 22 | return 0.0.xxxx; 23 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.matpack-1.frag: -------------------------------------------------------------------------------- 1 | struct MyBuffer1 2 | { 3 | column_major float4x4 mat1; 4 | row_major float4x4 mat2; 5 | float4 vec1; 6 | float foo; 7 | }; 8 | 9 | struct MyBuffer2 10 | { 11 | row_major float4x4 mat1; 12 | float4 vec1; 13 | }; 14 | 15 | cbuffer Example 16 | { 17 | MyBuffer1 g_MyBuffer1; 18 | MyBuffer2 g_MyBuffer2; 19 | column_major float4x4 mat1a; 20 | }; 21 | 22 | float4 main() : SV_Target0 23 | { 24 | return mul(g_MyBuffer1.mat1, g_MyBuffer1.vec1) + 25 | mul(g_MyBuffer2.mat1, g_MyBuffer2.vec1); 26 | } 27 | 28 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.max.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input1, float4 input2) : COLOR0 2 | { 3 | return max(input1, input2); 4 | } 5 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.mip.operator.frag: -------------------------------------------------------------------------------- 1 | Texture2DArray g_tTex2df4a; 2 | Texture2D g_tTex2df4; 3 | 4 | float4 main() : SV_Target0 5 | { 6 | return g_tTex2df4.mips[2][uint2(3, 4)] + 7 | 8 | // test float->uint cast on the mip arg 9 | g_tTex2df4a.mips[5.2][uint3(6, 7, 8)] + 10 | 11 | // Test nesting involving .mips operators: 12 | // ....outer operator mip level...... .....outer operator coordinate.... 13 | g_tTex2df4.mips[ g_tTex2df4.mips[9][uint2(10,11)][0] ][ g_tTex2df4.mips[13][uint2(14,15)].xy ]; 14 | } 15 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.namespace.frag: -------------------------------------------------------------------------------- 1 | static float4 v1; 2 | static float4 v2; 3 | 4 | namespace N1 { 5 | float4 getVec() { return v1; } 6 | } 7 | 8 | namespace N2 { 9 | static float gf; 10 | float4 getVec() { return v2; } 11 | namespace N3 { 12 | float4 getVec() { return v2; } 13 | 14 | class C1 { 15 | float4 getVec() { return v2; } 16 | }; 17 | } 18 | } 19 | 20 | float4 main() : SV_Target0 21 | { 22 | return N1::getVec() + N2::getVec() + N2::N3::getVec() + N2::N3::C1::getVec() * N2::gf; 23 | } 24 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.promote.atomic.frag: -------------------------------------------------------------------------------- 1 | 2 | RWBuffer s_uintbuff; // UINT RWBuffer ... 3 | 4 | float4 main() : SV_Target 5 | { 6 | int Loc; // ... with INT variables 7 | int Inc; 8 | int Orig; 9 | 10 | // This must select the uint flavor of SPIR-V atomic op, and promote 11 | // the other arguments as required. The output value from the 12 | // imageAtomicAdd AST will be converted to an int for 'Orig'. 13 | InterlockedAdd(s_uintbuff[Loc], Inc, Orig); 14 | 15 | return float4(0,0,0,0); 16 | } 17 | 18 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.promote.binary.frag: -------------------------------------------------------------------------------- 1 | struct PS_OUTPUT 2 | { 3 | float4 Color : SV_Target0; 4 | }; 5 | 6 | uniform bool bval; 7 | uniform bool4 bval4; 8 | uniform int ival; 9 | uniform int4 ival4; 10 | uniform float fval; 11 | uniform float4 fval4; 12 | 13 | PS_OUTPUT main() 14 | { 15 | ival % fval; 16 | ival4 % fval4; 17 | 18 | bval % fval; 19 | bval4 % fval4; 20 | 21 | int l_int = 1; 22 | l_int %= fval; 23 | 24 | PS_OUTPUT psout; 25 | psout.Color = 0; 26 | return psout; 27 | } 28 | 29 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.sample.dx9.vert: -------------------------------------------------------------------------------- 1 | 2 | sampler g_sam : register(t0); 3 | sampler2D g_sam2D : register(t1); 4 | 5 | struct VS_OUTPUT 6 | { 7 | float4 Pos : SV_Position; 8 | }; 9 | 10 | VS_OUTPUT main() 11 | { 12 | VS_OUTPUT vsout; 13 | 14 | float4 PosOut = float4(0,0,0,0); 15 | 16 | PosOut += tex2Dlod( g_sam , float4(0.3f, 0.4f, 0.0f, 1.0f)); 17 | PosOut += tex2Dlod( g_sam2D, float4(0.5f, 0.6f, 0.0f, 1.0f)); 18 | 19 | vsout.Pos = PosOut / 2.0f; 20 | 21 | return vsout; 22 | } 23 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.scope.frag: -------------------------------------------------------------------------------- 1 | void PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | int x; 4 | x; 5 | { 6 | float x; 7 | x; 8 | { 9 | bool x; 10 | x; 11 | { 12 | float3 x; 13 | x; 14 | } 15 | x; 16 | } 17 | x; 18 | } 19 | x; 20 | 21 | if (x > 0) 22 | bool x; 23 | 24 | while (x > 0) 25 | bool x; 26 | 27 | do { 28 | bool x; 29 | } while (x > 0); 30 | } 31 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.semantic-1.vert: -------------------------------------------------------------------------------- 1 | #define DLAYER 3 2 | 3 | #define DMACRO1 TEXCOORD1 4 | #define DMACRO(num) TEXCOORD##num 5 | 6 | struct S { 7 | float4 pos : POSITION; 8 | float2 UV0 : TEXCOORD0; 9 | float2 UV1 : DMACRO1; 10 | float2 UV2 : DMACRO(2); 11 | float2 UV3 : DMACRO(DLAYER); 12 | }; 13 | 14 | 15 | S main(float4 v : POSITION) 16 | { 17 | S s; 18 | s.pos = v; 19 | s.UV0 = float2(v.x,v.x); 20 | s.UV1 = float2(v.y,v.y); 21 | s.UV2 = float2(v.z,v.z); 22 | s.UV3 = float2(v.w,v.w); 23 | return s; 24 | } 25 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.semantic.geom: -------------------------------------------------------------------------------- 1 | struct S { 2 | float clip0 : SV_Position; 3 | float clip0 : SV_ClipDistance0; 4 | float cull0 : SV_CullDistance0; 5 | uint vpai : SV_ViewportArrayIndex; 6 | uint rtai : SV_RenderTargetArrayIndex; 7 | int ii : SV_InstanceID; 8 | }; 9 | 10 | [maxvertexcount(4)] 11 | void main(triangle in uint VertexID[3] : VertexID, 12 | inout LineStream OutputStream) 13 | { 14 | S s; 15 | OutputStream.Append(s); 16 | } 17 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.shapeConvRet.frag: -------------------------------------------------------------------------------- 1 | int3 foo() 2 | { 3 | return 13; 4 | } 5 | 6 | float4 main(float f) 7 | { 8 | return f; 9 | } 10 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.sin.frag: -------------------------------------------------------------------------------- 1 | float4 PixelShaderFunction(float4 input) : COLOR0 2 | { 3 | return sin(input); 4 | } 5 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.staticMemberFunction.frag: -------------------------------------------------------------------------------- 1 | struct Test 2 | { 3 | float4 memVar; 4 | static float4 staticMemFun(float4 a) : SV_Position 5 | { 6 | return 2 * a; 7 | } 8 | static int staticMemFun(int a) : SV_Position 9 | { 10 | return 2 + a; 11 | } 12 | int i; 13 | }; 14 | 15 | float4 main() : SV_Target0 16 | { 17 | Test test; 18 | float4 f4 = float4(1.0,1.0,1.0,1.0); 19 | f4 += Test::staticMemFun(float4(5.0f,5.0f,5.0f,5.0f)); 20 | f4 += Test::staticMemFun(7); 21 | return f4; 22 | } 23 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.struct.split-1.vert: -------------------------------------------------------------------------------- 1 | 2 | struct VS_INPUT 3 | { 4 | int x0_in : foo0; 5 | float4 Pos_in : SV_Position; 6 | int x1_in : foo1; 7 | }; 8 | 9 | struct VS_OUTPUT 10 | { 11 | int x0_out : foo0; 12 | float4 Pos_out : SV_Position; 13 | int x1_out : foo1; 14 | }; 15 | 16 | VS_OUTPUT main(VS_INPUT vsin, float4 Pos_loose : SV_Position) 17 | { 18 | VS_OUTPUT vsout; 19 | 20 | vsout.x0_out = vsin.x0_in; 21 | vsout.Pos_out = vsin.Pos_in + Pos_loose; 22 | vsout.x1_out = vsin.x1_in; 23 | 24 | return vsout; 25 | } 26 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.struct.split.array.geom: -------------------------------------------------------------------------------- 1 | struct PSInput 2 | { 3 | float4 Pos : SV_POSITION; 4 | float2 TexCoord : TEXCOORD; 5 | float3 TerrainPos : TERRAINPOS; 6 | uint VertexID : VertexID; 7 | }; 8 | 9 | typedef PSInput foo_t[2][3]; 10 | 11 | [maxvertexcount(4)] 12 | void main(point uint v[1] : VertexID, inout TriangleStream OutputStream) 13 | { 14 | foo_t Verts; 15 | 16 | PSInput Out = (PSInput) 0; 17 | 18 | for (int x=0; x<2; ++x) 19 | for (int y=0; y<2; ++y) 20 | Verts[x][y] = Out; 21 | } 22 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.struct.split.trivial.vert: -------------------------------------------------------------------------------- 1 | 2 | // Test trivial case for structure splitting: the IN and OUT structs have ONLY an interstage IO. 3 | // This should fall back to flattening, and not produce any empty structures. 4 | 5 | struct VS_INPUT 6 | { 7 | float4 Pos_in : SV_Position; 8 | }; 9 | 10 | struct VS_OUTPUT 11 | { 12 | float4 Pos : SV_Position; 13 | }; 14 | 15 | VS_OUTPUT main(VS_INPUT vsin, float4 Pos_loose : SV_Position) 16 | { 17 | VS_OUTPUT vsout; 18 | 19 | vsout.Pos = vsin.Pos_in + Pos_loose; 20 | 21 | return vsout; 22 | } 23 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.structIoFourWay.frag: -------------------------------------------------------------------------------- 1 | struct T { 2 | float f : packoffset(c4.y); // artificial, but validates all different treatments: uniform offset 3 | centroid float g; // interpolant input 4 | float d: SV_DepthGreaterEqual; // fragment output 5 | float4 normal; // non-IO 6 | }; 7 | 8 | T s; // loose uniform 9 | 10 | cbuffer buff { 11 | T t : packoffset(c5.z); 12 | }; 13 | 14 | T main(T t : myInput) : SV_Target0 15 | { 16 | T local; 17 | return local; 18 | } 19 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.structStructName.frag: -------------------------------------------------------------------------------- 1 | struct S { int s; }; 2 | 3 | int main() 4 | { 5 | struct S t; 6 | return t.s; 7 | } 8 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.structbuffer.coherent.frag: -------------------------------------------------------------------------------- 1 | struct sb_t 2 | { 3 | float3 color; 4 | bool test; 5 | }; 6 | 7 | 8 | globallycoherent RWStructuredBuffer sbuf; 9 | globallycoherent 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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.structbuffer.frag: -------------------------------------------------------------------------------- 1 | struct sb_t 2 | { 3 | float3 color; 4 | bool test; 5 | bool test2; 6 | }; // stride = 20 7 | 8 | StructuredBuffer sbuf : register(t10); 9 | StructuredBuffer sbuf2; 10 | 11 | float4 main(uint pos : FOO) : SV_Target0 12 | { 13 | sb_t mydata = sbuf.Load(pos); 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 mydata.color.x + size + stride; 23 | } 24 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.structbuffer.incdec.frag: -------------------------------------------------------------------------------- 1 | RWStructuredBuffer sbuf_rw_i; 2 | RWStructuredBuffer sbuf_rw_d; 3 | 4 | RWStructuredBuffer sbuf_rw_nocounter; // doesn't use inc or dec 5 | 6 | float4 main(uint pos : FOO) : SV_Target0 7 | { 8 | uint4 result = 0; 9 | 10 | sbuf_rw_i[7]; 11 | sbuf_rw_d[7]; 12 | 13 | sbuf_rw_nocounter[5] = 2; 14 | 15 | uint c1 = sbuf_rw_i.IncrementCounter(); 16 | uint c2 = sbuf_rw_d.DecrementCounter(); 17 | 18 | return float4(result.x, result.y, c1, c2); 19 | } 20 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.tristream-append.geom: -------------------------------------------------------------------------------- 1 | struct GSPS_INPUT 2 | { 3 | }; 4 | 5 | // Test Append() method appearing before declaration of entry point's stream output. 6 | 7 | void EmitVertex(in GSPS_INPUT output, inout TriangleStream TriStream) 8 | { 9 | TriStream.Append( output ); 10 | } 11 | 12 | [maxvertexcount(3)] 13 | void main( triangle GSPS_INPUT input[3], inout TriangleStream TriStream ) 14 | { 15 | EmitVertex(input[0], TriStream); 16 | EmitVertex(input[1], TriStream); 17 | EmitVertex(input[2], TriStream); 18 | } 19 | -------------------------------------------------------------------------------- /deps/glslang/Test/hlsl.tx.overload.frag: -------------------------------------------------------------------------------- 1 | 2 | Texture2D tf1; 3 | Texture2D tf4; 4 | 5 | RWTexture2D twf1; 6 | RWTexture2D twf4; 7 | 8 | float Func(Texture2D DummyTex) { return 1.0f; } 9 | float4 Func(Texture2D DummyTex) { return float4(0,0,0,0); } 10 | 11 | float Func(RWTexture2D DummyTex) { return 1.0f; } 12 | float4 Func(RWTexture2D DummyTex) { return float4(0,0,0,0); } 13 | 14 | float4 main() : SV_TARGET 15 | { 16 | return Func(tf1) + Func(tf4) + Func(twf1) + Func(twf4); 17 | } 18 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/i1.h: -------------------------------------------------------------------------------- 1 | u = g_nDataIdx; 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/implicitInnerAtomicUint.frag: -------------------------------------------------------------------------------- 1 | #version 460 2 | layout(binding = 0) uniform atomic_uint c[1][]; -------------------------------------------------------------------------------- /deps/glslang/Test/inc1/badInc.h: -------------------------------------------------------------------------------- 1 | #include "parentBad" 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc1/bar.h: -------------------------------------------------------------------------------- 1 | float4 i2; 2 | 3 | #include "foo.h" 4 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc1/foo.h: -------------------------------------------------------------------------------- 1 | #include "parent.h" 2 | 3 | float4 i3; 4 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc1/path1/bar.h: -------------------------------------------------------------------------------- 1 | float4 i9991; 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc1/path1/local.h: -------------------------------------------------------------------------------- 1 | float4 p2; 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc1/path1/notHere.h: -------------------------------------------------------------------------------- 1 | float4 p1; 2 | 3 | #include "local.h" 4 | #include "remote.h" 5 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc1/path2/bar.h: -------------------------------------------------------------------------------- 1 | float4 i9991; 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc1/path2/notHere.h: -------------------------------------------------------------------------------- 1 | float4 paoeu1; 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc1/path2/remote.h: -------------------------------------------------------------------------------- 1 | float4 p3; 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc2/bar.h: -------------------------------------------------------------------------------- 1 | #include "foo.h" 2 | float4 i5; 3 | -------------------------------------------------------------------------------- /deps/glslang/Test/inc2/foo.h: -------------------------------------------------------------------------------- 1 | float4 i6; -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/link1.vk.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | vec4 getColor(); 4 | 5 | layout(location=0) out vec4 color; 6 | 7 | int a1[]; // max size from link1 8 | int a2[]; // max size from link2 9 | int b[5]; 10 | int c[]; 11 | int i; 12 | 13 | buffer bnameRuntime { float r[]; }; 14 | buffer bnameImplicit { float m[]; }; 15 | 16 | void main() 17 | { 18 | color = getColor(); 19 | 20 | a1[8] = 1; 21 | a2[1] = 1; 22 | b[i] = 1; 23 | c[3] = 1; 24 | } 25 | -------------------------------------------------------------------------------- /deps/glslang/Test/link2.vk.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(binding=1) uniform sampler2D s2D; 4 | 5 | int a1[]; // max size from link1 6 | int a2[]; // max size from link2 7 | int b[]; 8 | int c[7]; 9 | int i; 10 | 11 | buffer bnameRuntime { float r[]; }; 12 | buffer bnameImplicit { float m[4]; }; 13 | 14 | vec4 getColor() 15 | { 16 | a1[2] = 1; 17 | a2[9] = 1; 18 | b[2] = 1; 19 | c[3] = 1; 20 | c[i] = 1; 21 | 22 | return texture(s2D, vec2(0.5)); 23 | } 24 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/mains.frag: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | void main() 4 | { 5 | } 6 | 7 | void main() 8 | { 9 | } 10 | -------------------------------------------------------------------------------- /deps/glslang/Test/mains1.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /deps/glslang/Test/mains2.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | void main() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /deps/glslang/Test/makeDoc: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | ./glslangValidator -p > instDesc 3 | asciidoc --backend=html5 instDesc 4 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/noMain.vert: -------------------------------------------------------------------------------- 1 | #version 300 es 2 | 3 | void foo() 4 | { 5 | } 6 | -------------------------------------------------------------------------------- /deps/glslang/Test/noMain1.geom: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | void foo() 4 | { 5 | } 6 | 7 | layout(points) out; -------------------------------------------------------------------------------- /deps/glslang/Test/noMain2.geom: -------------------------------------------------------------------------------- 1 | #version 150 2 | 3 | void bar() 4 | { 5 | } 6 | 7 | layout(line_strip) out; 8 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/nosuffix: -------------------------------------------------------------------------------- 1 | void main() 2 | { 3 | gl_Position = vec4(1.0); 4 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/Test/parent.h: -------------------------------------------------------------------------------- 1 | float4 i4; 2 | -------------------------------------------------------------------------------- /deps/glslang/Test/parentBad: -------------------------------------------------------------------------------- 1 | int a; 2 | 3 | #error bad parent 4 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/preprocessor.cpp_style___FILE__.vert: -------------------------------------------------------------------------------- 1 | #extension GL_GOOGLE_cpp_style_line_directive : enable 2 | 3 | __FILE__ 4 | 5 | #line 150 "a.h" 6 | __FILE__ 7 | 8 | #line 24 9 | __FILE__ 10 | 11 | #line 42 12 | __FILE__ 13 | 14 | #line 30 "b.cc" 15 | __FILE__ 16 | 17 | #line 10 3 18 | __FILE__ 19 | 20 | #line 48 21 | __FILE__ 22 | 23 | #line 4 24 | __FILE__ 25 | 26 | #line 55 100 27 | __FILE__ 28 | 29 | #line 1000 "c" 30 | __FILE__ 31 | 32 | #line 42 1 33 | __FILE__ 34 | 35 | #line 42 "this-is-a-quite-long-name-maybe-i-should-shorten-it" 36 | __FILE__ 37 | -------------------------------------------------------------------------------- /deps/glslang/Test/preprocessor.defined.vert: -------------------------------------------------------------------------------- 1 | #define defined_not_really 2 | #define defined // ERROR: "defined" can't be (un)defined: 3 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/preprocessor.eof_missing.vert: -------------------------------------------------------------------------------- 1 | noEOF -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/preprocessor.function_macro.vert: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | 4 | #define X(n) n + 1 5 | #define Y(n, z) n + z 6 | #define Z(f) X(f) 7 | 8 | #define REALLY_LONG_MACRO_NAME_WITH_MANY_PARAMETERS(X1, X2, X3, X4, X5, X6, X7,\ 9 | X8, X9, X10, X11, X12) X1+X2+X3+X4+X5+X6+X7+X8+X9+X10+X11+X12 10 | 11 | #define A(\ 12 | Y\ 13 | )\ 14 | 4 + 3 + Y 15 | 16 | int main() { 17 | gl_Position = vec4(X(3), Y(3, 4), Z(3)); 18 | gl_Position = vec4(REALLY_LONG_MACRO_NAME_WITH_MANY_PARAMETERS(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)); 19 | gl_Position = vec4(A(3)); 20 | } 21 | -------------------------------------------------------------------------------- /deps/glslang/Test/preprocessor.include.disabled.vert: -------------------------------------------------------------------------------- 1 | #line 8000 2 | #include 3 | #include 123 4 | #include "foo" 5 | #include "foo" garbage 6 | #include "no-eol" -------------------------------------------------------------------------------- /deps/glslang/Test/preprocessor.line.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | #line 1 2 3 | #pragma something 4 | void main() {} 5 | -------------------------------------------------------------------------------- /deps/glslang/Test/preprocessor.line.vert: -------------------------------------------------------------------------------- 1 | #line 300 2 | 3 | #line 2 4 | 5 | 6 | 7 | 8 | 9 | #line __LINE__ + 3 10 | 11 | 12 | #line __FILE__ + 2 13 | 14 | #line __FILE__ * __LINE__ 15 | 16 | 17 | #define X 4 18 | 19 | #line X 20 | 21 | #undef X 22 | 23 | #define X(y) y + 3 + 2 24 | 25 | #line X(3) 26 | 27 | void main() { 28 | gl_Position = vec4(__LINE__); 29 | } 30 | 31 | #line X(3) 4 32 | 33 | #define Z(y, q) \ 34 | y*q*2 q 35 | 36 | #line Z(2, 3) 37 | 38 | #line 1 39 | 40 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/preprocessor.success_if_parse_would_fail.vert: -------------------------------------------------------------------------------- 1 | int x() { 2 | something that shouldnt compile; 3 | } 4 | 5 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/remap.invalid-spirv-1.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/remap.invalid-spirv-1.spv -------------------------------------------------------------------------------- /deps/glslang/Test/remap.invalid-spirv-2.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/remap.invalid-spirv-2.spv -------------------------------------------------------------------------------- /deps/glslang/Test/remap.literal64.everything.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/remap.literal64.everything.spv -------------------------------------------------------------------------------- /deps/glslang/Test/remap.literal64.none.spv: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/remap.literal64.none.spv -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/specExamples.frag: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/specExamples.frag -------------------------------------------------------------------------------- /deps/glslang/Test/specExamples.vert: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/GPUOpen-Archive/Anvil/a13b276d1b5996699dece1d0a8cfd401cde2a1dd/deps/glslang/Test/specExamples.vert -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.100ops.frag: -------------------------------------------------------------------------------- 1 | #version 310 es 2 | 3 | lowp float foo(); 4 | 5 | in lowp float low, high; 6 | 7 | lowp float face1 = 11.0; 8 | 9 | out lowp vec4 Color; 10 | 11 | void main() 12 | { 13 | int z = 3; 14 | 15 | if (2.0 * low + 1.0 < high) 16 | ++z; 17 | 18 | Color = face1 * vec4(z) + foo(); 19 | } 20 | 21 | lowp float face2 = -2.0; 22 | 23 | lowp float foo() 24 | { 25 | // testing if face2 initializer insert logic is correct in main 26 | return face2; 27 | } 28 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.460.vert: -------------------------------------------------------------------------------- 1 | #version 460 2 | 3 | void main() 4 | { 5 | int a = gl_BaseVertex + gl_BaseInstance + gl_DrawID; 6 | } 7 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.AnyHitShader_Errors.rahit: -------------------------------------------------------------------------------- 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 | traceNV(accNV, 0, 0, 1, 1, 0, vec3(0.0f), 0.5f, vec3(1.0f), 0.75f, 0); // ERROR, unsupported builtin in stage 11 | } 12 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | uint curFlags = gl_IncomingRayFlagsNV; 12 | curFlags = curFlags & gl_RayFlagsOpaqueNV; 13 | data1 = 256U; 14 | executeCallableNV(2,1); 15 | } 16 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.buffer.autoassign.frag: -------------------------------------------------------------------------------- 1 | 2 | cbuffer MyUB1 : register(b5) // explicitly assigned & offsetted 3 | { 4 | float g_a; 5 | int g_b; 6 | }; 7 | 8 | cbuffer MyUB2 // implicitly assigned 9 | { 10 | float g_c; 11 | }; 12 | 13 | cbuffer MyUB3 // implicitly assigned 14 | { 15 | float g_d; 16 | }; 17 | 18 | struct PS_OUTPUT 19 | { 20 | float4 Color : SV_Target0; 21 | }; 22 | 23 | PS_OUTPUT main() 24 | { 25 | PS_OUTPUT psout; 26 | psout.Color = g_a + g_b + g_c + g_d; 27 | return psout; 28 | } 29 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.bufferhandle10.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_ARB_gpu_shader_int64 : enable 4 | #extension GL_EXT_buffer_reference : enable 5 | 6 | layout(buffer_reference, std430) buffer blockType { 7 | uint x[]; 8 | }; 9 | 10 | layout(std430) buffer t2 { 11 | blockType f; 12 | } t; 13 | 14 | layout(location = 0) flat in uint i; 15 | 16 | void main() { 17 | 18 | atomicAdd(t.f.x[i], 1); 19 | 20 | coherent blockType b = t.f; 21 | b.x[0] = 2; 22 | 23 | } 24 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.bufferhandle3.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | #extension GL_EXT_buffer_reference : enable 4 | 5 | layout(buffer_reference, std430) buffer t3 { 6 | int h; 7 | }; 8 | 9 | layout(set = 1, binding = 2, buffer_reference, std430) buffer t4 { 10 | layout(offset = 0) int j; 11 | t3 k; 12 | } x; 13 | 14 | layout(std430) buffer t5 { 15 | t4 m; 16 | } s5; 17 | 18 | flat in t4 k; 19 | 20 | t4 foo(t4 y) { return y; } 21 | 22 | void main() { 23 | foo(s5.m).j = s5.m.k.h; 24 | x.j = k.k.h; 25 | } 26 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.dataOut.frag: -------------------------------------------------------------------------------- 1 | #version 140 2 | 3 | in vec4 Color; 4 | 5 | void main() 6 | { 7 | gl_FragData[1] = Color; 8 | } 9 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.glFragColor.frag: -------------------------------------------------------------------------------- 1 | #version 330 2 | 3 | void main() 4 | { 5 | gl_FragColor = vec4(1.0); 6 | } 7 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.hlslDebugInfo.vert: -------------------------------------------------------------------------------- 1 | float4 origMain() : SV_Position 2 | { 3 | return (float4)0; 4 | } 5 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.hlslOffsets.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | buffer block { 4 | float m0; 5 | vec3 m4; 6 | ////// 7 | float m16; 8 | layout(offset=20) vec3 m20; 9 | ///// 10 | vec3 m32; 11 | ///// 12 | vec2 m48; 13 | vec2 m56; 14 | //// 15 | float m64; 16 | vec2 m68; 17 | float m76; 18 | ////// 19 | float m80; 20 | layout(offset=88) vec2 m88; 21 | ////// 22 | vec2 m96; 23 | /////// 24 | dvec2 m112; 25 | }; 26 | 27 | void main() {} -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/Test/spv.matFun.vert: -------------------------------------------------------------------------------- 1 | #version 400 2 | 3 | uniform bl { 4 | uniform mat4 m4; 5 | uniform mat3 m3; 6 | } bName; 7 | 8 | in vec3 v3; 9 | 10 | vec3 xf(mat3 m, vec3 v) 11 | { 12 | return v * m; 13 | } 14 | 15 | mat3 Mat3(mat4 m) 16 | { 17 | return mat3(m[0].xyz, m[1].xyz, m[2].xyz); 18 | } 19 | 20 | vec3 mxv(mat4 m4, vec3 v) 21 | { 22 | return v * Mat3(m4); 23 | } 24 | 25 | void main() 26 | { 27 | gl_Position = vec4(mxv(bName.m4, v3) + xf(bName.m3, v3), 1.0); 28 | } 29 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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; 14 | } 15 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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() {} -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.register.subpass.frag: -------------------------------------------------------------------------------- 1 | 2 | // Test binding autoassignment and offset for SubpassInput objects 3 | 4 | layout(input_attachment_index = 1) SubpassInput subpass_f4 : register(t1); 5 | layout(input_attachment_index = 4) SubpassInputMS subpass_ms_f4; 6 | [[vk::input_attachment_index(7)]] SubpassInput subpass_2; 7 | 8 | float4 main() : SV_Target0 9 | { 10 | float4 result00 = subpass_f4.SubpassLoad(); 11 | float4 result10 = subpass_ms_f4.SubpassLoad(3); 12 | float4 result73 = subpass_2.SubpassLoad(); 13 | 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.ssbo.autoassign.frag: -------------------------------------------------------------------------------- 1 | 2 | cbuffer TestCB 3 | { 4 | uint W; 5 | uint H; 6 | }; 7 | 8 | struct BufType 9 | { 10 | float4 va; 11 | float4 vb; 12 | }; 13 | 14 | StructuredBuffer < BufType > SB0; 15 | RWStructuredBuffer < BufType > SB1; 16 | 17 | float4 main(float4 pos : POS) : SV_Target0 18 | { 19 | float4 vTmp = SB0[pos.y * W + pos.x].va + SB0[pos.y * W + pos.x].vb; 20 | 21 | vTmp += SB1[pos.y * W + pos.x].va + SB1[pos.y * W + pos.x].vb; 22 | 23 | return vTmp; 24 | } 25 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.swizzleInversion.frag: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in vec4 in4; 4 | in vec3 in3; 5 | 6 | void main() 7 | { 8 | vec3 v43 = interpolateAtCentroid(in4.wzx); 9 | vec2 v42 = interpolateAtSample(in4.zx, 1); 10 | vec4 v44 = interpolateAtOffset(in4.zyxw, vec2(2.0)); 11 | float v41 = interpolateAtOffset(in4.y, vec2(2.0)); 12 | 13 | vec3 v33 = interpolateAtCentroid(in3.yzx); 14 | vec2 v32 = interpolateAtSample(in3.zx, 1); 15 | float v31 = interpolateAtOffset(in4.y, vec2(2.0)); 16 | } 17 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.xfb.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(xfb_buffer = 3) out; 4 | layout(xfb_stride = 48) out; 5 | layout(xfb_offset = 12, location = 0) out float out1; 6 | 7 | layout(xfb_buffer = 2) out; 8 | layout(location=1) out outXfb { 9 | layout(xfb_buffer = 2, xfb_stride = 32, xfb_offset = 8) float out2; 10 | }; 11 | 12 | layout(xfb_buffer = 1, location=3) out outXfb2 { 13 | layout(xfb_stride = 64, xfb_offset = 60) float out3; 14 | }; 15 | 16 | layout(location = 4, xfb_buffer = 0, xfb_offset = 4) out float out4; 17 | 18 | void main() 19 | { 20 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | } -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/spv.xfbOffsetOnStructMembersAssignment.vert: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | layout(xfb_buffer=2) out; 4 | 5 | struct S { 6 | float x1_out; 7 | float x2_out; 8 | }; 9 | 10 | layout(location=0, xfb_offset = 16) out S s1; 11 | 12 | layout(location=5, xfb_buffer=1, xfb_offset=8) out struct S2 { 13 | float y1_out; 14 | vec4 y2_out; 15 | }s2; 16 | 17 | void main() { 18 | s1.x1_out = 5.0; 19 | s1.x2_out = 6.0; 20 | s2.y1_out = 7.0; 21 | s2.y2_out = vec4(1.0, 0.0, 0.0, 1.0); 22 | gl_Position = vec4(0.0); 23 | } 24 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/test.frag: -------------------------------------------------------------------------------- 1 | #version 110 2 | 3 | uniform sampler2D texSampler2D; 4 | uniform sampler3D texSampler3D; 5 | 6 | uniform float blend; 7 | uniform vec2 scale; 8 | uniform vec4 u; 9 | 10 | varying vec2 t; 11 | varying vec3 coords; 12 | 13 | void main() 14 | { 15 | float blendscale = 1.789; 16 | 17 | vec4 v = texture2D(texSampler2D, (t + scale) / scale ).wzyx; 18 | 19 | vec4 w = texture3D(texSampler3D, coords) + v; 20 | 21 | gl_FragColor = mix(w, u, blend * blendscale); 22 | } 23 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/Test/varyingArrayIndirect.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 userIn[2]; 9 | 10 | uniform int a, b; 11 | 12 | void main() 13 | { 14 | vec4 texColor = texture2D(texSampler2D, vec2(userIn[b] + gl_TexCoord[a] + gl_TexCoord[5])); 15 | 16 | texColor += color; 17 | 18 | texColor.a = alpha; 19 | 20 | gl_FragColor = gl_TexCoord[0] + gl_TexCoord[b] + texColor + userIn[a]; 21 | } 22 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/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 | -------------------------------------------------------------------------------- /deps/glslang/glslang/Include/revision.h: -------------------------------------------------------------------------------- 1 | // This header is generated by the make-revision script. 2 | 3 | #define GLSLANG_PATCH_LEVEL 3057 4 | -------------------------------------------------------------------------------- /deps/glslang/glslang/updateGrammar: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | bison --defines=MachineIndependent/glslang_tab.cpp.h -t MachineIndependent/glslang.y -o MachineIndependent/glslang_tab.cpp 4 | -------------------------------------------------------------------------------- /deps/glslang/known_good_khr.json: -------------------------------------------------------------------------------- 1 | { 2 | "commits" : [ 3 | { 4 | "name" : "spirv-tools", 5 | "site" : "gitlab", 6 | "subrepo" : "spirv/spirv-tools", 7 | "subdir" : "External/spirv-tools", 8 | "commit" : "d4e2c2eaa6fd2e9f9cd218ea9add9b0c8ae759ba" 9 | }, 10 | { 11 | "name" : "spirv-tools/external/spirv-headers", 12 | "site" : "gitlab", 13 | "subrepo" : "spirv/SPIRV-Headers", 14 | "subdir" : "External/spirv-tools/external/spirv-headers", 15 | "commit" : "gitlab-prelim-rc4" 16 | } 17 | ] 18 | } 19 | -------------------------------------------------------------------------------- /deps/glslang/make-revision: -------------------------------------------------------------------------------- 1 | #!/bin/sh 2 | ( 3 | echo "// This header is generated by the make-revision script." 4 | echo 5 | echo \#define GLSLANG_PATCH_LEVEL `git log --oneline | wc -l` 6 | ) > glslang/Include/revision.h 7 | -------------------------------------------------------------------------------- /deps/glslang/ndk_test/Android.mk: -------------------------------------------------------------------------------- 1 | LOCAL_PATH:= $(call my-dir) 2 | 3 | include $(CLEAR_VARS) 4 | LOCAL_CPP_EXTENSION := .cc .cpp .cxx 5 | LOCAL_SRC_FILES:=test.cpp 6 | LOCAL_MODULE:=glslang_ndk_test 7 | LOCAL_LDLIBS:=-landroid 8 | LOCAL_CXXFLAGS:=-std=c++11 -fno-exceptions -fno-rtti -Werror 9 | LOCAL_STATIC_LIBRARIES:=glslang SPIRV HLSL 10 | include $(BUILD_SHARED_LIBRARY) 11 | 12 | include $(LOCAL_PATH)/../Android.mk 13 | -------------------------------------------------------------------------------- /deps/glslang/ndk_test/jni/Application.mk: -------------------------------------------------------------------------------- 1 | APP_ABI := all 2 | APP_BUILD_SCRIPT := Android.mk 3 | APP_STL := gnustl_static 4 | APP_PLATFORM := android-9 5 | NDK_TOOLCHAIN_VERSION := 4.9 6 | -------------------------------------------------------------------------------- /examples/HOW_TO_BUILD.txt: -------------------------------------------------------------------------------- 1 | Q: How can I run any of the included examples? 2 | A: Let us say you are interested in running the "OutOfOrderRasterization" example. 3 | To build it: 4 | 5 | 1. Go to the examples\OutOfOrderRasterization directory. 6 | 2. Create a "build" directory. 7 | 3. From there, issue: 8 | 9 | cmake -G "Your IDE of choice" .. 10 | 11 | 4. In the "build" directory, a project/solution file, supported by your IDE, 12 | should have been created. Open it, build the project, and you should be good 13 | to run it. 14 | --------------------------------------------------------------------------------