Perspectiva sobre o Flutter
Diversão com 3D e o widget Transform
tl;dr — O widget Transform permite fazer coisas incríveis nos seus apps Flutter. Aqui está um vídeo de um minuto mostrando o que desenvolvedores fizeram com widgets Transform:
Este artigo constrói um programa de demonstração simples que mostra como usar o widget Transform
para oferecer perspectiva 3D, uma demonstração gráfica da facilidade com que o Flutter consegue fazer algo que seria bastante difícil de implementar em um sistema baseado em widgets nativos. Também é divertido de brincar!
Aqui está o app que vamos construir em funcionamento (o pequeno círculo reflete a posição do dedo do usuário na tela):

Começando
Este exemplo começa com o app padrão familiar do Flutter, aquele que você obtém ao executar flutter create
ou usar sua IDE para gerar um novo projeto Flutter. Vamos acrescentar duas coisas novas a este app: um widget
Transform e um widget
GestureDetector
.
Primeiro, a transformação:
// v1: move default app to separate function with fixed name
// Add transform widget, rotate and perspective
import 'package:flutter/material.dart';
void main() => runApp(MyApp());
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Perspective',
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: MyHomePage(),
);
}
}
class MyHomePage extends StatefulWidget {
MyHomePage({Key key}) : super(key: key); // changed
@override
_MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePage> {
int _counter = 0;
Offset _offset = Offset(0.4, 0.7); // new
void _incrementCounter() {
setState(() {
_counter++;
});
}
@override
Widget build(BuildContext context) {
return Transform( // Transform widget
transform: Matrix4.identity()
..setEntry(3, 2, 0.001) // perspective
..rotateX(_offset.dy)
..rotateY(_offset.dx),
alignment: FractionalOffset.center,
child: _defaultApp(context),
);
}
_defaultApp(BuildContext context) { // new
return Scaffold(
appBar: AppBar(
title: Text('The Matrix 3D'), // changed
),
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Text(
'You have pushed the button this many times:',
),
Text(
'$_counter',
style: Theme.of(context).textTheme.display1,
),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: _incrementCounter,
tooltip: 'Increment',
child: Icon(Icons.add),
),
);
}
}
Executar este código mostra o app padrão sendo levemente transformado em 3D, com perspectiva:

Também removemos algumas coisas que não precisávamos, incluindo todos os comentários extras e (em homenagem ao Dart 2) todas as palavras-chave new. Para fins de demonstração, movemos a parte de layout do app padrão (o método build de _MyHomePageState) para um método separado chamado _defaultApp
(linhas 49–74). E, por simplicidade, definimos o título da AppBar na linha 52, em vez de passá-lo como parâmetro para MyHomePage.
Widget Transform
O widget Transform adicionado está nas linhas 39–46. Vamos analisá-lo mais de perto. O Transform recebe uma matriz de transformação 3D, que é uma Matrix4. Por que uma matriz 3D? O Flutter não serve para gráficos bidimensionais? Bem, mais ou menos.
Praticamente todos os smartphones, exceto os menos potentes, incluem GPUs incrivelmente rápidas, otimizadas para gráficos 3D. Isso significa que renderizar gráficos 3D é muito rápido. Consequentemente, quase tudo o que você vê no seu celular é renderizado em 3D, até as coisas 2D. Louco, né?
Definir a matriz de transformação nos permite manipular o que está sendo visualizado (em 3D, inclusive!). Transformações comuns incluem translação, rotação, escala e perspectiva. Para criar essa matriz, começamos com uma matriz identidade (linha 40) e depois aplicamos transformações a ela. As transformações não são comutativas, então precisamos aplicá-las na ordem certa. A matriz final completa será enviada à GPU para transformar os objetos renderizados.
Transformações são um assunto complicado, mas se você quiser saber mais, pode ler qualquer introdução a gráficos 3D sobre matrizes de transformação e coordenadas homogêneas.
Perspectiva
A primeira transformação (na linha 41) implementa a perspectiva. Perspectiva faz com que objetos mais distantes pareçam menores. Definir a linha 3, coluna 2 da matriz como 0.001 reduz a escala das coisas com base na distância.
De onde veio o número 0.001? Do nada! Você pode brincar com esse número para aumentar e diminuir a quantidade de perspectiva, algo como dar zoom com a lente de uma câmera. Quanto maior esse número, mais pronunciada é a perspectiva, o que faz parecer que você está mais perto do objeto visualizado.
O Flutter oferece uma função makePerspectiveMatrix
, mas esse método inclui argumentos para definir a proporção de aspecto, o campo de visão e os planos próximo e distante, bem mais do que precisamos. Então vamos definir diretamente o elemento necessário da matriz.
Rotações
Em seguida, nas linhas 42 e 43, aplicamos duas rotações com base no valor da variável _offset (da linha 29; mais tarde usaremos essa variável para acompanhar a posição do dedo do usuário). Curiosamente, a rotação em X é baseada no deslocamento em Y, e a rotação em Y é baseada no deslocamento em X. Por quê?

