Primeiros passos com o Flutter GPU
Crie renderers personalizados e renderize cenas 3D no Flutter.
A versão 3.24 do Flutter apresenta uma nova API gráfica de baixo nível chamada Flutter GPU. Também existe uma biblioteca de renderização 3D alimentada pelo Flutter GPU chamada
Flutter Scene (pacote: flutter_scene). Tanto o Flutter GPU quanto o Flutter Scene estão atualmente em prévia, disponíveis somente no
canal main do Flutter (por dependerem de recursos experimentais), exigem que o
Impeller esteja ativado, e podem introduzir breaking changes ocasionalmente.
Este artigo contém dois guias de "primeiros passos" para esses pacotes:
-
🔺 Avançado: Primeiros passos com o Flutter GPU Se você é um programador gráfico experiente ou se tem interesse em gráficos de baixo nível e quer construir renderizadores do zero no Flutter, este guia vai deixar você pronto para começar a experimentar o Flutter GPU. Você vai desenhar seu primeiro triângulo do zero… no Flutter!
-
💚 Intermediário: Renderização 3D com o Flutter Scene Se você é um desenvolvedor Flutter que quer adicionar funcionalidades 3D aos seus apps, ou quer criar jogos 3D usando Dart e Flutter, então este guia é para você! Você vai configurar um projeto que importa e renderiza assets 3D no Flutter.
Primeiros passos com o Flutter GPU
⚠️ Atenção! ⚠️ O Flutter GPU é, em última instância, uma API de baixo nível. É altamente provável que a grande maioria dos desenvolvedores Flutter que vão se beneficiar da existência do Flutter GPU façam isso consumindo bibliotecas de renderização de nível mais alto publicadas no pub.dev, como o pacote de renderização Flutter Scene. Se você não tem interesse na API do Flutter GPU em si e só quer renderização 3D, pule para Renderização 3D com o Flutter Scene.
O Flutter GPU é a API gráfica de baixo nível integrada do Flutter. Ela permite construir e integrar renderizadores customizados no Flutter escrevendo código Dart e shaders GLSL. Não é necessário código de plataforma nativa.
Atualmente, o Flutter GPU está em prévia inicial e oferece uma API básica de rasterização, mas mais funcionalidades continuarão sendo adicionadas e refinadas conforme a API se aproxima da versão estável.
O Flutter GPU também exige que o Impeller esteja ativado. Isso significa que ele só pode ser usado ao mirar em plataformas suportadas pelo Impeller. No momento em que escrevemos, o Impeller oferece suporte a:
iOS (ativado por padrão)
macOS (prévia com ativação opcional)
Android (prévia com ativação opcional)
Nosso objetivo com o Flutter GPU é, eventualmente, oferecer suporte a todas as plataformas-alvo do Flutter. A meta final é fomentar um ecossistema de soluções de renderização multiplataforma no Flutter que sejam fáceis de manter para os autores de pacotes e fáceis de instalar para os usuários.
A renderização 3D é apenas um dos casos de uso possíveis. O Flutter GPU também pode ser usado para construir renderizadores 2D especializados ou para fazer algo mais inusitado, como renderizar fatias 3D de um espaço 4D ou projetar espaços não euclidianos.
Um ótimo exemplo de caso de uso para um renderizador 2D customizado alimentado pelo Flutter GPU seriam os formatos de animação de personagens 2D que dependem de deformação de malha esquelética. O Spine 2D é um bom exemplo disso. Essas malhas esqueléticas normalmente têm clipes de animação que manipulam propriedades de translação, rotação e escala dos ossos em uma hierarquia, e cada vértice tem alguns "pesos de osso" associados que determinam quais ossos devem influenciar o vértice e em quanto.’
Com uma solução baseada em Canvas como drawVertices, as transformações de peso de osso precisariam ser aplicadas a cada vértice na CPU. Com o Flutter GPU, as transformações dos ossos poderiam ser enviadas a um vertex shader na forma de um array uniform ou até de um sampler de textura, permitindo que a posição final de cada vértice seja calculada em paralelo na GPU, com base no estado do esqueleto e nos pesos de osso de cada vértice.
Dito isso, vamos começar com o Flutter GPU por meio de uma introdução gentil: desenhar seu primeiro triângulo!

