17181727464

Committed 04 Aug 2025 07:19PM UTC coverage: 26.702% (+0.3%) from 26.388%

Build # 17181727464

Build Type

push

github

Committed by

web-flow

Commit Message

Bump min SDK to 3.7, update dependencies, reformat (#348)

Run Details

496 of 1182 new or added lines in 55 files covered. (41.96%)

18 existing lines in 8 files now uncovered.

4463 of 16714 relevant lines covered (26.7%)

1.18 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/lib/src/vector_math_geometry/generators/ring_generator.dart

// Copyright (c) 2015, Google Inc. Please see the AUTHORS file for details.
// All rights reserved. Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

part of '../../../vector_math_geometry.dart';

class RingGenerator extends GeometryGenerator {
  late double _innerRadius;
  late double _outerRadius;
  late int _segments;
  late double _thetaStart;
  late double _thetaLength;
  late bool _stripTextureCoordinates;

  @override
  int get vertexCount => (_segments + 1) * 2;

  @override
  int get indexCount => _segments * 3 * 2;

  MeshGeometry createRing(
    double innerRadius,
    double outerRadius, {
    GeometryGeneratorFlags? flags,
    List<GeometryFilter>? filters,
    int segments = 64,
    double thetaStart = 0.0,
    double thetaLength = math.pi * 2.0,
    bool stripTextureCoordinates = true,
  }) {
    _innerRadius = innerRadius;
    _outerRadius = outerRadius;
    _segments = segments;
    _thetaStart = thetaStart;
    _thetaLength = thetaLength;
    _stripTextureCoordinates = stripTextureCoordinates;
    return createGeometry(flags: flags, filters: filters);
  }

  @override
  void generateVertexPositions(Vector3List positions, Uint16List indices) {
    final v = Vector3.zero();
    var index = 0;
    for (var i = 0; i <= _segments; i++) {
      final percent = i / _segments;
      v
        ..x = _innerRadius * math.cos(_thetaStart + percent * _thetaLength)
        ..z = _innerRadius * math.sin(_thetaStart + percent * _thetaLength);
      positions[index] = v;
      index++;
      v
        ..x = _outerRadius * math.cos(_thetaStart + percent * _thetaLength)
        ..z = _outerRadius * math.sin(_thetaStart + percent * _thetaLength);
      positions[index] = v;
      index++;
    }
    assert(index == vertexCount);
  }

  @override
  void generateVertexTexCoords(
    Vector2List texCoords,
    Vector3List positions,
    Uint16List indices,
  ) {
    if (_stripTextureCoordinates) {
      final v = Vector2.zero();
      var index = 0;
      for (var i = 0; i <= _segments; i++) {
        final percent = i / _segments;
        v
          ..x = 0.0
          ..y = percent;
        texCoords[index] = v;
        index++;
        v
          ..x = 1.0
          ..y = percent;
        texCoords[index] = v;
        index++;
      }
    } else {
      final v = Vector2.zero();
      var index = 0;
      for (var i = 0; i <= _segments; i++) {
        var position = positions[index];
        var x = (position.x / (_outerRadius + 1.0)) * 0.5;
        var y = (position.z / (_outerRadius + 1.0)) * 0.5;
        v
          ..x = x + 0.5
          ..y = y + 0.5;
        texCoords[index] = v;
        index++;
        position = positions[index];
        x = (position.x / (_outerRadius + 1.0)) * 0.5;
        y = (position.z / (_outerRadius + 1.0)) * 0.5;
        v
          ..x = x + 0.5
          ..y = y + 0.5;
        texCoords[index] = v;
        index++;
      }
      assert(index == vertexCount);
    }
  }

  @override
  void generateIndices(Uint16List indices) {
    var index = 0;
    final length = _segments * 2;
    for (var i = 0; i < length; i += 2) {
      indices[index + 0] = i + 0;
      indices[index + 1] = i + 1;
      indices[index + 2] = i + 3;
      indices[index + 3] = i + 0;
      indices[index + 4] = i + 3;
      indices[index + 5] = i + 2;
      index += 6;
    }
    assert(index == indexCount);
  }
}

1	// Copyright (c) 2015, Google Inc. Please see the AUTHORS file for details.
2	// All rights reserved. Use of this source code is governed by a BSD-style
3	// license that can be found in the LICENSE file.
4
5	part of '../../../vector_math_geometry.dart';
6
7	class RingGenerator extends GeometryGenerator {
8	late double _innerRadius;
9	late double _outerRadius;
10	late int _segments;
11	late double _thetaStart;
12	late double _thetaLength;
13	late bool _stripTextureCoordinates;
14
15	@override	×
16	int get vertexCount => (_segments + 1) * 2;	×
17
18	@override	×
19	int get indexCount => _segments * 3 * 2;	×
20
NEW 21	MeshGeometry createRing(	×
22	double innerRadius,
23	double outerRadius, {
24	GeometryGeneratorFlags? flags,
25	List<GeometryFilter>? filters,
26	int segments = 64,
27	double thetaStart = 0.0,
28	double thetaLength = math.pi * 2.0,
29	bool stripTextureCoordinates = true,
30	}) {
31	_innerRadius = innerRadius;	×
32	_outerRadius = outerRadius;	×
33	_segments = segments;	×
34	_thetaStart = thetaStart;	×
35	_thetaLength = thetaLength;	×
36	_stripTextureCoordinates = stripTextureCoordinates;	×
37	return createGeometry(flags: flags, filters: filters);	×
38	}
39
40	@override	×
41	void generateVertexPositions(Vector3List positions, Uint16List indices) {
42	final v = Vector3.zero();	×
43	var index = 0;
44	for (var i = 0; i <= _segments; i++) {	×
45	final percent = i / _segments;	×
46	v
47	..x = _innerRadius * math.cos(_thetaStart + percent * _thetaLength)	×
48	..z = _innerRadius * math.sin(_thetaStart + percent * _thetaLength);	×
49	positions[index] = v;	×
50	index++;	×
51	v
52	..x = _outerRadius * math.cos(_thetaStart + percent * _thetaLength)	×
53	..z = _outerRadius * math.sin(_thetaStart + percent * _thetaLength);	×
54	positions[index] = v;	×
55	index++;	×
56	}
57	assert(index == vertexCount);	×
58	}
59
60	@override	×
61	void generateVertexTexCoords(
62	Vector2List texCoords,
63	Vector3List positions,
64	Uint16List indices,
65	) {
66	if (_stripTextureCoordinates) {	×
67	final v = Vector2.zero();	×
68	var index = 0;
69	for (var i = 0; i <= _segments; i++) {	×
70	final percent = i / _segments;	×
71	v
72	..x = 0.0	×
73	..y = percent;	×
74	texCoords[index] = v;	×
75	index++;	×
76	v
77	..x = 1.0	×
78	..y = percent;	×
79	texCoords[index] = v;	×
80	index++;	×
81	}
82	} else {
83	final v = Vector2.zero();	×
84	var index = 0;
85	for (var i = 0; i <= _segments; i++) {	×
86	var position = positions[index];	×
87	var x = (position.x / (_outerRadius + 1.0)) * 0.5;	×
88	var y = (position.z / (_outerRadius + 1.0)) * 0.5;	×
89	v
90	..x = x + 0.5	×
91	..y = y + 0.5;	×
92	texCoords[index] = v;	×
93	index++;	×
94	position = positions[index];	×
95	x = (position.x / (_outerRadius + 1.0)) * 0.5;	×
96	y = (position.z / (_outerRadius + 1.0)) * 0.5;	×
97	v
98	..x = x + 0.5	×
99	..y = y + 0.5;	×
100	texCoords[index] = v;	×
101	index++;	×
102	}
103	assert(index == vertexCount);	×
104	}
105	}
106
107	@override	×
108	void generateIndices(Uint16List indices) {
109	var index = 0;
110	final length = _segments * 2;	×
111	for (var i = 0; i < length; i += 2) {	×
112	indices[index + 0] = i + 0;	×
113	indices[index + 1] = i + 1;	×
114	indices[index + 2] = i + 3;	×
115	indices[index + 3] = i + 0;	×
116	indices[index + 4] = i + 3;	×
117	indices[index + 5] = i + 2;	×
118	index += 6;	×
119	}
120	assert(index == indexCount);	×
121	}
122	}

google / vector_math.dart / 17181727464

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous