Flutter Engine Uber Docs
Docs for the entire Flutter Engine repo.
 
Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | List of all members
flutter::gpu::ShaderLibrary Class Reference

An immutable collection of shaders loaded from a shader bundle asset. More...

#include <shader_library.h>

Inheritance diagram for flutter::gpu::ShaderLibrary:
flutter::RefCountedDartWrappable< ShaderLibrary > fml::RefCountedThreadSafe< T > tonic::DartWrappable fml::internal::RefCountedThreadSafeBase

Public Types

using ShaderMap = std::unordered_map< std::string, fml::RefPtr< Shader > >
 
- Public Types inherited from tonic::DartWrappable
enum  DartNativeFields {
  kPeerIndex ,
  kNumberOfNativeFields
}
 

Public Member Functions

fml::RefPtr< Shader > GetShader (const std::string &shader_name, Dart_Handle shader_wrapper) const
 
 ~ShaderLibrary () override
 
- Public Member Functions inherited from flutter::RefCountedDartWrappable< ShaderLibrary >
virtual void RetainDartWrappableReference () const override
 
virtual void ReleaseDartWrappableReference () const override
 
- Public Member Functions inherited from fml::RefCountedThreadSafe< T >
void Release () const
 
- Public Member Functions inherited from fml::internal::RefCountedThreadSafeBase
void AddRef () const
 
bool HasOneRef () const
 
void AssertHasOneRef () const
 
- Public Member Functions inherited from tonic::DartWrappable
 DartWrappable ()
 
virtual const DartWrapperInfo & GetDartWrapperInfo () const =0
 
Dart_Handle CreateDartWrapper (DartState *dart_state)
 
void AssociateWithDartWrapper (Dart_Handle wrappable)
 
void ClearDartWrapper ()
 
Dart_WeakPersistentHandle dart_wrapper () const
 

Static Public Member Functions

static fml::RefPtr< ShaderLibrary > MakeFromAsset (impeller::Context::BackendType backend_type, const std::string &name, std::string &out_error)
 
static fml::RefPtr< ShaderLibrary > MakeFromShaders (ShaderMap shaders)
 
static fml::RefPtr< ShaderLibrary > MakeFromFlatbuffer (impeller::Context::BackendType backend_type, std::shared_ptr< fml::Mapping > payload)
 
static void SetOverride (fml::RefPtr< ShaderLibrary > override_shader_library)
 Sets a return override for MakeFromAsset for testing purposes.
 

Additional Inherited Members

- Protected Member Functions inherited from fml::RefCountedThreadSafe< T >
 RefCountedThreadSafe ()
 
 ~RefCountedThreadSafe ()
 
- Protected Member Functions inherited from fml::internal::RefCountedThreadSafeBase
 RefCountedThreadSafeBase ()
 
 ~RefCountedThreadSafeBase ()
 
bool Release () const
 
void Adopt ()
 
- Protected Member Functions inherited from tonic::DartWrappable
virtual ~DartWrappable ()
 
- Static Protected Member Functions inherited from tonic::DartWrappable
static Dart_PersistentHandle GetTypeForWrapper (tonic::DartState *dart_state, const tonic::DartWrapperInfo &wrapper_info)
 

Detailed Description

An immutable collection of shaders loaded from a shader bundle asset.

Definition at line 21 of file shader_library.h.

Member Typedef Documentation

◆ ShaderMap

using flutter::gpu::ShaderLibrary::ShaderMap = std::unordered_map<std::string, fml::RefPtr<Shader> >

Definition at line 26 of file shader_library.h.

Constructor & Destructor Documentation

◆ ~ShaderLibrary()

flutter::gpu::ShaderLibrary::~ShaderLibrary ( )
overridedefault

Member Function Documentation

◆ GetShader()

fml::RefPtr< Shader > flutter::gpu::ShaderLibrary::GetShader ( const std::string &  shader_name,
Dart_Handle  shader_wrapper 
) const

Definition at line 334 of file shader_library.cc.

335 {
336 auto it = shaders_.find(shader_name);
337 if (it == shaders_.end()) {
338 return nullptr; // No matching shaders.
339 }
340 auto shader = it->second;
341
342 if (shader->dart_wrapper() == nullptr) {
343 shader->AssociateWithDartWrapper(shader_wrapper);
344 }
345 return shader;
346}

Referenced by InternalFlutterGpu_ShaderLibrary_GetShader().