Adicione o Flutter GPU ao seu projeto
Primeiro, observe que o Flutter GPU está atualmente em um estado de prévia inicial e pode estar sujeito a quebras de API. Já é possível fazer bastante coisa com a API atual, mas engenheiros gráficos experientes podem notar a falta de algumas funcionalidades comuns. Muita coisa está planejada para o Flutter GPU nos próximos meses.
Por essas razões, é fortemente recomendado que, por enquanto, você trabalhe com a versão mais recente do canal main ao desenvolver pacotes com o Flutter GPU. Se você encontrar algum comportamento inesperado, bugs ou tiver pedidos de funcionalidades, abra issues usando os templates de issue do Flutter no GitHub. Todas as issues rastreadas relacionadas ao Flutter GPU recebem o rótulo flutter-gpu.
Então, antes de experimentar o Flutter GPU, mude o Flutter para o canal main executando os seguintes comandos.
flutter channel main
flutter upgrade
Agora, crie um projeto Flutter novo.
flutter create my_cool_renderer
cd my_cool_renderer
Em seguida, adicione o pacote SDK flutter_gpu ao seu pubspec.
flutter pub add flutter_gpu --sdk=flutter
Crie e importe bundles de shaders.
Para renderizar qualquer coisa com o Flutter GPU, você vai precisar escrever alguns shaders GLSL. Os shaders do Flutter GPU têm uma semântica diferente dos consumidos pelo recurso de fragment shader do Flutter, especialmente no que diz respeito aos bindings de uniforms. Você também vai definir um vertex shader para acompanhar o fragment shader.
Comece definindo os shaders mais simples possíveis. Você pode colocar os shaders em qualquer lugar do projeto, mas, para este exemplo, crie um
shaders e preencha com dois shaders: simple.vert e simple.frag
.
// Copy into: shaders/simple.vert
in vec2 position;
void main() {
gl_Position = vec4(position, 0.0, 1.0);
}
Ao desenhar o triângulo, você terá uma lista de dados que define cada vértice. Neste caso, ela lista apenas posições 2D. Para cada um desses vértices, um vertex shader simples atribui essas posições 2D à saída de clip space, o intrínseco
gl_Position.
// Copy into: shaders/simple.frag
out vec4 frag_color;
void main() {
frag_color = vec4(0, 1, 0, 1);
}
O fragment shader é ainda mais simples: ele produz uma cor RGBA com valores no intervalo de (0, 0, 0, 0)
a (1, 1, 1, 1). Assim, tudo será sombreado em verde.
Ok, agora que você tem seus shaders, compile-os usando o compilador de shaders ahead of time (AOT) do Flutter . Para configurar builds automatizados de bundles de shaders, recomendamos usar o pacote flutter_gpu_shaders.
Use o pub para adicionar flutter_gpu_shaders como uma dependência comum no seu projeto.
flutter pub add flutter_gpu_shaders
Os shaders do Flutter GPU são empacotados em arquivos .shaderbundle, que podem ser adicionados ao asset bundle do seu projeto como assets comuns. Os shader bundles contêm os códigos de shader compilados para as plataformas-alvo.
Em seguida, crie um arquivo de manifesto do shader bundle que descreve o conteúdo do bundle. Adicione o seguinte em
my_renderer.shaderbundle.json no diretório raiz do seu projeto.
{
"SimpleVertex": {
"type": "vertex",
"file": "shaders/simple.vert"
},
"SimpleFragment": {
"type": "fragment",
"file": "shaders/simple.frag"
}
}
Cada entrada do shader bundle pode ter um nome arbitrário. Neste caso, os nomes são "SimpleVertex" e "SimpleFragment". Esses nomes são usados para buscar os shaders no seu app.
Em seguida, use o pacote flutter_gpu_shaders para construir o shader bundle. Você pode adicionar um hook que dispara o build automaticamente ativando o recurso experimental "native assets". Use os comandos a seguir para ativar os native assets e instalar o pacote
native_assets_cli.
flutter config --enable-native-assets
flutter pub add native_assets_cli
Com o recurso native assets ativado, adicione um script build.dart na pasta hook
que vai disparar o build do shader bundle automaticamente.
// Copy into: hook/build.dart
import 'package:native_assets_cli/native_assets_cli.dart';
import 'package:flutter_gpu_shaders/build.dart';
void main(List<String> args) async {
await build(args, (config, output) async {
await buildShaderBundleJson(
buildConfig: config,
buildOutput: output,
manifestFileName: 'my_renderer.shaderbundle.json');
});
}
Depois dessa mudança, quando a ferramenta do Flutter estiver fazendo o build do projeto, buildShaderBundleJson constrói o shader bundle e grava o resultado em
build/shaderbundles/my_renderer.shaderbundle dentro da raiz do pacote.
O formato do shader bundle está atrelado à versão específica do Flutter que você está usando e pode mudar com o tempo. Se você estiver escrevendo um pacote que gera shader bundles,
não versione os arquivos .shaderbundle gerados no seu código-fonte. Em vez disso, use um build hook para automatizar o processo de build (como explicado anteriormente).
Assim, os desenvolvedores que usam sua biblioteca sempre vão gerar shader bundles novos e no formato correto!
Agora que você está construindo o shader bundle automaticamente, importe-o como um asset comum. Adicione uma entrada de asset ao
pubspec.yaml do seu projeto:
flutter:
assets:
- build/shaderbundles/
No futuro, o recurso native assets vai permitir que build hooks anexem data assets ao bundle. Quando isso acontecer, não será mais necessário adicionar uma regra de importação de asset junto com o build hook.
Em seguida, adicione código para carregar os shaders em tempo de execução. Crie lib/shaders.dart e adicione o seguinte código.
// Copy into: lib/shaders.dart
import 'package:flutter_gpu/gpu.dart' as gpu;
const String _kShaderBundlePath =
'build/shaderbundles/my_renderer.shaderbundle';
// NOTE: If you're building a library, the path must be prefixed
// with a package name. For example:
// 'packages/my_cool_renderer/build/shaderbundles/my_renderer.shaderbundle'
gpu.ShaderLibrary? _shaderLibrary;
gpu.ShaderLibrary get shaderLibrary {
if (_shaderLibrary != null) {
return _shaderLibrary!;
}
_shaderLibrary = gpu.ShaderLibrary.fromAsset(_kShaderBundlePath);
if (_shaderLibrary != null) {
return _shaderLibrary!;
}
throw Exception("Failed to load shader bundle! ($_kShaderBundlePath)");
}
Este código cria um getter singleton para a biblioteca de runtime de shaders do Flutter GPU. Na primeira vez que shaderLibrary
for acessado, a biblioteca de runtime de shaders é inicializada usando o asset bundle construído com gpu.ShaderLibrary.fromAsset(shader_bundle_path).
O projeto agora está configurado para usar shaders do Flutter GPU. Está na hora de renderizar aquele triângulo!
Desenhando seu primeiro triângulo
Para este guia, você vai criar uma Texture RGBA do Flutter GPU e uma RenderPass que anexa a textura como saída de cor. Depois, você vai renderizar o
Texture em um widget usando Canvas.drawImage.
Para simplificar, vamos abrir mão das boas práticas e simplesmente reconstruir todos os recursos a cada frame.
Desde que você marque sua Texture como "shader readable" ao alocá-la, poderá convertê-la em um dart:ui.Image. Para exibir os resultados renderizados na árvore de widgets, desenhe-a em um dart:ui.Canvas!
Você pode acessar uma Canvas estruturando a árvore de widgets com um custom painter. Substitua o conteúdo de lib/main.dart pelo seguinte:
import 'dart:typed_data';
import 'package:flutter/material.dart';
import 'package:flutter_gpu/gpu.dart' as gpu;
// NOTE: We made this earlier while setting up shader bundle imports!
import 'shaders.dart';
void main() {
runApp(const MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({super.key});
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter GPU Triangle Example',
home: CustomPaint(
painter: TrianglePainter(),
),
);
}
}
class TrianglePainter extends CustomPainter {
@override
void paint(Canvas canvas, Size size) {
// Attempt to access `gpu.gpuContext`.
// If Flutter GPU isn't supported, an exception will be thrown.
print('Default color format: ' +
gpu.gpuContext.defaultColorFormat.toString());
}
@override
bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
}
Agora, execute o app. Como lembrete, o Flutter GPU atualmente exige que o Impeller esteja ativado. Então, você precisa usar uma plataforma com suporte ao Impeller. Para este guia, vou usar o macOS.
flutter run -d macos --enable-impeller

