RPCS3/glslang
1
0
Fork 0
mirror of https://github.com/RPCS3/glslang.git synced 2024-11-30 14:40:34 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
41aa19953f
glslang/hlsl/hlslParseHelper.h

493 lines
26 KiB
C
Raw Normal View History

HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// Copyright (C) 2016 Google, Inc.
// Copyright (C) 2016 LunarG, Inc.
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// All rights reserved.
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
//
// Neither the name of 3Dlabs Inc. Ltd. nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// 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.
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
#ifndef HLSL_PARSE_INCLUDED_
#define HLSL_PARSE_INCLUDED_
#include "../glslang/MachineIndependent/parseVersions.h"
#include "../glslang/MachineIndependent/ParseHelper.h"
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
#include <array>
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
namespace glslang {
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
class TAttributeMap; // forward declare
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
class TFunctionDeclarator;
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
class HlslParseContext : public TParseContextBase {
public:
HlslParseContext(TSymbolTable&, TIntermediate&, bool parsingBuiltins,
SPV: Non-functional: Condense SPV-related versioning, and rationalize all uses.
2016-06-17 02:59:42 +00:00
int version, EProfile, const SpvVersion& spvVersion, EShLanguage, TInfoSink&,
allow renaming of shader entry point when creating SPIR-V Use "--source-entrypoint name" on the command line, or the TShader::setSourceEntryPoint(char*) API. When the name given to the above interfaces is detected in the shader source, it will be renamed to the entry point name supplied to the -e option or the TShader::setEntryPoint() method.
2016-10-31 21:13:43 +00:00
const TString sourceEntryPointName,
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
bool forwardCompatible = false, EShMessages messages = EShMsgDefault);
virtual ~HlslParseContext();
Fix a large number of warnings about inconsistent usage of 'override' produced by clang
2016-12-21 11:48:08 +00:00
void initializeExtensionBehavior() override;
HLSL: enable #line extension by default for HLSL source.
2016-07-23 02:46:03 +00:00
Fix a large number of warnings about inconsistent usage of 'override' produced by clang
2016-12-21 11:48:08 +00:00
void setLimits(const TBuiltInResource&) override;
bool parseShaderStrings(TPpContext&, TInputScanner& input, bool versionWillBeError = false) override;
HLSL: Allow use of $Global members in between function calls. This allows global initializers to use $Global members.
2017-03-23 05:21:34 +00:00
virtual const char* getGlobalUniformBlockName() const override { return "$Global"; }
virtual void setUniformBlockDefaults(TType& block) const override
{
block.getQualifier().layoutPacking = ElpStd140;
block.getQualifier().layoutMatrix = ElmRowMajor;
}
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
Fix a large number of warnings about inconsistent usage of 'override' produced by clang
2016-12-21 11:48:08 +00:00
void reservedPpErrorCheck(const TSourceLoc&, const char* /*name*/, const char* /*op*/) override { }
bool lineContinuationCheck(const TSourceLoc&, bool /*endOfComment*/) override { return true; }
bool lineDirectiveShouldSetNextLine() const override { return true; }
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
bool builtInName(const TString&);
Fix a large number of warnings about inconsistent usage of 'override' produced by clang
2016-12-21 11:48:08 +00:00
void handlePragma(const TSourceLoc&, const TVector<TString>&) override;
HLSL: Non-functional: the symbol field of a token was in practice unused; remove it. Another precurser to getting member non-static functions working.
2017-03-22 00:35:04 +00:00
TIntermTyped* handleVariable(const TSourceLoc&, const TString* string);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
TIntermTyped* handleBracketDereference(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
HLSL: phase 2a: add r-value operator[] for RWTexture/RWBuffer This commit adds r-value support for RW textures and buffers. Supported is: - Function in parameter conversions - conversion of rvalue use to imageLoad
2016-10-07 02:12:24 +00:00
TIntermTyped* handleBracketOperator(const TSourceLoc&, TIntermTyped* base, TIntermTyped* index);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
TIntermTyped* handleBinaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* left, TIntermTyped* right);
TIntermTyped* handleUnaryMath(const TSourceLoc&, const char* str, TOperator op, TIntermTyped* childNode);
TIntermTyped* handleDotDereference(const TSourceLoc&, TIntermTyped* base, const TString& field);
HLSL: non-functional: simplify handleBuiltInMethod() to isBuiltInMethod().
2017-03-11 16:39:55 +00:00
bool isBuiltInMethod(const TSourceLoc&, TIntermTyped* base, const TString& field);
HLSL: Force flat (nointerp) onto integer fragment inputs. Addresses #940.
2017-06-20 09:20:59 +00:00
void assignToInterface(TVariable& variable);
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
void handleFunctionDeclarator(const TSourceLoc&, TFunction& function, bool prototype);
HLSL: Wrap the entry-point; need to write 'in' args, and support 'inout' args. This needs some render testing, but is destined to be part of master. This also leads to a variety of other simplifications. - IO are global symbols, so only need one list of linkage nodes (deferred) - no longer need parse-context-wide 'inEntryPoint' state, entry-point is localized - several parts of splitting/flattening are now localized
2017-01-19 22:41:47 +00:00
TIntermAggregate* handleFunctionDefinition(const TSourceLoc&, TFunction&, const TAttributeMap&, TIntermNode*& entryPointTree);
TIntermNode* transformEntryPoint(const TSourceLoc&, TFunction&, const TAttributeMap&);
HLSL: pass tessellation execution modes through to SPIR-V The SPIR-V generator had assumed tessellation modes such as primitive type and vertex order would only appear in tess eval (domain) shaders. SPIR-V allows either, and HLSL allows and possibly requires them to be in the hull shader. This change: 1. Passes them through for either tessellation stage, and, 2. Does not set up defaults in the domain stage for HLSl compilation, to avoid conflicting definitions.
2017-03-23 17:56:07 +00:00
void handleEntryPointAttributes(const TSourceLoc&, const TAttributeMap&);
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
void transferTypeAttributes(const TAttributeMap&, TType&);
HLSL: Error if funcion with return type doesn't return a value.
2016-09-03 01:13:36 +00:00
void handleFunctionBody(const TSourceLoc&, TFunction&, TIntermNode* functionBody, TIntermNode*& node);
HLSL: Build IO types bottom up, as parsed, and cache the original (IO). Previously, this was done recursively, per object, and the nonIO version was cached. This reverses both those approaches.
2017-02-04 00:57:55 +00:00
void remapEntryPointIO(TFunction& function, TVariable*& returnValue, TVector<TVariable*>& inputs, TVector<TVariable*>& outputs);
Non-functional: Sweep through the stack for consistent with "main" and entry point. Partially addresses issue #513.
2016-09-19 22:01:41 +00:00
void remapNonEntryPointIO(TFunction& function);
HLSL: add implicit promotions for assignments and function returns.
2016-08-09 17:28:03 +00:00
TIntermNode* handleReturnValue(const TSourceLoc&, TIntermTyped*);
HLSL: Add function call syntax and AST building.
2016-05-13 15:33:42 +00:00
void handleFunctionArgument(TFunction*, TIntermTyped*& arguments, TIntermTyped* newArg);
HLSL: Add EOpMatrixSwizzle, selectively decomposed to other ops, for issue #670. Since EOpMatrixSwizzle is a new op, existing back-ends only work when the front end first decomposes it to other operations. So far, this is only being done for simple assignment into matrix swizzles.
2017-01-13 19:27:52 +00:00
TIntermTyped* handleAssign(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right);
TIntermTyped* handleAssignToMatrixSwizzle(const TSourceLoc&, TOperator, TIntermTyped* left, TIntermTyped* right);
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
TIntermTyped* handleFunctionCall(const TSourceLoc&, TFunction*, TIntermTyped*);
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
TIntermAggregate* assignClipCullDistance(const TSourceLoc&, TOperator, int semanticId, TIntermTyped* left, TIntermTyped* right);
Add decompositions for some HLSL intrinsics.
2016-06-09 14:57:35 +00:00
void decomposeIntrinsic(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
void decomposeSampleMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
void decomposeStructBufferMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
void decomposeGeometryMethods(const TSourceLoc&, TIntermTyped*& node, TIntermNode* arguments);
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
void pushFrontArguments(TIntermTyped* front, TIntermTyped*& arguments);
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
void addInputArgumentConversions(const TFunction&, TIntermTyped*&);
SPV: When passing structs of opaque types, flatten and pass the members instead. This avoids either A) needing uniformConstant struct, or B) initializing a struct with opaque members, as writing them is not allowed.
2017-05-26 06:01:36 +00:00
void expandArguments(const TSourceLoc&, const TFunction&, TIntermTyped*&);
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
TIntermTyped* addOutputArgumentConversions(const TFunction&, TIntermOperator&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void builtInOpCheck(const TSourceLoc&, const TFunction&, TIntermOperator&);
HLSL: Non-functional: rationalize making constructors. Improves foundation for adding scalar casts. Makes handle/make names more sane, better commented, uses more precise subclass typing, and removes mutual recursion between converting initializer lists and making constructors.
2017-04-04 03:48:37 +00:00
TFunction* makeConstructorCall(const TSourceLoc&, const TType&);
Merge branch 'TiemoJung-semantic_handling'
2017-03-15 03:50:06 +00:00
void handleSemantic(TSourceLoc, TQualifier&, TBuiltInVariable, const TString& upperCase);
HLSL Non-Functional: Move to more robust capturing of postDecls into a qualifier. This will prevent a possible future defect of thinking the type can be changed, where there is a code path today that would drop that change.
2016-09-05 18:40:06 +00:00
void handlePackOffset(const TSourceLoc&, TQualifier&, const glslang::TString& location,
HLSL: Add back in the [subcomponent] part of a 'register' decl.
2016-07-30 16:29:54 +00:00
const glslang::TString* component);
HLSL Non-Functional: Move to more robust capturing of postDecls into a qualifier. This will prevent a possible future defect of thinking the type can be changed, where there is a code path today that would drop that change.
2016-09-05 18:40:06 +00:00
void handleRegister(const TSourceLoc&, TQualifier&, const glslang::TString* profile, const glslang::TString& desc,
HLSL: Support register(..., spaceN) for setting the descriptor set. This was suggested in issue #454.
2016-09-05 22:03:12 +00:00
int subComponent, const glslang::TString*);
HLSL: Support vector 'cond ? :' -> EOpMix -> OpSelect.
2017-04-12 01:45:00 +00:00
TIntermTyped* convertConditionalExpression(const TSourceLoc&, TIntermTyped*, bool mustBeScalar = true);
HLSL: Add SampleBias and SampleGrad, and associated tests
2016-07-14 20:45:14 +00:00
TIntermAggregate* handleSamplerTextureCombine(const TSourceLoc& loc, TIntermTyped* argTex, TIntermTyped* argSampler);
Front-ends: Non-functional: Rationalize vector and matrix swizzles. This reduces code duplication in a few ways, and better encapsulates vector swizzle representation.
2017-01-14 02:34:22 +00:00
bool parseMatrixSwizzleSelector(const TSourceLoc&, const TString&, int cols, int rows, TSwizzleSelectors<TMatrixSelector>&);
int getMatrixComponentsColumn(int rows, const TSwizzleSelectors<TMatrixSelector>&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void assignError(const TSourceLoc&, const char* op, TString left, TString right);
void unaryOpError(const TSourceLoc&, const char* op, TString operand);
void binaryOpError(const TSourceLoc&, const char* op, TString left, TString right);
void variableCheck(TIntermTyped*& nodePtr);
void constantValueCheck(TIntermTyped* node, const char* token);
void integerCheck(const TIntermTyped* node, const char* token);
void globalCheck(const TSourceLoc&, const char* token);
bool constructorError(const TSourceLoc&, TIntermNode*, TFunction&, TOperator, TType&);
bool constructorTextureSamplerError(const TSourceLoc&, const TFunction&);
void arraySizeCheck(const TSourceLoc&, TIntermTyped* expr, TArraySize&);
void arraySizeRequiredCheck(const TSourceLoc&, const TArraySizes&);
void structArrayCheck(const TSourceLoc&, const TType& structure);
void arrayDimMerge(TType& type, const TArraySizes* sizes);
bool voidErrorCheck(const TSourceLoc&, const TString&, TBasicType);
void globalQualifierFix(const TSourceLoc&, TQualifier&);
bool structQualifierErrorCheck(const TSourceLoc&, const TPublicType& pType);
HLSL: Improve setting and testing of interpolation qualifiers. Notably, use of 'linear' on a non-input could mark it as an input.
2016-09-16 23:10:39 +00:00
void mergeQualifiers(TQualifier& dst, const TQualifier& src);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
int computeSamplerTypeIndex(TSampler&);
Whole stack: Fix stale types in the AST linker object nodes, fixing #557. Rationalizes the entire tracking of the linker object nodes, effecting GLSL, HLSL, and SPIR-V, to allow tracked objects to be fully edited before their type snapshot for linker objects. Should only effect things when the rest of the AST contained no reference to the symbol, because normal AST nodes were not stale. Also will only effect such objects when their types were edited.
2016-11-05 16:15:53 +00:00
TSymbol* redeclareBuiltinVariable(const TSourceLoc&, const TString&, const TQualifier&, const TShaderQualifiers&);
HLSL: Map parameter qualifiers from generic to function-specific and entry-point specific.
2016-06-17 21:50:47 +00:00
void paramFix(TType& type);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void specializationCheck(const TSourceLoc&, const TType&, const char* op);
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
void setLayoutQualifier(const TSourceLoc&, TQualifier&, TString&);
void setLayoutQualifier(const TSourceLoc&, TQualifier&, TString&, const TIntermTyped*);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void mergeObjectLayoutQualifiers(TQualifier& dest, const TQualifier& src, bool inheritOnly);
void checkNoShaderLayouts(const TSourceLoc&, const TShaderQualifiers&);
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
const TFunction* findFunction(const TSourceLoc& loc, TFunction& call, bool& builtIn, int& thisDepth, TIntermTyped*& args);
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
void declareTypedef(const TSourceLoc&, const TString& identifier, const TType&);
HLSL: Build IO types bottom up, as parsed, and cache the original (IO). Previously, this was done recursively, per object, and the nonIO version was cached. This reverses both those approaches.
2017-02-04 00:57:55 +00:00
void declareStruct(const TSourceLoc&, TString& structName, TType&);
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
TSymbol* lookupUserType(const TString&, TType&);
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
TIntermNode* declareVariable(const TSourceLoc&, const TString& identifier, TType&, TIntermTyped* initializer = 0);
HLSL: Fix #805: Support cast of scalars to structures. Somewhat complex due to recognizing a general scalar, but not replicating it for each member to avoid side effects.
2017-04-04 17:47:42 +00:00
void lengthenList(const TSourceLoc&, TIntermSequence& list, int size, TIntermTyped* scalarInit);
HLSL: Non-functional: rationalize making constructors. Improves foundation for adding scalar casts. Makes handle/make names more sane, better commented, uses more precise subclass typing, and removes mutual recursion between converting initializer lists and making constructors.
2017-04-04 03:48:37 +00:00
TIntermTyped* handleConstructor(const TSourceLoc&, TIntermTyped*, const TType&);
TIntermTyped* addConstructor(const TSourceLoc&, TIntermTyped*, const TType&);
HLSL: Fix #924: Convert between two different arrays with cast.
2017-06-14 05:13:10 +00:00
TIntermTyped* convertArray(TIntermTyped*, const TType&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
TIntermTyped* constructAggregate(TIntermNode*, const TType&, int, const TSourceLoc&);
TIntermTyped* constructBuiltIn(const TType&, TOperator, TIntermTyped*, const TSourceLoc&, bool subset);
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
void declareBlock(const TSourceLoc&, TType&, const TString* instanceName = 0, TArraySizes* arraySizes = 0);
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
void declareStructBufferCounter(const TSourceLoc& loc, const TType& bufferType, const TString& name);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void fixBlockLocations(const TSourceLoc&, TQualifier&, TTypeList&, bool memberWithLocation, bool memberWithoutLocation);
void fixBlockXfbOffsets(TQualifier&, TTypeList&);
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
void fixBlockUniformOffsets(const TQualifier&, TTypeList&);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void addQualifierToExisting(const TSourceLoc&, TQualifier, const TString& identifier);
void addQualifierToExisting(const TSourceLoc&, TQualifier, TIdentifierList&);
void updateStandaloneQualifierDefaults(const TSourceLoc&, const TPublicType&);
void wrapupSwitchSubsequence(TIntermAggregate* statements, TIntermNode* branchNode);
HLSL: Translate directive [flatten] and [branch] to SPV control mask.
2017-07-04 15:23:40 +00:00
TIntermNode* addSwitch(const TSourceLoc&, TIntermTyped* expression, TIntermAggregate* body, TSelectionControl control);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void updateImplicitArraySize(const TSourceLoc&, TIntermNode*, int index);
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
void nestLooping() { ++loopNestingLevel; }
void unnestLooping() { --loopNestingLevel; }
void nestAnnotations() { ++annotationNestingLevel; }
void unnestAnnotations() { --annotationNestingLevel; }
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
int getAnnotationNestingLevel() { return annotationNestingLevel; }
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
void pushScope() { symbolTable.push(); }
void popScope() { symbolTable.pop(0); }
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
void pushThisScope(const TType&, const TVector<TFunctionDeclarator>&);
HLSL: non-static member functions: track and find active anonymous 'this' scopes and members. Thanks to @steve-lunarg for his input and discussions on handling member functions.
2017-03-22 05:56:40 +00:00
void popThisScope() { symbolTable.pop(0); }
void pushImplicitThis(TVariable* thisParameter) { implicitThisStack.push_back(thisParameter); }
void popImplicitThis() { implicitThisStack.pop_back(); }
TVariable* getImplicitThis(int thisDepth) const { return implicitThisStack[implicitThisStack.size() - thisDepth]; }
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
void pushNamespace(const TString& name);
void popNamespace();
GLSL: Promote HLSL entry-point renaming code to be used by GLSL as well. Fixes #1045.
2017-09-12 03:48:19 +00:00
void getFullNamespaceName(TString*&) const;
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
void addScopeMangler(TString&);
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
void pushSwitchSequence(TIntermSequence* sequence) { switchSequenceStack.push_back(sequence); }
void popSwitchSequence() { switchSequenceStack.pop_back(); }
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
virtual void growGlobalUniformBlock(const TSourceLoc&, TType&, const TString& memberName, TTypeList* typeList = nullptr) override;
HLSL: Have loose uniforms also go through the makeTypeNonIo() path.
2017-02-03 21:06:36 +00:00
HLSL: phase 2b: add l-value operator[] for RWTexture/RWBuffer This commit adds l-value support for RW texture and buffer objects. Supported are: - pre and post inc/decrement - function out parameters - op-assignments, such as *=, +-, etc. - result values from op-assignments. e.g, val=(MyRwTex[loc] *= 2); Not supported are: - Function inout parameters - multiple post-inc/decrement operators. E.g, MyRWTex[loc]++++;
2016-10-08 01:35:40 +00:00
// Apply L-value conversions. E.g, turning a write to a RWTexture into an ImageStore.
HLSL: Convert run-time sampler assignments to compile-time aliases. For "s.m = t", a sampler member assigned a sampler, make t an alias for s.m, and when s.m is flattened, it will flatten to the alias t. Normally, assignments to samplers are disallowed.
2017-06-02 22:28:39 +00:00
TIntermTyped* handleLvalue(const TSourceLoc&, const char* op, TIntermTyped*& node);
HLSL: phase 2c: use lValueErrorCheck in HLSL FE This commit splits lValueErrorCheck into machine dependent and independent parts. The GLSL form in TParseContext inherits from and invokes the machine dependent part in TParseContextBase. The base form checks language independent things. This split does not change the set of errors tested for: the test results are identical. The new base class interface is now used from the HLSL FE to test lvalues. There was one test diff due to this, where the test was writing to a uniform. It still does the same indirections, but does not attempt a uniform write.
2016-10-08 16:54:52 +00:00
bool lValueErrorCheck(const TSourceLoc&, const char* op, TIntermTyped*) override;
HLSL: phase 2b: add l-value operator[] for RWTexture/RWBuffer This commit adds l-value support for RW texture and buffer objects. Supported are: - pre and post inc/decrement - function out parameters - op-assignments, such as *=, +-, etc. - result values from op-assignments. e.g, val=(MyRwTex[loc] *= 2); Not supported are: - Function inout parameters - multiple post-inc/decrement operators. E.g, MyRWTex[loc]++++;
2016-10-08 01:35:40 +00:00
HLSL: phase 3a: Add sub-vec4 rwtexture formats (qualifier.layoutFormat) This PR sets the TQualifier layoutFormat according to the HLSL image type. For instance: RWTexture1D <float2> g_tTex1df2; becomes ElfRg32f. Similar on Buffers, e.g, Buffer<float4> mybuffer; The return type for image and buffer loads is now taken from the storage format. Also, the qualifier for the return type is now (properly) a temp, not a global.
2016-10-10 21:24:57 +00:00
TLayoutFormat getLayoutFromTxType(const TSourceLoc&, const TType&);
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
bool handleOutputGeometry(const TSourceLoc&, const TLayoutGeometry& geometry);
bool handleInputGeometry(const TSourceLoc&, const TLayoutGeometry& geometry);
HLSL: Translate directive [flatten] and [branch] to SPV control mask.
2017-07-04 15:23:40 +00:00
// Determine selection control from attributes
TSelectionControl handleSelectionControl(const TAttributeMap& attributes) const;
HLSL: implement [unroll] and [loop] attributes This adds infrastructure suitable for any front end to create SPIR-V loop control flags. The only current front end doing so is HLSL. [unroll] turns into spv::LoopControlUnrollMask [loop] turns into spv::LoopControlDontUnrollMask no specification means spv::LoopControlMaskNone
2017-05-03 02:14:50 +00:00
// Determine loop control from attributes
TLoopControl handleLoopControl(const TAttributeMap& attributes) const;
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
// Share struct buffer deep types
void shareStructBufferType(TType&);
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
// Set texture return type of the given sampler. Returns success (not all types are valid).
bool setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc);
// Obtain the sampler return type of the given sampler in retType.
void getTextureReturnType(const TSampler& sampler, TType& retType) const;
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
protected:
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
struct TFlattenData {
HLSL: Fix #942: Map SV_TargetN to SPV Location N.
2017-06-27 21:17:38 +00:00
TFlattenData() : nextBinding(TQualifier::layoutBindingEnd),
nextLocation(TQualifier::layoutLocationEnd) { }
TFlattenData(int nb, int nl) : nextBinding(nb), nextLocation(nl) { }
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
TVector<TVariable*> members; // individual flattened variables
HLSL: Fix #942: Map SV_TargetN to SPV Location N.
2017-06-27 21:17:38 +00:00
TVector<int> offsets; // offset to next tree level
unsigned int nextBinding; // next binding to use.
unsigned int nextLocation; // next location to use
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
};
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
void fixConstInit(const TSourceLoc&, const TString& identifier, TType& type, TIntermTyped*& initializer);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
void inheritGlobalDefaults(TQualifier& dst) const;
TVariable* makeInternalVariable(const char* name, const TType&) const;
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
TVariable* makeInternalVariable(const TString& name, const TType& type) const {
return makeInternalVariable(name.c_str(), type);
}
HLSL: Fix #805: Support cast of scalars to structures. Somewhat complex due to recognizing a general scalar, but not replicating it for each member to avoid side effects.
2017-04-04 17:47:42 +00:00
TIntermSymbol* makeInternalVariableNode(const TSourceLoc&, const char* name, const TType&) const;
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
TVariable* declareNonArray(const TSourceLoc&, const TString& identifier, const TType&, bool track);
void declareArray(const TSourceLoc&, const TString& identifier, const TType&, TSymbol*&, bool track);
Build: Fix a couple build issues.
2017-09-30 20:54:18 +00:00
TIntermNode* executeInitializer(const TSourceLoc&, TIntermTyped* initializer, TVariable* variable);
HLSL: Fix #805: Support cast of scalars to structures. Somewhat complex due to recognizing a general scalar, but not replicating it for each member to avoid side effects.
2017-04-04 17:47:42 +00:00
TIntermTyped* convertInitializerList(const TSourceLoc&, const TType&, TIntermTyped* initializer, TIntermTyped* scalarInit);
bool isScalarConstructor(const TIntermNode*);
Implement atomic ops, bit conversions, fix fwidth stage mask, fix saturate dest modifier.
2016-06-13 15:22:28 +00:00
TOperator mapAtomicOp(const TSourceLoc& loc, TOperator op, bool isImage);
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
HLSL: phase 2b: add l-value operator[] for RWTexture/RWBuffer This commit adds l-value support for RW texture and buffer objects. Supported are: - pre and post inc/decrement - function out parameters - op-assignments, such as *=, +-, etc. - result values from op-assignments. e.g, val=(MyRwTex[loc] *= 2); Not supported are: - Function inout parameters - multiple post-inc/decrement operators. E.g, MyRWTex[loc]++++;
2016-10-08 01:35:40 +00:00
// Return true if this node requires L-value conversion (e.g, to an imageStore).
bool shouldConvertLValue(const TIntermNode*) const;
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
// Array and struct flattening
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
TIntermTyped* flattenAccess(TIntermTyped* base, int member);
HLSL: Partially flatten hierarchies, instead of all or nothing. Fixes #1092. Allows arrays of opaques to keep arrayness, unless needed by uniform array flattening. Can handle assignments of mixed amounts of flattening.
2017-10-11 20:03:45 +00:00
TIntermTyped* flattenAccess(int uniqueId, int member, TStorageQualifier outerStorage, const TType&, int subset = -1);
HLSL: Fix #954: Track/access subsets of flattened multi-level aggregates. Works in conjuction with d1be754 to represent and modify a partially dereferenced multi-level flattened aggregate.
2017-10-04 19:27:43 +00:00
int findSubtreeOffset(const TIntermNode&) const;
int findSubtreeOffset(const TType&, int subset, const TVector<int>& offsets) const;
HLSL: Partially flatten hierarchies, instead of all or nothing. Fixes #1092. Allows arrays of opaques to keep arrayness, unless needed by uniform array flattening. Can handle assignments of mixed amounts of flattening.
2017-10-11 20:03:45 +00:00
bool shouldFlatten(const TType&, TStorageQualifier, bool topLevel) const;
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
bool wasFlattened(const TIntermTyped* node) const;
bool wasFlattened(int id) const { return flattenMap.find(id) != flattenMap.end(); }
HLSL: Include built-in processing for vertex input and fragment output flattening.
2017-08-09 02:02:21 +00:00
int addFlattenedMember(const TVariable&, const TType&, TFlattenData&, const TString& name, bool linkage,
const TQualifier& outerQualifier, const TArraySizes* builtInArraySizes);
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
SPV: When passing structs of opaque types, flatten and pass the members instead. This avoids either A) needing uniformConstant struct, or B) initializing a struct with opaque members, as writing them is not allowed.
2017-05-26 06:01:36 +00:00
// Structure splitting (splits interstage built-in types into its own struct)
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
void split(const TVariable&);
Non-functional HLSL: Factor out built-ins from splitting and related simplifications.
2017-08-08 05:40:05 +00:00
void splitBuiltIn(const TString& baseName, const TType& memberType, const TArraySizes*, const TQualifier&);
const TType& split(const TType& type, const TString& name, const TQualifier&);
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
bool wasSplit(const TIntermTyped* node) const;
HLSL: Correct which things flattening tracks for linkage, based on caller, not type. Includes related trackLinkage() code removal and name improvements.
2017-08-07 01:42:42 +00:00
bool wasSplit(int id) const { return splitNonIoVars.find(id) != splitNonIoVars.end(); }
TVariable* getSplitNonIoVar(int id) const;
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
void addPatchConstantInvocation();
HLSL: force textures to shadow modes from combined samplers Texture shadow mode must match the state of the sampler they are combined with. This change does that, both for the AST and the symbol table. Note that the texture cannot easily be *created* the right way, because this may not be known at that time. Instead, the texture is subsequently patched. This cannot work if a single texture is used with both a shadow and non-shadow sampler, so that case is detected and generates an error. This is permitted by the HLSL language, however. See #1073 discussion. Fixed one test source that was using a texture with both shadow and non-shadow samplers.
2017-09-27 15:12:51 +00:00
void fixTextureShadowModes();
HLSL: cast non-int types to uint on Load/Store indexes Some texture and SB operations can take non-integer indexes, which should be cast to integers before use if they are not already. This adds makeIntegerIndex() for the purpose. Int types are left alone. (This was done before for operator[], but needs to apply to some other things too, hence its extraction into common function now)
2017-04-20 15:00:56 +00:00
TIntermTyped* makeIntegerIndex(TIntermTyped*);
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: allow non-vec3 tessellation coordinate declarations HLSL requires vec2 tessellation coordinate declarations in some cases (e.g, isoline topology), where SPIR-V requires the TessCoord qualified builtin to be a vec3 in all cases. This alters the IO form of the variable to be a vec3, which will be copied to the shader's declared type if needed. This is not a validation; the shader type must be correct.
2017-04-05 17:03:02 +00:00
void fixBuiltInIoType(TType&);
HLSL: require tessellation factors to be fixed size arrays SPIR-V requires that tessellation factor arrays be size 4 (outer) or 2 (inner). HLSL allows other sizes such as 3, or even scalars. This commit converts between them by forcing the IO types to be the SPIR-V size, and allowing copies between the internal and IO types to handle these cases.
2017-03-18 00:51:05 +00:00
HLSL: Correct which things flattening tracks for linkage, based on caller, not type. Includes related trackLinkage() code removal and name improvements.
2017-08-07 01:42:42 +00:00
void flatten(const TVariable& variable, bool linkage);
HLSL: Include built-in processing for vertex input and fragment output flattening.
2017-08-09 02:02:21 +00:00
int flatten(const TVariable& variable, const TType&, TFlattenData&, TString name, bool linkage,
const TQualifier& outerQualifier, const TArraySizes* builtInArraySizes);
int flattenStruct(const TVariable& variable, const TType&, TFlattenData&, TString name, bool linkage,
const TQualifier& outerQualifier, const TArraySizes* builtInArraySizes);
int flattenArray(const TVariable& variable, const TType&, TFlattenData&, TString name, bool linkage,
const TQualifier& outerQualifier);
Flatten uniform arrays This checkin adds a --flatten-uniform-arrays option which can break uniform arrays of samplers, textures, or UBOs up into individual scalars named (e.g) myarray[0], myarray[1], etc. These appear as individual linkage objects. Code notes: - shouldFlatten internally calls shouldFlattenIO, and shouldFlattenUniform, but is the only flattening query directly called. - flattenVariable will handle structs or arrays (but not yet arrayed structs; this is tested an an error is generated). - There's some error checking around unhandled situations. E.g, flattening uniform arrays with initializer lists is not implemented. - This piggybacks on as much of the existing mechanism for struct flattening as it can. E.g, it uses the same flattenMap, and the same flattenAccess() method. - handleAssign() has been generalized to cope with either structs or arrays. - Extended test infrastructure to test flattening ability.
2016-09-16 19:26:37 +00:00
HLSL: Move to fine-grained control for defining input/output/uniform IO types.
2017-02-06 03:27:30 +00:00
bool hasUniform(const TQualifier& qualifier) const;
void clearUniform(TQualifier& qualifier);
bool isInputBuiltIn(const TQualifier& qualifier) const;
bool hasInput(const TQualifier& qualifier) const;
void correctOutput(TQualifier& qualifier);
bool isOutputBuiltIn(const TQualifier& qualifier) const;
bool hasOutput(const TQualifier& qualifier) const;
void correctInput(TQualifier& qualifier);
void correctUniform(TQualifier& qualifier);
void clearUniformInputOutput(TQualifier& qualifier);
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
// Test method names
bool isStructBufferMethod(const TString& name) const;
WIP: HLSL: add ability to pass struct buffers with counters to fns This modifies function parameter passing to pass the counter buffer associated with a struct buffer to a function as a hidden parameter. Similarly function declarations will have hidden parameters added to accept the associated counter buffers. There is a limitation: if a SB type may or may not have an associated counter, passing it as a function parameter will assume that it does, and the counter will appear in the linkage whether or not there is a counter method used on the object.
2017-04-27 17:22:32 +00:00
void counterBufferType(const TSourceLoc& loc, TType& type);
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
HLSL: add standard sample position return form of GetSamplePosition method Multisample textures support a GetSamplePosition() method intended to query positions given a sample index. This cannot be truly implemented in SPIR-V, but #753 requested returning standard positions for the 1..16 cases, which this PR adds. Anything besides that returns (0,0). If the standard positions are not used, this will be wrong. This should be revisited when there is a real query available.
2017-04-26 14:31:56 +00:00
// Return standard sample position array
TIntermConstantUnion* getSamplePosArray(int count);
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
TType* getStructBufferContentType(const TType& type) const;
bool isStructBufferType(const TType& type) const { return getStructBufferContentType(type) != nullptr; }
TIntermTyped* indexStructBufferContent(const TSourceLoc& loc, TIntermTyped* buffer) const;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
TIntermTyped* getStructBufferCounter(const TSourceLoc& loc, TIntermTyped* buffer);
WIP: HLSL: add ability to pass struct buffers with counters to fns This modifies function parameter passing to pass the counter buffer associated with a struct buffer to a function as a hidden parameter. Similarly function declarations will have hidden parameters added to accept the associated counter buffers. There is a limitation: if a SB type may or may not have an associated counter, passing it as a function parameter will assume that it does, and the counter will appear in the linkage whether or not there is a counter method used on the object.
2017-04-27 17:22:32 +00:00
TString getStructBuffCounterName(const TString&) const;
void addStructBuffArguments(const TSourceLoc& loc, TIntermAggregate*&);
void addStructBufferHiddenCounterParam(const TSourceLoc& loc, TParameter&, TIntermAggregate*&);
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
// Return true if this type is a reference. This is not currently a type method in case that's
// a language specific answer.
bool isReference(const TType& type) const { return isStructBufferType(type); }
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
// Return true if this a buffer type that has an associated counter buffer.
WIP: track declared builtin type [proposal] Marking as WIP since it might deserve discussion or at least explicit consideration. During type sanitization, the TQualifier's TBuiltInVariable type is lost. However, sometimes it's needed downstream. There were already two methods in use to track it through to places it was needed: one in the TParameter, and one in a map in the HlslParseContext used for structured buffers. The latter was going to be insufficient when SB types with counters are passed to user functions, and it's proving awkward to track the data to where it's needed. This PR holds a proposal: track the original declared builtin type in the TType, so it's trivially available where needed. This lets the other two mechanisms be removed (and they are in this PR). There's a side benefit of not losing certain types of information before the reflection interface. This PR is only that proposal, so it changes no test results. If it's acceptable, I'll use it for the last piece of SB counter functionality.
2017-04-24 01:44:28 +00:00
bool hasStructBuffCounter(const TType&) const;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
// Finalization step: remove unused buffer blocks from linkage (we don't know until the
// shader is entirely compiled)
void removeUnusedStructBufferCounters();
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
static bool isClipOrCullDistance(TBuiltInVariable);
static bool isClipOrCullDistance(const TQualifier& qual) { return isClipOrCullDistance(qual.builtIn); }
static bool isClipOrCullDistance(const TType& type) { return isClipOrCullDistance(type.getQualifier()); }
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
HLSL: handle split InputPatch templat type in patch constant functions InputPatch parameters to patch constant functions were not using the internal (temporary) variable type. That could cause validation errors if the input patch had a mixture of builtins and user qualified members. This uses the entry point's internal form. There is currently a limitation: if an InputPatch is used in a PCF, it must also have appeared in the main entry point's parameter list. That is not a limitation of HLSL. Currently that situation is detected and an "implemented" error results. The limitation can be addressed, but isn't yet in the current form of the PR.
2017-09-13 14:44:39 +00:00
// Find the patch constant function (issues error, returns nullptr if not found)
const TFunction* findPatchConstantFunction(const TSourceLoc& loc);
HLSL: Correct use of isPerVertexBuiltIn() to be isClipOrCullDistance(). This allows removal of isPerVertexBuiltIn(). It also leads to removal of addInterstageIoToLinkage(), which is no longer needed. Includes related name improvements.
2017-08-04 19:51:54 +00:00
// Pass through to base class after remembering built-in mappings.
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
using TParseContextBase::trackLinkage;
void trackLinkage(TSymbol& variable) override;
Mark an overriden method in a subclass with ‘override’.
2017-01-08 21:54:48 +00:00
void finish() override; // post-processing
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: HS return is arrayed to match SPIR-V semantics HLSL HS outputs a per ctrl point value, and the DS reads an array of that type. (It also has a per patch frequency). The per-ctrl-pt frequency is arrayed on just one side, as opposed to SPIR-V which is arrayed on both. To match semantics, the compiler creates an array behind the scenes and indexes it by invocation ID, assigning the HS return value to it.
2017-03-23 00:39:25 +00:00
// Linkage symbol helpers
HLSL: Correct use of isPerVertexBuiltIn() to be isClipOrCullDistance(). This allows removal of isPerVertexBuiltIn(). It also leads to removal of addInterstageIoToLinkage(), which is no longer needed. Includes related name improvements.
2017-08-04 19:51:54 +00:00
TIntermSymbol* findTessLinkageSymbol(TBuiltInVariable biType) const;
HLSL: HS return is arrayed to match SPIR-V semantics HLSL HS outputs a per ctrl point value, and the DS reads an array of that type. (It also has a per patch frequency). The per-ctrl-pt frequency is arrayed on just one side, as opposed to SPIR-V which is arrayed on both. To match semantics, the compiler creates an array behind the scenes and indexes it by invocation ID, assigning the HS return value to it.
2017-03-23 00:39:25 +00:00
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
// Current state of parsing
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
int annotationNestingLevel; // 0 if outside all annotations
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
HlslParseContext(HlslParseContext&);
HlslParseContext& operator=(HlslParseContext&);
static const int maxSamplerIndex = EsdNumDims * (EbtNumTypes * (2 * 2 * 2)); // see computeSamplerTypeIndex()
TQualifier globalBufferDefaults;
TQualifier globalUniformDefaults;
TQualifier globalInputDefaults;
TQualifier globalOutputDefaults;
TString currentCaller; // name of last function body entered (not valid when at global scope)
TIdSetType inductiveLoopIds;
TVector<TIntermTyped*> needsIndexLimitationChecking;
//
// Geometry shader input arrays:
// - array sizing is based on input primitive and/or explicit size
//
// Tessellation control output arrays:
// - array sizing is based on output layout(vertices=...) and/or explicit size
//
// Both:
// - array sizing is retroactive
// - built-in block redeclarations interact with this
//
// Design:
// - use a per-context "resize-list", a list of symbols whose array sizes
// can be fixed
//
// - the resize-list starts empty at beginning of user-shader compilation, it does
// not have built-ins in it
//
// - on built-in array use: copyUp() symbol and add it to the resize-list
//
// - on user array declaration: add it to the resize-list
//
// - on block redeclaration: copyUp() symbol and add it to the resize-list
// * note, that appropriately gives an error if redeclaring a block that
// was already used and hence already copied-up
//
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
// - on seeing a layout declaration that sizes the array, fix everything in the
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
// resize-list, giving errors for mismatch
//
// - on seeing an array size declaration, give errors on mismatch between it and previous
// array-sizing declarations
//
TVector<TSymbol*> ioArraySymbolResizeList;
HLSL: Flatten vertex input and fragment output structures. Vulkan can't handle structures into the vertex stage or out of the fragment stage.
2016-09-09 22:32:09 +00:00
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
TMap<int, TFlattenData> flattenMap;
HLSL: Move to fine-grained control for defining input/output/uniform IO types.
2017-02-06 03:27:30 +00:00
// IO-type map. Maps a pure symbol-table form of a structure-member list into
// each of the (up to) three kinds of IO, as each as different allowed decorations,
// but HLSL allows mixing all in the same structure.
struct tIoKinds {
TTypeList* input;
TTypeList* output;
TTypeList* uniform;
};
TMap<const TTypeList*, tIoKinds> ioTypeMap;
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
// Structure splitting data:
HLSL: Correct which things flattening tracks for linkage, based on caller, not type. Includes related trackLinkage() code removal and name improvements.
2017-08-07 01:42:42 +00:00
TMap<int, TVariable*> splitNonIoVars; // variables with the built-in interstage IO removed, indexed by unique ID.
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
// Structuredbuffer shared types. Typically there are only a few.
TVector<TType*> structBufferTypes;
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
// This tracks texture sample user structure return types. Only a limited number are supported, as
// may fit in TSampler::structReturnIndex.
TVector<TTypeList*> textureReturnStruct;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
TMap<TString, bool> structBufferCounter;
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
HLSL: Correct use of isPerVertexBuiltIn() to be isClipOrCullDistance(). This allows removal of isPerVertexBuiltIn(). It also leads to removal of addInterstageIoToLinkage(), which is no longer needed. Includes related name improvements.
2017-08-04 19:51:54 +00:00
// The built-in interstage IO map considers e.g, EvqPosition on input and output separately, so that we
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
// can build the linkage correctly if position appears on both sides. Otherwise, multiple positions
// are considered identical.
struct tInterstageIoData {
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
tInterstageIoData(TBuiltInVariable bi, TStorageQualifier q) :
builtIn(bi), storage(q) { }
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
TBuiltInVariable builtIn;
TStorageQualifier storage;
// ordering for maps
bool operator<(const tInterstageIoData d) const {
return (builtIn != d.builtIn) ? (builtIn < d.builtIn) : (storage < d.storage);
}
};
HLSL: Correct use of isPerVertexBuiltIn() to be isClipOrCullDistance(). This allows removal of isPerVertexBuiltIn(). It also leads to removal of addInterstageIoToLinkage(), which is no longer needed. Includes related name improvements.
2017-08-04 19:51:54 +00:00
TMap<tInterstageIoData, TVariable*> splitBuiltIns; // split built-ins, indexed by built-in type.
HLSL: handle split InputPatch templat type in patch constant functions InputPatch parameters to patch constant functions were not using the internal (temporary) variable type. That could cause validation errors if the input patch had a mixture of builtins and user qualified members. This uses the entry point's internal form. There is currently a limitation: if an InputPatch is used in a PCF, it must also have appeared in the main entry point's parameter list. That is not a limitation of HLSL. Currently that situation is detected and an "implemented" error results. The limitation can be addressed, but isn't yet in the current form of the PR.
2017-09-13 14:44:39 +00:00
TVariable* inputPatch; // input patch is special for PCF: it's the only non-builtin PCF input,
// and is handled as a pseudo-builtin.
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
HLSL: Flatten a return struct from an entry point and assign locations after flattening. Locations now get assigned in order, but skipping built-ins, which can be done post flattening.
2016-09-16 07:44:43 +00:00
unsigned int nextInLocation;
unsigned int nextOutLocation;
allow renaming of shader entry point when creating SPIR-V Use "--source-entrypoint name" on the command line, or the TShader::setSourceEntryPoint(char*) API. When the name given to the above interfaces is detected in the shader source, it will be renamed to the entry point name supplied to the -e option or the TShader::setEntryPoint() method.
2016-10-31 21:13:43 +00:00
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
TFunction* entryPointFunction;
TIntermNode* entryPointFunctionBody;
TString patchConstantFunctionName; // hull shader patch constant function name, from function level attribute.
HLSL: Correct use of isPerVertexBuiltIn() to be isClipOrCullDistance(). This allows removal of isPerVertexBuiltIn(). It also leads to removal of addInterstageIoToLinkage(), which is no longer needed. Includes related name improvements.
2017-08-04 19:51:54 +00:00
TMap<TBuiltInVariable, TSymbol*> builtInTessLinkageSymbols; // used for tessellation, finding declared built-ins
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: non-static member functions: track and find active anonymous 'this' scopes and members. Thanks to @steve-lunarg for his input and discussions on handling member functions.
2017-03-22 05:56:40 +00:00
TVector<TString> currentTypePrefix; // current scoping prefix for nested structures
TVector<TVariable*> implicitThisStack; // currently active 'this' variables for nested structures
HLSL: fix GS implementation for EP wrapping The prior implementation of GS did not work with the new EP wrapping architecture. This fixes it: the Append() method now looks up the actual output rather than the internal sanitized temporary type, and writes to that.
2017-03-30 02:01:13 +00:00
TVariable* gsStreamOutput; // geometry shader stream outputs, for emit (Append method)
HLSL: add .mips[][] operator for texture types This implements mytex.mips[mip][coord] for texture types. There is some error testing, but not comprehensive. The constructs can be nested, e.g in this case the inner .mips is parsed before the completion of the outer [][] operator. tx.mips[tx.mips[a][b].x][c]
2017-05-12 23:14:31 +00:00
HLSL: add geometry stage support for clip/cull distance Changes: (1) Allow clip/cull builtins as both input and output in the same shader stage. Previously, not enough data was tracked to handle this. (2) Handle the extra array dimension in GS inputs. The synthesized external variable can now be created with the extra array dimension if needed, and the form conversion code is able to handle it as well. For example, both of these GS inputs would result in the same synthesized external type: triangle in float4 clip[3] : SV_ClipDistance triangle in float2 clip[3][2] : SV_ClipDistance In the second case, the inner array dimension packs with the 2-vector of floats into an array[4], which there is an array[3] of due to the triangle geometry.
2017-08-28 20:02:19 +00:00
TVariable* clipDistanceOutput; // synthesized clip distance out variable (shader might have >1)
TVariable* cullDistanceOutput; // synthesized cull distance out variable (shader might have >1)
TVariable* clipDistanceInput; // synthesized clip distance in variable (shader might have >1)
TVariable* cullDistanceInput; // synthesized cull distance in variable (shader might have >1)
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
static const int maxClipCullRegs = 2;
HLSL: add geometry stage support for clip/cull distance Changes: (1) Allow clip/cull builtins as both input and output in the same shader stage. Previously, not enough data was tracked to handle this. (2) Handle the extra array dimension in GS inputs. The synthesized external variable can now be created with the extra array dimension if needed, and the form conversion code is able to handle it as well. For example, both of these GS inputs would result in the same synthesized external type: triangle in float4 clip[3] : SV_ClipDistance triangle in float2 clip[3][2] : SV_ClipDistance In the second case, the inner array dimension packs with the 2-vector of floats into an array[4], which there is an array[3] of due to the triangle geometry.
2017-08-28 20:02:19 +00:00
std::array<int, maxClipCullRegs> clipSemanticNSizeIn; // vector, indexed by clip semantic ID
std::array<int, maxClipCullRegs> cullSemanticNSizeIn; // vector, indexed by cull semantic ID
std::array<int, maxClipCullRegs> clipSemanticNSizeOut; // vector, indexed by clip semantic ID
std::array<int, maxClipCullRegs> cullSemanticNSizeOut; // vector, indexed by cull semantic ID
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: add .mips[][] operator for texture types This implements mytex.mips[mip][coord] for texture types. There is some error testing, but not comprehensive. The constructs can be nested, e.g in this case the inner .mips is parsed before the completion of the outer [][] operator. tx.mips[tx.mips[a][b].x][c]
2017-05-12 23:14:31 +00:00
// This tracks the first (mip level) argument to the .mips[][] operator. Since this can be nested as
// in tx.mips[tx.mips[0][1].x][2], we need a stack. We also track the TSourceLoc for error reporting
// purposes.
struct tMipsOperatorData {
tMipsOperatorData(TSourceLoc l, TIntermTyped* m) : loc(l), mipLevel(m) { }
TSourceLoc loc;
TIntermTyped* mipLevel;
};
TVector<tMipsOperatorData> mipsOperatorMipArg;
HLSL: force textures to shadow modes from combined samplers Texture shadow mode must match the state of the sampler they are combined with. This change does that, both for the AST and the symbol table. Note that the texture cannot easily be *created* the right way, because this may not be known at that time. Instead, the texture is subsequently patched. This cannot work if a single texture is used with both a shadow and non-shadow sampler, so that case is detected and generates an error. This is permitted by the HLSL language, however. See #1073 discussion. Fixed one test source that was using a texture with both shadow and non-shadow samplers.
2017-09-27 15:12:51 +00:00
HLSL: split textures used for both shadow and non-shadow modes A single texture can statically appear in code mixed with a shadow sampler and a non-shadow sampler. This would be create invalid SPIR-V, unless one of them is provably dead. The previous detection of this happened before DCE, so some shaders would trigger the error even though they wouldn't after DCE. To handle that case, this PR splits the texture into two: one with each mode. It sets "needsLegalization" (if that happens for any texture) to warn that this shader will need post-compilation legalization. If the texture is only used with one of the two modes, behavior is as it was before.
2017-10-05 22:25:52 +00:00
// A texture object may be used with shadow and non-shadow samplers, but both may not be
// alive post-DCE in the same shader. We do not know at compilation time which are alive: that's
// only known post-DCE. If a texture is used both ways, we create two textures, and
// leave the elimiation of one to the optimizer. This maps the shader variant to
// the shadow variant.
//
// This can be removed if and when the texture shadow code in
// HlslParseContext::handleSamplerTextureCombine is removed.
struct tShadowTextureSymbols {
tShadowTextureSymbols() { symId.fill(-1); }
void set(bool shadow, int id) { symId[int(shadow)] = id; }
int get(bool shadow) const { return symId[int(shadow)]; }
// True if this texture has been seen with both shadow and non-shadow modes
bool overloaded() const { return symId[0] != -1 && symId[1] != -1; }
bool isShadowId(int id) const { return symId[1] == id; }
private:
std::array<int, 2> symId;
};
TMap<int, tShadowTextureSymbols*> textureShadowVariant;
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
};
HLSL: Correct use of isPerVertexBuiltIn() to be isClipOrCullDistance(). This allows removal of isPerVertexBuiltIn(). It also leads to removal of addInterstageIoToLinkage(), which is no longer needed. Includes related name improvements.
2017-08-04 19:51:54 +00:00
// This is the prefix we use for built-in methods to avoid namespace collisions with
HLSL: use prefix for builtin functions names to avoid namespace collisions It would have been possible for globally scoped user functions to collide with builtin method names. This adds a prefix to avoid polluting the namespace. Ideally this would be an invalid character to use in user identifiers, but as that requires changing the scanner, for the moment it's an unlikely yet valid prefix.
2017-03-20 00:12:37 +00:00
// global scope user functions.
// TODO: this would be better as a nonparseable character, but that would
// require changing the scanner.
#define BUILTIN_PREFIX "__BI_"
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
} // end namespace glslang
#endif // HLSL_PARSE_INCLUDED_
Reference in New Issue Copy Permalink