Considere esta imagem, que acrescenta setas verdes mostrando os eixos X e Y da tela. A origem padrão desses eixos é o canto superior esquerdo da tela (por isso o eixo Y aponta para baixo), mas nosso programa define a origem (na linha 44) como o centro da tela.
A rotação é definida em torno de um eixo, então rotateX define a rotação em torno do eixo X, que inclina na direção Y (cima-baixo). Da mesma forma,
rotateY inclina na direção X (esquerda-direita), em torno do eixo Y. Por isso rotateX
é controlado por _offset.dy, e rotateY é controlado por _offset.dx.
Também existe um eixo Z, cuja origem está na superfície da tela, perpendicular a ela, atravessando o celular e saindo pelas costas, de modo que o valor de Z fica positivo quanto mais distante um objeto está do espectador. Consequentemente, o método
rotateZ gira no plano da tela.
Interação
O segundo e último item que vamos acrescentar é um widget GestureDetector . Isso é muito fácil no Flutter.
// v2: add Gesture detector
import 'package:flutter/material.dart';
void main() => runApp(MyApp());
class MyApp extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Perspective',
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: MyHomePage(),
);
}
}
class MyHomePage extends StatefulWidget {
MyHomePage({Key key}) : super(key: key); // changed
@override
_MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePage> {
int _counter = 0;
Offset _offset = Offset.zero; // changed
void _incrementCounter() {
setState(() {
_counter++;
});
}
@override
Widget build(BuildContext context) {
return Transform( // Transform widget
transform: Matrix4.identity()
..setEntry(3, 2, 0.001) // perspective
..rotateX(0.01 * _offset.dy) // changed
..rotateY(-0.01 * _offset.dx), // changed
alignment: FractionalOffset.center,
child: GestureDetector( // new
onPanUpdate: (details) => setState(() => _offset += details.delta),
onDoubleTap: () => setState(() => _offset = Offset.zero),
child: _defaultApp(context),
)
);
}
_defaultApp(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: Text('The Matrix 3D'), // changed
),
body: Center(
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Text(
'You have pushed the button this many times:',
),
Text(
'$_counter',
style: Theme.of(context).textTheme.display1,
),
],
),
),
floatingActionButton: FloatingActionButton(
onPressed: _incrementCounter,
tooltip: 'Increment',
child: Icon(Icons.add),
),
);
}
}
Na linha 28, _offset é inicializado com zero. As linhas 44–48 definem um GestureDetector que detecta dois tipos de gestos: gestos de pan (por exemplo, um dedo se movendo pela tela) e gestos de toque duplo. A linha 45 soma a quantidade de movimento de pan (em pixels) a
_offset. A linha 46 zera _offset quando o usuário dá um toque duplo na tela. Para ambos os gestos,
setState() agenda a tela para ser redesenhada.
Por fim, as linhas 41 e 42 são modificadas para que o deslocamento (em pixels) seja multiplicado por um fator de 0.01, o que o torna melhor para usar na rotação (que é em radianos, em que uma rotação completa é 2π, aproximadamente 6.28, então uma rotação completa exige um movimento de pan de 628 pixels). Você pode brincar com o fator de escala para tornar a rotação mais ou menos sensível ao movimento do dedo. Além disso, o parâmetro de
rotateY é negado porque, conforme o dedo se move para a direita, a imagem gira no sentido anti-horário em torno do eixo Y (porque o eixo Y aponta para baixo).
Pronto!
No Flutter, quase tudo fica no próprio app (e não na plataforma), incluindo os widgets e o renderizador. Isso oferece grande flexibilidade. Neste caso, tivemos acesso fácil aos poderosos recursos oferecidos pela GPU e até a um widget que nos ajudou. Nossas mudanças consistem em apenas 13 linhas de código. Nada mal!
Observe que, depois de girar o app padrão em torno do eixo X ou Y, você pode ter dificuldade para tocar no FAB e incrementar o contador. O Flutter compensa a maioria das transformações, incluindo scale e rotateZ, então a UI ainda funcionará corretamente nesses casos, mas tem alguns problemas com transformações 3D completas. Estamos trabalhando para corrigir isso.
É claro que nenhum dos objetos do app padrão é de fato 3D. Todos são objetos 2D (planos), até as sombras falsas projetadas pela AppBar e pelo FAB. Mas isso não nos impede de girá-los no espaço 3D.
Ideias para continuar
Há muito o que você pode fazer com este programa simples, muitas vezes com apenas algumas linhas de código:
Faça as mesmas mudanças em algum app mais complexo que o app padrão.
Adicione uma rotação em torno do eixo Z, usando
rotateZ.-
Mude a quantidade de perspectiva para que seja um número negativo. O que você acha que vai acontecer?
-
Translade o FAB um pouco na direção Z negativa, para que ele flutue levemente acima do corpo do widget Scaffold. Para pontos extras, crie uma sombra “real” em vez de uma falsa.
-
Adicione uma animação para que, quando o dedo do usuário soltar a tela, o app continue girando, desacelerando até parar. Você pode fazer isso com o argumento
onPanEnddo GestureDetector, que fornece a velocidade do dedo (em pixels por segundo) no momento em que ele perde o contato com a tela. -
Crie uma transição 3D entre duas telas ou abas em um app. Por exemplo, como virar as páginas de um livro, ou uma tela girando e se transformando em outra.
Se você tiver outras ideias, me conte nos comentários.
ATUALIZAÇÃO: Um agradecimento ao artigo “Animação de flip 3D no Flutter”, que referencia este artigo para adicionar perspectiva a uma animação de flip, assim:
