Added support for for early fragment tests.

Set early_fragment_tests render state to enable early fragment tests for
targets that support explicitly setting it.

Added support for Metal simulator. Internally this now uses an enum rather
than a bool for the target platform.

Author: akb825

Compile/include/MSL/Compile/Target.h

@@ -108,13 +108,14 @@ class MSL_COMPILE_EXPORT Target
 		SubpassInputs,          ///< Subpass inputs for reading directly from framebuffers.
 		ClipDistance,           ///< Support for gl_ClipDistance array.
 		CullDistance,           ///< Support for gl_CullDistance array.
+		EarlyFragmentTests,     ///< Support for explicitly enabling early fragment tests.
 	};
 
 	/**
 	 * @brief The number of feature enum elements.
 	 */
 	static const unsigned int featureCount =
-		static_cast<unsigned int>(Feature::CullDistance) + 1;
+		static_cast<unsigned int>(Feature::EarlyFragmentTests) + 1;
 
 	/**
 	 * @brief Information about a feature.

Compile/include/MSL/Compile/TargetMetal.h

@@ -48,23 +48,32 @@ namespace msl
 class MSL_COMPILE_EXPORT TargetMetal : public Target
 {
 public:
+	/**
+	 * @brief Enum for the platform to target.
+	 */
+	enum class Platform
+	{
+		MacOS,       ///< Target macOS.
+		iOS,         ///< Target iOS.
+		iOSSimulator ///< Target iOS simulator.
+	};
 
 	/**
 	 * @brief Constructs this with the version number.
 	 * @param version The Metal version number.
-	 * @param isIos True if this is Metal for iOS.
+	 * @param platform The platform to target.
 	 */
-	TargetMetal(std::uint32_t version, bool isIos);
+	TargetMetal(std::uint32_t version, Platform platform);
 
 	~TargetMetal();
 	TargetMetal(const TargetMetal&) = delete;
 	TargetMetal& operator=(const TargetMetal&) = delete;
 
 	/**
-	 * @brief Returns whether or not this is for iOS.
-	 * @return True if for iOS.
+	 * @brief Gets the platform that's targetd.
+	 * @return The targeted platform.
 	 */
-	bool isIos() const;
+	Platform getPlatform() const;
 
 	std::uint32_t getId() const override;
 	std::uint32_t getVersion() const override;
@@ -84,7 +93,7 @@ class MSL_COMPILE_EXPORT TargetMetal : public Target
 	std::string getSDK() const;
 
 	std::uint32_t m_version;
-	bool m_ios;
+	Platform m_platform;
 };
 
 } // namespace msl

Compile/include/MSL/Compile/Types.h

@@ -742,6 +742,11 @@ struct RenderState
 	 * @brief The number of cull distances.
 	 */
 	std::uint32_t cullDistanceCount = 0;