◆ MakeFromAsset()

fml::RefPtr< ShaderLibrary > flutter::gpu::ShaderLibrary::MakeFromAsset ( impeller::Context::BackendType  backend_type,
const std::string &  name,
std::string &  out_error 
)
static

Definition at line 28 of file shader_library.cc.

31 {
32 if (override_shader_library_) {
33 return override_shader_library_;
34 }
35
36 auto dart_state = UIDartState::Current();
37 std::shared_ptr<AssetManager> asset_manager =
38 dart_state->platform_configuration()->client()->GetAssetManager();
39
40 std::unique_ptr<fml::Mapping> data = asset_manager->GetAsMapping(name);
41 if (data == nullptr) {
42 out_error = std::string("Asset '") + name + std::string("' not found.");
43 return nullptr;
44 }
45
46 return MakeFromFlatbuffer(backend_type, std::move(data));
47}
flutter::UIDartState::Current
static UIDartState * Current()
Definition ui_dart_state.cc:116
flutter::gpu::ShaderLibrary::MakeFromFlatbuffer
static fml::RefPtr< ShaderLibrary > MakeFromFlatbuffer(impeller::Context::BackendType backend_type, std::shared_ptr< fml::Mapping > payload)
Definition shader_library.cc:172
flutter::name
DEF_SWITCHES_START aot vmservice shared library name
Definition switch_defs.h:27
flutter::data
DEF_SWITCHES_START aot vmservice shared library Name of the *so containing AOT compiled Dart assets for launching the service isolate vm snapshot data
Definition switch_defs.h:36

References flutter::UIDartState::Current(), flutter::data, MakeFromFlatbuffer(), and flutter::name.

Referenced by InternalFlutterGpu_ShaderLibrary_InitializeWithAsset().

◆ MakeFromFlatbuffer()

fml::RefPtr< ShaderLibrary > flutter::gpu::ShaderLibrary::MakeFromFlatbuffer ( impeller::Context::BackendType  backend_type,
std::shared_ptr< fml::Mapping >  payload 
)
static

Definition at line 172 of file shader_library.cc.

