update tests

thermion_dart/test/camera_tests.dart

@@ -54,169 +54,169 @@ void main() async {
       });
     });
 
-      test('getCameraProjectionMatrix', () async {
+    test('getCameraProjectionMatrix', () async {
-        await testHelper.withViewer((viewer) async {
+      await testHelper.withViewer((viewer) async {
-          var projectionMatrix = await viewer.getCameraProjectionMatrix();
+        var projectionMatrix = await viewer.getCameraProjectionMatrix();
-          print(projectionMatrix);
+        print(projectionMatrix);
-        });
-      });
-
-      test('getCameraCullingProjectionMatrix', () async {
-        await testHelper.withViewer((viewer) async {
-          // ignore: dead_code
-          var viewer = await testHelper.createViewer();
-          var matrix = await viewer.getCameraCullingProjectionMatrix();
-          print(matrix);
-        });
-      });
-
-      test('getCameraFrustum', () async {
-        await testHelper.withViewer((viewer) async {
-          var frustum = await viewer.getCameraFrustum();
-          print(frustum.plane5.normal);
-          print(frustum.plane5.constant);
-
-          var camera = await viewer.getMainCamera();
-
-          await camera.setLensProjection(
-              near: 10.0, far: 1000.0, aspect: 1.0, focalLength: 28.0);
-          frustum = await viewer.getCameraFrustum();
-          print(frustum.plane5.normal);
-          print(frustum.plane5.constant);
-        });
-      });
-
-      test('set orthographic projection', () async {
-        await testHelper.withViewer((viewer) async {
-          var camera = await viewer.getMainCamera();
-          await viewer.createGeometry(GeometryHelper.cube());
-
-          await camera.setProjection(
-              Projection.Orthographic, -0.05, 0.05, -0.05, 0.05, 0.05, 10000);
-          await testHelper.capture(
-              viewer, "camera_set_orthographic_projection");
-        });
-      });
-
-      test('set perspective projection/culling matrix', () async {
-        await testHelper.withViewer((viewer) async {
-          var camera = await viewer.getMainCamera();
-          final cube = await viewer.createGeometry(GeometryHelper.cube());
-
-          var fovY = pi / 2;
-          await camera.setProjectionMatrixWithCulling(
-              makePerspectiveMatrix(fovY, 1.0, 0.05, 10000), 0.05, 10000);
-
-          await testHelper.capture(viewer,
-              "camera_set_perspective_projection_culling_matrix_object_fov90");
-
-          // cube no longer visible when the far plane is moved closer to camera so cube is outside
-          fovY = 2 * (pi / 3);
-          await camera.setProjectionMatrixWithCulling(
-              makePerspectiveMatrix(fovY, 1.0, 0.05, 10000), 0.05, 10000);
-
-          await testHelper.capture(viewer,
-              "camera_set_perspective_projection_culling_matrix_object_fov120");
-        });
-      });
-
-      test('set custom projection/culling matrix (orthographic)', () async {
-        await testHelper.withViewer((viewer) async {
-          var camera = await viewer.getMainCamera();
-          final cube = await viewer.createGeometry(GeometryHelper.cube());
-
-          // cube is visible when inside the frustum, cube is visible
-          var projectionMatrix =
-              makeOrthographicMatrix(-10.0, 10.0, -10.0, 10.0, 0.05, 10000);
-          await camera.setProjectionMatrixWithCulling(
-              projectionMatrix, 0.05, 10000);
-
-          await testHelper.capture(
-              viewer, "camera_projection_culling_matrix_object_in_frustum");
-
-          // cube no longer visible when the far plane is moved closer to camera so cube is outside
-          projectionMatrix =
-              makeOrthographicMatrix(-10.0, 10.0, -10.0, 10.0, 0.05, 1);
-          await camera.setProjectionMatrixWithCulling(
-              projectionMatrix, 0.05, 1);
-          await testHelper.capture(viewer,
-              "camera_projection_culling_matrix_object_outside_frustum");
-        });
-      });
-
-      test('setting transform on camera updates model matrix (no parent)',
-          () async {
-        await testHelper.withViewer((viewer) async {
-          var cameraEntity = await viewer.getMainCameraEntity();
-          var camera = await viewer.getMainCamera();
-
-          await viewer.setTransform(
-              cameraEntity, Matrix4.translation(Vector3.all(1)));
-
-          var modelMatrix = await viewer.getCameraModelMatrix();
-          expect(modelMatrix.getColumn(3).x, 1.0);
-          expect(modelMatrix.getColumn(3).y, 1.0);
-          expect(modelMatrix.getColumn(3).z, 1.0);
-          expect(modelMatrix.getColumn(3).w, 1.0);
-        });
-      });
-
-      test('setting transform on camera updates model matrix (with parent)',
-          () async {
-        await testHelper.withViewer((viewer) async {
-          var cameraEntity = await viewer.getMainCameraEntity();
-          var camera = await viewer.getMainCamera();
-
-          var parent = await viewer.createGeometry(GeometryHelper.cube());
-
-          await viewer.setParent(camera.getEntity(), parent.entity);
-          await viewer.setTransform(
-              cameraEntity, Matrix4.translation(Vector3(1, 0, 0)));
-
-          var modelMatrix = await viewer.getCameraModelMatrix();
-          expect(modelMatrix.getColumn(3).x, 1.0);
-          expect(modelMatrix.getColumn(3).y, 0.0);
-          expect(modelMatrix.getColumn(3).z, 0.0);
-          expect(modelMatrix.getColumn(3).w, 1.0);
-
-          await viewer.setTransform(
-              parent.entity, Matrix4.translation(Vector3(0, 1, 0)));
-          modelMatrix = await viewer.getCameraModelMatrix();
-          expect(modelMatrix.getColumn(3).x, 1.0);
-          expect(modelMatrix.getColumn(3).y, 1.0);
-          expect(modelMatrix.getColumn(3).z, 0.0);
-          expect(modelMatrix.getColumn(3).w, 1.0);
-        });
-      });
-
-      test('create camera', () async {
-        await testHelper.withViewer((viewer) async {
-          await viewer.setCameraPosition(0, 0, 5);
-          await viewer.setBackgroundColor(1.0, 0.0, 1.0, 1.0);
-          await viewer.createGeometry(GeometryHelper.cube());
-          await testHelper.capture(viewer, "create_camera_main_camera");
-
-          var newCamera = await viewer.createCamera();
-          await newCamera.setTransform(Matrix4.translation(Vector3(0, 0, 4)));
-          newCamera.setLensProjection();
-          await viewer.setActiveCamera(newCamera);
-
-          expect(await viewer.getActiveCamera(), newCamera);
-
-          await testHelper.capture(viewer, "create_camera_new_camera");
-
-          final mainCamera = await viewer.getMainCamera();
-          await viewer.setActiveCamera(mainCamera);
-          expect(await viewer.getActiveCamera(), mainCamera);
-          await testHelper.capture(viewer, "create_camera_back_to_main");
-
-          expect(viewer.getCameraCount(), 2);
-          expect(viewer.getCameraAt(0), await viewer.getMainCamera());
-          expect(viewer.getCameraAt(1), newCamera);
-          await expectLater(
-              () => viewer.getCameraAt(2), throwsA(isA<Exception>()));
-        });
       });
     });
 
+    test('getCameraCullingProjectionMatrix', () async {
+      await testHelper.withViewer((viewer) async {
+        // ignore: dead_code
+        var viewer = await testHelper.createViewer();
+        var matrix = await viewer.getCameraCullingProjectionMatrix();
+        print(matrix);
+      });
+    });
+
+    test('getCameraFrustum', () async {
+      await testHelper.withViewer((viewer) async {
+        var frustum = await viewer.getCameraFrustum();
+        print(frustum.plane5.normal);
+        print(frustum.plane5.constant);
+
+        var camera = await viewer.getMainCamera();
+
+        await camera.setLensProjection(
+            near: 10.0, far: 1000.0, aspect: 1.0, focalLength: 28.0);
+        frustum = await viewer.getCameraFrustum();
+        print(frustum.plane5.normal);
+        print(frustum.plane5.constant);
+      });
+    });
+
+    test('set orthographic projection', () async {
+      await testHelper.withViewer((viewer) async {
+        var camera = await viewer.getMainCamera();
+        await viewer.createGeometry(GeometryHelper.cube());
+
+        await camera.setProjection(
+            Projection.Orthographic, -0.05, 0.05, -0.05, 0.05, 0.05, 10000);
+        await testHelper.capture(viewer, "camera_set_orthographic_projection");
+      });
+    });
+
+    test('set perspective projection/culling matrix', () async {
+      await testHelper.withViewer((viewer) async {
+        var camera = await viewer.getMainCamera();
+        final cube = await viewer.createGeometry(GeometryHelper.cube());
+
+        var fovY = pi / 2;
+        await camera.setProjectionMatrixWithCulling(
+            makePerspectiveMatrix(fovY, 1.0, 0.05, 10000), 0.05, 10000);
+
+        await testHelper.capture(viewer,
+            "camera_set_perspective_projection_culling_matrix_object_fov90");
+
+        // cube no longer visible when the far plane is moved closer to camera so cube is outside
+        fovY = 2 * (pi / 3);
+        await camera.setProjectionMatrixWithCulling(
+            makePerspectiveMatrix(fovY, 1.0, 0.05, 10000), 0.05, 10000);
+
+        await testHelper.capture(viewer,
+            "camera_set_perspective_projection_culling_matrix_object_fov120");
+      });
+    });
+
+    test('set custom projection/culling matrix (orthographic)', () async {
+      await testHelper.withViewer((viewer) async {
+        var camera = await viewer.getMainCamera();
+        final cube = await viewer.createGeometry(GeometryHelper.cube());
+
+        // cube is visible when inside the frustum, cube is visible
+        var projectionMatrix =
+            makeOrthographicMatrix(-10.0, 10.0, -10.0, 10.0, 0.05, 10000);
+        await camera.setProjectionMatrixWithCulling(
+            projectionMatrix, 0.05, 10000);
+
+        await testHelper.capture(
+            viewer, "camera_projection_culling_matrix_object_in_frustum");
+
+        // cube no longer visible when the far plane is moved closer to camera so cube is outside
+        projectionMatrix =
+            makeOrthographicMatrix(-10.0, 10.0, -10.0, 10.0, 0.05, 1);
+        await camera.setProjectionMatrixWithCulling(projectionMatrix, 0.05, 1);
+        await testHelper.capture(
+            viewer, "camera_projection_culling_matrix_object_outside_frustum");
+      });
+    });
+
+    test('setting transform on camera updates model matrix (no parent)',
+        () async {
+      await testHelper.withViewer((viewer) async {
+        var cameraEntity = await viewer.getMainCameraEntity();
+        var camera = await viewer.getMainCamera();
+
+        await viewer.setTransform(
+            cameraEntity, Matrix4.translation(Vector3.all(1)));
+
+        var modelMatrix = await viewer.getCameraModelMatrix();
+        expect(modelMatrix.getColumn(3).x, 1.0);
+        expect(modelMatrix.getColumn(3).y, 1.0);
+        expect(modelMatrix.getColumn(3).z, 1.0);
+        expect(modelMatrix.getColumn(3).w, 1.0);
+      });
+    });
+
+    test('setting transform on camera updates model matrix (with parent)',
+        () async {
+      await testHelper.withViewer((viewer) async {
+        var cameraEntity = await viewer.getMainCameraEntity();
+        var camera = await viewer.getMainCamera();
+
+        var parent = await viewer.createGeometry(GeometryHelper.cube());
+
+        await viewer.setParent(camera.getEntity(), parent.entity);
+        await viewer.setTransform(
+            cameraEntity, Matrix4.translation(Vector3(1, 0, 0)));
+
+        var modelMatrix = await viewer.getCameraModelMatrix();
+        expect(modelMatrix.getColumn(3).x, 1.0);
+        expect(modelMatrix.getColumn(3).y, 0.0);
+        expect(modelMatrix.getColumn(3).z, 0.0);
+        expect(modelMatrix.getColumn(3).w, 1.0);
+
+        await viewer.setTransform(
+            parent.entity, Matrix4.translation(Vector3(0, 1, 0)));
+        modelMatrix = await viewer.getCameraModelMatrix();
+        expect(modelMatrix.getColumn(3).x, 1.0);
+        expect(modelMatrix.getColumn(3).y, 1.0);
+        expect(modelMatrix.getColumn(3).z, 0.0);
+        expect(modelMatrix.getColumn(3).w, 1.0);
+      });
+    });
+
+    test('create camera', () async {
+      await testHelper.withViewer((viewer) async {
+        await viewer.setCameraPosition(0, 0, 5);
+        await viewer.setBackgroundColor(1.0, 0.0, 1.0, 1.0);
+        await viewer
+            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
+        await testHelper.capture(viewer, "create_camera_main_camera");
+
+        expect(viewer.getCameraCount(), 1);
+        var newCamera = await viewer.createCamera();
+        expect(viewer.getCameraCount(), 2);
+        await newCamera.setTransform(Matrix4.translation(Vector3(0, 0, 4)));
+        newCamera.setLensProjection();
+        await viewer.setActiveCamera(newCamera);
+
+        expect(await viewer.getActiveCamera(), newCamera);
+
+        await testHelper.capture(viewer, "create_camera_new_camera");
+
+        final mainCamera = await viewer.getMainCamera();
+        await viewer.setActiveCamera(mainCamera);
+        expect(await viewer.getActiveCamera(), mainCamera);
+        await testHelper.capture(viewer, "create_camera_back_to_main");
+
+        expect(viewer.getCameraCount(), 2);
+        expect(viewer.getCameraAt(0), await viewer.getMainCamera());
+        expect(viewer.getCameraAt(1), newCamera);
+        await expectLater(
+            () => viewer.getCameraAt(2), throwsA(isA<Exception>()));
+      });
+    });
+  });
 }

