303 lines
9.7 KiB
Dart
303 lines
9.7 KiB
Dart
import 'dart:io';
|
|
import 'package:archive/archive.dart';
|
|
import 'package:logging/logging.dart';
|
|
import 'package:native_assets_cli/native_assets_cli.dart';
|
|
import 'package:native_toolchain_c/native_toolchain_c.dart';
|
|
|
|
void main(List<String> args) async {
|
|
await build(args, (config, output) async {
|
|
var logDir = Directory(
|
|
"${config.packageRoot.toFilePath()}.dart_tool/thermion_dart/log/");
|
|
if (!logDir.existsSync()) {
|
|
logDir.createSync(recursive: true);
|
|
}
|
|
var logFile = File(logDir.path + "/build.log");
|
|
|
|
final logger = Logger("")
|
|
..level = Level.ALL
|
|
..onRecord.listen((record) => logFile.writeAsStringSync(
|
|
record.message + "\n",
|
|
mode: FileMode.append,
|
|
flush: true));
|
|
|
|
var platform = config.targetOS.toString().toLowerCase();
|
|
|
|
// We don't support Linux (yet), so the native/Filament libraries won't be
|
|
// compiled/available. However, we still want to be able to run the Dart
|
|
// package itself on a Linux host(e.g. for dart_services backed), so if
|
|
// we detect that we're running on Linux, add some dummy native code
|
|
// assets and exit early.
|
|
if (platform == "linux") {
|
|
final linkMode = DynamicLoadingBundled();
|
|
final name = "thermion_dart.dart";
|
|
final libUri = config.outputDirectory
|
|
.resolve(config.targetOS.libraryFileName(name, linkMode));
|
|
output.addAssets(
|
|
[
|
|
NativeCodeAsset(
|
|
package: config.packageName,
|
|
name: name,
|
|
file: libUri,
|
|
linkMode: linkMode,
|
|
os: config.targetOS,
|
|
architecture: config.dryRun ? null : config.targetArchitecture,
|
|
)
|
|
],
|
|
linkInPackage: null,
|
|
);
|
|
return;
|
|
}
|
|
|
|
var libDir = config.dryRun ? "" : (await getLibDir(config, logger)).path;
|
|
|
|
final packageName = config.packageName;
|
|
|
|
final sources = Directory("${config.packageRoot.toFilePath()}/native/src")
|
|
.listSync(recursive: true)
|
|
.whereType<File>()
|
|
.map((f) => f.path)
|
|
.toList();
|
|
sources.addAll([
|
|
"${config.packageRoot.toFilePath()}/native/include/material/gizmo.c",
|
|
"${config.packageRoot.toFilePath()}/native/include/material/image.c",
|
|
"${config.packageRoot.toFilePath()}/native/include/material/grid.c",
|
|
"${config.packageRoot.toFilePath()}/native/include/material/unlit.c",
|
|
]);
|
|
|
|
var libs = [
|
|
"filament",
|
|
"backend",
|
|
"filameshio",
|
|
"viewer",
|
|
"filamat",
|
|
"geometry",
|
|
"utils",
|
|
"filabridge",
|
|
"gltfio_core",
|
|
"filament-iblprefilter",
|
|
"image",
|
|
"imageio",
|
|
"tinyexr",
|
|
"filaflat",
|
|
"dracodec",
|
|
"ibl",
|
|
"ktxreader",
|
|
"png",
|
|
"z",
|
|
"stb",
|
|
"uberzlib",
|
|
"smol-v",
|
|
"uberarchive",
|
|
"zstd",
|
|
"basis_transcoder"
|
|
];
|
|
|
|
|
|
if (platform == "windows") {
|
|
libDir = Directory(libDir).uri.toFilePath();
|
|
libs = libs.map((lib) => "${libDir}${lib}.lib").toList();
|
|
libs.addAll(["${libDir}bluevk.lib", "${libDir}bluegl.lib"]);
|
|
libs.addAll([
|
|
"gdi32.lib",
|
|
"user32.lib",
|
|
"shell32.lib",
|
|
"opengl32.lib",
|
|
"dwmapi.lib",
|
|
"comctl32.lib"
|
|
]);
|
|
} else {
|
|
libs.add("stdc++");
|
|
}
|
|
final flags = []; //"-fsanitize=address"];
|
|
final defines = <String, String?>{};
|
|
var frameworks = [];
|
|
|
|
if (platform != "windows") {
|
|
flags.addAll(['-std=c++17']);
|
|
} else {
|
|
defines["WIN32"] = "1";
|
|
defines["_DEBUG"] = "1";
|
|
defines["_DLL"] = "1";
|
|
flags.addAll(["/std:c++20", "/MDd"]);
|
|
}
|
|
|
|
if (platform == "ios") {
|
|
frameworks.addAll([
|
|
'Foundation',
|
|
'CoreGraphics',
|
|
'QuartzCore',
|
|
'GLKit',
|
|
"Metal",
|
|
'CoreVideo',
|
|
'OpenGLES'
|
|
]);
|
|
} else if (platform == "macos") {
|
|
frameworks.addAll([
|
|
'Foundation',
|
|
'CoreVideo',
|
|
'Cocoa',
|
|
"Metal",
|
|
]);
|
|
libs.addAll(["bluegl", "bluevk"]);
|
|
} else if (platform == "android") {
|
|
libs.addAll(["GLESv3", "EGL", "bluevk", "dl", "android"]);
|
|
}
|
|
|
|
frameworks = frameworks.expand((f) => ["-framework", f]).toList();
|
|
|
|
final cbuilder = CBuilder.library(
|
|
name: packageName,
|
|
language: Language.cpp,
|
|
assetName: 'thermion_dart.dart',
|
|
sources: sources,
|
|
includes: ['native/include', 'native/include/filament'],
|
|
defines: defines,
|
|
flags: [
|
|
if (platform == "macos") '-mmacosx-version-min=13.0',
|
|
if (platform == "ios") '-mios-version-min=13.0',
|
|
...flags,
|
|
...frameworks,
|
|
...libs.map((lib) => "-l$lib"),
|
|
"-L$libDir",
|
|
],
|
|
dartBuildFiles: ['hook/build.dart'],
|
|
);
|
|
|
|
await cbuilder.run(
|
|
buildConfig: config,
|
|
buildOutput: output,
|
|
logger: logger,
|
|
);
|
|
if (config.targetOS == OS.android) {
|
|
if (!config.dryRun) {
|
|
final archExtension = switch (config.targetArchitecture) {
|
|
Architecture.arm => "arm-linux-androideabi",
|
|
Architecture.arm64 => "aarch64-linux-android",
|
|
Architecture.x64 => "x86_64-linux-android",
|
|
Architecture.ia32 => "i686-linux-android",
|
|
_ => throw FormatException('Invalid')
|
|
};
|
|
|
|
var compilerPath = config.cCompiler.compiler!.path;
|
|
|
|
if(Platform.isWindows && compilerPath.startsWith("/")) {
|
|
compilerPath = compilerPath.substring(1);
|
|
}
|
|
|
|
var ndkRoot = File(compilerPath).parent.parent.uri.toFilePath(windows:true);
|
|
|
|
var stlPath =
|
|
File([ndkRoot, "sysroot", "usr", "lib", archExtension, "libc++_shared.so"].join(Platform.pathSeparator));
|
|
output.addAsset(NativeCodeAsset(
|
|
package: "thermion_dart",
|
|
name: "libc++_shared.so",
|
|
linkMode: DynamicLoadingBundled(),
|
|
os: config.targetOS,
|
|
file: stlPath.uri,
|
|
architecture: config.targetArchitecture));
|
|
}
|
|
}
|
|
// do we need this?
|
|
if (config.targetOS == "windows") {
|
|
output.addAsset(
|
|
NativeCodeAsset(
|
|
package: "thermion_dart",
|
|
name: "thermion_dart.dll",
|
|
linkMode: DynamicLoadingBundled(),
|
|
os: config.targetOS,
|
|
file: Uri.file(
|
|
config.outputDirectory.toFilePath() + "/thermion_dart.dll"),
|
|
architecture: config.targetArchitecture),
|
|
linkInPackage: config.packageName);
|
|
}
|
|
});
|
|
}
|
|
|
|
String _FILAMENT_VERSION = "v1.51.2";
|
|
String _getLibraryUrl(String platform, String mode) {
|
|
return "https://pub-c8b6266320924116aaddce03b5313c0a.r2.dev/filament-${_FILAMENT_VERSION}-${platform}-${mode}.zip";
|
|
}
|
|
|
|
//
|
|
// Download precompiled Filament libraries for the target platform from Cloudflare.
|
|
//
|
|
Future<Directory> getLibDir(BuildConfig config, Logger logger) async {
|
|
var platform = config.targetOS.toString().toLowerCase();
|
|
|
|
// Except on Windows, most users will only need release builds of Filament.
|
|
// Debug builds are probably only relevant if you're a package developer debugging an internal Filament issue
|
|
// or if you're working on Flutter+Windows (which requires the CRT debug DLLs).
|
|
// Also note that there are known driver issues with Android debug builds, e.g.:
|
|
// https://github.com/google/filament/issues/7162
|
|
// (these aren't present in Filament release builds).
|
|
// However, if you know what you're doing, you can change "release" to "debug" below.
|
|
// TODO - check if we can pass this as a CLI compiler flag
|
|
var mode = "release";
|
|
if (platform == "windows") {
|
|
mode = config.buildMode == BuildMode.debug ? "debug" : "release";
|
|
}
|
|
|
|
var libDir = Directory(
|
|
"${config.packageRoot.toFilePath()}/.dart_tool/thermion_dart/lib/${_FILAMENT_VERSION}/$platform/$mode/");
|
|
|
|
if (platform == "android") {
|
|
final archExtension = switch (config.targetArchitecture) {
|
|
Architecture.arm => "armeabi-v7a",
|
|
Architecture.arm64 => "arm64-v8a",
|
|
Architecture.x64 => "x86_64",
|
|
Architecture.ia32 => "x86",
|
|
_ => throw FormatException('Invalid')
|
|
};
|
|
libDir = Directory("${libDir.path}/$archExtension/");
|
|
} else if (platform == "windows") {
|
|
if (config.targetArchitecture != Architecture.x64) {
|
|
throw Exception(
|
|
"Unsupported architecture : ${config.targetArchitecture}");
|
|
}
|
|
}
|
|
|
|
final url = _getLibraryUrl(platform, mode);
|
|
|
|
final filename = url.split("/").last;
|
|
|
|
// We will write an empty file called success to the unzip directory after successfully downloading/extracting the prebuilt libraries.
|
|
// If this file already exists, we assume everything has been successfully extracted and skip
|
|
final unzipDir = platform == "android" ? libDir.parent.path : libDir.path;
|
|
final successToken = File("$unzipDir/success");
|
|
final libraryZip = File("$unzipDir/$filename");
|
|
|
|
if (!successToken.existsSync()) {
|
|
if (libraryZip.existsSync()) {
|
|
libraryZip.deleteSync();
|
|
}
|
|
|
|
if (!libraryZip.parent.existsSync()) {
|
|
libraryZip.parent.createSync(recursive: true);
|
|
}
|
|
|
|
logger.info(
|
|
"Downloading prebuilt libraries for $platform/$mode from $url to ${libraryZip}, files will be unzipped to ${unzipDir}");
|
|
final request = await HttpClient().getUrl(Uri.parse(url));
|
|
final response = await request.close();
|
|
|
|
await response.pipe(libraryZip.openWrite());
|
|
|
|
final archive = ZipDecoder().decodeBytes(await libraryZip.readAsBytes());
|
|
|
|
for (final file in archive) {
|
|
final filename = file.name;
|
|
if (file.isFile) {
|
|
final data = file.content as List<int>;
|
|
final f = File('${unzipDir}/$filename');
|
|
await f.create(recursive: true);
|
|
await f.writeAsBytes(data);
|
|
} else {
|
|
final d = Directory('${unzipDir}/$filename');
|
|
await d.create(recursive: true);
|
|
}
|
|
}
|
|
successToken.writeAsStringSync("SUCCESS");
|
|
}
|
|
return libDir;
|
|
}
|