Se o Flutter GPU estiver funcionando, você deverá ver o formato de cor padrão impresso no console.
flutter: Default color format: PixelFormat.b8g8r8a8UNormInt
Se o Impeller não estiver ativado, uma exceção é lançada ao tentar acessar gpu.gpuContext.
Exception: Flutter GPU requires the Impeller rendering backend to be enabled.
The relevant error-causing widget was:
CustomPaint
Para simplificar, daqui em diante você só vai modificar o método paint.
Para começar, crie uma Texture do Flutter GPU, limpe-a e depois exiba-a desenhando-a no
Canvas.
Crie uma Texture com o tamanho do Canvas. Um StorageMode precisa ser escolhido. Neste caso, você vai marcar a
Texture como devicePrivate, porque só vai usar instruções que acessam a memória da textura a partir do dispositivo (GPU).
final texture = gpu.gpuContext.createTexture(gpu.StorageMode.devicePrivate,
size.width.toInt(), size.height.toInt())!;
Se for sobrescrever os dados da textura enviando-os do host (CPU), use StorageMode.hostVisible
em vez disso.
A terceira opção disponível é StorageMode.deviceTransient, que é útil para anexos que não precisam existir além do tempo de vida de uma única RenderPass (assim, podem existir apenas na memória de tiles e não precisam ser apoiados por uma alocação de VRAM). Muitas vezes, texturas de depth/stencil se encaixam nesse critério.
Em seguida, defina um RenderTarget. Render targets contêm uma coleção de "anexos" que descrevem um layout de memória por fragmento e seu comportamento de configuração e finalização no início e no fim de um(a) RenderPass.
Basicamente, um RenderTarget é um descritor reutilizável para um RenderPass.
Por enquanto, defina um RenderTarget bem simples, composto de apenas um anexo de cor.
final renderTarget = gpu.RenderTarget.singleColor(
gpu.ColorAttachment(texture: texture, clearValue: Colors.lightBlue));
Observe que este código define o clearValue como azul-claro. Cada anexo tem um LoadAction
e um StoreAction que determinam o que deve acontecer com a memória de tiles efêmera do anexo no início e no fim do pass, respectivamente.
Por padrão, os anexos de cor são definidos como LoadAction.clear (que inicializa a memória de tiles com uma cor específica) e
StoreAction.store (que salva os resultados na alocação de VRAM da textura anexada).
Agora, crie um CommandBuffer, gere um RenderPass a partir dele usando o RenderTarget
de antes e, em seguida, envie imediatamente o CommandBuffer para limpar a textura.
final commandBuffer = gpu.gpuContext.createCommandBuffer();
final renderPass = commandBuffer.createRenderPass(renderTarget);
// ... draw calls will go here!
commandBuffer.submit();
Falta apenas desenhar a textura inicializada no Canvas!
final image = texture.asImage();
canvas.drawImage(image, Offset.zero, Paint());

