update tests

thermion_dart/test/camera_tests.dart

@@ -93,8 +93,7 @@ void main() async {
 
         await camera.setProjection(
             Projection.Orthographic, -0.05, 0.05, -0.05, 0.05, 0.05, 10000);
-          await testHelper.capture(
+        await testHelper.capture(viewer, "camera_set_orthographic_projection");
-              viewer, "camera_set_orthographic_projection");
       });
     });
 
@@ -137,10 +136,9 @@ void main() async {
         // 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(
+        await camera.setProjectionMatrixWithCulling(projectionMatrix, 0.05, 1);
-              projectionMatrix, 0.05, 1);
+        await testHelper.capture(
-          await testHelper.capture(viewer,
+            viewer, "camera_projection_culling_matrix_object_outside_frustum");
-              "camera_projection_culling_matrix_object_outside_frustum");
       });
     });
 
@@ -193,10 +191,13 @@ void main() 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 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);
@@ -218,5 +219,4 @@ void main() async {
       });
     });
   });
-
 }

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,17 +51,13 @@ 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),
-          materialInstances: [materialInstance]
+            materialInstances: [materialInstance]);
-        );
 
         await viewer.addDirectLight(DirectLight.sun(
             intensity: 100000,
@@ -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,23 +12,22 @@ 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);
         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);
 
         await viewer.setBackgroundColor(1.0, 0, 0, 1);
-      final cube = await viewer.createGeometry(GeometryHelper.cube());
+        final cube = await viewer
+            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
 
         var mainCamera = await viewer.getMainCamera();
         mainCamera.setTransform(Matrix4.translation(Vector3(0, 0, 5)));
@@ -36,15 +35,13 @@ void main() async {
             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)));
@@ -74,13 +71,11 @@ void main() async {
           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());
 
         var mainCamera = await viewer.getMainCamera();
@@ -107,40 +102,56 @@ void main() async {
           renderTarget: renderTarget,
           "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);
 
         await view.setRenderable(true, testHelper.swapChain);
 
-      final cube = await viewer.createGeometry(GeometryHelper.cube());
+        final cube = await viewer
+            .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
 
         await testHelper.capture(viewer, "view_pick");
 
         final completer = Completer();
-      late StreamSubscription listener;
+
-      listener = viewer.pickResult.listen((result) async {
+        await viewer.pick(250, 250, (result) {
           completer.complete(result.entity);
-        await listener.cancel();
+          print(
-        print("Pick result : ${result.fragX} ${result.fragY} ${result.fragZ}");
+              "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");
-      for (int i = 0; i < 3; i++) {
+          if (completer.isCompleted) {
-        await viewer.render();
+            break;
-        await Future.delayed(Duration(milliseconds: 16));
+          }
         }
 
         expect(completer.isCompleted, true);
-      expect(await completer.future, cube);
+        expect(await completer.future, cube.entity);
-      await viewer.dispose();
+      }, cameraPosition: Vector3(0, 0, 3));
+    });
+
+    test('dithering', () async {
+      await testHelper.withViewer((viewer) async {
+        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));
     });
   });
 }