| // |
| // Copyright (c) 2002-2016 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // ValidateMultiviewWebGL.cpp: |
| // Validate the AST according to rules in the WEBGL_multiview extension spec. Only covers those |
| // rules not already covered in ParseContext. |
| // |
| |
| #include "compiler/translator/ValidateMultiviewWebGL.h" |
| |
| #include <array> |
| |
| #include "angle_gl.h" |
| #include "compiler/translator/Diagnostics.h" |
| #include "compiler/translator/FindSymbolNode.h" |
| #include "compiler/translator/IntermNode.h" |
| #include "compiler/translator/SymbolTable.h" |
| |
| namespace sh |
| { |
| |
| namespace |
| { |
| |
| class ValidateMultiviewTraverser : public TIntermTraverser |
| { |
| public: |
| // Check for errors and write error messages to diagnostics. Returns true if there are no |
| // errors. |
| static bool validate(TIntermBlock *root, |
| GLenum shaderType, |
| const TSymbolTable &symbolTable, |
| int shaderVersion, |
| bool multiview2, |
| TDiagnostics *diagnostics); |
| |
| bool isValid() { return mValid; } |
| |
| protected: |
| void visitSymbol(TIntermSymbol *node) override; |
| bool visitBinary(Visit visit, TIntermBinary *node) override; |
| bool visitUnary(Visit visit, TIntermUnary *node) override; |
| bool visitIfElse(Visit visit, TIntermIfElse *node) override; |
| bool visitAggregate(Visit visit, TIntermAggregate *node) override; |
| |
| private: |
| ValidateMultiviewTraverser(GLenum shaderType, |
| const TSymbolTable &symbolTable, |
| int shaderVersion, |
| bool multiview2, |
| TDiagnostics *diagnostics); |
| |
| static bool IsGLPosition(TIntermNode *node); |
| static bool IsGLViewIDOVR(TIntermNode *node); |
| static bool IsSimpleAssignmentToGLPositionX(TIntermBinary *node); |
| static bool IsSimpleAssignmentToGLPosition(TIntermBinary *node); |
| |
| void validateAndTraverseViewIDConditionalBlock(TIntermBlock *block, const char *token); |
| |
| bool mValid; |
| bool mMultiview2; |
| GLenum mShaderType; |
| const TSymbolTable &mSymbolTable; |
| const int mShaderVersion; |
| |
| bool mInsideViewIDConditional; // Only set if mMultiview2 is false. |
| bool mInsideRestrictedAssignment; |
| bool mGLPositionAllowed; |
| bool mViewIDOVRAllowed; |
| |
| TDiagnostics *mDiagnostics; |
| }; |
| |
| bool ValidateMultiviewTraverser::validate(TIntermBlock *root, |
| GLenum shaderType, |
| const TSymbolTable &symbolTable, |
| int shaderVersion, |
| bool multiview2, |
| TDiagnostics *diagnostics) |
| { |
| ValidateMultiviewTraverser validate(shaderType, symbolTable, shaderVersion, multiview2, |
| diagnostics); |
| ASSERT(root); |
| root->traverse(&validate); |
| return validate.isValid(); |
| } |
| |
| ValidateMultiviewTraverser::ValidateMultiviewTraverser(GLenum shaderType, |
| const TSymbolTable &symbolTable, |
| int shaderVersion, |
| bool multiview2, |
| TDiagnostics *diagnostics) |
| : TIntermTraverser(true, true, true), |
| mValid(true), |
| mMultiview2(multiview2), |
| mShaderType(shaderType), |
| mSymbolTable(symbolTable), |
| mShaderVersion(shaderVersion), |
| mInsideViewIDConditional(false), |
| mInsideRestrictedAssignment(false), |
| mGLPositionAllowed(multiview2), |
| mViewIDOVRAllowed(multiview2), |
| mDiagnostics(diagnostics) |
| { |
| } |
| |
| bool ValidateMultiviewTraverser::IsGLPosition(TIntermNode *node) |
| { |
| TIntermSymbol *symbolNode = node->getAsSymbolNode(); |
| return (symbolNode && symbolNode->getName().getString() == "gl_Position"); |
| } |
| |
| bool ValidateMultiviewTraverser::IsGLViewIDOVR(TIntermNode *node) |
| { |
| TIntermSymbol *symbolNode = node->getAsSymbolNode(); |
| return (symbolNode && symbolNode->getName().getString() == "gl_ViewID_OVR"); |
| } |
| |
| bool ValidateMultiviewTraverser::IsSimpleAssignmentToGLPositionX(TIntermBinary *node) |
| { |
| if (node->getOp() == EOpAssign) |
| { |
| TIntermSwizzle *leftAsSwizzle = node->getLeft()->getAsSwizzleNode(); |
| if (leftAsSwizzle && IsGLPosition(leftAsSwizzle->getOperand()) && |
| leftAsSwizzle->offsetsMatch(0)) |
| { |
| return true; |
| } |
| TIntermBinary *leftAsBinary = node->getLeft()->getAsBinaryNode(); |
| if (leftAsBinary && leftAsBinary->getOp() == EOpIndexDirect && |
| IsGLPosition(leftAsBinary->getLeft()) && |
| leftAsBinary->getRight()->getAsConstantUnion()->getIConst(0) == 0) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| bool ValidateMultiviewTraverser::IsSimpleAssignmentToGLPosition(TIntermBinary *node) |
| { |
| if (node->getOp() == EOpAssign) |
| { |
| if (IsGLPosition(node->getLeft())) |
| { |
| return true; |
| } |
| TIntermSwizzle *leftAsSwizzle = node->getLeft()->getAsSwizzleNode(); |
| if (leftAsSwizzle && IsGLPosition(leftAsSwizzle->getOperand())) |
| { |
| return true; |
| } |
| TIntermBinary *leftAsBinary = node->getLeft()->getAsBinaryNode(); |
| if (leftAsBinary && leftAsBinary->getOp() == EOpIndexDirect && |
| IsGLPosition(leftAsBinary->getLeft())) |
| { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| void ValidateMultiviewTraverser::visitSymbol(TIntermSymbol *node) |
| { |
| if (IsGLPosition(node) && !mGLPositionAllowed) |
| { |
| ASSERT(!mMultiview2); |
| mDiagnostics->error(node->getLine(), |
| "Disallowed use of gl_Position when using OVR_multiview", |
| "gl_Position"); |
| mValid = false; |
| } |
| else if (IsGLViewIDOVR(node) && !mViewIDOVRAllowed) |
| { |
| ASSERT(!mMultiview2); |
| mDiagnostics->error(node->getLine(), |
| "Disallowed use of gl_ViewID_OVR when using OVR_multiview", |
| "gl_ViewID_OVR"); |
| mValid = false; |
| } |
| else if (!mMultiview2 && mShaderType == GL_FRAGMENT_SHADER) |
| { |
| std::array<const char *, 3> disallowedFragmentShaderSymbols{ |
| {"gl_FragCoord", "gl_PointCoord", "gl_FrontFacing"}}; |
| for (auto disallowedSymbol : disallowedFragmentShaderSymbols) |
| { |
| if (node->getSymbol() == disallowedSymbol) |
| { |
| mDiagnostics->error( |
| node->getLine(), |
| "Disallowed use of a built-in variable when using OVR_multiview", |
| disallowedSymbol); |
| mValid = false; |
| } |
| } |
| } |
| } |
| |
| bool ValidateMultiviewTraverser::visitBinary(Visit visit, TIntermBinary *node) |
| { |
| if (!mMultiview2 && mShaderType == GL_VERTEX_SHADER) |
| { |
| if (visit == PreVisit) |
| { |
| ASSERT(!mInsideViewIDConditional || mInsideRestrictedAssignment); |
| if (node->isAssignment()) |
| { |
| if (mInsideRestrictedAssignment) |
| { |
| mDiagnostics->error(node->getLine(), |
| "Disallowed assignment inside assignment to gl_Position.x " |
| "when using OVR_multiview", |
| GetOperatorString(node->getOp())); |
| mValid = false; |
| } |
| else if (IsSimpleAssignmentToGLPositionX(node) && |
| FindSymbolNode(node->getRight(), "gl_ViewID_OVR", EbtUInt)) |
| { |
| if (!getParentNode()->getAsBlock()) |
| { |
| mDiagnostics->error(node->getLine(), |
| "Disallowed use of assignment to gl_Position.x " |
| "when using OVR_multiview", |
| "="); |
| mValid = false; |
| } |
| mInsideRestrictedAssignment = true; |
| mViewIDOVRAllowed = true; |
| node->getRight()->traverse(this); |
| mInsideRestrictedAssignment = false; |
| mViewIDOVRAllowed = false; |
| return false; |
| } |
| else if (IsSimpleAssignmentToGLPosition(node)) |
| { |
| node->getRight()->traverse(this); |
| return false; |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| bool ValidateMultiviewTraverser::visitUnary(Visit visit, TIntermUnary *node) |
| { |
| if (visit == PreVisit && !mMultiview2 && mInsideRestrictedAssignment) |
| { |
| if (node->isAssignment()) |
| { |
| mDiagnostics->error(node->getLine(), |
| "Disallowed unary operator inside assignment to gl_Position.x when " |
| "using OVR_multiview", |
| GetOperatorString(node->getOp())); |
| mValid = false; |
| } |
| } |
| return true; |
| } |
| |
| void ValidateMultiviewTraverser::validateAndTraverseViewIDConditionalBlock(TIntermBlock *block, |
| const char *token) |
| { |
| if (block->getSequence()->size() > 1) |
| { |
| mDiagnostics->error(block->getLine(), |
| "Only one assignment to gl_Position allowed inside if block dependent " |
| "on gl_ViewID_OVR when using OVR_multiview", |
| token); |
| mValid = false; |
| } |
| else if (block->getSequence()->size() == 1) |
| { |
| TIntermBinary *assignment = block->getSequence()->at(0)->getAsBinaryNode(); |
| if (assignment && IsSimpleAssignmentToGLPositionX(assignment)) |
| { |
| mInsideRestrictedAssignment = true; |
| assignment->getRight()->traverse(this); |
| mInsideRestrictedAssignment = false; |
| } |
| else |
| { |
| mDiagnostics->error(block->getLine(), |
| "Only one assignment to gl_Position.x allowed inside if block " |
| "dependent on gl_ViewID_OVR when using OVR_multiview", |
| token); |
| mValid = false; |
| } |
| } |
| } |
| |
| bool ValidateMultiviewTraverser::visitIfElse(Visit visit, TIntermIfElse *node) |
| { |
| if (!mMultiview2 && mShaderType == GL_VERTEX_SHADER) |
| { |
| ASSERT(visit == PreVisit); |
| |
| // Check if the if statement refers to gl_ViewID_OVR and if it does so correctly |
| TIntermBinary *binaryCondition = node->getCondition()->getAsBinaryNode(); |
| bool conditionIsAllowedComparisonWithViewID = false; |
| if (binaryCondition && binaryCondition->getOp() == EOpEqual) |
| { |
| conditionIsAllowedComparisonWithViewID = |
| IsGLViewIDOVR(binaryCondition->getLeft()) && |
| binaryCondition->getRight()->getAsConstantUnion() && |
| binaryCondition->getRight()->getQualifier() == EvqConst; |
| if (!conditionIsAllowedComparisonWithViewID) |
| { |
| conditionIsAllowedComparisonWithViewID = |
| IsGLViewIDOVR(binaryCondition->getRight()) && |
| binaryCondition->getLeft()->getAsConstantUnion() && |
| binaryCondition->getLeft()->getQualifier() == EvqConst; |
| } |
| } |
| if (conditionIsAllowedComparisonWithViewID) |
| { |
| mInsideViewIDConditional = true; |
| if (node->getTrueBlock()) |
| { |
| validateAndTraverseViewIDConditionalBlock(node->getTrueBlock(), "if"); |
| } |
| else |
| { |
| mDiagnostics->error(node->getLine(), "Expected assignment to gl_Position.x", "if"); |
| } |
| if (node->getFalseBlock()) |
| { |
| validateAndTraverseViewIDConditionalBlock(node->getFalseBlock(), "else"); |
| } |
| mInsideViewIDConditional = false; |
| } |
| else |
| { |
| node->getCondition()->traverse(this); |
| if (node->getTrueBlock()) |
| { |
| node->getTrueBlock()->traverse(this); |
| } |
| if (node->getFalseBlock()) |
| { |
| node->getFalseBlock()->traverse(this); |
| } |
| } |
| return false; |
| } |
| return true; |
| } |
| |
| bool ValidateMultiviewTraverser::visitAggregate(Visit visit, TIntermAggregate *node) |
| { |
| if (visit == PreVisit && !mMultiview2 && mInsideRestrictedAssignment) |
| { |
| // Check if the node is an user-defined function call or if an l-value is required, or if |
| // there are possible visible side effects, such as image writes. |
| if (node->getOp() == EOpCallFunctionInAST) |
| { |
| mDiagnostics->error(node->getLine(), |
| "Disallowed user defined function call inside assignment to " |
| "gl_Position.x when using OVR_multiview", |
| GetOperatorString(node->getOp())); |
| mValid = false; |
| } |
| else if (node->getOp() == EOpCallBuiltInFunction && |
| node->getFunctionSymbolInfo()->getName() == "imageStore") |
| { |
| // TODO(oetuaho@nvidia.com): Record which built-in functions have side effects in |
| // the symbol info instead. |
| mDiagnostics->error(node->getLine(), |
| "Disallowed function call with side effects inside assignment " |
| "to gl_Position.x when using OVR_multiview", |
| GetOperatorString(node->getOp())); |
| mValid = false; |
| } |
| else if (!node->isConstructor()) |
| { |
| TFunction *builtInFunc = static_cast<TFunction *>( |
| mSymbolTable.findBuiltIn(node->getSymbolTableMangledName(), mShaderVersion)); |
| for (size_t paramIndex = 0u; paramIndex < builtInFunc->getParamCount(); ++paramIndex) |
| { |
| TQualifier qualifier = builtInFunc->getParam(paramIndex).type->getQualifier(); |
| if (qualifier == EvqOut || qualifier == EvqInOut) |
| { |
| mDiagnostics->error(node->getLine(), |
| "Disallowed use of a function with an out parameter inside " |
| "assignment to gl_Position.x when using OVR_multiview", |
| GetOperatorString(node->getOp())); |
| mValid = false; |
| } |
| } |
| } |
| } |
| return true; |
| } |
| |
| } // anonymous namespace |
| |
| bool ValidateMultiviewWebGL(TIntermBlock *root, |
| GLenum shaderType, |
| const TSymbolTable &symbolTable, |
| int shaderVersion, |
| bool multiview2, |
| TDiagnostics *diagnostics) |
| { |
| if (shaderType == GL_VERTEX_SHADER && !FindSymbolNode(root, "gl_ViewID_OVR", EbtUInt)) |
| { |
| return true; |
| } |
| return ValidateMultiviewTraverser::validate(root, shaderType, symbolTable, shaderVersion, |
| multiview2, diagnostics); |
| } |
| |
| } // namespace sh |
