Eu quero criar uma versão muito simples desse código, basicamente quero criar um…
- User
Eu quero criar uma versão muito simples desse código, basicamente quero criar um "buraco" só um raio(círculo), porém, ele vai ter a mesma projeção, etc:
import 'dart:typed_data'; import 'dart:ui' as ui; import 'dart:ui'; import 'package:flutter/material.dart'; import 'package:vector_math/vector_math_64.dart' hide Colors; import 'dart:math' as math;
class SpherePainter extends CustomPainter { final ui.Image texture;
Vector3 position = Vector3.zero(); final Vector3 scale = Vector3(1, 1, 1); Vector3 rotation = Vector3.zero();
Quaternion rotationQuat = Quaternion.identity();
// Geometria da esfera static List staticVertices = []; static List staticTexcoords = []; static List<List> staticIndices = []; static bool isSphereGenerated = false;
Matrix4 transform = Matrix4.identity(); final double radius = 2.55; final int latSegments = 8; // Ajustado para melhor performance final int lonSegments = 8;
List transformedVertices = [];
SpherePainter(this.texture, this.position, this.transform, this.rotation, this.rotationQuat) { if (!isSphereGenerated) { _generateSphere(); isSphereGenerated = true; } }
void _generateSphere() { for (int y = 0; y <= latSegments; ++y) { final double v = y / latSegments; final double sv = math.sin(v * math.pi); final double cv = math.cos(v * math.pi); for (int x = 0; x <= lonSegments; ++x) { final double u = x / lonSegments; staticVertices.add(Vector3( radius * math.cos(u * math.pi * 2.0) * sv, // X radius * cv, // Y radius * math.sin(u * math.pi * 2.0) * sv, // Z )); staticTexcoords.add(Offset(u, v)); // Coordenadas UV normalizadas } }
// Preenche os índices dos triângulos com ordem anti-horária consistente for (int y = 0; y < latSegments; ++y) { for (int x = 0; x < lonSegments; ++x) { final int current = (lonSegments + 1) * y + x; final int next = current + 1; final int below = (lonSegments + 1) * (y + 1) + x; final int belowNext = below + 1; staticIndices .add([current, below, next]); // Triângulo inferior esquerdo staticIndices .add([next, below, belowNext]); // Triângulo superior direito } }}
Matrix4 createPerspectiveMatrix( double fovY, double aspectRatio, double near, double far) { final double f = 1.0 / math.tan(fovY / 2.0); return Matrix4( f / aspectRatio, 0, 0, 0, 0, f, 0, 0, 0, 0, (far + near) / (near - far), -1, 0, 0, (2 * far * near) / (near - far), 0, ); }
void rotate(Vector3 axis, double angleRadians) { // Atualiza o quaternion de rotação, mas não aplica a transformação ainda Quaternion increment = Quaternion.axisAngle(axis, angleRadians); rotationQuat = increment * rotationQuat; }
void updateTransform() { // Parâmetros para a projeção em perspectiva double fovY = math.pi / 4; // Campo de visão (45 graus) double aspectRatio = 1; double near = 1; double far = 1000.0;
// Cria a matriz de projeção perspectiva final Matrix4 projection = createPerspectiveMatrix(fovY, aspectRatio, near, far); // Define a matriz de visualização (view) final Matrix4 view = Matrix4.identity() ..translate( 0.0, 0.0, -1001); // Coloque a câmera 5 unidades para trás no eixo Z // Atualiza a matriz de modelo com posição, rotação e escala final Matrix4 model = Matrix4.compose(position, rotationQuat, scale); // Multiplica para obter a matriz MVP final final Matrix4 mvp = projection * view * model; // Define a transformação final para os vértices transform.setFrom(mvp);}
/* void updateTransform(BuildContext context) { // Aplica a transformação baseada na rotação (rotationQuat), posição e escala final Matrix4 m = Matrix4.compose(position, rotationQuat, scale); transform.setFrom(m); } */
Offset getSphereCenterFromProjection(Size size) { Vector4 center3D = transform.transformed(Vector4(0, 0, 0, 1.0)); double x2D = center3D.x + size.width / 2; double y2D = center3D.y + size.height / 2; return Offset(x2D, y2D); }
Offset teste(Size size, Vector3 pos) { double x = pos.x + size.width / 2; double y = pos.y + size.height / 2;
return Offset(x, y);}
@override void paint(Canvas canvas, Size size) { Vector3 pos = Vector3(-47, 0, 0);
//Size size = const Size(330, 603); //print(a); // print(convertPositionTo2D(position, transform, 330, 603)); // canvas.drawCircle(convertPositionTo2D(position, transform, 330, 603), 15, // Paint()..color = Colors.black); //rotate(Vector3(math.sin(-rotateAngle), math.cos(rotateAngle), 0), angle); updateTransform(); canvas.drawCircle( getSphereCenterFromProjection(size), 6.3, Paint() ..color = Colors.white ..style = ui.PaintingStyle.stroke ..strokeWidth = 1.1); final Float32List positions = Float32List(staticVertices.length * 2); final Float32List renderTexcoords = Float32List(staticTexcoords.length * 2); // Transformar os vértices transformedVertices = List<Vector4>.filled(staticVertices.length, Vector4.zero()); for (int i = 0; i < staticVertices.length; i++) { transformedVertices[i] = transform.transformed(Vector4( staticVertices[i].x, staticVertices[i].y, staticVertices[i].z, 1.0)); // Projeção em perspectiva //double perspective = 10000.0; //double w = perspective / (perspective + transformedVertices[i].z); // Aplicar o deslocamento para centralizar no meio da tela positions[i * 2] = transformedVertices[i].x + size.width / 2; // X positions[i * 2 + 1] = transformedVertices[i].y + size.height / 2; // Y/* canvas.drawCircle( Offset(positions[i * 2] = transformedVertices[i].x + 330 / 2, positions[i * 2 + 1] = transformedVertices[i].y + 603 / 2), 3.12, Paint() ..color = const ui.Color.fromARGB(255, 255, 255, 255) ..strokeWidth = 0.001 ..style = PaintingStyle.stroke); */ Offset t = staticTexcoords[i];
// Corrected texture coordinates to fit the entire texture over the sphere double u = t.dx * texture.width; // Map U coordinate by texture width double v = t.dy * texture.height; // Map V coordinate by texture height renderTexcoords[i * 2] = u; // U renderTexcoords[i * 2 + 1] = v; // V } // Lista para armazenar triângulos visíveis List<Triangle> visibleTriangles = []; // Calcular e filtrar triângulos com base nas normais (Back-Face Culling) for (int i = 0; i < staticIndices.length; i++) { final int idx0 = staticIndices[i][0]; final int idx1 = staticIndices[i][1]; final int idx2 = staticIndices[i][2]; Vector4 v0 = transformedVertices[idx0]; Vector4 v1 = transformedVertices[idx1]; Vector4 v2 = transformedVertices[idx2]; // Vetores das arestas do triângulo Vector3 edge1 = Vector3(v1.x - v0.x, v1.y - v0.y, v1.z - v0.z); Vector3 edge2 = Vector3(v2.x - v0.x, v2.y - v0.y, v2.z - v0.z); // Normal do triângulo Vector3 normal = edge1.cross(edge2).normalized(); // Vetor de visão assumindo câmera no eixo Z positivo // Vector3 viewVector = Vector3(0, 0, 1); Vector3 viewVector = Vector3(0, 0, -1); // Produto escalar entre normal e vetor de visão double dotProduct = normal.dot(viewVector); // Se o dot product for positivo, o triângulo está voltado para a câmera if (dotProduct > 0) { // Calcular profundidade média para ordenação double depth = (v0.z + v1.z + v2.z) / 3.0; visibleTriangles.add(Triangle([idx0, idx1, idx2], depth)); } } // Ordenar triângulos do mais distante para o mais próximo visibleTriangles.sort((a, b) => b.depth.compareTo(a.depth)); // Preparar buffers para Vertices.raw List<int> renderedIndices = []; List<double> renderedPositions = []; List<double> renderedTexcoordsList = []; // Mapeamento de vértices únicos para evitar duplicações Map<int, int> vertexMap = {}; int currentIndex = 0; for (var tri in visibleTriangles) { for (int idx in tri.indices) { if (!vertexMap.containsKey(idx)) { vertexMap[idx] = currentIndex++; renderedPositions.add(positions[idx * 2]); renderedPositions.add(positions[idx * 2 + 1]); renderedTexcoordsList.add(renderTexcoords[idx * 2]); renderedTexcoordsList.add(renderTexcoords[idx * 2 + 1]); } renderedIndices.add(vertexMap[idx]!); } } if (renderedIndices.isEmpty) { return; // Nenhum triângulo visível para desenhar } final Uint16List indexBuffer = Uint16List.fromList(renderedIndices); final Float32List positionsBuffer = Float32List.fromList(renderedPositions); final Float32List texcoordsBuffer = Float32List.fromList(renderedTexcoordsList); final verticesData = Vertices.raw( VertexMode.triangles, positionsBuffer, textureCoordinates: texcoordsBuffer, indices: indexBuffer, ); final Float64List matrix4 = Matrix4.identity().storage; final paint = Paint() ..shader = ImageShader( texture, TileMode.clamp, TileMode.clamp, matrix4, ) ..blendMode = ui.BlendMode.srcOver; // Desenhar os triângulos visíveis ordenados por profundidade canvas.drawVertices(verticesData, BlendMode.srcOver, paint); canvas.drawCircle(getSphereCenterFromProjection(size) - const Offset(3, 2), 3.1, Paint()..color = const ui.Color.fromARGB(220, 255, 255, 255));}
@override bool shouldRepaint(covariant CustomPainter oldDelegate) { return true; } }
class Triangle { final List indices; final double depth;
Triangle(this.indices, this.depth); }
- Assistant
Para criar uma versão mais simples do seu código que desenha apenas um círculo, mas aplicando as mesmas transformações e projeções da esfera, você pode seguir os seguintes passos:
-
Remover o código de geração da esfera: Como você deseja desenhar apenas um círculo, não é necessário gerar a geometria complexa da esfera (vértices, índices, etc.).
-
Definir o círculo em espaço 3D: Crie um ponto central e um raio para o círculo em coordenadas 3D.
-
Aplicar as mesmas transformações e projeções: Utilize as matrizes de transformação e projeção existentes para transformar o centro e a borda do círculo.
-
Projetar o círculo no canvas 2D: Após as transformações, projete o círculo no plano 2D do canvas.
-
Desenhar o círculo: Use o método
canvas.drawCirclepara desenhar o círculo projetado.
Aqui está como você pode modificar seu código:
import 'dart:ui' as ui; import 'package:flutter/material.dart'; import 'package:vector_math/vector_math_64.dart' hide Colors; import 'dart:math' as math; class CirclePainter extends CustomPainter { final Vector3 position; // Posição do círculo no espaço 3D final Vector3 scale; // Escala do círculo final Vector3 rotation; // Rotação aplicada ao círculo Quaternion rotationQuat = Quaternion.identity(); final double radius; // Raio do círculo Matrix4 transform = Matrix4.identity(); CirclePainter({ required this.position, required this.scale, required this.rotation, required this.radius, }) { // Converter o vetor de rotação para um quaternion rotationQuat = Quaternion.euler( rotation.x, rotation.y, rotation.z, ); updateTransform(); } void updateTransform() { // Parâmetros para a projeção em perspectiva double fovY = math.pi / 4; // Campo de visão (45 graus) double aspectRatio = 1.0; double near = 1.0; double far = 1000.0; // Criar a matriz de projeção perspectiva final Matrix4 projection = makePerspectiveMatrix(fovY, aspectRatio, near, far); // Definir a matriz de visualização (view) final Matrix4 view = Matrix4.identity() ..translate(0.0, 0.0, -10.0); // Mover a câmera para trás no eixo Z // Atualizar a matriz de modelo com posição, rotação e escala final Matrix4 model = Matrix4.compose(position, rotationQuat, scale); // Multiplicar para obter a matriz MVP final final Matrix4 mvp = projection * view * model; // Definir a transformação final transform.setFrom(mvp); } @override void paint(Canvas canvas, Size size) { // Definir o centro do círculo em espaço 3D Vector4 circleCenter = Vector4(0, 0, 0, 1); // Transformar o ponto central Vector4 transformedCenter = transform.transform(circleCenter); // Projeção do ponto 3D para 2D dividindo por w (divisão de perspectiva) Offset center2D = Offset( (transformedCenter.x / transformedCenter.w) * size.width / 2 + size.width / 2, (-transformedCenter.y / transformedCenter.w) * size.height / 2 + size.height / 2, ); // Para calcular o raio projetado, transformamos um ponto na borda do círculo Vector4 circleEdge = Vector4(radius, 0, 0, 1); Vector4 transformedEdge = transform.transform(circleEdge); // Projetar o ponto da borda Offset edge2D = Offset( (transformedEdge.x / transformedEdge.w) * size.width / 2 + size.width / 2, (-transformedEdge.y / transformedEdge.w) * size.height / 2 + size.height / 2, ); // Calcular o raio projetado double projectedRadius = (edge2D - center2D).distance; // Desenhar o círculo Paint paint = Paint() ..color = Colors.white ..style = PaintingStyle.stroke ..strokeWidth = 2.0; canvas.drawCircle(center2D, projectedRadius, paint); } @override bool shouldRepaint(CustomPainter oldDelegate) => true; }Explicação:
-
Remoção da Geração da Esfera: Eliminamos todo o código relacionado à geração de vértices e índices da esfera.
-
Transformação do Centro e Raio do Círculo: Em vez de transformar múltiplos vértices, transformamos apenas o centro do círculo e um ponto na borda para calcular o raio projetado.
-
Projeção e Divisão por w: Após transformar os pontos, dividimos por
wpara realizar a divisão de perspectiva, essencial para projeções 3D corretas. -
Desenho do Círculo: Usamos
canvas.drawCirclepara desenhar o círculo com o centro e raio projetados.
Notas Adicionais:
-
Ajuste de Aspect Ratio e Coordenadas do Canvas: Certifique-se de ajustar o aspect ratio e o mapeamento de coordenadas conforme o tamanho do seu canvas.
-
Posicionamento da Câmera: Você pode ajustar a posição da câmera alterando a translação na matriz de visualização (
view).
Exemplo de Uso:
class MyWidget extends StatelessWidget { @override Widget build(BuildContext context) { return CustomPaint( size: Size(300, 300), painter: CirclePainter( position: Vector3(0, 0, 0), scale: Vector3(1, 1, 1), rotation: Vector3(0, 0, 0), radius: 50.0, // Ajuste o raio conforme necessário ), ); } }Neste exemplo, estamos desenhando um círculo no centro do canvas de tamanho 300x300 pixels. Você pode ajustar
position,scale,rotationeradiusde acordo com suas necessidades.Aplicando Textura (Opcional):
Se você deseja aplicar uma textura ao círculo, precisará implementar a geração de vértices que compõem o círculo e mapear as coordenadas de textura correspondentes. No entanto, isso adiciona complexidade similar à da esfera. Para manter a simplicidade, o exemplo acima desenha um círculo simples sem textura.
Considerações Finais:
- Este código simplificado remove a complexidade de gerar e renderizar uma esfera, concentrando-se em projetar e desenhar um único círculo com as transformações e projeções desejadas.
- Se você precisar aplicar rotações ao círculo, ajuste os componentes do vetor
rotation. - Certifique-se de testar e ajustar os parâmetros para obter o resultado visual que você deseja.
Espero que isso o ajude a criar a versão simplificada do seu código para desenhar um círculo com as mesmas projeções e transformações.
Referências:
Se tiver mais dúvidas, fique à vontade para perguntar!
-