174 {
175 if (payload == nullptr || !payload->GetMapping()) {
176 return nullptr;
177 }
178 if (!impeller::fb::shaderbundle::ShaderBundleBufferHasIdentifier(
179 payload->GetMapping())) {
180 return nullptr;
181 }
182 auto* bundle =
183 impeller::fb::shaderbundle::GetShaderBundle(payload->GetMapping());
184 if (!bundle) {
185 return nullptr;
186 }
187
188 const auto version = bundle->format_version();
189 const auto expected = static_cast<uint32_t>(
190 impeller::fb::shaderbundle::ShaderBundleFormatVersion::kVersion);
191 if (version != expected) {
192 VALIDATION_LOG << "Unsupported shader bundle format version: " << version
193 << ", expected: " << expected;
194 return nullptr;
195 }
196
197 ShaderLibrary::ShaderMap shader_map;
198
199 for (const auto* bundled_shader : *bundle->shaders()) {
200 const impeller::fb::shaderbundle::BackendShader* backend_shader =
201 GetShaderBackend(backend_type, bundled_shader);
202 if (!backend_shader) {
203 VALIDATION_LOG << "Failed to unpack shader \""
204 << bundled_shader->name()->c_str() << "\" from bundle.";
205 continue;
206 }
207
208 auto code_mapping = std::make_shared<fml::NonOwnedMapping>(
209 backend_shader->shader()->data(), //
210 backend_shader->shader()->size(), //
211 [payload = payload](auto, auto) {} //
212 );
213
214 std::vector<impeller::DescriptorSetLayout> descriptor_set_layouts;
215
216 std::unordered_map<std::string, Shader::UniformBinding> uniform_structs;
217 if (backend_shader->uniform_structs() != nullptr) {
218 for (const auto& uniform : *backend_shader->uniform_structs()) {
219 std::vector<impeller::ShaderStructMemberMetadata> members;
220 if (uniform->fields() != nullptr) {
221 for (const auto& struct_member : *uniform->fields()) {
222 members.push_back(impeller::ShaderStructMemberMetadata{
223 .type = FromUniformType(struct_member->type()),
224 .name = struct_member->name()->c_str(),
225 .offset = static_cast<size_t>(struct_member->offset_in_bytes()),
226 .size =
227 static_cast<size_t>(struct_member->element_size_in_bytes()),
228 .byte_length =
229 static_cast<size_t>(struct_member->total_size_in_bytes()),
230 .array_elements =
231 struct_member->array_elements() == 0
232 ? std::optional<size_t>(std::nullopt)
233 : static_cast<size_t>(struct_member->array_elements()),
234 });
235 }
236 }
237
238 uniform_structs[uniform->name()->str()] = Shader::UniformBinding{
239 .slot =
240 impeller::ShaderUniformSlot{
241 .name = uniform->name()->c_str(),
242 .ext_res_0 = static_cast<size_t>(uniform->ext_res_0()),
243 .set = static_cast<size_t>(uniform->set()),
244 .binding = static_cast<size_t>(uniform->binding()),
245 },
246 .metadata =
247 impeller::ShaderMetadata{
248 .name = uniform->name()->c_str(),
249 .members = members,
250 },
251 .size_in_bytes = static_cast<size_t>(uniform->size_in_bytes()),
252 };
253
254 descriptor_set_layouts.push_back(impeller::DescriptorSetLayout{
255 static_cast<uint32_t>(uniform->binding()),
256 impeller::DescriptorType::kUniformBuffer,
257 ToShaderStage(backend_shader->stage()),
258 });
259 }
260 }
261
262 std::unordered_map<std::string, Shader::TextureBinding> uniform_textures;
263 if (backend_shader->uniform_textures() != nullptr) {
264 for (const auto& uniform : *backend_shader->uniform_textures()) {
265 Shader::TextureBinding texture_binding;
266 texture_binding.slot = impeller::SampledImageSlot{
267 .name = uniform->name()->c_str(),
268 .texture_index = static_cast<size_t>(uniform->ext_res_0()),
269 .set = static_cast<size_t>(uniform->set()),
270 .binding = static_cast<size_t>(uniform->binding()),
271 };
272 texture_binding.metadata = impeller::ShaderMetadata{
273 .name = uniform->name()->c_str(),
274 .members = {},
275 };
276
277 uniform_textures[uniform->name()->str()] = texture_binding;
278
279 descriptor_set_layouts.push_back(impeller::DescriptorSetLayout{
280 static_cast<uint32_t>(uniform->binding()),
281 impeller::DescriptorType::kSampledImage,
282 ToShaderStage(backend_shader->stage()),
283 });
284 }
285 }
286
287 std::vector<impeller::ShaderStageIOSlot> inputs;
288 std::vector<impeller::ShaderStageBufferLayout> layouts;
289 if (backend_shader->stage() ==
290 impeller::fb::shaderbundle::ShaderStage::kVertex) {
291 auto inputs_fb = backend_shader->inputs();
292
293 inputs.reserve(inputs_fb->size());
294 size_t default_stride = 0;
295 for (const auto& input : *inputs_fb) {
296 impeller::ShaderStageIOSlot slot;
297 slot.name = input->name()->c_str();
298 slot.location = input->location();
299 slot.set = input->set();
300 slot.binding = input->binding();
301 slot.type = FromInputType(input->type());
302 slot.bit_width = input->bit_width();
303 slot.vec_size = input->vec_size();
304 slot.columns = input->columns();
305 slot.offset = input->offset();
306 inputs.emplace_back(slot);
307
308 default_stride +=
309 SizeOfInputType(input->type()) * slot.vec_size * slot.columns;
310 }
311 layouts = {impeller::ShaderStageBufferLayout{
312 .stride = default_stride,
313 .binding = 0u,
314 }};
315 }
316
317 auto shader = flutter::gpu::Shader::Make(
318 backend_shader->entrypoint()->str(),
319 ToShaderStage(backend_shader->stage()), std::move(code_mapping),
320 std::move(inputs), std::move(layouts), std::move(uniform_structs),
321 std::move(uniform_textures), std::move(descriptor_set_layouts));
322 shader_map[bundled_shader->name()->str()] = std::move(shader);
323 }
324
325 return fml::MakeRefCounted<flutter::gpu::ShaderLibrary>(
326 std::move(payload), std::move(shader_map));
327}
flutter::gpu::Shader::Make
static fml::RefPtr< Shader > Make(std::string entrypoint, impeller::ShaderStage stage, std::shared_ptr< fml::Mapping > code_mapping, std::vector< impeller::ShaderStageIOSlot > inputs, std::vector< impeller::ShaderStageBufferLayout > layouts, std::unordered_map< std::string, UniformBinding > uniform_structs, std::unordered_map< std::string, TextureBinding > uniform_textures, std::vector< impeller::DescriptorSetLayout > descriptor_set_layouts)
Definition shader.cc:38
flutter::gpu::ShaderLibrary::ShaderMap
std::unordered_map< std::string, fml::RefPtr< Shader > > ShaderMap
Definition shader_library.h:26
input
static int input(yyscan_t yyscanner)
flutter::gpu::GetShaderBackend
static const impeller::fb::shaderbundle::BackendShader * GetShaderBackend(impeller::Context::BackendType backend_type, const impeller::fb::shaderbundle::Shader *shader)
Definition shader_library.cc:155
flutter::gpu::FromUniformType
static impeller::ShaderType FromUniformType(impeller::fb::shaderbundle::UniformDataType uniform_type)
Definition shader_library.cc:95
flutter::gpu::FromInputType
static impeller::ShaderType FromInputType(impeller::fb::shaderbundle::InputDataType input_type)
Definition shader_library.cc:67
flutter::gpu::ToShaderStage
static impeller::ShaderStage ToShaderStage(impeller::fb::shaderbundle::ShaderStage stage)
Definition shader_library.cc:54
flutter::gpu::SizeOfInputType
static size_t SizeOfInputType(impeller::fb::shaderbundle::InputDataType input_type)
Definition shader_library.cc:127
flutter::size
it will be possible to load the file into Perfetto s trace viewer use test Running tests that layout and measure text will not yield consistent results across various platforms Enabling this option will make font resolution default to the Ahem test font on all disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
Definition switch_defs.h:241
impeller::SampledImageSlot
Metadata required to bind a combined texture and sampler.
Definition shader_types.h:98
impeller::SampledImageSlot::name
const char * name
The name of the uniform slot.
Definition shader_types.h:100
impeller::ShaderUniformSlot
Metadata required to bind a buffer.
Definition shader_types.h:81
impeller::ShaderUniformSlot::name
const char * name
The name of the uniform slot.
Definition shader_types.h:83
VALIDATION_LOG
#define VALIDATION_LOG
Definition validation.h:91

