"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.close = exports.run = exports.api = void 0;
const child_process = require("child_process");
const fs = require("fs-extra");
const path = require("path");
const exec_1 = require("./exec");
const korepath = require("./korepath");
const log = require("./log");
const Platform_1 = require("./Platform");
const ProjectFile_1 = require("./ProjectFile");
const AssetConverter_1 = require("./AssetConverter");
const HaxeCompiler_1 = require("./HaxeCompiler");
const ShaderCompiler_1 = require("./ShaderCompiler");
const DebugHtml5Exporter_1 = require("./Exporters/DebugHtml5Exporter");
const EmptyExporter_1 = require("./Exporters/EmptyExporter");
const FlashExporter_1 = require("./Exporters/FlashExporter");
const Html5Exporter_1 = require("./Exporters/Html5Exporter");
const Html5WorkerExporter_1 = require("./Exporters/Html5WorkerExporter");
const JavaExporter_1 = require("./Exporters/JavaExporter");
const KincExporter_1 = require("./Exporters/KincExporter");
const KincHLExporter_1 = require("./Exporters/KincHLExporter");
const KromExporter_1 = require("./Exporters/KromExporter");
const NodeExporter_1 = require("./Exporters/NodeExporter");
const PlayStationMobileExporter_1 = require("./Exporters/PlayStationMobileExporter");
const WpfExporter_1 = require("./Exporters/WpfExporter");
const HaxeProject_1 = require("./HaxeProject");
const Icon = require("./Icon");
let lastAssetConverter;
let lastShaderCompiler;
let lastHaxeCompiler;
function fixName(name) {
name = name.replace(/[-@\ \.\/\\]/g, '_');
if (name[0] === '0' || name[0] === '1' || name[0] === '2' || name[0] === '3' || name[0] === '4'
|| name[0] === '5' || name[0] === '6' || name[0] === '7' || name[0] === '8' || name[0] === '9') {
name = '_' + name;
}
return name;
}
function safeName(name) {
return name.replace(/[^A-z0-9\-\_]/g, '-');
}
function createKorefile(name, exporter, options, targetOptions, libraries, cdefines, cflags, cppflags, stackSize, version, id, korehl, icon) {
let out = '';
out += 'let fs = require(\'fs\');\n';
out += 'let path = require(\'path\');\n';
out += 'let project = new Project(\'' + name + '\');\n';
if (version) {
out += 'project.version = \'' + version + '\';\n';
}
if (id) {
out += 'project.id = \'' + id + '\';\n';
}
if (icon != null)
out += 'project.icon = \'' + icon + '\';\n';
for (let cdefine of cdefines) {
out += 'project.addDefine(\'' + cdefine + '\');\n';
}
for (let cppflag of cppflags) {
out += 'project.addCppFlag(\'' + cppflag + '\');\n';
}
for (let cflag of cflags) {
out += 'project.addCFlag(\'' + cflag + '\');\n';
}
out += 'project.addDefine(\'HXCPP_API_LEVEL=400\');\n';
out += 'project.addDefine(\'HXCPP_DEBUG\', \'Debug\');\n';
if (!options.slowgc) {
out += 'project.addDefine(\'HXCPP_GC_GENERATIONAL\');\n';
}
if (targetOptions) {
let koreTargetOptions = {};
for (let option in targetOptions) {
koreTargetOptions[option] = targetOptions[option];
}
out += 'project.targetOptions = ' + JSON.stringify(koreTargetOptions) + ';\n';
}
out += 'project.setDebugDir(\'' + path.relative(options.from, path.join(options.to, exporter.sysdir())).replace(/\\/g, '/') + '\');\n';
let buildpath = path.relative(options.from, path.join(options.to, exporter.sysdir() + '-build')).replace(/\\/g, '/');
if (buildpath.startsWith('..'))
buildpath = path.resolve(path.join(options.from.toString(), buildpath));
out += 'await project.addProject(\'' + path.join(options.kha, 'Kinc').replace(/\\/g, '/') + '\');\n';
out += 'await project.addProject(\'' + buildpath.replace(/\\/g, '/') + '\');\n';
if (korehl)
out += 'await project.addProject(\'' + path.join(options.kha, 'Backends', 'Kinc-HL').replace(/\\/g, '/') + '\');\n';
else
out += 'await project.addProject(\'' + path.join(options.kha, 'Backends', 'Kinc-hxcpp').replace(/\\/g, '/') + '\');\n';
for (let lib of libraries) {
let libPath = lib.libpath.replace(/\\/g, '/');
out += 'if (fs.existsSync(path.join(\'' + libPath + '\', \'kfile.js\')) || fs.existsSync(path.join(\'' + libPath + '\', \'kincfile.js\')) || fs.existsSync(path.join(\'' + libPath + '\', \'korefile.js\'))) {\n';
out += '\tawait project.addProject(\'' + libPath + '\');\n';
out += '}\n';
}
if (stackSize) {
out += 'project.stackSize = ' + stackSize + ';\n';
}
out += 'project.flatten();\n';
out += 'resolve(project);\n';
return out;
}
function runKmake(options) {
return new Promise((resolve, reject) => {
const child = child_process.spawn(path.join(korepath.get(), 'kmake' + (0, exec_1.sys)()), options);
child.stdout.on('data', (data) => {
const str = data.toString();
log.info(str, false);
});
child.stderr.on('data', (data) => {
const str = data.toString();
log.error(str, false);
});
child.on('error', (err) => {
log.error('Could not start kmake.');
reject();
});
child.on('close', (code) => {
if (code === 0) {
resolve();
}
else {
reject();
}
});
});
}
async function exportProjectFiles(name, resourceDir, options, exporter, kore, korehl, icon, libraries, targetOptions, defines, cdefines, cflags, cppflags, stackSize, version, id) {
if (options.haxe !== '') {
let haxeOptions = exporter.haxeOptions(name, targetOptions, defines);
haxeOptions.defines.push('kha');
haxeOptions.defines.push('kha_version=1810');
haxeOptions.safeName = safeName(haxeOptions.name);
haxeOptions.defines.push('kha_project_name=' + haxeOptions.name);
if (options.livereload)
haxeOptions.defines.push('kha_live_reload');
if (options.debug && haxeOptions.parameters.indexOf('-debug') < 0) {
haxeOptions.parameters.push('-debug');
}
(0, HaxeProject_1.writeHaxeProject)(options.to, !options.noproject, haxeOptions);
if (!options.nohaxe) {
let compiler = new HaxeCompiler_1.HaxeCompiler(options.to, haxeOptions.to, haxeOptions.realto, resourceDir, options.haxe, 'project-' + exporter.sysdir() + '.hxml', haxeOptions.sources, exporter.sysdir(), options.watchport, options.livereload, options.port);
lastHaxeCompiler = compiler;
try {
await compiler.run(options.watch);
}
catch (error) {
return Promise.reject(error);
}
}
for (let callback of ProjectFile_1.Callbacks.postHaxeCompilation) {
callback();
}
await exporter.export(name, targetOptions, haxeOptions);
}
let buildDir = path.join(options.to, exporter.sysdir() + '-build');
if (options.haxe !== '' && kore && !options.noproject) {
// If target is a Kore project, generate additional project folders here.
// generate the kincfile.js
fs.copySync(path.join(__dirname, '..', 'Data', 'hxcpp', 'kfile.js'), path.join(buildDir, 'kfile.js'), { overwrite: true });
fs.writeFileSync(path.join(options.to, 'kfile.js'), createKorefile(name, exporter, options, targetOptions, libraries, cdefines, cflags, cppflags, stackSize, version, id, false, icon));
// Similar to khamake.js -> main.js -> run(...)
// We now do kincmake.js -> main.js -> run(...)
// This will create additional project folders for the target,
// e.g. 'build/pi-build'
try {
const kmakeOptions = ['--from', options.from, '--to', buildDir, '--kfile', path.resolve(options.to, 'kfile.js'), '-t', koreplatform(options.target), '--noshaders',
'--graphics', options.graphics, '--arch', options.arch, '--audio', options.audio, '--vr', options.vr, '-v', options.visualstudio
];
if (options.nosigning) {
kmakeOptions.push('--nosigning');
}
if (options.debug) {
kmakeOptions.push('--debug');
}
if (options.run) {
kmakeOptions.push('--run');
}
if (options.compile) {
kmakeOptions.push('--compile');
}
await runKmake(kmakeOptions);
for (let callback of ProjectFile_1.Callbacks.postCppCompilation) {
callback();
}
log.info('Done.');
return name;
}
catch (error) {
if (error) {
log.error('Error: ' + error);
}
else {
log.error('Error.');
}
process.exit(1);
return name;
}
}
else if (options.haxe !== '' && korehl && !options.noproject) {
fs.copySync(path.join(__dirname, '..', 'Data', 'hl', 'kore_sources.c'), path.join(buildDir, 'kore_sources.c'), { overwrite: true });
fs.copySync(path.join(__dirname, '..', 'Data', 'hl', 'kfile.js'), path.join(buildDir, 'kfile.js'), { overwrite: true });
fs.writeFileSync(path.join(options.to, 'kfile.js'), createKorefile(name, exporter, options, targetOptions, libraries, cdefines, cflags, cppflags, stackSize, version, id, korehl, icon));
try {
const kmakeOptions = ['--from', options.from, '--to', buildDir, '--kfile', path.resolve(options.to, 'kfile.js'), '-t', koreplatform(options.target), '--noshaders',
'--graphics', options.graphics, '--arch', options.arch, '--audio', options.audio, '--vr', options.vr, '-v', options.visualstudio
];
if (options.nosigning) {
kmakeOptions.push('--nosigning');
}
if (options.debug) {
kmakeOptions.push('--debug');
}
if (options.run) {
kmakeOptions.push('--run');
}
if (options.compile) {
kmakeOptions.push('--compile');
}
await runKmake(kmakeOptions);
for (let callback of ProjectFile_1.Callbacks.postCppCompilation) {
callback();
}
log.info('Done.');
return name;
}
catch (error) {
if (error) {
log.error('Error: ' + error);
}
else {
log.error('Error.');
}
process.exit(1);
return name;
}
}
else {
// If target is not a Kore project, e.g. HTML5, finish building here.
log.info('Done.');
return name;
}
}
function checkKorePlatform(platform) {
return platform === 'windows'
|| platform === 'windowsapp'
|| platform === 'ios'
|| platform === 'osx'
|| platform === 'android'
|| platform === 'linux'
|| platform === 'emscripten'
|| platform === 'pi'
|| platform === 'tvos'
|| platform === 'ps4'
|| platform === 'xboxone'
|| platform === 'switch'
|| platform === 'xboxscarlett'
|| platform === 'ps5'
|| platform === 'freebsd';
}
function koreplatform(platform) {
if (platform.endsWith('-hl'))
return platform.substr(0, platform.length - '-hl'.length);
else
return platform;
}
let kore = false;
let korehl = false;
async function exportKhaProject(options) {
log.info('Creating Kha project.');
let project = null;
let foundProjectFile = false;
// get the khafile.js and load the config code,
// then create the project config object, which contains stuff
// like project name, assets paths, sources path, library path...
if (fs.existsSync(path.join(options.from, options.projectfile))) {
try {
project = await (0, ProjectFile_1.loadProject)(options.from, options.projectfile, options.target);
}
catch (x) {
log.error(x);
throw 'Loading the projectfile failed.';
}
foundProjectFile = true;
}
if (!foundProjectFile) {
throw 'No khafile found.';
}
let temp = path.join(options.to, 'temp');
fs.ensureDirSync(temp);
let exporter = null;
let target = options.target.toLowerCase();
let baseTarget = target;
let customTarget = null;
if (project.customTargets.get(options.target)) {
customTarget = project.customTargets.get(options.target);
baseTarget = customTarget.baseTarget;
}
switch (baseTarget) {
case Platform_1.Platform.Krom:
exporter = new KromExporter_1.KromExporter(options);
break;
case Platform_1.Platform.Flash:
exporter = new FlashExporter_1.FlashExporter(options);
break;
case Platform_1.Platform.HTML5:
exporter = new Html5Exporter_1.Html5Exporter(options);
break;
case Platform_1.Platform.HTML5Worker:
exporter = new Html5WorkerExporter_1.Html5WorkerExporter(options);
break;
case Platform_1.Platform.DebugHTML5:
exporter = new DebugHtml5Exporter_1.DebugHtml5Exporter(options);
break;
case Platform_1.Platform.WPF:
exporter = new WpfExporter_1.WpfExporter(options);
break;
case Platform_1.Platform.Java:
exporter = new JavaExporter_1.JavaExporter(options);
break;
case Platform_1.Platform.PlayStationMobile:
exporter = new PlayStationMobileExporter_1.PlayStationMobileExporter(options);
break;
case Platform_1.Platform.Node:
exporter = new NodeExporter_1.NodeExporter(options);
break;
case Platform_1.Platform.Empty:
exporter = new EmptyExporter_1.EmptyExporter(options);
break;
default:
if (baseTarget.endsWith('-hl')) {
korehl = true;
options.target = koreplatform(baseTarget);
if (!checkKorePlatform(options.target)) {
log.error(`Unknown platform: ${target} (baseTarget=$${baseTarget})`);
return Promise.reject('');
}
exporter = new KincHLExporter_1.KincHLExporter(options);
}
else {
kore = true;
options.target = koreplatform(baseTarget);
if (!checkKorePlatform(options.target)) {
log.error(`Unknown platform: ${target} (baseTarget=$${baseTarget})`);
return Promise.reject('');
}
exporter = new KincExporter_1.KincExporter(options);
}
break;
}
exporter.setSystemDirectory(target);
let buildDir = path.join(options.to, exporter.sysdir() + '-build');
// Create the target build folder
// e.g. 'build/pi'
fs.ensureDirSync(path.join(options.to, exporter.sysdir()));
let defaultWindowOptions = {
width: 800,
height: 600
};
let windowOptions = project.windowOptions ? project.windowOptions : defaultWindowOptions;
exporter.setName(project.name);
exporter.setWidthAndHeight('width' in windowOptions ? windowOptions.width : defaultWindowOptions.width, 'height' in windowOptions ? windowOptions.height : defaultWindowOptions.height);
for (let source of project.sources) {
exporter.addSourceDirectory(source);
}
for (let library of project.libraries) {
exporter.addLibrary(library);
}
exporter.parameters = exporter.parameters.concat(project.parameters);
project.scriptdir = options.kha;
if (baseTarget !== Platform_1.Platform.Java && baseTarget !== Platform_1.Platform.WPF) {
project.addShaders('Sources/Shaders/**', {});
}
for (let callback of ProjectFile_1.Callbacks.preAssetConversion) {
callback();
}
let assetConverter = new AssetConverter_1.AssetConverter(exporter, options, project.assetMatchers);
lastAssetConverter = assetConverter;
let assets = await assetConverter.run(options.watch, temp);
if ((target === Platform_1.Platform.DebugHTML5 && process.platform === 'win32') || target === Platform_1.Platform.HTML5) {
Icon.exportIco(project.icon, path.join(options.to, exporter.sysdir(), 'favicon.ico'), options.from, options);
}
else if (target === Platform_1.Platform.DebugHTML5) {
Icon.exportPng(project.icon, path.join(options.to, exporter.sysdir(), 'favicon.png'), 256, 256, 0xffffffff, true, options.from, options);
}
let shaderDir = path.join(options.to, exporter.sysdir() + '-resources');
for (let callback of ProjectFile_1.Callbacks.preShaderCompilation) {
callback();
}
fs.ensureDirSync(shaderDir);
let oldResources = null;
let recompileAllShaders = false;
try {
oldResources = JSON.parse(fs.readFileSync(path.join(options.to, exporter.sysdir() + '-resources', 'files.json'), 'utf8'));
for (let file of oldResources.files) {
if (file.type === 'shader') {
if (!file.files || file.files.length === 0) {
recompileAllShaders = true;
break;
}
}
}
}
catch (error) {
}
let exportedShaders = [];
if (!options.noshaders) {
if (fs.existsSync(path.join(options.from, 'Backends'))) {
let libdirs = fs.readdirSync(path.join(options.from, 'Backends'));
for (let ld in libdirs) {
let libdir = path.join(options.from, 'Backends', libdirs[ld]);
if (fs.statSync(libdir).isDirectory()) {
let exe = path.join(libdir, 'krafix', 'krafix-' + options.target + '.exe');
if (fs.existsSync(exe)) {
options.krafix = exe;
}
}
}
}
let shaderCompiler = new ShaderCompiler_1.ShaderCompiler(exporter, baseTarget, options.krafix, shaderDir, temp, buildDir, options, project.shaderMatchers);
lastShaderCompiler = shaderCompiler;
try {
if (baseTarget !== Platform_1.Platform.Java && baseTarget !== Platform_1.Platform.WPF) {
exportedShaders = await shaderCompiler.run(options.watch, recompileAllShaders);
}
}
catch (err) {
return Promise.reject(err);
}
}
function findShader(name) {
let fallback = {};
fallback.files = [];
fallback.inputs = [];
fallback.outputs = [];
fallback.uniforms = [];
fallback.types = [];
try {
for (let file of oldResources.files) {
if (file.type === 'shader' && file.name === fixName(name)) {
return file;
}
}
}
catch (error) {
return fallback;
}
return fallback;
}
let files = [];
for (let asset of assets) {
let file = {
name: fixName(asset.name),
files: asset.files,
file_sizes: asset.file_sizes,
type: asset.type
};
if (file.type === 'image') {
file.original_width = asset.original_width;
file.original_height = asset.original_height;
if (asset.readable)
file.readable = asset.readable;
}
files.push(file);
}
for (let shader of exportedShaders) {
if (shader.noembed)
continue;
let oldShader = findShader(shader.name);
files.push({
name: fixName(shader.name),
files: shader.files === null ? oldShader.files : shader.files,
file_sizes: [1],
type: 'shader',
inputs: shader.inputs === null ? oldShader.inputs : shader.inputs,
outputs: shader.outputs === null ? oldShader.outputs : shader.outputs,
uniforms: shader.uniforms === null ? oldShader.uniforms : shader.uniforms,
types: shader.types === null ? oldShader.types : shader.types
});
}
// Sort to prevent files.json from changing between makes when no files have changed.
files.sort(function (a, b) {
if (a.name > b.name)
return 1;
if (a.name < b.name)
return -1;
return 0;
});
function secondPass() {
// First pass is for main project files. Second pass is for shaders.
// Will try to look for the folder, e.g. 'build/Shaders'.
// if it exists, export files similar to other a
let hxslDir = path.join('build', 'Shaders');
/** if (fs.existsSync(hxslDir) && fs.readdirSync(hxslDir).length > 0) {
addShaders(exporter, platform, project, from, to.resolve(exporter.sysdir() + '-resources'), temp, from.resolve(Paths.get(hxslDir)), krafix);
if (foundProjectFile) {
fs.outputFileSync(to.resolve(Paths.get(exporter.sysdir() + '-resources', 'files.json')).toString(), JSON.stringify({ files: files }, null, '\t'), { encoding: 'utf8' });
log.info('Assets done.');
exportProjectFiles(name, from, to, options, exporter, platform, khaDirectory, haxeDirectory, kore, project.libraries, project.targetOptions, callback);
}
else {
exportProjectFiles(name, from, to, options, exporter, platform, khaDirectory, haxeDirectory, kore, project.libraries, project.targetOptions, callback);
}
}*/
}
if (foundProjectFile) {
fs.outputFileSync(path.join(options.to, exporter.sysdir() + '-resources', 'files.json'), JSON.stringify({ files: files }, null, '\t'));
}
for (let callback of ProjectFile_1.Callbacks.preHaxeCompilation) {
callback();
}
return await exportProjectFiles(project.name, path.join(options.to, exporter.sysdir() + '-resources'), options, exporter, kore, korehl, project.icon, project.libraries, project.targetOptions, project.defines, project.cdefines, project.cflags, project.cppflags, project.stackSize, project.version, project.id);
}
function isKhaProject(directory, projectfile) {
return fs.existsSync(path.join(directory, 'Kha')) || fs.existsSync(path.join(directory, projectfile));
}
async function exportProject(options) {
if (isKhaProject(options.from, options.projectfile)) {
return await exportKhaProject(options);
}
else {
log.error('Neither Kha directory nor project file (' + options.projectfile + ') found.');
return 'Unknown';
}
}
function runProject(options, name) {
return new Promise((resolve, reject) => {
log.info('Running...');
let run = child_process.spawn(path.join(process.cwd(), options.to, 'linux-build', name), [], { cwd: path.join(process.cwd(), options.to, 'linux') });
run.stdout.on('data', function (data) {
log.info(data.toString());
});
run.stderr.on('data', function (data) {
log.error(data.toString());
});
run.on('close', function (code) {
resolve();
});
});
}
exports.api = 2;
function findKhaVersion(dir) {
let p = path.join(dir, '.git');
let hasGitInfo = false;
if (fs.existsSync(p)) {
let stat = fs.statSync(p);
hasGitInfo = stat.isDirectory();
// otherwise git might not utilize an in-place directory
if (!hasGitInfo) {
let contents = fs.readFileSync(p).toString('utf8', 0, 7);
hasGitInfo = contents === 'gitdir:';
}
}
if (hasGitInfo) {
let gitVersion = 'git-error';
try {
const output = child_process.spawnSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8', cwd: dir }).output;
for (const str of output) {
if (str != null && str.length > 0) {
gitVersion = str.substr(0, 8);
break;
}
}
}
catch (error) {
}
let gitStatus = 'git-error';
try {
const output = child_process.spawnSync('git', ['status', '--porcelain'], { encoding: 'utf8', cwd: dir }).output;
gitStatus = '';
for (const str of output) {
if (str != null && str.length > 0) {
gitStatus = str.trim();
break;
}
}
}
catch (error) {
}
if (gitStatus) {
return gitVersion + ', ' + gitStatus.replace(/\n/g, ',');
}
else {
return gitVersion;
}
}
else {
return '¯\\_(ツ)_/¯';
}
}
async function run(options, loglog) {
if (options.silent) {
log.silent();
}
else {
log.set(loglog);
}
if (options.quiet) {
log.silent(true);
}
if (!options.kha) {
let p = path.join(__dirname, '..', '..', '..');
if (fs.existsSync(p) && fs.statSync(p).isDirectory()) {
options.kha = p;
}
}
else {
options.kha = path.resolve(options.kha);
}
log.info('Using Kha (' + findKhaVersion(options.kha) + ') from ' + options.kha);
if (options.parallelAssetConversion === undefined) {
options.parallelAssetConversion = 0;
}
if (!options.haxe) {
let haxepath = path.join(options.kha, 'Tools', (0, exec_1.sysdir)());
if (fs.existsSync(haxepath) && fs.statSync(haxepath).isDirectory())
options.haxe = haxepath;
}
if (!options.krafix) {
let krafixpath = path.join(options.kha, 'Kinc', 'Tools', (0, exec_1.sysdir)(), 'krafix' + (0, exec_1.sys)());
if (fs.existsSync(krafixpath))
options.krafix = krafixpath;
}
if (!options.kraffiti) {
const kraffitipath = path.join(options.kha, 'Kinc', 'Tools', (0, exec_1.sysdir)(), 'kraffiti' + (0, exec_1.sys)());
if (fs.existsSync(kraffitipath))
options.kraffiti = kraffitipath;
}
else {
log.info('Using kraffiti from ' + options.kraffiti);
}
if (!options.ogg && options.ffmpeg) {
options.ogg = options.ffmpeg + ' -nostdin -i {in} {out} -y';
}
if (!options.mp3 && options.ffmpeg) {
options.mp3 = options.ffmpeg + ' -nostdin -i {in} {out}';
}
if (!options.ogg) {
let oggpath = path.join(options.kha, 'Tools', (0, exec_1.sysdir)(), 'oggenc' + (0, exec_1.sys)());
if (fs.existsSync(oggpath))
options.ogg = oggpath + ' {in} -o {out} --quiet';
}
if (!options.mp3) {
let lamepath = path.join(options.kha, 'Tools', (0, exec_1.sysdir)(), 'lame' + (0, exec_1.sys)());
if (fs.existsSync(lamepath))
options.mp3 = lamepath + ' {in} {out}';
}
// if (!options.kravur) {
// let kravurpath = path.join(options.kha, 'Tools', 'kravur', 'kravur' + sys());
// if (fs.existsSync(kravurpath)) options.kravur = kravurpath + ' {in} {size} {out}';
// }
if (!options.aac && options.ffmpeg) {
options.aac = options.ffmpeg + ' -nostdin -i {in} {out}';
}
if (!options.h264 && options.ffmpeg) {
options.h264 = options.ffmpeg + ' -nostdin -i {in} {out}';
}
if (!options.webm && options.ffmpeg) {
options.webm = options.ffmpeg + ' -nostdin -i {in} {out}';
}
if (!options.wmv && options.ffmpeg) {
options.wmv = options.ffmpeg + ' -nostdin -i {in} {out}';
}
if (!options.theora && options.ffmpeg) {
options.theora = options.ffmpeg + ' -nostdin -i {in} {out}';
}
if (options.target === 'emscripten') {
console.log();
console.log('Please note that the html5 target\n'
+ 'is usually a better choice.\n'
+ 'In particular the html5 target usually runs faster\n'
+ 'than the emscripten target. That is because\n'
+ 'Haxe and JavaScript are similar in many ways and\n'
+ 'therefore the html5 target can make direct use of\n'
+ 'all of the optimizations in modern JavaScript\n'
+ 'runtimes. The emscripten target on the other hand\n'
+ 'has to provide its own garbage collector and many\n'
+ 'other performance critical pieces of infrastructure.');
console.log();
}
let name = '';
try {
name = await exportProject(options);
}
catch (err) {
for (let callback of ProjectFile_1.Callbacks.onFailure) {
callback(err);
}
throw err;
}
for (let callback of ProjectFile_1.Callbacks.postBuild) {
callback();
}
if ((options.target === Platform_1.Platform.Linux || options.target === Platform_1.Platform.FreeBSD) && options.run) {
await runProject(options, name);
}
return name;
}
exports.run = run;
function close() {
if (lastAssetConverter)
lastAssetConverter.close();
if (lastShaderCompiler)
lastShaderCompiler.close();
if (lastHaxeCompiler)
lastHaxeCompiler.close();
}
exports.close = close;
//# sourceMappingURL=main.js.map