Vertex cache ordering: the source
Open the live demo · Read the guide · View on GitHub
Regions the guide quotes: scramble (line 30), reorder (line 46), rebuild (line 57), check (line 99).
1/// A mesh whose triangle order is scrambled, then rebuilt for GPU cache reuse.
2library;
4import 'dart:math' as math;
5import 'dart:typed_data';
7import 'package:flutter3d/flutter3d.dart';
8import 'package:flutter3d_core/flutter3d_core.dart'
9 show averageCacheMissRatio, optimizeTriangleOrder, optimizeVertexFetch;
10import 'package:flutter3d_showcase/src/demo/demo.dart';
12/// The `vertex-cache` page: a sphere whose triangles were scrambled and then
13/// reordered. Its check is that the reorder improved cache locality.
14final class VertexCacheDemo extends ShowcaseDemo {
15 double _beforeRatio = 0.0;
16 double _afterRatio = 0.0;
17 late final int _originalVertexCount;
18 late final int _reorderedIndexCount;
21 void configureView(DemoContext context) {
22 context.orbit
23 ..distance = 5.5
24 ..pitch = 0.24
25 ..yaw = 0.4;
26 }
29 Scene build(DemoContext context) {
30 final MeshData sphere = const SphereShape(
31 radius: 1.1,
32 segments: 32,
33 rings: 16,
34 ).build();
35 final int triangleCount = sphere.triangleCount;
36 final List<int> order = List<int>.generate(triangleCount, (int i) => i)
37 ..shuffle(math.Random(7));
38 final Uint32List scrambled = Uint32List(sphere.indices.length);
39 for (var t = 0; t < triangleCount; t++) {
40 final int from = order[t] * 3;
41 scrambled[t * 3] = sphere.indices[from];
42 scrambled[t * 3 + 1] = sphere.indices[from + 1];
43 scrambled[t * 3 + 2] = sphere.indices[from + 2];
44 }
46 _beforeRatio = averageCacheMissRatio(scrambled);
47 final Uint32List cacheOrdered = optimizeTriangleOrder(
48 scrambled,
49 sphere.vertexCount,
50 );
51 final VertexFetchOrder fetch = optimizeVertexFetch(
52 cacheOrdered,
53 sphere.vertexCount,
54 );
55 _afterRatio = averageCacheMissRatio(cacheOrdered);
57 final int stride = sphere.layout.floatsPerVertex;
58 final Float32List vertices = Float32List(sphere.vertices.length);
59 for (var oldV = 0; oldV < sphere.vertexCount; oldV++) {
60 final int newV = fetch.oldToNew[oldV];
61 vertices.setRange(
62 newV * stride,
63 newV * stride + stride,
64 sphere.vertices,
65 oldV * stride,
66 );
67 }
68 final MeshData reordered = MeshData(
69 layout: sphere.layout,
70 vertices: vertices,
71 indices: fetch.indices,
72 );
73 _originalVertexCount = sphere.vertexCount;
74 _reorderedIndexCount = reordered.indexCount;
76 final Scene scene = Scene()
77 ..ambientColor = LinearColor(0.44, 0.5, 0.66)
78 ..ambientIntensity = 0.16 * LightNode.legacyUnit
79 ..add(
80 MeshNode(
81 DeviceMesh.upload(context.device, reordered),
82 RenderMaterial(
83 name: 'sphere',
84 baseColor: LinearColor.fromSrgb(0.3, 0.62, 0.86, 1.0),
85 roughness: 0.5,
86 ),
87 name: 'sphere',
88 ),
89 )
90 ..add(
91 LightNode(name: 'key', intensity: 3.2 * LightNode.legacyUnit)
92 ..setLocalForward(Vector3(-0.42, -0.8, -0.36)),
93 );
94 return scene;
95 }
98 void verify(Scene scene, FrameResult frame) {
99 if (_reorderedIndexCount == 0 ||
100 _originalVertexCount == 0 ||
101 _afterRatio > _beforeRatio ||
102 frame.drawCalls < 1) {
103 throw StateError('reordering the mesh did not improve cache locality');
104 }
105 }
106}