Agora que você tem um RenderPass conectado aos resultados exibidos na tela, está pronto para começar a desenhar o triângulo. Para isso, configure o seguinte:
Um
RenderPipelinecriado a partir dos nossos shaders, eUm buffer acessível pela GPU contendo nossa geometria (três posições de vértices).
Criar o RenderPipeline é fácil. Você só precisa combinar um vertex shader e um fragment shader da sua biblioteca.
final vert = shaderLibrary['SimpleVertex']!;
final frag = shaderLibrary['SimpleFragment']!;
final pipeline = gpu.gpuContext.createRenderPipeline(vert, frag);
Agora, a geometria. Lembre-se de que o shader "SimpleVertex" tem apenas uma entrada: in vec2 position. Então, para desenhar os três vértices, você precisa de três conjuntos de dois números de ponto flutuante.
final vertices = Float32List.fromList([
-0.5, -0.5, // First vertex
0.5, -0.5, // Second vertex
0.0, 0.5, // Third vertex
]);
final verticesDeviceBuffer = gpu.gpuContext
.createDeviceBufferWithCopy(ByteData.sublistView(vertices))!;
Só falta vincular os novos recursos e chamar renderPass.draw() para finalizar a gravação da chamada de desenho.
renderPass.bindPipeline(pipeline);
final verticesView = gpu.BufferView(
verticesDeviceBuffer,
offsetInBytes: 0,
lengthInBytes: verticesDeviceBuffer.sizeInBytes,
);
renderPass.bindVertexBuffer(verticesView, 3);
renderPass.draw();
Se você executar o app, deverá ver agora um triângulo verde!

Uhuu, você construiu um renderizador do zero com Flutter, Dart e um pouquinho de GLSL!
Seja esta a sua primeira vez desenhando um triângulo ou você seja um veterano experiente em gráficos, espero que continue explorando o Flutter GPU e conheça os pacotes em que estamos trabalhando, como o Flutter Scene.
No futuro, esperamos publicar codelabs para iniciantes que vão mais fundo no comportamento padrão e nas boas práticas do Flutter GPU. Ainda não falamos sobre o layout de atributos de vértice, binding de texturas, uniforms e requisitos de alinhamento, blending de pipeline, anexos de depth e stencil, correção de perspectiva e muito mais!
Até lá, recomendo explorar o Flutter Scene como um exemplo mais abrangente de como usar o Flutter GPU.
Renderização 3D com o Flutter Scene
O Flutter Scene (pacote flutter_scene) é um novo pacote de scene graph 3D alimentado pelo Flutter GPU que permite que desenvolvedores Flutter importem modelos glTF animados e renderizem cenas 3D em tempo real.
A intenção é oferecer um pacote que torne fácil criar apps e jogos 3D interativos no Flutter.

Este pacote começou como uma extensão dart:ui para um renderizador 3D escrito em C++ e integrado diretamente ao runtime nativo do Flutter, mas foi reescrito com base no Flutter GPU, com uma interface mais flexível.
Assim como a própria API do Flutter GPU, o Flutter Scene está atualmente em um estado de prévia inicial e exige que o Impeller esteja ativado. O Flutter Scene geralmente acompanha as breaking changes da API do Flutter GPU, por isso é fortemente recomendado usar o canal main ao experimentar o Flutter Scene.
Agora, vamos criar um app com o Flutter Scene!
Configure um projeto Flutter Scene
Como é fortemente recomendado usar o Flutter Scene com o canal main, comece mudando para ele.
flutter channel main
flutter upgrade
Agora, crie um projeto Flutter novo.
flutter create my_3d_app
cd my_3d_app
O Flutter Scene depende do recurso experimental "native assets" para compilar shaders automaticamente. Você vai usar native assets daqui a pouco para configurar a importação automática de modelos 3D para o Flutter Scene.
Ative os native assets com o seguinte comando.
flutter config --enable-native-assets
E, por fim, adicione o Flutter Scene como dependência do projeto.
Você também vai precisar usar vários construtos vector_math ao interagir com a API do Flutter Scene, então adicione também o pacote
vector_math.
flutter pub add flutter_scene vector_math
Agora, importe um modelo 3D!
Importe um modelo 3D
Primeiro, você precisa de um modelo 3D para renderizar. Para este guia, você vai usar um asset de exemplo glTF comum: DamagedHelmet.glb. Veja como ele é.
Você pode baixá-lo no repositório de assets de exemplo do glTF hospedado no GitHub. Coloque DamagedHelmet.glb na raiz do seu projeto.
curl -O https://raw.githubusercontent.com/KhronosGroup/glTF-Sample-Models/main/2.0/DamagedHelmet/glTF-Binary/DamagedHelmet.glb
Assim como a maioria dos renderizadores 3D em tempo real, o Flutter Scene usa internamente um formato de modelo 3D especializado. Você pode converter binários glTF padrão (arquivos .glb) para esse formato usando o importador offline do Flutter Scene.
Adicione o pacote flutter_scene_importer ao projeto como uma dependência comum.
flutter pub add flutter_scene_importer
Nota: O importador vai compilar a si mesmo automaticamente usando o CMake quando for invocado. Então, certifique-se de instalar o CMake. Caso contrário, você vai encontrar erros do tipo “ProcessException: No such file or directory”.
Adicionar esse pacote torna possível invocar o importador manualmente usando dart run.
dart --enable-experiment=native-assets \
run flutter_scene_importer:import \
--input "path/to/my/source_model.glb" \
--output "path/to/my/imported_model.model"
Você pode executar o importador automaticamente usando um build hook de native assets. Para isso, primeiro instale native_assets_cli como uma dependência comum do projeto.
flutter pub add native_assets_cli
Agora você pode escrever o build hook. Crie hook/build.dart com o seguinte conteúdo.
import 'package:native_assets_cli/native_assets_cli.dart';
import 'package:flutter_scene_importer/build_hooks.dart';
void main(List<String> args) {
build(args, (config, output) async {
buildModels(buildConfig: config, inputFilePaths: [
'DamagedHelmet.glb',
]);
});
}
Usando o utilitário buildModels de flutter_scene_importer, forneça uma lista de modelos a serem construídos. Os caminhos são relativos à raiz de build do projeto.
Quando a ferramenta do Flutter estiver construindo o projeto, buildModels agora constrói o shader bundle e grava o resultado em
build/models/DamagedModel.model dentro da raiz do pacote.
O formato do modelo importado depende da versão específica do Flutter Scene que você usa e vai mudar com o tempo. Ao criar um app ou uma biblioteca que usa Flutter Scene, não versione os arquivos
.model gerados no seu código-fonte. Em vez disso, use um build hook para gerá-los a partir dos seus modelos de origem (como explicado antes).
Assim, você sempre vai gerar arquivos .model novos, com o formato correto, conforme atualizar o Flutter Scene ao longo do tempo!
Em seguida, importe o modelo como um asset comum. Adicione uma entrada de asset ao pubspec.yaml do seu projeto.
flutter:
assets:
- build/models/
No futuro, o recurso native assets vai permitir que build hooks anexem data assets ao bundle. Quando isso acontecer, não será mais necessário adicionar uma regra de importação de asset junto com o build hook.
Renderizando uma cena 3D
Agora, o código do app.
Primeiro, crie um widget stateful para manter um Scene entre os frames.
Você vai animar com base no tempo, então adicione o SingleTickerProviderStateMixin ao state, junto com um membro
elapsedSeconds.
import 'dart:math';
import 'package:flutter/material.dart';
import 'package:flutter/scheduler.dart';
import 'package:flutter_scene/camera.dart';
import 'package:flutter_scene/node.dart';
import 'package:flutter_scene/scene.dart';
import 'package:vector_math/vector_math.dart';
void main() {
runApp(const MyApp());
}
class MyApp extends StatefulWidget{
const MyApp({super.key});
@override
MyAppState createState() => MyAppState();
}
class MyAppState extends State<MyApp> with SingleTickerProviderStateMixin {
double elapsedSeconds = 0;
Scene scene = Scene();
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'My 3D app',
home: Placeholder(),
);
}
}
Rode o app como um teste de fumaça para garantir que não há erros. E lembre-se de habilitar o Impeller!
flutter run -d macos --enable-impeller

