private void InternalOpenFile(string file)
{
try
{
// load the score from the filesystem
Score = ScoreLoader.LoadScore(file);
trackDetails.Controls.Clear();
trackBars.Controls.Clear();
for (int i = Score.Tracks.Count - 1; i >= 0; i--)
{
TrackDetailsControl details = new TrackDetailsControl(Score.Tracks[i]);
details.Dock = DockStyle.Top;
details.Height = 25;
trackDetails.Controls.Add(details);
details.Selected += details_Click;
TrackBarsControl bars = new TrackBarsControl(Score.Tracks[i]);
bars.Dock = DockStyle.Top;
trackBars.Controls.Add(bars);
}
UpdateSelectedTrack();
}
catch (Exception e)
{
MessageBox.Show(this, e.Message, "An error during opening the file occured", MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage AlphaTab.ScoreDump.exe Path");
return;
}
Score score = ScoreLoader.loadScore(args[0]);
// score info
Console.WriteLine("Title: {0}", score.title);
Console.WriteLine("Subtitle: {0}", score.subTitle);
Console.WriteLine("Artist: {0}", score.artist);
Console.WriteLine("Tempo: {0}", score.tempo);
Console.WriteLine("Bars: {0}", score.masterBars.length);
Console.WriteLine("Time Signature: {0}/{1}", ((MasterBar)score.masterBars[0]).timeSignatureNumerator,
((MasterBar)score.masterBars[0]).timeSignatureDenominator);
// tracks
Console.WriteLine("Tracks: ");
for (int i = 0; i < score.tracks.length; i++)
{
Track track = (Track)score.tracks[i];
Console.WriteLine(" {0} - {1} - {2}", i + 1, track.name, track.isPercussion ? "Percussion" : "Midi Instrument: " + track.playbackInfo.program);
}
}
public async Task <Score> FetchSongScore(Song song, bool skipIfCached)
{
if (song.LatestAvailableRevision?.GuitarProTab?.BinaryData != null)
{
return(ScoreLoader.LoadScoreFromBytes(song.LatestAvailableRevision.GuitarProTab.BinaryData));
}
//if not cached, download it again
string datafileUrl = song.LatestAvailableRevision.GuitarProTab.AttachmentUrl;
string fileName = RootFolder + "s" + song.ID + "." + datafileUrl.Substring(datafileUrl.LastIndexOf('.') + 1, 3);
LogMessage("Fetching Track GP File: " + song.ID + " " + song.LatestAvailableRevision.GuitarProTab.AttachmentUrl);
byte[] data = await _resourceManager.GetAttachmentWithCaching(song.LatestAvailableRevision.GuitarProTab.AttachmentUrl, true, song.ID.ToString());
song.LatestAvailableRevision.GuitarProTab.BinaryData = data;
//save file to local cache
//await CacheBinaryData(fileName, song.ID.ToString(), data);
if (data != null)
{
return(ScoreLoader.LoadScoreFromBytes(data));
}
else
{
return(null);
}
}
public bool Load(object?data, Action <Score> success, Action <Error> error)
{
switch (data)
{
case Score score:
success(score);
return(true);
case byte[] b:
success(ScoreLoader.LoadScoreFromBytes(new Uint8Array(b), Api.Settings));
return(true);
case Stream s:
{
using (var ms = new MemoryStream())
{
s.CopyTo(ms);
success(ScoreLoader.LoadScoreFromBytes(new Uint8Array(ms.ToArray()),
Api.Settings));
}
return(true);
}
default:
return(false);
}
}
private static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage AlphaTab.Samples.ScoreDump.exe Path");
return;
}
var score = ScoreLoader.LoadScoreFromBytes(File.ReadAllBytes(args[0]));
// score info
Console.WriteLine("Title: {0}", score.Title);
Console.WriteLine("Subtitle: {0}", score.SubTitle);
Console.WriteLine("Artist: {0}", score.Artist);
Console.WriteLine("Tempo: {0}", score.Tempo);
Console.WriteLine("Bars: {0}", score.MasterBars.Count);
Console.WriteLine("Time Signature: {0}/{1}", score.MasterBars[0].TimeSignatureNumerator,
score.MasterBars[0].TimeSignatureDenominator);
// tracks
Console.WriteLine("Tracks: ");
for (var i = 0; i < score.Tracks.Count; i++)
{
var track = score.Tracks[i];
Console.WriteLine(" {0} - {1} - {2}", i + 1, track.Name,
track.Staves.Any(s => s.IsPercussion)
? "Percussion"
: "Midi Instrument: " + track.PlaybackInfo.Program);
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage AlphaTab.ScoreDump.exe Path");
return;
}
// load score
Score score = ScoreLoader.loadScore(args[0]);
// render score with svg engine
Settings settings = Settings.defaults();
settings.engine = "gdi";
ScoreRenderer renderer = new ScoreRenderer(settings, null);
// iterate tracks
for (int i = 0; i < score.tracks.length; i++)
{
Track track = (Track)score.tracks[i];
// render track
Console.WriteLine("Rendering track {0} - {1}", i + 1, track.name);
renderer.render(track);
// write png
FileInfo info = new FileInfo(args[0]);
string path = Path.Combine(info.DirectoryName, Path.GetFileNameWithoutExtension(info.Name) + "-" + i + ".png");
using (Bitmap bmp = ((GdiCanvas)renderer.canvas).getImage())
{
bmp.Save(path, ImageFormat.Png);
}
}
}
public async Task <Score> LoadScoreFromUrl(string url)
{
byte[] data = await _resourceManager.GetAttachmentWithCaching(url, false, "notcached");
return(ScoreLoader.LoadScoreFromBytes(data, new AlphaTab.Settings {
}));
}
public void Load(object data)
{
Element.classList.add("loading");
try
{
if (Std.InstanceOf <ArrayBuffer>(data))
{
ScoreLoaded(ScoreLoader.LoadScoreFromBytes(Std.ArrayBufferToByteArray((ArrayBuffer)data)));
}
else if (Std.InstanceOf <Uint8Array>(data))
{
ScoreLoaded(ScoreLoader.LoadScoreFromBytes((byte[])data));
}
else if (JsTypeOf(data) == JsTypes.@string)
{
ScoreLoader.LoadScoreAsync((string)data, s => ScoreLoaded(s), e =>
{
Error("import", e);
});
}
}
catch (Exception e)
{
Error("import", e);
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage AlphaTab.ScoreDump.exe Path");
return;
}
// load score
var score = ScoreLoader.LoadScoreFromBytes(File.ReadAllBytes(args[0]));
// render score with svg engine and desired rendering width
var settings = Settings.Defaults;
settings.Engine = "gdi";
settings.Width = 970;
var renderer = new ScoreRenderer(settings);
// iterate tracks
for (int i = 0, j = score.Tracks.Count; i < j; i++)
{
var track = score.Tracks[i];
// render track
Console.WriteLine("Rendering track {0} - {1}", i + 1, track.Name);
var images = new List <Image>();
var totalWidth = 0;
var totalHeight = 0;
renderer.PartialRenderFinished += r =>
{
images.Add((Image)r.RenderResult);
};
renderer.RenderFinished += r =>
{
totalWidth = (int)r.TotalWidth;
totalHeight = (int)r.TotalHeight;
};
renderer.Render(track);
// write png
var info = new FileInfo(args[0]);
var path = Path.Combine(info.DirectoryName, Path.GetFileNameWithoutExtension(info.Name) + "-" + i + ".png");
using (var bmp = new Bitmap(totalWidth, totalHeight))
{
int y = 0;
using (var g = Graphics.FromImage(bmp))
{
foreach (var image in images)
{
g.DrawImage(image, new Rectangle(0, y, image.Width, image.Height),
new Rectangle(0, 0, image.Width, image.Height), GraphicsUnit.Pixel);
y += image.Height;
}
}
bmp.Save(path, ImageFormat.Png);
}
}
}
private void LoadScore(byte[] bytes)
{
_score = ScoreLoader.LoadScoreFromBytes(bytes);
AlphaTabControl.Tracks = new[]
{
_score.Tracks[0]
};
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage AlphaTab.ScoreDump.exe Path");
return;
}
// we need to use english culture to have correct string variants of floating points (dot as decimal separator)
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-us");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-us");
// load score
Score score = ScoreLoader.LoadScore(args[0]);
// render score with svg engine
Settings settings = Settings.Defaults;
settings.Engine = "svg";
ScoreRenderer renderer = new ScoreRenderer(settings, null);
// get iterate tracks
for (int i = 0; i < score.Tracks.Count; i++)
{
Track track = score.Tracks[i];
// render track
Console.WriteLine("Rendering track {0} - {1}", i + 1, track.Name);
var totalWidth = 0;
var totalHeight = 0;
var merged = XDocument.Parse("<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" width=\"1px\" height=\"1px\"></svg>");
var currentY = 0f;
renderer.PartialRenderFinished += r =>
{
var subSvg = XDocument.Parse(r.RenderResult.ToString());
var subRoot = subSvg.Root;
subRoot.SetAttributeValue("x", "0px");
subRoot.SetAttributeValue("y", ((int)currentY) + "px");
merged.Root.Add(subRoot);
currentY += r.Height;
};
renderer.RenderFinished += r =>
{
totalWidth = (int)r.TotalWidth;
totalHeight = (int)r.TotalHeight;
};
renderer.Render(track);
merged.Root.Attribute("width").Value = totalWidth + "px";
merged.Root.Attribute("height").Value = totalHeight + "px";
string svg = merged.ToString();
FileInfo info = new FileInfo(args[0]);
string path = Path.Combine(info.DirectoryName, Path.GetFileNameWithoutExtension(info.Name) + "-" + i + ".svg");
File.WriteAllText(path, svg);
}
}
static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine("Usage AlphaTab.ScoreDump.exe PathToFile PathToSoundFont");
return;
}
// load score
var score = ScoreLoader.LoadScoreFromBytes(File.ReadAllBytes(args[0]));
// generate midi
var midiFile = new MidiFile();
var handler = new AlphaSynthMidiFileHandler(midiFile);
var generator = new MidiFileGenerator(score, null, handler);
generator.Generate();
var player = new AlphaSynth(new NAudioSynthOutput());
player.MidiLoaded += () => { Console.WriteLine("Midi loaded"); };
player.SoundFontLoaded += () => { Console.WriteLine("SoundFont loaded"); };
player.MidiLoadFailed += e => { Console.WriteLine("Midi load failed"); };
player.SoundFontLoadFailed += e => { Console.WriteLine("SoundFont load failed"); };
player.Finished += _ =>
{
Console.WriteLine("Playback finished");
((NAudioSynthOutput)player.Output).Close();
};
player.PositionChanged += e =>
{
TimeSpan currentTime = TimeSpan.FromMilliseconds(e.CurrentTime);
TimeSpan endTime = TimeSpan.FromMilliseconds(e.EndTime);
Console.CursorTop--;
Console.Write("".PadLeft(Console.BufferWidth - 1, ' '));
Console.CursorLeft = 0;
Console.WriteLine("{0:mm\\:ss\\:fff} ({1}) of {2:mm\\:ss\\:fff} ({3})",
currentTime, e.CurrentTick, endTime, e.EndTick);
};
player.ReadyForPlayback += () =>
{
Console.WriteLine("Ready for playback");
};
player.LoadSoundFont(File.ReadAllBytes(args[1]));
player.LoadMidi(midiFile);
Console.WriteLine("Start playing");
player.Play();
Console.WriteLine("Press enter to exit");
Console.ReadLine();
player.Pause();
Console.ReadLine();
}
void Awake()
{
if (control == null)
{
DontDestroyOnLoad(gameObject);
control = this;
this.Load();
}
else if (control != this)
{
Destroy(gameObject);
}
}
public override void Load(object data)
{
if (Std.InstanceOf <ArrayBuffer>(data))
{
ScoreLoaded(ScoreLoader.LoadScoreFromBytes(Std.ArrayBufferToByteArray((ArrayBuffer)data)));
}
else if (Std.InstanceOf <Uint8Array>(data))
{
ScoreLoaded(ScoreLoader.LoadScoreFromBytes((byte[])data));
}
else if (JsTypeOf(data) == JsTypes.@string)
{
ScoreLoader.LoadScoreAsync((string)data, s => ScoreLoaded(s), e => console.error(e));
}
}
public static async Task RunVisualTest(string inputFile, Settings?settings = null,
IList <double>?tracks = null, string?message = null)
{
try
{
inputFile = $"test-data/visual-tests/{inputFile}";
var inputFileData =
await TestPlatform.LoadFile(inputFile);
var referenceFileName = TestPlatform.ChangeExtension(inputFile, ".png");
var score = ScoreLoader.LoadScoreFromBytes(inputFileData, settings);
await VisualTestHelper.RunVisualTestScore(score, referenceFileName, settings,
tracks, message);
}
catch (Exception e)
{
Assert.Fail($"Failed to run visual test {e}");
}
}
private void InternalOpenFile(string file)
{
//try
{
// load the score from the filesystem
Score = ScoreLoader.LoadScore(file);
// build the track info objects for the ui
TrackViewModel[] trackInfos = new TrackViewModel[Score.Tracks.Count];
for (int i = 0; i < trackInfos.Length; i++)
{
trackInfos[i] = new TrackViewModel(Score.Tracks[i]);
}
TrackInfos = trackInfos;
}
//catch (Exception e)
//{
// _errorService.OpenFailed(e);
//}
}
/// <summary>
/// Defines the entry point of the application.
/// </summary>
/// <param name="args">The arguments.</param>
public static void Main(string[] args)
{
if (!string.IsNullOrWhiteSpace(gpFile) && File.Exists(gpFile))
{
try
{
// Load the score from the GuitarPro file
var gpScore = ScoreLoader.loadScore(gpFile);
var score = CreateScore(gpScore);
// Serialize the score
SerializeScore(score);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.ReadKey();
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage AlphaTab.MidiDump.exe Path");
return;
}
// load score
var score = ScoreLoader.LoadScoreFromBytes(File.ReadAllBytes(args[0]));
// generate midi
MidiFile file = MidiFileGenerator.GenerateMidiFile(score);
// write midi file
string path = Path.ChangeExtension(args[0], "mid");
using (var fs = new StreamWrapper(File.OpenWrite(path)))
{
file.WriteTo(fs);
}
}
private void InternalOpenFile(string file)
{
Task.Factory.StartNew(() =>
{
try
{
// load the score from the filesystem
Score = ScoreLoader.LoadScoreFromBytes(File.ReadAllBytes(file));
// build the track info objects for the ui
TrackViewModel[] trackInfos = new TrackViewModel[Score.Tracks.Count];
for (int i = 0; i < trackInfos.Length; i++)
{
trackInfos[i] = new TrackViewModel(Score.Tracks[i]);
}
TrackInfos = trackInfos;
}
catch (Exception e)
{
_errorService.OpenFailed(e);
}
});
}
private void Load(object data, int[] trackIndexes)
{
try
{
_trackIndexes = trackIndexes;
if (Std.InstanceOf <ArrayBuffer>(data))
{
ScoreLoaded(ScoreLoader.LoadScoreFromBytes(Std.ArrayBufferToByteArray((ArrayBuffer)data)));
}
else if (Std.InstanceOf <Uint8Array>(data))
{
ScoreLoaded(ScoreLoader.LoadScoreFromBytes((byte[])data));
}
else if (JsContext.JsTypeOf(data) == JsTypes.@string)
{
ScoreLoader.LoadScoreAsync((string)data, ScoreLoaded, Error);
}
}
catch (Exception e)
{
Error(e);
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage AlphaTab.ScoreDump.exe Path");
return;
}
// we need to use english culture to have correct string variants of floating points (dot as decimal separator)
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-us");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-us");
// load score
Score score = ScoreLoader.loadScore(args[0]);
// render score with svg engine
Settings settings = Settings.defaults();
settings.engine = "svg";
ScoreRenderer renderer = new ScoreRenderer(settings, null);
// get iterate tracks
for (int i = 0; i < score.tracks.length; i++)
{
Track track = (Track)score.tracks[i];
// render track
Console.WriteLine("Rendering track {0} - {1}", i + 1, track.name);
renderer.render(track);
// write svg file
string svg = ((SvgCanvas)renderer.canvas).toSvg(true, "alphaTab");
FileInfo info = new FileInfo(args[0]);
string path = Path.Combine(info.DirectoryName, Path.GetFileNameWithoutExtension(info.Name) + "-" + i + ".svg");
File.WriteAllText(path, svg);
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage AlphaTab.ScoreDump.exe Path");
return;
}
// we need to use english culture to have correct string variants of floating points (dot as decimal separator)
Thread.CurrentThread.CurrentCulture = new CultureInfo("en-us");
Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-us");
// load score
Score score = ScoreLoader.LoadScore(args[0]);
// render score with svg engine
Settings settings = Settings.Defaults;
settings.Engine = "svg";
ScoreRenderer renderer = new ScoreRenderer(settings);
// get iterate tracks
for (int i = 0; i < 1; i++)
{
Track track = score.Tracks[i];
// render track
Console.WriteLine("Rendering track {0} - {1}", i + 1, track.Name);
var totalWidth = 0;
var totalHeight = 0;
XDocument merged = null;
var currentY = 0f;
renderer.PreRender += r =>
{
// append the svg close tag which would be part of the RenderFinished event
var svgString = r.RenderResult.ToString() + "</svg>";
merged = XDocument.Parse(svgString);
};
renderer.PartialRenderFinished += r =>
{
var subSvg = XDocument.Parse(r.RenderResult.ToString());
var subRoot = subSvg.Root;
subRoot.SetAttributeValue("x", "0px");
subRoot.SetAttributeValue("y", ((int)currentY) + "px");
merged.Root.Add(subRoot);
currentY += r.Height;
};
renderer.RenderFinished += r =>
{
totalWidth = (int)r.TotalWidth;
totalHeight = (int)r.TotalHeight;
};
renderer.Render(track);
merged.Root.SetAttributeValue("width", totalWidth + "px");
merged.Root.SetAttributeValue("height", totalHeight + "px");
var svg = new StringWriter();
var xmlWriter = new EntitizingXmlWriter(svg);
merged.Save(xmlWriter);
FileInfo info = new FileInfo(args[0]);
string path = Path.Combine(info.DirectoryName, Path.GetFileNameWithoutExtension(info.Name) + "-" + i + ".svg");
File.WriteAllText(path, svg.ToString());
}
}
static void Main(string[] args)
{
if (args.Length != 1)
{
Console.WriteLine("Usage AlphaTab.ScoreDump.exe Path");
return;
}
// load score
var score = ScoreLoader.LoadScoreFromBytes(File.ReadAllBytes(args[0]));
// render score with svg engine and desired rendering width
var settings = Settings.Defaults;
settings.Engine = "skia";
settings.Width = 970;
var renderer = new ScoreRenderer(settings);
// iterate tracks
for (int i = 0, j = score.Tracks.Count; i < j; i++)
{
var track = score.Tracks[i];
// render track
Console.WriteLine("Rendering track {0} - {1}", i + 1, track.Name);
var images = new List <SKImage>();
var totalWidth = 0;
var totalHeight = 0;
renderer.PartialRenderFinished += r =>
{
images.Add((SKImage)r.RenderResult);
};
renderer.RenderFinished += r =>
{
totalWidth = (int)r.TotalWidth;
totalHeight = (int)r.TotalHeight;
};
renderer.Render(score, new[] { track.Index });
// write png
var info = new FileInfo(args[0]);
var path = Path.Combine(info.DirectoryName, Path.GetFileNameWithoutExtension(info.Name) + "-" + i + ".png");
using (var full = SKSurface.Create(totalWidth, totalHeight, SKImageInfo.PlatformColorType, SKAlphaType.Premul))
{
int y = 0;
foreach (var image in images)
{
full.Canvas.DrawImage(image, new SKRect(0, 0, image.Width, image.Height), new SKRect(0, y, image.Width, y + image.Height));
y += image.Height;
}
using (var fullImage = full.Snapshot())
{
using (var data = fullImage.Encode(SKEncodedImageFormat.Png, 100).AsStream(true))
{
using (var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
{
data.CopyTo(fileStream);
}
}
}
}
}
}
void Start()
{
score = GameObject.Find("ScoreLoader").GetComponent <ScoreLoader>();
jumper = GameObject.Find("Jumper").GetComponent <Jumper>();
sound = GameObject.Find("Points Audio Source").GetComponent <AudioSource>();
}