References impeller::ShaderStageIOSlot::binding, impeller::ShaderStageIOSlot::bit_width, impeller::ShaderStageIOSlot::columns, flutter::gpu::FromInputType(), flutter::gpu::FromUniformType(), flutter::gpu::GetShaderBackend(), input(), impeller::kSampledImage, impeller::kUniformBuffer, impeller::ShaderStageIOSlot::location, flutter::gpu::Shader::Make(), flutter::gpu::Shader::TextureBinding::metadata, impeller::ShaderMetadata::name, impeller::ShaderUniformSlot::name, impeller::SampledImageSlot::name, impeller::ShaderStageIOSlot::name, impeller::ShaderStageIOSlot::offset, impeller::ShaderStageIOSlot::set, flutter::set, flutter::size, flutter::gpu::SizeOfInputType(), flutter::gpu::Shader::UniformBinding::slot, flutter::gpu::Shader::TextureBinding::slot, impeller::ShaderStageBufferLayout::stride, flutter::gpu::ToShaderStage(), impeller::ShaderStructMemberMetadata::type, impeller::ShaderStageIOSlot::type, VALIDATION_LOG, and impeller::ShaderStageIOSlot::vec_size.

Referenced by impeller::testing::InstantiateTestShaderLibrary(), and MakeFromAsset().

◆ MakeFromShaders()

fml::RefPtr< ShaderLibrary > flutter::gpu::ShaderLibrary::MakeFromShaders ( ShaderMap  shaders)
static

Definition at line 49 of file shader_library.cc.

49 {
50 return fml::MakeRefCounted<flutter::gpu::ShaderLibrary>(nullptr,
51 std::move(shaders));
52}

◆ SetOverride()

void flutter::gpu::ShaderLibrary::SetOverride ( fml::RefPtr< ShaderLibrary >  override_shader_library)
static

Sets a return override for MakeFromAsset for testing purposes.

Definition at line 329 of file shader_library.cc.

330 {
331 override_shader_library_ = std::move(override_shader_library);
332}

Referenced by impeller::testing::InstantiateTestShaderLibrary().

The documentation for this class was generated from the following files: