ADD_TYPE(ISampler2D);
+ ADD_TYPE(Image2D);
+ ADD_TYPE(IImage2D);
+
ADD_TYPE(GSampler1D);
ADD_TYPE(GSampler2D);
ADD_TYPE(GSampler3D);
, fSampler1DArrayShadow_Type(new Type("sampler1DArrayShadow"))
, fSampler2DArrayShadow_Type(new Type("sampler2DArrayShadow"))
, fSamplerCubeArrayShadow_Type(new Type("samplerCubeArrayShadow"))
+
// Related to below FIXME, gsampler*s don't currently expand to cover integer case.
, fISampler2D_Type(new Type("isampler2D", SpvDim2D, false, false, false, true))
+
+ // FIXME express these as "gimage2D" that expand to image2D, iimage2D, and uimage2D.
+ , fImage2D_Type(new Type("image2D", SpvDim2D, false, false, false, true))
+ , fIImage2D_Type(new Type("iimage2D", SpvDim2D, false, false, false, true))
+
// FIXME figure out what we're supposed to do with the gsampler et al. types)
, fGSampler1D_Type(new Type("$gsampler1D", static_type(*fSampler1D_Type)))
, fGSampler2D_Type(new Type("$gsampler2D", static_type(*fSampler2D_Type)))
const std::unique_ptr<Type> fSampler2DArrayShadow_Type;
const std::unique_ptr<Type> fSamplerCubeArrayShadow_Type;
+
const std::unique_ptr<Type> fISampler2D_Type;
+ const std::unique_ptr<Type> fImage2D_Type;
+ const std::unique_ptr<Type> fIImage2D_Type;
+
const std::unique_ptr<Type> fGSampler1D_Type;
const std::unique_ptr<Type> fGSampler2D_Type;
const std::unique_ptr<Type> fGSampler3D_Type;
this->write(" = ");
this->writeExpression(*var.fValue, kTopLevel_Precedence);
}
+ if (!fFoundImageDecl && var.fVar->fType == *fContext.fImage2D_Type) {
+ if (fCaps.imageLoadStoreExtensionString()) {
+ fHeader << "#extension " << fCaps.imageLoadStoreExtensionString() << " : require\n";
+ }
+ fFoundImageDecl = true;
+ }
}
this->write(";");
}
std::vector<const Type*> fWrittenStructs;
// true if we have run into usages of dFdx / dFdy
bool fFoundDerivatives = false;
+ bool fFoundImageDecl = false;
};
}
bool originUpperLeft = false;
bool overrideCoverage = false;
bool blendSupportAllEquations = false;
+ ASTLayout::Format format = ASTLayout::Format::kUnspecified;
if (this->peek().fKind == Token::LAYOUT) {
this->nextToken();
if (!this->expect(Token::LPAREN, "'('")) {
return ASTLayout(location, binding, index, set, builtin, originUpperLeft,
- overrideCoverage, blendSupportAllEquations);
+ overrideCoverage, blendSupportAllEquations, format);
}
for (;;) {
Token t = this->nextToken();
overrideCoverage = true;
} else if (t.fText == "blend_support_all_equations") {
blendSupportAllEquations = true;
+ } else if (ASTLayout::ReadFormat(t.fText, &format)) {
+ // AST::ReadFormat stored the result in 'format'.
} else {
this->error(t.fPosition, ("'" + t.fText +
"' is not a valid layout qualifier").c_str());
}
}
return ASTLayout(location, binding, index, set, builtin, originUpperLeft, overrideCoverage,
- blendSupportAllEquations);
+ blendSupportAllEquations, format);
}
/* layout? (UNIFORM | CONST | IN | OUT | INOUT | LOWP | MEDIUMP | HIGHP | FLAT | NOPERSPECTIVE)* */
* layout (location = 0) int x;
*/
struct ASTLayout : public ASTNode {
- // For all parameters, a -1 means no value
+ // These are used by images in GLSL. We only support a subset of what GL supports.
+ enum class Format {
+ kUnspecified = -1,
+ kRGBA32F,
+ kR32F,
+ kRGBA16F,
+ kR16F,
+ kRGBA8,
+ kR8,
+ kRGBA8I,
+ kR8I,
+ };
+
+ static const char* FormatToStr(Format format) {
+ switch (format) {
+ case Format::kUnspecified: return "";
+ case Format::kRGBA32F: return "rgba32f";
+ case Format::kR32F: return "r32f";
+ case Format::kRGBA16F: return "rgba16f";
+ case Format::kR16F: return "r16f";
+ case Format::kRGBA8: return "rgba8";
+ case Format::kR8: return "r8";
+ case Format::kRGBA8I: return "rgba8i";
+ case Format::kR8I: return "r8i";
+ }
+ SkFAIL("Unexpected format");
+ return "";
+ }
+
+ static bool ReadFormat(std::string str, Format* format) {
+ if (str == "rgba32f") {
+ *format = Format::kRGBA32F;
+ return true;
+ } else if (str == "r32f") {
+ *format = Format::kR32F;
+ return true;
+ } else if (str == "rgba16f") {
+ *format = Format::kRGBA16F;
+ return true;
+ } else if (str == "r16f") {
+ *format = Format::kR16F;
+ return true;
+ } else if (str == "rgba8") {
+ *format = Format::kRGBA8;
+ return true;
+ } else if (str == "r8") {
+ *format = Format::kR8;
+ return true;
+ } else if (str == "rgba8i") {
+ *format = Format::kRGBA8I;
+ return true;
+ } else if (str == "r8i") {
+ *format = Format::kR8I;
+ return true;
+ }
+ return false;
+ }
+
+ // For int parameters, a -1 means no value
ASTLayout(int location, int binding, int index, int set, int builtin, bool originUpperLeft,
- bool overrideCoverage, bool blendSupportAllEquations)
+ bool overrideCoverage, bool blendSupportAllEquations, Format format)
: fLocation(location)
, fBinding(binding)
, fIndex(index)
, fBuiltin(builtin)
, fOriginUpperLeft(originUpperLeft)
, fOverrideCoverage(overrideCoverage)
- , fBlendSupportAllEquations(blendSupportAllEquations) {}
+ , fBlendSupportAllEquations(blendSupportAllEquations)
+ , fFormat(format) {}
std::string description() const {
std::string result;
result += separator + "blend_support_all_equations";
separator = ", ";
}
+ if (fFormat != Format::kUnspecified) {
+ result += separator + FormatToStr(fFormat);
+ separator = ", ";
+ }
if (result.length() > 0) {
result = "layout (" + result + ")";
}
const bool fOriginUpperLeft;
const bool fOverrideCoverage;
const bool fBlendSupportAllEquations;
+ const Format fFormat;
};
} // namespace
, fBuiltin(layout.fBuiltin)
, fOriginUpperLeft(layout.fOriginUpperLeft)
, fOverrideCoverage(layout.fOverrideCoverage)
- , fBlendSupportAllEquations(layout.fBlendSupportAllEquations) {}
+ , fBlendSupportAllEquations(layout.fBlendSupportAllEquations)
+ , fFormat(layout.fFormat) {}
Layout(int location, int binding, int index, int set, int builtin, bool originUpperLeft,
- bool overrideCoverage, bool blendSupportAllEquations)
+ bool overrideCoverage, bool blendSupportAllEquations, ASTLayout::Format format)
: fLocation(location)
, fBinding(binding)
, fIndex(index)
, fBuiltin(builtin)
, fOriginUpperLeft(originUpperLeft)
, fOverrideCoverage(overrideCoverage)
- , fBlendSupportAllEquations(blendSupportAllEquations) {}
+ , fBlendSupportAllEquations(blendSupportAllEquations)
+ , fFormat(format) {}
+
+ Layout()
+ : fLocation(-1)
+ , fBinding(-1)
+ , fIndex(-1)
+ , fSet(-1)
+ , fBuiltin(-1)
+ , fOriginUpperLeft(false)
+ , fOverrideCoverage(false)
+ , fBlendSupportAllEquations(false)
+ , fFormat(ASTLayout::Format::kUnspecified) {}
std::string description() const {
std::string result;
result += separator + "blend_support_all_equations";
separator = ", ";
}
+ if (ASTLayout::Format::kUnspecified != fFormat) {
+ result += separator + ASTLayout::FormatToStr(fFormat);
+ separator = ", ";
+ }
if (result.length() > 0) {
result = "layout (" + result + ")";
}
fBuiltin == other.fBuiltin &&
fOriginUpperLeft == other.fOriginUpperLeft &&
fOverrideCoverage == other.fOverrideCoverage &&
- fBlendSupportAllEquations == other.fBlendSupportAllEquations;
+ fBlendSupportAllEquations == other.fBlendSupportAllEquations &&
+ fFormat == other.fFormat;
}
bool operator!=(const Layout& other) const {
bool fOriginUpperLeft;
bool fOverrideCoverage;
bool fBlendSupportAllEquations;
+ ASTLayout::Format fFormat;
};
} // namespace
uint atomicCompSwap(inout uint mem, uint compare, uint data);
int atomicCompSwap(inout int mem, int compare, int data);
*/
-// section 8.12 Image Functions will go here if and when we add support for them
-
+// section 8.12 Additional Image Functions will go here if and when we add
+// support for them
+vec4 imageLoad(image2D image, ivec2 P);
+ivec4 imageLoad(iimage2D image, ivec2 P);
$genType dFdx($genType p);
$genType dFdy($genType p);
float interpolateAtSample(float interpolant, int sample);