622 lines
24 KiB
Dart
622 lines
24 KiB
Dart
@Timeout(const Duration(seconds: 600))
|
|
|
|
import 'package:logging/logging.dart';
|
|
import 'package:path/path.dart' as p;
|
|
import 'package:test/test.dart';
|
|
import 'package:thermion_dart/src/filament/src/implementation/ffi_asset.dart';
|
|
import 'package:thermion_dart/src/filament/src/implementation/ffi_camera.dart';
|
|
import 'package:thermion_dart/src/filament/src/implementation/ffi_material.dart';
|
|
import 'package:thermion_dart/src/filament/src/implementation/ffi_render_target.dart';
|
|
import 'package:thermion_dart/src/filament/src/implementation/ffi_scene.dart';
|
|
import 'package:thermion_dart/src/filament/src/implementation/ffi_view.dart';
|
|
import 'package:thermion_dart/src/bindings/src/thermion_dart_ffi.g.dart';
|
|
import 'package:thermion_dart/thermion_dart.dart';
|
|
import 'helpers.dart';
|
|
|
|
void main() async {
|
|
Logger.root.onRecord.listen((record) {
|
|
print(record);
|
|
});
|
|
|
|
final testHelper = TestHelper("view");
|
|
await testHelper.setup();
|
|
|
|
test('get camera from view', () async {
|
|
await testHelper.withViewer((viewer) async {
|
|
final camera = await viewer.view.getCamera();
|
|
expect(camera, isNotNull);
|
|
});
|
|
});
|
|
|
|
test('toggle transparent picking', () async {
|
|
await testHelper.withViewer((viewer) async {
|
|
expect(await viewer.view.isTransparentPickingEnabled(), false);
|
|
await viewer.view.setTransparentPickingEnabled(true);
|
|
expect(await viewer.view.isTransparentPickingEnabled(), true);
|
|
await viewer.view.setTransparentPickingEnabled(false);
|
|
expect(await viewer.view.isTransparentPickingEnabled(), false);
|
|
});
|
|
});
|
|
|
|
test('render two views, change material instance in between', () async {
|
|
final viewportDimensions = (width: 500, height: 500);
|
|
final swapChain = await FilamentApp.instance!.createHeadlessSwapChain(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
await FilamentApp.instance!.setClearOptions(0, 0, 0, 0);
|
|
final views = [];
|
|
final scene = await FilamentApp.instance!.createScene() as FFIScene;
|
|
final camera = await FilamentApp.instance!.createCamera() as FFICamera;
|
|
await camera.setLensProjection();
|
|
for (int i = 0; i < 2; i++) {
|
|
final view = await FilamentApp.instance!.createView() as FFIView;
|
|
await view.setScene(scene);
|
|
await view.setCamera(camera);
|
|
await view.setRenderable(true);
|
|
await view.setViewport(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
await view.setFrustumCullingEnabled(false);
|
|
await FilamentApp.instance!.register(swapChain, view);
|
|
views.add(view);
|
|
}
|
|
|
|
var red = await FilamentApp.instance!.createUnlitMaterialInstance();
|
|
await red.setParameterFloat4("baseColorFactor", 1, 0, 0, 1);
|
|
|
|
var green = await FilamentApp.instance!.createUnlitMaterialInstance();
|
|
await green.setParameterFloat4("baseColorFactor", 0, 1, 0, 1);
|
|
|
|
var cube = await FilamentApp.instance!.createGeometry(
|
|
GeometryHelper.cube(flipUvs: true), nullptr,
|
|
materialInstances: [red]) as FFIAsset;
|
|
|
|
await scene.add(cube);
|
|
|
|
await camera.lookAt(Vector3(0, 0, 10));
|
|
|
|
await testHelper.capture(null, "multiview_change_material_instance",
|
|
swapChain: swapChain, beforeRender: (view) async {
|
|
if (view == views.last) {
|
|
await cube.setMaterialInstanceAt(green);
|
|
}
|
|
});
|
|
});
|
|
|
|
test('render to multiple views, same camera', () async {
|
|
final viewportDimensions = (width: 500, height: 500);
|
|
final swapChain = await FilamentApp.instance!.createHeadlessSwapChain(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
await FilamentApp.instance!.setClearOptions(0, 0, 0, 0);
|
|
final views = [];
|
|
final scene = await FilamentApp.instance!.createScene() as FFIScene;
|
|
final camera = await FilamentApp.instance!.createCamera() as FFICamera;
|
|
await camera.setLensProjection();
|
|
for (int i = 0; i < 2; i++) {
|
|
final view = await FilamentApp.instance!.createView() as FFIView;
|
|
await view.setScene(scene);
|
|
await view.setCamera(camera);
|
|
await view.setRenderable(true);
|
|
await view.setViewport(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
await view.setFrustumCullingEnabled(false);
|
|
await view.setPostProcessing(false);
|
|
await FilamentApp.instance!.register(swapChain, view);
|
|
views.add(view);
|
|
await view.setRenderTarget(await FilamentApp.instance!.createRenderTarget(
|
|
viewportDimensions.width,
|
|
viewportDimensions.height,
|
|
) as FFIRenderTarget);
|
|
}
|
|
|
|
await camera.lookAt(Vector3(0, 0, 10));
|
|
|
|
var materialInstance =
|
|
await FilamentApp.instance!.createUnlitMaterialInstance();
|
|
await materialInstance.setParameterFloat4("baseColorFactor", 1, 0, 0, 0);
|
|
|
|
var cube = await FilamentApp.instance!.createGeometry(
|
|
GeometryHelper.cube(flipUvs: true), nullptr,
|
|
materialInstances: [materialInstance]) as FFIAsset;
|
|
|
|
await scene.add(cube);
|
|
final results = await FilamentApp.instance!.capture(swapChain);
|
|
|
|
await savePixelBufferToBmp(
|
|
results.first.$2,
|
|
viewportDimensions.width,
|
|
viewportDimensions.height,
|
|
p.join(testHelper.outDir.path, "multi_view_same_camera_0.bmp"),
|
|
isFloat: true);
|
|
await savePixelBufferToBmp(
|
|
results.last.$2,
|
|
viewportDimensions.width,
|
|
viewportDimensions.height,
|
|
p.join(testHelper.outDir.path, "multi_view_same_camera_1.bmp"),
|
|
isFloat: true);
|
|
});
|
|
|
|
test('render to multiple views, same scene, different camera', () async {
|
|
final viewportDimensions = (width: 500, height: 500);
|
|
final swapChain = await FilamentApp.instance!.createHeadlessSwapChain(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
final views = <FFIView>[];
|
|
final scene = await FilamentApp.instance!.createScene() as FFIScene;
|
|
final camera1 = await FilamentApp.instance!.createCamera() as FFICamera;
|
|
await camera1.setLensProjection();
|
|
final camera2 = await FilamentApp.instance!.createCamera() as FFICamera;
|
|
await camera2.setLensProjection();
|
|
for (int i = 0; i < 2; i++) {
|
|
final view = await FilamentApp.instance!.createView() as FFIView;
|
|
await view.setScene(scene);
|
|
await view.setRenderable(true);
|
|
await view.setViewport(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
await view.setFrustumCullingEnabled(false);
|
|
await view.setPostProcessing(false);
|
|
await FilamentApp.instance!.register(swapChain, view);
|
|
views.add(view);
|
|
}
|
|
|
|
await camera1.lookAt(Vector3(-5, 0, 10));
|
|
await camera2.lookAt(Vector3(5, 0, 10));
|
|
|
|
await views.first.setCamera(camera1);
|
|
await views.last.setCamera(camera2);
|
|
|
|
var materialInstance =
|
|
await FilamentApp.instance!.createUnlitMaterialInstance();
|
|
await materialInstance.setParameterFloat4("baseColorFactor", 1, 0, 0, 0);
|
|
|
|
var cube = await FilamentApp.instance!.createGeometry(
|
|
GeometryHelper.cube(flipUvs: true), nullptr,
|
|
materialInstances: [materialInstance]) as FFIAsset;
|
|
|
|
await scene.add(cube);
|
|
|
|
await testHelper.capture(null, "multiple_view_different_camera");
|
|
});
|
|
|
|
test('render view to render target, used as input for another', () async {
|
|
final viewportDimensions = (width: 500, height: 500);
|
|
final swapChain = await FilamentApp.instance!.createHeadlessSwapChain(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
final views = <FFIView>[];
|
|
final scene = await FilamentApp.instance!.createScene() as FFIScene;
|
|
final camera = await FilamentApp.instance!.createCamera() as FFICamera;
|
|
await camera.setLensProjection();
|
|
|
|
await FilamentApp.instance!.setClearOptions(0, 0, 0, 0);
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
final view = await FilamentApp.instance!.createView() as FFIView;
|
|
await view.setScene(scene);
|
|
await view.setRenderable(true);
|
|
await view.setViewport(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
await view.setFrustumCullingEnabled(false);
|
|
await view.setPostProcessing(false);
|
|
await view.setRenderTarget(await FilamentApp.instance!.createRenderTarget(
|
|
viewportDimensions.width, viewportDimensions.height)
|
|
as FFIRenderTarget);
|
|
await FilamentApp.instance!.register(swapChain, view);
|
|
await view.setCamera(camera);
|
|
views.add(view);
|
|
}
|
|
|
|
await camera.lookAt(Vector3(0, 4, 12), focus: Vector3(0, -4, 0));
|
|
|
|
var materialInstance1 =
|
|
await FilamentApp.instance!.createUnlitMaterialInstance();
|
|
await materialInstance1.setParameterFloat4("baseColorFactor", 1, 0, 0, 0);
|
|
|
|
var cube = await FilamentApp.instance!.createGeometry(
|
|
GeometryHelper.cube(flipUvs: true), nullptr,
|
|
materialInstances: [materialInstance1]) as FFIAsset;
|
|
|
|
await scene.add(cube);
|
|
|
|
var result =
|
|
await FilamentApp.instance!.capture(swapChain, view: views.first);
|
|
|
|
await savePixelBufferToBmp(
|
|
result.first.$2,
|
|
viewportDimensions.width,
|
|
viewportDimensions.height,
|
|
p.join(testHelper.outDir.path, "render_target_output.bmp"),
|
|
isFloat: true);
|
|
|
|
var materialInstance2 = await FilamentApp.instance!
|
|
.createUbershaderMaterialInstance(
|
|
hasBaseColorTexture: true, unlit: false);
|
|
|
|
var light = await FilamentApp.instance!.createDirectLight(DirectLight(
|
|
type: LightType.SUN,
|
|
color: 6500,
|
|
intensity: 100000000,
|
|
direction: Vector3(0, 0, -1),
|
|
position: Vector3.zero()));
|
|
await scene.addEntity(light);
|
|
|
|
final texture =
|
|
await (await views.first.getRenderTarget())!.getColorTexture();
|
|
|
|
await materialInstance2.setParameterTexture("baseColorMap", texture,
|
|
await FilamentApp.instance!.createTextureSampler());
|
|
await materialInstance2.setParameterInt("baseColorIndex", 0);
|
|
await materialInstance2.setParameterFloat4("baseColorFactor", 1, 1, 1, 1);
|
|
await cube.setMaterialInstanceAt(materialInstance2 as FFIMaterialInstance);
|
|
|
|
result = await FilamentApp.instance!.capture(swapChain, view: views.last);
|
|
|
|
await savePixelBufferToBmp(
|
|
result.first.$2,
|
|
viewportDimensions.width,
|
|
viewportDimensions.height,
|
|
p.join(testHelper.outDir.path, "render_target_as_texture.bmp"),
|
|
isFloat: true);
|
|
});
|
|
|
|
///
|
|
///
|
|
///
|
|
test('render two views to same render target', () async {
|
|
final viewportDimensions = (width: 500, height: 500);
|
|
final swapChain = await FilamentApp.instance!.createHeadlessSwapChain(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
final views = <FFIView>[];
|
|
|
|
await FilamentApp.instance!.setClearOptions(0, 0, 0, 0,
|
|
clear: false, clearStencil: 0, discard: false);
|
|
|
|
final renderTarget = await FilamentApp.instance!.createRenderTarget(
|
|
viewportDimensions.width, viewportDimensions.height) as FFIRenderTarget;
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
final camera = await FilamentApp.instance!.createCamera() as FFICamera;
|
|
await camera.setLensProjection();
|
|
final view = await FilamentApp.instance!.createView() as FFIView;
|
|
final scene = await FilamentApp.instance!.createScene() as FFIScene;
|
|
await view.setScene(scene);
|
|
await view.setRenderable(true);
|
|
await view.setViewport(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
await view.setFrustumCullingEnabled(false);
|
|
await view.setPostProcessing(false);
|
|
|
|
await view.setRenderTarget(renderTarget);
|
|
|
|
await FilamentApp.instance!.register(swapChain, view);
|
|
await view.setCamera(camera);
|
|
views.add(view);
|
|
|
|
await camera.lookAt(Vector3(0, 4, 12),
|
|
focus: Vector3(i == 0 ? -2 : 2, 0, 0));
|
|
|
|
var cube = await FilamentApp.instance!.createGeometry(
|
|
GeometryHelper.cube(flipUvs: true), nullptr) as FFIAsset;
|
|
|
|
await scene.add(cube);
|
|
}
|
|
var result = await FilamentApp.instance!
|
|
.capture(swapChain, captureRenderTarget: true);
|
|
|
|
await savePixelBufferToBmp(
|
|
result.first.$2,
|
|
viewportDimensions.width,
|
|
viewportDimensions.height,
|
|
p.join(testHelper.outDir.path, "two_views_same_render_target1.bmp"),
|
|
isFloat: true);
|
|
await savePixelBufferToBmp(
|
|
result.last.$2,
|
|
viewportDimensions.width,
|
|
viewportDimensions.height,
|
|
p.join(testHelper.outDir.path, "two_views_same_render_target2.bmp"),
|
|
isFloat: true);
|
|
});
|
|
|
|
test('render depth buffer to render target', () async {
|
|
final viewportDimensions = (width: 500, height: 500);
|
|
final swapChain = await FilamentApp.instance!.createHeadlessSwapChain(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
final views = <FFIView>[];
|
|
final scene = await FilamentApp.instance!.createScene() as FFIScene;
|
|
final camera = await FilamentApp.instance!.createCamera() as FFICamera;
|
|
await camera.setLensProjection();
|
|
|
|
await FilamentApp.instance!.setClearOptions(0, 0, 0, 0);
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
final view = await FilamentApp.instance!.createView() as FFIView;
|
|
await view.setScene(scene);
|
|
await view.setRenderable(true);
|
|
await view.setViewport(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
await view.setFrustumCullingEnabled(false);
|
|
await view.setPostProcessing(false);
|
|
await view.setRenderTarget(await FilamentApp.instance!.createRenderTarget(
|
|
viewportDimensions.width, viewportDimensions.height)
|
|
as FFIRenderTarget);
|
|
await FilamentApp.instance!.register(swapChain, view);
|
|
await view.setCamera(camera);
|
|
views.add(view);
|
|
}
|
|
|
|
await camera.lookAt(Vector3(0, 4, 12), focus: Vector3(0, -4, 0));
|
|
|
|
var materialInstance1 =
|
|
await FilamentApp.instance!.createUnlitMaterialInstance();
|
|
await materialInstance1.setParameterFloat4("baseColorFactor", 1, 0, 0, 0);
|
|
|
|
var cube = await FilamentApp.instance!.createGeometry(
|
|
GeometryHelper.cube(flipUvs: true), nullptr,
|
|
materialInstances: [materialInstance1]) as FFIAsset;
|
|
|
|
await scene.add(cube);
|
|
|
|
var result =
|
|
await FilamentApp.instance!.capture(swapChain, view: views.first);
|
|
|
|
await savePixelBufferToBmp(
|
|
result.first.$2,
|
|
viewportDimensions.width,
|
|
viewportDimensions.height,
|
|
p.join(testHelper.outDir.path, "render_target_output.bmp"),
|
|
isFloat: true);
|
|
|
|
var materialInstance2 = await FilamentApp.instance!
|
|
.createUbershaderMaterialInstance(
|
|
hasBaseColorTexture: true, unlit: false);
|
|
|
|
var light = await FilamentApp.instance!.createDirectLight(DirectLight(
|
|
type: LightType.SUN,
|
|
color: 6500,
|
|
intensity: 100000000,
|
|
direction: Vector3(0, 0, -1),
|
|
position: Vector3.zero()));
|
|
await scene.addEntity(light);
|
|
|
|
final texture =
|
|
await (await views.first.getRenderTarget())!.getColorTexture();
|
|
|
|
await materialInstance2.setParameterTexture("baseColorMap", texture,
|
|
await FilamentApp.instance!.createTextureSampler());
|
|
await materialInstance2.setParameterInt("baseColorIndex", 0);
|
|
await materialInstance2.setParameterFloat4("baseColorFactor", 1, 1, 1, 1);
|
|
await cube.setMaterialInstanceAt(materialInstance2 as FFIMaterialInstance);
|
|
|
|
result = await FilamentApp.instance!.capture(swapChain, view: views.last);
|
|
|
|
await savePixelBufferToBmp(
|
|
result.first.$2,
|
|
viewportDimensions.width,
|
|
viewportDimensions.height,
|
|
p.join(testHelper.outDir.path, "render_target_as_texture.bmp"),
|
|
isFloat: true);
|
|
});
|
|
|
|
test('fog tests', () async {
|
|
await testHelper.withViewer((viewer) async {
|
|
var cube = await FilamentApp.instance!
|
|
.createGeometry(GeometryHelper.cube(flipUvs: true), nullptr);
|
|
await viewer.addToScene(cube);
|
|
|
|
final camera = await viewer.getActiveCamera();
|
|
await camera.lookAt(Vector3(1, 3, 5), focus: Vector3.zero());
|
|
|
|
await testHelper.capture(viewer.view, "fog_options_disabled");
|
|
|
|
await viewer.view
|
|
.setFogOptions(FogOptions(enabled: true, distance: 0, density: 0.5));
|
|
await testHelper.capture(viewer.view, "fog_options_enabled");
|
|
}, addSkybox: true, postProcessing: true);
|
|
});
|
|
|
|
test('show/hide stencil highlight', () async {
|
|
await testHelper.withViewer((viewer) async {
|
|
var cube = await FilamentApp.instance!
|
|
.createGeometry(GeometryHelper.cube(flipUvs: true), nullptr);
|
|
await viewer.addToScene(cube);
|
|
await viewer.view.setStencilHighlight(cube);
|
|
await FilamentApp.instance!
|
|
.setClearOptions(1, 1, 1, 0, clear: true, discard: false);
|
|
await FilamentApp.instance!.requestFrame();
|
|
|
|
await testHelper.capture(null, "stencil_highlight_enabled",
|
|
render: false);
|
|
|
|
await FilamentApp.instance!
|
|
.setClearOptions(1, 1, 1, 0, clear: true, discard: false);
|
|
await viewer.view.removeStencilHighlight(cube);
|
|
await FilamentApp.instance!.requestFrame();
|
|
|
|
await testHelper.capture(null, "stencil_highlight_removed",
|
|
render: false);
|
|
}, postProcessing: false);
|
|
});
|
|
}
|
|
// manually construct two views with stencil buffer
|
|
// final viewportDimensions = (width: 500, height: 500);
|
|
// final swapChain = await FilamentApp.instance!.createHeadlessSwapChain(
|
|
// viewportDimensions.width, viewportDimensions.height,
|
|
// hasStencilBuffer: true);
|
|
// final renderTarget = await FilamentApp.instance!.createRenderTarget(
|
|
// viewportDimensions.width, viewportDimensions.height);
|
|
// await FilamentApp.instance!.setClearOptions(1, 1, 0, 0);
|
|
// final views = <View>[];
|
|
// final scene = await FilamentApp.instance!.createScene();
|
|
// final camera = await FilamentApp.instance!.createCamera();
|
|
// await camera.setLensProjection();
|
|
// await camera.lookAt(Vector3(0, 0, 10));
|
|
// for (int i = 0; i < 2; i++) {
|
|
// final view = await FilamentApp.instance!.createView() as FFIView;
|
|
// await view.setScene(scene);
|
|
// await view.setCamera(camera);
|
|
// await view.setStencilBufferEnabled(true);
|
|
// await view.setBlendMode(BlendMode.transparent);
|
|
// await view.setViewport(
|
|
// viewportDimensions.width, viewportDimensions.height);
|
|
// await view.setFrustumCullingEnabled(false);
|
|
// await view.setPostProcessing(true);
|
|
// await view.setRenderTarget(renderTarget);
|
|
// views.add(view);
|
|
// }
|
|
|
|
// var green = await FilamentApp.instance!.createUnlitMaterialInstance();
|
|
// await green.setParameterFloat4("baseColorFactor", 0, 1, 0, 1);
|
|
// await green.setStencilCompareFunction(SamplerCompareFunction.A);
|
|
// await green.setStencilOpDepthStencilPass(StencilOperation.REPLACE);
|
|
// await green.setStencilReferenceValue(11);
|
|
// await green.setDepthCullingEnabled(false);
|
|
// await green.setStencilWriteEnabled(true);
|
|
|
|
// var red = await FilamentApp.instance!.createUnlitMaterialInstance();
|
|
// await red.setParameterFloat4("baseColorFactor", 1, 0, 0, 1);
|
|
// await red.setDepthCullingEnabled(false);
|
|
// await red.setDepthFunc(SamplerCompareFunction.E);
|
|
// await red.setStencilCompareFunction(SamplerCompareFunction.A);
|
|
// await red.setStencilReferenceValue(11);
|
|
|
|
// var cube = await FilamentApp.instance!.createGeometry(
|
|
// GeometryHelper.cube(), nullptr,
|
|
// materialInstances: [green]);
|
|
// // var cube2 = await FilamentApp.instance!.createGeometry(
|
|
// // GeometryHelper.cube(), nullptr,
|
|
// // materialInstances: [red]);
|
|
// await scene.add(cube);
|
|
// // await scene.add(cube2);
|
|
// await FilamentApp.instance!.setPriority(cube.entity, 0);
|
|
// // await FilamentApp.instance!.setPriority(cube2.entity, 1);
|
|
|
|
// final renderer = FilamentApp.instance!.renderer;
|
|
|
|
// final beginFrame = await withBoolCallback((cb) {
|
|
// Renderer_beginFrameRenderThread(
|
|
// renderer, swapChain.getNativeHandle(), 0.toBigInt, cb);
|
|
// });
|
|
// await withVoidCallback((requestId, cb) {
|
|
// Renderer_renderRenderThread(
|
|
// renderer, views[0].getNativeHandle(), requestId, cb);
|
|
// });
|
|
|
|
// await cube.setMaterialInstanceAt(red);
|
|
|
|
// await FilamentApp.instance!.flush;
|
|
|
|
// await withVoidCallback((requestId, cb) {
|
|
// Renderer_renderRenderThread(
|
|
// renderer, views[1].getNativeHandle(), requestId, cb);
|
|
// });
|
|
// var out = Uint8List(500 * 500 * 4 * 4);
|
|
|
|
// await withVoidCallback((requestId, cb) {
|
|
// Renderer_readPixelsRenderThread(
|
|
// renderer,
|
|
// views[0].getNativeHandle(),
|
|
// renderTarget.getNativeHandle(),
|
|
// PixelDataFormat.RGBA.value,
|
|
// PixelDataType.FLOAT.value,
|
|
// out.address,
|
|
// out.length,
|
|
// requestId,
|
|
// cb);
|
|
// });
|
|
|
|
// await withVoidCallback((requestId, cb) {
|
|
// Renderer_endFrameRenderThread(renderer, requestId, cb);
|
|
// });
|
|
|
|
// await FilamentApp.instance!.flush();
|
|
|
|
// await savePixelBufferToPng(out, 500, 500, "/tmp/foo.png",
|
|
// hasAlpha: true, isFloat: true);
|
|
// }, createStencilBuffer: true);
|
|
|
|
// test('one swapchain, render view to render target', () async {
|
|
// await testHelper.withViewer((viewer) async {
|
|
// final texture = await testHelper.createTexture(500, 500);
|
|
// final renderTarget = await viewer.createRenderTarget(
|
|
// 500, 500, texture.metalTextureAddress);
|
|
// final view = await viewer.getViewAt(0);
|
|
// await view.setRenderTarget(renderTarget);
|
|
|
|
// await viewer.setBackgroundColor(1.0, 0, 0, 1);
|
|
// final cube = await viewer
|
|
// .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
|
|
|
|
// 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 {
|
|
// await testHelper.withViewer((viewer) async {
|
|
// final cube = await viewer
|
|
// .createGeometry(GeometryHelper.cube(normals: false, uvs: false));
|
|
|
|
// 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.setViewport(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);
|
|
|
|
// await testHelper.capture(
|
|
// viewer,
|
|
// "default_swapchain_new_view_new_camera",
|
|
// view: view,
|
|
// );
|
|
|
|
// await testHelper.capture(
|
|
// viewer,
|
|
// "default_swapchain_default_view_main_camera_no_change",
|
|
// );
|
|
// });
|
|
// });
|
|
|
|
// test('create secondary view, different swapchain', () async {
|
|
// 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");
|
|
|
|
// 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);
|
|
|
|
// await view.setViewport(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",
|
|
// );
|
|
// });
|
|
// });
|
|
|
|
// }
|