Source code

Revision control

Copy as Markdown

Other Tools

//
// Copyright 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.
//
// UseInterfaceBlockFields.cpp: insert statements to reference all members in InterfaceBlock list at
// the beginning of main. This is to work around a Mac driver that treats unused standard/shared
// uniform blocks as inactive.
#include "compiler/translator/tree_ops/gl/UseInterfaceBlockFields.h"
#include "compiler/translator/Compiler.h"
#include "compiler/translator/IntermNode.h"
#include "compiler/translator/SymbolTable.h"
#include "compiler/translator/tree_util/FindMain.h"
#include "compiler/translator/tree_util/IntermNode_util.h"
#include "compiler/translator/util.h"
namespace sh
{
namespace
{
void AddNodeUseStatements(TIntermTyped *node, TIntermSequence *sequence)
{
if (node->isArray())
{
for (unsigned int i = 0u; i < node->getOutermostArraySize(); ++i)
{
TIntermBinary *element =
new TIntermBinary(EOpIndexDirect, node->deepCopy(), CreateIndexNode(i));
AddNodeUseStatements(element, sequence);
}
}
else
{
sequence->insert(sequence->begin(), node);
}
}
void AddFieldUseStatements(const ShaderVariable &var,
TIntermSequence *sequence,
const TSymbolTable &symbolTable)
{
ASSERT(var.name.find_last_of('[') == std::string::npos);
TIntermSymbol *symbol = ReferenceGlobalVariable(ImmutableString(var.name), symbolTable);
AddNodeUseStatements(symbol, sequence);
}
void InsertUseCode(const InterfaceBlock &block, TIntermTyped *blockNode, TIntermSequence *sequence)
{
for (unsigned int i = 0; i < block.fields.size(); ++i)
{
TIntermBinary *element = new TIntermBinary(EOpIndexDirectInterfaceBlock,
blockNode->deepCopy(), CreateIndexNode(i));
sequence->insert(sequence->begin(), element);
}
}
void InsertUseCode(TIntermSequence *sequence,
const InterfaceBlockList &blocks,
const TSymbolTable &symbolTable)
{
for (const auto &block : blocks)
{
if (block.instanceName.empty())
{
for (const auto &var : block.fields)
{
AddFieldUseStatements(var, sequence, symbolTable);
}
}
else if (block.arraySize > 0u)
{
TIntermSymbol *arraySymbol =
ReferenceGlobalVariable(ImmutableString(block.instanceName), symbolTable);
for (unsigned int i = 0u; i < block.arraySize; ++i)
{
TIntermBinary *elementSymbol =
new TIntermBinary(EOpIndexDirect, arraySymbol->deepCopy(), CreateIndexNode(i));
InsertUseCode(block, elementSymbol, sequence);
}
}
else
{
TIntermSymbol *blockSymbol =
ReferenceGlobalVariable(ImmutableString(block.instanceName), symbolTable);
InsertUseCode(block, blockSymbol, sequence);
}
}
}
} // namespace
bool UseInterfaceBlockFields(TCompiler *compiler,
TIntermBlock *root,
const InterfaceBlockList &blocks,
const TSymbolTable &symbolTable)
{
TIntermBlock *mainBody = FindMainBody(root);
InsertUseCode(mainBody->getSequence(), blocks, symbolTable);
return compiler->validateAST(root);
}
} // namespace sh