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

comment out tests for merge

Browse Source
This commit is contained in:
Nick Fisher
2025-03-28 14:17:54 +08:00
parent 5aaf212d9a
commit e25d7805d9
3 changed files with 452 additions and 783 deletions
Download Patch File Download Diff File Expand all files Collapse all files

598
thermion_dart/test/geometry_tests.dart
View File

@@ -20,278 +20,330 @@ void main() async {
await viewer.destroyAsset(asset);
}, bg: kRed);
});
test('custom geometry (no normals/uvs)', () async {
await testHelper.withViewer((viewer) async {
final asset = await viewer
.createGeometry(GeometryHelper.cube(normals: false, uvs: false));
await viewer.addToScene(asset);
await testHelper.capture(viewer.view, "geometry_cube_no_normals_uvs");
await viewer.removeFromScene(asset);
await viewer.destroyAsset(asset);
});
});
test('geometry with unlit (ubershader) material',
() async {
await testHelper.withViewer((viewer) async {
final materialInstance =
await FilamentApp.instance!
.createUbershaderMaterialInstance(unlit: true);
await materialInstance.setParameterFloat4(
"baseColorFactor", 1.0, 0.0, 0.0, 1.0);
final asset = await viewer.createGeometry(
GeometryHelper.cube(normals: false, uvs: false),
materialInstances: [materialInstance]);
await viewer.addToScene(asset);
await testHelper.capture(viewer.view, "geometry_cube_ubershader_red");
await materialInstance.setParameterFloat4(
"baseColorFactor", 0.0, 1.0, 0.0, 1.0);
await testHelper.capture(viewer.view, "geometry_cube_ubershader_green");
await viewer.removeFromScene(asset);
await viewer.destroyAsset(asset);
});
});
// 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);
// await materialInstance.setParameterFloat4(
// "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
// final asset = await viewer.createGeometry(
// GeometryHelper.cube(normals: true, uvs: false),
// materialInstances: [materialInstance]);
// await viewer.addToScene(asset);
// await viewer.addDirectLight(DirectLight.sun(
// intensity: 100000,
// castShadows: false,
// direction: Vector3(0, -0.5, -1)));
// // await viewer.addDirectLight(DirectLight.spot(
// // intensity: 1000000,
// // position: Vector3(0,3,3),
// // direction: Vector3(0,-1.5,-1),
// // falloffRadius: 10));
// await materialInstance.setParameterFloat4(
// "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
// await testHelper.capture(viewer.view, "geometry_cube_lit_ubershader");
// await viewer.removeFromScene(asset);
// await viewer.destroyAsset(asset);
// });
// });
// test('create instance', () async {
// await testHelper.withViewer((viewer) async {
// final asset = await viewer
// .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
// await viewer.addToScene(asset);
// await asset.setTransform(Matrix4.translation(Vector3.all(-1)));
// final instance = await asset.createInstance();
// await viewer.addToScene(instance);
// await instance.setTransform(Matrix4.translation(Vector3.all(1)));
// await testHelper.capture(viewer.view, "geometry_instanced");
// await viewer.destroyAsset(instance);
// await viewer.removeFromScene(asset);
// await viewer.destroyAsset(asset);
// });
// });
// test('create instance (shared material)', () async {
// await testHelper.withViewer((viewer) async {
// final materialInstance = await viewer.createUnlitMaterialInstance();
// await materialInstance.setParameterFloat4(
// "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
// final asset = await viewer.createGeometry(
// GeometryHelper.cube(normals: true, uvs: false),
// materialInstances: [materialInstance]);
// await viewer.addToScene(asset);
// final instance = await asset.createInstance();
// await instance.addToScene();
// await viewer.setTransform(
// instance.entity, Matrix4.translation(Vector3.all(1)));
// await testHelper.capture(
// viewer.view, "geometry_instanced_with_shared_material");
// await viewer.destroyAsset(instance);
// await viewer.removeFromScene(asset);
// await viewer.destroyAsset(asset);
// });
// });
// // test('create instance (no material on second instance)', () async {
// // await testHelper.withViewer((viewer) async {
// // final materialInstance = await viewer.createUnlitMaterialInstance();
// // await materialInstance.setParameterFloat4(
// // "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
// // final asset = await viewer.createGeometry(
// // GeometryHelper.cube(normals: true, uvs: false),
// // materialInstances: [materialInstance]);
// // await viewer.addToScene(asset);
// // final instance = await viewer.createInstance(asset);
// // await instance.addToScene();
// // await viewer.setTransform(instance.entity, Matrix4.translation(Vector3.all(1)));
// // await testHelper.capture(viewer.view, "geometry_instanced_with_no_material_instance");
// // await viewer.destroyAsset(instance);
// // await viewer.removeFromScene(asset);
// // await viewer.destroyAsset(asset);
// // });
// // });
// // test('create instance (separate materials)', () async {
// // await testHelper.withViewer((viewer) async {
// // final materialInstance = await viewer.createUnlitMaterialInstance();
// // await materialInstance.setParameterFloat4(
// // "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
// // final asset = await viewer.createGeometry(
// // GeometryHelper.cube(normals: true, uvs: false),
// // materialInstances: [materialInstance]);
// // await viewer.addToScene(asset);
// // final materialInstance2 = await viewer.createUnlitMaterialInstance();
// // await materialInstance2.setParameterFloat4(
// // "baseColorFactor", 0.0, 1.0, 0.0, 1.0);
// // final instance = await viewer.createInstance(asset, materialInstances: [materialInstance2]);
// // await instance.addToScene();
// // await viewer.setTransform(instance.entity, Matrix4.translation(Vector3.all(1)));
// // await testHelper.capture(viewer.view, "geometry_instanced_with_separate_material_instances");
// // await viewer.destroyAsset(instance);
// // await viewer.removeFromScene(asset);
// // await viewer.destroyAsset(asset);
// // });
// // });
// test('create cube with custom ubershader material (color)', () async {
// await testHelper.withViewer((viewer) async {
// await viewer.addLight(LightType.SUN, 6500, 1000000, 0, 0, 0, 0, 0, -1);
// await viewer.setCameraPosition(0, 2, 6);
// await viewer
// .setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
// await viewer.setBackgroundColor(1.0, 0.0, 1.0, 1.0);
// var materialInstance =
// await viewer.createUbershaderMaterialInstance(unlit: true);
// final asset = await viewer.createGeometry(
// GeometryHelper.cube(uvs: false, normals: true),
// materialInstances: [materialInstance]);
// await viewer.addToScene(asset);
// await materialInstance.setParameterFloat4(
// "baseColorFactor", 0.0, 1.0, 0.0, 0.0);
// await testHelper.capture(
// viewer.view, "geometry_cube_with_custom_material_ubershader");
// await viewer.removeFromScene(asset);
// await viewer.destroyAsset(asset);
// });
// });
// test('create cube with custom ubershader material instance (texture)',
// () async {
// await testHelper.withViewer((viewer) async {
// await viewer.addLight(LightType.SUN, 6500, 1000000, 0, 0, 0, 0, 0, -1);
// await viewer.setCameraPosition(0, 2, 6);
// await viewer
// .setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
// await viewer.setBackgroundColor(1.0, 0.0, 0.0, 1.0);
// var materialInstance = await viewer.createUbershaderMaterialInstance();
// final asset = await viewer.createGeometry(
// GeometryHelper.cube(uvs: true, normals: true),
// materialInstances: [materialInstance]);
// await viewer.addToScene(asset);
// final image = await viewer.decodeImage(
// File("${testHelper.testDir}/assets/cube_texture_512x512.png")
// .readAsBytesSync());
// var texture = await viewer.createTexture(
// await image.getWidth(), await image.getHeight());
// await texture.setLinearImage(
// image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
// await testHelper.capture(viewer.view,
// "geometry_cube_with_custom_material_ubershader_texture");
// await viewer.removeFromScene(asset);
// await viewer.destroyAsset(asset);
// await texture.dispose();
// await image.destroy();
// });
// });
// test('unlit material with color only', () async {
// await testHelper.withViewer((viewer) async {
// var materialInstance = await viewer.createUnlitMaterialInstance();
// final asset = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstances: [materialInstance]);
// await viewer.addToScene(asset);
// await materialInstance.setParameterFloat4(
// "baseColorFactor", 0.0, 1.0, 0.0, 1.0);
// await testHelper.capture(viewer.view, "unlit_material_base_color");
// await viewer.removeFromScene(asset);
// await viewer.destroyAsset(asset);
// });
// });
// test('unlit material with texture', () async {
// await testHelper.withViewer((viewer) async {
// var materialInstance = await viewer.createUnlitMaterialInstance();
// final asset = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstances: [materialInstance]);
// await viewer.addToScene(asset);
// await materialInstance.setParameterInt("baseColorIndex", 0);
// final image = await viewer.decodeImage(
// File("${testHelper.testDir}/assets/cube_texture_512x512.png")
// .readAsBytesSync());
// var texture = await viewer.createTexture(
// await image.getWidth(), await image.getHeight());
// await texture.setLinearImage(
// image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
// await testHelper.capture(viewer.view, "unlit_material_texture_only");
// await viewer.removeFromScene(asset);
// await viewer.destroyAsset(asset);
// await texture.dispose();
// await image.destroy();
// });
// });
// test('shared material instance with texture and base color', () async {
// await testHelper.withViewer((viewer) async {
// var materialInstance = await viewer.createUnlitMaterialInstance();
// final asset1 = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstances: [materialInstance]);
// await viewer.addToScene(asset1);
// final asset2 = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstances: [materialInstance]);
// await viewer.addToScene(asset2);
// await viewer.setTransform(
// asset2.entity, Matrix4.translation(Vector3(1, 1, 1)));
// await materialInstance.setParameterInt("baseColorIndex", 0);
// final image = await viewer.decodeImage(
// File("${testHelper.testDir}/assets/cube_texture_512x512.png")
// .readAsBytesSync());
// var texture = await viewer.createTexture(
// await image.getWidth(), await image.getHeight());
// await texture.setLinearImage(
// image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
// await testHelper.capture(viewer.view, "unlit_material_shared");
// await viewer.removeFromScene(asset1);
// await viewer.destroyAsset(asset1);
// await viewer.removeFromScene(asset2);
// await viewer.destroyAsset(asset2);
// await texture.dispose();
// await image.destroy();
// });
// });
// test('create sphere (no normals)', () async {
// await testHelper.withViewer((viewer) async {
// final asset = await viewer
// .createGeometry(GeometryHelper.sphere(normals: false, uvs: false));
// await viewer.addToScene(asset);
// await testHelper.capture(viewer.view, "geometry_sphere_no_normals");
// await viewer.removeFromScene(asset);
// await viewer.destroyAsset(asset);
// }, bg: kBlue, cameraPosition: Vector3(0, 0, 6));
// });
// test('create multiple (non-instanced) geometry', () async {
// await testHelper.withViewer((viewer) async {
// final asset1 = await viewer
// .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
// await viewer.addToScene(asset1);
// final asset2 = await viewer
// .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
// await viewer.addToScene(asset2);
// await viewer.setTransform(
// asset2.entity, Matrix4.translation(Vector3(0, 1.5, 0)));
// await testHelper.capture(viewer.view, "multiple_geometry");
// await viewer.removeFromScene(asset1);
// await viewer.destroyAsset(asset1);
// await viewer.removeFromScene(asset2);
// await viewer.destroyAsset(asset2);
// }, bg: kRed);
// });
// test('create camera geometry', () async {
// await testHelper.withViewer((viewer) async {
// final asset = await viewer.createGeometry(
// GeometryHelper.wireframeCamera(normals: false, uvs: false));
// await viewer.addToScene(asset);
// await viewer.setTransform(asset.entity, Matrix4.rotationY(pi / 4));
// await testHelper.capture(viewer.view, "camera_geometry");
// await viewer.removeFromScene(asset);
// await viewer.destroyAsset(asset);
// });
// });
});
// test('create cube with normals & uvs', () async {
// var viewer = await testHelper.createViewer();
// await viewer
// .createGeometry(GeometryHelper.cube(normals: true, uvs: true));
// await testHelper.capture(viewer, "geometry_cube_with_normals_uvs");
// });
// 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");
// await viewer.destroyAsset(cube);
// await testHelper.capture(viewer, "geometry_remove_cube");
// });
// });
// test('create cube with unlit ubershader material (no normals/uvs)',
// () async {
// await testHelper.withViewer((viewer) async {
// final materialInstance =
// await viewer.createUbershaderMaterialInstance(unlit: true);
// await materialInstance.setParameterFloat4(
// "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
// final cube = await viewer.createGeometry(
// GeometryHelper.cube(normals: false, uvs: false),
// materialInstances: [materialInstance]);
// await testHelper.capture(viewer, "geometry_cube_ubershader");
// });
// });
// 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);
// 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]);
// await viewer.addDirectLight(DirectLight.sun(
// intensity: 100000,
// castShadows: false,
// direction: Vector3(0, -0.5, -1)));
// // await viewer.addDirectLight(DirectLight.spot(
// // intensity: 1000000,
// // position: Vector3(0,3,3),
// // direction: Vector3(0,-1.5,-1),
// // falloffRadius: 10));
// await materialInstance.setParameterFloat4(
// "baseColorFactor", 1.0, 0.0, 0.0, 1.0);
// await testHelper.capture(viewer, "geometry_cube_lit_ubershader");
// });
// });
// test('create instance', () async {
// await testHelper.withViewer((viewer) async {
// final cube = await viewer
// .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
// await viewer.setTransform(
// cube.entity, Matrix4.translation(Vector3.all(-1)));
// final instance = await cube.createInstance();
// await instance.addToScene();
// await viewer.setTransform(
// instance.entity, Matrix4.translation(Vector3.all(1)));
// await testHelper.capture(viewer, "geometry_instanced");
// await viewer.destroyAsset(instance);
// await testHelper.capture(viewer, "geometry_instance_removed");
// });
// });
// test('create instance (shared material)', () async {
// await testHelper.withViewer((viewer) async {
// final materialInstance = await viewer.createUnlitMaterialInstance();
// 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]);
// final instance = await cube.createInstance();
// await instance.addToScene();
// await viewer.setTransform(
// instance.entity, Matrix4.translation(Vector3.all(1)));
// await testHelper.capture(
// viewer, "geometry_instanced_with_shared_material");
// });
// });
// // test('create instance (no material on second instance)', () async {
// // await testHelper.withViewer((viewer) async {
// // final materialInstance = await viewer.createUnlitMaterialInstance();
// // 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]);
// // final instance = await viewer
// // .createInstance(cube);
// // await viewer.setTransform(
// // instance.entity, Matrix4.translation(Vector3.all(1)));
// // await testHelper.capture(
// // viewer, "geometry_instanced_with_no_material_instance");
// // });
// // });
// // test('create instance (separate materials)', () async {
// // await testHelper.withViewer((viewer) async {
// // final materialInstance = await viewer.createUnlitMaterialInstance();
// // 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]);
// // final materialInstance2 = await viewer.createUnlitMaterialInstance();
// // await materialInstance2.setParameterFloat4(
// // "baseColorFactor", 0.0, 1.0, 0.0, 1.0);
// // final instance = await viewer
// // .createInstance(cube, materialInstances: [materialInstance2]);
// // await viewer.setTransform(
// // instance.entity, Matrix4.translation(Vector3.all(1)));
// // await testHelper.capture(
// // viewer, "geometry_instanced_with_separate_material_instances");
// // });
// // });
// test('create cube with custom ubershader material (color)', () async {
// await testHelper.withViewer((viewer) async {
// await viewer.addLight(LightType.SUN, 6500, 1000000, 0, 0, 0, 0, 0, -1);
// await viewer.setCameraPosition(0, 2, 6);
// await viewer
// .setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
// await viewer.setBackgroundColor(1.0, 0.0, 1.0, 1.0);
// var materialInstance =
// await viewer.createUbershaderMaterialInstance(unlit: true);
// final cube = await viewer.createGeometry(
// GeometryHelper.cube(uvs: false, normals: true),
// materialInstances: [materialInstance]);
// await materialInstance.setParameterFloat4(
// "baseColorFactor", 0.0, 1.0, 0.0, 0.0);
// await testHelper.capture(
// viewer, "geometry_cube_with_custom_material_ubershader");
// await viewer.destroyAsset(cube);
// });
// });
// test('create cube with custom ubershader material instance (texture)',
// () async {
// var viewer = await testHelper.createViewer();
// await viewer.addLight(LightType.SUN, 6500, 1000000, 0, 0, 0, 0, 0, -1);
// await viewer.setCameraPosition(0, 2, 6);
// await viewer
// .setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
// await viewer.setBackgroundColor(1.0, 0.0, 0.0, 1.0);
// var materialInstance = await viewer.createUbershaderMaterialInstance();
// final cube = await viewer.createGeometry(
// GeometryHelper.cube(uvs: true, normals: true),
// materialInstances: [materialInstance]);
// final image = await viewer.decodeImage(
// File("${testHelper.testDir}/assets/cube_texture_512x512.png")
// .readAsBytesSync());
// var texture = await viewer.createTexture(
// await image.getWidth(), await image.getHeight());
// await texture.setLinearImage(
// image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
// await testHelper.capture(
// viewer, "geometry_cube_with_custom_material_ubershader_texture");
// await viewer.destroyAsset(cube);
// await texture.dispose();
// await image.destroy();
// });
// test('unlit material with color only', () async {
// await testHelper.withViewer((viewer) async {
// var materialInstance = await viewer.createUnlitMaterialInstance();
// var cube = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstances: [materialInstance]);
// await materialInstance.setParameterFloat4(
// "baseColorFactor", 0.0, 1.0, 0.0, 1.0);
// await testHelper.capture(viewer, "unlit_material_base_color");
// });
// });
// test('unlit material with texture', () async {
// await testHelper.withViewer((viewer) async {
// var materialInstance = await viewer.createUnlitMaterialInstance();
// var cube = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstances: [materialInstance]);
// await materialInstance.setParameterInt("baseColorIndex", 0);
// final image = await viewer.decodeImage(
// File("${testHelper.testDir}/assets/cube_texture_512x512.png")
// .readAsBytesSync());
// var texture = await viewer.createTexture(
// await image.getWidth(), await image.getHeight());
// await texture.setLinearImage(
// image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
// await testHelper.capture(viewer, "unlit_material_texture_only");
// await viewer.destroyAsset(cube);
// });
// });
// test('shared material instance with texture and base color', () async {
// await testHelper.withViewer((viewer) async {
// var materialInstance = await viewer.createUnlitMaterialInstance();
// var cube1 = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstances: [materialInstance]);
// var cube2 = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstances: [materialInstance]);
// await viewer.setTransform(
// cube2.entity, Matrix4.translation(Vector3(1, 1, 1)));
// await materialInstance.setParameterInt("baseColorIndex", 0);
// final image = await viewer.decodeImage(
// File("${testHelper.testDir}/assets/cube_texture_512x512.png")
// .readAsBytesSync());
// var texture = await viewer.createTexture(
// await image.getWidth(), await image.getHeight());
// await texture.setLinearImage(
// image, PixelDataFormat.RGBA, PixelDataType.FLOAT);
// await testHelper.capture(viewer, "unlit_material_shared");
// await texture.dispose();
// await image.destroy();
// });
// });
// test('create sphere (no normals)', () async {
// await testHelper.withViewer((viewer) async {
// await viewer
// .createGeometry(GeometryHelper.sphere(normals: false, uvs: false));
// await testHelper.capture(viewer, "geometry_sphere_no_normals");
// }, bg: kBlue, cameraPosition: Vector3(0, 0, 6));
// });
// test('create multiple (non-instanced) geometry', () async {
// await testHelper.withViewer((viewer) async {
// final cube1 = await viewer
// .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
// final cube2 = await viewer
// .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
// await viewer.setTransform(
// cube2.entity, Matrix4.translation(Vector3(0, 1.5, 0)));
// await testHelper.capture(viewer, "multiple_geometry");
// }, bg: kRed);
// });
// 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");
// });
// });
// });
}

