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; } Version = package.Meta.Version.ToString(); return true; }
public static LoggerResult FixAssetReferences(IEnumerable<AssetItem> items) { var parameters = new AssetAnalysisParameters() { IsProcessingAssetReferences = true, IsLoggingAssetNotFoundAsError = true}; var result = new LoggerResult(); Run(items, result, parameters); return result; }
public static int RunProcessAndRedirectToLogger(string command, string parameters, string workingDirectory, LoggerResult logger) { var process = new Process { StartInfo = new ProcessStartInfo(command) { UseShellExecute = false, CreateNoWindow = true, RedirectStandardError = true, RedirectStandardOutput = true, WorkingDirectory = workingDirectory, Arguments = parameters, } }; process.Start(); DataReceivedEventHandler outputDataReceived = (_, args) => LockProcessAndAddDataToLogger(process, logger, false, args); DataReceivedEventHandler errorDataReceived = (_, args) => LockProcessAndAddDataToLogger(process, logger, true, args); process.OutputDataReceived += outputDataReceived; process.ErrorDataReceived += errorDataReceived; process.BeginOutputReadLine(); process.BeginErrorReadLine(); process.WaitForExit(); process.CancelOutputRead(); process.CancelErrorRead(); process.OutputDataReceived -= outputDataReceived; process.ErrorDataReceived -= errorDataReceived; return process.ExitCode; }
public static Builder CreateBuilder() { var logger = new LoggerResult(); logger.ActivateLog(LogMessageType.Debug); var builder = new Builder(BuildPath, "Windows", "index", logger) { BuilderName = "TestBuilder", SlaveBuilderPath = @"SiliconStudio.BuildEngine.exe" }; return builder; }
public SettingsContainer() { rootProfile = new SettingsProfile(this, null); profileList.Add(rootProfile); currentProfile = rootProfile; Logger = new LoggerResult(); }
public void Test() { var logger = new LoggerResult(); var context = new AssetMigrationContext(null, logger); var files = Directory.EnumerateFiles(@"..\..\samples", "*.xkscene", SearchOption.AllDirectories); foreach (var sceneFile in files) { logger.HasErrors = false; logger.Clear(); Console.WriteLine($"Checking file {sceneFile}"); var file = new PackageLoadingAssetFile(sceneFile, null); var needMigration = AssetMigration.MigrateAssetIfNeeded(context, file, "Xenko"); foreach (var message in logger.Messages) { Console.WriteLine(message); } Assert.False(logger.HasErrors); if (needMigration) { var result = Encoding.UTF8.GetString(file.AssetContent); Console.WriteLine(result); // We cannot load the Package here, as the package can use code/scripts that are only available when you actually compile project assmeblies } } }
/// <summary> /// Performs a wide package validation analysis. /// </summary> /// <returns>Result of the validation.</returns> public LoggerResult Run() { if (packageSession == null) throw new InvalidOperationException("packageSession is null"); var results = new LoggerResult(); Run(results); return results; }
public SettingsGroup() { defaultProfile = new SettingsProfile(this, null); profileList.Add(defaultProfile); currentProfile = defaultProfile; Logger = new LoggerResult(); }
public static Builder CreateBuilder(bool createIndexFile) { var logger = new LoggerResult(); logger.ActivateLog(LogMessageType.Debug); var indexName = createIndexFile ? VirtualFileSystem.ApplicationDatabaseIndexName : null; var builder = new Builder(logger, BuildPath, "Windows", indexName) { BuilderName = "TestBuilder", SlaveBuilderPath = @"SiliconStudio.BuildEngine.exe" }; return builder; }
/// <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 static LoggerResult Run(IEnumerable<AssetItem> items, AssetAnalysisParameters parameters) { if (items == null) throw new ArgumentNullException("items"); if (parameters == null) throw new ArgumentNullException("parameters"); var result = new LoggerResult(); Run(items, result, parameters); return result; }
/// <summary> /// Generates this project template to the specified output directory. /// </summary> /// <param name="outputDirectory">The output directory.</param> /// <param name="projectName">Name of the project.</param> /// <param name="projectGuid">The project unique identifier.</param> /// <param name="options">The options arguments that will be made available through the Session property in each template.</param> /// <returns>LoggerResult.</returns> /// <exception cref="System.ArgumentNullException">outputDirectory /// or /// projectName</exception> /// <exception cref="System.InvalidOperationException">FilePath cannot be null on this instance</exception> public LoggerResult Generate(string outputDirectory, string projectName, Guid projectGuid, Dictionary<string, object> options = null) { if (outputDirectory == null) throw new ArgumentNullException("outputDirectory"); if (projectName == null) throw new ArgumentNullException("projectName"); if (FilePath == null) throw new InvalidOperationException("FilePath cannot be null on this instance"); var result = new LoggerResult(); Generate(outputDirectory, projectName, projectGuid, result, options); return result; }
internal AssetToImportMergeGroup(AssetToImportByImporter parent, AssetItem item) { if (parent == null) throw new ArgumentNullException("parent"); if (item == null) throw new ArgumentNullException("item"); this.Parent = parent; Item = item; Merges = new List<AssetToImportMerge>(); Enabled = true; var assetDescription = DisplayAttribute.GetDisplay(item.Asset.GetType()); Log = new LoggerResult(string.Format("Import {0} {1}", assetDescription != null ? assetDescription.Name : "Asset" , item)); }
internal AssetToImportByImporter(AssetToImport parent, IAssetImporter importer, AssetItem previousItem = null) { if (parent == null) throw new ArgumentNullException("parent"); if (importer == null) throw new ArgumentNullException("importer"); this.Parent = parent; this.importer = importer; this.Items = new List<AssetToImportMergeGroup>(); Enabled = true; Log = new LoggerResult(string.Format("{0} Importer", importer.Name)); ImporterParameters = importer.GetDefaultParameters(previousItem != null); ImporterParameters.Logger = Log; PreviousItem = previousItem; }
public void Init() { // Create and mount database file system var objDatabase = new ObjectDatabase("/data/db", "index", "/local/db"); var databaseFileProvider = new DatabaseFileProvider(objDatabase); AssetManager.GetFileProvider = () => databaseFileProvider; Compiler = new EffectCompiler(); Compiler.SourceDirectories.Add("shaders"); MixinParameters = new ShaderMixinParameters(); MixinParameters.Add(CompilerParameters.GraphicsPlatformKey, GraphicsPlatform.Direct3D11); MixinParameters.Add(CompilerParameters.GraphicsProfileKey, GraphicsProfile.Level_11_0); ResultLogger = new LoggerResult(); }
private static int Main(string[] args) { Console.WriteLine(@"Bootstrapping: " + args[0]); var xenkoDir = Environment.GetEnvironmentVariable("SiliconStudioXenkoDir"); var xenkoPkgPath = UPath.Combine(xenkoDir, new UFile("Xenko.xkpkg")); var session = PackageSession.Load(xenkoPkgPath); var generator = TemplateSampleGenerator.Default; var logger = new LoggerResult(); var parameters = new TemplateGeneratorParameters { Session = session.Session }; var outputPath = UPath.Combine(new UDirectory(xenkoDir), new UDirectory("samplesGenerated")); outputPath = UPath.Combine(outputPath, new UDirectory(args[0])); var xenkoTemplates = session.Session.Packages.First().Templates; parameters.Description = xenkoTemplates.First(x => x.Group.StartsWith("Samples") && x.Id == new Guid(args[1])); parameters.Name = args[0]; parameters.Namespace = args[0]; parameters.OutputDirectory = outputPath; parameters.Logger = logger; generator.Generate(parameters); var updaterTemplate = xenkoTemplates.First(x => x.FullPath.ToString().EndsWith("UpdatePlatforms.xktpl")); parameters.Description = updaterTemplate; var updater = UpdatePlatformsTemplateGenerator.Default; var gameSettingsAsset = session.Session.Packages.Last().GetGameSettingsAsset(); var updateParams = new GameTemplateParameters { Common = parameters, ForcePlatformRegeneration = true, GraphicsProfile = gameSettingsAsset.DefaultGraphicsProfile, IsHDR = false, Orientation = gameSettingsAsset.DisplayOrientation, Platforms = AssetRegistry.SupportedPlatforms.ToList() }; updater.Generate(updateParams); Console.WriteLine(logger.ToText()); return logger.HasErrors ? 1 : 0; }
public void Init() { // Create and mount database file system var objDatabase = ObjectDatabase.CreateDefaultDatabase(); var databaseFileProvider = new DatabaseFileProvider(objDatabase); ContentManager.GetFileProvider = () => databaseFileProvider; Compiler = new EffectCompiler(); Compiler.SourceDirectories.Add("shaders"); MixinParameters = new CompilerParameters(); MixinParameters.EffectParameters.Platform = GraphicsPlatform.Direct3D11; MixinParameters.EffectParameters.Profile = GraphicsProfile.Level_11_0; ResultLogger = new LoggerResult(); }
private void UpdateReflection(ShaderBytecode shaderBytecode, EffectReflection effectReflection, LoggerResult log) { var shaderReflectionRaw = new SharpDX.D3DCompiler.ShaderReflection(shaderBytecode); var shaderReflectionRawDesc = shaderReflectionRaw.Description; // Constant Buffers for (int i = 0; i < shaderReflectionRawDesc.ConstantBuffers; ++i) { var constantBufferRaw = shaderReflectionRaw.GetConstantBuffer(i); var constantBufferRawDesc = constantBufferRaw.Description; var linkBuffer = effectReflection.ConstantBuffers.FirstOrDefault(buffer => buffer.Name == constantBufferRawDesc.Name && buffer.Stage == ShaderStage.None); var constantBuffer = GetConstantBufferReflection(constantBufferRaw, ref constantBufferRawDesc, linkBuffer, log); constantBuffer.Stage = shaderBytecode.Stage; effectReflection.ConstantBuffers.Add(constantBuffer); } // BoundResources for (int i = 0; i < shaderReflectionRawDesc.BoundResources; ++i) { var boundResourceDesc = shaderReflectionRaw.GetResourceBindingDescription(i); string linkKeyName = null; foreach (var linkResource in effectReflection.ResourceBindings) { if (linkResource.Param.RawName == boundResourceDesc.Name && linkResource.Stage == ShaderStage.None) { linkKeyName = linkResource.Param.KeyName; break; } } if (linkKeyName == null) { log.Error("Resource [{0}] has no link", boundResourceDesc.Name); } else { var binding = GetResourceBinding(boundResourceDesc, linkKeyName, log); binding.Stage = shaderBytecode.Stage; effectReflection.ResourceBindings.Add(binding); } } }
public void TestLocalLogger() { var log = new LoggerResult(); log.Info("#0"); Assert.That(log.Messages.Count, Is.EqualTo(1)); Assert.That(log.Messages[0].Type, Is.EqualTo(LogMessageType.Info)); Assert.That(log.Messages[0].Text, Is.EqualTo("#0")); log.Info("#{0}", 1); Assert.That(log.Messages.Count, Is.EqualTo(2)); Assert.That(log.Messages[1].Type, Is.EqualTo(LogMessageType.Info)); Assert.That(log.Messages[1].Text, Is.EqualTo("#1")); Assert.That(log.HasErrors, Is.False); log.Error("#2"); Assert.That(log.Messages.Count, Is.EqualTo(3)); Assert.That(log.Messages[2].Type, Is.EqualTo(LogMessageType.Error)); Assert.That(log.Messages[2].Text, Is.EqualTo("#2")); Assert.That(log.HasErrors, Is.True); log.Error("#{0}", 3); Assert.That(log.Messages.Count, Is.EqualTo(4)); Assert.That(log.Messages[3].Type, Is.EqualTo(LogMessageType.Error)); Assert.That(log.Messages[3].Text, Is.EqualTo("#3")); // Activate log from Info to Fatal. Verbose won't be logged. log.ActivateLog(LogMessageType.Info); log.Verbose("#4"); Assert.That(log.Messages.Count, Is.EqualTo(4)); // Activate log from Verbose to Fatal. Verbose will be logged log.ActivateLog(LogMessageType.Verbose); log.Verbose("#4"); Assert.That(log.Messages.Count, Is.EqualTo(5)); // Activate log from Info to Fatal and only Debug. Verbose won't be logged. log.ActivateLog(LogMessageType.Info); log.ActivateLog(LogMessageType.Debug, true); log.Verbose("#5"); log.Debug("#6"); Assert.That(log.Messages.Count, Is.EqualTo(6)); Assert.That(log.Messages[5].Text, Is.EqualTo("#6")); }
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; } // Override version with task SpecialVersion (if specified by user) if (!string.IsNullOrEmpty(SpecialVersion)) { package.Meta.Version = new PackageVersion(package.Meta.Version.Version, SpecialVersion); } Log.LogMessage(MessageImportance.High, "Packaging [{0}] version [{1}]", package.Meta.Name, package.Meta.Version); // Build the package PackageArchive.Build(package); return true; }
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 Assembly LoadAssemblyFromPath(string assemblyFullPath, ILogger outputLog = null, List<string> lookupDirectoryList = null) { if (assemblyFullPath == null) throw new ArgumentNullException("assemblyFullPath"); log = new LoggerResult(); lookupDirectoryList = lookupDirectoryList ?? new List<string>(); assemblyFullPath = Path.GetFullPath(Path.Combine(Environment.CurrentDirectory, assemblyFullPath)); var assemblyDirectory = Path.GetDirectoryName(assemblyFullPath); if (assemblyDirectory == null || !Directory.Exists(assemblyDirectory)) { throw new ArgumentException("Invalid assembly path. Doesn't contain directory information"); } if (!lookupDirectoryList.Contains(assemblyDirectory, StringComparer.InvariantCultureIgnoreCase)) { lookupDirectoryList.Add(assemblyDirectory); } var previousLookupList = searchDirectoryList; try { loadingInstance = this; searchDirectoryList = lookupDirectoryList; return LoadAssemblyFromPathInternal(assemblyFullPath); } finally { loadingInstance = null; searchDirectoryList = previousLookupList; if (outputLog != null) { log.CopyTo(outputLog); } } }
/// <summary> /// Converts the specified hlsl source code to glsl. /// </summary> /// <param name="hlslSourcecode">The HLSL source code.</param> /// <param name="hlslEntryPoint">The HLSL entry point.</param> /// <param name="stage">The stage to convert.</param> /// <param name="shader">The shader.</param> /// <param name="inputHlslFilepath">The input HLSL filepath.</param> /// <returns> /// The resulting glsl AST tree. /// </returns> public global::SiliconStudio.Shaders.Ast.Shader Convert(string hlslSourcecode, string hlslEntryPoint, PipelineStage stage, string inputHlslFilepath, LoggerResult log) { try { // Convert from Framework.Graphics ShaderMacro to Framework.Shaders ShaderMacro var macros = new global::SiliconStudio.Shaders.Parser.ShaderMacro[Macros.Count]; for (int index = 0; index < Macros.Count; index++) macros[index] = new global::SiliconStudio.Shaders.Parser.ShaderMacro(Macros[index].Name, Macros[index].Definition); var result = HlslParser.TryPreProcessAndParse(hlslSourcecode, inputHlslFilepath, macros, IncludeDirectories); if (result.HasErrors) { log.Error(result.ToString()); return null; } // Prepare the shader before type inference analysis HlslToGlslConvertor.Prepare(result.Shader); HlslSemanticAnalysis.Run(result); // If there are any type inference analysis, just display all errors but ytu if (result.HasErrors) { log.Error(result.ToString()); return null; } return Convert(result, hlslEntryPoint, stage, inputHlslFilepath, log); } catch (Exception ex) { log.Error("Unexpected error while converting file [{0}] with entry point [{1}]", ex, inputHlslFilepath, hlslEntryPoint); } return null; }
private ShaderConstantBufferDescription GetConstantBufferReflection(ConstantBuffer constantBufferRaw, ref ConstantBufferDescription constantBufferRawDesc, ShaderConstantBufferDescription linkBuffer, LoggerResult log) { var constantBuffer = new ShaderConstantBufferDescription { Name = constantBufferRawDesc.Name, Size = constantBufferRawDesc.Size, }; switch (constantBufferRawDesc.Type) { case SharpDX.D3DCompiler.ConstantBufferType.ConstantBuffer: constantBuffer.Type = ConstantBufferType.ConstantBuffer; break; case SharpDX.D3DCompiler.ConstantBufferType.TextureBuffer: constantBuffer.Type = ConstantBufferType.TextureBuffer; break; default: constantBuffer.Type = ConstantBufferType.Unknown; break; } // ConstantBuffers variables var members = new List <EffectParameterValueData>(); for (int i = 0; i < constantBufferRawDesc.VariableCount; i++) { var variable = constantBufferRaw.GetVariable(i); var variableType = variable.GetVariableType(); var variableDescription = variable.Description; var variableTypeDescription = variableType.Description; var parameter = new EffectParameterValueData() { Param = { Class = (EffectParameterClass)variableTypeDescription.Class, Type = ConvertVariableValueType(variableTypeDescription.Type, log), RawName = variableDescription.Name, }, Offset = variableDescription.StartOffset, Size = variableDescription.Size, Count = variableTypeDescription.ElementCount == 0 ? 1 : variableTypeDescription.ElementCount, RowCount = (byte)variableTypeDescription.RowCount, ColumnCount = (byte)variableTypeDescription.ColumnCount, }; if (variableTypeDescription.Offset != 0) { log.Error("Unexpected offset [{0}] for variable [{1}] in constant buffer [{2}]", variableTypeDescription.Offset, variableDescription.Name, constantBuffer.Name); } bool bindingNotFound = true; // Retrieve Link Member foreach (var binding in linkBuffer.Members) { if (binding.Param.RawName == variableDescription.Name) { // TODO: should we replicate linkMember.Count/RowCount/ColumnCount? or use what is retrieved by D3DCompiler reflection parameter.Param.KeyName = binding.Param.KeyName; bindingNotFound = false; break; } } if (bindingNotFound) { log.Error("Variable [{0}] in constant buffer [{1}] has no link", variableDescription.Name, constantBuffer.Name); } members.Add(parameter); } constantBuffer.Members = members.ToArray(); return(constantBuffer); }
public int Run(string[] args) { // This is used by ExecServer to retrieve the logs directly without using the console redirect (which is not working well // in a multi-domain scenario) var redirectLogToAppDomainAction = AppDomain.CurrentDomain.GetData("AppDomainLogToAction") as Action <string, ConsoleColor>; clock = Stopwatch.StartNew(); // TODO this is hardcoded. Check how to make this dynamic instead. RuntimeHelpers.RunModuleConstructor(typeof(IProceduralModel).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(MaterialKeys).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(SpriteFontAsset).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(ModelAsset).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(SpriteStudioAnimationAsset).Module.ModuleHandle); RuntimeHelpers.RunModuleConstructor(typeof(ParticleSystem).Module.ModuleHandle); //var project = new Package(); //project.Save("test.xkpkg"); //Thread.Sleep(10000); //var spriteFontAsset = StaticFontAsset.New(); //Content.Save("test.xkfnt", spriteFontAsset); //project.Refresh(); //args = new string[] { "test.xkpkg", "-o:app_data", "-b:tmp", "-t:1" }; var exeName = Path.GetFileName(Assembly.GetExecutingAssembly().Location); var showHelp = false; var packMode = false; var buildEngineLogger = GlobalLogger.GetLogger("BuildEngine"); var options = new PackageBuilderOptions(new ForwardingLoggerResult(buildEngineLogger)); var p = new OptionSet { "Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp) All Rights Reserved", "Xenko Build Tool - Version: " + String.Format( "{0}.{1}.{2}", typeof(Program).Assembly.GetName().Version.Major, typeof(Program).Assembly.GetName().Version.Minor, typeof(Program).Assembly.GetName().Version.Build) + string.Empty, string.Format("Usage: {0} inputPackageFile [options]* -b buildPath", exeName), string.Empty, "=== Options ===", string.Empty, { "h|help", "Show this message and exit", v => showHelp = v != null }, { "v|verbose", "Show more verbose progress logs", v => options.Verbose = v != null }, { "d|debug", "Show debug logs (imply verbose)", v => options.Debug = v != null }, { "log", "Enable file logging", v => options.EnableFileLogging = v != null }, { "disable-auto-compile", "Disable auto-compile of projects", v => options.DisableAutoCompileProjects = v != null }, { "project-configuration=", "Project configuration", v => options.ProjectConfiguration = v }, { "platform=", "Platform name", v => options.Platform = (PlatformType)Enum.Parse(typeof(PlatformType), v) }, { "solution-file=", "Solution File Name", v => options.SolutionFile = v }, { "package-id=", "Package Id from the solution file", v => options.PackageId = Guid.Parse(v) }, { "package-file=", "Input Package File Name", v => options.PackageFile = v }, { "o|output-path=", "Output path", v => options.OutputDirectory = v }, { "b|build-path=", "Build path", v => options.BuildDirectory = v }, { "log-file=", "Log build in a custom file.", v => { options.EnableFileLogging = v != null; options.CustomLogFileName = v; } }, { "log-pipe=", "Log pipe.", v => { if (!string.IsNullOrEmpty(v)) { options.LogPipeNames.Add(v); } } }, { "monitor-pipe=", "Monitor pipe.", v => { if (!string.IsNullOrEmpty(v)) { options.MonitorPipeNames.Add(v); } } }, { "slave=", "Slave pipe", v => options.SlavePipe = v }, // Benlitz: I don't think this should be documented { "server=", "This Compiler is launched as a server", v => { } }, { "pack", "Special mode to copy assets and resources in a folder for NuGet packaging", v => packMode = true }, { "t|threads=", "Number of threads to create. Default value is the number of hardware threads available.", v => options.ThreadCount = int.Parse(v) }, { "test=", "Run a test session.", v => options.TestName = v }, { "property:", "Properties. Format is name1=value1;name2=value2", v => { if (!string.IsNullOrEmpty(v)) { foreach (var nameValue in v.Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries)) { var equalIndex = nameValue.IndexOf('='); if (equalIndex == -1) { throw new OptionException("Expect name1=value1;name2=value2 format.", "property"); } options.Properties.Add(nameValue.Substring(0, equalIndex), nameValue.Substring(equalIndex + 1)); } } } }, { "compile-property:", "Compile properties. Format is name1=value1;name2=value2", v => { if (!string.IsNullOrEmpty(v)) { if (options.ExtraCompileProperties == null) { options.ExtraCompileProperties = new Dictionary <string, string>(); } foreach (var nameValue in v.Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries)) { var equalIndex = nameValue.IndexOf('='); if (equalIndex == -1) { throw new OptionException("Expect name1=value1;name2=value2 format.", "property"); } options.ExtraCompileProperties.Add(nameValue.Substring(0, equalIndex), nameValue.Substring(equalIndex + 1)); } } } }, { "reattach-debugger=", "Reattach to a Visual Studio debugger", v => { int debuggerProcessId; if (!string.IsNullOrEmpty(v) && int.TryParse(v, out debuggerProcessId)) { if (!Debugger.IsAttached) { using (var debugger = VisualStudioDebugger.GetByProcess(debuggerProcessId)) { debugger?.Attach(); } } } } }, }; TextWriterLogListener fileLogListener = null; BuildResultCode exitCode; RemoteLogForwarder assetLogger = null; try { var unexpectedArgs = p.Parse(args); // Set remote logger assetLogger = new RemoteLogForwarder(options.Logger, options.LogPipeNames); GlobalLogger.GlobalMessageLogged += assetLogger; // Activate proper log level buildEngineLogger.ActivateLog(options.LoggerType); // Output logs to the console with colored messages if (options.SlavePipe == null && !options.LogPipeNames.Any()) { if (redirectLogToAppDomainAction != null) { globalLoggerOnGlobalMessageLogged = new LogListenerRedirectToAction(redirectLogToAppDomainAction); } else { globalLoggerOnGlobalMessageLogged = new ConsoleLogListener { LogMode = ConsoleLogMode.Always }; } globalLoggerOnGlobalMessageLogged.TextFormatter = FormatLog; GlobalLogger.GlobalMessageLogged += globalLoggerOnGlobalMessageLogged; } if (unexpectedArgs.Any()) { throw new OptionException("Unexpected arguments [{0}]".ToFormat(string.Join(", ", unexpectedArgs)), "args"); } try { options.ValidateOptions(); } catch (ArgumentException ex) { throw new OptionException(ex.Message, ex.ParamName); } if (showHelp) { p.WriteOptionDescriptions(Console.Out); return((int)BuildResultCode.Successful); } else if (packMode) { PackageSessionPublicHelper.FindAndSetMSBuildVersion(); var csprojFile = options.PackageFile; var intermediatePackagePath = options.BuildDirectory; var generatedItems = new List <(string SourcePath, string PackagePath)>(); var logger = new LoggerResult(); if (!PackAssetsHelper.Run(logger, csprojFile, intermediatePackagePath, generatedItems)) { foreach (var message in logger.Messages) { Console.WriteLine(message); } return((int)BuildResultCode.BuildError); } foreach (var generatedItem in generatedItems) { Console.WriteLine($"{generatedItem.SourcePath}|{generatedItem.PackagePath}"); } return((int)BuildResultCode.Successful); } // Also write logs from master process into a file if (options.SlavePipe == null) { if (options.EnableFileLogging) { string logFileName = options.CustomLogFileName; if (string.IsNullOrEmpty(logFileName)) { string inputName = Path.GetFileNameWithoutExtension(options.PackageFile); logFileName = "Logs/Build-" + inputName + "-" + DateTime.Now.ToString("yy-MM-dd-HH-mm") + ".txt"; } string dirName = Path.GetDirectoryName(logFileName); if (dirName != null) { Directory.CreateDirectory(dirName); } fileLogListener = new TextWriterLogListener(new FileStream(logFileName, FileMode.Create)) { TextFormatter = FormatLog }; GlobalLogger.GlobalMessageLogged += fileLogListener; } options.Logger.Info("BuildEngine arguments: " + string.Join(" ", args)); options.Logger.Info("Starting builder."); var baseDirectory = Path.Combine(options.BuildDirectory, @"../../../../../"); var changeFile = baseDirectory + "/files_changed"; var buildFile = baseDirectory + "/files_built"; var skipFile = baseDirectory + "/always_build"; long files_changed_ticks = 0, files_built_ticks = 0; string[] buildlines = null; string platform = options.Platform.ToString() + "-" + options.ProjectConfiguration; if (File.Exists(changeFile)) { long.TryParse(File.ReadAllText(changeFile), out files_changed_ticks); } if (File.Exists(buildFile)) { buildlines = File.ReadAllLines(buildFile); for (int i = 0; i < buildlines.Length; i += 2) { if (buildlines[i] == platform) { long.TryParse(buildlines[i + 1], out files_built_ticks); // also update with now time buildlines[i + 1] = System.DateTime.Now.Ticks.ToString(); } } } if (File.Exists(skipFile)) { options.Logger.Info("Found always_build, so always building assets."); } else if (Process.GetProcessesByName("Focus.GameStudio").Length == 0) { options.Logger.Warning("Focus.GameStudio does not appear to be running, so the AssetCompiler will always rebuild assets."); } else if (files_changed_ticks > 0 && files_built_ticks > 0 && files_built_ticks > files_changed_ticks) { options.Logger.Info("All Assets/ and Resources/ appear up date for " + platform + ", so skipping recompilation. If this is a mistake, delete files_changed and files_built in the root project directory. If you want to always build assets, make a file called always_build in the root project directory."); return(0); } // if there was no changefile, do it now if (File.Exists(changeFile) == false) { File.WriteAllText(changeFile, System.DateTime.Now.Ticks.ToString()); } // update file with changes if (File.Exists(buildFile) == false) { File.WriteAllText(buildFile, platform + "\n" + System.DateTime.Now.Ticks.ToString()); } else { File.WriteAllLines(buildFile, buildlines); if (files_built_ticks <= 0) { File.AppendAllText(buildFile, platform + "\n" + System.DateTime.Now.Ticks.ToString()); } } } else { IsSlave = true; } if (!string.IsNullOrEmpty(options.TestName)) { var test = new TestSession(); test.RunTest(options.TestName, options.Logger); exitCode = BuildResultCode.Successful; } else { builder = new PackageBuilder(options); if (!IsSlave && redirectLogToAppDomainAction == null) { Console.CancelKeyPress += OnConsoleOnCancelKeyPress; } exitCode = builder.Build(); } } catch (OptionException e) { options.Logger.Error($"Command option '{e.OptionName}': {e.Message}"); exitCode = BuildResultCode.CommandLineError; } catch (Exception e) { options.Logger.Error($"Unhandled exception", e); exitCode = BuildResultCode.BuildError; } finally { // Flush and close remote logger if (assetLogger != null) { GlobalLogger.GlobalMessageLogged -= assetLogger; assetLogger.Dispose(); } if (fileLogListener != null) { GlobalLogger.GlobalMessageLogged -= fileLogListener; fileLogListener.LogWriter.Close(); } // Output logs to the console with colored messages if (globalLoggerOnGlobalMessageLogged != null) { GlobalLogger.GlobalMessageLogged -= globalLoggerOnGlobalMessageLogged; } if (builder != null && !IsSlave && redirectLogToAppDomainAction == null) { Console.CancelKeyPress -= OnConsoleOnCancelKeyPress; } // Reset cache hold by YamlSerializer YamlSerializer.Default.ResetCache(); } return((int)exitCode); }
public EffectBytecodeCompilerResult(EffectBytecode bytecode) : this() { Bytecode = bytecode; CompilationLog = emptyLoggerResult; }
/// <summary> /// Loads the <see cref="ShaderClassType" />. /// </summary> /// <param name="shaderClassSource">The shader class source.</param> /// <param name="shaderMacros">The shader macros.</param> /// <param name="log">The log to output error logs.</param> /// <param name="autoGenericInstances"></param> /// <returns>A ShaderClassType or null if there was some errors.</returns> /// <exception cref="System.ArgumentNullException">shaderClassSource</exception> public LoadedShaderClassType LoadClassSource(ShaderClassCode shaderClassSource, Stride.Core.Shaders.Parser.ShaderMacro[] shaderMacros, LoggerResult log, bool autoGenericInstances) { if (shaderClassSource == null) { throw new ArgumentNullException("shaderClassSource"); } string generics = null; if (shaderClassSource.GenericArguments != null) { generics = ""; foreach (var gen in shaderClassSource.GenericArguments) { generics += "___" + gen; } } var shaderClassType = LoadShaderClass(shaderClassSource, generics, log, shaderMacros); if (shaderClassType == null) { return(null); } // Instantiate generic class if (shaderClassSource.GenericArguments != null || (shaderClassType.Type.ShaderGenerics.Count > 0 && autoGenericInstances)) { if (shaderClassType.IsInstanciated) { return(shaderClassType); } // If we want to automatically generate a generic instance (in case we just want to parse and verify the generic) if (autoGenericInstances) { shaderClassSource.GenericArguments = new string[shaderClassType.Type.ShaderGenerics.Count]; for (int i = 0; i < shaderClassSource.GenericArguments.Length; i++) { var variableGeneric = shaderClassType.Type.ShaderGenerics[i]; shaderClassSource.GenericArguments[i] = GetDefaultConstValue(variableGeneric); } } if (shaderClassSource.GenericArguments.Length != shaderClassType.Type.ShaderGenerics.Count) { log.Error(StrideMessageCode.WrongGenericNumber, shaderClassType.Type.Span, shaderClassSource.ClassName); return(null); } // check the name of the generics foreach (var generic in shaderClassType.Type.ShaderGenerics) { foreach (var genericCompare in shaderClassType.Type.ShaderGenerics.Where(x => x != generic)) { if (generic.Name.Text == genericCompare.Name.Text) { log.Error(StrideMessageCode.SameNameGenerics, generic.Span, generic, genericCompare, shaderClassSource.ClassName); } } } if (log.HasErrors) { return(null); } // When we use an actual generic instance, we replace the name with the name of the class + a hash of the generic parameters if (!autoGenericInstances) { var className = GenerateGenericClassName(shaderClassSource); shaderClassType.Type.Name = new Identifier(className); } var genericAssociation = CreateGenericAssociation(shaderClassType.Type.ShaderGenerics, shaderClassSource.GenericArguments); var identifierGenerics = GenerateIdentifierFromGenerics(genericAssociation); var expressionGenerics = GenerateGenericsExpressionValues(shaderClassType.Type.ShaderGenerics, shaderClassSource.GenericArguments); StrideClassInstantiator.Instantiate(shaderClassType.Type, expressionGenerics, identifierGenerics, autoGenericInstances, log); shaderClassType.Type.ShaderGenerics.Clear(); shaderClassType.IsInstanciated = true; } return(shaderClassType); }
private LoadedShaderClassType LoadShaderClass(ShaderClassCode classSource, string generics, LoggerResult log, Stride.Core.Shaders.Parser.ShaderMacro[] macros = null) { var type = classSource.ClassName; if (type == null) { throw new ArgumentNullException("type"); } var shaderSourceKey = new ShaderSourceKey(type, generics, macros); lock (loadedShaders) { // Already instantiated LoadedShaderClassType shaderClass; if (loadedShaders.TryGetValue(shaderSourceKey, out shaderClass)) { return(shaderClass); } ShaderSourceManager.ShaderSourceWithHash shaderSource; // Load shader source code if (classSource is ShaderClassString shaderClassString) { shaderSource = SourceManager.LoadShaderSource(type, shaderClassString.ShaderSourceCode); } else { shaderSource = SourceManager.LoadShaderSource(type); } string preprocessedSource; try { preprocessedSource = PreProcessor.Run(shaderSource.Source, shaderSource.Path, macros); } catch (Exception ex) { log.Error(MessageCode.ErrorUnexpectedException, new SourceSpan(new SourceLocation(shaderSource.Path, 0, 1, 1), 1), ex); return(null); } byte[] byteArray = Encoding.UTF8.GetBytes(preprocessedSource); var hashPreprocessSource = ObjectId.FromBytes(byteArray); // Compile var parsingResult = StrideShaderParser.TryParse(preprocessedSource, shaderSource.Path); parsingResult.CopyTo(log); if (parsingResult.HasErrors) { return(null); } var shader = parsingResult.Shader; // As shaders can be embedded in namespaces, get only the shader class and make sure there is only one in a sdsl. var shaderClassTypes = StrideShaderParser.GetShaderClassTypes(shader.Declarations).ToList(); if (shaderClassTypes.Count != 1) { var sourceSpan = new SourceSpan(new SourceLocation(shaderSource.Path, 0, 0, 0), 1); if (shaderClassTypes.Count > 1) { sourceSpan = shaderClassTypes[1].Span; } log.Error(StrideMessageCode.ShaderMustContainSingleClassDeclaration, sourceSpan, type); return(null); } shaderClass = new LoadedShaderClassType(); shaderClass.Type = shaderClassTypes.First(); shaderClass.SourcePath = shaderSource.Path; shaderClass.SourceHash = shaderSource.Hash; shaderClass.PreprocessedSourceHash = hashPreprocessSource; shaderClass.IsInstanciated = false; // TODO: We should not use Console. Change the way we log things here // Console.WriteLine("Loading Shader {0}{1}", type, macros != null && macros.Length > 0 ? String.Format("<{0}>", string.Join(", ", macros)) : string.Empty); // If the file name is not matching the class name, provide an error if (shaderClass.Type.Name.Text != type) { log.Error(StrideMessageCode.FileNameNotMatchingClassName, shaderClass.Type.Name.Span, type, shaderClass.Type.Name.Text); return(null); } loadedShaders.Add(shaderSourceKey, shaderClass); return(shaderClass); } }
public XenkoStreamAnalyzer(LoggerResult errorLog) : base(false, true) { errorWarningLog = errorLog ?? new LoggerResult(); }
/// <summary> /// Merge with a local virtual table = need to check override keywords /// </summary> /// <param name="virtualTable">the virtual table to add</param> /// <param name="mixinName">the name of the mixin</param> /// <param name="log">the error logger</param> public void MergeWithLocalVirtualTable(MixinVirtualTable virtualTable, string mixinName, LoggerResult log) { foreach (var method in virtualTable.Methods) { var methodDecl = Methods.LastOrDefault(x => x.Method.IsSameSignature(method.Method)); if (methodDecl != null) { var isBaseMethod = method.Shader.BaseClasses.Any(x => x.Name.Text == methodDecl.Shader.Name.Text); if (isBaseMethod) { if (methodDecl.Method is MethodDefinition) { if (!method.Method.Qualifiers.Contains(ParadoxStorageQualifier.Override)) { log.Error(ParadoxMessageCode.ErrorMissingOverride, method.Method.Span, method.Method, mixinName); continue; } } else if (method.Method.Qualifiers.Contains(ParadoxStorageQualifier.Override)) { log.Error(ParadoxMessageCode.ErrorOverrideDeclaration, method.Method.Span, method.Method, mixinName); continue; } } Methods.Remove(methodDecl); } else { if (method.Method.Qualifiers.Contains(ParadoxStorageQualifier.Override)) { log.Error(ParadoxMessageCode.ErrorNoMethodToOverride, method.Method.Span, method.Method, mixinName); continue; } } Methods.Add(method); // TODO: handle declarations vs definitions } Variables.UnionWith(virtualTable.Variables.Where(x => !Variables.Contains(x))); StructureTypes.AddRange(virtualTable.StructureTypes.Where(x => !StructureTypes.Contains(x))); Typedefs.AddRange(virtualTable.Typedefs.Where(x => !Typedefs.Contains(x))); }
public GameDebuggerHost(LoggerResult logger) { Log = logger; }
public static int RunProcessAndRedirectToLogger(string command, string parameters, string workingDirectory, LoggerResult logger) { var process = new Process { StartInfo = new ProcessStartInfo(command) { UseShellExecute = false, CreateNoWindow = true, RedirectStandardError = true, RedirectStandardOutput = true, WorkingDirectory = workingDirectory, Arguments = parameters, } }; process.Start(); DataReceivedEventHandler outputDataReceived = (_, args) => LockProcessAndAddDataToLogger(process, logger, false, args); DataReceivedEventHandler errorDataReceived = (_, args) => LockProcessAndAddDataToLogger(process, logger, true, args); process.OutputDataReceived += outputDataReceived; process.ErrorDataReceived += errorDataReceived; process.BeginOutputReadLine(); process.BeginErrorReadLine(); process.WaitForExit(); process.CancelOutputRead(); process.CancelErrorRead(); process.OutputDataReceived -= outputDataReceived; process.ErrorDataReceived -= errorDataReceived; return(process.ExitCode); }
private static PackageSession GenerateSample(UDirectory outputPath, Guid templateGuid, string sampleName, LoggerResult logger) { // Make output path absolute if (!outputPath.IsAbsolute) { outputPath = UPath.Combine(Environment.CurrentDirectory, outputPath); } Console.WriteLine(@"Bootstrapping: " + sampleName); var session = new PackageSession(); var generator = TemplateSampleGenerator.Default; // Ensure progress is shown while it is happening. logger.MessageLogged += (sender, eventArgs) => Console.WriteLine(eventArgs.Message.Text); var parameters = new SessionTemplateGeneratorParameters { Session = session }; parameters.Unattended = true; TemplateSampleGenerator.SetParameters( parameters, AssetRegistry.SupportedPlatforms.Where(x => x.Type == Core.PlatformType.Windows).Select(x => new SelectedSolutionPlatform(x, x.Templates.FirstOrDefault())).ToList(), addGamesTesting: true); session.SolutionPath = UPath.Combine <UFile>(outputPath, sampleName + ".sln"); // Properly delete previous version if (Directory.Exists(outputPath)) { try { Directory.Delete(outputPath, true); } catch (Exception) { logger.Warning($"Unable to delete directory [{outputPath}]"); } } // Load templates XenkoDefaultAssetsPlugin.LoadDefaultTemplates(); var xenkoTemplates = TemplateManager.FindTemplates(session); parameters.Description = xenkoTemplates.First(x => x.Id == templateGuid); parameters.Name = sampleName; parameters.Namespace = sampleName; parameters.OutputDirectory = outputPath; parameters.Logger = logger; if (!generator.PrepareForRun(parameters).Result) { logger.Error("PrepareForRun returned false for the TemplateSampleGenerator"); } if (!generator.Run(parameters)) { logger.Error("Run returned false for the TemplateSampleGenerator"); } var updaterTemplate = xenkoTemplates.First(x => x.FullPath.ToString().EndsWith("UpdatePlatforms.xktpl")); parameters.Description = updaterTemplate; if (logger.HasErrors) { throw new InvalidOperationException($"Error generating sample {sampleName} from template:\r\n{logger.ToText()}"); } return(session); }
private EffectParameterType ConvertVariableValueType(ShaderVariableType type, LoggerResult log) { EffectParameterType effectParameterType; if (!MapTypes.TryGetValue(type, out effectParameterType)) { log.Error("Type [{0}] from D3DCompiler not supported", type); } return(effectParameterType); }
public static bool EnsureRouterLaunched(bool attachChildJob = false, bool checkIfPortOpen = true) { try { // Try to connect to router FileVersionInfo runningRouterVersion = null; Process runningRouterProcess = null; foreach (var process in Process.GetProcessesByName("Stride.ConnectionRouter")) { try { runningRouterVersion = process.MainModule.FileVersionInfo; runningRouterProcess = process; break; } catch (Exception) { } } // Make sure to use .exe rather than .dll (.NET Core) var defaultRouterAssemblyLocation = LoaderToolLocator.GetExecutable(typeof(Router).Assembly.Location); if (defaultRouterAssemblyLocation == null) { throw new InvalidOperationException("Could not find Connection Router assembly location"); } // Setup with default locations var routerAssemblyLocation = defaultRouterAssemblyLocation; var routerAssemblyExe = Path.GetFileName(routerAssemblyLocation); // Try to locate using Stride.ConnectionRouter package var logger = new LoggerResult(); var package = PackageStore.Instance.FindLocalPackage("Stride.ConnectionRouter", new PackageVersionRange(new PackageVersion(StrideVersion.NuGetVersion))); if (package != null) { routerAssemblyLocation = package.GetFiles().FirstOrDefault(x => string.Compare(Path.GetFileName(x.Path), routerAssemblyExe, true) == 0)?.FullPath ?? routerAssemblyLocation; } // If already started, check if found version is same that we wanted to start if (runningRouterVersion != null) { var routerAssemblyFileVersionInfo = FileVersionInfo.GetVersionInfo(routerAssemblyLocation); // Check that current router is at least as good as the one of latest found Stride if (new PackageVersion(routerAssemblyFileVersionInfo.FileVersion) <= new PackageVersion(runningRouterVersion.FileVersion)) { return(true); } } // Kill previous router process (if any) if (runningRouterProcess != null) { runningRouterProcess.Kill(); runningRouterProcess.WaitForExit(); } // Start new router process var spawnedRouterProcess = Process.Start(routerAssemblyLocation); // If we are in "developer" mode, attach job so that it gets killed with editor if (attachChildJob && spawnedRouterProcess != null) { new AttachedChildProcessJob(spawnedRouterProcess); } if (checkIfPortOpen) { using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)) { // Try during 5 seconds (10 * 500 msec) for (int i = 0; i < 10; ++i) { try { socket.Connect("localhost", RouterClient.DefaultPort); } catch (SocketException) { // Try again in 500 msec Thread.Sleep(500); continue; } break; } } } return(spawnedRouterProcess != null); } catch { return(false); } }
public PackageBuilderOptions(LoggerResult logger) { if (logger == null) throw new ArgumentNullException("logger"); Logger = logger; }
/// <summary> /// Find the base definition of the method and override its occurrence /// </summary> /// <param name="methodDeclaration"></param> /// <param name="errorLogger"></param> private void LookForBaseDeclarationMixin(MethodDeclaration methodDeclaration, LoggerResult errorLogger) { foreach (var dict in VirtualTableGroup.Select(x => x.Value)) { for (int i = 0; i < dict.Length; ++i) { var method = dict[i]; var baseDeclarationMixin = (string)method.GetTag(StrideTags.BaseDeclarationMixin); // TODO: take typedefs into account... if (method.IsSameSignature(methodDeclaration)) { var sourceShader = ((ModuleMixin)methodDeclaration.GetTag(StrideTags.ShaderScope)).MixinName; // test override if (methodDeclaration is MethodDefinition && method is MethodDefinition && !methodDeclaration.Qualifiers.Contains(StrideStorageQualifier.Override)) { errorLogger.Error(StrideMessageCode.ErrorMissingOverride, method.Span, methodDeclaration, sourceShader); } if (!(methodDeclaration is MethodDefinition)) { errorLogger.Error(StrideMessageCode.ErrorOverrindingDeclaration, method.Span, methodDeclaration, sourceShader); } if (method.Qualifiers.Contains(StrideStorageQualifier.Stage) && !methodDeclaration.Qualifiers.Contains(StrideStorageQualifier.Stage)) { errorLogger.Warning(StrideMessageCode.WarningMissingStageKeyword, methodDeclaration.Span, methodDeclaration, (methodDeclaration.GetTag(StrideTags.ShaderScope) as ModuleMixin).MixinName); methodDeclaration.Qualifiers |= StrideStorageQualifier.Stage; } else if (!method.Qualifiers.Contains(StrideStorageQualifier.Stage) && methodDeclaration.Qualifiers.Contains(StrideStorageQualifier.Stage)) { errorLogger.Error(StrideMessageCode.ErrorExtraStageKeyword, methodDeclaration.Span, methodDeclaration, method, (methodDeclaration.GetTag(StrideTags.ShaderScope) as ModuleMixin).MixinName); methodDeclaration.Qualifiers.Values.Remove(StrideStorageQualifier.Stage); } dict[i] = methodDeclaration; methodDeclaration.SetTag(StrideTags.BaseDeclarationMixin, baseDeclarationMixin); } } } }
public LocalCommandContext(IExecuteContext executeContext, CommandBuildStep step, BuilderContext builderContext) : base(step.Command, builderContext) { this.executeContext = executeContext; logger = new ForwardingLoggerResult(executeContext.Logger); Step = step; }
public ShaderNavigationResult() { Messages = new LoggerResult(); }
/// <summary> /// Adds the methods defined in the final mixin /// </summary> /// <param name="methodDeclarations">a list of MethodDeclaration</param> /// <param name="className">the name of the class</param> /// <param name="errorLogger">the logger for errors and warnings</param> public void AddFinalDeclarations(List <MethodDeclaration> methodDeclarations, string className, LoggerResult errorLogger) { var finalDict = new MethodDeclaration[methodDeclarations.Count]; foreach (var methodDecl in methodDeclarations) { var vtableReference = (VTableReference)methodDecl.GetTag(StrideTags.VirtualTableReference); finalDict[vtableReference.Slot] = methodDecl; // TODO: override/abstract behavior //if (methodDecl.Qualifiers.Contains(StrideStorageQualifier.Override)) LookForBaseDeclarationMixin(methodDecl, errorLogger); } VirtualTableGroup.Add(className, finalDict); }
private EffectBytecodeCompilerResult CompileBytecode(ShaderMixinSource mixinTree, EffectCompilerParameters effectParameters, CompilerParameters compilerParameters, ObjectId mixinObjectId, DatabaseFileProvider database, string compiledUrl) { // Open the database for writing var log = new LoggerResult(); var effectLog = GlobalLogger.GetLogger("EffectCompilerCache"); // Note: this compiler is expected to not be async and directly write stuff in localLogger var compiledShader = base.Compile(mixinTree, effectParameters, compilerParameters).WaitForResult(); compiledShader.CompilationLog.CopyTo(log); // If there are any errors, return immediately if (log.HasErrors) { lock (compilingShaders) { compilingShaders.Remove(mixinObjectId); } log.CopyTo(effectLog); return(new EffectBytecodeCompilerResult(null, log)); } // Compute the bytecodeId var newBytecodeId = compiledShader.Bytecode.ComputeId(); // Check if we really need to store the bytecode lock (bytecodes) { // Using custom serialization to the database to store an object with a custom id // TODO: Check if we really need to write the bytecode everytime even if id is not changed var memoryStream = new MemoryStream(); compiledShader.Bytecode.WriteTo(memoryStream); // Write current cache at the end (not part of the pure bytecode, but we use this as meta info) var writer = new BinarySerializationWriter(memoryStream); writer.Write(CurrentCache); memoryStream.Position = 0; database.ObjectDatabase.Write(memoryStream, newBytecodeId, true); database.ContentIndexMap[compiledUrl] = newBytecodeId; // Save bytecode Id to the database cache as well memoryStream.SetLength(0); memoryStream.Write((byte[])newBytecodeId, 0, ObjectId.HashSize); memoryStream.Position = 0; database.ObjectDatabase.Write(memoryStream, mixinObjectId, true); if (!bytecodes.ContainsKey(newBytecodeId)) { log.Verbose($"New effect compiled #{effectCompileCount} [{mixinObjectId}] (db: {newBytecodeId})\r\n{compilerParameters?.ToStringPermutationsDetailed()}"); Interlocked.Increment(ref effectCompileCount); // Replace or add new bytecode bytecodes[newBytecodeId] = new KeyValuePair <EffectBytecode, EffectBytecodeCacheLoadSource>(compiledShader.Bytecode, EffectBytecodeCacheLoadSource.JustCompiled); } } lock (compilingShaders) { compilingShaders.Remove(mixinObjectId); } log.CopyTo(effectLog); return(compiledShader); }
public ModuleMixinInfo() { Log = new LoggerResult(); Instanciated = true; }
public static void Instantiate(ShaderClassType classType, Dictionary <string, Expression> expressions, Dictionary <string, Identifier> identifiers, bool autoGenericInstances, LoggerResult log) { var instantiator = new XenkoClassInstantiator(classType, expressions, identifiers, autoGenericInstances, log); instantiator.Run(); }
public EffectBytecodeCompilerResult(EffectBytecode bytecode, LoggerResult compilationLog) { Bytecode = bytecode; CompilationLog = compilationLog; }
private EffectParameterResourceData GetResourceBinding(SharpDX.D3DCompiler.InputBindingDescription bindingDescriptionRaw, string name, LoggerResult log) { var paramClass = EffectParameterClass.Object; var paramType = EffectParameterType.Void; switch (bindingDescriptionRaw.Type) { case SharpDX.D3DCompiler.ShaderInputType.TextureBuffer: paramType = EffectParameterType.TextureBuffer; paramClass = EffectParameterClass.TextureBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.ConstantBuffer: paramType = EffectParameterType.ConstantBuffer; paramClass = EffectParameterClass.ConstantBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.Texture: paramClass = EffectParameterClass.ShaderResourceView; switch (bindingDescriptionRaw.Dimension) { case SharpDX.Direct3D.ShaderResourceViewDimension.Buffer: paramType = EffectParameterType.Buffer; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture1D: paramType = EffectParameterType.Texture1D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture1DArray: paramType = EffectParameterType.Texture1DArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D: paramType = EffectParameterType.Texture2D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DArray: paramType = EffectParameterType.Texture2DArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DMultisampled: paramType = EffectParameterType.Texture2DMultisampled; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DMultisampledArray: paramType = EffectParameterType.Texture2DMultisampledArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture3D: paramType = EffectParameterType.Texture3D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.TextureCube: paramType = EffectParameterType.TextureCube; break; case SharpDX.Direct3D.ShaderResourceViewDimension.TextureCubeArray: paramType = EffectParameterType.TextureCubeArray; break; } break; case SharpDX.D3DCompiler.ShaderInputType.Structured: paramClass = EffectParameterClass.ShaderResourceView; paramType = EffectParameterType.StructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.ByteAddress: paramClass = EffectParameterClass.ShaderResourceView; paramType = EffectParameterType.ByteAddressBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewRWTyped: paramClass = EffectParameterClass.UnorderedAccessView; switch (bindingDescriptionRaw.Dimension) { case SharpDX.Direct3D.ShaderResourceViewDimension.Buffer: paramType = EffectParameterType.RWBuffer; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture1D: paramType = EffectParameterType.RWTexture1D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture1DArray: paramType = EffectParameterType.RWTexture1DArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D: paramType = EffectParameterType.RWTexture2D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DArray: paramType = EffectParameterType.RWTexture2DArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture3D: paramType = EffectParameterType.RWTexture3D; break; } break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewRWStructured: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.RWStructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewRWByteAddress: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.RWByteAddressBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewAppendStructured: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.AppendStructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewConsumeStructured: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.ConsumeStructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewRWStructuredWithCounter: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.RWStructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.Sampler: paramClass = EffectParameterClass.Sampler; paramType = EffectParameterType.Sampler; break; } var binding = new EffectParameterResourceData() { Param = { KeyName = name, RawName = bindingDescriptionRaw.Name, Class = paramClass, Type = paramType }, SlotStart = bindingDescriptionRaw.BindPoint, SlotCount = bindingDescriptionRaw.BindCount, }; return binding; }
public static void Build(ILogger log, Package package, string outputDirectory = null) { if (package == null) { throw new ArgumentNullException(nameof(package)); } var meta = new ManifestMetadata(); PackageStore.ToNugetManifest(package.Meta, meta); // Sanity check: Xenko version should be same between NuGet package and Xenko package var nugetVersion = new PackageVersion(XenkoVersion.NuGetVersion).Version; var packageVersion = package.Meta.Version.Version; if (nugetVersion != packageVersion) { log.Error($"Package has mismatching version: NuGet package version is {nugetVersion} and Xenko Package version is {packageVersion}"); return; } if (nugetVersion.Revision <= 0) { // If 0, we have special cases with NuGet dropping it in install path, could be dangerous and lead to bugs if not properly tested. log.Error($"Package has revision {nugetVersion} but 4th digit needs to be at least 1."); return; } // Override version with NuGet version (4th number is different in Xenko package) meta.Version = XenkoVersion.NuGetVersion; var builder = new NugetPackageBuilder(); builder.Populate(meta); var currentAssemblyLocation = Assembly.GetExecutingAssembly().Location; var mainPlatformDirectory = Path.GetFileName(Path.GetDirectoryName(currentAssemblyLocation)); // TODO this is not working // We are excluding everything that is in a folder that starts with a dot (ie. .shadow, .vs) var files = new List <ManifestFile>() { NewFile(@"Bin\**\*.exe", "Bin", @"Bin\**\.*\**\*.exe;Bin\**\Tools\**.exe"), NewFile(@"Bin\**\*.so", "Bin", @"Bin\**\.*\**\*.so;Bin\Windows\lib\**\*.so"), NewFile(@"Bin\**\*.ssdeps", "Bin", @"Bin\**\.*\**\*.ssdeps"), NewFile(@"Bin\**\*.a", "Bin", @"Bin\**\.*\**\*.a"), NewFile(@"Bin\**\*.md", "Bin", @"Bin\**\.*\**\*.md"), NewFile(@"Bin\**\*.html", "Bin", @"Bin\**\.*\**\*.html"), NewFile(@"Bin\**\*.config", "Bin", @"Bin\**\.*\**\*.config"), NewFile(@"Bin\**\*.dll", "Bin", @"Bin\**\.*\**\*.dll;Bin\Windows\lib\**\*.dll"), NewFile(@"Bin\**\*.xml", "Bin", @"Bin\**\.*\**\*.xml"), NewFile(@"Bin\**\*.usrdoc", "Bin", @"Bin\**\.*\**\*.usrdoc"), NewFile(@"Bin\**\*.winmd", "Bin", @"Bin\**\.*\**\*.winmd"), NewFile(@"Bin\**\*.sh", "Bin", @"Bin\**\.*\**\*.sh"), NewFile(@"Bin\**\*.json", "Bin", @"Bin\**\.*\**\*.json"), NewFile(@"deps\AssemblyProcessor\*.exe", @"deps/AssemblyProcessor"), NewFile(@"deps\AssemblyProcessor\*.dll", @"deps/AssemblyProcessor"), NewFile(@"deps\CoreFX\**\*.*", @"deps\CoreFX"), NewFile($@"Bin\{mainPlatformDirectory}\ios-tcprelay\*.py", $@"Bin\{mainPlatformDirectory}\ios-tcprelay"), NewFile(@"Targets\*.targets", "Targets"), NewFile($@"Bin\{mainPlatformDirectory}\SiliconStudio.*.pdb", $@"Bin\{mainPlatformDirectory}", @"Bin\**\SiliconStudio.Xenko.Importer*.pdb;Bin\**\SiliconStudio.Xenko.Assimp.Translation.pdb"), }; // Handle Assets var rootDir = package.RootDirectory; var newPackage = new Package { Meta = package.Meta }; foreach (var profile in package.Profiles) { var target = "Assets/" + profile.Name; foreach (var assetFolder in profile.AssetFolders) { // TODO: handle exclude in asset folders //files.Add(NewFile(source, target, @"**\*.cs;**\*.hlsl;**\*.csproj;**\*.csproj.user;**\obj\**")); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xksl", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xkfx", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xkfnt", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xksheet", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xkuilib", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xkgfxcomp", target)); files.Add(NewFile(assetFolder.Path.MakeRelative(rootDir) + "/**/*.xktex", target)); var resourceFolder = UPath.Combine(assetFolder.Path, new UDirectory("../../Resources")); if (Directory.Exists(resourceFolder.ToWindowsPath())) { files.Add(NewFile(resourceFolder.MakeRelative(rootDir) + "/**/*.*", "Resources")); } } var targetProfile = new PackageProfile(profile.Name); targetProfile.AssetFolders.Add(new AssetFolder(target)); newPackage.Profiles.Add(targetProfile); } //Handle RootAssets foreach (var rootAsset in package.RootAssets) { newPackage.RootAssets.Add(rootAsset); } // Handle templates var targetFolder = new TemplateFolder("Templates"); foreach (var templateFolder in package.TemplateFolders) { var source = templateFolder.Path.MakeRelative(rootDir) + "/**"; UDirectory target = targetFolder.Path; if (templateFolder.Group != null) { target = UPath.Combine(target, templateFolder.Group); } var excludeFiles = templateFolder.Exclude; files.Add(NewFile(source, target, excludeFiles)); // Add template files foreach (var templateFile in templateFolder.Files) { var newTemplateFile = templateFile.MakeRelative(templateFolder.Path); if (templateFolder.Group != null) { newTemplateFile = UPath.Combine(templateFolder.Group, newTemplateFile); } newTemplateFile = UPath.Combine(targetFolder.Path, newTemplateFile); targetFolder.Files.Add(newTemplateFile); } } // Add files builder.PopulateFiles(package.RootDirectory, files); files.Clear(); var dataFiles = builder.Files.ToList(); builder.ClearFiles(); // Create temp package for archive newPackage.TemplateFolders.Add(targetFolder); var newPackageFileName = "temp" + Guid.NewGuid() + ".xkpkg"; newPackage.FullPath = package.RootDirectory + "/" + newPackageFileName; var result = new LoggerResult(); newPackage.Save(result); if (result.HasErrors) { throw new InvalidOperationException(result.ToText()); // TODO throw error } // Add the package file files.Add(NewFile(newPackageFileName, package.Meta.Name + Package.PackageFileExtension)); // Add entry point to decompress LZMA files.Add(NewFile(@"tools\**\*.exe", "tools")); files.Add(NewFile(@"tools\**\*.dll", "tools")); // Add an empty .xz file so that it gets added to [Content_Types].xml // This file will be removed later files.Add(NewFile(@"tools\data_empty.xz", string.Empty)); // Repopulate with .xkpkg file builder.PopulateFiles(package.RootDirectory, files); outputDirectory = outputDirectory ?? Environment.CurrentDirectory; // Save the nupkg var outputPath = GetOutputPath(builder, outputDirectory); bool isExistingPackage = File.Exists(outputPath); if (isExistingPackage) { File.Delete(outputPath); } try { using (Stream stream = File.Create(outputPath)) { builder.Save(stream); stream.Position = 0; // Add LZMA file as update so that it is stored without compression using (var archive = new ZipArchive(stream, ZipArchiveMode.Update, true)) { // Delete data_empty.xz var dataEntry = archive.GetEntry("data_empty.xz"); dataEntry.Delete(); // Create data.xz (no compression since .xz is already compressed) dataEntry = archive.CreateEntry("data.xz", CompressionLevel.NoCompression); using (var dataStream = dataEntry.Open()) { // Generate LZMA using (var indexedArchive = new IndexedArchive()) { foreach (var file in dataFiles) { indexedArchive.AddFile(Path.Combine(package.RootDirectory, file.SourcePath), file.Path); } indexedArchive.Save(dataStream, new ConsoleProgressReport()); } } } } } catch { if (!isExistingPackage && File.Exists(outputPath)) { File.Delete(outputPath); } throw; } File.Delete(newPackage.FullPath); }
private EffectParameterType ConvertVariableValueType(ShaderVariableType type, LoggerResult log) { EffectParameterType effectParameterType; if (!MapTypes.TryGetValue(type, out effectParameterType)) { log.Error("Type [{0}] from D3DCompiler not supported", type); } return effectParameterType; }
private XenkoClassInstantiator(ShaderClassType classType, Dictionary <string, Expression> expressions, Dictionary <string, Identifier> identifiers, bool autoGenericInstances, LoggerResult log) : base(false, false) { shaderClassType = classType; expressionGenerics = expressions; identifiersGenerics = identifiers; this.autoGenericInstances = autoGenericInstances; logger = log; variableGenerics = shaderClassType.ShaderGenerics.ToDictionary(x => x.Name.Text, x => x); }
private EffectParameterResourceData GetResourceBinding(SharpDX.D3DCompiler.InputBindingDescription bindingDescriptionRaw, string name, LoggerResult log) { var paramClass = EffectParameterClass.Object; var paramType = EffectParameterType.Void; switch (bindingDescriptionRaw.Type) { case SharpDX.D3DCompiler.ShaderInputType.TextureBuffer: paramType = EffectParameterType.TextureBuffer; paramClass = EffectParameterClass.TextureBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.ConstantBuffer: paramType = EffectParameterType.ConstantBuffer; paramClass = EffectParameterClass.ConstantBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.Texture: paramClass = EffectParameterClass.ShaderResourceView; switch (bindingDescriptionRaw.Dimension) { case SharpDX.Direct3D.ShaderResourceViewDimension.Buffer: paramType = EffectParameterType.Buffer; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture1D: paramType = EffectParameterType.Texture1D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture1DArray: paramType = EffectParameterType.Texture1DArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D: paramType = EffectParameterType.Texture2D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DArray: paramType = EffectParameterType.Texture2DArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DMultisampled: paramType = EffectParameterType.Texture2DMultisampled; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DMultisampledArray: paramType = EffectParameterType.Texture2DMultisampledArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture3D: paramType = EffectParameterType.Texture3D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.TextureCube: paramType = EffectParameterType.TextureCube; break; case SharpDX.Direct3D.ShaderResourceViewDimension.TextureCubeArray: paramType = EffectParameterType.TextureCubeArray; break; } break; case SharpDX.D3DCompiler.ShaderInputType.Structured: paramClass = EffectParameterClass.ShaderResourceView; paramType = EffectParameterType.StructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.ByteAddress: paramClass = EffectParameterClass.ShaderResourceView; paramType = EffectParameterType.ByteAddressBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewRWTyped: paramClass = EffectParameterClass.UnorderedAccessView; switch (bindingDescriptionRaw.Dimension) { case SharpDX.Direct3D.ShaderResourceViewDimension.Buffer: paramType = EffectParameterType.RWBuffer; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture1D: paramType = EffectParameterType.RWTexture1D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture1DArray: paramType = EffectParameterType.RWTexture1DArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D: paramType = EffectParameterType.RWTexture2D; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture2DArray: paramType = EffectParameterType.RWTexture2DArray; break; case SharpDX.Direct3D.ShaderResourceViewDimension.Texture3D: paramType = EffectParameterType.RWTexture3D; break; } break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewRWStructured: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.RWStructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewRWByteAddress: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.RWByteAddressBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewAppendStructured: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.AppendStructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewConsumeStructured: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.ConsumeStructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.UnorderedAccessViewRWStructuredWithCounter: paramClass = EffectParameterClass.UnorderedAccessView; paramType = EffectParameterType.RWStructuredBuffer; break; case SharpDX.D3DCompiler.ShaderInputType.Sampler: paramClass = EffectParameterClass.Sampler; paramType = EffectParameterType.Sampler; break; } var binding = new EffectParameterResourceData() { Param = { KeyName = name, RawName = bindingDescriptionRaw.Name, Class = paramClass, Type = paramType }, SlotStart = bindingDescriptionRaw.BindPoint, SlotCount = bindingDescriptionRaw.BindCount, }; return(binding); }
private ShaderConstantBufferDescription GetConstantBufferReflection(ConstantBuffer constantBufferRaw, ref ConstantBufferDescription constantBufferRawDesc, ShaderConstantBufferDescription linkBuffer, LoggerResult log) { var constantBuffer = new ShaderConstantBufferDescription { Name = constantBufferRawDesc.Name, Size = constantBufferRawDesc.Size, }; switch (constantBufferRawDesc.Type) { case SharpDX.D3DCompiler.ConstantBufferType.ConstantBuffer: constantBuffer.Type = ConstantBufferType.ConstantBuffer; break; case SharpDX.D3DCompiler.ConstantBufferType.TextureBuffer: constantBuffer.Type = ConstantBufferType.TextureBuffer; break; default: constantBuffer.Type = ConstantBufferType.Unknown; break; } // ConstantBuffers variables var members = new List<EffectParameterValueData>(); for (int i = 0; i < constantBufferRawDesc.VariableCount; i++) { var variable = constantBufferRaw.GetVariable(i); var variableType = variable.GetVariableType(); var variableDescription = variable.Description; var variableTypeDescription = variableType.Description; var parameter = new EffectParameterValueData() { Param = { Class = (EffectParameterClass)variableTypeDescription.Class, Type = ConvertVariableValueType(variableTypeDescription.Type, log), RawName = variableDescription.Name, }, Offset = variableDescription.StartOffset, Size = variableDescription.Size, Count = variableTypeDescription.ElementCount == 0 ? 1 : variableTypeDescription.ElementCount, RowCount = (byte)variableTypeDescription.RowCount, ColumnCount = (byte)variableTypeDescription.ColumnCount, }; if (variableTypeDescription.Offset != 0) { log.Error("Unexpected offset [{0}] for variable [{1}] in constant buffer [{2}]", variableTypeDescription.Offset, variableDescription.Name, constantBuffer.Name); } bool bindingNotFound = true; // Retrieve Link Member foreach (var binding in linkBuffer.Members) { if (binding.Param.RawName == variableDescription.Name) { // TODO: should we replicate linkMember.Count/RowCount/ColumnCount? or use what is retrieved by D3DCompiler reflection parameter.Param.KeyName = binding.Param.KeyName; bindingNotFound = false; break; } } if (bindingNotFound) { log.Error("Variable [{0}] in constant buffer [{1}] has no link", variableDescription.Name, constantBuffer.Name); } members.Add(parameter); } constantBuffer.Members = members.ToArray(); return constantBuffer; }
public override EffectBytecode Compile(ShaderMixinSource mixin, string fullEffectName, ShaderMixinParameters compilerParameters, HashSet <string> modifiedShaders, HashSet <string> recentlyModifiedShaders, LoggerResult log) { throw new NotSupportedException("Shader Compilation is not allowed at run time on this platform."); }
/// <summary> /// Converts the specified hlsl source code to glsl. /// </summary> /// <param name="hlslSourcecode">The HLSL source code.</param> /// <param name="hlslEntryPoint">The HLSL entry point.</param> /// <param name="stage">The stage to convert.</param> /// <param name="shader">The shader.</param> /// <param name="inputHlslFilepath">The input HLSL filepath.</param> /// <returns> /// The resulting glsl AST tree. /// </returns> public global::SiliconStudio.Shaders.Ast.Shader Convert(string hlslSourcecode, string hlslEntryPoint, PipelineStage stage, string inputHlslFilepath, LoggerResult log) { try { // Convert from Framework.Graphics ShaderMacro to Framework.Shaders ShaderMacro var macros = new global::SiliconStudio.Shaders.Parser.ShaderMacro[Macros.Count]; for (int index = 0; index < Macros.Count; index++) { macros[index] = new global::SiliconStudio.Shaders.Parser.ShaderMacro(Macros[index].Name, Macros[index].Definition); } var result = HlslParser.TryPreProcessAndParse(hlslSourcecode, inputHlslFilepath, macros, IncludeDirectories); if (result.HasErrors) { log.Error(result.ToString()); return(null); } // Prepare the shader before type inference analysis HlslToGlslConvertor.Prepare(result.Shader); HlslSemanticAnalysis.Run(result); // If there are any type inference analysis, just display all errors but ytu if (result.HasErrors) { log.Error(result.ToString()); return(null); } return(Convert(result, hlslEntryPoint, stage, inputHlslFilepath, log)); } catch (Exception ex) { log.Error("Unexpected error while converting file [{0}] with entry point [{1}]", ex, inputHlslFilepath, hlslEntryPoint); } return(null); }
private BuildResultCode BuildGetGraphicsPlatform() { var localLogger = new LoggerResult(); var simplePackage = Package.Load(localLogger, builderOptions.PackageFile, new PackageLoadParameters { AutoLoadTemporaryAssets = false, LoadAssemblyReferences = false, AutoCompileProjects = false }); if (simplePackage == null || localLogger.HasErrors) { localLogger.CopyTo(builderOptions.Logger); return BuildResultCode.BuildError; } var buildProfile = simplePackage.Profiles.FirstOrDefault(pair => pair.Name == builderOptions.BuildProfile); if (buildProfile == null) { builderOptions.Logger.Error("Package {0} did not contain platform {1}", builderOptions.PackageFile, builderOptions.BuildProfile); return BuildResultCode.BuildError; } // For now, graphics platform is implicit. // It will need to be readded to GameSettingsAsset at some point. var graphicsPlatform = builderOptions.Platform.GetDefaultGraphicsPlatform(); Console.WriteLine(graphicsPlatform); return BuildResultCode.Successful; }
/// <summary> /// Converts the specified hlsl source code to glsl. /// </summary> /// <param name="hlslEntryPoint">The HLSL entry point.</param> /// <param name="stage">The stage to convert.</param> /// <param name="shader">The shader.</param> /// <param name="inputHlslFilepath">The input HLSL filepath.</param> /// <returns> /// The resulting glsl AST tree. /// </returns> private global::SiliconStudio.Shaders.Ast.Shader Convert(ParsingResult result, string hlslEntryPoint, PipelineStage stage, string inputHlslFilepath, LoggerResult log) { try { var convertor = new HlslToGlslConvertor(hlslEntryPoint, stage, ShaderModel.Model40) // TODO HARDCODED VALUE to change { KeepConstantBuffer = !isOpenGLES, TextureFunctionsCompatibilityProfile = isOpenGLES, NoSwapForBinaryMatrixOperation = true, UseBindingLayout = false, UseLocationLayout = false, UseSemanticForVariable = true, IsPointSpriteShader = false, ViewFrustumRemap = true, KeepNonUniformArrayInitializers = !isOpenGLES }; convertor.Run(result); // After the converter we display the errors but we don't stop writing output glsl if (result.HasErrors) { //DisplayError(log, result, "Error while converting file:"); } return(result.Shader); } catch (Exception ex) { log.Error("Unexpected error while converting file [{0}] with entry point [{1}]", ex, inputHlslFilepath, hlslEntryPoint); return(null); } }
private static void GenerateUnitTestProject(string outputDirectory, string templateFile, string name) { var projectTemplate = ProjectTemplate.Load(templateFile); // Force reference to Paradox.Assets (to have acess to SolutionPlatform) projectTemplate.Assemblies.Add(typeof(GraphicsProfile).Assembly.FullName); projectTemplate.Assemblies.Add(typeof(ParadoxConfig).Assembly.FullName); var options = new Dictionary <string, object>(); var session = new PackageSession(); var result = new LoggerResult(); var templateGeneratorParameters = new TemplateGeneratorParameters(); templateGeneratorParameters.OutputDirectory = outputDirectory; templateGeneratorParameters.Session = session; templateGeneratorParameters.Name = name; templateGeneratorParameters.Logger = result; templateGeneratorParameters.Description = new TemplateDescription(); PackageUnitTestGenerator.Default.Generate(templateGeneratorParameters); if (result.HasErrors) { Console.WriteLine("Error generating package: {0}", result.ToText()); return; } var package = templateGeneratorParameters.Package; var previousCurrent = session.CurrentPackage; session.CurrentPackage = package; // Compute Paradox Sdk relative path // We are supposed to be in standard output binary folder, so Paradox root should be at ..\.. var paradoxPath = UDirectory.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), new UDirectory(@"..\..")); var paradoxRelativePath = new UDirectory(paradoxPath) .MakeRelative(outputDirectory) .ToString() .Replace('/', '\\'); paradoxRelativePath = paradoxRelativePath.TrimEnd('\\'); options["Namespace"] = name; options["Package"] = package; options["Platforms"] = new List <SolutionPlatform>(AssetRegistry.SupportedPlatforms); options["ParadoxSdkRelativeDir"] = paradoxRelativePath; // Generate project template var projectGuid = Guid.NewGuid(); result = projectTemplate.Generate(outputDirectory, name, projectGuid, options); if (result.HasErrors) { Console.WriteLine("Error generating solution: {0}", result.ToText()); return; } var sharedProfile = package.Profiles.FindSharedProfile(); // Setup the assets folder Directory.CreateDirectory(UPath.Combine(outputDirectory, (UDirectory)"Assets/Shared")); // Add Windows test as Shared library var projectWindowsRef = new ProjectReference(); projectWindowsRef.Id = projectGuid; projectWindowsRef.Location = UPath.Combine(outputDirectory, (UFile)(name + ".Windows.csproj")); projectWindowsRef.Type = SiliconStudio.Assets.ProjectType.Library; sharedProfile.ProjectReferences.Add(projectWindowsRef); // Generate executable projects for each platform foreach (var platform in AssetRegistry.SupportedPlatforms) { var platformProfile = new PackageProfile(platform.Name) { Platform = platform.Type }; platformProfile.AssetFolders.Add(new AssetFolder("Assets/" + platform.Name)); // Log progress var projectName = name + "." + platform.Type; // Create project reference var projectPlatformRef = new ProjectReference(); projectPlatformRef.Id = projectGuid; projectPlatformRef.Location = UPath.Combine(outputDirectory, (UFile)(projectName + ".csproj")); projectPlatformRef.Type = SiliconStudio.Assets.ProjectType.Executable; platformProfile.ProjectReferences.Add(projectPlatformRef); // Add build configuration per platform platform.Properties.CopyTo(platformProfile.Properties, true); package.Profiles.Add(platformProfile); } session.CurrentPackage = previousCurrent; result = session.Save(); if (result.HasErrors) { Console.WriteLine("Error saving package: {0}", result.ToText()); return; } }
/// <summary> /// Adds the virtual table of the mixin /// </summary> /// <param name="shaderVirtualTable"></param> /// <param name="className"></param> /// <param name="errorLogger"></param> public void AddVirtualTable(ShaderVirtualTable shaderVirtualTable, string className, LoggerResult errorLogger) { var newVT = shaderVirtualTable.VirtualTableGroup[className].ToArray(); VirtualTableGroup.Add(className, newVT); foreach (var methodDecl in newVT) { ReplaceVirtualMethod(methodDecl, errorLogger); } }
/// <summary> /// Get a compilation context based on the macros /// </summary> /// <param name="mixinToAnalyze">List of mixin to analyze</param> /// <param name="log">The log.</param> /// <returns>the correct compilation context</returns> private ShaderCompilationContext GetCompilationContext(IEnumerable <ModuleMixinInfo> mixinToAnalyze, LoggerResult log) { var mixinInfos = new HashSet <ModuleMixinInfo>(); foreach (var mixin in mixinToAnalyze) { mixinInfos.UnionWith(mixin.MinimalContext); } var context = new ShaderCompilationContext(log); context.Preprocess(mixinInfos); return(context); }