DEV/flutter_flutter
1
0
Fork 0
mirror of https://github.com/flutter/flutter.git synced 2026-02-20 02:29:02 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge 57e30bdc1716ec11f0e2478ca6fb77ef7aa1c35a into 06df71c51446e96939c6a615b7c34ce9123806ba

Browse Source
This commit is contained in:
b-luk 2026-02-19 16:47:10 +01:00 committed by GitHub
commit e7a9ee3826
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 229 additions and 286 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
engine/src/flutter/impeller/compiler/compiler.cc
View File

@ -242,7 +242,6 @@ static CompilerBackend CreateCompiler(const spirv_cross::ParsedIR& ir,
case TargetPlatform::kRuntimeStageVulkan:
compiler = CreateVulkanCompiler(ir, source_options);
break;
case TargetPlatform::kUnknown:
case TargetPlatform::kOpenGLES:
case TargetPlatform::kOpenGLDesktop:
case TargetPlatform::kRuntimeStageGLES:
@ -251,6 +250,9 @@ static CompilerBackend CreateCompiler(const spirv_cross::ParsedIR& ir,
break;
case TargetPlatform::kSkSL:
compiler = CreateSkSLCompiler(ir, source_options);
break;
case TargetPlatform::kUnknown:
FML_UNREACHABLE();
}
if (!compiler) {
return {};

77
engine/src/flutter/impeller/compiler/compiler_test.cc
View File

@ -142,53 +142,50 @@ bool CompilerTestBase::CanCompileAndReflect(
return false;
}
if (TargetPlatformNeedsReflection(GetParam())) {
auto reflector = compiler.GetReflector();
if (!reflector) {
VALIDATION_LOG
<< "No reflector was found for target platform SL compiler.";
return false;
}
auto reflector = compiler.GetReflector();
if (!reflector) {
VALIDATION_LOG << "No reflector was found for target platform SL compiler.";
return false;
}
auto reflection_json = reflector->GetReflectionJSON();
auto reflection_header = reflector->GetReflectionHeader();
auto reflection_source = reflector->GetReflectionCC();
auto reflection_json = reflector->GetReflectionJSON();
auto reflection_header = reflector->GetReflectionHeader();
auto reflection_source = reflector->GetReflectionCC();
if (!reflection_json) {
VALIDATION_LOG << "Reflection JSON was not found.";
return false;
}
if (!reflection_json) {
VALIDATION_LOG << "Reflection JSON was not found.";
return false;
}
if (!reflection_header) {
VALIDATION_LOG << "Reflection header was not found.";
return false;
}
if (!reflection_header) {
VALIDATION_LOG << "Reflection header was not found.";
return false;
}
if (!reflection_source) {
VALIDATION_LOG << "Reflection source was not found.";
return false;
}
if (!reflection_source) {
VALIDATION_LOG << "Reflection source was not found.";
return false;
}
if (!fml::WriteAtomically(intermediates_directory_,
ReflectionHeaderName(fixture_name).c_str(),
*reflection_header)) {
VALIDATION_LOG << "Could not write reflection header intermediates.";
return false;
}
if (!fml::WriteAtomically(intermediates_directory_,
ReflectionHeaderName(fixture_name).c_str(),
*reflection_header)) {
VALIDATION_LOG << "Could not write reflection header intermediates.";
return false;
}
if (!fml::WriteAtomically(intermediates_directory_,
ReflectionCCName(fixture_name).c_str(),
*reflection_source)) {
VALIDATION_LOG << "Could not write reflection CC intermediates.";
return false;
}
if (!fml::WriteAtomically(intermediates_directory_,
ReflectionCCName(fixture_name).c_str(),
*reflection_source)) {
VALIDATION_LOG << "Could not write reflection CC intermediates.";
return false;
}
if (!fml::WriteAtomically(intermediates_directory_,
ReflectionJSONName(fixture_name).c_str(),
*reflection_json)) {
VALIDATION_LOG << "Could not write reflection json intermediates.";
return false;
}
if (!fml::WriteAtomically(intermediates_directory_,
ReflectionJSONName(fixture_name).c_str(),
*reflection_json)) {
VALIDATION_LOG << "Could not write reflection json intermediates.";
return false;
}
return true;
}

4
engine/src/flutter/impeller/compiler/compiler_test.h
View File

@ -45,9 +45,11 @@ class CompilerTestBase : public ::testing::TestWithParam<TargetPlatform> {
class CompilerTest : public CompilerTestBase {};
class CompilerTestRuntime : public CompilerTestBase {};
class CompilerTestSkSL : public CompilerTestBase {};
class CompilerTestRuntime : public CompilerTestBase {};
class CompilerTestUnknownPlatform : public CompilerTestBase {};
} // namespace testing
} // namespace compiler

108
engine/src/flutter/impeller/compiler/compiler_unittests.cc
View File

@ -15,6 +15,46 @@ namespace impeller {
namespace compiler {
namespace testing {
INSTANTIATE_TEST_SUITE_P(
CompilerSuite,
CompilerTest,
::testing::Values(TargetPlatform::kOpenGLES,
TargetPlatform::kOpenGLDesktop,
TargetPlatform::kMetalDesktop,
TargetPlatform::kMetalIOS,
TargetPlatform::kVulkan),
[](const ::testing::TestParamInfo<CompilerTest::ParamType>& info) {
return TargetPlatformToString(info.param);
});
INSTANTIATE_TEST_SUITE_P(
CompilerSuite,
CompilerTestRuntime,
::testing::Values(TargetPlatform::kRuntimeStageMetal,
TargetPlatform::kRuntimeStageGLES,
TargetPlatform::kRuntimeStageGLES3,
TargetPlatform::kRuntimeStageVulkan,
TargetPlatform::kSkSL),
[](const ::testing::TestParamInfo<CompilerTest::ParamType>& info) {
return TargetPlatformToString(info.param);
});
INSTANTIATE_TEST_SUITE_P(
CompilerSuite,
CompilerTestSkSL,
::testing::Values(TargetPlatform::kSkSL),
[](const ::testing::TestParamInfo<CompilerTest::ParamType>& info) {
return TargetPlatformToString(info.param);
});
INSTANTIATE_TEST_SUITE_P(
CompilerSuite,
CompilerTestUnknownPlatform,
::testing::Values(TargetPlatform::kUnknown),
[](const ::testing::TestParamInfo<CompilerTest::ParamType>& info) {
return TargetPlatformToString(info.param);
});
TEST(CompilerTest, Defines) {
std::shared_ptr<const fml::Mapping> fixture =
flutter::testing::OpenFixtureAsMapping("check_gles_definition.frag");
@ -48,9 +88,6 @@ TEST(CompilerTest, ShaderKindMatchingIsSuccessful) {
}
TEST_P(CompilerTest, CanCompile) {
if (GetParam() == TargetPlatform::kSkSL) {
GTEST_SKIP() << "Not supported with SkSL";
}
ASSERT_TRUE(CanCompileAndReflect("sample.vert"));
ASSERT_TRUE(CanCompileAndReflect("sample.vert", SourceType::kVertexShader));
ASSERT_TRUE(CanCompileAndReflect("sample.vert", SourceType::kVertexShader,
@ -58,17 +95,11 @@ TEST_P(CompilerTest, CanCompile) {
}
TEST_P(CompilerTest, CanCompileHLSL) {
if (GetParam() == TargetPlatform::kSkSL) {
GTEST_SKIP() << "Not supported with SkSL";
}
ASSERT_TRUE(CanCompileAndReflect(
"simple.vert.hlsl", SourceType::kVertexShader, SourceLanguage::kHLSL));
}
TEST_P(CompilerTest, CanCompileHLSLWithMultipleStages) {
if (GetParam() == TargetPlatform::kSkSL) {
GTEST_SKIP() << "Not supported with SkSL";
}
ASSERT_TRUE(CanCompileAndReflect("multiple_stages.hlsl",
SourceType::kVertexShader,
SourceLanguage::kHLSL, "VertexShader"));
@ -87,18 +118,12 @@ TEST_P(CompilerTest, CanCompileComputeShader) {
}
TEST_P(CompilerTest, MustFailDueToExceedingResourcesLimit) {
if (GetParam() == TargetPlatform::kSkSL) {
GTEST_SKIP() << "Not supported with SkSL";
}
ScopedValidationDisable disable_validation;
ASSERT_FALSE(
CanCompileAndReflect("resources_limit.vert", SourceType::kVertexShader));
}
TEST_P(CompilerTest, MustFailDueToMultipleLocationPerStructMember) {
if (GetParam() == TargetPlatform::kSkSL) {
GTEST_SKIP() << "Not supported with SkSL";
}
ScopedValidationDisable disable_validation;
ASSERT_FALSE(CanCompileAndReflect("struct_def_bug.vert"));
}
@ -202,6 +227,12 @@ inline std::ostream& operator<<(std::ostream& out, const UniformInfo& info) {
} // namespace
TEST_P(CompilerTestRuntime, UniformsAppearInJson) {
if (GetParam() == TargetPlatform::kRuntimeStageVulkan) {
// TODO(https://github.com/flutter/flutter/issues/182578): Investigate why
// this does not pass.
GTEST_SKIP() << "Not supported with Vulkan";
}
ASSERT_TRUE(CanCompileAndReflect("sample_with_uniforms.frag",
SourceType::kFragmentShader,
SourceLanguage::kGLSL));
@ -248,6 +279,12 @@ TEST_P(CompilerTestRuntime, UniformsAppearInJson) {
}
TEST_P(CompilerTestRuntime, PositionedUniformsAppearInJson) {
if (GetParam() == TargetPlatform::kRuntimeStageVulkan) {
// TODO(https://github.com/flutter/flutter/issues/182578): Investigate why
// this does not pass.
GTEST_SKIP() << "Not supported with Vulkan";
}
ASSERT_TRUE(CanCompileAndReflect("sample_with_positioned_uniforms.frag",
SourceType::kFragmentShader,
SourceLanguage::kGLSL));
@ -377,39 +414,11 @@ TEST_P(CompilerTestSkSL, CompilesWithValidArrayInitialization) {
SourceType::kFragmentShader));
}
#define INSTANTIATE_TARGET_PLATFORM_TEST_SUITE_P(suite_name) \
INSTANTIATE_TEST_SUITE_P( \
suite_name, CompilerTest, \
::testing::Values(TargetPlatform::kOpenGLES, \
TargetPlatform::kOpenGLDesktop, \
TargetPlatform::kMetalDesktop, \
TargetPlatform::kMetalIOS, TargetPlatform::kSkSL), \
[](const ::testing::TestParamInfo<CompilerTest::ParamType>& info) { \
return TargetPlatformToString(info.param); \
});
INSTANTIATE_TARGET_PLATFORM_TEST_SUITE_P(CompilerSuite);
#define INSTANTIATE_RUNTIME_TARGET_PLATFORM_TEST_SUITE_P(suite_name) \
INSTANTIATE_TEST_SUITE_P( \
suite_name, CompilerTestRuntime, \
::testing::Values(TargetPlatform::kRuntimeStageMetal), \
[](const ::testing::TestParamInfo<CompilerTest::ParamType>& info) { \
return TargetPlatformToString(info.param); \
});
INSTANTIATE_RUNTIME_TARGET_PLATFORM_TEST_SUITE_P(CompilerSuite);
#define INSTANTIATE_SKSL_TARGET_PLATFORM_TEST_SUITE_P(suite_name) \
INSTANTIATE_TEST_SUITE_P( \
suite_name, CompilerTestSkSL, ::testing::Values(TargetPlatform::kSkSL), \
[](const ::testing::TestParamInfo<CompilerTest::ParamType>& info) { \
return TargetPlatformToString(info.param); \
});
INSTANTIATE_SKSL_TARGET_PLATFORM_TEST_SUITE_P(CompilerSuite);
TEST_P(CompilerTestRuntime, Mat2Reflection) {
if (GetParam() == TargetPlatform::kSkSL) {
GTEST_SKIP() << "Not supported with SkSL";
}
ASSERT_TRUE(CanCompileAndReflect(
"mat2_test.frag", SourceType::kFragmentShader, SourceLanguage::kGLSL));
@ -448,6 +457,11 @@ TEST_P(CompilerTestRuntime, Mat2Reflection) {
EXPECT_EQ(mat2Member["offset"], 0u);
}
TEST_P(CompilerTestUnknownPlatform, MustFailDueToUnknownPlatform) {
ASSERT_FALSE(
CanCompileAndReflect("sample.frag", SourceType::kFragmentShader));
}
} // namespace testing
} // namespace compiler
} // namespace impeller

127
engine/src/flutter/impeller/compiler/impellerc_main.cc
View File

@ -32,48 +32,15 @@ static Reflector::Options CreateReflectorOptions(const SourceOptions& options,
return reflector_options;
}
/// Run the shader compiler to geneate SkSL reflection data.
/// If there is an error, prints error text and returns `nullptr`.
static std::shared_ptr<RuntimeStageData::Shader> CompileSkSL(
std::shared_ptr<fml::Mapping> source_file_mapping,
const Switches& switches) {
auto options = switches.CreateSourceOptions(TargetPlatform::kSkSL);
Reflector::Options sksl_reflector_options =
CreateReflectorOptions(options, switches);
sksl_reflector_options.target_platform = TargetPlatform::kSkSL;
Compiler sksl_compiler =
Compiler(std::move(source_file_mapping), options, sksl_reflector_options);
if (!sksl_compiler.IsValid()) {
std::cerr << "Compilation to SkSL failed." << std::endl;
std::cerr << sksl_compiler.GetErrorMessages() << std::endl;
return nullptr;
}
return sksl_compiler.GetReflector()->GetRuntimeStageShaderData();
}
static bool OutputIPLR(
const Switches& switches,
const std::shared_ptr<fml::Mapping>& source_file_mapping) {
FML_DCHECK(switches.iplr);
RuntimeStageData stages;
std::shared_ptr<RuntimeStageData::Shader> sksl_shader;
if (TargetPlatformBundlesSkSL(switches.SelectDefaultTargetPlatform())) {
sksl_shader = CompileSkSL(source_file_mapping, switches);
if (!sksl_shader) {
return false;
}
stages.AddShader(sksl_shader);
}
for (const auto& platform : switches.PlatformsToCompile()) {
if (platform == TargetPlatform::kSkSL) {
// Already handled above.
continue;
}
SourceOptions options = switches.CreateSourceOptions(platform);
SourceOptions options = switches.CreateSourceOptions();
options.target_platform = platform;
// Invoke the compiler and generate reflection data for a single shader.
@ -81,7 +48,8 @@ static bool OutputIPLR(
CreateReflectorOptions(options, switches);
Compiler compiler(source_file_mapping, options, reflector_options);
if (!compiler.IsValid()) {
std::cerr << "Compilation failed." << std::endl;
std::cerr << "Compilation failed for target: "
<< TargetPlatformToString(platform) << std::endl;
std::cerr << compiler.GetErrorMessages() << std::endl;
return false;
}
@ -149,43 +117,40 @@ static bool OutputReflectionData(const Compiler& compiler,
/// May include a JSON file, a C++ header, and/or a C++ TU.
///
if (TargetPlatformNeedsReflection(options.target_platform)) {
if (!switches.reflection_json_name.empty()) {
auto reflection_json_name = std::filesystem::absolute(
std::filesystem::current_path() / switches.reflection_json_name);
if (!fml::WriteAtomically(
*switches.working_directory,
Utf8FromPath(reflection_json_name).c_str(),
*compiler.GetReflector()->GetReflectionJSON())) {
std::cerr << "Could not write reflection json to "
<< switches.reflection_json_name << std::endl;
return false;
}
if (!switches.reflection_json_name.empty()) {
auto reflection_json_name = std::filesystem::absolute(
std::filesystem::current_path() / switches.reflection_json_name);
if (!fml::WriteAtomically(*switches.working_directory,
Utf8FromPath(reflection_json_name).c_str(),
*compiler.GetReflector()->GetReflectionJSON())) {
std::cerr << "Could not write reflection json to "
<< switches.reflection_json_name << std::endl;
return false;
}
}
if (!switches.reflection_header_name.empty()) {
auto reflection_header_name = std::filesystem::absolute(
std::filesystem::current_path() / switches.reflection_header_name);
if (!fml::WriteAtomically(
*switches.working_directory,
Utf8FromPath(reflection_header_name).c_str(),
*compiler.GetReflector()->GetReflectionHeader())) {
std::cerr << "Could not write reflection header to "
<< switches.reflection_header_name << std::endl;
return false;
}
if (!switches.reflection_header_name.empty()) {
auto reflection_header_name = std::filesystem::absolute(
std::filesystem::current_path() / switches.reflection_header_name);
if (!fml::WriteAtomically(
*switches.working_directory,
Utf8FromPath(reflection_header_name).c_str(),
*compiler.GetReflector()->GetReflectionHeader())) {
std::cerr << "Could not write reflection header to "
<< switches.reflection_header_name << std::endl;
return false;
}
}
if (!switches.reflection_cc_name.empty()) {
auto reflection_cc_name = std::filesystem::absolute(
std::filesystem::current_path() / switches.reflection_cc_name);
if (!fml::WriteAtomically(*switches.working_directory,
Utf8FromPath(reflection_cc_name).c_str(),
*compiler.GetReflector()->GetReflectionCC())) {
std::cerr << "Could not write reflection CC to "
<< switches.reflection_cc_name << std::endl;
return false;
}
if (!switches.reflection_cc_name.empty()) {
auto reflection_cc_name = std::filesystem::absolute(
std::filesystem::current_path() / switches.reflection_cc_name);
if (!fml::WriteAtomically(*switches.working_directory,
Utf8FromPath(reflection_cc_name).c_str(),
*compiler.GetReflector()->GetReflectionCC())) {
std::cerr << "Could not write reflection CC to "
<< switches.reflection_cc_name << std::endl;
return false;
}
}
return true;
@ -197,24 +162,7 @@ static bool OutputDepfile(const Compiler& compiler, const Switches& switches) {
///
if (!switches.depfile_path.empty()) {
std::string result_file;
switch (switches.SelectDefaultTargetPlatform()) {
case TargetPlatform::kMetalDesktop:
case TargetPlatform::kMetalIOS:
case TargetPlatform::kOpenGLES:
case TargetPlatform::kOpenGLDesktop:
case TargetPlatform::kRuntimeStageMetal:
case TargetPlatform::kRuntimeStageGLES:
case TargetPlatform::kRuntimeStageGLES3:
case TargetPlatform::kRuntimeStageVulkan:
case TargetPlatform::kSkSL:
case TargetPlatform::kVulkan:
result_file = Utf8FromPath(switches.sl_file_name);
break;
case TargetPlatform::kUnknown:
result_file = Utf8FromPath(switches.spirv_file_name);
break;
}
std::string result_file = Utf8FromPath(switches.sl_file_name);
auto depfile_path = std::filesystem::absolute(
std::filesystem::current_path() / switches.depfile_path);
if (!fml::WriteAtomically(*switches.working_directory,
@ -264,6 +212,11 @@ bool Main(const fml::CommandLine& command_line) {
// depfile.
SourceOptions options = switches.CreateSourceOptions();
// If there are multiple platform compile targets, the specific target
// platform that is used does not matter because the output files won't depend
// on the target platform. Arbitrarily choose the first one from
// PlatformsToCompile().
options.target_platform = switches.PlatformsToCompile().front();
// Invoke the compiler and generate reflection data for a single shader.

26
engine/src/flutter/impeller/compiler/switches.cc
View File

@ -25,12 +25,13 @@ static const std::map<std::string, TargetPlatform> kKnownPlatforms = {
{"opengl-desktop", TargetPlatform::kOpenGLDesktop},
};
static const std::map<std::string, TargetPlatform> kKnownRuntimeStages = {
{"sksl", TargetPlatform::kSkSL},
{"runtime-stage-metal", TargetPlatform::kRuntimeStageMetal},
{"runtime-stage-gles", TargetPlatform::kRuntimeStageGLES},
{"runtime-stage-gles3", TargetPlatform::kRuntimeStageGLES3},
{"runtime-stage-vulkan", TargetPlatform::kRuntimeStageVulkan},
static const std::vector<std::pair<std::string, TargetPlatform>>
kKnownRuntimeStages = {
{"sksl", TargetPlatform::kSkSL},
{"runtime-stage-metal", TargetPlatform::kRuntimeStageMetal},
{"runtime-stage-gles", TargetPlatform::kRuntimeStageGLES},
{"runtime-stage-gles3", TargetPlatform::kRuntimeStageGLES3},
{"runtime-stage-vulkan", TargetPlatform::kRuntimeStageVulkan},
};
static const std::map<std::string, SourceType> kKnownSourceTypes = {
@ -309,19 +310,8 @@ std::vector<TargetPlatform> Switches::PlatformsToCompile() const {
return {target_platform_};
}
TargetPlatform Switches::SelectDefaultTargetPlatform() const {
if (target_platform_ == TargetPlatform::kUnknown &&
!runtime_stages_.empty()) {
return runtime_stages_.front();
}
return target_platform_;
}
SourceOptions Switches::CreateSourceOptions(
std::optional<TargetPlatform> target_platform) const {
SourceOptions Switches::CreateSourceOptions() const {
SourceOptions options;
options.target_platform =
target_platform.value_or(SelectDefaultTargetPlatform());
options.source_language = source_language;
if (input_type == SourceType::kUnknown) {
options.type = SourceTypeFromFileName(source_file_name);

10
engine/src/flutter/impeller/compiler/switches.h
View File

@ -56,12 +56,12 @@ class Switches {
/// A vector containing at least one valid platform.
std::vector<TargetPlatform> PlatformsToCompile() const;
TargetPlatform SelectDefaultTargetPlatform() const;
// Creates source options from these switches for the specified
// TargetPlatform. Uses SelectDefaultTargetPlatform if not specified.
SourceOptions CreateSourceOptions(
std::optional<TargetPlatform> target_platform = std::nullopt) const;
// Creates source options from these switches. The returned options does not
// have a set TargetPlatform because that cannot be determined based purely
// on the switches. Clients must set a valid TargetPlatform on the returned
// options before before it is used.
SourceOptions CreateSourceOptions() const;
static void PrintHelp(std::ostream& stream);

1
engine/src/flutter/impeller/compiler/switches_unittests.cc
View File

@ -10,6 +10,7 @@
#include "flutter/fml/string_conversion.h"
#include "flutter/testing/testing.h"
#include "impeller/compiler/switches.h"
#include "impeller/compiler/types.h"
#include "impeller/compiler/utilities.h"
namespace impeller {

38
engine/src/flutter/impeller/compiler/types.cc
View File

@ -127,25 +127,6 @@ std::string EntryPointFunctionNameFromSourceName(
return stream.str();
}
bool TargetPlatformNeedsReflection(TargetPlatform platform) {
switch (platform) {
case TargetPlatform::kMetalIOS:
case TargetPlatform::kMetalDesktop:
case TargetPlatform::kOpenGLES:
case TargetPlatform::kOpenGLDesktop:
case TargetPlatform::kRuntimeStageMetal:
case TargetPlatform::kRuntimeStageGLES:
case TargetPlatform::kRuntimeStageGLES3:
case TargetPlatform::kRuntimeStageVulkan:
case TargetPlatform::kVulkan:
return true;
case TargetPlatform::kUnknown:
case TargetPlatform::kSkSL:
return false;
}
FML_UNREACHABLE();
}
std::string ShaderCErrorToString(shaderc_compilation_status status) {
using Status = shaderc_compilation_status;
switch (status) {
@ -312,24 +293,5 @@ bool TargetPlatformIsVulkan(TargetPlatform platform) {
FML_UNREACHABLE();
}
bool TargetPlatformBundlesSkSL(TargetPlatform platform) {
switch (platform) {
case TargetPlatform::kSkSL:
case TargetPlatform::kRuntimeStageMetal:
case TargetPlatform::kRuntimeStageGLES:
case TargetPlatform::kRuntimeStageGLES3:
case TargetPlatform::kRuntimeStageVulkan:
return true;
case TargetPlatform::kMetalDesktop:
case TargetPlatform::kMetalIOS:
case TargetPlatform::kUnknown:
case TargetPlatform::kOpenGLES:
case TargetPlatform::kOpenGLDesktop:
case TargetPlatform::kVulkan:
return false;
}
FML_UNREACHABLE();
}
} // namespace compiler
} // namespace impeller

4
engine/src/flutter/impeller/compiler/types.h
View File

@ -122,10 +122,6 @@ std::string EntryPointFunctionNameFromSourceName(
SourceLanguage source_language,
const std::string& entry_point_name);
bool TargetPlatformNeedsReflection(TargetPlatform platform);
bool TargetPlatformBundlesSkSL(TargetPlatform platform);
std::string ShaderCErrorToString(shaderc_compilation_status status);
shaderc_shader_kind ToShaderCShaderKind(SourceType type);

23
engine/src/flutter/impeller/fixtures/BUILD.gn
View File

@ -104,6 +104,22 @@ impellerc("runtime_stages") {
]
sl_file_extension = "iplr"
shader_target_flags = [
"--sksl",
"--runtime-stage-metal",
"--runtime-stage-gles",
"--runtime-stage-gles3",
"--runtime-stage-vulkan",
]
iplr = true
}
impellerc("runtime_stages_non_sksl") {
mnemonic = "IMPELLERC_IPLR"
shaders = [ "runtime_stage_simple_no_sksl.frag" ]
sl_file_extension = "iplr"
shader_target_flags = [
"--runtime-stage-metal",
"--runtime-stage-gles",
@ -172,7 +188,12 @@ test_fixtures("file_fixtures") {
}
fixtures +=
filter_include(get_target_outputs(":runtime_stages"), [ "*.iplr" ])
deps = [ ":runtime_stages" ]
fixtures += filter_include(get_target_outputs(":runtime_stages_non_sksl"),
[ "*.iplr" ])
deps = [
":runtime_stages",
":runtime_stages_non_sksl",
]
}
impellerc("flutter_gpu_shaders") {

9
engine/src/flutter/impeller/fixtures/runtime_stage_simple_no_sksl.frag Normal file
View File

@ -0,0 +1,9 @@
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
out vec4 frag_color;
void main() {
frag_color = vec4(1.0, 0.0, 0.0, 1.0);
}

14
engine/src/flutter/impeller/runtime_stage/runtime_stage_unittests.cc
View File

@ -471,12 +471,18 @@ TEST_P(RuntimeStageTest, ContainsExpectedShaderTypes) {
auto stages_result = OpenAssetAsRuntimeStage("ink_sparkle.frag.iplr");
ABSL_ASSERT_OK(stages_result);
auto stages = stages_result.value();
// Right now, SkSL gets implicitly bundled regardless of what the build rule
// for this test requested. After
// https://github.com/flutter/flutter/issues/138919, this may require a build
// rule change or a new test.
EXPECT_TRUE(stages[RuntimeStageBackend::kSkSL]);
EXPECT_TRUE(stages[RuntimeStageBackend::kOpenGLES]);
EXPECT_TRUE(stages[RuntimeStageBackend::kMetal]);
EXPECT_TRUE(stages[RuntimeStageBackend::kVulkan]);
}
TEST_P(RuntimeStageTest, ContainsExpectedShaderTypesNoSksl) {
auto stages_result =
OpenAssetAsRuntimeStage("runtime_stage_simple_no_sksl.frag.iplr");
ABSL_ASSERT_OK(stages_result);
auto stages = stages_result.value();
EXPECT_FALSE(stages[RuntimeStageBackend::kSkSL]);
EXPECT_TRUE(stages[RuntimeStageBackend::kOpenGLES]);
EXPECT_TRUE(stages[RuntimeStageBackend::kMetal]);
EXPECT_TRUE(stages[RuntimeStageBackend::kVulkan]);

70
engine/src/flutter/impeller/tools/compiler.gni
View File

@ -75,10 +75,6 @@ template("impellerc") {
shader_target_flags = []
}
sksl = false
foreach(shader_target_flag, shader_target_flags) {
sksl = shader_target_flag == "--sksl"
}
iplr = false
if (defined(invoker.iplr) && invoker.iplr) {
iplr = invoker.iplr
@ -91,7 +87,6 @@ template("impellerc") {
# Not needed on every path.
not_needed([
"iplr",
"sksl",
"shader_bundle",
"shader_bundle_output",
])
@ -181,11 +176,7 @@ template("impellerc") {
]
outputs = [ sl_output ]
} else if (sksl) {
# When SkSL is selected as a `shader_target_flags`, don't generate
# C++ reflection state. Nothing needs to use it and it's likely invalid
# given the special cases when generating SkSL.
# Note that this configuration is orthogonal to the "--iplr" flag
} else {
sl_output =
"$generated_dir/{{source_file_part}}.${invoker.sl_file_extension}"
sl_output_path = rebase_path(sl_output, root_build_dir)
@ -198,40 +189,39 @@ template("impellerc") {
]
outputs = [ sl_output ]
} else {
# The default branch. Here we just generate one shader along with all of
# its C++ reflection state.
sl_output =
"$generated_dir/{{source_file_part}}.${invoker.sl_file_extension}"
sl_output_path = rebase_path(sl_output, root_build_dir)
# Generate reflection state only if a non-runtime target is provided.
if (filter_include(shader_target_flags,
[
"--metal-ios",
"--metal-desktop",
"--opengl-es",
"--opengl-desktop",
"--vulkan",
]) != []) {
reflection_json_intermediate =
"$generated_dir/{{source_file_part}}.json"
reflection_header_intermediate = "$generated_dir/{{source_file_part}}.h"
reflection_cc_intermediate = "$generated_dir/{{source_file_part}}.cc"
reflection_json_intermediate = "$generated_dir/{{source_file_part}}.json"
reflection_header_intermediate = "$generated_dir/{{source_file_part}}.h"
reflection_cc_intermediate = "$generated_dir/{{source_file_part}}.cc"
reflection_json_path =
rebase_path(reflection_json_intermediate, root_build_dir)
reflection_header_path =
rebase_path(reflection_header_intermediate, root_build_dir)
reflection_cc_path =
rebase_path(reflection_cc_intermediate, root_build_dir)
spirv_intermediate = "$generated_dir/{{source_file_part}}.spirv"
spirv_intermediate_path = rebase_path(spirv_intermediate, root_build_dir)
reflection_json_path =
rebase_path(reflection_json_intermediate, root_build_dir)
reflection_header_path =
rebase_path(reflection_header_intermediate, root_build_dir)
reflection_cc_path =
rebase_path(reflection_cc_intermediate, root_build_dir)
args += [
"--reflection-json=$reflection_json_path",
"--reflection-header=$reflection_header_path",
"--reflection-cc=$reflection_cc_path",
]
args += [
"--sl=$sl_output_path",
"--spirv=$spirv_intermediate_path",
"--reflection-json=$reflection_json_path",
"--reflection-header=$reflection_header_path",
"--reflection-cc=$reflection_cc_path",
]
outputs = [
sl_output,
reflection_header_intermediate,
reflection_cc_intermediate,
]
outputs += [
reflection_header_intermediate,
reflection_cc_intermediate,
]
}
}
if (defined(invoker.defines)) {