Asset_Create_Sprite_ShouldRecreateSpriteAssetFileWithTheSameAssetId_WhenSpriteAssetFileAlreadyExists_GivenTextureAssetFilePath_And_KeepAssetId()
{
// Arrange
var pngFilePathToCopy = Utils.GetPathUnderTestDirectory(@"Assets\TestTexture.png");
var pngFilePathInTempDir = Path.Combine(_temporaryDirectory.Path, "TestTexture.png");
File.Copy(pngFilePathToCopy, pngFilePathInTempDir);
var textureAssetFilePathToCopy = Utils.GetPathUnderTestDirectory(AssetFileUtils.AppendExtension(@"Assets\TestTexture"));
var textureAssetFilePathInTempDir = Path.Combine(_temporaryDirectory.Path, AssetFileUtils.AppendExtension("TestTexture"));
File.Copy(textureAssetFilePathToCopy, textureAssetFilePathInTempDir);
var spriteAssetFilePath = Path.Combine(_temporaryDirectory.Path, AssetFileUtils.AppendExtension("TestTexture.sprite"));
RunGeishaCli($"asset create sprite \"{textureAssetFilePathInTempDir}\"");
var originalAssetData = AssetData.Load(spriteAssetFilePath);
var modifiedAssetData = AssetData.CreateWithJsonContent(originalAssetData.AssetId, originalAssetData.AssetType, new SpriteAssetContent());
modifiedAssetData.Save(spriteAssetFilePath);
// Act
RunGeishaCli($"asset create sprite \"{textureAssetFilePathInTempDir}\" --keep-asset-id");
// Assert
var actualAssetData = AssetData.Load(spriteAssetFilePath);
Assert.That(actualAssetData.AssetId, Is.EqualTo(originalAssetData.AssetId));
Assert.That(actualAssetData.ReadJsonContent <SpriteAssetContent>().TextureAssetId, Is.EqualTo(AssetsIds.TestTexture.Value));
}
public void Asset_Create_Sound_ShouldRecreateSoundAssetFileWithTheSameAssetId_WhenSoundAssetFileAlreadyExists_GivenKeepAssetId()
{
// Arrange
var mp3FilePathToCopy = Utils.GetPathUnderTestDirectory(@"Assets\TestSound.mp3");
var mp3FilePathInTempDir = Path.Combine(_temporaryDirectory.Path, "TestSound.mp3");
File.Copy(mp3FilePathToCopy, mp3FilePathInTempDir);
var soundAssetFilePath = Path.Combine(_temporaryDirectory.Path, AssetFileUtils.AppendExtension("TestSound"));
RunGeishaCli($"asset create sound \"{mp3FilePathInTempDir}\"");
var originalAssetData = AssetData.Load(soundAssetFilePath);
var modifiedAssetData = AssetData.CreateWithJsonContent(originalAssetData.AssetId, originalAssetData.AssetType, new SoundAssetContent());
modifiedAssetData.Save(soundAssetFilePath);
// Act
RunGeishaCli($"asset create sound \"{mp3FilePathInTempDir}\" --keep-asset-id");
// Assert
var actualAssetData = AssetData.Load(soundAssetFilePath);
Assert.That(actualAssetData.AssetId, Is.EqualTo(originalAssetData.AssetId));
Assert.That(actualAssetData.ReadJsonContent <SoundAssetContent>().SoundFilePath, Is.EqualTo("TestSound.mp3"));
}
public static string CreateSoundAsset(string soundFilePath, bool keepAssetId = false)
{
var soundFileExtension = Path.GetExtension(soundFilePath);
if (!IsSupportedSoundFileFormat(soundFileExtension))
{
throw new ArgumentException($"Sound file format {soundFileExtension} is not supported.", nameof(soundFilePath));
}
var directoryPath = Path.GetDirectoryName(soundFilePath) ??
throw new ArgumentException("The path does not point to any file.", nameof(soundFilePath));
var soundAssetFileName = AssetFileUtils.AppendExtension(Path.GetFileNameWithoutExtension(soundFilePath));
var soundAssetFilePath = Path.Combine(directoryPath, soundAssetFileName);
var soundAssetContent = new SoundAssetContent
{
SoundFilePath = Path.GetFileName(soundFilePath)
};
var assetId = GetAssetId(keepAssetId, soundAssetFilePath);
var assetData = AssetData.CreateWithJsonContent(assetId, AudioAssetTypes.Sound, soundAssetContent);
assetData.Save(soundAssetFilePath);
return(soundAssetFilePath);
}
public void Load_ShouldLoadInputMappingFromFile(LoadTestCase testCase)
{
// Arrange
const string filePath = "input mapping file path";
var assetInfo = new AssetInfo(AssetId.CreateUnique(), InputAssetTypes.InputMapping, filePath);
var assetData = AssetData.CreateWithJsonContent(assetInfo.AssetId, assetInfo.AssetType, testCase.InputMappingAssetContent);
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var file = Substitute.For <IFile>();
file.OpenRead().Returns(memoryStream);
_fileSystem.GetFile(filePath).Returns(file);
var inputMappingAssetLoader = new InputMappingAssetLoader(_fileSystem);
// Act
var actual = (InputMapping)inputMappingAssetLoader.LoadAsset(assetInfo, _assetStore);
// Assert
testCase.Assert(actual);
}
public void ReadStringContent_ShouldThrowException_WhenContentIsJson()
{
// Arrange
// Act
var assetData = AssetData.CreateWithJsonContent(_assetId, _assetType, _jsonContent);
// Assert
Assert.That(() => assetData.ReadStringContent(), Throws.InvalidOperationException);
}
public void LoadAsset_ShouldLoadSpriteFromFile()
{
// Arrange
const string assetFilePath = @"some_directory\sprite_file_path";
var textureAssetId = AssetId.CreateUnique();
var spriteAssetContent = new SpriteAssetContent
{
TextureAssetId = textureAssetId.Value,
SourceUV = new SerializableVector2 {
X = 123.456, Y = 234.567
},
SourceDimensions = new SerializableVector2 {
X = 345.456, Y = 456.567
},
Pivot = new SerializableVector2 {
X = 567.678, Y = 678.789
},
PixelsPerUnit = 123.456
};
var assetInfo = new AssetInfo(AssetId.CreateUnique(), RenderingAssetTypes.Sprite, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(assetInfo.AssetId, assetInfo.AssetType, spriteAssetContent);
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var assetFile = Substitute.For <IFile>();
assetFile.OpenRead().Returns(memoryStream);
var fileSystem = Substitute.For <IFileSystem>();
fileSystem.GetFile(assetFilePath).Returns(assetFile);
var assetStore = Substitute.For <IAssetStore>();
var texture = Substitute.For <ITexture>();
assetStore.GetAsset <ITexture>(textureAssetId).Returns(texture);
var spriteAssetLoader = new SpriteAssetLoader(fileSystem);
// Act
var actual = (Sprite)spriteAssetLoader.LoadAsset(assetInfo, assetStore);
// Assert
Assert.That(actual.SourceTexture, Is.EqualTo(texture));
Assert.That(actual.SourceUV.X, Is.EqualTo(spriteAssetContent.SourceUV.X));
Assert.That(actual.SourceUV.Y, Is.EqualTo(spriteAssetContent.SourceUV.Y));
Assert.That(actual.SourceDimensions.X, Is.EqualTo(spriteAssetContent.SourceDimensions.X));
Assert.That(actual.SourceDimensions.Y, Is.EqualTo(spriteAssetContent.SourceDimensions.Y));
Assert.That(actual.Pivot.X, Is.EqualTo(spriteAssetContent.Pivot.X));
Assert.That(actual.Pivot.Y, Is.EqualTo(spriteAssetContent.Pivot.Y));
Assert.That(actual.PixelsPerUnit, Is.EqualTo(spriteAssetContent.PixelsPerUnit));
}
public void Create_AssetData_WithJsonContent()
{
// Arrange
// Act
var assetData = AssetData.CreateWithJsonContent(_assetId, _assetType, _jsonContent);
// Assert
Assert.That(assetData.AssetId, Is.EqualTo(_assetId));
Assert.That(assetData.AssetType, Is.EqualTo(_assetType));
Assert.That(assetData.ContentFormat, Is.EqualTo(AssetData.AssetContentFormat.Json));
var actualJsonContent = assetData.ReadJsonContent <JsonContent>();
Assert.That(actualJsonContent.IntProperty, Is.EqualTo(_jsonContent.IntProperty));
Assert.That(actualJsonContent.DoubleProperty, Is.EqualTo(_jsonContent.DoubleProperty));
Assert.That(actualJsonContent.StringProperty, Is.EqualTo(_jsonContent.StringProperty));
}
public void SetUp()
{
var renderingBackend = Substitute.For <IRenderingBackend>();
var renderer2D = Substitute.For <IRenderer2D>();
var fileSystem = Substitute.For <IFileSystem>();
_assetStore = Substitute.For <IAssetStore>();
renderingBackend.Renderer2D.Returns(renderer2D);
const string assetFilePath = @"some_directory\texture_file_path";
const string textureFilePath = @"some_directory\actual_texture_file_path";
var textureAssetContent = new TextureAssetContent
{
TextureFilePath = "actual_texture_file_path"
};
_assetInfo = new AssetInfo(AssetId.CreateUnique(), RenderingAssetTypes.Texture, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(_assetInfo.AssetId, _assetInfo.AssetType, textureAssetContent);
var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var assetFile = Substitute.For <IFile>();
assetFile.OpenRead().Returns(memoryStream);
fileSystem.GetFile(assetFilePath).Returns(assetFile);
var stream = Substitute.For <Stream>();
var textureFile = Substitute.For <IFile>();
textureFile.OpenRead().Returns(stream);
fileSystem.GetFile(textureFilePath).Returns(textureFile);
_texture = Substitute.For <ITexture>();
renderer2D.CreateTexture(stream).Returns(_texture);
_textureAssetLoader = new TextureAssetLoader(renderingBackend, fileSystem);
}
Asset_Create_InputMapping_ShouldRecreateDefaultInputMappingAssetFileWithTheSameAssetId_WhenInputMappingAssetFileAlreadyExists_GivenKeepAssetId()
{
// Arrange
var inputMappingAssetFilePath = Path.Combine(_temporaryDirectory.Path, AssetFileUtils.AppendExtension("DefaultInputMapping"));
RunGeishaCli("asset create input-mapping", _temporaryDirectory.Path);
var originalAssetData = AssetData.Load(inputMappingAssetFilePath);
var modifiedAssetData = AssetData.CreateWithJsonContent(originalAssetData.AssetId, originalAssetData.AssetType, new InputMappingAssetContent());
modifiedAssetData.Save(inputMappingAssetFilePath);
// Act
RunGeishaCli("asset create input-mapping --keep-asset-id", _temporaryDirectory.Path);
// Assert
var actualAssetData = AssetData.Load(inputMappingAssetFilePath);
Assert.That(actualAssetData.AssetId, Is.EqualTo(originalAssetData.AssetId));
Assert.That(actualAssetData.ReadJsonContent <InputMappingAssetContent>().ActionMappings, Contains.Key("Jump"));
}
public void SaveToFileAndLoadFromFile_AssetData_WithJsonContent()
{
// Arrange
var assetData = AssetData.CreateWithJsonContent(_assetId, _assetType, _jsonContent);
// Act
var filePath = _temporaryDirectory.GetRandomFilePath();
assetData.Save(filePath);
var actual = AssetData.Load(filePath);
// Assert
Assert.That(actual.AssetId, Is.EqualTo(_assetId));
Assert.That(actual.AssetType, Is.EqualTo(_assetType));
Assert.That(assetData.ContentFormat, Is.EqualTo(AssetData.AssetContentFormat.Json));
var actualJsonContent = actual.ReadJsonContent <JsonContent>();
Assert.That(actualJsonContent.IntProperty, Is.EqualTo(_jsonContent.IntProperty));
Assert.That(actualJsonContent.DoubleProperty, Is.EqualTo(_jsonContent.DoubleProperty));
Assert.That(actualJsonContent.StringProperty, Is.EqualTo(_jsonContent.StringProperty));
}
public void SaveToStreamAndLoadFromStream_AssetData_WithJsonContent()
{
// Arrange
var assetData = AssetData.CreateWithJsonContent(_assetId, _assetType, _jsonContent);
// Act
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var actual = AssetData.Load(memoryStream);
// Assert
Assert.That(actual.AssetId, Is.EqualTo(_assetId));
Assert.That(actual.AssetType, Is.EqualTo(_assetType));
Assert.That(assetData.ContentFormat, Is.EqualTo(AssetData.AssetContentFormat.Json));
var actualJsonContent = actual.ReadJsonContent <JsonContent>();
Assert.That(actualJsonContent.IntProperty, Is.EqualTo(_jsonContent.IntProperty));
Assert.That(actualJsonContent.DoubleProperty, Is.EqualTo(_jsonContent.DoubleProperty));
Assert.That(actualJsonContent.StringProperty, Is.EqualTo(_jsonContent.StringProperty));
}
public void SetUp()
{
_audioBackend = Substitute.For <IAudioBackend>();
_fileSystem = Substitute.For <IFileSystem>();
_assetStore = Substitute.For <IAssetStore>();
const string soundFilePath = "sound.wav";
const SoundFormat soundFormat = SoundFormat.Wav;
const string assetFilePath = "sound-asset-path";
var soundAssetContent = new SoundAssetContent
{
SoundFilePath = soundFilePath
};
_assetInfo = new AssetInfo(AssetId.CreateUnique(), AudioAssetTypes.Sound, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(_assetInfo.AssetId, _assetInfo.AssetType, soundAssetContent);
var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var assetFile = Substitute.For <IFile>();
assetFile.OpenRead().Returns(memoryStream);
_fileSystem.GetFile(assetFilePath).Returns(assetFile);
var soundFile = Substitute.For <IFile>();
var stream = Substitute.For <Stream>();
soundFile.OpenRead().Returns(stream);
_fileSystem.GetFile(soundFilePath).Returns(soundFile);
_sound = Substitute.For <ISound>();
_audioBackend.CreateSound(stream, soundFormat).Returns(_sound);
_soundAssetLoader = new SoundAssetLoader(_audioBackend, _fileSystem);
}
public void LoadAsset_ThrowsException_WhenFileContentIsInvalid(LoadThrowsExceptionTestCase testCase)
{
// Arrange
const string assetFilePath = "input mapping file path";
var assetInfo = new AssetInfo(AssetId.CreateUnique(), InputAssetTypes.InputMapping, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(assetInfo.AssetId, assetInfo.AssetType, testCase.InputMappingAssetContent);
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var file = Substitute.For <IFile>();
file.OpenRead().Returns(memoryStream);
_fileSystem.GetFile(assetFilePath).Returns(file);
var inputMappingAssetLoader = new InputMappingAssetLoader(_fileSystem);
// Act
// Assert
Assert.That(() => inputMappingAssetLoader.LoadAsset(assetInfo, _assetStore), Throws.TypeOf <InvalidInputMappingAssetContentException>());
}
Asset_Create_SpriteAnimation_ShouldRecreateSpriteAnimationAssetFileWithTheSameAssetId_WhenSpriteAnimationAssetFileAlreadyExists_GivenKeepAssetId()
{
// Arrange
CopyAnimationFiles();
var spriteAnimationAssetFilePath =
Path.Combine(_temporaryDirectory.Path, AssetFileUtils.AppendExtension(new DirectoryInfo(_temporaryDirectory.Path).Name));
RunGeishaCli($"asset create sprite-animation \"{_temporaryDirectory.Path}\"");
var originalAssetData = AssetData.Load(spriteAnimationAssetFilePath);
var modifiedAssetData = AssetData.CreateWithJsonContent(originalAssetData.AssetId, originalAssetData.AssetType, new SpriteAnimationAssetContent());
modifiedAssetData.Save(spriteAnimationAssetFilePath);
// Act
RunGeishaCli($"asset create sprite-animation \"{_temporaryDirectory.Path}\" --keep-asset-id");
// Assert
var actualAssetData = AssetData.Load(spriteAnimationAssetFilePath);
Assert.That(actualAssetData.AssetId, Is.EqualTo(originalAssetData.AssetId));
Assert.That(actualAssetData.ReadJsonContent <SpriteAnimationAssetContent>().DurationTicks, Is.EqualTo(TimeSpan.FromSeconds(1).Ticks));
}
public void LoadAsset_ShouldLoadSpriteAnimationFromFile()
{
// Arrange
const string assetFilePath = @"some_directory\sprite_animation_file_path";
const int duration = 123;
var sprite1AssetId = AssetId.CreateUnique();
var sprite2AssetId = AssetId.CreateUnique();
var sprite3AssetId = AssetId.CreateUnique();
var spriteAnimationAssetContent = new SpriteAnimationAssetContent
{
DurationTicks = TimeSpan.FromSeconds(duration).Ticks,
Frames = new[]
{
new SpriteAnimationAssetContent.Frame
{
Duration = 1,
SpriteAssetId = sprite1AssetId.Value
},
new SpriteAnimationAssetContent.Frame
{
Duration = 1.5,
SpriteAssetId = sprite2AssetId.Value
},
new SpriteAnimationAssetContent.Frame
{
Duration = 0.5,
SpriteAssetId = sprite3AssetId.Value
}
}
};
var assetInfo = new AssetInfo(AssetId.CreateUnique(), AnimationAssetTypes.SpriteAnimation, assetFilePath);
var assetData = AssetData.CreateWithJsonContent(assetInfo.AssetId, assetInfo.AssetType, spriteAnimationAssetContent);
using var memoryStream = new MemoryStream();
assetData.Save(memoryStream);
memoryStream.Position = 0;
var sprite1 = new Sprite(Substitute.For <ITexture>(), Vector2.Zero, Vector2.Zero, Vector2.Zero, 0);
var sprite2 = new Sprite(Substitute.For <ITexture>(), Vector2.Zero, Vector2.Zero, Vector2.Zero, 0);
var sprite3 = new Sprite(Substitute.For <ITexture>(), Vector2.Zero, Vector2.Zero, Vector2.Zero, 0);
var assetFile = Substitute.For <IFile>();
assetFile.OpenRead().Returns(memoryStream);
var fileSystem = Substitute.For <IFileSystem>();
fileSystem.GetFile(assetFilePath).Returns(assetFile);
var assetStore = Substitute.For <IAssetStore>();
assetStore.GetAsset <Sprite>(sprite1AssetId).Returns(sprite1);
assetStore.GetAsset <Sprite>(sprite2AssetId).Returns(sprite2);
assetStore.GetAsset <Sprite>(sprite3AssetId).Returns(sprite3);
var spriteAnimationManagedAsset = new SpriteAnimationAssetLoader(fileSystem);
// Act
var actual = (SpriteAnimation)spriteAnimationManagedAsset.LoadAsset(assetInfo, assetStore);
// Assert
Assert.That(actual.Duration, Is.EqualTo(TimeSpan.FromSeconds(duration)));
Assert.That(actual.Frames, Has.Count.EqualTo(3));
Assert.That(actual.Frames[0].Duration, Is.EqualTo(1));
Assert.That(actual.Frames[0].Sprite, Is.EqualTo(sprite1));
Assert.That(actual.Frames[1].Duration, Is.EqualTo(1.5));
Assert.That(actual.Frames[1].Sprite, Is.EqualTo(sprite2));
Assert.That(actual.Frames[2].Duration, Is.EqualTo(0.5));
Assert.That(actual.Frames[2].Sprite, Is.EqualTo(sprite3));
}
