|
|
@@ -37,9 +37,11 @@
|
|
|
|
|
|
#include "../Include/Common.h"
|
|
|
#include "../Include/InfoSink.h"
|
|
|
+#include "../Include/Types.h"
|
|
|
|
|
|
#include "gl_types.h"
|
|
|
#include "iomapper.h"
|
|
|
+#include "SymbolTable.h"
|
|
|
|
|
|
//
|
|
|
// Map IO bindings.
|
|
|
@@ -82,17 +84,17 @@ public:
|
|
|
// If a global is being visited, then we should also traverse it incase it's evaluation
|
|
|
// ends up visiting inputs we want to tag as live
|
|
|
else if (base->getQualifier().storage == EvqGlobal)
|
|
|
- addGlobalReference(base->getName());
|
|
|
+ addGlobalReference(base->getAccessName());
|
|
|
|
|
|
if (target) {
|
|
|
TVarEntryInfo ent = {base->getId(), base, ! traverseAll};
|
|
|
ent.stage = intermediate.getStage();
|
|
|
TVarLiveMap::iterator at = target->find(
|
|
|
- ent.symbol->getName()); // std::lower_bound(target->begin(), target->end(), ent, TVarEntryInfo::TOrderById());
|
|
|
+ ent.symbol->getAccessName()); // std::lower_bound(target->begin(), target->end(), ent, TVarEntryInfo::TOrderById());
|
|
|
if (at != target->end() && at->second.id == ent.id)
|
|
|
at->second.live = at->second.live || ! traverseAll; // update live state
|
|
|
else
|
|
|
- (*target)[ent.symbol->getName()] = ent;
|
|
|
+ (*target)[ent.symbol->getAccessName()] = ent;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -125,7 +127,8 @@ public:
|
|
|
return;
|
|
|
|
|
|
TVarEntryInfo ent = { base->getId() };
|
|
|
- TVarLiveMap::const_iterator at = source->find(base->getName());
|
|
|
+ // Fix a defect, when block has no instance name, we need to find its block name
|
|
|
+ TVarLiveMap::const_iterator at = source->find(base->getAccessName());
|
|
|
if (at == source->end())
|
|
|
return;
|
|
|
|
|
|
@@ -181,7 +184,7 @@ struct TNotifyInOutAdaptor
|
|
|
|
|
|
inline void operator()(std::pair<const TString, TVarEntryInfo>& entKey)
|
|
|
{
|
|
|
- resolver.notifyInOut(stage, entKey.second);
|
|
|
+ resolver.notifyInOut(entKey.second.stage, entKey.second);
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
@@ -189,12 +192,13 @@ private:
|
|
|
};
|
|
|
|
|
|
struct TResolverUniformAdaptor {
|
|
|
- TResolverUniformAdaptor(EShLanguage s, TIoMapResolver& r, TInfoSink& i, bool& e)
|
|
|
+ TResolverUniformAdaptor(EShLanguage s, TIoMapResolver& r, TVarLiveMap* uniform[EShLangCount], TInfoSink& i, bool& e)
|
|
|
: stage(s)
|
|
|
, resolver(r)
|
|
|
, infoSink(i)
|
|
|
, error(e)
|
|
|
{
|
|
|
+ memcpy(uniformVarMap, uniform, EShLangCount * (sizeof(TVarLiveMap*)));
|
|
|
}
|
|
|
|
|
|
inline void operator()(std::pair<const TString, TVarEntryInfo>& entKey) {
|
|
|
@@ -206,9 +210,9 @@ struct TResolverUniformAdaptor {
|
|
|
ent.newIndex = -1;
|
|
|
const bool isValid = resolver.validateBinding(stage, ent);
|
|
|
if (isValid) {
|
|
|
- resolver.resolveBinding(stage, ent);
|
|
|
- resolver.resolveSet(stage, ent);
|
|
|
- resolver.resolveUniformLocation(stage, ent);
|
|
|
+ resolver.resolveBinding(ent.stage, ent);
|
|
|
+ resolver.resolveSet(ent.stage, ent);
|
|
|
+ resolver.resolveUniformLocation(ent.stage, ent);
|
|
|
|
|
|
if (ent.newBinding != -1) {
|
|
|
if (ent.newBinding >= int(TQualifier::layoutBindingEnd)) {
|
|
|
@@ -217,6 +221,17 @@ struct TResolverUniformAdaptor {
|
|
|
infoSink.info.message(EPrefixInternalError, err.c_str());
|
|
|
error = true;
|
|
|
}
|
|
|
+
|
|
|
+ if (ent.symbol->getQualifier().hasBinding()) {
|
|
|
+ for (uint32_t idx = EShLangVertex; idx < EShLangCount; ++idx) {
|
|
|
+ if (idx == ent.stage || uniformVarMap[idx] == nullptr)
|
|
|
+ continue;
|
|
|
+ auto entKey2 = uniformVarMap[idx]->find(entKey.first);
|
|
|
+ if (entKey2 != uniformVarMap[idx]->end()) {
|
|
|
+ entKey2->second.newBinding = ent.newBinding;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
if (ent.newSet != -1) {
|
|
|
if (ent.newSet >= int(TQualifier::layoutSetEnd)) {
|
|
|
@@ -225,6 +240,16 @@ struct TResolverUniformAdaptor {
|
|
|
infoSink.info.message(EPrefixInternalError, err.c_str());
|
|
|
error = true;
|
|
|
}
|
|
|
+ if (ent.symbol->getQualifier().hasSet()) {
|
|
|
+ for (uint32_t idx = EShLangVertex; idx < EShLangCount; ++idx) {
|
|
|
+ if ((idx == stage) || (uniformVarMap[idx] == nullptr))
|
|
|
+ continue;
|
|
|
+ auto entKey2 = uniformVarMap[idx]->find(entKey.first);
|
|
|
+ if (entKey2 != uniformVarMap[idx]->end()) {
|
|
|
+ entKey2->second.newSet = ent.newSet;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
} else {
|
|
|
TString errorMsg = "Invalid binding: " + entKey.first;
|
|
|
@@ -239,7 +264,7 @@ struct TResolverUniformAdaptor {
|
|
|
TIoMapResolver& resolver;
|
|
|
TInfoSink& infoSink;
|
|
|
bool& error;
|
|
|
-
|
|
|
+ TVarLiveMap* uniformVarMap[EShLangCount];
|
|
|
private:
|
|
|
TResolverUniformAdaptor& operator=(TResolverUniformAdaptor&) = delete;
|
|
|
};
|
|
|
@@ -261,7 +286,7 @@ struct TResolverInOutAdaptor {
|
|
|
ent.newBinding = -1;
|
|
|
ent.newSet = -1;
|
|
|
ent.newIndex = -1;
|
|
|
- const bool isValid = resolver.validateInOut(stage, ent);
|
|
|
+ const bool isValid = resolver.validateInOut(ent.stage, ent);
|
|
|
if (isValid) {
|
|
|
resolver.resolveInOutLocation(stage, ent);
|
|
|
resolver.resolveInOutComponent(stage, ent);
|
|
|
@@ -296,17 +321,116 @@ private:
|
|
|
struct TSymbolValidater
|
|
|
{
|
|
|
TSymbolValidater(TIoMapResolver& r, TInfoSink& i, TVarLiveMap* in[EShLangCount], TVarLiveMap* out[EShLangCount],
|
|
|
- TVarLiveMap* uniform[EShLangCount], bool& hadError)
|
|
|
+ TVarLiveMap* uniform[EShLangCount], bool& hadError, EProfile profile, int version)
|
|
|
: preStage(EShLangCount)
|
|
|
, currentStage(EShLangCount)
|
|
|
, nextStage(EShLangCount)
|
|
|
, resolver(r)
|
|
|
, infoSink(i)
|
|
|
, hadError(hadError)
|
|
|
+ , profile(profile)
|
|
|
+ , version(version)
|
|
|
{
|
|
|
memcpy(inVarMaps, in, EShLangCount * (sizeof(TVarLiveMap*)));
|
|
|
memcpy(outVarMaps, out, EShLangCount * (sizeof(TVarLiveMap*)));
|
|
|
memcpy(uniformVarMap, uniform, EShLangCount * (sizeof(TVarLiveMap*)));
|
|
|
+
|
|
|
+ std::map<TString, TString> anonymousMemberMap;
|
|
|
+ std::vector<TRange> usedUniformLocation;
|
|
|
+ std::vector<TString> usedUniformName;
|
|
|
+ usedUniformLocation.clear();
|
|
|
+ usedUniformName.clear();
|
|
|
+ for (int i = 0; i < EShLangCount; i++) {
|
|
|
+ if (uniformVarMap[i]) {
|
|
|
+ for (auto uniformVar : *uniformVarMap[i])
|
|
|
+ {
|
|
|
+ TIntermSymbol* pSymbol = uniformVar.second.symbol;
|
|
|
+ TQualifier qualifier = uniformVar.second.symbol->getQualifier();
|
|
|
+ TString symbolName = pSymbol->getAccessName();
|
|
|
+
|
|
|
+ // All the uniform needs multi-stage location check (block/default)
|
|
|
+ int uniformLocation = qualifier.layoutLocation;
|
|
|
+
|
|
|
+ if (uniformLocation != TQualifier::layoutLocationEnd) {
|
|
|
+ // Total size of current uniform, could be block, struct or other types.
|
|
|
+ int size = TIntermediate::computeTypeUniformLocationSize(pSymbol->getType());
|
|
|
+
|
|
|
+ TRange locationRange(uniformLocation, uniformLocation + size - 1);
|
|
|
+
|
|
|
+ // Combine location and component ranges
|
|
|
+ int overlapLocation = -1;
|
|
|
+ bool diffLocation = false;
|
|
|
+
|
|
|
+ // Check for collisions, except for vertex inputs on desktop targeting OpenGL
|
|
|
+ overlapLocation = checkLocationOverlap(locationRange, usedUniformLocation, symbolName, usedUniformName, diffLocation);
|
|
|
+
|
|
|
+ // Overlap locations of uniforms, regardless of components (multi stages)
|
|
|
+ if (overlapLocation == -1) {
|
|
|
+ usedUniformLocation.push_back(locationRange);
|
|
|
+ usedUniformName.push_back(symbolName);
|
|
|
+ }
|
|
|
+ else if (overlapLocation >= 0) {
|
|
|
+ if (diffLocation == true) {
|
|
|
+ TString err = ("Uniform location should be equal for same uniforms: " +std::to_string(overlapLocation)).c_str();
|
|
|
+ infoSink.info.message(EPrefixInternalError, err.c_str());
|
|
|
+ hadError = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ TString err = ("Uniform location overlaps across stages: " + std::to_string(overlapLocation)).c_str();
|
|
|
+ infoSink.info.message(EPrefixInternalError, err.c_str());
|
|
|
+ hadError = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if ((uniformVar.second.symbol->getBasicType() == EbtBlock) &&
|
|
|
+ IsAnonymous(uniformVar.second.symbol->getName()))
|
|
|
+ {
|
|
|
+ auto blockType = uniformVar.second.symbol->getType().getStruct();
|
|
|
+ for (size_t memberIdx = 0; memberIdx < blockType->size(); ++memberIdx) {
|
|
|
+ auto memberName = (*blockType)[memberIdx].type->getFieldName();
|
|
|
+ if (anonymousMemberMap.find(memberName) != anonymousMemberMap.end())
|
|
|
+ {
|
|
|
+ if (anonymousMemberMap[memberName] != uniformVar.second.symbol->getType().getTypeName())
|
|
|
+ {
|
|
|
+ TString err = "Invalid block member name: " + memberName;
|
|
|
+ infoSink.info.message(EPrefixInternalError, err.c_str());
|
|
|
+ hadError = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ anonymousMemberMap[memberName] = uniformVar.second.symbol->getType().getTypeName();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (hadError)
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // In case we need to new an intermediate, which costs too much
|
|
|
+ int checkLocationOverlap(const TRange& locationRange, std::vector<TRange>& usedUniformLocation, const TString symbolName, std::vector<TString>& usedUniformName, bool& diffLocation)
|
|
|
+ {
|
|
|
+ for (size_t r = 0; r < usedUniformLocation.size(); ++r) {
|
|
|
+ if (usedUniformName[r] == symbolName) {
|
|
|
+ diffLocation = true;
|
|
|
+ return (usedUniformLocation[r].start == locationRange.start &&
|
|
|
+ usedUniformLocation[r].last == locationRange.last)
|
|
|
+ ? -2 : std::max(locationRange.start, usedUniformLocation[r].start);
|
|
|
+ }
|
|
|
+ if (locationRange.overlap(usedUniformLocation[r])) {
|
|
|
+ // there is a collision; pick one
|
|
|
+ return std::max(locationRange.start, usedUniformLocation[r].start);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return -1; // no collision
|
|
|
}
|
|
|
|
|
|
inline void operator()(std::pair<const TString, TVarEntryInfo>& entKey) {
|
|
|
@@ -339,11 +463,24 @@ struct TSymbolValidater
|
|
|
// validate stage in;
|
|
|
if (preStage == EShLangCount)
|
|
|
return;
|
|
|
- if (name == "gl_PerVertex")
|
|
|
+ if (TSymbolTable::isBuiltInSymbol(base->getId()))
|
|
|
return;
|
|
|
if (outVarMaps[preStage] != nullptr) {
|
|
|
auto ent2 = outVarMaps[preStage]->find(name);
|
|
|
+ uint32_t location = base->getType().getQualifier().layoutLocation;
|
|
|
+ if (ent2 == outVarMaps[preStage]->end() &&
|
|
|
+ location != glslang::TQualifier::layoutLocationEnd) {
|
|
|
+ for (auto var = outVarMaps[preStage]->begin(); var != ent2; var++) {
|
|
|
+ if (var->second.symbol->getType().getQualifier().layoutLocation == location) {
|
|
|
+ ent2 = var;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
if (ent2 != outVarMaps[preStage]->end()) {
|
|
|
+ auto& type1 = base->getType();
|
|
|
+ auto& type2 = ent2->second.symbol->getType();
|
|
|
+ hadError = hadError || typeCheck(&type1, &type2, name.c_str(), false);
|
|
|
if (ent2->second.symbol->getType().getQualifier().isArrayedIo(preStage)) {
|
|
|
TType subType(ent2->second.symbol->getType(), 0);
|
|
|
subType.appendMangledName(mangleName2);
|
|
|
@@ -351,23 +488,49 @@ struct TSymbolValidater
|
|
|
else {
|
|
|
ent2->second.symbol->getType().appendMangledName(mangleName2);
|
|
|
}
|
|
|
- if (mangleName1 == mangleName2)
|
|
|
+
|
|
|
+ if (mangleName1 == mangleName2) {
|
|
|
+ // For ES 3.0 only, other versions have no such restrictions
|
|
|
+ // According to ES 3.0 spec: The type and presence of the interpolation qualifiers and
|
|
|
+ // storage qualifiers of variables with the same name declared in all linked shaders must
|
|
|
+ // match, otherwise the link command will fail.
|
|
|
+ if (profile == EEsProfile && version == 300) {
|
|
|
+ // Don't need to check smooth qualifier, as it uses the default interpolation mode
|
|
|
+ if (ent1.stage == EShLangFragment && type1.isBuiltIn() == false) {
|
|
|
+ if (type1.getQualifier().flat != type2.getQualifier().flat ||
|
|
|
+ type1.getQualifier().nopersp != type2.getQualifier().nopersp) {
|
|
|
+ TString err = "Interpolation qualifier mismatch : " + entKey.first;
|
|
|
+ infoSink.info.message(EPrefixInternalError, err.c_str());
|
|
|
+ hadError = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
return;
|
|
|
+ }
|
|
|
else {
|
|
|
TString err = "Invalid In/Out variable type : " + entKey.first;
|
|
|
infoSink.info.message(EPrefixInternalError, err.c_str());
|
|
|
hadError = true;
|
|
|
}
|
|
|
}
|
|
|
+ else if (!base->getType().isBuiltIn()) {
|
|
|
+ // According to spec: A link error is generated if any statically referenced input variable
|
|
|
+ // or block does not have a matching output
|
|
|
+ if (profile == EEsProfile && ent1.live) {
|
|
|
+ hadError = true;
|
|
|
+ TString errorStr = name + ": not been declare as a output variable in pre shader stage.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ }
|
|
|
+ }
|
|
|
return;
|
|
|
}
|
|
|
} else if (base->getQualifier().storage == EvqVaryingOut) {
|
|
|
// validate stage out;
|
|
|
if (nextStage == EShLangCount)
|
|
|
return;
|
|
|
- if (name == "gl_PerVertex")
|
|
|
+ if (TSymbolTable::isBuiltInSymbol(base->getId()))
|
|
|
return;
|
|
|
- if (outVarMaps[nextStage] != nullptr) {
|
|
|
+ if (inVarMaps[nextStage] != nullptr) {
|
|
|
auto ent2 = inVarMaps[nextStage]->find(name);
|
|
|
if (ent2 != inVarMaps[nextStage]->end()) {
|
|
|
if (ent2->second.symbol->getType().getQualifier().isArrayedIo(nextStage)) {
|
|
|
@@ -400,11 +563,50 @@ struct TSymbolValidater
|
|
|
hadError = true;
|
|
|
}
|
|
|
mangleName2.clear();
|
|
|
+
|
|
|
+ // validate instance name of blocks
|
|
|
+ if (hadError == false &&
|
|
|
+ base->getType().getBasicType() == EbtBlock &&
|
|
|
+ IsAnonymous(base->getName()) != IsAnonymous(ent2->second.symbol->getName())) {
|
|
|
+ TString err = "Matched uniform block names must also either all be lacking "
|
|
|
+ "an instance name or all having an instance name: " + entKey.first;
|
|
|
+ infoSink.info.message(EPrefixInternalError, err.c_str());
|
|
|
+ hadError = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ // validate uniform block member qualifier and member names
|
|
|
+ auto& type1 = base->getType();
|
|
|
+ auto& type2 = ent2->second.symbol->getType();
|
|
|
+ if (hadError == false && base->getType().getBasicType() == EbtBlock) {
|
|
|
+ hadError = hadError || typeCheck(&type1, &type2, name.c_str(), true);
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ hadError = hadError || typeCheck(&type1, &type2, name.c_str(), false);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else if (base->getBasicType() == EbtBlock)
|
|
|
+ {
|
|
|
+ if (IsAnonymous(base->getName()))
|
|
|
+ {
|
|
|
+ // The name of anonymous block member can't same with default uniform variable.
|
|
|
+ auto blockType1 = base->getType().getStruct();
|
|
|
+ for (size_t memberIdx = 0; memberIdx < blockType1->size(); ++memberIdx) {
|
|
|
+ auto memberName = (*blockType1)[memberIdx].type->getFieldName();
|
|
|
+ if (uniformVarMap[i]->find(memberName) != uniformVarMap[i]->end())
|
|
|
+ {
|
|
|
+ TString err = "Invalid Uniform variable name : " + memberName;
|
|
|
+ infoSink.info.message(EPrefixInternalError, err.c_str());
|
|
|
+ hadError = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
+
|
|
|
TVarLiveMap *inVarMaps[EShLangCount], *outVarMaps[EShLangCount], *uniformVarMap[EShLangCount];
|
|
|
// Use for mark pre stage, to get more interface symbol information.
|
|
|
EShLanguage preStage, currentStage, nextStage;
|
|
|
@@ -412,9 +614,118 @@ struct TSymbolValidater
|
|
|
TIoMapResolver& resolver;
|
|
|
TInfoSink& infoSink;
|
|
|
bool& hadError;
|
|
|
+ EProfile profile;
|
|
|
+ int version;
|
|
|
|
|
|
private:
|
|
|
TSymbolValidater& operator=(TSymbolValidater&) = delete;
|
|
|
+
|
|
|
+ bool qualifierCheck(const TType* const type1, const TType* const type2, const std::string& name, bool isBlock)
|
|
|
+ {
|
|
|
+ bool hasError = false;
|
|
|
+ const TQualifier& qualifier1 = type1->getQualifier();
|
|
|
+ const TQualifier& qualifier2 = type2->getQualifier();
|
|
|
+
|
|
|
+ if (((isBlock == false) &&
|
|
|
+ (type1->getQualifier().storage == EvqUniform && type2->getQualifier().storage == EvqUniform)) ||
|
|
|
+ (type1->getQualifier().storage == EvqGlobal && type2->getQualifier().storage == EvqGlobal)) {
|
|
|
+ if (qualifier1.precision != qualifier2.precision) {
|
|
|
+ hasError = true;
|
|
|
+ std::string errorStr = name + ": have precision conflict cross stage.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ }
|
|
|
+ if (qualifier1.hasFormat() && qualifier2.hasFormat()) {
|
|
|
+ if (qualifier1.layoutFormat != qualifier2.layoutFormat) {
|
|
|
+ hasError = true;
|
|
|
+ std::string errorStr = name + ": have layout format conflict cross stage.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ }
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (isBlock == true) {
|
|
|
+ if (qualifier1.layoutPacking != qualifier2.layoutPacking) {
|
|
|
+ hasError = true;
|
|
|
+ std::string errorStr = name + ": have layoutPacking conflict cross stage.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ }
|
|
|
+ if (qualifier1.layoutMatrix != qualifier2.layoutMatrix) {
|
|
|
+ hasError = true;
|
|
|
+ std::string errorStr = name + ": have layoutMatrix conflict cross stage.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ }
|
|
|
+ if (qualifier1.layoutOffset != qualifier2.layoutOffset) {
|
|
|
+ hasError = true;
|
|
|
+ std::string errorStr = name + ": have layoutOffset conflict cross stage.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ }
|
|
|
+ if (qualifier1.layoutAlign != qualifier2.layoutAlign) {
|
|
|
+ hasError = true;
|
|
|
+ std::string errorStr = name + ": have layoutAlign conflict cross stage.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ return hasError;
|
|
|
+ }
|
|
|
+
|
|
|
+ bool typeCheck(const TType* const type1, const TType* const type2, const std::string& name, bool isBlock)
|
|
|
+ {
|
|
|
+ bool hasError = false;
|
|
|
+ if (!(type1->isStruct() && type2->isStruct())) {
|
|
|
+ hasError = hasError || qualifierCheck(type1, type2, name, isBlock);
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ if (type1->getBasicType() == EbtBlock && type2->getBasicType() == EbtBlock)
|
|
|
+ isBlock = true;
|
|
|
+ const TTypeList* typeList1 = type1->getStruct();
|
|
|
+ const TTypeList* typeList2 = type2->getStruct();
|
|
|
+
|
|
|
+ std::string newName = name;
|
|
|
+ size_t memberCount = typeList1->size();
|
|
|
+ size_t index2 = 0;
|
|
|
+ for (size_t index = 0; index < memberCount; index++, index2++) {
|
|
|
+ // Skip inactive member
|
|
|
+ if (typeList1->at(index).type->getBasicType() == EbtVoid)
|
|
|
+ continue;
|
|
|
+ while (index2 < typeList2->size() && typeList2->at(index2).type->getBasicType() == EbtVoid) {
|
|
|
+ ++index2;
|
|
|
+ }
|
|
|
+
|
|
|
+ // TypeList1 has more members in list
|
|
|
+ if (index2 == typeList2->size()) {
|
|
|
+ std::string errorStr = name + ": struct mismatch.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ hasError = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (typeList1->at(index).type->getFieldName() != typeList2->at(index2).type->getFieldName()) {
|
|
|
+ std::string errorStr = name + ": member name mismatch.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ hasError = true;
|
|
|
+ }
|
|
|
+ else {
|
|
|
+ newName = typeList1->at(index).type->getFieldName().c_str();
|
|
|
+ }
|
|
|
+ hasError = hasError || typeCheck(typeList1->at(index).type, typeList2->at(index2).type, newName, isBlock);
|
|
|
+ }
|
|
|
+
|
|
|
+ while (index2 < typeList2->size())
|
|
|
+ {
|
|
|
+ // TypeList2 has more members
|
|
|
+ if (typeList2->at(index2).type->getBasicType() != EbtVoid) {
|
|
|
+ std::string errorStr = name + ": struct mismatch.";
|
|
|
+ infoSink.info.message(EPrefixError, errorStr.c_str());
|
|
|
+ hasError = true;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ ++index2;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return hasError;
|
|
|
+ }
|
|
|
};
|
|
|
|
|
|
struct TSlotCollector {
|
|
|
@@ -500,7 +811,7 @@ int TDefaultIoResolverBase::resolveSet(EShLanguage /*stage*/, TVarEntryInfo& ent
|
|
|
|
|
|
int TDefaultIoResolverBase::resolveUniformLocation(EShLanguage /*stage*/, TVarEntryInfo& ent) {
|
|
|
const TType& type = ent.symbol->getType();
|
|
|
- const char* name = ent.symbol->getName().c_str();
|
|
|
+ const char* name = ent.symbol->getAccessName().c_str();
|
|
|
// kick out of not doing this
|
|
|
if (! doAutoLocationMapping()) {
|
|
|
return ent.newLocation = -1;
|
|
|
@@ -609,7 +920,7 @@ TDefaultGlslIoResolver::TDefaultGlslIoResolver(const TIntermediate& intermediate
|
|
|
|
|
|
int TDefaultGlslIoResolver::resolveInOutLocation(EShLanguage stage, TVarEntryInfo& ent) {
|
|
|
const TType& type = ent.symbol->getType();
|
|
|
- const TString& name = getAccessName(ent.symbol);
|
|
|
+ const TString& name = ent.symbol->getAccessName();
|
|
|
if (currentStage != stage) {
|
|
|
preStage = currentStage;
|
|
|
currentStage = stage;
|
|
|
@@ -693,7 +1004,7 @@ int TDefaultGlslIoResolver::resolveInOutLocation(EShLanguage stage, TVarEntryInf
|
|
|
|
|
|
int TDefaultGlslIoResolver::resolveUniformLocation(EShLanguage /*stage*/, TVarEntryInfo& ent) {
|
|
|
const TType& type = ent.symbol->getType();
|
|
|
- const TString& name = getAccessName(ent.symbol);
|
|
|
+ const TString& name = ent.symbol->getAccessName();
|
|
|
// kick out of not doing this
|
|
|
if (! doAutoLocationMapping()) {
|
|
|
return ent.newLocation = -1;
|
|
|
@@ -764,7 +1075,7 @@ int TDefaultGlslIoResolver::resolveUniformLocation(EShLanguage /*stage*/, TVarEn
|
|
|
|
|
|
int TDefaultGlslIoResolver::resolveBinding(EShLanguage /*stage*/, TVarEntryInfo& ent) {
|
|
|
const TType& type = ent.symbol->getType();
|
|
|
- const TString& name = getAccessName(ent.symbol);
|
|
|
+ const TString& name = ent.symbol->getAccessName();
|
|
|
// On OpenGL arrays of opaque types take a separate binding for each element
|
|
|
int numBindings = intermediate.getSpv().openGl != 0 && type.isSizedArray() ? type.getCumulativeArraySize() : 1;
|
|
|
TResourceType resource = getResourceType(type);
|
|
|
@@ -839,7 +1150,7 @@ void TDefaultGlslIoResolver::endCollect(EShLanguage /*stage*/) {
|
|
|
|
|
|
void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink& infoSink) {
|
|
|
const TType& type = ent.symbol->getType();
|
|
|
- const TString& name = getAccessName(ent.symbol);
|
|
|
+ const TString& name = ent.symbol->getAccessName();
|
|
|
TStorageQualifier storage = type.getQualifier().storage;
|
|
|
EShLanguage stage(EShLangCount);
|
|
|
switch (storage) {
|
|
|
@@ -899,7 +1210,7 @@ void TDefaultGlslIoResolver::reserverStorageSlot(TVarEntryInfo& ent, TInfoSink&
|
|
|
|
|
|
void TDefaultGlslIoResolver::reserverResourceSlot(TVarEntryInfo& ent, TInfoSink& infoSink) {
|
|
|
const TType& type = ent.symbol->getType();
|
|
|
- const TString& name = getAccessName(ent.symbol);
|
|
|
+ const TString& name = ent.symbol->getAccessName();
|
|
|
int resource = getResourceType(type);
|
|
|
if (type.getQualifier().hasBinding()) {
|
|
|
TVarSlotMap& varSlotMap = resourceSlotMap[resource];
|
|
|
@@ -922,13 +1233,6 @@ void TDefaultGlslIoResolver::reserverResourceSlot(TVarEntryInfo& ent, TInfoSink&
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-const TString& TDefaultGlslIoResolver::getAccessName(const TIntermSymbol* symbol)
|
|
|
-{
|
|
|
- return symbol->getBasicType() == EbtBlock ?
|
|
|
- symbol->getType().getTypeName() :
|
|
|
- symbol->getName();
|
|
|
-}
|
|
|
-
|
|
|
//TDefaultGlslIoResolver end
|
|
|
|
|
|
/*
|
|
|
@@ -1117,25 +1421,23 @@ bool TIoMapper::addStage(EShLanguage stage, TIntermediate& intermediate, TInfoSi
|
|
|
}
|
|
|
|
|
|
// sort entries by priority. see TVarEntryInfo::TOrderByPriority for info.
|
|
|
- std::for_each(inVarMap.begin(), inVarMap.end(),
|
|
|
- [&inVector](TVarLivePair p) { inVector.push_back(p); });
|
|
|
+ for (auto& var : inVarMap) { inVector.push_back(var); }
|
|
|
std::sort(inVector.begin(), inVector.end(), [](const TVarLivePair& p1, const TVarLivePair& p2) -> bool {
|
|
|
return TVarEntryInfo::TOrderByPriority()(p1.second, p2.second);
|
|
|
});
|
|
|
- std::for_each(outVarMap.begin(), outVarMap.end(),
|
|
|
- [&outVector](TVarLivePair p) { outVector.push_back(p); });
|
|
|
+ for (auto& var : outVarMap) { outVector.push_back(var); }
|
|
|
std::sort(outVector.begin(), outVector.end(), [](const TVarLivePair& p1, const TVarLivePair& p2) -> bool {
|
|
|
return TVarEntryInfo::TOrderByPriority()(p1.second, p2.second);
|
|
|
});
|
|
|
- std::for_each(uniformVarMap.begin(), uniformVarMap.end(),
|
|
|
- [&uniformVector](TVarLivePair p) { uniformVector.push_back(p); });
|
|
|
+ for (auto& var : uniformVarMap) { uniformVector.push_back(var); }
|
|
|
std::sort(uniformVector.begin(), uniformVector.end(), [](const TVarLivePair& p1, const TVarLivePair& p2) -> bool {
|
|
|
return TVarEntryInfo::TOrderByPriority()(p1.second, p2.second);
|
|
|
});
|
|
|
bool hadError = false;
|
|
|
+ TVarLiveMap* dummyUniformVarMap[EShLangCount] = {};
|
|
|
TNotifyInOutAdaptor inOutNotify(stage, *resolver);
|
|
|
TNotifyUniformAdaptor uniformNotify(stage, *resolver);
|
|
|
- TResolverUniformAdaptor uniformResolve(stage, *resolver, infoSink, hadError);
|
|
|
+ TResolverUniformAdaptor uniformResolve(stage, *resolver, dummyUniformVarMap, infoSink, hadError);
|
|
|
TResolverInOutAdaptor inOutResolve(stage, *resolver, infoSink, hadError);
|
|
|
resolver->beginNotifications(stage);
|
|
|
std::for_each(inVector.begin(), inVector.end(), inOutNotify);
|
|
|
@@ -1143,22 +1445,22 @@ bool TIoMapper::addStage(EShLanguage stage, TIntermediate& intermediate, TInfoSi
|
|
|
std::for_each(uniformVector.begin(), uniformVector.end(), uniformNotify);
|
|
|
resolver->endNotifications(stage);
|
|
|
resolver->beginResolve(stage);
|
|
|
- std::for_each(inVector.begin(), inVector.end(), inOutResolve);
|
|
|
+ for (auto& var : inVector) { inOutResolve(var); }
|
|
|
std::for_each(inVector.begin(), inVector.end(), [&inVarMap](TVarLivePair p) {
|
|
|
- auto at = inVarMap.find(p.second.symbol->getName());
|
|
|
- if (at != inVarMap.end())
|
|
|
+ auto at = inVarMap.find(p.second.symbol->getAccessName());
|
|
|
+ if (at != inVarMap.end() && p.second.id == at->second.id)
|
|
|
at->second = p.second;
|
|
|
});
|
|
|
- std::for_each(outVector.begin(), outVector.end(), inOutResolve);
|
|
|
+ for (auto& var : outVector) { inOutResolve(var); }
|
|
|
std::for_each(outVector.begin(), outVector.end(), [&outVarMap](TVarLivePair p) {
|
|
|
- auto at = outVarMap.find(p.second.symbol->getName());
|
|
|
- if (at != outVarMap.end())
|
|
|
+ auto at = outVarMap.find(p.second.symbol->getAccessName());
|
|
|
+ if (at != outVarMap.end() && p.second.id == at->second.id)
|
|
|
at->second = p.second;
|
|
|
});
|
|
|
std::for_each(uniformVector.begin(), uniformVector.end(), uniformResolve);
|
|
|
std::for_each(uniformVector.begin(), uniformVector.end(), [&uniformVarMap](TVarLivePair p) {
|
|
|
- auto at = uniformVarMap.find(p.second.symbol->getName());
|
|
|
- if (at != uniformVarMap.end())
|
|
|
+ auto at = uniformVarMap.find(p.second.symbol->getAccessName());
|
|
|
+ if (at != uniformVarMap.end() && p.second.id == at->second.id)
|
|
|
at->second = p.second;
|
|
|
});
|
|
|
resolver->endResolve(stage);
|
|
|
@@ -1174,9 +1476,14 @@ bool TIoMapper::addStage(EShLanguage stage, TIntermediate& intermediate, TInfoSi
|
|
|
//
|
|
|
// Returns false if the input is too malformed to do this.
|
|
|
bool TGlslIoMapper::addStage(EShLanguage stage, TIntermediate& intermediate, TInfoSink& infoSink, TIoMapResolver* resolver) {
|
|
|
+ bool somethingToDo = !intermediate.getResourceSetBinding().empty() ||
|
|
|
+ intermediate.getAutoMapBindings() ||
|
|
|
+ intermediate.getAutoMapLocations();
|
|
|
+
|
|
|
+ // Profile and version are use for symbol validate.
|
|
|
+ profile = intermediate.getProfile();
|
|
|
+ version = intermediate.getVersion();
|
|
|
|
|
|
- bool somethingToDo = ! intermediate.getResourceSetBinding().empty() || intermediate.getAutoMapBindings() ||
|
|
|
- intermediate.getAutoMapLocations();
|
|
|
// Restrict the stricter condition to further check 'somethingToDo' only if 'somethingToDo' has not been set, reduce
|
|
|
// unnecessary or insignificant for-loop operation after 'somethingToDo' have been true.
|
|
|
for (int res = 0; (res < EResCount && !somethingToDo); ++res) {
|
|
|
@@ -1236,31 +1543,30 @@ bool TGlslIoMapper::doMap(TIoMapResolver* resolver, TInfoSink& infoSink) {
|
|
|
resolver->endResolve(EShLangCount);
|
|
|
if (!hadError) {
|
|
|
//Resolve uniform location, ubo/ssbo/opaque bindings across stages
|
|
|
- TResolverUniformAdaptor uniformResolve(EShLangCount, *resolver, infoSink, hadError);
|
|
|
+ TResolverUniformAdaptor uniformResolve(EShLangCount, *resolver, uniformVarMap, infoSink, hadError);
|
|
|
TResolverInOutAdaptor inOutResolve(EShLangCount, *resolver, infoSink, hadError);
|
|
|
- TSymbolValidater symbolValidater(*resolver, infoSink, inVarMaps, outVarMaps, uniformVarMap, hadError);
|
|
|
+ TSymbolValidater symbolValidater(*resolver, infoSink, inVarMaps,
|
|
|
+ outVarMaps, uniformVarMap, hadError, profile, version);
|
|
|
TVarLiveVector uniformVector;
|
|
|
resolver->beginResolve(EShLangCount);
|
|
|
for (int stage = EShLangVertex; stage < EShLangCount; stage++) {
|
|
|
if (inVarMaps[stage] != nullptr) {
|
|
|
inOutResolve.setStage(EShLanguage(stage));
|
|
|
- std::for_each(inVarMaps[stage]->begin(), inVarMaps[stage]->end(), symbolValidater);
|
|
|
- std::for_each(inVarMaps[stage]->begin(), inVarMaps[stage]->end(), inOutResolve);
|
|
|
- std::for_each(outVarMaps[stage]->begin(), outVarMaps[stage]->end(), symbolValidater);
|
|
|
- std::for_each(outVarMaps[stage]->begin(), outVarMaps[stage]->end(), inOutResolve);
|
|
|
+ for (auto& var : *(inVarMaps[stage])) { symbolValidater(var); }
|
|
|
+ for (auto& var : *(inVarMaps[stage])) { inOutResolve(var); }
|
|
|
+ for (auto& var : *(outVarMaps[stage])) { symbolValidater(var); }
|
|
|
+ for (auto& var : *(outVarMaps[stage])) { inOutResolve(var); }
|
|
|
}
|
|
|
if (uniformVarMap[stage] != nullptr) {
|
|
|
uniformResolve.setStage(EShLanguage(stage));
|
|
|
- // sort entries by priority. see TVarEntryInfo::TOrderByPriority for info.
|
|
|
- std::for_each(uniformVarMap[stage]->begin(), uniformVarMap[stage]->end(),
|
|
|
- [&uniformVector](TVarLivePair p) { uniformVector.push_back(p); });
|
|
|
+ for (auto& var : *(uniformVarMap[stage])) { uniformVector.push_back(var); }
|
|
|
}
|
|
|
}
|
|
|
std::sort(uniformVector.begin(), uniformVector.end(), [](const TVarLivePair& p1, const TVarLivePair& p2) -> bool {
|
|
|
return TVarEntryInfo::TOrderByPriority()(p1.second, p2.second);
|
|
|
});
|
|
|
- std::for_each(uniformVector.begin(), uniformVector.end(), symbolValidater);
|
|
|
- std::for_each(uniformVector.begin(), uniformVector.end(), uniformResolve);
|
|
|
+ for (auto& var : uniformVector) { symbolValidater(var); }
|
|
|
+ for (auto& var : uniformVector) { uniformResolve(var); }
|
|
|
std::sort(uniformVector.begin(), uniformVector.end(), [](const TVarLivePair& p1, const TVarLivePair& p2) -> bool {
|
|
|
return TVarEntryInfo::TOrderByPriority()(p1.second, p2.second);
|
|
|
});
|
|
|
@@ -1269,14 +1575,18 @@ bool TGlslIoMapper::doMap(TIoMapResolver* resolver, TInfoSink& infoSink) {
|
|
|
if (intermediates[stage] != nullptr) {
|
|
|
// traverse each stage, set new location to each input/output and unifom symbol, set new binding to
|
|
|
// ubo, ssbo and opaque symbols
|
|
|
- TVarLiveMap** pUniformVarMap = uniformVarMap;
|
|
|
+ TVarLiveMap** pUniformVarMap = uniformResolve.uniformVarMap;
|
|
|
std::for_each(uniformVector.begin(), uniformVector.end(), [pUniformVarMap, stage](TVarLivePair p) {
|
|
|
- auto at = pUniformVarMap[stage]->find(p.second.symbol->getName());
|
|
|
- if (at != pUniformVarMap[stage]->end())
|
|
|
+ auto at = pUniformVarMap[stage]->find(p.second.symbol->getAccessName());
|
|
|
+ if (at != pUniformVarMap[stage]->end() && at->second.id == p.second.id){
|
|
|
+ int resolvedBinding = at->second.newBinding;
|
|
|
at->second = p.second;
|
|
|
+ if (resolvedBinding > 0)
|
|
|
+ at->second.newBinding = resolvedBinding;
|
|
|
+ }
|
|
|
});
|
|
|
TVarSetTraverser iter_iomap(*intermediates[stage], *inVarMaps[stage], *outVarMaps[stage],
|
|
|
- *uniformVarMap[stage]);
|
|
|
+ *uniformResolve.uniformVarMap[stage]);
|
|
|
intermediates[stage]->getTreeRoot()->traverse(&iter_iomap);
|
|
|
}
|
|
|
}
|
Бранимир Караџић