266
thermion_dart/test/gizmo_tests.dart
View File

@@ -1,5 +1,4 @@
import 'dart:async';
import 'package:thermion_dart/thermion_dart.dart';
import 'package:test/test.dart';
import 'package:vector_math/vector_math_64.dart';
@@ -7,164 +6,129 @@ import 'helpers.dart';
void main() async {
final testHelper = TestHelper("gizmo");
await testHelper.setup();
group("gizmo tests", () {
test('add/remove translation gizmo', () async {
await testHelper.withViewer((viewer) async {
var cameraPos = Vector3(1.5, 1.5, 3);
var modelMatrix =
makeViewMatrix(cameraPos, Vector3.zero(), Vector3(0, 1, 0));
modelMatrix.invert();
await viewer.setCameraModelMatrix4(modelMatrix);
final view = await viewer.getViewAt(0);
await viewer.showGridOverlay();
final gizmo = await viewer.createGizmo(view, GizmoType.translation);
await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
await gizmo.addToScene();
await testHelper.capture(viewer, "translation_gizmo_near");
modelMatrix = makeViewMatrix(
cameraPos.scaled(10), Vector3.zero(), Vector3(0, 1, 0));
modelMatrix.invert();
await viewer.setCameraModelMatrix4(modelMatrix);
// gizmo occupies same viewport size no matter the camera position
await testHelper.capture(viewer, "translation_gizmo_far");
await gizmo.removeFromScene();
await testHelper.capture(viewer, "translation_gizmo_removed");
}, postProcessing: true, bg: kWhite);
});
test('add/remove rotation gizmo', () async {
await testHelper.withViewer((viewer) async {
var cameraPos = Vector3(1.5, 1.5, 3);
var modelMatrix =
makeViewMatrix(cameraPos, Vector3.zero(), Vector3(0, 1, 0));
modelMatrix.invert();
await viewer.setCameraModelMatrix4(modelMatrix);
final view = await viewer.getViewAt(0);
await viewer.showGridOverlay();
final gizmo = await viewer.createGizmo(view, GizmoType.rotation);
await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
await gizmo.addToScene();
await testHelper.capture(viewer, "rotation_gizmo_near");
modelMatrix = makeViewMatrix(
cameraPos.scaled(10), Vector3.zero(), Vector3(0, 1, 0));
modelMatrix.invert();
await viewer.setCameraModelMatrix4(modelMatrix);
// gizmo occupies same viewport size no matter the camera position
await testHelper.capture(viewer, "rotation_gizmo_far");
await gizmo.removeFromScene();
await testHelper.capture(viewer, "rotation_gizmo_removed");
}, postProcessing: true, bg: kWhite);
});
test('set gizmo transform', () async {
await testHelper.withViewer((viewer) async {
var cameraPos = Vector3(1.5, 1.5, 3);
var modelMatrix =
makeViewMatrix(cameraPos, Vector3.zero(), Vector3(0, 1, 0));
modelMatrix.invert();
await viewer.setCameraModelMatrix4(modelMatrix);
final view = await viewer.getViewAt(0);
await viewer.showGridOverlay();
final gizmo = await viewer.createGizmo(view, GizmoType.translation);
await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
await gizmo.addToScene();
await viewer.setTransform(gizmo.entity, Matrix4.translation(Vector3(0,2,0)));
await testHelper.capture(viewer, "translation_gizmo_transformed");
}, postProcessing: true, bg: kWhite);
});
test('pick gizmo when not added to scene (this should not crash)',
() async {
await testHelper.withViewer((viewer) async {
await viewer.setCameraPosition(0, 0, 1);
final view = await viewer.getViewAt(0);
final viewport = await view.getViewport();
final gizmo = await viewer.createGizmo(view, GizmoType.translation);
final completer = Completer<GizmoPickResultType>();
await gizmo.pick(viewport.width ~/ 2, viewport.height ~/ 2 + 1,
handler: (GizmoPickResultType resultType, Vector3 coords) async {
completer.complete(resultType);
});
for (int i = 0; i < 10; i++) {
await testHelper.capture(
viewer, "pick_gizmo_without_adding_to_scene");
if (completer.isCompleted) {
break;
}
}
expect(completer.isCompleted, false);
}, postProcessing: true, bg: kWhite);
});
test('pick translation gizmo when added to scene', () async {
await testHelper.withViewer((viewer) async {
await viewer.setCameraPosition(0, 0, 1);
final view = await viewer.getViewAt(0);
final viewport = await view.getViewport();
final gizmo = await viewer.createGizmo(view, GizmoType.translation);
await gizmo.addToScene();
await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
final completer = Completer<GizmoPickResultType>();
await testHelper.capture(viewer, "gizmo_before_pick_no_highlight");
await gizmo.pick(viewport.width ~/ 2 + 100, viewport.height ~/ 2,
handler: (resultType, coords) async {
completer.complete(resultType);
});
for (int i = 0; i < 10; i++) {
await testHelper.capture(viewer, "gizmo_after_pick_no_highlight");
if (completer.isCompleted) {
break;
}
}
assert(completer.isCompleted);
expect(await completer.future, GizmoPickResultType.AxisX);
}, postProcessing: true, bg: kWhite);
});
test('highlight/unhighlight gizmo', () async {
await testHelper.withViewer((viewer) async {
final modelMatrix = makeViewMatrix(
Vector3(0.5, 0.5, 0.5), Vector3.zero(), Vector3(0, 1, 0));
modelMatrix.invert();
await viewer.setCameraModelMatrix4(modelMatrix);
final view = await viewer.getViewAt(0);
final gizmo = await viewer.createGizmo(view, GizmoType.translation);
await gizmo.addToScene();
await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
await testHelper.capture(viewer, "gizmo_before_highlight");
await gizmo.highlight(Axis.X);
await testHelper.capture(viewer, "gizmo_after_highlight");
await gizmo.unhighlight();
await testHelper.capture(viewer, "gizmo_after_unhighlight");
final gizmo = await viewer.getGizmo(GizmoType.translation);
await viewer.addToScene(gizmo);
await testHelper.capture(viewer.view, "translation_gizmo");
await viewer.removeFromScene(gizmo);
await testHelper.capture(viewer.view, "translation_gizmo_removed");
}, postProcessing: true, bg: kWhite);
});
});
test('add/remove rotation gizmo', () async {
await testHelper.withViewer((viewer) async {
final gizmo = await viewer.getGizmo(GizmoType.rotation);
await viewer.addToScene(gizmo);
await testHelper.capture(viewer.view, "rotation_gizmo");
await viewer.removeFromScene(gizmo);
await testHelper.capture(viewer.view, "rotation_gizmo_removed");
}, postProcessing: true, bg: kWhite);
});
// test('set gizmo transform', () async {
// await testHelper.withViewer((viewer) async {
// var cameraPos = Vector3(1.5, 1.5, 3);
// var modelMatrix =
// makeViewMatrix(cameraPos, Vector3.zero(), Vector3(0, 1, 0));
// modelMatrix.invert();
// await viewer.setCameraModelMatrix4(modelMatrix);
// final view = await viewer.getViewAt(0);
// await viewer.showGridOverlay();
// final gizmo = await viewer.createGizmo(view, GizmoType.translation);
// await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
// await gizmo.addToScene();
// await viewer.setTransform(gizmo.entity, Matrix4.translation(Vector3(0,2,0)));
// await testHelper.capture(viewer, "translation_gizmo_transformed");
// }, postProcessing: true, bg: kWhite);
// });
// test('pick gizmo when not added to scene (this should not crash)',
// () async {
// await testHelper.withViewer((viewer) async {
// await viewer.setCameraPosition(0, 0, 1);
// final view = await viewer.getViewAt(0);
// final viewport = await view.getViewport();
// final gizmo = await viewer.createGizmo(view, GizmoType.translation);
// final completer = Completer<GizmoPickResultType>();
// await gizmo.pick(viewport.width ~/ 2, viewport.height ~/ 2 + 1,
// handler: (GizmoPickResultType resultType, Vector3 coords) async {
// completer.complete(resultType);
// });
// for (int i = 0; i < 10; i++) {
// await testHelper.capture(
// viewer, "pick_gizmo_without_adding_to_scene");
// if (completer.isCompleted) {
// break;
// }
// }
// expect(completer.isCompleted, false);
// }, postProcessing: true, bg: kWhite);
// });
// test('pick translation gizmo when added to scene', () async {
// await testHelper.withViewer((viewer) async {
// await viewer.setCameraPosition(0, 0, 1);
// final view = await viewer.getViewAt(0);
// final viewport = await view.getViewport();
// final gizmo = await viewer.createGizmo(view, GizmoType.translation);
// await gizmo.addToScene();
// await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
// final completer = Completer<GizmoPickResultType>();
// await testHelper.capture(viewer, "gizmo_before_pick_no_highlight");
// await gizmo.pick(viewport.width ~/ 2 + 100, viewport.height ~/ 2,
// handler: (resultType, coords) async {
// completer.complete(resultType);
// });
// for (int i = 0; i < 10; i++) {
// await testHelper.capture(viewer, "gizmo_after_pick_no_highlight");
// if (completer.isCompleted) {
// break;
// }
// }
// assert(completer.isCompleted);
// expect(await completer.future, GizmoPickResultType.AxisX);
// }, postProcessing: true, bg: kWhite);
// });
// test('highlight/unhighlight gizmo', () async {
// await testHelper.withViewer((viewer) async {
// final modelMatrix = makeViewMatrix(
// Vector3(0.5, 0.5, 0.5), Vector3.zero(), Vector3(0, 1, 0));
// modelMatrix.invert();
// await viewer.setCameraModelMatrix4(modelMatrix);
// final view = await viewer.getViewAt(0);
// final gizmo = await viewer.createGizmo(view, GizmoType.translation);
// await gizmo.addToScene();
// await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
// await testHelper.capture(viewer, "gizmo_before_highlight");
// await gizmo.highlight(Axis.X);
// await testHelper.capture(viewer, "gizmo_after_highlight");
// await gizmo.unhighlight();
// await testHelper.capture(viewer, "gizmo_after_unhighlight");
// }, postProcessing: true, bg: kWhite);
// });
// });
// test('set uv scaling (unlit)', () async {
// var viewer = await testHelper.createViewer();
// await viewer.setBackgroundColor(1.0, 0.0, 0.0, 1.0);

371
thermion_dart/test/overlay_tests.dart
View File

@@ -1,369 +1,22 @@
import 'dart:io';
import 'dart:typed_data';
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("overlay");
// var material = await viewer.createMaterial(File(
// "/Users/nickfisher/Documents/thermion/materials/grid.filamat")
// .readAsBytesSync());
// var materialInstance = await material.createInstance();
// await materialInstance.setCullingMode(CullingMode.NONE);
// await materialInstance.setParameterFloat("distance", 10000.0);
// await materialInstance.setParameterFloat("lineSize", 0.001);
// var grid = await viewer.createGeometry(await createGridGeometry(),
// materialInstances: [materialInstance]);
// await viewer.setPriority(grid.entity, 7);
// await viewer.setViewFrustumCulling(false);
Future<Geometry> createGridGeometry() async {
List<double> vertices = [];
List<int> indices = [];
double stepSize = 1 / 4.0;
for (double x = -1.0; x < 1.0; x += stepSize) {
for (double z = -1.0; z < 1.0; z += stepSize) {
int baseIndex = vertices.length ~/ 3;
var verts = [
x,
0.0,
z,
x,
0.0,
z + stepSize,
x + stepSize,
0.0,
z + stepSize,
x + stepSize,
0.0,
z
];
vertices.addAll(verts);
indices.addAll([
baseIndex,
baseIndex + 1,
baseIndex + 2,
baseIndex + 2,
baseIndex + 3,
baseIndex
]);
}
}
return Geometry(Float32List.fromList(vertices), indices);
}
await testHelper.setup();
group("overlay tests", () {
group("grid", () {
test('enable grid', () async {
await testHelper.withViewer(
(viewer) async {
var viewMatrix = makeViewMatrix(
Vector3(0, 20, 0), Vector3(0, 0, 0), Vector3(0, 0, -1));
var modelMatrix = viewMatrix.clone()..invert();
await viewer.setCameraModelMatrix4(modelMatrix);
await viewer.showGridOverlay();
await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
final cube = await viewer.createGeometry(
GeometryHelper.cube(normals: false, uvs: false));
await testHelper.capture(viewer, "grid_added_layer_visible");
await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, false);
await testHelper.capture(viewer, "grid_added_layer_invisible");
await viewer.setLayerVisibility(VisibilityLayers.OVERLAY, true);
await viewer.removeGridOverlay();
await testHelper.capture(viewer, "grid_remove_layer_visible");
},
postProcessing: true,
);
});
});
group("stencil", () {
test('set stencil highlight for geometry', () async {
await testHelper.withViewer((viewer) async {
var cube = await viewer
.createGeometry(GeometryHelper.cube(normals: false, uvs: false));
await testHelper.capture(viewer, "geometry_before_stencil_highlight");
await cube.setStencilHighlight();
await testHelper.capture(viewer, "geometry_add_stencil_highlight");
await cube.removeStencilHighlight();
await testHelper.capture(viewer, "geometry_remove_stencil_highlight");
await viewer.setTransform(
cube.entity, Matrix4.translation(Vector3(1, 0, 0)));
await cube.setStencilHighlight();
await testHelper.capture(viewer, "geometry_add_stencil_highlight2");
}, postProcessing: true);
});
test('set stencil highlight for glb', () async {
await testHelper.withViewer((viewer) async {
var cube = await viewer.loadGlb(
"${testHelper.testDir}/assets/cube.glb",
numInstances: 2);
await testHelper.capture(viewer, "glb_before_stencil_highlight");
// gltf is slightly more complicated, because the "head" entity is
// not renderable, so we need to pick a child entity with a renderable
// component.
await cube.setStencilHighlight(entityIndex: 0);
await testHelper.capture(viewer, "glb_add_stencil_highlight");
await cube.removeStencilHighlight();
await testHelper.capture(viewer, "glb_remove_stencil_highlight");
}, postProcessing: true, bg: kWhite);
});
});
group("bounding box", () {
test('add bounding box to geometry', () async {
await testHelper.withViewer(
(viewer) async {
final cube = await viewer.createGeometry(
GeometryHelper.cube(normals: false, uvs: false));
await cube.setBoundingBoxVisibility(true);
await testHelper.capture(viewer, "geometry_bounding_box_visible");
await cube.setBoundingBoxVisibility(false);
await testHelper.capture(
viewer, "geometry_bounding_box_not_visible");
await cube.setBoundingBoxVisibility(true);
await viewer.destroyAsset(cube);
await testHelper.capture(
viewer, "geometry_bounding_box_removed");
},
postProcessing: true,
);
});
test('add bounding box to gltf', () async {
await testHelper.withViewer(
(viewer) async {
var cube = await viewer
.loadGlb("file://${testHelper.testDir}/assets/cube.glb");
await cube.setBoundingBoxVisibility(true);
await testHelper.capture(viewer, "gltf_bounding_box_visible");
await cube.setBoundingBoxVisibility(false);
await testHelper.capture(viewer, "gltf_bounding_box_not_visible");
},
postProcessing: true,
);
});
test('toggle grid visibility', () async {
await testHelper.withViewer(
(viewer) async {
await viewer.setGridOverlayVisibility(true);
await testHelper.capture(viewer.view, "grid_visible");
await viewer.setGridOverlayVisibility(false);
await testHelper.capture(viewer.view, "grid_hidden");
},
postProcessing: true,
);
});
});
// test('set uv scaling (unlit)', () async {
// var viewer = await testHelper.createViewer();
// await viewer.setBackgroundColor(1.0, 0.0, 0.0, 1.0);
// await viewer.setCameraPosition(0, 0, 6);
// await viewer.addDirectLight(
// DirectLight.sun(direction: Vector3(0, 0, -1)..normalize()));
// final unlitMaterialInstance = await viewer.createUnlitMaterialInstance();
// final cube = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstance: unlitMaterialInstance);
// await viewer.setMaterialPropertyFloat4(
// cube, 'baseColorFactor', 0, 1, 1, 1, 1);
// await viewer.setMaterialPropertyInt(cube, 'baseColorIndex', 0, 1);
// unlitMaterialInstance.setParameterFloat2("uvScale", 2.0, 4.0);
// var textureData =
// File("${testHelper.testDir}/assets/cube_texture_512x512.png")
// .readAsBytesSync();
// var texture = await viewer.createTexture(textureData);
// await viewer.applyTexture(texture, cube);
// await testHelper.capture(viewer, "set_uv_scaling");
// await viewer.dispose();
// });
// });
// group("texture", () {
// test("create/apply/dispose texture", () async {
// var viewer = await testHelper.createViewer();
// var textureData =
// File("${testHelper.testDir}/assets/cube_texture_512x512.png")
// .readAsBytesSync();
// var texture = await viewer.createTexture(textureData);
// await viewer.setBackgroundColor(0.0, 0.0, 0.0, 1.0);
// await viewer.addDirectLight(
// DirectLight.sun(direction: Vector3(0, -10, -1)..normalize()));
// await viewer.addDirectLight(DirectLight.spot(
// intensity: 1000000,
// position: Vector3(0, 0, 1.5),
// direction: Vector3(0, 0, -1)..normalize(),
// falloffRadius: 10,
// spotLightConeInner: 1,
// spotLightConeOuter: 1));
// await viewer.setCameraPosition(0, 2, 6);
// await viewer
// .setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
// var materialInstance =
// await viewer.createUbershaderMaterialInstance(unlit: true);
// var cube = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstances: [materialInstance]);
// await viewer.setPostProcessing(true);
// await viewer.setToneMapping(ToneMapper.LINEAR);
// await viewer.applyTexture(texture, cube,
// materialIndex: 0, parameterName: "baseColorMap");
// await testHelper.capture(viewer, "texture_applied_to_geometry");
// await viewer.destroyAsset(cube);
// await viewer.destroyTexture(texture);
// await viewer.dispose();
// });
// });
// group("unproject", () {
// test("unproject", () async {
// final dimensions = (width: 1280, height: 768);
// var viewer = await testHelper.createViewer(viewportDimensions: dimensions);
// await viewer.setPostProcessing(false);
// // await viewer.setToneMapping(ToneMapper.LINEAR);
// await viewer.setBackgroundColor(1.0, 1.0, 1.0, 1.0);
// // await viewer.createIbl(1.0, 1.0, 1.0, 100000);
// await viewer.addLight(LightType.SUN, 6500, 100000, -2, 0, 0, 1, -1, 0);
// await viewer.addLight(LightType.SPOT, 6500, 500000, 0, 0, 2, 0, 0, -1,
// falloffRadius: 10, spotLightConeInner: 1.0, spotLightConeOuter: 2.0);
// await viewer.setCameraPosition(-3, 4, 6);
// await viewer.setCameraRotation(
// Quaternion.axisAngle(Vector3(0, 1, 0), -pi / 8) *
// Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 6));
// var cube =
// await viewer.createGeometry(GeometryHelper.cube(), keepData: true);
// await viewer.setMaterialPropertyFloat4(
// cube, "baseColorFactor", 0, 1.0, 1.0, 1.0, 1.0);
// var textureData =
// File("${testHelper.testDir}/assets/cube_texture_512x512.png").readAsBytesSync();
// var texture = await viewer.createTexture(textureData);
// await viewer.applyTexture(texture, cube,
// materialIndex: 0, parameterName: "baseColorMap");
// var numFrames = 60;
// // first do the render
// for (int i = 0; i < numFrames; i++) {
// await viewer.setCameraPosition(-3 + (i / numFrames * 2), 4, 6);
// await viewer.setCameraRotation(
// Quaternion.axisAngle(Vector3(0, 1, 0), -pi / 8) *
// Quaternion.axisAngle(
// Vector3(1, 0, 0), -pi / 6 - (i / numFrames * pi / 6)));
// var rendered = await testHelper.capture(viewer, "unproject_render$i");
// var renderPng =
// await pixelsToPng(rendered, dimensions.width, dimensions.height);
// File("${outDir.path}/unproject_render${i}.png")
// .writeAsBytesSync(renderPng);
// }
// // then go off and convert the video
// // now unproject the render back onto the geometry
// final textureSize = (width: 1280, height: 768);
// var pixels = <Uint8List>[];
// // note we skip the first frame
// for (int i = 0; i < numFrames; i++) {
// await viewer.setCameraPosition(-3 + (i / numFrames * 2), 4, 6);
// await viewer.setCameraRotation(
// Quaternion.axisAngle(Vector3(0, 1, 0), -pi / 8) *
// Quaternion.axisAngle(
// Vector3(1, 0, 0), -pi / 6 - (i / numFrames * pi / 6)));
// var input = pngToPixelBuffer(File(
// "${outDir.path}/a8c317af-6081-4848-8a06-f6b69bc57664_${i + 1}.png")
// .readAsBytesSync());
// var pixelBuffer = await (await viewer as ThermionViewerFFI).unproject(
// cube,
// input,
// dimensions.width,
// dimensions.height,
// textureSize.width,
// textureSize.height);
// // var png = await pixelsToPng(Uint8List.fromList(pixelBuffer),
// // dimensions.width, dimensions.height);
// await savePixelBufferToBmp(
// pixelBuffer,
// textureSize.width,
// textureSize.height,
// p.join(outDir.path, "unprojected_texture${i}.bmp"));
// pixels.add(pixelBuffer);
// if (i > 10) {
// break;
// }
// }
// // }
// final aggregatePixelBuffer = medianImages(pixels);
// await savePixelBufferToBmp(aggregatePixelBuffer, textureSize.width,
// textureSize.height, "unproject_texture.bmp");
// var pixelBufferPng = await pixelsToPng(
// Uint8List.fromList(aggregatePixelBuffer),
// dimensions.width,
// dimensions.height);
// File("${outDir.path}/unproject_texture.png")
// .writeAsBytesSync(pixelBufferPng);
// await viewer.setPostProcessing(true);
// await viewer.setToneMapping(ToneMapper.LINEAR);
// final unlit = await viewer.createUnlitMaterialInstance();
// await viewer.destroyAsset(cube);
// cube = await viewer.createGeometry(GeometryHelper.cube(),
// materialInstance: unlit);
// var reconstructedTexture = await viewer.createTexture(pixelBufferPng);
// await viewer.applyTexture(reconstructedTexture, cube);
// await viewer.setCameraRotation(
// Quaternion.axisAngle(Vector3(0, 1, 0), -pi / 8) *
// Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 6));
// await testHelper.capture(viewer, "unproject_reconstruct");
// // now re-render
// for (int i = 0; i < numFrames; i++) {
// await viewer.setCameraPosition(-3 + (i / numFrames * 2), 4, 6);
// await viewer.setCameraRotation(
// Quaternion.axisAngle(Vector3(0, 1, 0), -pi / 8) *
// Quaternion.axisAngle(
// Vector3(1, 0, 0), -pi / 6 - (i / numFrames * pi / 6)));
// var rendered = await testHelper.capture(viewer, "unproject_rerender$i");
// var renderPng =
// await pixelsToPng(rendered, dimensions.width, dimensions.height);
// File("${outDir.path}/unproject_rerender${i}.png")
// .writeAsBytesSync(renderPng);
// }
// }, timeout: Timeout(Duration(minutes: 2)));
}