Antes de continuar, configure o ticker da animação. Sobrescreva initState em MyAppState
para chamar createTicker.
@override
void initState() {
createTicker((elapsed) {
setState(() {
elapsedSeconds = elapsed.inMilliseconds.toDouble() / 1000;
});
}).start();
super.initState();
}
Enquanto o widget estiver visível, o callback do ticker é invocado a cada frame. Chamar setState
faz este widget ser reconstruído a cada frame.
Em seguida, carregue o modelo 3D que você colocou no projeto antes e adicione-o à Scene.
Use Node.fromAsset para carregar o modelo do asset bundle. Coloque o código a seguir em
initState.
Node.fromAsset('build/models/DamagedHelmet.model').then((model) {
model.name = 'Helmet';
scene.add(model);
});
Node.fromAsset desserializa o modelo do asset bundle de forma assíncrona e resolve o Future<Node> retornado assim que ele estiver pronto para ser adicionado à cena.
O MyAppState.initState agora deve ficar assim:
@override
void initState() {
createTicker((elapsed) {
setState(() {
elapsedSeconds = elapsed.inMilliseconds.toDouble() / 1000;
});
}).start();
Node.fromAsset('build/models/DamagedHelmet.model').then((model) {
model.name = 'Helmet';
scene.add(model);
});
super.initState();
}
Mas você ainda não está renderizando a cena 3D! Para isso, use Scene.render, que recebe um
Canvas de UI, uma Camera do Flutter Scene e um tamanho.
Uma forma de acessar um Canvas é criar um CustomPainter:
class ScenePainter extends CustomPainter {
ScenePainter({required this.scene, required this.camera});
Scene scene;
Camera camera;
@override
void paint(Canvas canvas, Size size) {
scene.render(camera, canvas, viewport: Offset.zero & size);
}
@override
bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
}
Não esqueça de definir a sobrescrita de shouldRepaint para retornar true, assim o custom painter vai repintar sempre que houver uma reconstrução.
Por fim, adicione o CustomPainter à árvore de código-fonte.
@override
Widget build(BuildContext context) {
final painter = ScenePainter(
scene: scene,
camera: PerspectiveCamera(
position: Vector3(sin(elapsedSeconds) * 3, 2, cos(elapsedSeconds) * 3),
target: Vector3(0, 0, 0),
),
);
return MaterialApp(
title: 'My 3D app',
home: CustomPaint(painter: painter),
);
}
Esse código faz a câmera se mover em um círculo contínuo, sempre olhando para a origem.
Finalmente, inicie o app!
flutter run -d macos --enable-impeller

