maobo/cup_edit
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update tests

Browse Source
This commit is contained in:
Nick Fisher
2024-11-30 13:57:42 +08:00
parent aa7350c419
commit 600ab1ad28
6 changed files with 381 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

324
thermion_dart/test/camera_tests.dart
View File

@@ -54,169 +54,169 @@ void main() async {
});
});
test('getCameraProjectionMatrix', () async {
await testHelper.withViewer((viewer) async {
var projectionMatrix = await viewer.getCameraProjectionMatrix();
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('getCameraProjectionMatrix', () async {
await testHelper.withViewer((viewer) async {
var projectionMatrix = await viewer.getCameraProjectionMatrix();
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(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>()));
});
});
});
}

40
thermion_dart/test/geometry_tests.dart
View File

@@ -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 =
await viewer.createUbershaderMaterialInstance(
unlit: false,
alphaMode: AlphaMode.BLEND,
hasVertexColors:false);
final materialInstance = await viewer.createUbershaderMaterialInstance(
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]
);
GeometryHelper.cube(normals: true, uvs: false),
materialInstances: [materialInstance]);
await viewer.addDirectLight(DirectLight.sun(
intensity: 100000,
castShadows: false,
direction: Vector3(0,-0.5,-1)));
intensity: 100000,
castShadows: false,
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 {
// var viewer = await testHelper.createViewer(
// cameraPosition: Vector3(0, 0, 6), bg: kRed);
// final cube = await viewer
// .createGeometry(GeometryHelper.sphere(normals: false, uvs: false));
// await viewer.setTransform(cube.entity, Matrix4.translation(Vector3(2, 1, 1)));
// final cube2 = await viewer.createInstance(cube);
// await viewer.setTransform(cube2.entity, Matrix4.translation(Vector3(-2, 1, 1)));
// await testHelper.capture(viewer, "geometry_instance");
// });
test('create camera geometry', () async {
await testHelper.withViewer((viewer) async {
final camera = await viewer.createGeometry(
GeometryHelper.wireframeCamera(normals: false, uvs: false));
await viewer.setTransform(camera.entity, Matrix4.rotationY(pi / 4));
await testHelper.capture(viewer, "camera_geometry");
});
});
});
}

29
thermion_dart/test/overlay_tests.dart
View File

@@ -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);
});
});
});

36
thermion_dart/test/picking_tests.dart Normal file
View File

@@ -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);
});
});
});
}

45
thermion_dart/test/transform_tests.dart Normal file
View File

@@ -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");
});
});
});
}

205
thermion_dart/test/view_tests.dart
View File

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