protected override void PostAssetCreation(AssetTemplateGeneratorParameters parameters, AssetItem assetItem)
{
base.PostAssetCreation(parameters, assetItem);
var material = parameters.GetTag(MaterialKey);
((PrimitiveProceduralModelBase)((ProceduralModelAsset)assetItem.Asset).Type).MaterialInstance.Material = material;
}
/// <inheritdoc />
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
var importedAssets = new List <AssetItem>();
foreach (var assetItem in base.CreateAssets(parameters))
{
if (assetItem.Asset is SoundAsset soundAsset)
{
using (var media = new FFmpegMedia())
{
media.Open(soundAsset.Source.ToWindowsPath());
var audioStreams = media.Streams.OfType <AudioStream>().ToList();
foreach (var audioTrack in audioStreams)
{
var assetCopy = AssetCloner.Clone(soundAsset);
assetCopy.Index = audioTrack.Index;
assetCopy.SampleRate = audioTrack.SampleRate;
// If there's more than one streams, append the track index to the asset name
var fileLocation = audioStreams.Count > 1
? (UFile)(assetItem.Location + " track " + audioTrack.Index)
: assetItem.Location;
importedAssets.Add(new AssetItem(fileLocation, assetCopy));
}
}
}
}
return(MakeUniqueNames(importedAssets));
}
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
var files = parameters.Tags.Get(SourceFilesPathKey);
if (files == null)
{
return(base.CreateAssets(parameters));
}
var importParameters = new AssetImporterParameters {
Logger = parameters.Logger
};
importParameters.SelectedOutputTypes.Add(typeof(SkeletonAsset), true);
var importedAssets = new List <AssetItem>();
foreach (var file in files)
{
// TODO: should we allow to select the importer?
var importer = AssetRegistry.FindImporterForFile(file).OfType <ModelAssetImporter>().FirstOrDefault();
if (importer == null)
{
parameters.Logger.Warning($"No importer found for file \"{file}\"");
continue;
}
var assets = importer.Import(file, importParameters).Select(x => new AssetItem(UPath.Combine(parameters.TargetLocation, x.Location), x.Asset)).ToList();
// Create unique names amongst the list of assets
importedAssets.AddRange(MakeUniqueNames(assets));
}
return(importedAssets);
}
protected override void PostAssetCreation(AssetTemplateGeneratorParameters parameters, AssetItem assetItem)
{
base.PostAssetCreation(parameters, assetItem);
var model = parameters.GetTag(ModelKey);
((ConvexHullColliderShapeDesc)((ColliderShapeAsset)assetItem.Asset).ColliderShapes[0]).Model = model;
}
protected override void PostAssetCreation(AssetTemplateGeneratorParameters parameters, AssetItem assetItem)
{
base.PostAssetCreation(parameters, assetItem);
var texture = parameters.GetTag(TextureKey);
((SkyboxAsset)assetItem.Asset).CubeMap = texture;
}
/// <inheritdoc />
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
var importedAssets = new List <AssetItem>();
foreach (var assetItem in base.CreateAssets(parameters))
{
if (assetItem.Asset is SoundAsset soundAsset)
{
using (var media = new FFmpegMedia())
{
media.Open(soundAsset.Source.ToWindowsPath());
foreach (var audioTrack in media.Streams.OfType <AudioStream>().ToList())
{
var assetCopy = AssetCloner.Clone(soundAsset);
assetCopy.Index = audioTrack.Index;
assetCopy.SampleRate = audioTrack.SampleRate;
importedAssets.Add(new AssetItem(assetItem.Location + (audioTrack.Index > 0 ? " track " + audioTrack.Index : ""), assetCopy));
}
}
}
}
return(MakeUniqueNames(importedAssets));
}
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
var sources = parameters.Tags.Get(SourceFilesPathKey);
if (sources == null)
{
return(base.CreateAssets(parameters));
}
var assets = new List <AssetItem>();
var defaultName = parameters.Name;
foreach (var source in sources)
{
// Use the source file name for the asset name if it is valid
parameters.Name = source.GetFileNameWithoutExtension();
if (string.IsNullOrWhiteSpace(parameters.Name))
{
parameters.Name = defaultName;
}
var assetImport = base.CreateAssets(parameters).First();
((IAssetWithSource)assetImport.Asset).Source = source;
assets.Add(assetImport);
}
return(assets);
}
/// <inheritdoc />
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
var files = parameters.Tags.Get(SourceFilesPathKey);
if (files == null)
{
return(base.CreateAssets(parameters));
}
var importedAssets = new List <AssetItem>();
foreach (var file in files)
{
using (var media = new FFmpegMedia())
{
media.Open(file.ToWindowsPath());
var videoStream = media.Streams.OfType <VideoStream>().FirstOrDefault();
if (videoStream != null)
{
var videoItem = ImportVideo(file, videoStream);
importedAssets.Add(videoItem);
}
}
}
return(MakeUniqueNames(importedAssets));
}
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
var sources = parameters.Tags.Get(SourceFilesPathKey);
if (sources == null)
{
return(base.CreateAssets(parameters));
}
SpriteSheetAsset asset;
if (parameters.Description.Id == SpriteSheetId)
{
asset = SpriteSheetSprite2DFactory.Create();
}
else if (parameters.Description.Id == UISpriteSheetId)
{
asset = SpriteSheetUIFactory.Create();
}
else
{
throw new ArgumentException("Invalid template description for this generator.");
}
using (var textureTool = new TextureTool())
{
foreach (var source in sources)
{
int width = 0;
int height = 0;
parameters.Logger.Verbose($"Processing image \"{source}\"");
try
{
var image = textureTool.Load(source.ToString(), false);
width = image.Width;
height = image.Height;
}
catch (Exception)
{
parameters.Logger.Warning($"Unable to retrieve the size of \"{source}\"");
}
var spriteInfo = new SpriteInfo
{
Name = source.GetFileNameWithoutExtension(),
TextureRegion = new Rectangle(0, 0, width, height),
Source = source
};
asset.Sprites.Add(spriteInfo);
}
}
return(new AssetItem(GenerateLocation(parameters), asset).Yield());
}
protected override async Task <bool> PrepareAssetCreation(AssetTemplateGeneratorParameters parameters)
{
if (!await base.PrepareAssetCreation(parameters))
{
return(false);
}
var modelViewModel = await BrowseForAsset(parameters.Package, new[] { typeof(IModelAsset) }, new UFile(parameters.Name).GetFullDirectory(), "Select a model to use to generate the hull - _cancel to leave the model empty_");
var model = ContentReferenceHelper.CreateReference <Model>(modelViewModel);
parameters.SetTag(ModelKey, model);
return(true);
}
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
// Find default graphics compositor to create a derived asset from
var graphicsCompositor = SupportedTemplatesToUrl.TryGetValue(parameters.Description.Id, out var graphicsCompositorUrl) ? parameters.Package.FindAsset(graphicsCompositorUrl) : null;
// Something went wrong, create an empty asset
if (graphicsCompositor == null)
{
return(base.CreateAssets(parameters));
}
// Create derived asset
return(new[] { new AssetItem(GenerateLocation(parameters), graphicsCompositor.CreateDerivedAsset()) });
}
protected override async Task <bool> PrepareAssetCreation(AssetTemplateGeneratorParameters parameters)
{
if (!await base.PrepareAssetCreation(parameters))
{
return(false);
}
var acceptedTypes = AssetRegistry.GetAssetTypes(typeof(Material));
var materialViewModel = await BrowseForAsset(parameters.Package, acceptedTypes, new UFile(parameters.Name).GetFullDirectory(), "Select a material to use for this model - _cancel to leave the material empty_");
var material = ContentReferenceHelper.CreateReference <Material>(materialViewModel);
parameters.SetTag(MaterialKey, material);
return(true);
}
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
// Find default graphics compositor to create a derived asset from
var graphicsCompositorUrl = parameters.Description.Id == Level9TemplateId ? XenkoPackageUpgrader.DefaultGraphicsCompositorLevel9Url : XenkoPackageUpgrader.DefaultGraphicsCompositorLevel10Url;
var graphicsCompositor = parameters.Package.FindAsset(graphicsCompositorUrl);
// Something went wrong, create an empty asset
if (graphicsCompositor == null)
{
return(base.CreateAssets(parameters));
}
// Create derived asset
return(new[] { new AssetItem(GenerateLocation(parameters), graphicsCompositor.CreateDerivedAsset()) });
}
protected override async Task <bool> PrepareAssetCreation(AssetTemplateGeneratorParameters parameters)
{
if (!await base.PrepareAssetCreation(parameters))
{
return(false);
}
var acceptedTypes = AssetRegistry.GetAssetTypes(typeof(Texture));
var textureViewModel = await BrowseForAsset(parameters.Package, acceptedTypes, new UFile(parameters.Name).GetFullDirectory(), "Select a cubemap texture to use for this skybox - _cancel to leave the texture empty_");
var texture = ContentReferenceHelper.CreateReference <Texture>(textureViewModel);
parameters.SetTag(TextureKey, texture);
return(true);
}
protected override async Task <bool> PrepareAssetCreation(AssetTemplateGeneratorParameters parameters)
{
if (!parameters.Unattended)
{
var window = new ScriptNameWindow(parameters.Description.DefaultOutputName, parameters.Namespace);
await window.ShowModal();
if (window.Result == DialogResult.Cancel)
{
return(false);
}
parameters.Namespace = window.Namespace;
parameters.Tags.Set(ClassNameKey, window.ClassName);
var ask = Xenko.Core.Assets.Editor.Settings.EditorSettings.AskBeforeSavingNewScripts.GetValue();
if (ask)
{
var buttons = DialogHelper.CreateButtons(new[]
{
Tr._p("Button", "Save"),
Tr._p("Button", "Cancel")
}, 1, 2);
var message = Tr._p("Message", "You can't use scripts until you save them. Do you want to save now?");
var checkedMessage = Xenko.Core.Assets.Editor.Settings.EditorSettings.AlwaysSaveNewScriptsWithoutAsking;
var result = await EditorViewModel.Instance.ServiceProvider.Get <IDialogService>().CheckedMessageBox(message, false, checkedMessage, buttons, MessageBoxImage.Question);
if (result.IsChecked == true)
{
Xenko.Core.Assets.Editor.Settings.EditorSettings.AskBeforeSavingNewScripts.SetValue(false);
Xenko.Core.Assets.Editor.Settings.EditorSettings.Save();
}
parameters.Tags.Set(SaveSessionKey, result.Result == 1);
}
else
{
parameters.Tags.Set(SaveSessionKey, true);
}
}
else
{
// TODO: Some templates save, some don't (and behavior can even change in Unattended mode)
// For consistency, should this be moved to a common parameters.Saving?
parameters.Tags.Set(SaveSessionKey, false);
}
return(true);
}
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
var desc = parameters.Description;
var scriptFile = Path.ChangeExtension(desc.FullPath, HtmlFileAsset.Extension);
var scriptContent = File.ReadAllText(scriptFile);
parameters.Name = parameters.Tags.Get(ClassNameKey);
var location = GenerateLocation(parameters);
scriptContent = scriptContent.Replace("##Scriptname##", location.GetFileNameWithoutExtension());
var asset = (HtmlFileAsset)ObjectFactoryRegistry.NewInstance(typeof(HtmlFileAsset));
asset.Id = SourceCodeAsset.GenerateIdFromLocation(parameters.Package.Meta.Name, location);
asset.Text = scriptContent;
yield return(new AssetItem(location, asset));
}
protected override IEnumerable <AssetItem> CreateAssets(AssetTemplateGeneratorParameters parameters)
{
var desc = parameters.Description as TemplateAssetFactoryDescription;
if (desc == null)
{
yield break;
}
var factory = desc.GetFactory();
if (factory == null)
{
throw new InvalidOperationException("Unable to find the asset factory associated to this template.");
}
var asset = factory.New();
yield return(new AssetItem(GenerateLocation(parameters), asset));
}
protected override async Task <bool> PrepareAssetCreation(AssetTemplateGeneratorParameters parameters)
{
var description = (TemplateAssetDescription)parameters.Description;
var assetType = description.GetAssetType();
var files = parameters.SourceFiles.Count > 0 ? parameters.SourceFiles : await BrowseForSourceFiles(description, true);
while (files == null)
{
var assetTypeName = TypeDescriptorFactory.Default.AttributeRegistry.GetAttribute <DisplayAttribute>(assetType)?.Name ?? assetType.Name;
var buttons = DialogHelper.CreateButtons(new[]
{
Tr._p("Button", "Create"),
Tr._p("Button", "Select a source..."),
Tr._p("Button", "Cancel")
}, 1, 3);
var result = await DialogHelper.MessageBox(DispatcherService.Create(),
string.Format(Tr._p("Message", "Do you want to create this {0} without a source file?"), assetTypeName),
EditorViewModel.Instance.EditorName, buttons, MessageBoxImage.Question);
// Close without clicking a button or Cancel
if (result == 0 || result == 3)
{
return(false);
}
// Create without source
if (result == 1)
{
break;
}
// Display the file picker again
files = await BrowseForSourceFiles(description, true);
}
parameters.Tags.Add(SourceFilesPathKey, files);
return(await base.PrepareAssetCreation(parameters));
}
protected override void PostAssetCreation(AssetTemplateGeneratorParameters parameters, AssetItem assetItem)
{
parameters.RequestSessionSave = parameters.TryGetTag(SaveSessionKey);
}
protected override bool Generate(SessionTemplateGeneratorParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException(nameof(parameters));
}
// Structure of files to generate:
// $Name$.sdpkg
// $Name$.targets
// Assets\
// $Name$.Game\
// $Name$.Windows\
// $Name$.Android\
// $Name$.iOS\
var logger = parameters.Logger;
var platforms = parameters.GetTag(PlatformsKey);
var name = parameters.Name;
var outputDirectory = parameters.OutputDirectory;
var orientation = parameters.GetTag(OrientationKey);
// Generate the package
//var package = NewPackageTemplateGenerator.GeneratePackage(parameters);
// Generate projects for this package
var session = parameters.Session;
var projectGameName = Utilities.BuildValidNamespaceName(name);
var stepIndex = 0;
var stepCount = platforms.Count + 1;
// Log progress
ProjectTemplateGeneratorHelper.Progress(logger, $"Generating {projectGameName}...", stepIndex++, stepCount);
// Generate the Game library
var project = ProjectTemplateGeneratorHelper.GenerateTemplate(parameters, platforms, "ProjectLibrary.Game/ProjectLibrary.Game.ttproj", projectGameName, PlatformType.Shared, null, ProjectType.Library, orientation);
var package = project.Package;
//write gitignore
WriteGitIgnore(parameters);
// Setup the assets folder
//Directory.CreateDirectory(UPath.Combine(package.RootDirectory, (UDirectory)"Assets/Shared"));
session.Projects.Add(project);
// Load missing references
session.LoadMissingDependencies(parameters.Logger);
// Load dependency assets (needed for camera script template)
session.LoadMissingAssets(parameters.Logger, project.FlattenedDependencies.Select(x => x.Package).NotNull());
// Add Effects as an asset folder in order to load sdsl
package.AssetFolders.Add(new AssetFolder("Effects"));
var packageParameters = new PackageTemplateGeneratorParameters
{
Name = package.Meta.Name,
OutputDirectory = package.FullPath.GetFullDirectory(),
Description = parameters.Description,
Package = package,
Logger = parameters.Logger,
Namespace = parameters.Namespace
};
// Generate executable projects for each platform
var platformProjects = ProjectTemplateGeneratorHelper.UpdatePackagePlatforms(packageParameters, platforms, orientation, false).ToList();
// Add asset packages
CopyAssetPacks(parameters, package);
// Create camera script
var cameraScriptTemplate = TemplateManager.FindTemplates(package.Session).OfType <TemplateAssetDescription>().FirstOrDefault(x => x.DefaultOutputName == CameraScriptDefaultOutputName);
if (cameraScriptTemplate == null)
{
throw new InvalidOperationException($"Could not find template for script '{CameraScriptDefaultOutputName}'");
}
var cameraScriptParameters = new AssetTemplateGeneratorParameters(string.Empty)
{
Name = cameraScriptTemplate.DefaultOutputName,
Description = cameraScriptTemplate,
Namespace = parameters.Namespace,
Package = package,
Logger = logger,
Unattended = true,
};
ScriptTemplateGenerator.SetClassName(cameraScriptParameters, cameraScriptTemplate.DefaultOutputName);
if (!ScriptTemplateGenerator.Default.PrepareForRun(cameraScriptParameters).Result || !ScriptTemplateGenerator.Default.Run(cameraScriptParameters))
{
throw new InvalidOperationException($"Could not create script '{CameraScriptDefaultOutputName}'");
}
// Force save after having created the script
// Note: We do that AFTER GameSettings is dirty, otherwise it would ask for an assembly reload (game settings saved might mean new graphics API)
SaveSession(parameters);
// Load missing references
session.LoadMissingReferences(parameters.Logger);
// Setup GraphicsCompositor using DefaultGraphicsCompositor
var graphicsProfile = parameters.GetTag(GraphicsProfileKey);
var defaultCompositorUrl = graphicsProfile >= GraphicsProfile.Level_10_0 ? StridePackageUpgrader.DefaultGraphicsCompositorLevel10Url : StridePackageUpgrader.DefaultGraphicsCompositorLevel9Url;
var defaultCompositor = session.FindAsset(defaultCompositorUrl);
var graphicsCompositor = new AssetItem("GraphicsCompositor", defaultCompositor.CreateDerivedAsset());
package.Assets.Add(graphicsCompositor);
graphicsCompositor.IsDirty = true;
// Setup GameSettingsAsset
var gameSettingsAsset = GameSettingsFactory.Create();
gameSettingsAsset.GetOrCreate <EditorSettings>().RenderingMode = parameters.GetTag(IsHDRKey) ? RenderingMode.HDR : RenderingMode.LDR;
gameSettingsAsset.GraphicsCompositor = AttachedReferenceManager.CreateProxyObject <GraphicsCompositor>(graphicsCompositor.ToReference());
var renderingSettings = gameSettingsAsset.GetOrCreate <RenderingSettings>();
renderingSettings.DefaultGraphicsProfile = parameters.GetTag(GraphicsProfileKey);
renderingSettings.DisplayOrientation = (RequiredDisplayOrientation)orientation;
var gameSettingsAssetItem = new AssetItem(GameSettingsAsset.GameSettingsLocation, gameSettingsAsset);
package.Assets.Add(gameSettingsAssetItem);
gameSettingsAssetItem.IsDirty = true;
// Add assets to the package
AddAssets(parameters, package, projectGameName);
// Log done
ProjectTemplateGeneratorHelper.Progress(logger, "Done", stepCount, stepCount);
// Set current project
session.CurrentProject = platformProjects.FirstOrDefault(x => x.Platform == PlatformType.Windows) ?? project;
return(true);
}
protected override async Task <bool> PrepareAssetCreation(AssetTemplateGeneratorParameters parameters)
{
var result = await base.PrepareAssetCreation(parameters);
if (!result)
{
return(false);
}
var files = parameters.Tags.Get(SourceFilesPathKey);
if (files is null)
{
return(true);
}
var showDeduplicateMaterialsCheckBox = files.Any(x => ImportAssimpCommand.IsSupportingExtensions(x.GetFileExtension()));
var showFbxDedupeNotSupportedWarning = showDeduplicateMaterialsCheckBox && files.Any(x => ImportFbxCommand.IsSupportingExtensions(x.GetFileExtension()));
// Load settings from the last time this template was used for this project
var profile = parameters.Package.UserSettings.Profile;
var window = new ModelAssetTemplateWindow
{
Parameters =
{
ImportMaterials = ModelFromFileTemplateSettings.ImportMaterials.GetValue(profile, true),
ShowDeduplicateMaterialsCheckBox = showDeduplicateMaterialsCheckBox,
ShowFbxDedupeNotSupportedWarning = showFbxDedupeNotSupportedWarning,
DeduplicateMaterials = ModelFromFileTemplateSettings.DeduplicateMaterials.GetValue(profile, true),
ImportTextures = ModelFromFileTemplateSettings.ImportTextures.GetValue(profile, true),
ImportSkeleton = ModelFromFileTemplateSettings.ImportSkeleton.GetValue(profile, true)
}
};
var skeletonId = ModelFromFileTemplateSettings.DefaultSkeleton.GetValue();
var skeleton = SessionViewModel.Instance?.GetAssetById(skeletonId);
if (skeleton != null)
{
window.Parameters.ReuseSkeleton = true;
window.Parameters.SkeletonToReuse = ContentReferenceHelper.CreateReference <Skeleton>(skeleton);
}
await window.ShowModal();
if (window.Result == DialogResult.Cancel)
{
return(false);
}
// Apply settings
var skeletonToReuse = window.Parameters.ReuseSkeleton ? window.Parameters.SkeletonToReuse : null;
parameters.Tags.Set(ImportMaterialsKey, window.Parameters.ImportMaterials);
parameters.Tags.Set(DeduplicateMaterialsKey, window.Parameters.DeduplicateMaterials);
parameters.Tags.Set(ImportTexturesKey, window.Parameters.ImportTextures);
parameters.Tags.Set(ImportSkeletonKey, window.Parameters.ImportSkeleton);
parameters.Tags.Set(SkeletonToUseKey, skeletonToReuse);
// Save settings
ModelFromFileTemplateSettings.ImportMaterials.SetValue(window.Parameters.ImportMaterials, profile);
ModelFromFileTemplateSettings.DeduplicateMaterials.SetValue(window.Parameters.DeduplicateMaterials, profile);
ModelFromFileTemplateSettings.ImportTextures.SetValue(window.Parameters.ImportTextures, profile);
ModelFromFileTemplateSettings.ImportSkeleton.SetValue(window.Parameters.ImportSkeleton, profile);
skeletonId = AttachedReferenceManager.GetAttachedReference(skeletonToReuse)?.Id ?? AssetId.Empty;
ModelFromFileTemplateSettings.DefaultSkeleton.SetValue(skeletonId, profile);
parameters.Package.UserSettings.Save();
return(true);
}
private void CreateCameraScript(SessionTemplateGeneratorParameters parameters, Package package, ProjectReference projectGameReference, string projectGameName, Entity cameraEntity, AssetItem sceneAssetItem)
{
var logger = parameters.Logger;
// Create camera script
var cameraScriptTemplate = TemplateManager.FindTemplates(package.Session).OfType <TemplateAssetDescription>().FirstOrDefault(x => x.DefaultOutputName == CameraScriptDefaultOutputName);
if (cameraScriptTemplate == null)
{
throw new InvalidOperationException($"Could not find template for script '{CameraScriptDefaultOutputName}'");
}
var cameraScriptParameters = new AssetTemplateGeneratorParameters(projectGameName)
{
Name = cameraScriptTemplate.DefaultOutputName,
Description = cameraScriptTemplate,
Namespace = parameters.Namespace,
Package = package,
Logger = logger,
Unattended = true,
};
ScriptTemplateGenerator.SetClassName(cameraScriptParameters, cameraScriptTemplate.DefaultOutputName);
if (!ScriptTemplateGenerator.Default.PrepareForRun(cameraScriptParameters).Result || !ScriptTemplateGenerator.Default.Run(cameraScriptParameters))
{
throw new InvalidOperationException($"Could not create script '{CameraScriptDefaultOutputName}'");
}
// Force save after having created the script
// Note: We do that AFTER GameSettings is dirty, otherwise it would ask for an assembly reload (game settings saved might mean new graphics API)
SaveSession(parameters);
parameters.Logger.Verbose("Restore NuGet packages...");
VSProjectHelper.RestoreNugetPackages(parameters.Logger, parameters.Session.SolutionPath).Wait();
logger.Verbose("Compiling game assemblies...");
parameters.Session.UpdateAssemblyReferences(logger);
if (package.State < PackageState.DependenciesReady)
{
logger.Warning("Assembly references were not compiled properly");
return;
}
logger.Verbose("Game assemblies compiled...");
// Create the Camera script in Camera entity
// Since we rely on lot of string check, added some null checking and try/catch to not crash the apps in case something went wrong
// We only emit warnings rather than errors, so that the user could continue
try
{
var gameAssembly = package.LoadedAssemblies.FirstOrDefault(x => x.ProjectReference == projectGameReference)?.Assembly;
if (gameAssembly == null)
{
logger.Warning("Can't load Game assembly");
return;
}
var cameraScriptType = package.LoadedAssemblies.First(x => x.ProjectReference == projectGameReference).Assembly.GetType($"{parameters.Namespace}.{CameraScriptDefaultOutputName}");
if (cameraScriptType == null)
{
logger.Warning($"Could not find script '{CameraScriptDefaultOutputName}' in Game assembly");
return;
}
cameraEntity.Add((EntityComponent)Activator.CreateInstance(cameraScriptType));
sceneAssetItem.IsDirty = true;
}
catch (Exception e)
{
logger.Warning($"Could not instantiate {CameraScriptDefaultOutputName} script", e);
}
}
protected override async Task <bool> PrepareAssetCreation(AssetTemplateGeneratorParameters parameters)
{
if (!parameters.Unattended)
{
string defaultClassName = parameters.Description.DefaultOutputName;
if (parameters.Tags.TryGetValue(DefaultClassNameKey, out string className) && !string.IsNullOrEmpty(className))
{
defaultClassName = className;
}
bool enableTemplateSelect = parameters.TryGetTag(EnableTemplateSelectKey);
IEnumerable <TemplateAssetDescription> scriptTemplates = null;
if (enableTemplateSelect)
{
scriptTemplates = GetScriptTemplateAssetDescriptions(TemplateManager.FindTemplates(TemplateScope.Asset, parameters.Package.Session));
}
var window = new ScriptNameWindow(defaultClassName, parameters.Namespace, parameters.Description as TemplateAssetDescription, enableTemplateSelect, scriptTemplates);
await window.ShowModal();
if (window.Result == DialogResult.Cancel)
{
return(false);
}
parameters.Namespace = window.Namespace;
parameters.Tags.Set(ClassNameKey, window.ClassName);
parameters.Description = window.ScriptTemplate;
var ask = Stride.Core.Assets.Editor.Settings.EditorSettings.AskBeforeSavingNewScripts.GetValue();
if (ask)
{
var buttons = DialogHelper.CreateButtons(new[]
{
Tr._p("Button", "Save"),
Tr._p("Button", "Cancel")
}, 1, 2);
var message = Tr._p("Message", "You can't use scripts until you save them. Do you want to save now?");
var checkedMessage = Stride.Core.Assets.Editor.Settings.EditorSettings.AlwaysSaveNewScriptsWithoutAsking;
var result = await EditorViewModel.Instance.ServiceProvider.Get <IDialogService>().CheckedMessageBox(message, false, checkedMessage, buttons, MessageBoxImage.Question);
if (result.IsChecked == true)
{
Stride.Core.Assets.Editor.Settings.EditorSettings.AskBeforeSavingNewScripts.SetValue(false);
Stride.Core.Assets.Editor.Settings.EditorSettings.Save();
}
parameters.Tags.Set(SaveSessionKey, result.Result == 1);
}
else
{
parameters.Tags.Set(SaveSessionKey, true);
}
}
else
{
// TODO: Some templates save, some don't (and behavior can even change in Unattended mode)
// For consistency, should this be moved to a common parameters.Saving?
parameters.Tags.Set(SaveSessionKey, false);
}
return(true);
}
public static void SetClassName(AssetTemplateGeneratorParameters parameters, string className) => parameters.Tags.Set(ClassNameKey, className);
