2016-05-16 16:50:30 +00:00
|
|
|
//
|
|
|
|
|
// Copyright (C) 2016 Google, Inc.
|
2016-05-26 16:10:16 +00:00
|
|
|
// Copyright (C) 2016 LunarG, Inc.
|
2016-05-16 16:50:30 +00:00
|
|
|
//
|
|
|
|
|
// All rights reserved.
|
|
|
|
|
//
|
|
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
|
// modification, are permitted provided that the following conditions
|
|
|
|
|
// are met:
|
|
|
|
|
//
|
|
|
|
|
// Redistributions of source code must retain the above copyright
|
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
|
//
|
|
|
|
|
// Redistributions in binary form must reproduce the above
|
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
|
// with the distribution.
|
|
|
|
|
//
|
|
|
|
|
// Neither the name of Google Inc. nor the names of its
|
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
|
//
|
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
|
|
|
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
|
|
|
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
|
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
|
|
|
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
|
|
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
|
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
|
|
|
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
|
// POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
|
|
|
|
|
|
#include "TestFixture.h"
|
|
|
|
|
|
|
|
|
|
namespace glslangtest {
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
struct FileNameEntryPointPair {
|
|
|
|
|
const char* fileName;
|
|
|
|
|
const char* entryPoint;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// We are using FileNameEntryPointPair objects as parameters for instantiating
|
|
|
|
|
// the template, so the global FileNameAsCustomTestSuffix() won't work since
|
|
|
|
|
// it assumes std::string as parameters. Thus, an overriding one here.
|
|
|
|
|
std::string FileNameAsCustomTestSuffix(
|
|
|
|
|
const ::testing::TestParamInfo<FileNameEntryPointPair>& info) {
|
|
|
|
|
std::string name = info.param.fileName;
|
|
|
|
|
// A valid test case suffix cannot have '.' and '-' inside.
|
|
|
|
|
std::replace(name.begin(), name.end(), '.', '_');
|
|
|
|
|
std::replace(name.begin(), name.end(), '-', '_');
|
|
|
|
|
return name;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
using HlslCompileTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
|
2018-03-06 23:12:04 +00:00
|
|
|
using HlslVulkan1_1CompileTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
|
2016-09-16 19:26:37 +00:00
|
|
|
using HlslCompileAndFlattenTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
|
2017-09-22 00:40:22 +00:00
|
|
|
using HlslLegalizeTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
|
2018-12-08 00:36:33 +00:00
|
|
|
using HlslDebugTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
|
2018-12-08 01:38:26 +00:00
|
|
|
using HlslDX9CompatibleTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
|
2018-11-28 18:10:27 +00:00
|
|
|
using HlslLegalDebugTest = GlslangTest<::testing::TestWithParam<FileNameEntryPointPair>>;
|
2016-05-16 16:50:30 +00:00
|
|
|
|
2017-09-22 00:40:22 +00:00
|
|
|
// Compiling HLSL to pre-legalized SPIR-V under Vulkan semantics. Expected
|
|
|
|
|
// to successfully generate both AST and SPIR-V.
|
2016-05-16 16:50:30 +00:00
|
|
|
TEST_P(HlslCompileTest, FromFile)
|
|
|
|
|
{
|
2016-10-05 14:25:09 +00:00
|
|
|
loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
|
2019-01-04 10:10:53 +00:00
|
|
|
Source::HLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_0, glslang::EShTargetSpv_1_0,
|
2018-03-06 23:12:04 +00:00
|
|
|
Target::BothASTAndSpv, true, GetParam().entryPoint);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST_P(HlslVulkan1_1CompileTest, FromFile)
|
|
|
|
|
{
|
|
|
|
|
loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
|
2019-01-04 10:10:53 +00:00
|
|
|
Source::HLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_1, glslang::EShTargetSpv_1_3,
|
2018-02-22 01:19:49 +00:00
|
|
|
Target::BothASTAndSpv, true, GetParam().entryPoint);
|
2016-05-16 16:50:30 +00:00
|
|
|
}
|
|
|
|
|
|
2016-09-16 19:26:37 +00:00
|
|
|
TEST_P(HlslCompileAndFlattenTest, FromFile)
|
|
|
|
|
{
|
2016-10-05 14:25:09 +00:00
|
|
|
loadFileCompileFlattenUniformsAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
|
2016-09-16 19:26:37 +00:00
|
|
|
Source::HLSL, Semantics::Vulkan,
|
|
|
|
|
Target::BothASTAndSpv, GetParam().entryPoint);
|
|
|
|
|
}
|
|
|
|
|
|
2017-09-22 00:40:22 +00:00
|
|
|
// Compiling HLSL to legal SPIR-V under Vulkan semantics. Expected to
|
|
|
|
|
// successfully generate SPIR-V.
|
|
|
|
|
TEST_P(HlslLegalizeTest, FromFile)
|
|
|
|
|
{
|
|
|
|
|
loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
|
2019-01-04 10:10:53 +00:00
|
|
|
Source::HLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_0, glslang::EShTargetSpv_1_0,
|
2018-02-22 01:19:49 +00:00
|
|
|
Target::Spv, true, GetParam().entryPoint,
|
2018-03-29 17:49:14 +00:00
|
|
|
"/baseLegalResults/", true);
|
2017-09-22 00:40:22 +00:00
|
|
|
}
|
|
|
|
|
|
2018-12-08 00:36:33 +00:00
|
|
|
// Compiling HLSL to pre-legalized SPIR-V. Expected to successfully generate
|
|
|
|
|
// SPIR-V with debug instructions, particularly line info.
|
|
|
|
|
TEST_P(HlslDebugTest, FromFile)
|
|
|
|
|
{
|
|
|
|
|
loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
|
2019-01-04 10:10:53 +00:00
|
|
|
Source::HLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_0, glslang::EShTargetSpv_1_0,
|
2018-12-08 00:36:33 +00:00
|
|
|
Target::Spv, true, GetParam().entryPoint,
|
|
|
|
|
"/baseResults/", false, true);
|
|
|
|
|
}
|
|
|
|
|
|
2018-12-08 01:38:26 +00:00
|
|
|
TEST_P(HlslDX9CompatibleTest, FromFile)
|
|
|
|
|
{
|
|
|
|
|
loadFileCompileAndCheckWithOptions(GlobalTestSettings.testRoot, GetParam().fileName, Source::HLSL,
|
2019-01-04 10:10:53 +00:00
|
|
|
Semantics::Vulkan, glslang::EShTargetVulkan_1_0, glslang::EShTargetSpv_1_0,
|
|
|
|
|
Target::BothASTAndSpv, true,
|
2018-12-08 01:38:26 +00:00
|
|
|
GetParam().entryPoint, "/baseResults/",
|
|
|
|
|
EShMessages::EShMsgHlslDX9Compatible);
|
|
|
|
|
}
|
|
|
|
|
|
2018-11-28 18:10:27 +00:00
|
|
|
// Compiling HLSL to legalized SPIR-V with debug instructions. Expected to
|
|
|
|
|
// successfully generate SPIR-V with debug instructions preserved through
|
|
|
|
|
// legalization, particularly line info.
|
|
|
|
|
TEST_P(HlslLegalDebugTest, FromFile)
|
|
|
|
|
{
|
|
|
|
|
loadFileCompileAndCheck(GlobalTestSettings.testRoot, GetParam().fileName,
|
2019-01-04 10:10:53 +00:00
|
|
|
Source::HLSL, Semantics::Vulkan, glslang::EShTargetVulkan_1_0, glslang::EShTargetSpv_1_0,
|
2018-11-28 18:10:27 +00:00
|
|
|
Target::Spv, true, GetParam().entryPoint,
|
|
|
|
|
"/baseResults/", true, true);
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-16 16:50:30 +00:00
|
|
|
// clang-format off
|
|
|
|
|
INSTANTIATE_TEST_CASE_P(
|
|
|
|
|
ToSpirv, HlslCompileTest,
|
|
|
|
|
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
|
2016-09-30 05:58:30 +00:00
|
|
|
{"hlsl.amend.frag", "f1"},
|
2018-03-06 21:48:46 +00:00
|
|
|
{"hlsl.aliasOpaque.frag", "main"},
|
2016-06-19 17:50:34 +00:00
|
|
|
{"hlsl.array.frag", "PixelShaderFunction"},
|
2016-09-27 16:57:35 +00:00
|
|
|
{"hlsl.array.implicit-size.frag", "PixelShaderFunction"},
|
2016-10-13 18:26:18 +00:00
|
|
|
{"hlsl.array.multidim.frag", "main"},
|
2016-05-16 23:39:50 +00:00
|
|
|
{"hlsl.assoc.frag", "PixelShaderFunction"},
|
2016-06-05 17:23:11 +00:00
|
|
|
{"hlsl.attribute.frag", "PixelShaderFunction"},
|
2016-11-11 15:17:44 +00:00
|
|
|
{"hlsl.attribute.expression.comp", "main"},
|
2017-09-30 20:34:50 +00:00
|
|
|
{"hlsl.attributeC11.frag", "main"},
|
2017-10-19 22:54:25 +00:00
|
|
|
{"hlsl.attributeGlobalBuffer.frag", "main"},
|
2016-10-16 18:12:11 +00:00
|
|
|
{"hlsl.basic.comp", "main"},
|
2016-11-17 22:04:20 +00:00
|
|
|
{"hlsl.basic.geom", "main"},
|
2017-04-13 04:37:32 +00:00
|
|
|
{"hlsl.boolConv.vert", "main"},
|
2016-07-25 22:05:33 +00:00
|
|
|
{"hlsl.buffer.frag", "PixelShaderFunction"},
|
2016-07-26 14:57:53 +00:00
|
|
|
{"hlsl.calculatelod.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.calculatelodunclamped.dx10.frag", "main"},
|
2016-06-03 22:55:49 +00:00
|
|
|
{"hlsl.cast.frag", "PixelShaderFunction"},
|
2017-11-27 21:45:36 +00:00
|
|
|
{"hlsl.cbuffer-identifier.vert", "main"},
|
2017-04-12 22:31:15 +00:00
|
|
|
{"hlsl.charLit.vert", "main"},
|
2017-03-31 18:47:34 +00:00
|
|
|
{"hlsl.clip.frag", "main"},
|
2017-08-23 18:34:42 +00:00
|
|
|
{"hlsl.clipdistance-1.frag", "main"},
|
|
|
|
|
{"hlsl.clipdistance-1.geom", "main"},
|
2017-06-22 18:08:00 +00:00
|
|
|
{"hlsl.clipdistance-1.vert", "main"},
|
2017-08-23 18:34:42 +00:00
|
|
|
{"hlsl.clipdistance-2.frag", "main"},
|
|
|
|
|
{"hlsl.clipdistance-2.geom", "main"},
|
2017-06-22 18:08:00 +00:00
|
|
|
{"hlsl.clipdistance-2.vert", "main"},
|
2017-08-23 18:34:42 +00:00
|
|
|
{"hlsl.clipdistance-3.frag", "main"},
|
2017-08-28 20:02:19 +00:00
|
|
|
{"hlsl.clipdistance-3.geom", "main"},
|
2017-06-22 18:08:00 +00:00
|
|
|
{"hlsl.clipdistance-3.vert", "main"},
|
2017-08-23 18:34:42 +00:00
|
|
|
{"hlsl.clipdistance-4.frag", "main"},
|
2017-08-28 20:02:19 +00:00
|
|
|
{"hlsl.clipdistance-4.geom", "main"},
|
2017-06-22 18:08:00 +00:00
|
|
|
{"hlsl.clipdistance-4.vert", "main"},
|
2017-08-23 18:34:42 +00:00
|
|
|
{"hlsl.clipdistance-5.frag", "main"},
|
2017-06-22 18:08:00 +00:00
|
|
|
{"hlsl.clipdistance-5.vert", "main"},
|
2017-08-23 18:34:42 +00:00
|
|
|
{"hlsl.clipdistance-6.frag", "main"},
|
HLSL: handle multiple clip/cull semantic IDs
HLSL allows several variables to be declared. There are packing rules involved:
e.g, a float3 and a float1 can be packed into a single array[4], while for a
float3 and another float3, the second one will skip the third array entry to
avoid straddling
This is implements that ability. Because there can be multiple variables involved,
and the final output array will often be a different type altogether (to fuse
the values into a single destination), a new variable is synthesized, unlike the prior
clip/cull support which used the declared variable. The new variable name is
taken from one of the declared ones, so the old tests are unchanged.
Several new tests are added to test various packing scenarios.
Only two semantic IDs are supported: 0, and 1, per HLSL rules. This is
encapsulated in
static const int maxClipCullRegs = 2;
and the algorithm (probably :) ) generalizes to larger values, although there
are a few issues around how HLSL would pack (e.g, would 4 scalars be packed into
a single HLSL float4 out reg? Probably, and this algorithm assumes so).
2017-07-05 17:33:06 +00:00
|
|
|
{"hlsl.clipdistance-6.vert", "main"},
|
2017-08-23 18:34:42 +00:00
|
|
|
{"hlsl.clipdistance-7.frag", "main"},
|
HLSL: handle multiple clip/cull semantic IDs
HLSL allows several variables to be declared. There are packing rules involved:
e.g, a float3 and a float1 can be packed into a single array[4], while for a
float3 and another float3, the second one will skip the third array entry to
avoid straddling
This is implements that ability. Because there can be multiple variables involved,
and the final output array will often be a different type altogether (to fuse
the values into a single destination), a new variable is synthesized, unlike the prior
clip/cull support which used the declared variable. The new variable name is
taken from one of the declared ones, so the old tests are unchanged.
Several new tests are added to test various packing scenarios.
Only two semantic IDs are supported: 0, and 1, per HLSL rules. This is
encapsulated in
static const int maxClipCullRegs = 2;
and the algorithm (probably :) ) generalizes to larger values, although there
are a few issues around how HLSL would pack (e.g, would 4 scalars be packed into
a single HLSL float4 out reg? Probably, and this algorithm assumes so).
2017-07-05 17:33:06 +00:00
|
|
|
{"hlsl.clipdistance-7.vert", "main"},
|
2017-08-23 18:34:42 +00:00
|
|
|
{"hlsl.clipdistance-8.frag", "main"},
|
HLSL: handle multiple clip/cull semantic IDs
HLSL allows several variables to be declared. There are packing rules involved:
e.g, a float3 and a float1 can be packed into a single array[4], while for a
float3 and another float3, the second one will skip the third array entry to
avoid straddling
This is implements that ability. Because there can be multiple variables involved,
and the final output array will often be a different type altogether (to fuse
the values into a single destination), a new variable is synthesized, unlike the prior
clip/cull support which used the declared variable. The new variable name is
taken from one of the declared ones, so the old tests are unchanged.
Several new tests are added to test various packing scenarios.
Only two semantic IDs are supported: 0, and 1, per HLSL rules. This is
encapsulated in
static const int maxClipCullRegs = 2;
and the algorithm (probably :) ) generalizes to larger values, although there
are a few issues around how HLSL would pack (e.g, would 4 scalars be packed into
a single HLSL float4 out reg? Probably, and this algorithm assumes so).
2017-07-05 17:33:06 +00:00
|
|
|
{"hlsl.clipdistance-8.vert", "main"},
|
2017-08-23 18:34:42 +00:00
|
|
|
{"hlsl.clipdistance-9.frag", "main"},
|
HLSL: handle multiple clip/cull semantic IDs
HLSL allows several variables to be declared. There are packing rules involved:
e.g, a float3 and a float1 can be packed into a single array[4], while for a
float3 and another float3, the second one will skip the third array entry to
avoid straddling
This is implements that ability. Because there can be multiple variables involved,
and the final output array will often be a different type altogether (to fuse
the values into a single destination), a new variable is synthesized, unlike the prior
clip/cull support which used the declared variable. The new variable name is
taken from one of the declared ones, so the old tests are unchanged.
Several new tests are added to test various packing scenarios.
Only two semantic IDs are supported: 0, and 1, per HLSL rules. This is
encapsulated in
static const int maxClipCullRegs = 2;
and the algorithm (probably :) ) generalizes to larger values, although there
are a few issues around how HLSL would pack (e.g, would 4 scalars be packed into
a single HLSL float4 out reg? Probably, and this algorithm assumes so).
2017-07-05 17:33:06 +00:00
|
|
|
{"hlsl.clipdistance-9.vert", "main"},
|
2017-12-08 19:01:16 +00:00
|
|
|
{"hlsl.color.hull.tesc", "main"},
|
HLSL: Enable component-wise vector comparisons from operators
This PR only changes a few lines of code, but is subtle.
In HLSL, comparison operators (<,>,<=,>=,==,!=) operate component-wise
when given a vector operand. If a whole vector equality or inequality is
desired, then all() or any() can be used on the resulting bool vector.
This PR enables this change. Existing shape conversion is used when
one of the two arguments is a vector and one is a scalar.
Some existing HLSL tests had assumed == and != meant vector-wise
instead of component-wise comparisons. These tests have been changed
to add an explicit any() or all() to the test source. This verifably
does not change the final SPIR-V binary relative to the old behavior
for == and !=. The AST does change for the (now explicit, formerly
implicit) any() and all(). Also, a few tests changes where they
previously had the return type wrong, e.g, from a vec < vec comparison
in hlsl.shapeConv.frag.
Promotion of comparison opcodes to vector forms
(EOpEqual->EOpVectorEqual) is handled in promoteBinary(), as is setting
the proper vector type of the result.
EOpVectorEqual and EOpVectorNotEqual are now accepted as either
aggregate or binary nodes, similar to how the other operators are
handled. Partial support already existed for this: it has been
fleshed out in the printing functions in intermOut.cpp.
There is an existing defect around shape conversion with 1-vectors, but
that is orthogonal to this PR and not addressed by it.
2016-10-21 22:43:38 +00:00
|
|
|
{"hlsl.comparison.vec.frag", "main"},
|
2016-07-27 16:39:57 +00:00
|
|
|
{"hlsl.conditional.frag", "PixelShaderFunction"},
|
2017-04-25 15:30:28 +00:00
|
|
|
{"hlsl.constantbuffer.frag", "main"},
|
2017-06-14 05:13:10 +00:00
|
|
|
{"hlsl.constructArray.vert", "main"},
|
2016-07-30 13:38:55 +00:00
|
|
|
{"hlsl.constructexpr.frag", "main"},
|
2017-05-21 03:40:27 +00:00
|
|
|
{"hlsl.constructimat.frag", "main"},
|
2018-05-16 13:25:29 +00:00
|
|
|
{"hlsl.coverage.frag", "main"},
|
2016-09-03 02:05:19 +00:00
|
|
|
{"hlsl.depthGreater.frag", "PixelShaderFunction"},
|
|
|
|
|
{"hlsl.depthLess.frag", "PixelShaderFunction"},
|
2016-06-20 07:22:38 +00:00
|
|
|
{"hlsl.discard.frag", "PixelShaderFunction"},
|
2016-06-05 21:44:07 +00:00
|
|
|
{"hlsl.doLoop.frag", "PixelShaderFunction"},
|
2019-01-29 05:19:43 +00:00
|
|
|
{"hlsl.earlydepthstencil.frag", "main"},
|
2017-03-24 14:56:37 +00:00
|
|
|
{"hlsl.emptystructreturn.frag", "main"},
|
|
|
|
|
{"hlsl.emptystructreturn.vert", "main"},
|
2017-04-28 00:22:52 +00:00
|
|
|
{"hlsl.emptystruct.init.vert", "main"},
|
2016-09-17 01:44:00 +00:00
|
|
|
{"hlsl.entry-in.frag", "PixelShaderFunction"},
|
2016-08-28 21:00:23 +00:00
|
|
|
{"hlsl.entry-out.frag", "PixelShaderFunction"},
|
2017-05-13 15:20:11 +00:00
|
|
|
{"hlsl.fraggeom.frag", "main"},
|
2016-05-20 18:06:03 +00:00
|
|
|
{"hlsl.float1.frag", "PixelShaderFunction"},
|
2016-05-16 23:39:50 +00:00
|
|
|
{"hlsl.float4.frag", "PixelShaderFunction"},
|
2016-10-03 04:13:22 +00:00
|
|
|
{"hlsl.flatten.return.frag", "main"},
|
2018-03-06 21:48:46 +00:00
|
|
|
{"hlsl.flattenOpaque.frag", "main"},
|
|
|
|
|
{"hlsl.flattenOpaqueInit.vert", "main"},
|
|
|
|
|
{"hlsl.flattenOpaqueInitMix.vert", "main"},
|
|
|
|
|
{"hlsl.flattenSubset.frag", "main"},
|
|
|
|
|
{"hlsl.flattenSubset2.frag", "main"},
|
2016-06-05 21:44:07 +00:00
|
|
|
{"hlsl.forLoop.frag", "PixelShaderFunction"},
|
2016-07-22 14:28:11 +00:00
|
|
|
{"hlsl.gather.array.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.gather.basic.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.gather.basic.dx10.vert", "main"},
|
|
|
|
|
{"hlsl.gather.offset.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.gather.offsetarray.dx10.frag", "main"},
|
2017-03-09 15:59:45 +00:00
|
|
|
{"hlsl.gathercmpRGBA.offset.dx10.frag", "main"},
|
2016-07-31 16:37:02 +00:00
|
|
|
{"hlsl.gatherRGBA.array.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.gatherRGBA.basic.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.gatherRGBA.offset.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.gatherRGBA.offsetarray.dx10.frag", "main"},
|
2016-07-15 17:22:24 +00:00
|
|
|
{"hlsl.getdimensions.dx10.frag", "main"},
|
2016-10-04 22:58:14 +00:00
|
|
|
{"hlsl.getdimensions.rw.dx10.frag", "main"},
|
2016-07-15 17:22:24 +00:00
|
|
|
{"hlsl.getdimensions.dx10.vert", "main"},
|
2016-07-26 14:57:53 +00:00
|
|
|
{"hlsl.getsampleposition.dx10.frag", "main"},
|
WIP: HLSL: support global const initializers from non-constant rvalues
Semantic test left over from other source languages is removed, since this is permitted by HLSL.
Also, to support the functionality, a targeted test is performed for this case and it is
turned into a EvqGlobal qualifier to create an AST initialization segment when needed.
Constness is now propagated up aggregate chains during initializer construction. This
handles hierarchical cases such as the distinction between:
static const float2 a[2] = { { 1, 2 }, { 3, 4} };
vs
static const float2 a[2] = { { 1, 2 }, { cbuffer_member, 4} };
The first of which can use a first class constant initalization, and the second cannot.
2017-07-10 21:43:40 +00:00
|
|
|
{"hlsl.global-const-init.frag", "main"},
|
2017-11-15 18:33:25 +00:00
|
|
|
{"hlsl.gs-hs-mix.tesc", "HSMain"},
|
2017-03-23 17:56:07 +00:00
|
|
|
{"hlsl.domain.1.tese", "main"},
|
2017-04-03 15:27:53 +00:00
|
|
|
{"hlsl.domain.2.tese", "main"},
|
2017-04-05 17:03:02 +00:00
|
|
|
{"hlsl.domain.3.tese", "main"},
|
2017-05-24 22:02:56 +00:00
|
|
|
{"hlsl.function.frag", "main"},
|
Add basic HS/DS implementation.
This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version
here uses entry point wrapping.
This is a limited implementation of tessellation shaders. In particular, the following are not functional,
and will be added as separate stages to reduce the size of each PR.
* patchconstantfunctions accepting per-control-point input values, such as
const OutputPatch <hs_out_t, 3> cpv are not implemented.
* patchconstantfunctions whose signature requires an aggregate input type such as
a structure containing builtin variables. Code to synthesize such calls is not
yet present.
These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example
Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors.
PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on
invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is
added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in
the PCF but not the EP are also added to the linkage and synthesized as shader inputs.
Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user
variables in the PCF signature will result in an error. Overloaded PCF functions will also result in
an error.
[domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()]
attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
|
|
|
{"hlsl.hull.1.tesc", "main"},
|
|
|
|
|
{"hlsl.hull.2.tesc", "main"},
|
2017-06-26 23:52:22 +00:00
|
|
|
{"hlsl.hull.3.tesc", "main"},
|
2017-09-10 15:46:55 +00:00
|
|
|
{"hlsl.hull.4.tesc", "main"},
|
2017-09-13 14:44:39 +00:00
|
|
|
{"hlsl.hull.5.tesc", "main"},
|
Add basic HS/DS implementation.
This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version
here uses entry point wrapping.
This is a limited implementation of tessellation shaders. In particular, the following are not functional,
and will be added as separate stages to reduce the size of each PR.
* patchconstantfunctions accepting per-control-point input values, such as
const OutputPatch <hs_out_t, 3> cpv are not implemented.
* patchconstantfunctions whose signature requires an aggregate input type such as
a structure containing builtin variables. Code to synthesize such calls is not
yet present.
These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example
Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors.
PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on
invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is
added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in
the PCF but not the EP are also added to the linkage and synthesized as shader inputs.
Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user
variables in the PCF signature will result in an error. Overloaded PCF functions will also result in
an error.
[domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()]
attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
|
|
|
{"hlsl.hull.void.tesc", "main"},
|
2017-03-14 23:37:10 +00:00
|
|
|
{"hlsl.hull.ctrlpt-1.tesc", "main"},
|
2017-04-01 21:34:48 +00:00
|
|
|
{"hlsl.hull.ctrlpt-2.tesc", "main"},
|
2019-09-27 21:14:18 +00:00
|
|
|
{"hlsl.format.rwtexture.frag", "main"},
|
2018-05-15 20:52:14 +00:00
|
|
|
{"hlsl.groupid.comp", "main"},
|
2016-11-16 20:22:11 +00:00
|
|
|
{"hlsl.identifier.sample.frag", "main"},
|
2016-06-05 17:23:11 +00:00
|
|
|
{"hlsl.if.frag", "PixelShaderFunction"},
|
2018-02-18 18:40:01 +00:00
|
|
|
{"hlsl.imagefetch-subvec4.comp", "main"},
|
2017-03-31 04:09:30 +00:00
|
|
|
{"hlsl.implicitBool.frag", "main"},
|
2017-04-12 19:26:57 +00:00
|
|
|
{"hlsl.inf.vert", "main"},
|
2016-07-13 02:44:32 +00:00
|
|
|
{"hlsl.inoutquals.frag", "main"},
|
2016-07-02 01:06:44 +00:00
|
|
|
{"hlsl.init.frag", "ShaderFunction"},
|
2016-07-30 16:36:09 +00:00
|
|
|
{"hlsl.init2.frag", "main"},
|
2017-04-04 02:05:21 +00:00
|
|
|
{"hlsl.isfinite.frag", "main"},
|
2016-06-15 15:50:24 +00:00
|
|
|
{"hlsl.intrinsics.barriers.comp", "ComputeShaderFunction"},
|
2016-06-13 15:22:28 +00:00
|
|
|
{"hlsl.intrinsics.comp", "ComputeShaderFunction"},
|
2016-06-15 15:50:24 +00:00
|
|
|
{"hlsl.intrinsics.evalfns.frag", "main"},
|
2017-01-03 21:42:18 +00:00
|
|
|
{"hlsl.intrinsics.d3dcolortoubyte4.frag", "main"},
|
2016-06-22 21:20:14 +00:00
|
|
|
{"hlsl.intrinsics.double.frag", "PixelShaderFunction"},
|
2017-02-27 20:09:32 +00:00
|
|
|
{"hlsl.intrinsics.f1632.frag", "main"},
|
|
|
|
|
{"hlsl.intrinsics.f3216.frag", "main"},
|
2016-08-24 20:36:13 +00:00
|
|
|
{"hlsl.intrinsics.frag", "main"},
|
2017-03-29 09:04:58 +00:00
|
|
|
{"hlsl.intrinsic.frexp.frag", "main"},
|
2016-06-15 15:50:24 +00:00
|
|
|
{"hlsl.intrinsics.lit.frag", "PixelShaderFunction"},
|
2016-06-13 15:22:28 +00:00
|
|
|
{"hlsl.intrinsics.negative.comp", "ComputeShaderFunction"},
|
2016-06-03 16:53:28 +00:00
|
|
|
{"hlsl.intrinsics.negative.frag", "PixelShaderFunction"},
|
|
|
|
|
{"hlsl.intrinsics.negative.vert", "VertexShaderFunction"},
|
HLSL: add intrinsic function implicit promotions
This PR handles implicit promotions for intrinsics when there is no exact match,
such as for example clamp(int, bool, float). In this case the int and bool will
be promoted to a float, and the clamp(float, float, float) form used.
These promotions can be mixed with shape conversions, e.g, clamp(int, bool2, float2).
Output conversions are handled either via the existing addOutputArgumentConversion
function, which this PR generalizes to handle either aggregates or unaries, or by
intrinsic decomposition. If there are methods or intrinsics to be decomposed,
then decomposition is responsible for any output conversions, which turns out to
happen automatically in all current cases. This can be revisited once inout
conversions are in place.
Some cases of actual ambiguity were fixed in several tests, e.g, spv.register.autoassign.*
Some intrinsics with only uint versions were expanded to signed ints natively, where the
underlying AST and SPIR-V supports that. E.g, countbits. This avoids extraneous
conversion nodes.
A new function promoteAggregate is added, and used by findFunction. This is essentially
a generalization of the "promote 1st or 2nd arg" algorithm in promoteBinary.
The actual selection proceeds in three steps, as described in the comments in
hlslParseContext::findFunction:
1. Attempt an exact match. If found, use it.
2. If not, obtain the operator from step 1, and promote arguments.
3. Re-select the intrinsic overload from the results of step 2.
2016-11-02 18:42:34 +00:00
|
|
|
{"hlsl.intrinsics.promote.frag", "main"},
|
|
|
|
|
{"hlsl.intrinsics.promote.down.frag", "main"},
|
|
|
|
|
{"hlsl.intrinsics.promote.outputs.frag", "main"},
|
2016-08-17 16:22:08 +00:00
|
|
|
{"hlsl.layout.frag", "main"},
|
2017-12-06 15:17:21 +00:00
|
|
|
{"hlsl.layoutOverride.vert", "main"},
|
2016-07-26 21:19:28 +00:00
|
|
|
{"hlsl.load.2dms.dx10.frag", "main"},
|
2016-07-20 22:34:44 +00:00
|
|
|
{"hlsl.load.array.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.load.basic.dx10.frag", "main"},
|
2016-07-26 21:19:28 +00:00
|
|
|
{"hlsl.load.basic.dx10.vert", "main"},
|
2016-07-27 21:46:48 +00:00
|
|
|
{"hlsl.load.buffer.dx10.frag", "main"},
|
2016-10-10 21:24:57 +00:00
|
|
|
{"hlsl.load.buffer.float.dx10.frag", "main"},
|
2016-10-04 22:58:14 +00:00
|
|
|
{"hlsl.load.rwbuffer.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.load.rwtexture.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.load.rwtexture.array.dx10.frag", "main"},
|
2016-07-20 22:34:44 +00:00
|
|
|
{"hlsl.load.offset.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.load.offsetarray.dx10.frag", "main"},
|
2017-10-06 22:47:54 +00:00
|
|
|
{"hlsl.localStructuredBuffer.comp", "main"},
|
2016-10-15 16:29:58 +00:00
|
|
|
{"hlsl.logical.binary.frag", "main"},
|
2016-10-26 18:42:49 +00:00
|
|
|
{"hlsl.logical.binary.vec.frag", "main"},
|
2017-03-31 05:32:21 +00:00
|
|
|
{"hlsl.logicalConvert.frag", "main"},
|
|
|
|
|
{"hlsl.logical.unary.frag", "main"},
|
2017-05-03 02:14:50 +00:00
|
|
|
{"hlsl.loopattr.frag", "main"},
|
2017-08-07 18:08:50 +00:00
|
|
|
{"hlsl.matpack-pragma.frag", "main"},
|
2017-05-12 23:14:31 +00:00
|
|
|
{"hlsl.mip.operator.frag", "main"},
|
|
|
|
|
{"hlsl.mip.negative.frag", "main"},
|
|
|
|
|
{"hlsl.mip.negative2.frag", "main"},
|
2017-03-30 22:22:26 +00:00
|
|
|
{"hlsl.namespace.frag", "main"},
|
2017-04-07 02:22:20 +00:00
|
|
|
{"hlsl.nonint-index.frag", "main"},
|
2016-11-15 17:11:04 +00:00
|
|
|
{"hlsl.matNx1.frag", "main"},
|
2017-08-04 21:40:53 +00:00
|
|
|
{"hlsl.matpack-1.frag", "main"},
|
2017-01-12 23:51:18 +00:00
|
|
|
{"hlsl.matrixSwizzle.vert", "ShaderFunction"},
|
2017-05-17 05:16:26 +00:00
|
|
|
{"hlsl.memberFunCall.frag", "main"},
|
2016-10-27 01:18:55 +00:00
|
|
|
{"hlsl.mintypes.frag", "main"},
|
2017-11-22 17:33:34 +00:00
|
|
|
{"hlsl.mul-truncate.frag", "main"},
|
2016-09-03 02:23:27 +00:00
|
|
|
{"hlsl.multiEntry.vert", "RealEntrypoint"},
|
2016-10-06 18:59:51 +00:00
|
|
|
{"hlsl.multiReturn.frag", "main"},
|
2016-08-24 20:36:13 +00:00
|
|
|
{"hlsl.matrixindex.frag", "main"},
|
2017-03-20 00:09:59 +00:00
|
|
|
{"hlsl.nonstaticMemberFunction.frag", "main"},
|
2016-07-28 20:49:48 +00:00
|
|
|
{"hlsl.numericsuffixes.frag", "main"},
|
2018-01-30 18:01:39 +00:00
|
|
|
{"hlsl.numthreads.comp", "main_aux2"},
|
2016-08-25 00:34:43 +00:00
|
|
|
{"hlsl.overload.frag", "PixelShaderFunction"},
|
2017-09-06 20:59:06 +00:00
|
|
|
{"hlsl.opaque-type-bug.frag", "main"},
|
2016-12-24 01:56:57 +00:00
|
|
|
{"hlsl.params.default.frag", "main"},
|
|
|
|
|
{"hlsl.params.default.negative.frag", "main"},
|
2016-11-28 00:39:07 +00:00
|
|
|
{"hlsl.partialInit.frag", "PixelShaderFunction"},
|
2018-03-06 21:48:46 +00:00
|
|
|
{"hlsl.partialFlattenLocal.vert", "main"},
|
2017-12-06 14:33:36 +00:00
|
|
|
{"hlsl.PointSize.geom", "main"},
|
|
|
|
|
{"hlsl.PointSize.vert", "main"},
|
2017-06-08 23:12:56 +00:00
|
|
|
{"hlsl.pp.vert", "main"},
|
2016-07-23 02:46:03 +00:00
|
|
|
{"hlsl.pp.line.frag", "main"},
|
2016-08-25 05:49:36 +00:00
|
|
|
{"hlsl.precise.frag", "main"},
|
HLSL: opcode specific promotion rules for interlocked ops
PR #577 addresses most but not all of the intrinsic promotion problems.
This PR resolves all known cases in the remainder.
Interlocked ops need special promotion rules because at the time
of function selection, the first argument has not been converted
to a buffer object. It's just an int or uint, but you don't want
to convert THAT argument, because that implies converting the
buffer object itself. Rather, you can convert other arguments,
but want to stay in the same "family" of functions. E.g, if
the first interlocked arg is a uint, use only the uint family,
never the int family, you can convert the other args as you please.
This PR allows making such opcode and arg specific choices by
passing the op and arg to the convertible lambda. The code in
the new test "hlsl.promote.atomic.frag" would not compile without
this change, but it must compile.
Also, it provides better handling of downconversions (to "worse"
types), which are permitted in HLSL. The existing method of
selecting upconversions is unchanged, but if that doesn't find
any valid ones, then it will allow downconversions. In effect
this always uses an upconversion if there is one.
2016-12-06 22:50:11 +00:00
|
|
|
{"hlsl.promote.atomic.frag", "main"},
|
2016-10-15 16:29:58 +00:00
|
|
|
{"hlsl.promote.binary.frag", "main"},
|
2016-11-11 22:37:10 +00:00
|
|
|
{"hlsl.promote.vec1.frag", "main"},
|
2016-08-09 17:28:03 +00:00
|
|
|
{"hlsl.promotions.frag", "main"},
|
2016-10-19 16:15:25 +00:00
|
|
|
{"hlsl.rw.atomics.frag", "main"},
|
2016-10-07 02:12:24 +00:00
|
|
|
{"hlsl.rw.bracket.frag", "main"},
|
2016-11-01 16:31:42 +00:00
|
|
|
{"hlsl.rw.register.frag", "main"},
|
2016-10-10 21:24:57 +00:00
|
|
|
{"hlsl.rw.scalar.bracket.frag", "main"},
|
2016-12-28 17:03:58 +00:00
|
|
|
{"hlsl.rw.swizzle.frag", "main"},
|
2016-10-10 21:24:57 +00:00
|
|
|
{"hlsl.rw.vec2.bracket.frag", "main"},
|
2016-07-14 20:45:14 +00:00
|
|
|
{"hlsl.sample.array.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.sample.basic.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.sample.offset.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.sample.offsetarray.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplebias.array.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplebias.basic.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplebias.offset.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplebias.offsetarray.dx10.frag", "main"},
|
2016-07-19 20:28:05 +00:00
|
|
|
{"hlsl.samplecmp.array.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplecmp.basic.dx10.frag", "main"},
|
2018-03-06 21:48:46 +00:00
|
|
|
{"hlsl.samplecmp.dualmode.frag", "main"},
|
2016-07-19 20:28:05 +00:00
|
|
|
{"hlsl.samplecmp.offset.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplecmp.offsetarray.dx10.frag", "main"},
|
2017-04-21 15:54:53 +00:00
|
|
|
{"hlsl.samplecmp.negative.frag", "main"},
|
|
|
|
|
{"hlsl.samplecmp.negative2.frag", "main"},
|
2016-07-19 20:28:05 +00:00
|
|
|
{"hlsl.samplecmplevelzero.array.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplecmplevelzero.basic.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplecmplevelzero.offset.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplecmplevelzero.offsetarray.dx10.frag", "main"},
|
2016-07-14 20:45:14 +00:00
|
|
|
{"hlsl.samplegrad.array.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplegrad.basic.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplegrad.basic.dx10.vert", "main"},
|
|
|
|
|
{"hlsl.samplegrad.offset.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplegrad.offsetarray.dx10.frag", "main"},
|
2016-07-21 21:02:16 +00:00
|
|
|
{"hlsl.samplelevel.array.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplelevel.basic.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplelevel.basic.dx10.vert", "main"},
|
|
|
|
|
{"hlsl.samplelevel.offset.dx10.frag", "main"},
|
|
|
|
|
{"hlsl.samplelevel.offsetarray.dx10.frag", "main"},
|
2016-10-15 16:29:58 +00:00
|
|
|
{"hlsl.sample.sub-vec4.dx10.frag", "main"},
|
2017-03-24 16:12:53 +00:00
|
|
|
{"hlsl.scalar-length.frag", "main"},
|
2017-04-04 17:47:42 +00:00
|
|
|
{"hlsl.scalarCast.vert", "main"},
|
2016-08-03 13:04:18 +00:00
|
|
|
{"hlsl.semicolons.frag", "main"},
|
2016-07-28 23:53:56 +00:00
|
|
|
{"hlsl.shapeConv.frag", "main"},
|
2016-10-06 22:56:54 +00:00
|
|
|
{"hlsl.shapeConvRet.frag", "main"},
|
2020-02-11 13:23:48 +00:00
|
|
|
{"hlsl.singleArgIntPromo.vert", "main"},
|
2018-05-17 19:03:12 +00:00
|
|
|
{"hlsl.self_cast.frag", "main"},
|
2017-11-14 21:55:40 +00:00
|
|
|
{"hlsl.snorm.uav.comp", "main"},
|
2019-07-03 07:27:39 +00:00
|
|
|
{"hlsl.specConstant.frag", "main"},
|
2017-03-11 21:13:00 +00:00
|
|
|
{"hlsl.staticMemberFunction.frag", "main"},
|
2018-07-11 07:09:14 +00:00
|
|
|
{"hlsl.staticFuncInit.frag", "main"},
|
2017-11-27 15:53:09 +00:00
|
|
|
{"hlsl.store.rwbyteaddressbuffer.type.comp", "main"},
|
2016-08-22 22:13:47 +00:00
|
|
|
{"hlsl.stringtoken.frag", "main"},
|
2016-09-20 02:23:18 +00:00
|
|
|
{"hlsl.string.frag", "main"},
|
HLSL: inter-stage structure splitting.
This adds structure splitting, which among other things will enable GS support where input structs
are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case.
The salient points of this PR are:
* Structure splitting has been changed from "always between stages" to "only into the VS and out of
the PS". It had previously happened between stages because it's not legal to pass a struct
containing a builtin IO variable.
* Structs passed between stages are now split into a struct containing ONLY user types, and a
collection of loose builtin IO variables, if any. The user-part is passed as a normal struct
between stages, which is valid SPIR-V now that the builtin IO is removed.
* Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g,
functions can work unmodified.
* If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS,
the array reference is moved to the split-off loose variable, which is given the array dimension
itself.
When passing things around inside the shader, such as over a function call, the the original type
is used in a sanitized form that removes the builtIn qualifications and makes them temporaries.
This means internal function calls do not have to change. However, the type when returned from
the shader will be member-wise copied from the internal sanitized one to the external type.
The sanitized type is used in variable declarations.
When copying split types and unsplit, if a sub-struct contains only user variables, it is copied
as a single entity to avoid more AST verbosity.
Above strategy arrived at with talks with @johnkslang.
This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to
real world cases.
2016-12-14 22:22:25 +00:00
|
|
|
{"hlsl.struct.split-1.vert", "main"},
|
2016-12-19 22:48:01 +00:00
|
|
|
{"hlsl.struct.split.array.geom", "main"},
|
2017-01-19 22:18:00 +00:00
|
|
|
{"hlsl.struct.split.assign.frag", "main"},
|
HLSL: inter-stage structure splitting.
This adds structure splitting, which among other things will enable GS support where input structs
are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case.
The salient points of this PR are:
* Structure splitting has been changed from "always between stages" to "only into the VS and out of
the PS". It had previously happened between stages because it's not legal to pass a struct
containing a builtin IO variable.
* Structs passed between stages are now split into a struct containing ONLY user types, and a
collection of loose builtin IO variables, if any. The user-part is passed as a normal struct
between stages, which is valid SPIR-V now that the builtin IO is removed.
* Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g,
functions can work unmodified.
* If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS,
the array reference is moved to the split-off loose variable, which is given the array dimension
itself.
When passing things around inside the shader, such as over a function call, the the original type
is used in a sanitized form that removes the builtIn qualifications and makes them temporaries.
This means internal function calls do not have to change. However, the type when returned from
the shader will be member-wise copied from the internal sanitized one to the external type.
The sanitized type is used in variable declarations.
When copying split types and unsplit, if a sub-struct contains only user variables, it is copied
as a single entity to avoid more AST verbosity.
Above strategy arrived at with talks with @johnkslang.
This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to
real world cases.
2016-12-14 22:22:25 +00:00
|
|
|
{"hlsl.struct.split.call.vert", "main"},
|
2016-12-19 22:48:01 +00:00
|
|
|
{"hlsl.struct.split.nested.geom", "main"},
|
2017-02-02 23:32:02 +00:00
|
|
|
{"hlsl.struct.split.trivial.geom", "main"},
|
HLSL: inter-stage structure splitting.
This adds structure splitting, which among other things will enable GS support where input structs
are passed, and thus become input arrays of structs in the GS inputs. That is a common GS case.
The salient points of this PR are:
* Structure splitting has been changed from "always between stages" to "only into the VS and out of
the PS". It had previously happened between stages because it's not legal to pass a struct
containing a builtin IO variable.
* Structs passed between stages are now split into a struct containing ONLY user types, and a
collection of loose builtin IO variables, if any. The user-part is passed as a normal struct
between stages, which is valid SPIR-V now that the builtin IO is removed.
* Internal to the shader, a sanitized struct (with IO qualifiers removed) is used, so that e.g,
functions can work unmodified.
* If a builtin IO such as Position occurs in an arrayed struct, for example as an input to a GS,
the array reference is moved to the split-off loose variable, which is given the array dimension
itself.
When passing things around inside the shader, such as over a function call, the the original type
is used in a sanitized form that removes the builtIn qualifications and makes them temporaries.
This means internal function calls do not have to change. However, the type when returned from
the shader will be member-wise copied from the internal sanitized one to the external type.
The sanitized type is used in variable declarations.
When copying split types and unsplit, if a sub-struct contains only user variables, it is copied
as a single entity to avoid more AST verbosity.
Above strategy arrived at with talks with @johnkslang.
This is a big complex change. I'm inclined to leave it as a WIP until it can get some exposure to
real world cases.
2016-12-14 22:22:25 +00:00
|
|
|
{"hlsl.struct.split.trivial.vert", "main"},
|
HLSL: Recursive composite flattening
This PR implements recursive type flattening. For example, an array of structs of other structs
can be flattened to individual member variables at the shader interface.
This is sufficient for many purposes, e.g, uniforms containing opaque types, but is not sufficient
for geometry shader arrayed inputs. That will be handled separately with structure splitting,
which is not implemented by this PR. In the meantime, that case is detected and triggers an error.
The recursive flattening extends the following three aspects of single-level flattening:
- Flattening of structures to individual members with names such as "foo[0].samp[1]";
- Turning constant references to the nested composite type into a reference to a particular
flattened member.
- Shadow copies between arrays of flattened members and the nested composite type.
Previous single-level flattening only flattened at the shader interface, and that is unchanged by this PR.
Internally, shadow copies are, such as if the type is passed to a function.
Also, the reasons for flattening are unchanged. Uniforms containing opaque types, and interface struct
types are flattened. (The latter will change with structure splitting).
One existing test changes: hlsl.structin.vert, which did in fact contain a nested composite type to be
flattened.
Two new tests are added: hlsl.structarray.flatten.frag, and hlsl.structarray.flatten.geom (currently
issues an error until type splitting is online).
The process of arriving at the individual member from chained postfix expressions is more complex than
it was with one level. See large-ish comment above HlslParseContext::flatten() for details.
2016-11-29 00:09:54 +00:00
|
|
|
{"hlsl.structarray.flatten.frag", "main"},
|
|
|
|
|
{"hlsl.structarray.flatten.geom", "main"},
|
2017-02-13 00:50:28 +00:00
|
|
|
{"hlsl.structbuffer.frag", "main"},
|
2017-04-14 00:42:58 +00:00
|
|
|
{"hlsl.structbuffer.append.frag", "main"},
|
2017-04-27 17:22:32 +00:00
|
|
|
{"hlsl.structbuffer.append.fn.frag", "main"},
|
2017-02-13 00:50:28 +00:00
|
|
|
{"hlsl.structbuffer.atomics.frag", "main"},
|
|
|
|
|
{"hlsl.structbuffer.byte.frag", "main"},
|
|
|
|
|
{"hlsl.structbuffer.coherent.frag", "main"},
|
2017-04-20 15:00:56 +00:00
|
|
|
{"hlsl.structbuffer.floatidx.comp", "main"},
|
2017-04-10 14:19:21 +00:00
|
|
|
{"hlsl.structbuffer.incdec.frag", "main"},
|
2017-02-24 01:04:12 +00:00
|
|
|
{"hlsl.structbuffer.fn.frag", "main"},
|
2017-04-20 22:37:14 +00:00
|
|
|
{"hlsl.structbuffer.fn2.comp", "main"},
|
2017-02-13 00:50:28 +00:00
|
|
|
{"hlsl.structbuffer.rw.frag", "main"},
|
|
|
|
|
{"hlsl.structbuffer.rwbyte.frag", "main"},
|
2016-09-09 22:32:09 +00:00
|
|
|
{"hlsl.structin.vert", "main"},
|
2017-02-07 01:44:52 +00:00
|
|
|
{"hlsl.structIoFourWay.frag", "main"},
|
2017-03-02 21:30:59 +00:00
|
|
|
{"hlsl.structStructName.frag", "main"},
|
2017-09-27 15:04:43 +00:00
|
|
|
{"hlsl.subpass.frag", "main"},
|
2017-06-21 07:35:57 +00:00
|
|
|
{"hlsl.synthesizeInput.frag", "main"},
|
2017-11-09 02:48:11 +00:00
|
|
|
{"hlsl.texturebuffer.frag", "main"},
|
HLSL: add methods to track user structure in texture return type.
Some languages allow a restricted set of user structure types returned from texture sampling
operations. Restrictions include the total vector size of all components may not exceed 4,
and the basic types of all members must be identical.
This adds underpinnings for that ability. Because storing a whole TType or even a simple
TTypeList in the TSampler would be expensive, the structure definition is held in a
table outside the TType. The TSampler contains a small bitfield index, currently 4 bits
to support up to 15 separate texture template structure types, but that can be adjusted
up or down. Vector returns are handled as before.
There are abstraction methods accepting and returning a TType (such as may have been parsed
from a grammar). The new methods will accept a texture template type and set the
sampler to the structure if possible, checking a range of error conditions such as whether
the total structure vector components exceed 4, or whether their basic types differe, or
whether the struct contains non-vector-or-scalar members. Another query returns the
appropriate TType for the sampler.
High level summary of design:
In the TSampler, this holds an index into the texture structure return type table:
unsigned int structReturnIndex : structReturnIndexBits;
These are the methods to set or get the return type from the TSampler. They work for vector or structure returns, and potentially could be expanded to handle other things (small arrays?) if ever needed.
bool setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc);
void getTextureReturnType(const TSampler& sampler, const TType& retType, const TSourceLoc& loc) const;
The ``convertReturn`` lambda in ``HlslParseContext::decomposeSampleMethods`` is greatly expanded to know how to copy a vec4 sample return to whatever the structure type should be. This is a little awkward since it involves introducing a comma expression to return the proper aggregate value after a set of memberwise copies.
2017-07-31 19:41:42 +00:00
|
|
|
{"hlsl.texture.struct.frag", "main"},
|
2017-06-01 19:10:25 +00:00
|
|
|
{"hlsl.texture.subvec4.frag", "main"},
|
2017-03-22 17:38:22 +00:00
|
|
|
{"hlsl.this.frag", "main"},
|
2016-06-03 16:53:28 +00:00
|
|
|
{"hlsl.intrinsics.vert", "VertexShaderFunction"},
|
2017-03-29 09:04:58 +00:00
|
|
|
{"hlsl.intrinsic.frexp.vert", "VertexShaderFunction"},
|
2016-05-20 18:17:26 +00:00
|
|
|
{"hlsl.matType.frag", "PixelShaderFunction"},
|
2016-11-15 17:11:04 +00:00
|
|
|
{"hlsl.matType.bool.frag", "main"},
|
|
|
|
|
{"hlsl.matType.int.frag", "main"},
|
2016-05-16 23:39:50 +00:00
|
|
|
{"hlsl.max.frag", "PixelShaderFunction"},
|
2017-08-24 06:28:57 +00:00
|
|
|
{"hlsl.preprocessor.frag", "main"},
|
2016-05-16 23:39:50 +00:00
|
|
|
{"hlsl.precedence.frag", "PixelShaderFunction"},
|
|
|
|
|
{"hlsl.precedence2.frag", "PixelShaderFunction"},
|
2017-06-09 20:36:46 +00:00
|
|
|
{"hlsl.scalar2matrix.frag", "main"},
|
2017-03-09 21:37:32 +00:00
|
|
|
{"hlsl.semantic.geom", "main"},
|
|
|
|
|
{"hlsl.semantic.vert", "main"},
|
2017-08-24 06:28:57 +00:00
|
|
|
{"hlsl.semantic-1.vert", "main"},
|
2016-06-09 08:02:17 +00:00
|
|
|
{"hlsl.scope.frag", "PixelShaderFunction"},
|
2016-05-16 23:39:50 +00:00
|
|
|
{"hlsl.sin.frag", "PixelShaderFunction"},
|
2016-06-11 22:43:14 +00:00
|
|
|
{"hlsl.struct.frag", "PixelShaderFunction"},
|
2016-07-01 06:04:11 +00:00
|
|
|
{"hlsl.switch.frag", "PixelShaderFunction"},
|
2016-06-17 23:16:27 +00:00
|
|
|
{"hlsl.swizzle.frag", "PixelShaderFunction"},
|
2017-06-27 21:17:38 +00:00
|
|
|
{"hlsl.target.frag", "main"},
|
|
|
|
|
{"hlsl.targetStruct1.frag", "main"},
|
|
|
|
|
{"hlsl.targetStruct2.frag", "main"},
|
2016-06-24 01:13:48 +00:00
|
|
|
{"hlsl.templatetypes.frag", "PixelShaderFunction"},
|
2018-05-15 19:36:13 +00:00
|
|
|
{"hlsl.tristream-append.geom", "main"},
|
2016-10-10 16:00:14 +00:00
|
|
|
{"hlsl.tx.bracket.frag", "main"},
|
2017-05-18 23:43:08 +00:00
|
|
|
{"hlsl.tx.overload.frag", "main"},
|
HLSL: allow scalar type keywords as identifiers, and add half type support.
HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is
valid, or more bizzarely, something like "float.float = int.uint + bool;"
There are places this is not supported. E.g, it's permitted for struct members, but not struct
names or functions. Also, vector or matrix types such as "float3" are not permitted as
identifiers.
This PR adds that support, as well as support for the "half" type. In production shaders,
this was seen with variables named "half". The PR attempts to support this without breaking
useful grammar errors such as "; expected" at the end of unterminated statements, so it errs
on that side at the possible expense of failing to accept valid constructs containing a type
keyword identifier. If others are discovered, they can be added.
Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
|
|
|
{"hlsl.type.half.frag", "main"},
|
|
|
|
|
{"hlsl.type.identifier.frag", "main"},
|
2017-02-01 20:14:03 +00:00
|
|
|
{"hlsl.typeGraphCopy.vert", "main"},
|
2016-07-05 06:02:40 +00:00
|
|
|
{"hlsl.typedef.frag", "PixelShaderFunction"},
|
2016-06-05 21:44:07 +00:00
|
|
|
{"hlsl.whileLoop.frag", "PixelShaderFunction"},
|
2018-11-13 16:11:03 +00:00
|
|
|
{"hlsl.void.frag", "PixelShaderFunction"},
|
|
|
|
|
{"hlsl.type.type.conversion.all.frag", "main"}
|
2016-05-16 16:50:30 +00:00
|
|
|
}),
|
2018-03-06 23:12:04 +00:00
|
|
|
FileNameAsCustomTestSuffix
|
|
|
|
|
);
|
|
|
|
|
// clang-format on
|
|
|
|
|
|
|
|
|
|
// clang-format off
|
|
|
|
|
INSTANTIATE_TEST_CASE_P(
|
|
|
|
|
ToSpirv, HlslVulkan1_1CompileTest,
|
|
|
|
|
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
|
|
|
|
|
{"hlsl.wavebroadcast.comp", "CSMain"},
|
|
|
|
|
{"hlsl.waveprefix.comp", "CSMain"},
|
|
|
|
|
{"hlsl.wavequad.comp", "CSMain"},
|
|
|
|
|
{"hlsl.wavequery.comp", "CSMain"},
|
|
|
|
|
{"hlsl.wavequery.frag", "PixelShaderFunction"},
|
|
|
|
|
{"hlsl.wavereduction.comp", "CSMain"},
|
|
|
|
|
{"hlsl.wavevote.comp", "CSMain"},
|
2018-11-15 09:21:36 +00:00
|
|
|
{ "hlsl.type.type.conversion.valid.frag", "main" },
|
|
|
|
|
{"hlsl.int.dot.frag", "main"}
|
2018-03-06 23:12:04 +00:00
|
|
|
}),
|
2016-05-16 16:50:30 +00:00
|
|
|
FileNameAsCustomTestSuffix
|
|
|
|
|
);
|
|
|
|
|
// clang-format on
|
|
|
|
|
|
2016-09-16 19:26:37 +00:00
|
|
|
// clang-format off
|
|
|
|
|
INSTANTIATE_TEST_CASE_P(
|
|
|
|
|
ToSpirv, HlslCompileAndFlattenTest,
|
|
|
|
|
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
|
|
|
|
|
{"hlsl.array.flatten.frag", "main"},
|
2018-03-06 21:48:46 +00:00
|
|
|
{"hlsl.partialFlattenMixed.vert", "main"},
|
2016-09-16 19:26:37 +00:00
|
|
|
}),
|
|
|
|
|
FileNameAsCustomTestSuffix
|
|
|
|
|
);
|
2017-09-22 00:40:22 +00:00
|
|
|
// clang-format on
|
2016-09-16 19:26:37 +00:00
|
|
|
|
2018-03-29 17:49:14 +00:00
|
|
|
#if ENABLE_OPT
|
2017-09-22 00:40:22 +00:00
|
|
|
// clang-format off
|
|
|
|
|
INSTANTIATE_TEST_CASE_P(
|
|
|
|
|
ToSpirv, HlslLegalizeTest,
|
|
|
|
|
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
|
|
|
|
|
{"hlsl.aliasOpaque.frag", "main"},
|
|
|
|
|
{"hlsl.flattenOpaque.frag", "main"},
|
|
|
|
|
{"hlsl.flattenOpaqueInit.vert", "main"},
|
2017-10-07 03:01:07 +00:00
|
|
|
{"hlsl.flattenOpaqueInitMix.vert", "main"},
|
2017-11-16 22:02:06 +00:00
|
|
|
{"hlsl.flattenSubset.frag", "main"},
|
|
|
|
|
{"hlsl.flattenSubset2.frag", "main"},
|
|
|
|
|
{"hlsl.partialFlattenLocal.vert", "main"},
|
2018-03-06 21:48:46 +00:00
|
|
|
{"hlsl.partialFlattenMixed.vert", "main"}
|
2017-09-22 00:40:22 +00:00
|
|
|
}),
|
|
|
|
|
FileNameAsCustomTestSuffix
|
|
|
|
|
);
|
2016-09-16 19:26:37 +00:00
|
|
|
// clang-format on
|
2017-09-28 16:08:32 +00:00
|
|
|
#endif
|
2017-09-22 00:40:22 +00:00
|
|
|
|
2018-12-08 00:36:33 +00:00
|
|
|
// clang-format off
|
|
|
|
|
INSTANTIATE_TEST_CASE_P(
|
|
|
|
|
ToSpirv, HlslDebugTest,
|
|
|
|
|
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
|
|
|
|
|
{"hlsl.pp.line2.frag", "MainPs"}
|
|
|
|
|
}),
|
|
|
|
|
FileNameAsCustomTestSuffix
|
|
|
|
|
);
|
|
|
|
|
|
2018-12-08 01:38:26 +00:00
|
|
|
INSTANTIATE_TEST_CASE_P(
|
|
|
|
|
ToSpirv, HlslDX9CompatibleTest,
|
|
|
|
|
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
|
|
|
|
|
{"hlsl.sample.dx9.frag", "main"},
|
|
|
|
|
{"hlsl.sample.dx9.vert", "main"},
|
|
|
|
|
}),
|
|
|
|
|
FileNameAsCustomTestSuffix
|
|
|
|
|
);
|
2018-11-28 18:10:27 +00:00
|
|
|
|
|
|
|
|
// clang-format off
|
|
|
|
|
INSTANTIATE_TEST_CASE_P(
|
|
|
|
|
ToSpirv, HlslLegalDebugTest,
|
|
|
|
|
::testing::ValuesIn(std::vector<FileNameEntryPointPair>{
|
|
|
|
|
{"hlsl.pp.line4.frag", "MainPs"}
|
|
|
|
|
}),
|
|
|
|
|
FileNameAsCustomTestSuffix
|
|
|
|
|
);
|
|
|
|
|
|
2018-12-08 00:36:33 +00:00
|
|
|
// clang-format on
|
2018-12-08 01:38:26 +00:00
|
|
|
|
2016-05-16 16:50:30 +00:00
|
|
|
} // anonymous namespace
|
|
|
|
|
} // namespace glslangtest
|