Aqui está o código-fonte completo que montamos.
import 'dart:math';
import 'package:flutter/material.dart';
import 'package:flutter_scene/camera.dart';
import 'package:flutter_scene/node.dart';
import 'package:flutter_scene/scene.dart';
import 'package:vector_math/vector_math.dart';
void main() {
runApp(const MyApp());
}
class MyApp extends StatefulWidget {
const MyApp({super.key});
@override
MyAppState createState() => MyAppState();
}
class MyAppState extends State<MyApp> with SingleTickerProviderStateMixin {
double elapsedSeconds = 0;
Scene scene = Scene();
@override
void initState() {
createTicker((elapsed) {
setState(() {
elapsedSeconds = elapsed.inMilliseconds.toDouble() / 1000;
});
}).start();
Node.fromAsset('build/models/DamagedHelmet.model').then((model) {
model.name = 'Helmet';
scene.add(model);
});
super.initState();
}
@override
Widget build(BuildContext context) {
final painter = ScenePainter(
scene: scene,
camera: PerspectiveCamera(
position: Vector3(sin(elapsedSeconds) * 3, 2, cos(elapsedSeconds) * 3),
target: Vector3(0, 0, 0),
),
);
return MaterialApp(
title: 'My 3D app',
home: CustomPaint(painter: painter),
);
}
}
class ScenePainter extends CustomPainter {
ScenePainter({required this.scene, required this.camera});
Scene scene;
Camera camera;
@override
void paint(Canvas canvas, Size size) {
scene.render(camera, canvas, viewport: Offset.zero & size);
}
@override
bool shouldRepaint(covariant CustomPainter oldDelegate) => true;
}
O futuro promissor do Flutter
Se você conseguiu seguir um destes guias e colocar algo para rodar: uhuu, parabéns!
Tanto o Flutter GPU quanto o Flutter Scene são iniciativas muito jovens, com suporte limitado a plataformas. Mas eu acho que um dia vamos olhar com carinho para esses começos humildes.
Com o esforço do Impeller, a equipe do Flutter assumiu a responsabilidade total pela pilha de renderização, porque precisávamos especializar o renderer para o caso de uso do Flutter. E agora estamos começando um novo capítulo da história do Flutter. Um em que VOCÊ, coletivamente, assume o controle da renderização!
O Flutter Scene começou como um componente em C++ dentro do Impeller, junto com o renderer de Canvas 2D, com uma extensão
dart:ui enxuta. Quando eu o estava construindo, já sabia que a engine do Flutter não seria o destino final dele.
O espaço de decisões de arquitetura para renderers 3D é vasto, e nenhum renderer 3D genérico consegue resolver bem todos os casos de uso. “Genérico” e “alta performance” costumam ser objetivos antagônicos.
No melhor dos casos, ser adequado em tudo quase garante excelência em nada.
No mundo da performance de renderização, a situação é ainda pior. Especializar-se para um caso de uso muitas vezes significa degradar a performance de outro.
Resumindo, não é possível entregar um renderer 3D genérico que resolva todos os casos de uso para todo mundo. Mas, ao expor as APIs de baixo nível necessárias para você construir as próprias soluções (Flutter GPU) e ao criar um renderer 3D genérico útil sobre elas, fácil de inspecionar e modificar pela comunidade (Flutter Scene), estamos abrindo espaço para que as pessoas desenvolvedoras do Flutter tenham baixo risco de obsolescência e uma alta recompensa.

Mal posso esperar para ver o que vocês vão criar com essas novas capacidades. Fiquem de olho nas próximas versões do Flutter Scene. Há muita coisa a caminho.
Enquanto isso, eu vou voltar ao trabalho.
Até breve. :)