thermion_dart/test/geometry_tests.dart

@@ -15,6 +15,10 @@ void main() async {
   group("custom geometry", () {
     test('create cube (no normals/uvs)', () async {
       await testHelper.withViewer((viewer) async {
+        var viewMatrix =
+            makeViewMatrix(Vector3(0, 2, 5), Vector3.zero(), Vector3(0, 1, 0));
+        viewMatrix.invert();
+        await viewer.setCameraModelMatrix4(viewMatrix);
         final cube = await viewer
             .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
         await testHelper.capture(viewer, "geometry_cube_no_normals_uvs");
@@ -47,22 +51,18 @@ void main() async {
     test('create cube with lit ubershader material (normals/ no uvs)',
         () async {
       await testHelper.withViewer((viewer) async {
-        final materialInstance =
+        final materialInstance = await viewer.createUbershaderMaterialInstance(
-            await viewer.createUbershaderMaterialInstance(
+            unlit: false, alphaMode: AlphaMode.BLEND, hasVertexColors: false);
-              unlit: false,
-              alphaMode: AlphaMode.BLEND,
-            hasVertexColors:false);
         await materialInstance.setParameterFloat4(
             "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
         final cube = await viewer.createGeometry(
-          GeometryHelper.cube(normals: true, uvs: false),
+            GeometryHelper.cube(normals: true, uvs: false),
-          materialInstances: [materialInstance]
+            materialInstances: [materialInstance]);
-        );
 
         await viewer.addDirectLight(DirectLight.sun(
-          intensity: 100000,
+            intensity: 100000,
-          castShadows: false,
+            castShadows: false,
-          direction: Vector3(0,-0.5,-1)));
+            direction: Vector3(0, -0.5, -1)));
         // await viewer.addDirectLight(DirectLight.spot(
         //   intensity: 1000000,
         //   position: Vector3(0,3,3),
@@ -256,15 +256,13 @@ void main() async {
       await testHelper.capture(viewer, "geometry_sphere_no_normals");
     });
 
-    // test('create geometry instance', () async {
+    test('create camera geometry', () async {
-    //   var viewer = await testHelper.createViewer(
+      await testHelper.withViewer((viewer) async {
-    //       cameraPosition: Vector3(0, 0, 6), bg: kRed);
+        final camera = await viewer.createGeometry(
-    //   final cube = await viewer
+            GeometryHelper.wireframeCamera(normals: false, uvs: false));
-    //       .createGeometry(GeometryHelper.sphere(normals: false, uvs: false));
+        await viewer.setTransform(camera.entity, Matrix4.rotationY(pi / 4));
-    //   await viewer.setTransform(cube.entity, Matrix4.translation(Vector3(2, 1, 1)));
+        await testHelper.capture(viewer, "camera_geometry");
-    //   final cube2 = await viewer.createInstance(cube);
+      });
-    //   await viewer.setTransform(cube2.entity, Matrix4.translation(Vector3(-2, 1, 1)));
+    });
-    //   await testHelper.capture(viewer, "geometry_instance");
-    // });
   });
 }

thermion_dart/test/overlay_tests.dart

@@ -12,6 +12,17 @@ void main() async {
   final testHelper = TestHelper("overlay");
 
   group("overlay tests", () {
+    group("grid", () {
+      test('enable grid', () async {
+        await testHelper.withViewer((viewer) async {
+          await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
+          await testHelper.capture(viewer, "enable_grid");
+          await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, false);
+          await testHelper.capture(viewer, "disable_grid");
+        }, postProcessing: true);
+      });
+    });
+
     group("stencil", () {
       test('set stencil highlight for geometry', () async {
         await testHelper.withViewer((viewer) async {
@@ -47,24 +58,6 @@ void main() async {
         }, postProcessing: true, bg: kWhite);
       });
 
-      test('add gizmo', () async {
-        await testHelper.withViewer((viewer) async {
-          var cube = await viewer.createGeometry(GeometryHelper.cube());
-
-          final view = await viewer.getViewAt(0);
-          final gizmo = await viewer.createGizmo(view);
-          await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
-          await viewer.addEntityToScene(gizmo);
-          await viewer.setTransform(gizmo, Matrix4.identity());
-          // await gizmo.attach(cube.entity);
-
-          await testHelper.capture(viewer, "gizmo_attached");
-
-          // await gizmo.detach();
-
-          // await testHelper.capture(viewer, "gizmo_detached");
-        }, postProcessing: true, bg: kWhite);
-      });
     });
   });
 

thermion_dart/test/picking_tests.dart

@@ -0,0 +1,36 @@
+import 'dart:async';
+import 'package:thermion_dart/thermion_dart.dart';
+import 'package:test/test.dart';
+import 'helpers.dart';
+
+void main() async {
+  final testHelper = TestHelper("picking");
+  group("picking", () {
+    test('pick cube', () async {
+      await testHelper.withViewer((viewer) async {
+        final cube = await viewer
+            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
+        await viewer.setCameraPosition(0, 0, 10);
+        final view = await viewer.getViewAt(0);
+        final viewport = await view.getViewport();
+
+        final completer = Completer<PickResult>();
+        
+        await viewer.pick(viewport.width ~/ 2, viewport.height ~/ 2, (result) {
+          completer.complete(result);
+        });
+
+        for (int i = 0; i < 10; i++) {
+          await testHelper.capture(viewer, "pick_cube0");
+          if (completer.isCompleted) {
+            break;
+          }
+        }
+
+        expect(completer.isCompleted, true);
+        var result = await completer.future;
+        expect(result.entity, cube.entity);
+      });
+    });
+  });
+}

thermion_dart/test/transform_tests.dart

@@ -0,0 +1,45 @@
+// ignore_for_file: unused_local_variable
+
+import 'package:thermion_dart/thermion_dart.dart';
+import 'package:test/test.dart';
+
+import 'package:vector_math/vector_math_64.dart';
+
+import 'helpers.dart';
+
+void main() async {
+  final testHelper = TestHelper("transforms");
+  group("transforms", () {
+    test('set/unset parent geometry', () async {
+      await testHelper.withViewer((viewer) async {
+        var blueMaterialInstance = await viewer.createUnlitMaterialInstance();
+        final blueCube = await viewer.createGeometry(GeometryHelper.cube(normals: false, uvs: false),
+            materialInstances: [blueMaterialInstance]);
+        await blueMaterialInstance.setParameterFloat4(
+            "baseColorFactor", 0.0, 0.0, 1.0, 1.0);
+
+        // Position blue cube slightly behind and to the right
+        await viewer.setTransform(
+            blueCube.entity, Matrix4.translation(Vector3(1.0, 0.0, -1.0)));
+
+        var greenMaterialInstance = await viewer.createUnlitMaterialInstance();
+        final greenCube = await viewer.createGeometry(GeometryHelper.cube(normals: false, uvs: false),
+            materialInstances: [greenMaterialInstance]);
+        await greenMaterialInstance.setParameterFloat4(
+            "baseColorFactor", 0.0, 1.0, 0.0, 1.0);
+
+        await testHelper.capture(viewer, "before_parent");
+        await viewer.setParent(blueCube.entity, greenCube.entity);
+
+        await viewer.setTransform(
+            greenCube.entity, Matrix4.translation(Vector3.all(-1)));
+
+        await testHelper.capture(viewer, "after_parent");
+
+        await viewer.setParent(blueCube.entity, null);
+
+        await testHelper.capture(viewer, "unparent");
+      });
+    });
+  });
+}

thermion_dart/test/view_tests.dart

@@ -12,135 +12,146 @@ void main() async {
 
   group('view tests', () {
     test('get camera from view', () async {
-      var viewer = await testHelper.createViewer();
+      await testHelper.withViewer((viewer) async {
-      var view = await viewer.getViewAt(0);
+        var view = await viewer.getViewAt(0);
-      expect(await view.getCamera(), isNotNull);
+        expect(await view.getCamera(), isNotNull);
-
+      });
-      await viewer.dispose();
     });
 
     test('one swapchain, render view to render target', () async {
-      var viewer = await testHelper.createViewer();
+      await testHelper.withViewer((viewer) async {
+        final texture = await testHelper.createTexture(500, 500);
+        final renderTarget = await viewer.createRenderTarget(
+            500, 500, texture.metalTextureAddress);
+        viewer.setRenderTarget(renderTarget);
 
-      final texture = await testHelper.createTexture(500, 500);
+        await viewer.setBackgroundColor(1.0, 0, 0, 1);
-      final renderTarget = await viewer.createRenderTarget(
+        final cube = await viewer
-          500, 500, texture.metalTextureAddress);
+            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
-      viewer.setRenderTarget(renderTarget);
 
-      await viewer.setBackgroundColor(1.0, 0, 0, 1);
+        var mainCamera = await viewer.getMainCamera();
-      final cube = await viewer.createGeometry(GeometryHelper.cube());
+        mainCamera.setTransform(Matrix4.translation(Vector3(0, 0, 5)));
-
+        await testHelper.capture(
-      var mainCamera = await viewer.getMainCamera();
+            viewer,
-      mainCamera.setTransform(Matrix4.translation(Vector3(0, 0, 5)));
+            renderTarget: renderTarget,
-      await testHelper.capture(
+            "default_swapchain_default_view_render_target");
-          viewer,
+      });
-          renderTarget: renderTarget,
-          "default_swapchain_default_view_render_target");
-
-      await viewer.dispose();
     });
 
     test('create secondary view, default swapchain', () async {
-      var viewer = await testHelper.createViewer();
+      await testHelper.withViewer((viewer) async {
-      await viewer.setBackgroundColor(1.0, 0, 0, 1);
+        final cube = await viewer
+            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
 
-      final cube = await viewer.createGeometry(GeometryHelper.cube());
+        var mainCamera = await viewer.getMainCamera();
+        mainCamera.setTransform(Matrix4.translation(Vector3(0, 0, 5)));
+        await testHelper.capture(viewer, "default_swapchain_default_view");
 
-      var mainCamera = await viewer.getMainCamera();
+        final view = await viewer.createView();
-      mainCamera.setTransform(Matrix4.translation(Vector3(0, 0, 5)));
+        view.updateViewport(500, 500);
-      await testHelper.capture(viewer, "default_swapchain_default_view");
+        view.setCamera(mainCamera);
+        await testHelper.capture(
+          viewer,
+          "default_swapchain_new_view_with_main_camera",
+          view: view,
+        );
 
-      final view = await viewer.createView();
+        var newCamera = await viewer.createCamera();
-      view.updateViewport(500, 500);
+        newCamera.setTransform(Matrix4.translation(Vector3(0.0, 0.0, 10.0)));
-      view.setCamera(mainCamera);
+        newCamera.setLensProjection();
-      await testHelper.capture(
+        view.setCamera(newCamera);
-        viewer,
-        "default_swapchain_new_view_with_main_camera",
-        view: view,
-      );
 
-      var newCamera = await viewer.createCamera();
+        await testHelper.capture(
-      newCamera.setTransform(Matrix4.translation(Vector3(0.0, 0.0, 10.0)));
+          viewer,
-      newCamera.setLensProjection();
+          "default_swapchain_new_view_new_camera",
-      view.setCamera(newCamera);
+          view: view,
+        );
 
-      await testHelper.capture(
+        await testHelper.capture(
-        viewer,
+          viewer,
-        "default_swapchain_new_view_new_camera",
+          "default_swapchain_default_view_main_camera_no_change",
-        view: view,
+        );
-      );
+      });
-
-      await testHelper.capture(
-        viewer,
-        "default_swapchain_default_view_main_camera_no_change",
-      );
-
-      await viewer.dispose();
     });
 
     test('create secondary view, different swapchain', () async {
-      var viewer = await testHelper.createViewer();
+      await testHelper.withViewer((viewer) async {
-      await viewer.setBackgroundColor(1.0, 0, 0, 1);
+        final cube = await viewer.createGeometry(GeometryHelper.cube());
-      final cube = await viewer.createGeometry(GeometryHelper.cube());
 
-      var mainCamera = await viewer.getMainCamera();
+        var mainCamera = await viewer.getMainCamera();
-      mainCamera.setTransform(Matrix4.translation(Vector3(0, 0, 5)));
+        mainCamera.setTransform(Matrix4.translation(Vector3(0, 0, 5)));
-      final swapChain = await viewer.createHeadlessSwapChain(1, 1);
+        final swapChain = await viewer.createHeadlessSwapChain(1, 1);
-      await testHelper.capture(
+        await testHelper.capture(
-          viewer, "create_swapchain_default_view_default_swapchain");
+            viewer, "create_swapchain_default_view_default_swapchain");
 
-      final view = await viewer.createView();
+        final view = await viewer.createView();
 
-      final texture = await testHelper.createTexture(200, 400);
+        final texture = await testHelper.createTexture(200, 400);
-      final renderTarget = await viewer.createRenderTarget(
+        final renderTarget = await viewer.createRenderTarget(
-          200, 400, texture.metalTextureAddress);
+            200, 400, texture.metalTextureAddress);
-      await view.setRenderTarget(renderTarget);
+        await view.setRenderTarget(renderTarget);
 
-      await view.updateViewport(200, 400);
+        await view.updateViewport(200, 400);
-      view.setCamera(mainCamera);
+        view.setCamera(mainCamera);
-      mainCamera.setLensProjection(aspect: 0.5);
+        mainCamera.setLensProjection(aspect: 0.5);
 
-      await testHelper.capture(
+        await testHelper.capture(
-        viewer,
+          viewer,
-        view: view,
+          view: view,
-        swapChain: swapChain,
+          swapChain: swapChain,
-        renderTarget: renderTarget,
+          renderTarget: renderTarget,
-        "create_swapchain_secondary_view_new_swapchain",
+          "create_swapchain_secondary_view_new_swapchain",
-      );
+        );
-
+      });
-      await viewer.dispose();
     });
 
     test('pick', () async {
-      var viewer = await testHelper.createViewer(
+      await testHelper.withViewer((viewer) async {
-          bg: kRed, cameraPosition: Vector3(0, 0, 3));
+        final view = await viewer.getViewAt(0);
 
-      final view = await viewer.getViewAt(0);
+        await view.setRenderable(true, testHelper.swapChain);
 
-      await view.setRenderable(true, testHelper.swapChain);
+        final cube = await viewer
+            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
 
-      final cube = await viewer.createGeometry(GeometryHelper.cube());
+        await testHelper.capture(viewer, "view_pick");
 
-      await testHelper.capture(viewer, "view_pick");
+        final completer = Completer();
 
-      final completer = Completer();
+        await viewer.pick(250, 250, (result) {
-      late StreamSubscription listener;
+          completer.complete(result.entity);
-      listener = viewer.pickResult.listen((result) async {
+          print(
-        completer.complete(result.entity);
+              "Pick result : ${result.fragX} ${result.fragY} ${result.fragZ}");
-        await listener.cancel();
+        });
-        print("Pick result : ${result.fragX} ${result.fragY} ${result.fragZ}");
-      });
 
-      await viewer.pick(250, 250);
+        for (int i = 0; i < 10; i++) {
+          await testHelper.capture(viewer, "view_pick");
+          if (completer.isCompleted) {
+            break;
+          }
+        }
 
-      for (int i = 0; i < 3; i++) {
+        expect(completer.isCompleted, true);
-        await viewer.render();
+        expect(await completer.future, cube.entity);
-        await Future.delayed(Duration(milliseconds: 16));
+      }, cameraPosition: Vector3(0, 0, 3));
-      }
+    });
 
-      expect(completer.isCompleted, true);
+    test('dithering', () async {
-      expect(await completer.future, cube);
+      await testHelper.withViewer((viewer) async {
-      await viewer.dispose();
+        final view = await viewer.getViewAt(0);
+
+        expect(await view.isDitheringEnabled(), true);
+
+        final cube = await viewer
+            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
+
+        await testHelper.capture(viewer, "dithering_enabled");
+
+        await view.setDithering(false);
+        expect(await view.isDitheringEnabled(), false);
+        await testHelper.capture(viewer, "dithering_disabled");
+        
+      }, cameraPosition: Vector3(0, 0, 3));
     });
   });
 }