454 lines
16 KiB
Dart
454 lines
16 KiB
Dart
import 'dart:io';
|
|
import 'dart:math';
|
|
|
|
import 'dart:typed_data';
|
|
import 'package:thermion_dart/thermion_dart.dart';
|
|
import 'package:thermion_dart/thermion_dart/swift/swift_bindings.g.dart';
|
|
import 'package:thermion_dart/thermion_dart/thermion_viewer_ffi.dart';
|
|
import 'package:thermion_dart/thermion_dart/utils/dart_resources.dart';
|
|
import 'package:thermion_dart/thermion_dart/compatibility/compatibility.dart';
|
|
import 'package:test/test.dart';
|
|
import 'package:animation_tools_dart/animation_tools_dart.dart';
|
|
import 'package:path/path.dart' as p;
|
|
import 'package:vector_math/vector_math_64.dart';
|
|
|
|
/// Test files are run in a variety of ways, find this package root in all.
|
|
///
|
|
/// Test files can be run from source from any working directory. The Dart SDK
|
|
/// `tools/test.py` runs them from the root of the SDK for example.
|
|
///
|
|
/// Test files can be run from dill from the root of package. `package:test`
|
|
/// does this.
|
|
Uri findPackageRoot(String packageName) {
|
|
final script = Platform.script;
|
|
final fileName = script.name;
|
|
if (fileName.endsWith('_test.dart')) {
|
|
// We're likely running from source.
|
|
var directory = script.resolve('.');
|
|
while (true) {
|
|
final dirName = directory.name;
|
|
if (dirName == packageName) {
|
|
return directory;
|
|
}
|
|
final parent = directory.resolve('..');
|
|
if (parent == directory) break;
|
|
directory = parent;
|
|
}
|
|
} else if (fileName.endsWith('.dill')) {
|
|
final cwd = Directory.current.uri;
|
|
final dirName = cwd.name;
|
|
if (dirName == packageName) {
|
|
return cwd;
|
|
}
|
|
}
|
|
throw StateError("Could not find package root for package '$packageName'. "
|
|
'Tried finding the package root via Platform.script '
|
|
"'${Platform.script.toFilePath()}' and Directory.current "
|
|
"'${Directory.current.uri.toFilePath()}'.");
|
|
}
|
|
|
|
extension on Uri {
|
|
String get name => pathSegments.where((e) => e != '').last;
|
|
}
|
|
|
|
late String testDir;
|
|
|
|
Future<void> pixelBufferToBmp(
|
|
Uint8List pixelBuffer, int width, int height, String outputPath) async {
|
|
// BMP file header (14 bytes)
|
|
final fileHeader = ByteData(14);
|
|
fileHeader.setUint16(0, 0x4D42, Endian.little); // 'BM'
|
|
final fileSize = 54 + width * height * 3; // 54 bytes header + RGB data
|
|
fileHeader.setUint32(2, fileSize, Endian.little);
|
|
fileHeader.setUint32(10, 54, Endian.little); // Offset to pixel data
|
|
|
|
// BMP info header (40 bytes)
|
|
final infoHeader = ByteData(40);
|
|
infoHeader.setUint32(0, 40, Endian.little); // Info header size
|
|
infoHeader.setInt32(4, width, Endian.little);
|
|
infoHeader.setInt32(8, -height, Endian.little); // Negative for top-down
|
|
infoHeader.setUint16(12, 1, Endian.little); // Number of color planes
|
|
infoHeader.setUint16(14, 24, Endian.little); // Bits per pixel (RGB)
|
|
infoHeader.setUint32(16, 0, Endian.little); // No compression
|
|
infoHeader.setUint32(20, width * height * 3, Endian.little); // Image size
|
|
infoHeader.setInt32(24, 2835, Endian.little); // X pixels per meter
|
|
infoHeader.setInt32(28, 2835, Endian.little); // Y pixels per meter
|
|
|
|
// Calculate row size and padding
|
|
final rowSize = (width * 3 + 3) & ~3;
|
|
final padding = rowSize - (width * 3);
|
|
|
|
// Pixel data (BMP stores in BGR format)
|
|
final bmpData = Uint8List(rowSize * height);
|
|
for (var y = 0; y < height; y++) {
|
|
for (var x = 0; x < width; x++) {
|
|
final srcIndex = (y * width + x) * 4; // RGBA format
|
|
final dstIndex = y * rowSize + x * 3; // BGR format
|
|
bmpData[dstIndex] = pixelBuffer[srcIndex + 2]; // Blue
|
|
bmpData[dstIndex + 1] = pixelBuffer[srcIndex + 1]; // Green
|
|
bmpData[dstIndex + 2] = pixelBuffer[srcIndex]; // Red
|
|
// Alpha channel is discarded
|
|
}
|
|
// Add padding to the end of each row
|
|
for (var p = 0; p < padding; p++) {
|
|
bmpData[y * rowSize + width * 3 + p] = 0;
|
|
}
|
|
}
|
|
|
|
// Write BMP file
|
|
final file = File(outputPath);
|
|
final sink = file.openWrite();
|
|
sink.add(fileHeader.buffer.asUint8List());
|
|
sink.add(infoHeader.buffer.asUint8List());
|
|
sink.add(bmpData);
|
|
await sink.close();
|
|
|
|
print('BMP image saved to: $outputPath');
|
|
}
|
|
|
|
final viewportDimensions = (width: 500, height: 500);
|
|
void main() async {
|
|
final packageUri = findPackageRoot('thermion_dart');
|
|
testDir = Directory("${packageUri.toFilePath()}/test").path;
|
|
final lib = ThermionDartTexture1(DynamicLibrary.open(
|
|
'${packageUri.toFilePath()}/native/lib/macos/swift/libthermion_swift.dylib'));
|
|
final object = ThermionDartTexture.new1(lib);
|
|
object.initWithWidth_height_(
|
|
viewportDimensions.width, viewportDimensions.height);
|
|
|
|
final resourceLoader = calloc<ResourceLoaderWrapper>(1);
|
|
var loadToOut = NativeCallable<
|
|
Void Function(Pointer<Char>,
|
|
Pointer<ResourceBuffer>)>.listener(DartResourceLoader.loadResource);
|
|
|
|
resourceLoader.ref.loadToOut = loadToOut.nativeFunction;
|
|
var freeResource = NativeCallable<Void Function(ResourceBuffer)>.listener(
|
|
DartResourceLoader.freeResource);
|
|
resourceLoader.ref.freeResource = freeResource.nativeFunction;
|
|
|
|
var viewer = ThermionViewerFFI(resourceLoader: resourceLoader.cast<Void>());
|
|
|
|
await viewer.initialized;
|
|
await viewer.createSwapChain(viewportDimensions.width.toDouble(),
|
|
viewportDimensions.height.toDouble());
|
|
await viewer.createRenderTarget(viewportDimensions.width.toDouble(),
|
|
viewportDimensions.height.toDouble(), object.metalTextureAddress);
|
|
await viewer.updateViewportAndCameraProjection(
|
|
viewportDimensions.width.toDouble(),
|
|
viewportDimensions.height.toDouble());
|
|
|
|
var outDir = Directory("$testDir/output");
|
|
|
|
// outDir.deleteSync(recursive: true);
|
|
outDir.createSync();
|
|
|
|
Future _capture(String outputFilename) async {
|
|
var outPath = p.join(outDir.path, "$outputFilename.bmp");
|
|
var pixelBuffer = await viewer.capture();
|
|
await pixelBufferToBmp(pixelBuffer, viewportDimensions.width,
|
|
viewportDimensions.height, outPath);
|
|
}
|
|
|
|
group('background', () {
|
|
test('set background color to solid green', () async {
|
|
await viewer.setRendering(true);
|
|
await viewer.setBackgroundColor(0.0, 1.0, 0.0, 1.0);
|
|
await _capture("bgcolor");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('load skybox', () async {
|
|
var outDir = Directory("$testDir/skybox");
|
|
outDir.createSync();
|
|
await viewer.setRendering(true);
|
|
await viewer.loadSkybox(
|
|
"file:///$testDir/../../examples/assets/default_env/default_env_skybox.ktx");
|
|
await Future.delayed(Duration(seconds: 1));
|
|
await _capture("skybox");
|
|
await viewer.setRendering(false);
|
|
});
|
|
});
|
|
|
|
group("gltf", () {
|
|
test('load glb', () async {
|
|
var model = await viewer.loadGlb("$testDir/cube.glb");
|
|
await viewer.transformToUnitCube(model);
|
|
await viewer.setBackgroundColor(0.0, 0.0, 1.0, 1.0);
|
|
await viewer.setCameraPosition(0, 1, 5);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -0.5));
|
|
await viewer.setRendering(true);
|
|
await _capture("load_glb");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('create instance from glb when keepData is true', () async {
|
|
var model = await viewer.loadGlb("$testDir/cube.glb", keepData: true);
|
|
await viewer.transformToUnitCube(model);
|
|
var instance = await viewer.createInstance(model);
|
|
await viewer.setPosition(instance, 0.5, 0.5, -0.5);
|
|
await viewer.setBackgroundColor(0.0, 0.0, 1.0, 1.0);
|
|
await viewer.setCameraPosition(0, 1, 5);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -0.5));
|
|
await viewer.setRendering(true);
|
|
await _capture("glb_create_instance");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('create instance from glb fails when keepData is false', () async {
|
|
var model = await viewer.loadGlb("$testDir/cube.glb", keepData: false);
|
|
bool thrown = false;
|
|
try {
|
|
await viewer.createInstance(model);
|
|
} catch (err) {
|
|
thrown = true;
|
|
}
|
|
expect(thrown, true);
|
|
});
|
|
});
|
|
|
|
group('Skinning & animations', () {
|
|
test('get bone names', () async {
|
|
var model = await viewer.loadGlb("$testDir/assets/shapes.glb");
|
|
var names = await viewer.getBoneNames(model);
|
|
expect(names.first, "Bone");
|
|
});
|
|
|
|
test('reset bones', () async {
|
|
var model = await viewer.loadGlb("$testDir/assets/shapes.glb");
|
|
await viewer.resetBones(model);
|
|
});
|
|
test('set from BVH', () async {
|
|
var model = await viewer.loadGlb("$testDir/assets/shapes.glb");
|
|
var animation = BVHParser.parse(
|
|
File("$testDir/assets/animation.bvh").readAsStringSync(),
|
|
boneRegex: RegExp(r"Bone$"));
|
|
await viewer.addBoneAnimation(model, animation);
|
|
});
|
|
|
|
test('fade in/out', () async {
|
|
var model = await viewer.loadGlb("$testDir/assets/shapes.glb");
|
|
var animation = BVHParser.parse(
|
|
File("$testDir/assets/animation.bvh").readAsStringSync(),
|
|
boneRegex: RegExp(r"Bone$"));
|
|
await viewer.addBoneAnimation(model, animation,
|
|
fadeInInSecs: 0.5, fadeOutInSecs: 0.5);
|
|
await Future.delayed(Duration(seconds: 1));
|
|
});
|
|
|
|
test('create geometry', () async {
|
|
// Define the vertices of the cube
|
|
List<double> vertices = [
|
|
// Front face
|
|
-1, -1, 1,
|
|
1, -1, 1,
|
|
1, 1, 1,
|
|
-1, 1, 1,
|
|
|
|
// Back face
|
|
-1, -1, -1,
|
|
-1, 1, -1,
|
|
1, 1, -1,
|
|
1, -1, -1,
|
|
|
|
// Top face
|
|
-1, 1, -1,
|
|
-1, 1, 1,
|
|
1, 1, 1,
|
|
1, 1, -1,
|
|
|
|
// Bottom face
|
|
-1, -1, -1,
|
|
1, -1, -1,
|
|
1, -1, 1,
|
|
-1, -1, 1,
|
|
|
|
// Right face
|
|
1, -1, -1,
|
|
1, 1, -1,
|
|
1, 1, 1,
|
|
1, -1, 1,
|
|
|
|
// Left face
|
|
-1, -1, -1,
|
|
-1, -1, 1,
|
|
-1, 1, 1,
|
|
-1, 1, -1,
|
|
];
|
|
|
|
// Define the indices for the cube
|
|
List<int> indices = [
|
|
0, 1, 2, 0, 2, 3, // Front face
|
|
4, 5, 6, 4, 6, 7, // Back face
|
|
8, 9, 10, 8, 10, 11, // Top face
|
|
12, 13, 14, 12, 14, 15, // Bottom face
|
|
16, 17, 18, 16, 18, 19, // Right face
|
|
20, 21, 22, 20, 22, 23 // Left face
|
|
];
|
|
await viewer.createIbl(1.0, 1.0, 1.0, 1000);
|
|
await viewer.setCameraPosition(0, 0.5, 6);
|
|
await viewer.setBackgroundColor(0.0, 0.0, 1.0, 1.0);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
|
|
await viewer.setRendering(true);
|
|
|
|
// Create the cube geometry
|
|
await viewer.createGeometry(vertices, indices,
|
|
primitiveType: PrimitiveType.TRIANGLES);
|
|
|
|
await _capture("geometry_cube");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('create sphere', () async {
|
|
// Define the parameters for the sphere
|
|
int latitudeBands = 30;
|
|
int longitudeBands = 30;
|
|
double radius = 1.0;
|
|
|
|
List<double> vertices = [];
|
|
List<int> indices = [];
|
|
|
|
// Generate vertices
|
|
for (int latNumber = 0; latNumber <= latitudeBands; latNumber++) {
|
|
double theta = latNumber * pi / latitudeBands;
|
|
double sinTheta = sin(theta);
|
|
double cosTheta = cos(theta);
|
|
|
|
for (int longNumber = 0; longNumber <= longitudeBands; longNumber++) {
|
|
double phi = longNumber * 2 * pi / longitudeBands;
|
|
double sinPhi = sin(phi);
|
|
double cosPhi = cos(phi);
|
|
|
|
double x = cosPhi * sinTheta;
|
|
double y = cosTheta;
|
|
double z = sinPhi * sinTheta;
|
|
|
|
vertices.addAll([radius * x, radius * y, radius * z]);
|
|
}
|
|
}
|
|
|
|
// Generate indices
|
|
for (int latNumber = 0; latNumber < latitudeBands; latNumber++) {
|
|
for (int longNumber = 0; longNumber < longitudeBands; longNumber++) {
|
|
int first = (latNumber * (longitudeBands + 1)) + longNumber;
|
|
int second = first + longitudeBands + 1;
|
|
|
|
indices.addAll(
|
|
[first, second, first + 1, second, second + 1, first + 1]);
|
|
}
|
|
}
|
|
|
|
await viewer.createIbl(1.0, 1.0, 1.0, 1000);
|
|
await viewer.setCameraPosition(0, 0.5, 10);
|
|
await viewer.setBackgroundColor(0.0, 0.0, 1.0, 1.0);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -pi / 8));
|
|
await viewer.setRendering(true);
|
|
|
|
// Create the sphere geometry
|
|
// final sphere = await viewer.createGeometry(vertices, indices,
|
|
// primitiveType: PrimitiveType.TRIANGLES);
|
|
|
|
// await viewer.gizmo!.attach(sphere);
|
|
// await viewer.setPosition(sphere, -1.0, 0.0, -10.0);
|
|
// await viewer.setRotationQuat(
|
|
// sphere, Quaternion.axisAngle(Vector3(1, 0, 0), pi / 8));
|
|
await _capture("geometry_sphere");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('enable grid overlay', () async {
|
|
await viewer.setBackgroundColor(0, 0, 0, 1);
|
|
await viewer.setCameraPosition(0, 0.5, 0);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -0.1));
|
|
await viewer.setRendering(true);
|
|
await viewer.setLayerEnabled(2, true);
|
|
await _capture("grid");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('point light', () async {
|
|
var model = await viewer.loadGlb("$testDir/cube.glb");
|
|
await viewer.transformToUnitCube(model);
|
|
var light = await viewer.addLight(
|
|
LightType.POINT, 6500, 1000000, 0, 2, 0, 0, -1, 0,
|
|
falloffRadius: 10.0);
|
|
await viewer.setBackgroundColor(0.0, 0.0, 0.0, 1.0);
|
|
await viewer.setCameraPosition(0, 1, 5);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -0.5));
|
|
await viewer.setRendering(true);
|
|
await _capture("point_light");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('set point light position', () async {
|
|
var model = await viewer.loadGlb("$testDir/cube.glb");
|
|
await viewer.transformToUnitCube(model);
|
|
var light = await viewer.addLight(
|
|
LightType.POINT, 6500, 1000000, 0, 2, 0, 0, -1, 0,
|
|
falloffRadius: 10.0);
|
|
await viewer.setLightPosition(light, 0.5, 2, 0);
|
|
await viewer.setBackgroundColor(0.0, 0.0, 0.0, 1.0);
|
|
await viewer.setCameraPosition(0, 1, 5);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -0.5));
|
|
await viewer.setRendering(true);
|
|
await _capture("move_point_light");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('directional light', () async {
|
|
var model = await viewer.loadGlb("$testDir/cube.glb");
|
|
await viewer.transformToUnitCube(model);
|
|
var light = await viewer.addLight(
|
|
LightType.SUN, 6500, 1000000, 0, 0, 0, 0, -1, 0);
|
|
await viewer.setBackgroundColor(0.0, 0.0, 0.0, 1.0);
|
|
await viewer.setCameraPosition(0, 1, 5);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -0.5));
|
|
await viewer.setRendering(true);
|
|
await _capture("directional_light");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('set directional light direction', () async {
|
|
var model = await viewer.loadGlb("$testDir/cube.glb");
|
|
await viewer.transformToUnitCube(model);
|
|
var light = await viewer.addLight(
|
|
LightType.SUN, 6500, 1000000, 0, 0, 0, 0, -1, 0);
|
|
await viewer.setLightDirection(light, Vector3(-1, -1, -1));
|
|
await viewer.setBackgroundColor(0.0, 0.0, 0.0, 1.0);
|
|
await viewer.setCameraPosition(0, 1, 5);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -0.5));
|
|
await viewer.setRendering(true);
|
|
await _capture("set_directional_light_direction");
|
|
await viewer.setRendering(false);
|
|
});
|
|
|
|
test('set stencil highlight', () async {
|
|
var model = await viewer.loadGlb("$testDir/cube.glb");
|
|
await viewer.transformToUnitCube(model);
|
|
await viewer.setPostProcessing(true);
|
|
|
|
var light = await viewer.addLight(
|
|
LightType.SUN, 6500, 1000000, 0, 0, 0, 0, -1, 0);
|
|
await viewer.setLightDirection(light, Vector3(-1, -1, -1));
|
|
|
|
await viewer.setBackgroundColor(0.0, 0.0, 0.0, 1.0);
|
|
await viewer.setCameraPosition(0, 1, 5);
|
|
await viewer
|
|
.setCameraRotation(Quaternion.axisAngle(Vector3(1, 0, 0), -0.5));
|
|
await viewer.setStencilHighlight(model);
|
|
await viewer.setRendering(true);
|
|
await Future.delayed(Duration(milliseconds: 500));
|
|
await _capture("stencil_highlight");
|
|
await viewer.setRendering(false);
|
|
});
|
|
});
|
|
}
|