+
+	/**
+	 * @brief Whether or not to enable early fragment tests.
+	 */
+	Bool earlyFragmentTests = Bool::Unset;
 };
 
 /**

Compile/src/Parser.cpp

@@ -1268,13 +1268,19 @@ static ParseResult readRenderState(Output& output, Parser::Pipeline& pipeline, c
 		}
 		return ParseResult::Success;
 	}
-	// Patch control points
-	else if (isAttachment(attachmentIndex, key.value, "patch_control_points"))
+	// Other states
+	else if (key.value == "patch_control_points")
 	{
 		if (!getInt(output, pipeline.renderState.patchControlPoints, value))
 			return ParseResult::Error;
 		return ParseResult::Success;
 	}
+	else if (key.value == "early_fragment_tests")
+	{
+		if (!getBool(output, pipeline.renderState.earlyFragmentTests, value))
+			return ParseResult::Error;
+		return ParseResult::Success;
+	}
 	else
 		return ParseResult::NotThisType;
 }
@@ -1540,7 +1546,8 @@ bool Parser::parse(Output& output, int options)
 }
 
 std::string Parser::createShaderString(std::vector<LineMapping>& lineMappings, Output& output,
-	const Pipeline& pipeline, Stage stage, bool ignoreEntryPoint) const
+	const Pipeline& pipeline, Stage stage, bool ignoreEntryPoint,
+	bool earlyFragmentTests) const
 {
 	lineMappings.clear();
 	std::string shaderString;
@@ -1555,6 +1562,15 @@ std::string Parser::createShaderString(std::vector<LineMapping>& lineMappings, O
 			!m_elements[static_cast<unsigned int>(Element::UniformBlock)][stageIndex].empty();
 	}
 
+	// Add line for early fragment tests if enabled.
+	if (stage == Stage::Fragment && earlyFragmentTests)
+	{
+		shaderString += "layout(early_fragment_tests) in;\n";
+		lineMappings.emplace_back();
+		lineMappings.back().fileName = "<internal>";
+		lineMappings.back().line = 0;
+	}
+
 	// Add precision and struct elements first. This ensures that any type declarations are present
 	// before generating the push constant.
 	for (const TokenRange& tokenRange :
@@ -2155,6 +2171,7 @@ bool Parser::removeUniformBlock(std::string& str, std::vector<LineMapping>& line
 	if (!(m_options & RemoveUniformBlocks))
 		return false;
 
+	// Add the contents of the uniform block, stripping the block itself.
 	bool newline = true;
 	bool processed = false;
 	unsigned int braceCount = 0;

Compile/src/Parser.h

@@ -82,7 +82,8 @@ class MSL_COMPILE_EXPORT Parser
 
 	bool parse(Output& output, int options = 0);
 	std::string createShaderString(std::vector<LineMapping>& lineMappings, Output& output,
-		const Pipeline& pipeline, Stage stage, bool ignoreEntryPoint = false) const;
+		const Pipeline& pipeline, Stage stage, bool ignoreEntryPoint,
+		bool earlyFragmentTests) const;
 
 private:
 	enum class Element

Compile/src/Target.cpp

@@ -100,6 +100,8 @@ static Target::FeatureInfo featureInfos[] =
 		"Subpass inputs for reading directly from framebuffers."},
 	{"ClipDistance", "HAS_CLIP_DISTANCE", "Support for gl_ClipDistance array."},
 	{"CullDistance", "HAS_CULL_DISTANCE", "Support for gl_CullDistance array."},
+	{"EarlyFragmentTests", "HAS_EARLY_FRAGMENT_TESTS",
+		"Support for explicitly enabling early fragment tests."},
 };
 
 static_assert(sizeof(featureInfos)/sizeof(*featureInfos) == Target::featureCount,
@@ -685,6 +687,7 @@ bool Target::compileImpl(CompiledResult& result, Output& output, Parser& parser,
 	int options = 0;
 	if (!featureEnabled(Feature::UniformBlocks))
 		options |= Parser::RemoveUniformBlocks;
+	bool hasEarlyFragmentTests = featureEnabled(Feature::EarlyFragmentTests);
 
 	if (!parser.parse(output, options))
 		return false;
@@ -770,7 +773,9 @@ bool Target::compileImpl(CompiledResult& result, Output& output, Parser& parser,
 			if (pipeline.entryPoints[i].value.empty())
 				continue;
 
-			std::string glsl = parser.createShaderString(lineMappings, output, pipeline, stage);
+			std::string glsl = parser.createShaderString(lineMappings, output, pipeline, stage,
+				false, hasEarlyFragmentTests &&
+					pipeline.renderState.earlyFragmentTests == Bool::True);
 			if (glsl.empty())
 				return false;
 			if (!Compiler::compile(stages, output, fileName, glsl, lineMappings, stage, resources))

Compile/src/TargetGlsl.cpp

@@ -313,6 +313,11 @@ bool TargetGlsl::featureSupported(Feature feature) const
 			return !m_es && m_version >= 130;
 		case Feature::CullDistance:
 			return !m_es && m_version >= 450;
+		case Feature::EarlyFragmentTests:
+			if (m_es)
+				return m_version >= 310;
+			else
+				return m_version >= 420;
 	}
 
 	return false;

Compile/src/TargetMetal.cpp

@@ -128,27 +128,27 @@ static std::vector<std::uint32_t> setBindingIndices(const std::vector<std::uint3
 	return adjustedSpirv;
 }
 
-TargetMetal::TargetMetal(std::uint32_t version, bool isIos)
+TargetMetal::TargetMetal(std::uint32_t version, Platform platform)
 	: m_version(version)
-	, m_ios(isIos)
+	, m_platform(platform)
 {
 }
 
 TargetMetal::~TargetMetal()
 {
 }
 
-bool TargetMetal::isIos() const
+TargetMetal::Platform TargetMetal::getPlatform() const
 {
-	return m_ios;
+	return m_platform;
 }
 
 std::uint32_t TargetMetal::getId() const
 {
-	if (m_ios)
-		return MSL_CREATE_ID('M', 'T', 'L', 'I');
-	else
+	if (m_platform == Platform::MacOS)
 		return MSL_CREATE_ID('M', 'T', 'L', 'X');
+	else
+		return MSL_CREATE_ID('M', 'T', 'L', 'I');
 }
 
 std::uint32_t TargetMetal::getVersion() const
@@ -170,6 +170,8 @@ bool TargetMetal::featureSupported(Feature feature) const
 			return false;
 		case Feature::TessellationStages:
 			return m_version >= 102;
+		case Feature::EarlyFragmentTests:
+			return m_version >= 102;
 		default:
 			return true;
 	}
@@ -180,10 +182,10 @@ std::vector<std::pair<std::string, std::string>> TargetMetal::getExtraDefines()
 	std::stringstream stream;
 	stream << getVersion();
 	std::vector<std::pair<std::string, std::string>> defines = {{"METAL_VERSION", stream.str()}};
-	if (m_ios)
-		defines.emplace_back("METAL_IOS_VERSION", stream.str());
-	else
+	if (m_platform == Platform::MacOS)
 		defines.emplace_back("METAL_OSX_VERSION", stream.str());
+	else
+		defines.emplace_back("METAL_IOS_VERSION", stream.str());
 	return defines;
 }
 
@@ -208,7 +210,8 @@ bool TargetMetal::crossCompile(std::vector<std::uint8_t>& data, Output& output,
 	std::vector<std::uint32_t> adjustedSpirv = setBindingIndices(spirv, uniforms, uniformIds,
 		hasPushConstant, bufferCount, textureCount);
 
-	std::string metal = MetalOutput::disassemble(output, adjustedSpirv, stage, m_version, m_ios,
+	bool ios = m_platform != Platform::MacOS;
+	std::string metal = MetalOutput::disassemble(output, adjustedSpirv, stage, m_version, ios,
 		outputToBuffer, hasPushConstant, bufferCount, textureCount, fileName, line, column);
 	if (metal.empty())
 		return false;
@@ -218,7 +221,7 @@ bool TargetMetal::crossCompile(std::vector<std::uint8_t>& data, Output& output,
 
 	// Compile this entry point.
 	std::stringstream versionStr;
-	if (m_ios)
+	if (ios)
 		versionStr << "-std=ios-metal";
 	else
 		versionStr << "-std=osx-metal";
@@ -253,10 +256,16 @@ bool TargetMetal::crossCompile(std::vector<std::uint8_t>& data, Output& output,
 
 std::string TargetMetal::getSDK() const
 {
-	if (m_ios)
-		return "iphoneos";
-	else
-		return "macosx";
+	switch (m_platform)
+	{
+		case Platform::MacOS:
+			return "macosx";
+		case Platform::iOS:
+			return "iphoneos";
+		case Platform::iOSSimulator:
+			return "iphonesimulator";
+	}
+	return "";
 }
 
 } // namespace msl

Compile/test/CompilerTest.cpp

@@ -61,7 +61,8 @@ TEST_F(CompilerTest, CompleteShader)
 
 		auto stage = static_cast<Stage>(i);
 		std::vector<Parser::LineMapping> lineMappings;
-		std::string glsl = parser.createShaderString(lineMappings, output, pipeline, stage);
+		std::string glsl =
+			parser.createShaderString(lineMappings, output, pipeline, stage, false, false);
 		EXPECT_TRUE(Compiler::compile(stages, output, shaderName, glsl, lineMappings, stage,
 			Compiler::getDefaultResources()));
 		compiledStage = true;
@@ -102,7 +103,40 @@ TEST_F(CompilerTest, CompileError)
 
 	auto stage = Stage::Fragment;
 	std::vector<Parser::LineMapping> lineMappings;
-	std::string glsl = parser.createShaderString(lineMappings, output, pipeline, stage);
+	std::string glsl =
+		parser.createShaderString(lineMappings, output, pipeline, stage, false, false);
+	EXPECT_FALSE(Compiler::compile(stages, output, shaderName, glsl, lineMappings, stage,
+		Compiler::getDefaultResources()));
+
+	const std::vector<Output::Message>& messages = output.getMessages();
+	ASSERT_LE(1U, messages.size());
+	EXPECT_EQ(Output::Level::Error, messages[0].level);
+	EXPECT_TRUE(boost::algorithm::ends_with(pathStr(messages[0].file),
+		pathStr(inputDir/"CompileError.mslh")));
+	EXPECT_EQ(15U, messages[0].line);
+	EXPECT_EQ("'inputss' : undeclared identifier", messages[0].message);
+}
+
+TEST_F(CompilerTest, CompileErrorWithEarlyFragmentTests)
+{
+	boost::filesystem::path inputDir = exeDir/"inputs";
+	std::string shaderName = pathStr(inputDir/"CompileError.msl");
+
+	Parser parser;
+	Preprocessor preprocessor;
+	Output output;
+	preprocessor.addIncludePath(pathStr(inputDir));
+	EXPECT_TRUE(preprocessor.preprocess(parser.getTokens(), output, shaderName));
+	EXPECT_TRUE(parser.parse(output));
+
+	ASSERT_EQ(1U, parser.getPipelines().size());
+	const Parser::Pipeline& pipeline = parser.getPipelines()[0];
+	Compiler::Stages stages;
+
+	auto stage = Stage::Fragment;
+	std::vector<Parser::LineMapping> lineMappings;
+	std::string glsl =
+		parser.createShaderString(lineMappings, output, pipeline, stage, false, true);
 	EXPECT_FALSE(Compiler::compile(stages, output, shaderName, glsl, lineMappings, stage,
 		Compiler::getDefaultResources()));
 
@@ -133,7 +167,8 @@ TEST_F(CompilerTest, CompileWarning)
 
 	auto stage = Stage::Fragment;
 	std::vector<Parser::LineMapping> lineMappings;
-	std::string glsl = parser.createShaderString(lineMappings, output, pipeline, stage);
+	std::string glsl =
+		parser.createShaderString(lineMappings, output, pipeline, stage, false, false);
 	EXPECT_TRUE(Compiler::compile(stages, output, shaderName, glsl, lineMappings, stage,
 		Compiler::getDefaultResources()));
 
@@ -169,7 +204,8 @@ TEST_F(CompilerTest, MissingEntryPoint)
 
 		auto stage = static_cast<Stage>(i);
 		std::vector<Parser::LineMapping> lineMappings;
-		std::string glsl = parser.createShaderString(lineMappings, output, pipeline, stage);
+		std::string glsl =
+			parser.createShaderString(lineMappings, output, pipeline, stage, false, false);
 		if (stage == Stage::Fragment)
 			EXPECT_TRUE(glsl.empty());
 		else
@@ -210,7 +246,8 @@ TEST_F(CompilerTest, DuplicateEntryPoint)
 
 		auto stage = static_cast<Stage>(i);
 		std::vector<Parser::LineMapping> lineMappings;
-		std::string glsl = parser.createShaderString(lineMappings, output, pipeline, stage);
+		std::string glsl =
+			parser.createShaderString(lineMappings, output, pipeline, stage, false, false);
 		if (stage == Stage::Fragment)
 			EXPECT_TRUE(glsl.empty());
 		else