public void WriteTrack(string path, string password = null)
{
using (BinaryWriter writer = new BinaryWriter(File.Open(path, FileMode.Create)))
{
// TRACK INFO
writer.Write(TrackInfo.Name);
writer.Write(TrackInfo.Author);
writer.Write(TrackInfo.ImageLen);
if (TrackInfo.Image != null)
{
writer.Write(TrackInfo.Image);
}
writer.Write(TrackInfo.SliderValue);
writer.Write(password != null); // write TRUE if password is not null
// ASSETS
writer.Write(Assets.Count);
foreach (var asset in Assets)
{
var basset = AssetConverter.ConvertToBinaryAsset(asset);
if (password != null)
{
basset.EncryptBytes(password);
}
basset.WriteBinaryAsset(writer);
}
}
}
private byte[] ConvertWorld(ImportedObject obj)
{
var world = new NwWorld();
{
var texs = new List <NwTexture2D>();
foreach (var t in obj.Textures)
{
var bm = AssetConverter.ToNwTexture2D(t.SrcBitmap, t.Name);
texs.Add(bm);
}
var cubes = new List <NwCubemap>();
cubes.Add(AssetConverter.ToNwTextureCube(new Bitmap[]
{
Resources.posx2,
Resources.posy2,
Resources.posz2,
Resources.negx2,
Resources.negy2,
Resources.negz2,
}, null));
var mats = new List <NwMaterial>();
foreach (var m in obj.Materials)
{
var mat = AssetConverter.ToNwMaterial(m, m.Name, ref texs, ref cubes);
mats.Add(mat);
}
world.Texture2Ds = texs.ToArray();
world.Cubemaps = cubes.ToArray();
world.Materials = mats.ToArray();
var meshes = new List <NwMesh>();
foreach (var mesh in obj.Meshes)
{
meshes.Add(AssetConverter.ToNwMesh(mesh));
}
world.Meshes = meshes.ToArray();
var colMeshes = new List <NwColliderMesh>();
foreach (var mesh in obj.Meshes)
{
colMeshes.Add(AssetConverter.ToNwColliderMesh(mesh));
}
world.ColliderMeshes = colMeshes.ToArray();
world.Environments = new NwEnvironment[1];
world.Environments[0] = new NwEnvironment()
{
EnvMap = world.Cubemaps[0].Hash,
};
}
var json = Util.SerializeJson(world);
var comp = Util.Compress(Encoding.UTF8.GetBytes(json));
return(comp);
}
public override IFileRepository ForDefaultCulture()
{
var assetConverter = new AssetConverter();
var identifiersConverter = new CollectionResponseConverter <string, string>(new ConverterAdapter <string>());
var responseConverter = new ResponseConverter <FileDTO, Asset>(assetConverter);
var bulkResponseConverter = new DictionaryRangeResponseConverter <FileDTO, string, Asset>(assetConverter, value => value.Identifier);
var pageResponseConverter = new CollectionPageResponseConverter <FileDTO, Asset>(assetConverter);
return(new FileRepository(this.serviceClient, identifiersConverter, responseConverter, bulkResponseConverter, pageResponseConverter));
}
private NwObject ConvertObject(ImportedObject obj)
{
var o = new NwObject();
{
o.Name = obj.Name;
o.Description = obj.Description;
o.Version = obj.Version;
o.Editor = obj.Editor;
o.EditorURL = obj.EditorURL;
var texs = new List <NwTexture2D>();
foreach (var t in obj.Textures)
{
var bm = AssetConverter.ToNwTexture2D(t.SrcBitmap, t.Name);
texs.Add(bm);
}
var cubes = new List <NwCubemap>();
var mats = new List <NwMaterial>();
foreach (var m in obj.Materials)
{
var mat = AssetConverter.ToNwMaterial(m, m.Name, ref texs, ref cubes);
mats.Add(mat);
}
o.Texture2Ds = texs.ToArray();
o.Cubemaps = cubes.ToArray();
o.Materials = mats.ToArray();
if (obj.Bones != null)
{
var bones = new List <NwBone>();
foreach (var b in obj.Bones)
{
var bone = AssetConverter.ToNwBone(b);
bones.Add(bone);
}
o.Bones = bones.ToArray();
}
o.Mesh = AssetConverter.ToNwMesh(obj.Meshes[0]);
o.CollisionShape = new NwCollisionCapsule()
{
Height = 1.6f,
Radius = 0.3f,
};
o.PhysicalMaterial = new NwPhysicalMaterial();
}
return(o);
}
private NwCharacter ConvertCharacter(ImportedObject obj)
{
var c = new NwCharacter();
{
c.Name = obj.Name;
c.Description = obj.Description;
c.Version = obj.Version;
c.Editor = obj.Editor;
c.EditorURL = obj.EditorURL;
var texs = new List <NwTexture2D>();
foreach (var t in obj.Textures)
{
var bm = AssetConverter.ToNwTexture2D(t.SrcBitmap, t.Name);
texs.Add(bm);
}
var cubes = new List <NwCubemap>();
var mats = new List <NwMaterial>();
foreach (var m in obj.Materials)
{
var mat = AssetConverter.ToNwMaterial(m, m.Name, ref texs, ref cubes);
mats.Add(mat);
}
c.Texture2Ds = texs.ToArray();
c.Cubemaps = cubes.ToArray();
c.Materials = mats.ToArray();
var bones = new List <NwBone>();
foreach (var b in obj.Bones)
{
var bone = AssetConverter.ToNwBone(b);
bones.Add(bone);
}
c.Bones = bones.ToArray();
c.Mesh = AssetConverter.ToNwMesh(obj.Meshes[0]);
c.CollisionShape = new NwCollisionCapsule()
{
Height = 1.6f,
Radius = 0.3f,
};
c.Mass = 50.0f;
}
return(c);
}
public void OnObjectLoaded(NwObject obj)
{
var wo = AssetConverter.FromNwObject(obj);
MMW.Invoke(() =>
{
wo.Load();
var go = CreateGameObject(wo, wo.Name, "Deferred Physical");
go.AddComponent <CollisionRenderer>();
MMW.RegistGameObject(go);
gameObj = go;
});
}
public void OnCharacterLoaded(NwCharacter ch)
{
var chara = AssetConverter.FromNwCharacter(ch);
MMW.Invoke(() =>
{
chara.Load();
var go = CreateGameObject(chara, chara.Name, "Deferred Physical");
go.AddComponent <CollisionRenderer>();
MMW.RegistGameObject(go);
gameObj = go;
});
}
private byte[] ConvertCharacter(ImportedObject obj)
{
var ch = new NwCharacter();
{
ch.Name = obj.Name;
var texs = new List <NwTexture2D>();
foreach (var t in obj.Textures)
{
var bm = AssetConverter.ToNwTexture2D(t.SrcBitmap, t.Name);
texs.Add(bm);
}
var cubes = new List <NwCubemap>();
var mats = new List <NwMaterial>();
foreach (var m in obj.Materials)
{
var mat = AssetConverter.ToNwMaterial(m, m.Name, ref texs, ref cubes);
mats.Add(mat);
}
ch.Texture2Ds = texs.ToArray();
ch.Cubemaps = cubes.ToArray();
ch.Materials = mats.ToArray();
var bones = new List <NwBone>();
foreach (var b in obj.Bones)
{
var bone = AssetConverter.ToNwBone(b);
bones.Add(bone);
}
ch.Bones = bones.ToArray();
ch.Mesh = AssetConverter.ToNwMesh(obj.Meshes[0]);
//ch.Height = 1.6f;
//ch.WidthRadius = 0.3f;
ch.EyePosition = new Vector3f(0.0f, 1.42f, 0.2f);
ch.Mass = 50.0f;
}
var json = Util.SerializeJson(ch);
var comp = Util.Compress(Encoding.UTF8.GetBytes(json));
return(comp);
}
public static void AssetConverterInit()
{
// use concrete asset for concrete extension
AssetConverter.RegisterExtension <TextAsset>(".txt");
AssetConverter.RegisterExtension <DocAsset>(".doc");
AssetConverter.RegisterExtension <DocAsset>(".docx");
AssetConverter.RegisterExtension <JpgAsset>(".jpg");
AssetConverter.RegisterExtension <PngAsset>(".png");
AssetConverter.RegisterExtension <PdfAsset>(".pdf");
// for concrete asset use concrete asset converter
AssetConverter.RegisterConverter <TextAsset, TextAssetConverter>();
AssetConverter.RegisterConverter <WebAsset, TextAssetConverter>();
AssetConverter.RegisterConverter <JpgAsset, ImageAssetConverter>();
AssetConverter.RegisterConverter <PngAsset, ImageAssetConverter> ();
AssetConverter.RegisterConverter <PdfAsset, PdfAssetConverter>();
}
void Test <T>(AssetId id,
AssetId[] prerequisites,
Func <T, ISerializer, T> serdes,
Func <T, T> canonicalize = null) where T : class
{
prerequisites ??= Array.Empty <AssetId>();
var allIds = prerequisites.Append(id);
var resultsDir = Path.Combine(_baseDir, "re", "ConversionTests");
var baseAsset = (T)_baseApplier.LoadAsset(id);
if (canonicalize != null)
{
baseAsset = canonicalize(baseAsset);
}
var(baseBytes, baseNotes) = Asset.Save(baseAsset, serdes);
var baseJson = Asset.SaveJson(baseAsset, JsonUtil);
var idStrings = allIds.Select(x => $"{x.Type}.{x.Id}").ToArray();
var assetTypes = allIds.Select(x => x.Type).Distinct().ToHashSet();
var mapping = AssetMapping.Global;
using (var unpacker = new AssetConverter(
mapping,
_disk,
JsonUtil,
new[] { BaseAssetMod },
UnpackedAssetMod))
{
unpacker.Convert(idStrings, assetTypes, null);
}
var unpackedAsset = (T)BuildApplier(UnpackedAssetMod, AssetMapping.Global).LoadAsset(id);
Assert.NotNull(unpackedAsset);
var(unpackedBytes, unpackedNotes) = Asset.Save(unpackedAsset, serdes);
var unpackedJson = Asset.SaveJson(unpackedAsset, JsonUtil);
Asset.Compare(resultsDir,
id.ToString(),
baseBytes,
unpackedBytes,
new[]
/// <summary>
/// Collects info about data and injects it into track's assets list.
/// </summary>
public void RegisterAssets(Track track)
{
try
{
var filePaths = NTDFiles.Items;
foreach (string file in filePaths)
{
// WEB ASSET
if (Regex.IsMatch(file, WebAssetPattern))
{
Match m = Regex.Match(file, WebAssetPattern);
string url = m.Groups[1].Value;
WebAsset webAsset = new WebAsset(url);
track.Assets.Add(webAsset);
continue;
}
// MODIFY
if (_modifyMode)
{
Match m = Regex.Match(file, ModifyTrackPattern);
if (m.Success)
{
int indexOfAsset = int.Parse(m.Groups[1].Value) - 1;
track.Assets.Add(_track.Assets[indexOfAsset]);
continue;
}
}
// OTHER FILES
FileInfo fi = new FileInfo(file);
Type type = AssetConverter.GetAssetTypeByExtension(fi.Extension);
var bytes = File.ReadAllBytes(file);
var basset = new BinaryAsset(type, bytes);
var asset = AssetConverter.ResolveBinaryAsset(basset);
track.Assets.Add(asset);
}
} catch (Exception e)
{
throw new ForUserException(
"A Problem occured during registering assets. Details: " + e.Message);
}
}
protected override void OnLoad()
{
var decomp = Util.Decompress(Resources.coin_cupper);
var data = Util.DeserializeJson <NwObject>(Encoding.UTF8.GetString(decomp));
cupperCoin = AssetConverter.FromNwObject(data);
cupperCoin.Purchasable = false;
cupperCoin.Hash = Util.ComputeHash(Resources.coin_cupper, 12);
cupperCoin.Load();
decomp = Util.Decompress(Resources.coin_silver);
data = Util.DeserializeJson <NwObject>(Encoding.UTF8.GetString(decomp));
silverCoin = AssetConverter.FromNwObject(data);
silverCoin.Purchasable = false;
silverCoin.Hash = Util.ComputeHash(Resources.coin_silver, 12);
silverCoin.Load();
decomp = Util.Decompress(Resources.coin_gold);
data = Util.DeserializeJson <NwObject>(Encoding.UTF8.GetString(decomp));
goldCoin = AssetConverter.FromNwObject(data);
goldCoin.Purchasable = false;
goldCoin.Hash = Util.ComputeHash(Resources.coin_gold, 12);
goldCoin.Load();
var wr = MMW.GetAsset <WorldResources>();
wr.Objects.Add(cupperCoin.Hash, cupperCoin);
wr.Objects.Add(silverCoin.Hash, silverCoin);
wr.Objects.Add(goldCoin.Hash, goldCoin);
var mr = GameObject.GetComponent <MeshRenderer>();
bounds = mr.Mesh.Bounds;
var size = bounds.Size.X * bounds.Size.Z;
if (size > 400.0f)
{
maxCoin = (int)Math.Log10(size);
}
userData = MMW.GetAsset <UserData>();
time = userData.CoinSpownTime;
}
/// <summary>
///
/// </summary>
/// <param name="nsPath"></param>
/// <returns></returns>
public static Track ReadTrack(string nsPath)
{
try
{
Track t = new Track();
using (BinaryReader reader = new BinaryReader(File.OpenRead(nsPath)))
{
// TRACK INFO
t.TrackInfo.Name = reader.ReadString();
t.TrackInfo.Author = reader.ReadString();
t.TrackInfo.ImageLen = reader.ReadInt32();
t.TrackInfo.Image = reader.ReadBytes(t.TrackInfo.ImageLen);
t.TrackInfo.SliderValue = reader.ReadDouble();
t.TrackInfo.Encrypted = reader.ReadBoolean();
string password = null;
if (t.TrackInfo.Encrypted)
{
var dialog = InfoDialog.ShowValueDialog("Enter the password:"******"Fail with interpreting the track.");
}
}
private byte[] ConvertObject(ImportedObject obj)
{
var o = new NwObject();
{
o.Name = obj.Name;
var texs = new List <NwTexture2D>();
foreach (var t in obj.Textures)
{
var bm = AssetConverter.ToNwTexture2D(t.SrcBitmap, t.Name);
texs.Add(bm);
}
var cubes = new List <NwCubemap>();
var mats = new List <NwMaterial>();
foreach (var m in obj.Materials)
{
var mat = AssetConverter.ToNwMaterial(m, m.Name, ref texs, ref cubes);
mats.Add(mat);
}
o.Texture2Ds = texs.ToArray();
o.Cubemaps = cubes.ToArray();
o.Materials = mats.ToArray();
o.Mesh = AssetConverter.ToNwMesh(obj.Meshes[0]);
//o.Height = 1.6f;
//o.WidthRadius = 0.3f;
o.PhysicalMaterial = new NwPhysicalMaterial();
}
var json = Util.SerializeJson(o);
var comp = Util.Compress(Encoding.UTF8.GetBytes(json));
return(comp);
}
/// <summary>
/// Execute the machine to process its contents
/// </summary>
public void Execute()
{
// get the asset type
var type = AssetConverter.ExtractType(_asset);
// switch execution based on the asset type
switch (type)
{
case Data.AssetType.Surface:
Execute_Surface();
break;
case Data.AssetType.Prop:
Execute_Prop();
break;
case Data.AssetType.Plant:
Execute_Prop();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Converts a texture to a TextureInformation
/// </summary>
/// <param name="texture"></param>
/// <returns></returns>
public static TextureInformation ToTextureInformation(this Texture texture)
{
return(AssetConverter.ExtractInformation(texture));
}
static void Main(string[] args)
{
#if DEBUG
PerfTracker.IsTracing = true;
#endif
PerfTracker.StartupEvent("Entered main");
AssetSystem.LoadEvents();
PerfTracker.StartupEvent("Built event parsers");
var commandLine = new CommandLineOptions(args);
if (commandLine.Mode == ExecutionMode.Exit)
{
return;
}
PerfTracker.StartupEvent($"Running as {commandLine.Mode}");
var disk = new FileSystem();
var jsonUtil = new FormatJsonUtil();
var baseDir = ConfigUtil.FindBasePath(disk);
if (baseDir == null)
{
throw new InvalidOperationException("No base directory could be found.");
}
PerfTracker.StartupEvent($"Found base directory {baseDir}");
if (commandLine.Mode == ExecutionMode.ConvertAssets)
{
using var converter = new AssetConverter(
AssetMapping.Global,
disk,
jsonUtil,
commandLine.ConvertFrom,
commandLine.ConvertTo);
converter.Convert(
commandLine.DumpIds,
commandLine.DumpAssetTypes,
commandLine.ConvertFilePattern);
return;
}
var(exchange, services) = AssetSystem.SetupAsync(baseDir, AssetMapping.Global, disk, jsonUtil).Result;
IRenderPass mainPass = null;
if (commandLine.NeedsEngine)
{
mainPass = BuildEngine(commandLine, exchange);
}
services.Add(new StdioConsoleReader());
var assets = exchange.Resolve <IAssetManager>();
AutodetectLanguage(exchange, assets);
switch (commandLine.Mode) // ConvertAssets handled above as it requires a specialised asset system setup
{
case ExecutionMode.Game: Albion.RunGame(exchange, services, mainPass, baseDir, commandLine); break;
case ExecutionMode.BakeIsometric: IsometricTest.Run(exchange, commandLine); break;
case ExecutionMode.DumpData:
PerfTracker.BeginFrame(); // Don't need to show verbose startup logging while dumping
var tf = new TextFormatter();
exchange.Attach(tf);
var parsedIds = commandLine.DumpIds?.Select(AssetId.Parse).ToArray();
if ((commandLine.DumpFormats & DumpFormats.Json) != 0)
{
var dumper = new DumpJson();
exchange.Attach(dumper);
dumper.Dump(baseDir, commandLine.DumpAssetTypes, parsedIds);
dumper.Remove();
}
if ((commandLine.DumpFormats & DumpFormats.Text) != 0)
{
var dumper = new DumpText();
exchange.Attach(dumper);
dumper.Dump(baseDir, commandLine.DumpAssetTypes, parsedIds);
dumper.Remove();
}
if ((commandLine.DumpFormats & DumpFormats.Png) != 0)
{
var dumper = new DumpGraphics(commandLine.DumpFormats);
exchange.Attach(dumper);
dumper.Dump(baseDir, commandLine.DumpAssetTypes, parsedIds);
dumper.Remove();
}
if ((commandLine.DumpFormats & DumpFormats.Annotated) != 0)
{
var dumper = new DumpAnnotated();
exchange.Attach(dumper);
dumper.Dump(baseDir, commandLine.DumpAssetTypes, parsedIds);
dumper.Remove();
}
//if ((commandLine.DumpFormats & DumpFormats.Tiled) != 0)
// DumpTiled.Dump(baseDir, assets, commandLine.DumpAssetTypes, parsedIds);
break;
case ExecutionMode.Exit: break;
}
Console.WriteLine("Exiting");
exchange.Dispose();
}
public void Init()
{
loggerMock = new Mock <ILogger <AssetConverter> >();
assetConverter = new AssetConverter(loggerMock.Object);
}
/// <summary>
/// Converts a <see cref="Geometry"/> to a <see cref="GeometryInformation"/>
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
public static GeometryInformation ToGeometryInformation(this Geometry geometry)
{
return(AssetConverter.ExtractInformation(geometry));
}
