public void Upgrade(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, YamlMappingNode yamlAssetNode, PackageLoadingAssetFile assetFile)
{
dynamic asset = new DynamicYamlMapping(yamlAssetNode);
// upgrade the asset
UpgradeAsset(context, currentVersion, targetVersion, asset, assetFile);
SetSerializableVersion(asset, dependencyName, targetVersion);
// upgrade its base
var baseBranch = asset[Asset.BaseProperty];
if (baseBranch != null)
{
UpgradeBase(context, dependencyName, currentVersion, targetVersion, baseBranch, assetFile);
}
// upgrade base parts
var basePartsBranch = asset[Asset.BasePartsProperty] as DynamicYamlArray;
if (basePartsBranch != null)
{
foreach (dynamic assetBase in basePartsBranch)
{
UpgradeBase(context, dependencyName, currentVersion, targetVersion, assetBase, assetFile);
}
}
}
public void Upgrade(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, YamlMappingNode yamlAssetNode, PackageLoadingAssetFile assetFile)
{
dynamic asset = new DynamicYamlMapping(yamlAssetNode);
// upgrade the asset
var baseBranch = asset[Asset.BaseProperty];
var basePartsBranch = asset[Asset.BasePartsProperty] as DynamicYamlArray;
// Detect in what kind of override context we are
var overrideHint = (baseBranch != null || (basePartsBranch != null && basePartsBranch.Node.Children.Count > 0))
? OverrideUpgraderHint.Derived
: OverrideUpgraderHint.Unknown;
// Upgrade the asset
UpgradeAsset(context, currentVersion, targetVersion, asset, assetFile, overrideHint);
SetSerializableVersion(asset, dependencyName, targetVersion);
// Upgrade its base
if (baseBranch != null)
{
UpgradeBase(context, dependencyName, currentVersion, targetVersion, baseBranch, assetFile);
}
// Upgrade base parts
if (basePartsBranch != null)
{
foreach (dynamic assetBase in basePartsBranch)
{
UpgradeBase(context, dependencyName, currentVersion, targetVersion, assetBase, assetFile);
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile)
{
if (asset.Source != null)
asset.Source = DynamicYamlEmpty.Default;
if (asset.SourceHash != null)
asset.SourceHash = DynamicYamlEmpty.Default;
}
public PackageDownloadHandle(DynamoViewModel dynamoViewModel, Greg.Responses.PackageHeader header, PackageVersion version)
{
this.dynamoViewModel = dynamoViewModel;
this.Header = header;
this.DownloadPath = "";
this.VersionName = version.version;
}
/// <summary>
/// Initializes a new instance of the <see cref="PackageVersionRange"/> class.
/// </summary>
/// <param name="version">The exact version.</param>
public PackageVersionRange(PackageVersion version)
{
IsMinInclusive = true;
IsMaxInclusive = true;
MinVersion = version;
MaxVersion = version;
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile)
{
// Introduction of MaterialInstance
var material = asset.Type.Material;
if (material != null)
{
asset.Type.MaterialInstance = new YamlMappingNode();
asset.Type.MaterialInstance.Material = material;
asset.Type.Material = DynamicYamlEmpty.Default;
}
var type = asset.Type.Node as YamlMappingNode;
if (type != null && type.Tag == "!CubeProceduralModel")
{
// Size changed from scalar to vector3
var size = asset.Type.Size as DynamicYamlScalar;
if (size != null)
{
var vecSize = new YamlMappingNode
{
{ new YamlScalarNode("X"), new YamlScalarNode(size.Node.Value) },
{ new YamlScalarNode("Y"), new YamlScalarNode(size.Node.Value) },
{ new YamlScalarNode("Z"), new YamlScalarNode(size.Node.Value) }
};
vecSize.Style = YamlStyle.Flow;
asset.Type.Size = vecSize;
}
}
}
public void OnRequestDownload(PackageVersion version)
{
if (RequestDownload != null)
{
RequestDownload(this.Model, version);
}
}
private void UpgradeBase(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, dynamic assetBase, PackageLoadingAssetFile assetFile)
{
var baseAsset = assetBase[nameof(AssetBase.Asset)];
if (baseAsset != null)
{
UpgradeAsset(context, currentVersion, targetVersion, baseAsset, assetFile);
SetSerializableVersion(baseAsset, dependencyName, targetVersion);
}
}
public void Upgrade(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, YamlMappingNode yamlAssetNode, PackageLoadingAssetFile assetFile)
{
dynamic asset = new DynamicYamlMapping(yamlAssetNode);
var baseBranch = asset["~Base"];
if (baseBranch != null)
asset["~Base"] = DynamicYamlEmpty.Default;
AssetUpgraderBase.SetSerializableVersion(asset, dependencyName, targetVersion);
}
/// <summary>
/// Initializes a new instance of the <see cref="PackageStore"/> class.
/// </summary>
/// <exception cref="System.InvalidOperationException">Unable to find a valid Xenko installation path</exception>
private PackageStore(string installationPath = null, string defaultPackageName = "Xenko", string defaultPackageVersion = XenkoVersion.CurrentAsText)
{
// TODO: these are currently hardcoded to Xenko
DefaultPackageName = defaultPackageName;
DefaultPackageVersion = new PackageVersion(defaultPackageVersion);
defaultPackageDirectory = DirectoryHelper.GetPackageDirectory(defaultPackageName);
// 1. Try to use the specified installation path
if (installationPath != null)
{
if (!DirectoryHelper.IsInstallationDirectory(installationPath))
{
throw new ArgumentException("Invalid Xenko installation path [{0}]".ToFormat(installationPath), "installationPath");
}
globalInstallationPath = installationPath;
}
// 2. Try to resolve an installation path from the path of this assembly
// We need to be able to use the package manager from an official Xenko install as well as from a developer folder
if (globalInstallationPath == null)
{
globalInstallationPath = DirectoryHelper.GetInstallationDirectory(DefaultPackageName);
}
// If there is no root, this is an error
if (globalInstallationPath == null)
{
throw new InvalidOperationException("Unable to find a valid Xenko installation or dev path");
}
// Preload default package
var logger = new LoggerResult();
var defaultPackageFile = DirectoryHelper.GetPackageFile(defaultPackageDirectory, DefaultPackageName);
defaultPackage = Package.Load(logger, defaultPackageFile, GetDefaultPackageLoadParameters());
if (defaultPackage == null)
{
throw new InvalidOperationException("Error while loading default package from [{0}]: {1}".ToFormat(defaultPackageFile, logger.ToText()));
}
defaultPackage.IsSystem = true;
// A flag variable just to know if it is a bare bone development directory
isDev = defaultPackageDirectory != null && DirectoryHelper.IsRootDevDirectory(defaultPackageDirectory);
// Check if we are in a root directory with store/packages facilities
if (NugetStore.IsStoreDirectory(globalInstallationPath))
{
packagesDirectory = UPath.Combine(globalInstallationPath, (UDirectory)NugetStore.DefaultGamePackagesDirectory);
store = new NugetStore(globalInstallationPath);
}
else
{
// We should exit from here if NuGet is not configured.
MessageBox.Show($"Unexpected installation. Cannot find a proper NuGet configuration for [{defaultPackageName}] in [{globalInstallationPath}]", "Installation Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
Environment.Exit(1);
}
}
public void Upgrade(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, YamlMappingNode yamlAssetNode, PackageLoadingAssetFile assetFile)
{
dynamic asset = new DynamicYamlMapping(yamlAssetNode);
AssetUpgraderBase.SetSerializableVersion(asset, dependencyName, targetVersion);
// Move Test4 to Test5
asset.Test5 = asset.Test4;
asset.Test4 = DynamicYamlEmpty.Default;
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile)
{
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Entities;
foreach (dynamic entity in entities)
{
var components = entity.Components;
var spriteComponent = components["SpriteComponent.Key"];
if (spriteComponent != null)
spriteComponent.RemoveChild("ExtrusionMethod");
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Entities;
foreach (dynamic entity in entities)
{
var components = entity.Components;
var modelComponent = components["ModelComponent.Key"];
if (modelComponent != null)
modelComponent.RemoveChild("DrawOrder");
}
}
public void Upgrade(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, YamlMappingNode yamlAssetNode, PackageLoadingAssetFile assetFile)
{
dynamic asset = new DynamicYamlMapping(yamlAssetNode);
// Note: seems little bit strange, but original test was not using targetVersion...
var serializedVersion = AssetRegistry.GetCurrentFormatVersions(typeof(MyUpgradedAsset))[dependencyName];
AssetUpgraderBase.SetSerializableVersion(asset, dependencyName, serializedVersion);
// Move Test1 to Test2
asset.Test2 = asset.Test1;
asset.Test1 = DynamicYamlEmpty.Default;
}
public static void SetSerializableVersion(dynamic asset, string dependencyName, PackageVersion value)
{
if (asset.IndexOf(nameof(Asset.SerializedVersion)) == -1)
{
asset.SerializedVersion = new YamlMappingNode();
// Ensure that it is stored right after the asset Id
asset.MoveChild(nameof(Asset.SerializedVersion), asset.IndexOf(nameof(Asset.Id)) + 1);
}
asset.SerializedVersion[dependencyName] = value;
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile)
{
foreach (var modelMaterial in asset.Materials)
{
var material = modelMaterial.Material;
if (material != null)
{
modelMaterial.MaterialInstance = new YamlMappingNode();
modelMaterial.MaterialInstance.Material = material;
modelMaterial.Material = DynamicYamlEmpty.Default;
}
}
}
private static IEnumerable<Tuple<PackageHeader, PackageVersion>> ListRequiredPackageVersions(
IEnumerable<PackageHeader> headers, PackageVersion version)
{
return headers.Zip(
version.full_dependency_versions,
(header, v) => new Tuple<PackageHeader, string>(header, v))
.Select(
(pair) =>
new Tuple<PackageHeader, PackageVersion>(
pair.Item1,
pair.Item1.versions.First(x => x.version == pair.Item2)));
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile,
OverrideUpgraderHint overrideHint)
{
if (asset.IsDynamic != null)
{
var isDynamic = (bool)asset.IsDynamic;
// There is also SDF type, but old assets don't have it yet
asset.AddChild("FontType", isDynamic ? "Dynamic" : "Static");
asset.RemoveChild("IsDynamic");
}
}
public override bool Execute()
{
var result = new LoggerResult();
var package = Package.Load(result, File.ItemSpec, new PackageLoadParameters()
{
AutoCompileProjects = false,
LoadAssemblyReferences = false,
AutoLoadTemporaryAssets = false,
});
foreach (var message in result.Messages)
{
if (message.Type >= LogMessageType.Error)
{
Log.LogError(message.ToString());
}
else if (message.Type == LogMessageType.Warning)
{
Log.LogWarning(message.ToString());
}
else
{
Log.LogMessage(message.ToString());
}
}
// If we have errors loading the package, exit
if (result.HasErrors)
{
return false;
}
var version = package.Meta.Version;
// Override version with task SpecialVersion (if specified by user)
if (!string.IsNullOrEmpty(SpecialVersion))
{
version = new PackageVersion(version.ToString().Split('-').First() + "-" + SpecialVersion);
}
Version = version.ToString();
return true;
}
public void Upgrade(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, YamlMappingNode yamlAssetNode, PackageLoadingAssetFile assetFile)
{
dynamic asset = new DynamicYamlMapping(yamlAssetNode);
// upgrade the asset
UpgradeAsset(context, currentVersion, targetVersion, asset, assetFile);
SetSerializableVersion(asset, dependencyName, targetVersion);
// upgrade its base
var baseBranch = asset["~Base"];
if (baseBranch != null)
{
var baseAsset = baseBranch["Asset"];
if (baseAsset != null)
{
UpgradeAsset(context, currentVersion, targetVersion, baseAsset, assetFile);
SetSerializableVersion(baseAsset, dependencyName, targetVersion);
}
}
}
public void Upgrade(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, YamlMappingNode yamlAssetNode, PackageLoadingAssetFile assetFile)
{
dynamic asset = new DynamicYamlMapping(yamlAssetNode);
AssetUpgraderBase.SetSerializableVersion(asset, dependencyName, targetVersion);
// Move Test2 to Test4
if (currentVersion == PackageVersion.Parse("0.0.2"))
{
asset.Test4 = asset.Test2;
asset.Test2 = DynamicYamlEmpty.Default;
}
// Move Test3 to Test4
else if (currentVersion == PackageVersion.Parse("0.0.3"))
{
asset.Test4 = asset.Test3;
asset.Test3 = DynamicYamlEmpty.Default;
}
}
public void FilterFuturePackages_IEnumerableTuplePackageHeaderPackageVersion_ReturnsCorrectResults()
{
var pkgVersion063 = new PackageVersion()
{
engine_version = "0.6.3"
};
var pkgVersion080 = new PackageVersion()
{
engine_version = "0.8.0"
};
var pkg063 = new PackageHeader()
{
name = "063",
versions = new List<PackageVersion>()
{
pkgVersion063
}
};
var pkg080 = new PackageHeader()
{
name = "080",
versions = new List<PackageVersion>()
{
pkgVersion080
}
};
var pkgList = new List<Tuple<PackageHeader, PackageVersion>>()
{
new Tuple<PackageHeader, PackageVersion>(pkg063, pkgVersion063),
new Tuple<PackageHeader, PackageVersion>(pkg080, pkgVersion080),
};
var dynamoVersion = Version.Parse("0.7.1");
var filteredPkgList = pkgList.FilterFuturePackages(dynamoVersion);
Assert.AreEqual(1, filteredPkgList.Count());
Assert.AreEqual("080", filteredPkgList.First().Item1.name);
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile)
{
if (asset.ColliderShapes == null)
return;
foreach (var colliderShape in asset.ColliderShapes)
{
if (colliderShape.Node.Tag == "!Box2DColliderShapeDesc")
{
var size = 2f * DynamicYamlExtensions.ConvertTo<Vector2>(colliderShape.HalfExtent);
colliderShape.Size = DynamicYamlExtensions.ConvertFrom(size);
colliderShape.HalfExtent = DynamicYamlEmpty.Default;
}
if (colliderShape.Node.Tag == "!BoxColliderShapeDesc")
{
var size = 2f * DynamicYamlExtensions.ConvertTo<Vector3>(colliderShape.HalfExtents);
colliderShape.Size = DynamicYamlExtensions.ConvertFrom(size);
colliderShape.HalfExtents = DynamicYamlEmpty.Default;
}
if (colliderShape.Node.Tag == "!CapsuleColliderShapeDesc" || colliderShape.Node.Tag == "!CylinderColliderShapeDesc")
{
var upVector = DynamicYamlExtensions.ConvertTo<Vector3>(colliderShape.UpAxis);
if (upVector == Vector3.UnitX)
colliderShape.Orientation = ShapeOrientation.UpX;
if (upVector == Vector3.UnitZ)
colliderShape.Orientation = ShapeOrientation.UpZ;
colliderShape.UpAxis = DynamicYamlEmpty.Default;
}
if (colliderShape.Node.Tag == "!CapsuleColliderShapeDesc" && colliderShape.Height != null)
{
colliderShape.Length = 2f * (float)colliderShape.Height;
colliderShape.Height = DynamicYamlEmpty.Default;
}
if (colliderShape.Node.Tag == "!CylinderColliderShapeDesc")
{
colliderShape.Radius = (float)colliderShape.HalfExtents.X;
colliderShape.Height = 2f * (float)colliderShape.HalfExtents.Y;
colliderShape.HalfExtents = DynamicYamlEmpty.Default;
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Entities;
foreach (dynamic entity in entities)
{
var components = entity.Components;
var spriteComponent = components["SpriteComponent.Key"];
if (spriteComponent != null)
{
var provider = spriteComponent.SpriteProvider;
var providerAsMap = provider as DynamicYamlMapping;
if (providerAsMap != null && providerAsMap.Node.Tag == "!SpriteFromSpriteGroup")
{
provider.Sheet = provider.SpriteGroup;
provider.SpriteGroup = DynamicYamlEmpty.Default;
providerAsMap.Node.Tag = "!SpriteFromSheet";
}
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile,
OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = hierarchy.Entities;
foreach (var entityAndDesign in entities)
{
var entity = entityAndDesign.Entity;
foreach (var component in entity.Components)
{
var componentTag = component.Node.Tag;
if (componentTag != "!UIComponent")
continue;
// VirtualResolution
component.RenameChild("VirtualResolution", "Resolution");
// VirtualResolutionMode
component.RenameChild("VirtualResolutionMode", "ResolutionStretch");
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile,
OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = hierarchy.Entities;
foreach (var entityAndDesign in entities)
{
var entity = entityAndDesign.Entity;
foreach (var component in entity.Components)
{
var componentTag = component.Node.Tag;
if (componentTag != "!SpriteComponent")
continue;
var provider = component.SpriteProvider;
if (provider == null || provider.Node.Tag != "!SpriteFromSheet")
continue;
component.TransferChild("CurrentFrame", provider, "CurrentFrame");
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
asset.Parameters = DynamicYamlEmpty.Default;
}
private string GetAppVersion()
{
PackageVersion version = Package.Current.Id.Version;
return(string.Format("{0}.{1}.{2}.{3}", version.Major, version.Minor, version.Build, version.Revision));
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
// Remove from all layers/renderers
var layers = (DynamicYamlArray)hierarchy?.SceneSettings?.GraphicsCompositor?.Layers;
if (layers != null)
{
foreach (dynamic layer in layers)
{
ProcessRenderers((DynamicYamlArray)layer.Renderers);
}
}
var masterRenderers = (DynamicYamlArray)hierarchy?.SceneSettings?.GraphicsCompositor?.Master?.Renderers;
ProcessRenderers(masterRenderers);
// Remove from editor settings
var colorTransforms = hierarchy?.SceneSettings?.EditorSettings?.Mode?.PostProcessingEffects?.ColorTransforms;
if (colorTransforms != null)
{
colorTransforms.RemoveChild("GammaTransform");
// Because the color was stored in linear, we need to store it back to gamma
// We also apply a x2 to the color to
var color = hierarchy.SceneSettings.EditorSettings.Mode.BackgroundColor;
if (color != null)
{
color["R"] = MathUtil.Clamp(MathUtil.LinearToSRgb((float)color["R"]) * 2.0f, 0.0f, 1.0f);
color["G"] = MathUtil.Clamp(MathUtil.LinearToSRgb((float)color["G"]) * 2.0f, 0.0f, 1.0f);
color["B"] = MathUtil.Clamp(MathUtil.LinearToSRgb((float)color["B"]) * 2.0f, 0.0f, 1.0f);
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
asset.Hierarchy.SceneSettings.EditorSettings.Camera = DynamicYamlEmpty.Default;
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Entities;
foreach (dynamic entity in entities)
{
var components = entity.Entity.Components;
var physComponent = components["PhysicsComponent.Key"];
if (physComponent == null)
{
continue;
}
foreach (dynamic element in physComponent.Elements)
{
if (element.Node.Tag == "!RigidbodyElement")
{
element.NodeName = element.LinkedBoneName;
element.RemoveChild("LinkedBoneName");
}
}
}
}
private static PackageVersionEnvironment GetPackageEnvironmentEntity(IRepository <Package> repository, PackageVersion packageVersionEntity)
{
return(packageVersionEntity.PackageEnvironments.FirstOrDefault(s => s.PackageVersionId == packageVersionEntity.PackageVersionId && s.Name == repository.Name));
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Entities;
foreach (dynamic entity in entities)
{
var components = entity.Components;
var modelComponent = components["ModelComponent.Key"];
if (modelComponent != null)
{
modelComponent.RemoveChild("DrawOrder");
}
}
}
public PackageDownloadHandle(Greg.Responses.PackageHeader header, PackageVersion version)
{
this.Header = header;
this.DownloadPath = "";
this.VersionName = version.version;
}
public static Version ToVersion(this PackageVersion version)
{
return(new Version(version.Major, version.Minor, version.Build, version.Revision));
}
private static void SetUpAndValidate(CommandLineArguments args)
{
string[] batchActions =
{
"extract-packages",
"convert-models",
"convert-resources"
};
string[] packageActions =
{
"create-package",
"extract-package",
"extract-packages"
};
string[] graphicsActions =
{
"convert-model",
"convert-models"
};
LogLevel = CommandLineArguments.GetLogLevelByString(args.LogLevel);
CommandLineLogger.LogDebug($"Using log level: {LogLevel}");
Game = CommandLineArguments.GetGameByString(args.Game);
CommandLineLogger.LogDebug($"Using game: {Game}");
if (batchActions.Any(args.Action.Contains))
{
if (args.InputFormat == null || args.OutputFormat == null)
{
if (args.InputFormat == null && args.Action != "extract-packages")
{
CommandLineLogger.LogFatal("Cannot perform batch action without --input-format and --output-format arguments", 1);
}
}
InputFormat = CommandLineArguments.GetResourceFormatByString(args.InputFormat);
CommandLineLogger.LogDebug($"Using input format: {InputFormat}");
if (args.Action != "extract-packages")
{
OutputFormat = CommandLineArguments.GetResourceFormatByString(args.OutputFormat);
CommandLineLogger.LogDebug($"Using output format: {OutputFormat}");
}
}
if (packageActions.Any(args.Action.Contains))
{
PackageVersion = CommandLineArguments.GetPackageVersion(args.PackageVersion);
CommandLineLogger.LogDebug($"Using package version: {PackageVersion}");
}
if (graphicsActions.Any(args.Action.Contains))
{
GR2Options = CommandLineArguments.GetGR2Options(args.Options);
CommandLineLogger.LogDebug($"Using graphics options: {GR2Options}");
if (GR2Options["conform"])
{
ConformPath = TryToValidatePath(args.ConformPath);
}
}
SourcePath = TryToValidatePath(args.Source);
DestinationPath = TryToValidatePath(args.Destination);
}
static void MeshSyncEditorConstants_OnLoad() {
bool parsed = PackageVersion.TryParse(Lib.GetPluginVersion(), out m_pluginVersion);
Assert.IsTrue(parsed);
}
public void Run(IBackgroundTaskInstance taskInstance)
{
try
{
bme280Sensor = new BME280(0x76);
}
catch (Exception ex)
{
Debug.WriteLine($"BME280 Initialisation failed:{ex.Message}");
return;
}
try
{
TpmDevice myDevice = new TpmDevice(0); // Use logical device 0 on the TPM
azureIoTHubUri = myDevice.GetHostName();
deviceId = myDevice.GetDeviceId();
sasToken = myDevice.GetSASToken((uint)sasTokenValidityPeriod.TotalSeconds);
sasTokenIssuedAtUtc = DateTime.UtcNow;
}
catch (Exception ex)
{
Debug.WriteLine($"TpmDevice.GetSASToken failed:{ex.Message}");
return;
}
try
{
azureIoTHubClient = DeviceClient.Create(azureIoTHubUri, AuthenticationMethodFactory.CreateAuthenticationWithToken(deviceId, sasToken), TransportType.Mqtt);
}
catch (Exception ex)
{
Debug.WriteLine($"DeviceClient.Create with TPM info failed:{ex.Message}");
return;
}
try
{
azureIoTHubClient.SetMethodHandlerAsync("Restart", RestartAsync, null);
}
catch (Exception ex)
{
Debug.WriteLine($"Azure IoT Hub device method handler configuration failed:{ex.Message}");
return;
}
try
{
TwinCollection reportedProperties;
reportedProperties = new TwinCollection();
// This is from the OS
reportedProperties["Timezone"] = TimeZoneSettings.CurrentTimeZoneDisplayName;
reportedProperties["OSVersion"] = Environment.OSVersion.VersionString;
reportedProperties["MachineName"] = Environment.MachineName;
// This is from the application manifest
Package package = Package.Current;
PackageId packageId = package.Id;
PackageVersion version = packageId.Version;
reportedProperties["ApplicationDisplayName"] = package.DisplayName;
reportedProperties["ApplicationName"] = packageId.Name;
reportedProperties["ApplicationVersion"] = string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}");
// Unique identifier from the hardware
SystemIdentificationInfo systemIdentificationInfo = SystemIdentification.GetSystemIdForPublisher();
using (DataReader reader = DataReader.FromBuffer(systemIdentificationInfo.Id))
{
byte[] bytes = new byte[systemIdentificationInfo.Id.Length];
reader.ReadBytes(bytes);
reportedProperties["SystemId"] = BitConverter.ToString(bytes);
}
azureIoTHubClient.UpdateReportedPropertiesAsync(reportedProperties).Wait();
}
catch (Exception ex)
{
Debug.Print($"Azure IoT Hub device twin configuration retrieval failed:{ex.Message}");
return;
}
try
{
deviceTwin = azureIoTHubClient.GetTwinAsync().Result;
}
catch (Exception ex)
{
Debug.WriteLine($"Azure IoT Hub device twin configuration retrieval failed:{ex.Message}");
return;
}
try
{
if (deviceTwin.Properties.Desired.Contains("TimerDue"))
{
timerDue = TimeSpan.Parse(deviceTwin.Properties.Desired["TimerDue"].ToString());
}
if (deviceTwin.Properties.Desired.Contains("TimerPeriod"))
{
timerPeriod = TimeSpan.Parse(deviceTwin.Properties.Desired["TimerPeriod"].ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine($"Sensor due or period configuration retrieval failed using default:{ex.Message}");
return;
}
bme280InputPollingTimer = new Timer(SensorUpdateTimerCallback, null, timerDue, timerPeriod);
// enable task to continue running in background
backgroundTaskDeferral = taskInstance.GetDeferral();
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
// Move SceneSettings to SceneAsset outside the HierarchyData
var sceneSettings = asset.Hierarchy.SceneSettings;
asset.SceneSettings = sceneSettings;
var assetYaml = (DynamicYamlMapping)asset.Hierarchy;
assetYaml.RemoveChild("SceneSettings");
}
private PackageVersionEnvironment GetOrAddPackageEnvironmentEntity(IRepository <Package> repository, Entity.Package packageEntity, PackageVersion packageVersionEntity)
{
var packageEnvironment = GetPackageEnvironmentEntity(repository, packageVersionEntity);
if (packageEnvironment == null)
{
packageEnvironment = new PackageVersionEnvironment
{
PackageVersionId = packageVersionEntity.PackageVersionId,
Name = repository.Name
};
packageVersionEntity.PackageEnvironments.Add(packageEnvironment);
dbContext.SaveChanges();
Logger.LogInformation($"Environment {packageEnvironment.Name} for Package {packageEntity.Name} added to database");
}
return(packageEnvironment);
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
if (asset.NoPremultiply != null)
{
asset.IsPremultiplied = !(bool)asset.NoPremultiply;
asset.NoPremultiply = DynamicYamlEmpty.Default;
}
if (asset.IsNotPremultiply != null)
{
asset.IsPremultiplied = !(bool)asset.IsNotPremultiply;
asset.IsNotPremultiply = DynamicYamlEmpty.Default;
}
}
private void PopulatePackageAssembliesFromPackageContent(Package package, Entity.Package packageEntity, PackageVersion packageVersionEntity)
{
var uniqueAssemblies = new Dictionary <string, AssemblyName>();
var coreAssembly = typeof(object).Assembly;
using var byteStream = new MemoryStream(package.Content);
using var archive = ArchiveFactory.Open(byteStream);
using var lc = new MetadataLoadContext(new ZipAssemblyResolver(archive, coreAssembly), coreAssembly.FullName);
foreach (var archiveEntry in archive.Entries)
{
if (archiveEntry.IsDirectory ||
(!archiveEntry.Key.EndsWith(".dll", StringComparison.InvariantCultureIgnoreCase) && !archiveEntry.Key.EndsWith(".exe", StringComparison.InvariantCultureIgnoreCase)))
{
continue;
}
System.Reflection.Assembly assembly;
using var entryStream = archiveEntry.ExtractToStream();
try
{
assembly = lc.LoadFromStream(entryStream);
}
catch (FileLoadException)
{
Logger.LogError($"{packageEntity.Name} (v{packageVersionEntity.Version}) - {archiveEntry.Key} - could not be loaded.");
continue;
}
catch (Exception e)
{
Logger.LogError(e, $"{packageEntity.Name} (v{packageVersionEntity.Version}) - {archiveEntry.Key} - threw an exception.");
continue;
}
foreach (var referencedAssembly in assembly.GetReferencedAssemblies())
{
if (!uniqueAssemblies.ContainsKey(referencedAssembly.FullName))
{
uniqueAssemblies.Add(referencedAssembly.FullName, referencedAssembly);
}
}
var assemblyName = assembly.GetName();
Logger.LogDebug($"Processing assembly {assemblyName.Name}, version={assemblyName.Version}");
var assemblyEntity = GetOrAddAssemblyEntity(assemblyName);
var assemblyVersionEntity = GetOrAddAssemblyVersionEntity(assemblyEntity, assemblyName);
var packageAssemblyVersionEntity = GetOrAddPackageAssemblyVersionEntity(packageEntity, packageVersionEntity, assemblyEntity, assemblyVersionEntity);
packageAssemblyVersionEntity.ReferenceIncluded = true;
}
foreach (var uniqueAssembly in uniqueAssemblies.Values)
{
Logger.LogDebug($"Processing referenced assembly {uniqueAssembly.Name}, version={uniqueAssembly.Version}");
var assemblyEntity = GetOrAddAssemblyEntity(uniqueAssembly);
var assemblyVersionEntity = GetOrAddAssemblyVersionEntity(assemblyEntity, uniqueAssembly);
GetOrAddPackageAssemblyVersionEntity(packageEntity, packageVersionEntity, assemblyEntity, assemblyVersionEntity);
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
// SerializedVersion format changed during renaming upgrade. However, before this was merged back in master, some asset upgrader still with older version numbers were developed.
// As a result, sprite component upgrade is not needed for version 19 and 20, and physics component upgrade is not needed for version 20
var version19 = PackageVersion.Parse("0.0.19");
var version20 = PackageVersion.Parse("0.0.20");
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Entities;
foreach (dynamic entity in entities)
{
var components = entity.Entity.Components;
var spriteComponent = components["SpriteComponent.Key"];
if (spriteComponent != null && (currentVersion != version19 && currentVersion != version20))
{
var color = spriteComponent.Color;
spriteComponent.Color = DynamicYamlExtensions.ConvertFrom((Color4)DynamicYamlExtensions.ConvertTo <Color>(color));
}
var physComponent = components["PhysicsComponent.Key"];
if (physComponent != null && (currentVersion != version20))
{
foreach (dynamic element in physComponent.Elements)
{
if (element.Node.Tag == "!TriggerElement")
{
element.Node.Tag = "!StaticColliderElement";
element.IsTrigger = true;
}
}
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile)
{
// SerializedVersion format changed during renaming upgrade. However, before this was merged back in master, some asset upgrader still with older version numbers were developed.
// However since this upgrader can be reapplied, it is not a problem
var proceduralType = asset.Type;
if (proceduralType.Node.Tag == "!CapsuleProceduralModel" && currentVersion != PackageVersion.Parse("0.0.6"))
{
if (proceduralType.Radius == null)
{
proceduralType.Radius = 0.25f;
}
}
}
public void Run(IBackgroundTaskInstance taskInstance)
{
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
this.logging.LogEvent("Application starting");
// Log the Application build, OS version information etc.
LoggingFields startupInformation = new LoggingFields();
startupInformation.AddString("Timezone", TimeZoneSettings.CurrentTimeZoneDisplayName);
startupInformation.AddString("OSVersion", Environment.OSVersion.VersionString);
startupInformation.AddString("MachineName", Environment.MachineName);
// This is from the application manifest
Package package = Package.Current;
PackageId packageId = package.Id;
PackageVersion version = packageId.Version;
startupInformation.AddString("ApplicationVersion", string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}"));
try
{
// see if the configuration file is present if not copy minimal sample one from application directory
if (localFolder.TryGetItemAsync(ConfigurationFilename).AsTask().Result == null)
{
StorageFile templateConfigurationfile = Package.Current.InstalledLocation.GetFileAsync(ConfigurationFilename).AsTask().Result;
templateConfigurationfile.CopyAsync(localFolder, ConfigurationFilename).AsTask();
}
IConfiguration configuration = new ConfigurationBuilder().AddJsonFile(Path.Combine(localFolder.Path, ConfigurationFilename), false, true).Build();
this.azureCognitiveServicesEndpoint = configuration.GetSection("AzureCognitiveServicesEndpoint").Value;
startupInformation.AddString("AzureCognitiveServicesEndpoint", this.azureCognitiveServicesEndpoint);
this.azureCognitiveServicesSubscriptionKey = configuration.GetSection("AzureCognitiveServicesSubscriptionKey").Value;
startupInformation.AddString("AzureCognitiveServicesSubscriptionKey", this.azureCognitiveServicesSubscriptionKey);
foreach (string categoryName in configuration.GetSection("ComputerVisionCategoryNames").Value.Split(','))
{
this.categoryList.Add(new Category(name: categoryName));
}
this.interruptPinNumber = int.Parse(configuration.GetSection("InterruptPinNumber").Value);
startupInformation.AddInt32("Interrupt pin", this.interruptPinNumber);
this.interruptTriggerOn = (GpioPinEdge)Enum.Parse(typeof(GpioPinEdge), configuration.GetSection("interruptTriggerOn").Value);
startupInformation.AddString("Interrupt Trigger on", this.interruptTriggerOn.ToString());
this.displayPinNumber = int.Parse(configuration.GetSection("DisplayPinNumber").Value);
startupInformation.AddInt32("Display pin", this.interruptPinNumber);
this.debounceTimeout = TimeSpan.Parse(configuration.GetSection("debounceTimeout").Value);
startupInformation.AddTimeSpan("Debounce timeout", this.debounceTimeout);
}
catch (Exception ex)
{
this.logging.LogMessage("JSON configuration file load or settings retrieval failed " + ex.Message, LoggingLevel.Error);
return;
}
try
{
this.computerVisionClient = new ComputerVisionClient(
new Microsoft.Azure.CognitiveServices.Vision.ComputerVision.ApiKeyServiceClientCredentials(this.azureCognitiveServicesSubscriptionKey),
new System.Net.Http.DelegatingHandler[] { })
{
Endpoint = this.azureCognitiveServicesEndpoint,
};
}
catch (Exception ex)
{
this.logging.LogMessage("Azure Cognitive Services Computer Vision client configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
try
{
this.mediaCapture = new MediaCapture();
this.mediaCapture.InitializeAsync().AsTask().Wait();
}
catch (Exception ex)
{
this.logging.LogMessage("Camera configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
this.displayOffTimer = new Timer(this.TimerCallback, null, Timeout.Infinite, Timeout.Infinite);
try
{
GpioController gpioController = GpioController.GetDefault();
this.interruptGpioPin = gpioController.OpenPin(this.interruptPinNumber);
this.interruptGpioPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
this.interruptGpioPin.ValueChanged += this.InterruptGpioPin_ValueChanged;
this.displayGpioPin = gpioController.OpenPin(this.displayPinNumber);
this.displayGpioPin.SetDriveMode(GpioPinDriveMode.Output);
this.displayGpioPin.Write(GpioPinValue.Low);
}
catch (Exception ex)
{
this.logging.LogMessage("Digital input configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
this.logging.LogEvent("Application started", startupInformation);
// enable task to continue running in background
this.backgroundTaskDeferral = taskInstance.GetDeferral();
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile)
{
var proceduralType = asset.Type;
if (proceduralType.Node.Tag == "!CapsuleProceduralModel" && proceduralType.Height != null)
{
proceduralType.Length = 2f * (float)proceduralType.Height;
proceduralType.Height = DynamicYamlEmpty.Default;
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var entities = asset.Hierarchy.Entities;
var designEntities = new YamlSequenceNode();
asset.Hierarchy.Entities = designEntities;
foreach (var entity in entities)
{
var designEntity = new YamlMappingNode();
dynamic dynamicDesignEntity = new DynamicYamlMapping(designEntity);
dynamicDesignEntity.Entity = entity;
designEntities.Add(designEntity);
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var packing = asset.Packing;
if (packing != null)
{
packing.AtlasMaximumSize = DynamicYamlEmpty.Default;
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
// SerializedVersion format changed during renaming upgrade. However, before this was merged back in master, some asset upgrader still with older version numbers were developed.
// As a result, upgrade is not needed for version 3
var sprites = asset.Sprites;
if (sprites == null || currentVersion == PackageVersion.Parse("0.0.3"))
{
return;
}
foreach (var sprite in asset.Sprites)
{
if (sprite.Borders == null)
{
continue;
}
var y = sprite.Borders.Y ?? 0.0f;
sprite.Borders.Y = sprite.Borders.Z ?? 0.0f;
sprite.Borders.Z = y;
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Entities;
var mapEntityComponents = new Dictionary <string, Dictionary <string, Tuple <string, dynamic> > >();
var newScriptComponentsPerEntity = new Dictionary <string, List <dynamic> >();
var newPhysicsComponentsPerEntity = new Dictionary <string, List <dynamic> >();
// Collect current order of known components
// We will use this order to add components in order to the new component list
var mapComponentOrder = new Dictionary <string, int>();
var knownComponentTypes = SiliconStudio.Core.Extensions.TypeDescriptorExtensions.GetInheritedInstantiableTypes(typeof(EntityComponent));
const int defaultComponentOrder = 2345;
foreach (var knownComponent in knownComponentTypes)
{
var componentName = knownComponent.GetCustomAttribute <DataContractAttribute>()?.Alias;
if (componentName == null)
{
continue;
}
var order = knownComponent.GetCustomAttribute <ComponentOrderAttribute>(true)?.Order ?? defaultComponentOrder;
mapComponentOrder[componentName] = order;
}
mapComponentOrder["ScriptComponent"] = 1000;
// --------------------------------------------------------------------------------------------
// 1) Collect all components ids and key/types, collect all scripts
// --------------------------------------------------------------------------------------------
foreach (dynamic entityAndDesign in entities)
{
var entity = entityAndDesign.Entity;
var entityId = (string)entity.Id;
var newComponents = new Dictionary <string, Tuple <string, dynamic> >();
mapEntityComponents.Add(entityId, newComponents);
foreach (var component in entity.Components)
{
var componentKey = (string)component.Key;
if (componentKey == "ScriptComponent.Key")
{
var newScripts = new List <dynamic>();
newScriptComponentsPerEntity.Add(entityId, newScripts);
foreach (var script in component.Value.Scripts)
{
newScripts.Add(script);
}
}
else if (componentKey == "PhysicsComponent.Key")
{
var newPhysics = new List <dynamic>();
newPhysicsComponentsPerEntity.Add(entityId, newPhysics);
foreach (var newPhysic in component.Value.Elements)
{
newPhysics.Add(newPhysic);
}
}
else
{
componentKey = GetComponentNameFromKey(componentKey);
var componentValue = component.Value;
var componentId = (string)componentValue["~Id"];
newComponents.Add(componentKey, new Tuple <string, dynamic>(componentId, componentValue));
}
}
}
// --------------------------------------------------------------------------------------------
// 2) Collect all components ids and key/types
// --------------------------------------------------------------------------------------------
foreach (dynamic entityAndDesign in entities)
{
var entity = entityAndDesign.Entity;
var entityId = (string)entity.Id;
var newComponents = mapEntityComponents[entityId];
// Order components
var orderedComponents = newComponents.ToList();
// Convert scripts to ScriptComponents
List <dynamic> scripts;
if (newScriptComponentsPerEntity.TryGetValue(entityId, out scripts))
{
foreach (var component in scripts)
{
// Update Script to ScriptComponent
var componentId = (string)component.Id;
component.RemoveChild("Id");
component["~Id"] = componentId;
var componentNode = (DynamicYamlMapping)component;
var componentType = componentNode.Node.Tag.Substring(1);
orderedComponents.Add(new KeyValuePair <string, Tuple <string, dynamic> >(componentType, new Tuple <string, dynamic>(componentId, component)));
}
}
// Convert PhysicsElements to PhysicsComponents
List <dynamic> physics;
if (newPhysicsComponentsPerEntity.TryGetValue(entityId, out physics))
{
foreach (var component in physics)
{
// Update Script to ScriptComponent
var componentId = (string)component["~Id"];
var componentNode = (DynamicYamlMapping)component;
var componentType = componentNode.Node.Tag.Substring(1);
componentType = componentType.Replace("Element", "Component");
orderedComponents.Add(new KeyValuePair <string, Tuple <string, dynamic> >(componentType, new Tuple <string, dynamic>(componentId, component)));
}
}
// Order components
orderedComponents.Sort((left, right) =>
{
int leftOrder;
if (!mapComponentOrder.TryGetValue(left.Key, out leftOrder))
{
leftOrder = defaultComponentOrder;
}
int rightOrder;
if (!mapComponentOrder.TryGetValue(right.Key, out rightOrder))
{
rightOrder = defaultComponentOrder;
}
return(leftOrder.CompareTo(rightOrder));
});
// Reset previous component mapping
entity.Components = new DynamicYamlArray(new YamlSequenceNode());
foreach (var item in orderedComponents)
{
var componentKey = item.Key;
var component = (DynamicYamlMapping)item.Value.Item2;
component.Node.Tag = "!" + componentKey;
// Fix any component references.
FixEntityComponentReferences(component, mapEntityComponents);
entity.Components.Add(item.Value.Item2);
}
}
// Fix also component references in the settings
if (asset.SceneSettings != null)
{
FixEntityComponentReferences(asset.SceneSettings, mapEntityComponents);
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Entities;
foreach (dynamic entityAndDesign in entities)
{
var entity = entityAndDesign.Entity;
foreach (var component in entity.Components)
{
var componentTag = component.Node.Tag;
if (componentTag == "!ParticleSystemComponent")
{
dynamic particleSystem = component.ParticleSystem;
if (particleSystem != null)
{
foreach (dynamic emitter in particleSystem.Emitters)
{
// Lifetime changed from: float (ParticleMinLifetime), float (ParticleMaxLifetime) -> Vector2 (ParticleLifetime)
dynamic lifetime = new DynamicYamlMapping(new YamlMappingNode());
lifetime.AddChild("X", emitter.ParticleMinLifetime);
lifetime.AddChild("Y", emitter.ParticleMaxLifetime);
emitter.AddChild("ParticleLifetime", lifetime);
emitter.RemoveChild("ParticleMinLifetime");
emitter.RemoveChild("ParticleMaxLifetime");
// Initializers
foreach (dynamic initializer in emitter.Initializers)
{
var initializerTag = initializer.Node.Tag;
if (initializerTag == "!InitialRotationSeed")
{
dynamic angle = new DynamicYamlMapping(new YamlMappingNode());
angle.AddChild("X", initializer.AngularRotationMin);
angle.AddChild("Y", initializer.AngularRotationMax);
initializer.AddChild("AngularRotation", angle);
initializer.RemoveChild("AngularRotationMin");
initializer.RemoveChild("AngularRotationMax");
}
}
// Updaters
foreach (dynamic updater in emitter.Updaters)
{
var updaterTag = updater.Node.Tag;
if (updaterTag == "!UpdaterCollider")
{
var isSolid = (bool)updater.IsSolid;
updater.AddChild("IsHollow", !isSolid);
updater.RemoveChild("IsSolid");
}
}
}
}
}
}
}
}
public void Run(IBackgroundTaskInstance taskInstance)
{
StorageFolder localFolder = ApplicationData.Current.LocalFolder;
this.logging.LogEvent("Application starting");
// Log the Application build, OS version information etc.
LoggingFields startupInformation = new LoggingFields();
startupInformation.AddString("Timezone", TimeZoneSettings.CurrentTimeZoneDisplayName);
startupInformation.AddString("OSVersion", Environment.OSVersion.VersionString);
startupInformation.AddString("MachineName", Environment.MachineName);
// This is from the application manifest
Package package = Package.Current;
PackageId packageId = package.Id;
PackageVersion version = packageId.Version;
startupInformation.AddString("ApplicationVersion", string.Format($"{version.Major}.{version.Minor}.{version.Build}.{version.Revision}"));
try
{
// see if the configuration file is present if not copy minimal sample one from application directory
if (localFolder.TryGetItemAsync(ConfigurationFilename).AsTask().Result == null)
{
StorageFile templateConfigurationfile = Package.Current.InstalledLocation.GetFileAsync(ConfigurationFilename).AsTask().Result;
templateConfigurationfile.CopyAsync(localFolder, ConfigurationFilename).AsTask();
this.logging.LogMessage("JSON configuration file missing, templated created", LoggingLevel.Warning);
return;
}
IConfiguration configuration = new ConfigurationBuilder().AddJsonFile(Path.Combine(localFolder.Path, ConfigurationFilename), false, true).Build();
this.localStorageimageFilenameLatestFormat = configuration.GetSection("LocalImageFilenameFormatLatest").Value;
startupInformation.AddString("ImageFilenameLatestFormat", this.localStorageimageFilenameLatestFormat);
this.localStorageImageFilenameHistoryFormat = configuration.GetSection("LocalImageFilenameFormatHistoric").Value;
startupInformation.AddString("ImageFilenameLatestFormat", this.localStorageImageFilenameHistoryFormat);
this.interruptPinNumber = int.Parse(configuration.GetSection("InterruptPinNumber").Value);
startupInformation.AddInt32("Interrupt pin", this.interruptPinNumber);
this.interruptTriggerOn = (GpioPinEdge)Enum.Parse(typeof(GpioPinEdge), configuration.GetSection("interruptTriggerOn").Value);
startupInformation.AddString("Interrupt Trigger on", this.interruptTriggerOn.ToString());
this.debounceTimeout = TimeSpan.Parse(configuration.GetSection("debounceTimeout").Value);
startupInformation.AddTimeSpan("Debounce timeout", this.debounceTimeout);
}
catch (Exception ex)
{
this.logging.LogMessage("JSON configuration file load or settings retrieval failed " + ex.Message, LoggingLevel.Error);
return;
}
try
{
this.mediaCapture = new MediaCapture();
this.mediaCapture.InitializeAsync().AsTask().Wait();
}
catch (Exception ex)
{
this.logging.LogMessage("Camera configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
try
{
GpioController gpioController = GpioController.GetDefault();
this.interruptGpioPin = gpioController.OpenPin(this.interruptPinNumber);
this.interruptGpioPin.SetDriveMode(GpioPinDriveMode.InputPullUp);
this.interruptGpioPin.ValueChanged += this.InterruptGpioPin_ValueChanged;
}
catch (Exception ex)
{
this.logging.LogMessage("Digital input configuration failed " + ex.Message, LoggingLevel.Error);
return;
}
this.logging.LogEvent("Application started", startupInformation);
// enable task to continue running in background
this.backgroundTaskDeferral = taskInstance.GetDeferral();
}
public void Upgrade(AssetMigrationContext context, string dependencyName, PackageVersion currentVersion, PackageVersion targetVersion, YamlMappingNode yamlAssetNode, PackageLoadingAssetFile assetFile)
{
dynamic asset = new DynamicYamlMapping(yamlAssetNode);
var baseBranch = asset[Asset.BaseProperty];
if (baseBranch != null)
{
asset[BaseProperty] = DynamicYamlEmpty.Default;
}
AssetUpgraderBase.SetSerializableVersion(asset, dependencyName, targetVersion);
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var hierarchy = asset.Hierarchy;
var entities = (DynamicYamlArray)hierarchy.Entities;
foreach (dynamic entity in entities)
{
var components = entity.Components;
var spriteComponent = components["SpriteComponent.Key"];
if (spriteComponent != null)
{
var provider = spriteComponent.SpriteProvider;
var providerAsMap = provider as DynamicYamlMapping;
if (providerAsMap != null && providerAsMap.Node.Tag == "!SpriteFromSpriteGroup")
{
provider.Sheet = provider.SpriteGroup;
provider.SpriteGroup = DynamicYamlEmpty.Default;
providerAsMap.Node.Tag = "!SpriteFromSheet";
}
}
}
}
internal async void ExecutePackageDownload(string name, PackageVersion package, string installPath)
{
string msg = String.IsNullOrEmpty(installPath) ?
String.Format(Resources.MessageConfirmToInstallPackage, name, package.version) :
String.Format(Resources.MessageConfirmToInstallPackageToFolder, name, package.version, installPath);
var result = MessageBoxService.Show(msg,
Resources.PackageDownloadConfirmMessageBoxTitle,
MessageBoxButton.OKCancel, MessageBoxImage.Question);
var pmExt = DynamoViewModel.Model.GetPackageManagerExtension();
if (result == MessageBoxResult.OK)
{
Debug.Assert(package.full_dependency_ids.Count == package.full_dependency_versions.Count);
// get all of the dependency version headers
// we reverse these arrays because the package manager returns dependencies in topological order starting at
// the current package - and we want to install the dependencies first!.
var reversedVersions = package.full_dependency_versions.Select(x => x).Reverse().ToList();
var dependencyVersionHeaders = package.full_dependency_ids.Select(x => x).Reverse().Select((dep, i) =>
{
var depVersion = reversedVersions[i];
try
{
return(Model.GetPackageVersionHeader(dep._id, depVersion));
}
catch
{
MessageBoxService.Show(
String.Format(Resources.MessageFailedToDownloadPackageVersion, depVersion, dep._id),
Resources.PackageDownloadErrorMessageBoxTitle,
MessageBoxButton.OK, MessageBoxImage.Error);
return(null);
}
}).ToList();
// if any header download fails, abort
if (dependencyVersionHeaders.Any(x => x == null))
{
return;
}
var localPkgs = pmExt.PackageLoader.LocalPackages;
var uninstallsRequiringRestart = new List <Package>();
var uninstallRequiringUserModifications = new List <Package>();
var immediateUninstalls = new List <Package>();
var builtinPackages = new List <Package>();
// if the new package has one or more dependencies that are already installed
// we need to either first uninstall them, or allow the user to forcibly install the package,
// or cancel the installation if they do not want either of the first two options.
// local package that conflicts with package itself.
Package duplicatePackage = null;
// list of local packages that conflict (have different versions) with package dependencies.
var localPkgsConflictingWithPkgDeps = new List <Package>();
var newPackageHeaders = new List <PackageVersion>();
foreach (var dependencyHeader in dependencyVersionHeaders)
{
bool isHeaderDuplicate = false;
foreach (var localPkg in localPkgs)
{
if (localPkg.Name == dependencyHeader.name)
{
if (localPkg.Name == name)
{
duplicatePackage = localPkg;
break;
}
isHeaderDuplicate = true;
if (localPkg.VersionName != dependencyHeader.version)
{
localPkgsConflictingWithPkgDeps.Add(localPkg);
}
}
}
if (duplicatePackage != null)
{
break;
}
if (!isHeaderDuplicate)
{
newPackageHeaders.Add(dependencyHeader);
}
}
WarnAboutDuplicatePackageConflicts(name, package, duplicatePackage);
foreach (var pkg in localPkgsConflictingWithPkgDeps)
{
if (pkg == null)
{
continue;
}
if (pkg.BuiltInPackage)
{
builtinPackages.Add(pkg);
continue;
}
if (pkg.LoadedAssemblies.Any())
{
uninstallsRequiringRestart.Add(pkg);
continue;
}
if (pkg.InUse(DynamoViewModel.Model))
{
uninstallRequiringUserModifications.Add(pkg);
continue;
}
immediateUninstalls.Add(pkg);
}
// determine if any of the packages contain binaries or python scripts.
var containsBinariesOrPythonScripts = dependencyVersionHeaders.Any(x =>
{
// The contents (string) property of the PackageVersion object can be null for an empty package
// like LunchBox.
var are_contents_empty = string.IsNullOrEmpty(x.contents);
var contains_binaries = x.contains_binaries ||
!are_contents_empty && x.contents.Contains(PackageManagerClient.PackageContainsBinariesConstant);
var contains_python =
!are_contents_empty && x.contents.Contains(PackageManagerClient.PackageContainsPythonScriptsConstant);
return(contains_binaries || contains_python);
});
// if any do, notify user and allow cancellation
if (containsBinariesOrPythonScripts)
{
var res = MessageBoxService.Show(Resources.MessagePackageContainPythonScript,
Resources.PackageDownloadMessageBoxTitle,
MessageBoxButton.OKCancel, MessageBoxImage.Exclamation);
if (res == MessageBoxResult.Cancel)
{
return;
}
}
var packageToDownload = $"{name} {package.version}";
if (builtinPackages.Any())
{
// Conflicts with builtin packages
var message = string.Format(Resources.MessagePackageDepsInBuiltinPackages, packageToDownload,
JoinPackageNames(builtinPackages));
var dialogResult = MessageBoxService.Show(message,
Resources.BuiltInPackageConflictMessageBoxTitle,
MessageBoxButton.OKCancel, MessageBoxImage.Exclamation);
if (dialogResult == MessageBoxResult.Cancel)
{
return;
}
}
// Determine if there are any dependencies that are made with a newer version
// of Dynamo (this includes the root package)
var dynamoVersion = VersionUtilities.PartialParse(DynamoViewModel.Model.Version);
var futureDeps = dependencyVersionHeaders.Where(dep => VersionUtilities.PartialParse(dep.engine_version) > dynamoVersion);
// If any of the required packages use a newer version of Dynamo, show a dialog to the user
// allowing them to cancel the package download
if (futureDeps.Any())
{
if (MessageBoxService.Show(string.Format(Resources.MessagePackageNewerDynamo, DynamoViewModel.BrandingResourceProvider.ProductName),
string.Format(Resources.PackageUseNewerDynamoMessageBoxTitle, DynamoViewModel.BrandingResourceProvider.ProductName),
MessageBoxButton.OKCancel,
MessageBoxImage.Warning) == MessageBoxResult.Cancel)
{
return;
}
}
if (uninstallRequiringUserModifications.Any())
{
var conflictingPkgs = JoinPackageNames(uninstallRequiringUserModifications);
var message = string.Format(Resources.MessageForceInstallOrUninstallToContinue, packageToDownload, conflictingPkgs,
DynamoViewModel.BrandingResourceProvider.ProductName);
var dialogResult = MessageBoxService.Show(message,
Resources.PackagesInUseConflictMessageBoxTitle,
MessageBoxButton.YesNo, MessageBoxImage.Exclamation);
if (dialogResult == MessageBoxResult.No)
{
return;
}
}
var settings = DynamoViewModel.Model.PreferenceSettings;
if (uninstallsRequiringRestart.Any())
{
var conflictingPkgs = JoinPackageNames(uninstallsRequiringRestart);
var message = string.Format(Resources.MessageForceInstallOrUninstallUponRestart, packageToDownload,
conflictingPkgs, DynamoViewModel.BrandingResourceProvider.ProductName);
var dialogResult = MessageBoxService.Show(message,
Resources.LoadedPackagesConflictMessageBoxTitle,
MessageBoxButton.YesNoCancel, MessageBoxImage.Exclamation);
if (dialogResult == MessageBoxResult.No)
{
// mark for uninstallation
uninstallsRequiringRestart.ForEach(x => x.MarkForUninstall(settings));
return;
}
else if (dialogResult == MessageBoxResult.Cancel)
{
return;
}
}
if (immediateUninstalls.Any())
{
// if the package is not in use, tell the user we will uninstall it and give them the opportunity to cancel
var message = String.Format(Resources.MessageAlreadyInstallDynamo,
DynamoViewModel.BrandingResourceProvider.ProductName,
JoinPackageNames(immediateUninstalls), packageToDownload);
var dialogResult = MessageBoxService.Show(message,
Resources.DownloadWarningMessageBoxTitle, MessageBoxButton.OKCancel, MessageBoxImage.Warning);
if (dialogResult == MessageBoxResult.Cancel)
{
return;
}
}
// add custom path to custom package folder list
if (!String.IsNullOrEmpty(installPath))
{
if (!settings.CustomPackageFolders.Contains(installPath))
{
settings.CustomPackageFolders.Add(installPath);
}
}
// form header version pairs and download and install all packages
var downloadTasks = newPackageHeaders
.Select((dep) => {
return(new PackageDownloadHandle()
{
Id = dep.id,
VersionName = dep.version,
Name = dep.name
});
})
.Select(x => Download(x)).ToArray();
//wait for all downloads.
await Task.WhenAll(downloadTasks);
// When above downloads complete, start installing packages in dependency order.
// The downloads have completed in a random order, but the dependencyVersionHeaders list is in correct topological
// install order.
foreach (var dep in newPackageHeaders)
{
var matchingDownload = downloadTasks.Where(x => x.Result.handle.Id == dep.id).FirstOrDefault();
if (matchingDownload != null)
{
InstallPackage(matchingDownload.Result.handle, matchingDownload.Result.downloadPath, installPath);
}
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
var images = asset.Images;
if (images != null)
{
asset.Sprites = images;
asset.Images = DynamicYamlEmpty.Default;
}
}
protected abstract void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile);
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
if (asset.ColliderShapes == null)
{
return;
}
foreach (var colliderShape in asset.ColliderShapes)
{
if (colliderShape.Node.Tag == "!Box2DColliderShapeDesc")
{
var size = 2f * DynamicYamlExtensions.ConvertTo <Vector2>(colliderShape.HalfExtent);
colliderShape.Size = DynamicYamlExtensions.ConvertFrom(size);
colliderShape.HalfExtent = DynamicYamlEmpty.Default;
}
if (colliderShape.Node.Tag == "!BoxColliderShapeDesc")
{
var size = 2f * DynamicYamlExtensions.ConvertTo <Vector3>(colliderShape.HalfExtents);
colliderShape.Size = DynamicYamlExtensions.ConvertFrom(size);
colliderShape.HalfExtents = DynamicYamlEmpty.Default;
}
if (colliderShape.Node.Tag == "!CapsuleColliderShapeDesc" || colliderShape.Node.Tag == "!CylinderColliderShapeDesc")
{
var upVector = DynamicYamlExtensions.ConvertTo <Vector3>(colliderShape.UpAxis);
if (upVector == Vector3.UnitX)
{
colliderShape.Orientation = ShapeOrientation.UpX;
}
if (upVector == Vector3.UnitZ)
{
colliderShape.Orientation = ShapeOrientation.UpZ;
}
colliderShape.UpAxis = DynamicYamlEmpty.Default;
}
if (colliderShape.Node.Tag == "!CapsuleColliderShapeDesc" && colliderShape.Height != null)
{
colliderShape.Length = 2f * (float)colliderShape.Height;
colliderShape.Height = DynamicYamlEmpty.Default;
}
if (colliderShape.Node.Tag == "!CylinderColliderShapeDesc")
{
colliderShape.Radius = (float)colliderShape.HalfExtents.X;
colliderShape.Height = 2f * (float)colliderShape.HalfExtents.Y;
colliderShape.HalfExtents = DynamicYamlEmpty.Default;
}
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile)
{
if (asset.NoPremultiply != null)
{
asset.IsPremultiplied = !(bool)asset.NoPremultiply;
asset.NoPremultiply = DynamicYamlEmpty.Default;
}
if (asset.IsNotPremultiply != null)
{
asset.IsPremultiplied = !(bool)asset.IsNotPremultiply;
asset.IsNotPremultiply = DynamicYamlEmpty.Default;
}
}
protected override void UpgradeAsset(AssetMigrationContext context, PackageVersion currentVersion, PackageVersion targetVersion, dynamic asset, PackageLoadingAssetFile assetFile, OverrideUpgraderHint overrideHint)
{
if (asset.ColliderShapes == null)
{
return;
}
foreach (dynamic shape in asset.ColliderShapes)
{
var tag = shape.Node.Tag;
if (tag != "!Box2DColliderShapeDesc")
{
continue;
}
shape.Node.Tag = "!BoxColliderShapeDesc";
shape.Is2D = true;
shape.Size.X = shape.Size.X;
shape.Size.Y = shape.Size.Y;
shape.Size.Z = 0.01f;
}
}
