1

Matemática e desenvolvimento é possível ? #post::1

E ai Dev, como vão as suas habilidades matemáticas ? Ao confiar cegamente em abstrações de um framework, elas mais cedo ou mais tarde vazam

No Flutter, o GestureDetector resolve a maior parte dos problemas, até que o widget sofre uma rotação tridimensional e o ponteiro clica no vazio. É aí que a magia dos frameworks cede espaço à crua Álgebra Linear.

Enquanto grande parte da comunidade consome debates sobre: “Linguagem X é pior que Y” ou “ Qual stack da vez tem prioridade absoluta” o desenvolvimento de sistemas complexos e IA nos lembra de uma verdade inegável - hilario não é

  • Os fundamentos da computação e a matemática são mais importantes que o código em si .

Afinal, um modelo de linguagem (dispersão, e outros) é um algoritmo matemático encapsulado em um algoritmo computacional.

Para além disso, linguagens e frameworks executam suas tarefas com primor, por serem baseadas em teorias profundas de matemática aplicada tal como teoria dos tipos e grafos.

Sendo assim, a sua compreensão é primordial, na necessidade de aplicar comportamentos complexos no software. E esse foi o meu domingo

Durante o desenvolvimento do Quaternion, a aplicação precisou implementar um sistema rigoroso de localização de widgets filhos e rastreio de ponteiro com o fito de executar comandos cirúrgicos ( click, hover, pan, ... )

Uma tarefa trivial em layouts estáticos, mas complexa quando o widget sofre rotações, translações e deformações em um espaço tridimensional.

Contudo, ao adentrar as entranhas do framework Flutter (RenderObject), assustei-me com o grito "Transformação linear !"

O serviço responsável por gerenciar os eventos de ponteiro percorre a árvore de renderização de forma estruturada por meio de uma função muito especial, a saber o hitTest

Essa propagação não é aleatória, acontece através de um conjunto de regras bem definidas:

  • Verifica se a “posição” do ponteiro está contida na área geométrica do widget
  • Ou se está contida na área de seus widgets filhos, e assim se propaga

Note que, o segredo arquitetural está no fato de que "posição" não é uma coordenada cartesiana estática (x, y), mas sim o vetor resultante de uma transformação linear via *matriz 4x4* aplicada sobre o referencial do widget pai

O offset do ponteiro entra no topo da árvore, é transformado pela matriz de coordenadas homogêneas, propaga-se para o nível inferior e o loop continua. Isso é fascinante ! Pois essa fundação matemática resolve elegantemente qualquer complexidade espacial na UI.

Agora, porquê utilizar uma matriz 4x4 ?

Para quem teve o privilegio de estudar profundamente este assunto - principalmente com a obra clássica de Elon Langes - poderia argumentar que seria mais eficaz uma transformação envolvendo apenas matrizes 3x3 ou até mesmo 2x2.

  • Afinal, sabemos as bases do espaço vetorial e a renderização sempre é em um espaço bi-dimensional.

Com todo, essa percepção falha no que tange unificação de dependências. Se quisermos rotacionar ou deformar os elementos do E.V. podemos com primor fazer-los a partir de uma matriz, mas transladar não !

Sendo assim, para permitir que a translação seja feita através de uma multiplicação, a computação gráfica adota as coordenadas homogêneas. Adicionando uma dimensão extra (w=1w = 1) aos vetores e transformações.

Ou seja, o Flutter armazena seus dados em uma lista plana(FloatStorage) de 16 números Matrix4 (column-major order), que conceitualmente se organiza assim:

M=[sx00tx0sy0ty00sztzpxpypzw]M = \begin{bmatrix} s_x & 0 & 0 & t_x \\ 0 & s_y & 0 & t_y \\ 0 & 0 & s_z & t_z \\ p_x & p_y & p_z & w \end{bmatrix}
  • Submatriz 3x3 superior esquerda (Escala e Rotação): Controla o redimensionamento (sx,sy,szs_x, s_y, s_z) e as orientações angulares dos eixos.
  • Coluna de Translação (tx,ty,tzt_x, t_y, t_z): Os três elementos da última coluna (exceto o canto inferior) representam o deslocamento bruto nos eixos X, Y e Z. Exemplo: quando você arrasta a tela (pan), são esses valores que mudam.
  • Linha de Perspectiva (px,py,pzp_x, p_y, p_z): Usada para criar efeitos de profundidade tridimensional.
  • Fator de Escala Global (w): Geralmente igual a 1, controla a homogeneidade global da matriz.

Observe como essa engenharia é genial! Ao adicionar uma linha e uma coluna a mais, obtemos em cada posição do vetor resultante um valor definido pela velha multiplicação de matrizes que inclui nativamente a translação (quando w=1w = 1):

[1005001010000100001][xy01]=[x+50y+10001]\begin{bmatrix} 1 & 0 & 0 & 50 \\ 0 & 1 & 0 & 100 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} x \\ y \\ 0 \\ 1 \end{bmatrix} = \begin{bmatrix} x + 50 \\ y + 100 \\ 0 \\ 1 \end{bmatrix}

E com isso, ganhamos total previsibilidade sobre o comportamento espacial.

Um Paralelismo com Scene Graph

No fim do dia, a árvore de renderização do Flutter se comporta exatamente como o Scene Graph de uma engine gráfica de jogos (como Unity ou Unreal). O que chamamos de "widget filho" é, na arquitetura de baixo nível, apenas um nó em uma hierarquia de transformações afins onde cada pai propaga sua matriz de espaço local para o filho.

Para além do comum

Certamente, essa estrutura elegante serve de base para tarefas muito mais complexas, como converter as coordenadas cartesianas nativas da engine em coordenadas polares — sem perder a precisão na multiplicidade de widgets filhos.

Nota: vale relembrar que a multiplicação de matrizes é associativa, e não comutativa

Dentro do projeto Quaternion, utilizamos coordenadas polares/centradas para dispor a maioria dos componentes com os quais o usuário interage. Portanto, a pergunta deixa de ser "o widget está a uma distância x, y da borda?" para se tornar "a que x, y e ângulo θ\theta o widget está do centro?".

Dado o preâmbulo, podemos realizar essa transformação ! O primeiro passo é deslocar a origem (topo-esquerdo da tela) para o centro da aplicação e, em seguida, aplicá-la sobre a transformação existente do widget pai:

Tc=[100−size.width/20−10size.height/200100001]T_c = \begin{bmatrix} 1 & 0 & 0 & -size.width/2 \\ 0 & -1 & 0 & size.height / 2 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}

Observação: size é um getter do RenderObject, e a inversão dos sinais ocorre porque precisamos "descer" e "deslocar para a direita" a origem do sistema cartesiano para o centro do canvas.

Isso é equivalente a :

final toCenter = Matrix4.identity();
toCenter.setTranslation(Vector3(-size.width/2, size.height / 2, 0));
toCenter.setEntry(1, 1, -1);

play |>

O vídeo ilustra a aplicação direta desses conceitos: transformamos a posição do ponteiro para a perspectiva do canvas em coordenadas polares de modo a criar uma flecha que acompanha o movimento do mouse em tempo real.

Todo o código-fonte dessa implementação de rastreamento polar e transformações matriciais no motor do Flutter está aberto no repositório do Quaternion ( link acima ). Quem quiser otimizar ou sugerir melhorias na árvore de renderização, o PR é super bem-vindo !

Deixe nos comentários: em que momento do seu projeto atual a abstração do framework parou de funcionar e obrigou você a descer para os fundamentos teóricos da computação?

Carregando publicação patrocinada...