public static Logger CleanContext()
{
// delete previous build data
if (Directory.Exists(BuildPath))
{
Directory.Delete(BuildPath, true);
}
// Create database directory
((FileSystemProvider)VirtualFileSystem.ApplicationData).ChangeBasePath(BuildPath);
VirtualFileSystem.CreateDirectory(VirtualFileSystem.ApplicationDatabasePath);
// Delete source folder if exists
if (Directory.Exists(FileSourceFolder))
{
Directory.Delete(FileSourceFolder, true);
}
Builder.CloseObjectDatabase();
TestCommand.ResetCounter();
if (!loggerHandled)
{
GlobalLogger.GlobalMessageLogged += new ConsoleLogListener();
loggerHandled = true;
}
return(GlobalLogger.GetLogger("UnitTest"));
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="GraphViewModelService"/> to use for this view model.</param>
/// <param name="type"></param>
/// <param name="rootPresenters">The root <see cref="INodePresenter"/> instances.</param>
private GraphViewModel([NotNull] IViewModelServiceProvider serviceProvider, [NotNull] Type type, [NotNull] IEnumerable <INodePresenter> rootPresenters)
: base(serviceProvider)
{
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (rootPresenters == null)
{
throw new ArgumentNullException(nameof(rootPresenters));
}
GraphViewModelService = serviceProvider.TryGet <GraphViewModelService>();
if (GraphViewModelService == null)
{
throw new InvalidOperationException($"{nameof(GraphViewModel)} requires a {nameof(GraphViewModelService)} in the service provider.");
}
Logger = GlobalLogger.GetLogger(DefaultLoggerName);
if (rootPresenters == null)
{
throw new ArgumentNullException(nameof(rootNode));
}
var viewModelFactory = serviceProvider.Get <GraphViewModelService>().NodeViewModelFactory;
viewModelFactory.CreateGraph(this, type, rootPresenters);
}
public override void Serialize(ContentSerializerContext context, SerializationStream stream, Texture texture)
{
if (context.Mode == ArchiveMode.Serialize)
{
throw new NotImplementedException();
}
var assetManager = context.AssetManager;
var url = context.Url;
using (var textureData = Image.Load(stream.NativeStream))
{
try
{
texture.InitializeFrom(textureData.Description, new TextureViewDescription(), textureData.ToDataBox());
// Setup reload callback (reload from asset manager)
texture.Reload = (graphicsResource) =>
{
// TODO: Avoid loading/unloading the same data
var textureDataReloaded = assetManager.Load <Image>(url);
((Texture)graphicsResource).Recreate(textureDataReloaded.ToDataBox());
assetManager.Unload(textureDataReloaded);
};
}
catch (Exception ex)
{
GlobalLogger.GetLogger("GPUTexture").Error("Unable to load Texture {0}. See Debug for more information", ex, context.Url);
}
}
}
public GameStudioPreviewService(SessionViewModel session)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
this.session = session;
Dispatcher = session.Dispatcher;
AssetBuilderService = session.ServiceProvider.Get <GameStudioBuilderService>();
gameSettingsProvider = session.ServiceProvider.Get <GameSettingsProviderService>();
Logger = GlobalLogger.GetLogger("Preview");
loggerDebugPage = EditorDebugTools.CreateLogDebugPage(Logger, "Preview");
previewGameSettings = GameSettingsFactory.Create();
previewGameSettings.GetOrCreate <RenderingSettings>().DefaultGraphicsProfile = GraphicsProfile.Level_11_0;
UpdateGameSettings(gameSettingsProvider.CurrentGameSettings);
previewCompileContext.SetGameSettingsAsset(previewGameSettings);
previewCompileContext.CompilationContext = typeof(PreviewCompilationContext);
previewGameThread = new Thread(SafeAction.Wrap(StrideUIThread))
{
IsBackground = true, Name = "PreviewGame Thread"
};
previewGameThread.SetApartmentState(ApartmentState.STA);
previewGameThread.Start();
// Wait for the window handle to be generated on the proper thread
initializationSignal.WaitOne();
host = new GameEngineHost(windowHandle);
session.AssetPropertiesChanged += OnAssetPropertyChanged;
gameSettingsProvider.GameSettingsChanged += OnGameSettingsChanged;
}
public GameEngineBase(ContentManager contentManager, IServiceRegistry services, GameSystemCollection gameSystems = null)
{
Logger = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name);
GameClockManager = new GameClockManager(PhysicsGameTime);
_targetTimeDriftAdjustmentThreshold = GameClockManager.SimulationDeltaTime.Ticks / 10; // 10% of a single sim step
Services = (ServiceRegistry)services;
Content = contentManager;
GameSystems = gameSystems ?? new GameSystemCollection(Services);
// Replacing existing IGameSystemCollection with our own
var existingGameSystems = Services.GetService <IGameSystemCollection>();
if (existingGameSystems != null)
{
Services.RemoveService <IGameSystemCollection>();
}
Services.AddOrOverwriteService <IGameSystemCollection>(GameSystems);
var networkAssetDatabase = new NetworkAssetDatabase(Content, assetFolderUrls: new[] { "Prefabs", "Scenes" });
Services.AddOrOverwriteService(networkAssetDatabase);
Services.AddOrOverwriteService(GameClockManager);
var gameSettingsService = services.GetSafeServiceAs <IGameSettingsService>();
Settings = gameSettingsService.Settings;
}
public void TestGlobalLogger()
{
var log = GlobalLogger.GetLogger("Module1");
var logbis = GlobalLogger.GetLogger("Module1");
var log1x = GlobalLogger.GetLogger("Module1x");
// Check that we get the same instance.
Assert.That(log, Is.EqualTo(logbis));
// This should work but no handler is installed.
log.Info("TEST");
// Instal a message handler.
var messages = new List <ILogMessage>();
GlobalLogger.GlobalMessageLogged += messages.Add;
// Log a simple message (disabled by default).
log.Verbose("#0");
Assert.That(messages.Count, Is.EqualTo(0));
// Activate the log for all loggers starting from Info
GlobalLogger.ActivateLog(".*", LogMessageType.Verbose);
// Log a simple message
log.Verbose("#0");
Assert.That(messages.Count, Is.EqualTo(1));
Assert.That(messages[0].Text, Is.EqualTo("#0"));
// Activate the log for Module1x starting from Debug
GlobalLogger.ActivateLog(".*x", LogMessageType.Debug);
log1x.Debug("#1");
Assert.That(messages.Count, Is.EqualTo(2));
Assert.That(messages[1].Text, Is.EqualTo("#1"));
}
public void TestBasicPackageCreateSaveLoad()
{
// Override search path since we are in a unit test directory
DirectoryHelper.PackageDirectoryOverride = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\..\..");
var defaultPackage = PackageStore.Instance.DefaultPackage;
PackageArchive.Build(GlobalLogger.GetLogger("PackageArchiveTest"), defaultPackage, AppDomain.CurrentDomain.BaseDirectory);
}
public void TestRuntime()
{
var package = new Package();
// ReSharper disable once UnusedVariable - we need a package session to compile
var packageSession = new PackageSession(package);
var otherAssets = new List <AssetItem>
{
new AssetItem("asset11", new MyAsset11(), package),
new AssetItem("asset12", new MyAsset12(), package),
new AssetItem("asset13", new MyAsset13(), package),
};
otherAssets.ForEach(x => package.Assets.Add(x));
var compileAssetReference = new MyAsset4
{
CompileAssetReference = CreateRef <MyContent11>(otherAssets[0]),
CompileContentReference = CreateRef <MyContent12>(otherAssets[1]),
CompileRuntimeReference = CreateRef <MyContent13>(otherAssets[2]),
};
var assetItem = new AssetItem("asset4", compileAssetReference, package);
package.Assets.Add(assetItem);
var asset = new MyAsset1 {
CompileAssetReference = CreateRef <MyContent2>(assetItem)
};
assetItem = new AssetItem("asset1", asset, package);
package.Assets.Add(assetItem);
package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location));
// Create context
var context = new AssetCompilerContext {
CompilationContext = typeof(AssetCompilationContext)
};
// Builds the project
Exception ex = null;
MyAsset1Compiler.AssertFunc = (url, ass, pkg) =>
{
AssertInThread(ref ex, () => Assert.AreEqual(1, TestCompilerBase.CompiledAssets.Count));
AssertInThread(ref ex, () => Assert.AreEqual(compileAssetReference.Id, TestCompilerBase.CompiledAssets.First().Id));
};
var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package));
var assetBuildResult = assetBuilder.Prepare(context);
// Since MyAsset4 is a Runtime reference, it should be compiled, so we should have 2 asset (MyAsset1 and MyAsset4) to compile.
Assert.AreEqual(2, assetBuildResult.BuildSteps.Count);
var builder = new Builder(GlobalLogger.GetLogger("Test"), "", "", "");
builder.Root.Add(assetBuildResult.BuildSteps);
builder.Run(Builder.Mode.Build, false);
RethrowAssertsFromThread(ex);
}
public void TestCompileAsset()
{
var package = new Package();
// ReSharper disable once UnusedVariable - we need a package session to compile
var packageSession = new PackageSession(package);
var otherAssets = new List <AssetItem>
{
new AssetItem("asset5", new MyAsset5(), package),
new AssetItem("asset6", new MyAsset6(), package),
new AssetItem("asset7", new MyAsset7(), package),
};
otherAssets.ForEach(x => package.Assets.Add(x));
var compileAssetReference = new MyAsset2
{
CompileAssetReference = CreateRef <MyContent5>(otherAssets[0]),
CompileContentReference = CreateRef <MyContent6>(otherAssets[1]),
CompileRuntimeReference = CreateRef <MyContent7>(otherAssets[2]),
};
var assetItem = new AssetItem("asset2", compileAssetReference, package);
package.Assets.Add(assetItem);
var asset = new MyAsset1 {
CompileAssetReference = CreateRef <MyContent2>(assetItem)
};
assetItem = new AssetItem("asset1", asset, package);
package.Assets.Add(assetItem);
package.RootAssets.Add(new AssetReference(assetItem.Id, assetItem.Location));
// Create context
var context = new AssetCompilerContext {
CompilationContext = typeof(AssetCompilationContext)
};
// Builds the project
Exception ex = null;
MyAsset1Compiler.AssertFunc = (url, ass, pkg) =>
{
// Nothing must have been compiled before
AssertInThread(ref ex, () => Assert.Empty(TestCompilerBase.CompiledAssets));
};
var assetBuilder = new PackageCompiler(new RootPackageAssetEnumerator(package));
var assetBuildResult = assetBuilder.Prepare(context);
// Since MyAsset2 is a CompileAsset reference, it should not be compiled, so we should have only 1 asset (MyAsset1) to compile.
Assert.Equal(1, assetBuildResult.BuildSteps.Count);
var builder = new Builder(GlobalLogger.GetLogger("Test"), "", "");
builder.Root.Add(assetBuildResult.BuildSteps);
builder.Run(Builder.Mode.Build, false);
RethrowAssertsFromThread(ex);
}
internal EventKeyBase(string category = "General", string eventName = "Event")
{
broadcastBlock = new BroadcastBlock <T>(null, new DataflowBlockOptions {
TaskScheduler = EventTaskScheduler.Scheduler
});
EventName = eventName;
Logger = GlobalLogger.GetLogger($"Event - {category}");
broadcastDebug = $"Broadcasting '{eventName}' ({EventId})";
}
public GameAppServer()
{
_logger = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name);
// Database file provider
_services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(null));
_services.AddService(GameEngineServer.DefaultGraphicsDeviceService); // ContentManager requires a GraphicsDeviceService if graphical assets are loaded (eg. Textures)
_services.AddService <IExitGameService>(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="GraphViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="GraphViewModelService"/> to use for this view model.</param>
private GraphViewModel(IViewModelServiceProvider serviceProvider)
: base(serviceProvider)
{
GraphViewModelService = serviceProvider.TryGet <GraphViewModelService>();
if (GraphViewModelService == null)
{
throw new InvalidOperationException($"{nameof(GraphViewModel)} requires a {nameof(GraphViewModelService)} in the service provider.");
}
Logger = GlobalLogger.GetLogger(DefaultLoggerName);
}
public Logger GetLogger(LogKey key, bool create = true)
{
Logger logger;
if (!loggers.TryGetValue(key, out logger) && create)
{
logger = GlobalLogger.GetLogger(key.ToString());
loggers.Add(key, logger);
}
return(logger);
}
/// <summary>
/// Initializes a new instance of the <see cref="GameBase" /> class.
/// </summary>
protected GameBase()
{
// Internals
Log = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name);
updateTime = new GameTime();
drawTime = new GameTime();
playTimer = new TimerTick();
updateTimer = new TimerTick();
totalUpdateTime = new TimeSpan();
timer = new TimerTick();
IsFixedTimeStep = false;
maximumElapsedTime = TimeSpan.FromMilliseconds(500.0);
lastUpdateCount = new int[4];
nextLastUpdateCountIndex = 0;
TargetElapsedTime = defaultTimeSpan; // default empty timespan, will be set on window create if not set elsewhere
TreatNotFocusedLikeMinimized = true;
DrawEvenMinimized = false;
WindowMinimumUpdateRate = new ThreadThrottler(defaultTimeSpan); // will be set when window gets created with window's refresh rate
MinimizedMinimumUpdateRate = new ThreadThrottler(TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 15)); // by default 15 updates per second while minimized
// Calculate the updateCountAverageSlowLimit (assuming moving average is >=3 )
// Example for a moving average of 4:
// updateCountAverageSlowLimit = (2 * 2 + (4 - 2)) / 4 = 1.5f
const int BadUpdateCountTime = 2; // number of bad frame (a bad frame is a frame that has at least 2 updates)
var maxLastCount = 2 * Math.Min(BadUpdateCountTime, lastUpdateCount.Length);
updateCountAverageSlowLimit = (float)(maxLastCount + (lastUpdateCount.Length - maxLastCount)) / lastUpdateCount.Length;
// Externals
Services = new ServiceRegistry(true);
// Database file provider
Services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(null));
LaunchParameters = new LaunchParameters();
GameSystems = new GameSystemCollection(Services);
Services.AddService <IGameSystemCollection>(GameSystems);
// Create Platform
gamePlatform = GamePlatform.Create(this);
gamePlatform.Activated += GamePlatform_Activated;
gamePlatform.Deactivated += GamePlatform_Deactivated;
gamePlatform.Exiting += GamePlatform_Exiting;
gamePlatform.WindowCreated += GamePlatformOnWindowCreated;
// Setup registry
Services.AddService <IGame>(this);
Services.AddService <IGraphicsDeviceFactory>(gamePlatform);
Services.AddService <IGamePlatform>(gamePlatform);
IsActive = true;
}
public static Builder CreateBuilder()
{
var logger = GlobalLogger.GetLogger("Builder");
logger.ActivateLog(LogMessageType.Debug);
var builder = new Builder(BuildPath, "Windows", "index", "inputHashes", logger)
{
BuilderName = "TestBuilder", SlaveBuilderPath = @"SiliconStudio.BuildEngine.exe"
};
return(builder);
}
/// <summary>
/// Initializes a new instance of the <see cref="GameBase" /> class.
/// </summary>
protected GameBase()
{
// Internals
Log = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name);
updateTime = new GameTime();
drawTime = new GameTime();
playTimer = new TimerTick();
updateTimer = new TimerTick();
totalUpdateTime = new TimeSpan();
timer = new TimerTick();
IsFixedTimeStep = false;
maximumElapsedTime = TimeSpan.FromMilliseconds(500.0);
TargetElapsedTime = TimeSpan.FromTicks(10000000 / 60); // target elapsed time is by default 60Hz
lastUpdateCount = new int[4];
nextLastUpdateCountIndex = 0;
// Calculate the updateCountAverageSlowLimit (assuming moving average is >=3 )
// Example for a moving average of 4:
// updateCountAverageSlowLimit = (2 * 2 + (4 - 2)) / 4 = 1.5f
const int BadUpdateCountTime = 2; // number of bad frame (a bad frame is a frame that has at least 2 updates)
var maxLastCount = 2 * Math.Min(BadUpdateCountTime, lastUpdateCount.Length);
updateCountAverageSlowLimit = (float)(maxLastCount + (lastUpdateCount.Length - maxLastCount)) / lastUpdateCount.Length;
// Externals
Services = new ServiceRegistry();
// Content manager
Content = new ContentManager(Services);
Services.AddService <IContentManager>(Content);
Services.AddService(Content);
LaunchParameters = new LaunchParameters();
GameSystems = new GameSystemCollection(Services);
Services.AddService <IGameSystemCollection>(GameSystems);
// Create Platform
gamePlatform = GamePlatform.Create(this);
gamePlatform.Activated += gamePlatform_Activated;
gamePlatform.Deactivated += gamePlatform_Deactivated;
gamePlatform.Exiting += gamePlatform_Exiting;
gamePlatform.WindowCreated += GamePlatformOnWindowCreated;
// Setup registry
Services.AddService <IGame>(this);
Services.AddService <IGraphicsDeviceFactory>(gamePlatform);
Services.AddService <IGamePlatform>(gamePlatform);
IsActive = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="Game"/> class.
/// </summary>
public HeadlessGame()
{
// Internals
Log = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name);
UpdateTime = new GameTime();
autoTickTimer = new TimerTick();
IsFixedTimeStep = true;
maximumElapsedTime = TimeSpan.FromMilliseconds(500.0);
TargetElapsedTime = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 60); // target elapsed time is by default 60Hz
// Externals
Services = new ServiceRegistry();
GraphicsDevice = GraphicsDevice.New(DeviceCreationFlags.VideoSupport, new GraphicsProfile[]
{
GraphicsProfile.Level_11_0,
GraphicsProfile.Level_11_1,
GraphicsProfile.Level_11_2
});
Services.AddService <IGraphicsDeviceService>(new GraphicsDeviceServiceLocal(GraphicsDevice));
// Database file provider
Services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(null));
GameSystems = new GameSystemCollection(Services);
Services.AddService <IGameSystemCollection>(GameSystems);
// Setup registry
Services.AddService <IGame>(this);
// Register the logger backend before anything else
logListener = GetLogListener();
if (logListener != null)
{
GlobalLogger.GlobalMessageLogged += logListener;
}
// Create all core services, except Input which is created during `Initialize'.
// Registration takes place in `Initialize'.
Script = new ScriptSystem(Services);
Services.AddService(Script);
SceneSystem = new SceneSystem(Services);
Services.AddService(SceneSystem);
Streaming = new StreamingManager(Services);
}
/// <summary>
/// Initializes a new instance of the <see cref="ObservableViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="ObservableViewModelService"/> to use for this view model.</param>
/// <param name="nodeContainer">A <see cref="NodeContainer"/> to use to build view model nodes.</param>
/// <param name="dirtiables">The list of <see cref="IDirtiable"/> objects linked to this view model.</param>
private ObservableViewModel(IViewModelServiceProvider serviceProvider, NodeContainer nodeContainer, IEnumerable <IDirtiable> dirtiables)
: base(serviceProvider)
{
if (nodeContainer == null)
{
throw new ArgumentNullException(nameof(nodeContainer));
}
if (dirtiables == null)
{
throw new ArgumentNullException(nameof(dirtiables));
}
NodeContainer = nodeContainer;
Dirtiables = dirtiables;
ObservableViewModelService = serviceProvider.Get <ObservableViewModelService>();
Logger = GlobalLogger.GetLogger(DefaultLoggerName);
}
/// <summary>
/// Initializes a new instance of the <see cref="ObservableViewModel"/> class.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> and an <see cref="ObservableViewModelService"/> to use for this view model.</param>
/// <param name="modelContainer">A <see cref="ModelContainer"/> to use to build view model nodes.</param>
/// <param name="dirtiables">The list of <see cref="IDirtiableViewModel"/> objects linked to this view model.</param>
private ObservableViewModel(IViewModelServiceProvider serviceProvider, ModelContainer modelContainer, IEnumerable <IDirtiableViewModel> dirtiables)
: base(serviceProvider)
{
if (modelContainer == null)
{
throw new ArgumentNullException("modelContainer");
}
if (dirtiables == null)
{
throw new ArgumentNullException("dirtiables");
}
this.modelContainer = modelContainer;
this.dirtiables = dirtiables;
this.dirtiables.ForEach(x => x.DirtinessUpdated += DirtinessUpdated);
observableViewModelService = serviceProvider.Get <ObservableViewModelService>();
Logger = GlobalLogger.GetLogger(DefaultLoggerName);
}
public SceneViewModel GetRoot()
{
var root = this;
var hash = new HashSet <AssetId> {
root.Id
};
while (root.Parent != null)
{
if (!hash.Add(root.Parent.Id))
{
GlobalLogger.GetLogger("Asset").Error($"Cyclic reference detected for scene {root.Name} (Id={root.Id}).");
break;
}
root = root.Parent;
}
return(root);
}
public int Run(string[] args)
{
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.sdpkg");
//Thread.Sleep(10000);
//var spriteFontAsset = StaticFontAsset.New();
//Content.Save("test.sdfnt", spriteFontAsset);
//project.Refresh();
//args = new string[] { "test.sdpkg", "-o:app_data", "-b:tmp", "-t:1" };
var exeName = Path.GetFileName(Assembly.GetExecutingAssembly().Location);
var showHelp = false;
var packMode = false;
var updateGeneratedFilesMode = false;
var buildEngineLogger = GlobalLogger.GetLogger("BuildEngine");
var options = new PackageBuilderOptions(new ForwardingLoggerResult(buildEngineLogger));
var p = new OptionSet
{
"Copyright (c) 2018-2021 Stride and its contributors (https://stride3d.net)",
"Copyright (c) 2011-2018 Silicon Studio Corp. (https://www.siliconstudio.co.jp)",
"Stride Package Build Tool - Version: " + Format("{0}.{1}.{2}",
typeof(Program).Assembly.GetName().Version.Major,
typeof(Program).Assembly.GetName().Version.Minor,
typeof(Program).Assembly.GetName().Version.Build),
Empty,
Format("Usage: {0} inputPackageFile [options]* -b buildPath", exeName),
Empty,
"=== Options ===",
Empty,
{ "h|help", "Show this message and exit", help => showHelp = help != null },
/// <summary>
/// Initializes a new instance of the <see cref="GameBase" /> class.
/// </summary>
protected GameBase()
{
// Internals
Log = GlobalLogger.GetLogger(GetType().GetTypeInfo().Name);
UpdateTime = new GameTime();
DrawTime = new GameTime();
autoTickTimer = new TimerTick();
IsFixedTimeStep = false;
maximumElapsedTime = TimeSpan.FromMilliseconds(500.0);
TargetElapsedTime = TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 60); // target elapsed time is by default 60Hz
TreatNotFocusedLikeMinimized = true;
WindowMinimumUpdateRate = new ThreadThrottler(TimeSpan.FromSeconds(0d));
MinimizedMinimumUpdateRate = new ThreadThrottler(TimeSpan.FromTicks(TimeSpan.TicksPerSecond / 15)); // by default 15 updates per second while minimized
isMouseVisible = true;
// Externals
Services = new ServiceRegistry();
// Database file provider
Services.AddService <IDatabaseFileProviderService>(new DatabaseFileProviderService(null));
LaunchParameters = new LaunchParameters();
GameSystems = new GameSystemCollection(Services);
Services.AddService <IGameSystemCollection>(GameSystems);
// Create Platform
gamePlatform = GamePlatform.Create(this);
gamePlatform.Activated += GamePlatform_Activated;
gamePlatform.Deactivated += GamePlatform_Deactivated;
gamePlatform.Exiting += GamePlatform_Exiting;
gamePlatform.WindowCreated += GamePlatformOnWindowCreated;
// Setup registry
Services.AddService <IGame>(this);
Services.AddService <IGraphicsDeviceFactory>(gamePlatform);
Services.AddService <IGamePlatform>(gamePlatform);
IsActive = true;
}
public static async Task UnpackAPK()
{
// get the apk last update time
var packageManager = PlatformAndroid.Context.PackageManager;
var packageInfo = packageManager.GetPackageInfo(PlatformAndroid.Context.PackageName, PackageInfoFlags.Activities);
var lastUpdateTime = packageInfo.LastUpdateTime;
var sourceDir = PlatformAndroid.Context.ApplicationInfo.SourceDir;
// evaluate if asset data should be extracted from apk file
var shouldExtractAssets = true;
if (ApplicationTemporary.FileExists(LastExtractedApkFileName))
{
Int64 extractedLastUpdateTime = 0;
using (var file = ApplicationTemporary.OpenStream(LastExtractedApkFileName, VirtualFileMode.Open, VirtualFileAccess.Read))
{
var binaryReader = new BinarySerializationReader(file);
binaryReader.Serialize(ref extractedLastUpdateTime, ArchiveMode.Deserialize);
}
shouldExtractAssets = extractedLastUpdateTime != lastUpdateTime;
}
// Copy assets
if (shouldExtractAssets)
{
var assets = PlatformAndroid.Context.Assets;
// Make sure assets exists
var logger = GlobalLogger.GetLogger("VFS");
CopyFileOrDirectory(logger, sourceDir, "assets/data/", string.Empty);
// update value of extracted last update time
using (var stream = ApplicationTemporary.OpenStream(LastExtractedApkFileName, VirtualFileMode.Create, VirtualFileAccess.Write, VirtualFileShare.None))
{
var binaryWriter = new BinarySerializationWriter(stream);
binaryWriter.Write(lastUpdateTime);
}
}
}
private static Process RunServiceProcessAndLog(string servicePath)
{
var process = ShellHelper.RunProcess(servicePath, string.Empty);
// Create log and notify start
var logModule = string.Format("{0}:{1}", Path.GetFileNameWithoutExtension(servicePath), process.Id);
var logger = GlobalLogger.GetLogger(logModule);
logger.Info("Process started");
process.OutputDataReceived += (_, args) => logger.Info(args.Data);
process.ErrorDataReceived += (_, args) => logger.Error(args.Data);
process.Exited += (_, args) => logger.Info("Process exited");
process.BeginOutputReadLine();
process.BeginErrorReadLine();
// Let's tie lifetime of spawned process to ours
// TODO: Move that in a better namespace? (currently a shared file)
new AttachedChildProcessJob(process);
return(process);
}
public GameStudioBuilderService(SessionViewModel sessionViewModel, GameSettingsProviderService settingsProvider, string buildDirectory, bool createDebugTools = true)
: base(buildDirectory)
{
this.createDebugTools = createDebugTools;
if (createDebugTools)
{
assetBuilderServiceDebugPage = EditorDebugTools.CreateLogDebugPage(GlobalLogger.GetLogger("AssetBuilderService"), "AssetBuilderService");
effectCompilerServiceDebugPage = EditorDebugTools.CreateLogDebugPage(GlobalLogger.GetLogger("EffectCompilerCache"), "EffectCompilerCache");
}
SessionViewModel = sessionViewModel ?? throw new ArgumentNullException(nameof(sessionViewModel));
var shaderImporter = new StrideShaderImporter();
var shaderBuildSteps = shaderImporter.CreateSystemShaderBuildSteps(sessionViewModel);
shaderBuildSteps.StepProcessed += ShaderBuildStepsStepProcessed;
PushBuildUnit(new PrecompiledAssetBuildUnit(AssetBuildUnitIdentifier.Default, shaderBuildSteps, true));
Database = new GameStudioDatabase(this, settingsProvider);
const string shaderBundleUrl = "/binary/editor/EditorShadersD3D11.bundle";
if (VirtualFileSystem.FileExists(shaderBundleUrl))
{
Builder.ObjectDatabase.BundleBackend.LoadBundleFromUrl("EditorShadersD3D11", Builder.ObjectDatabase.ContentIndexMap, shaderBundleUrl, true).Wait();
}
// Use a shared database for our shader system
// TODO: Shaders compiled on main thread won't actually be visible to MicroThread build engine (contentIndexMap are separate).
// It will still work and cache because EffectCompilerCache caches not only at the index map level, but also at the database level.
// Later, we probably want to have a GetSharedDatabase() allowing us to mutate it (or merging our results back with IndexFileCommand.AddToSharedGroup()),
// so that database created with MountDatabase also have all the newest shaders.
taskScheduler = new EffectPriorityScheduler(ThreadPriority.BelowNormal, Math.Max(1, Environment.ProcessorCount / 2));
TaskSchedulerSelector taskSchedulerSelector = (mixinTree, compilerParameters) => taskScheduler.GetOrCreatePriorityGroup(compilerParameters?.TaskPriority ?? 0);
effectCompiler = (EffectCompilerBase)EffectCompilerFactory.CreateEffectCompiler(MicrothreadLocalDatabases.GetSharedDatabase(), taskSchedulerSelector: taskSchedulerSelector);
StartPushNotificationsTask();
}
private static StridePlatformOptions GetOptions()
{
try
{
var configuratorConstructor =
AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(a => a.GetCustomAttributes <AvaloniaConfiguratorAttribute>())
.Single().ConfiguratorType.GetTypeInfo().DeclaredConstructors
.Where(c => c.GetParameters().Length == 0 && !c.IsStatic).Single();
var configuratorMethod = configuratorConstructor.DeclaringType.GetTypeInfo().DeclaredMethods
.Single(m => m.GetParameters().Length == 0 && m.ReturnType == typeof(StridePlatformOptions));
var instance = configuratorConstructor.Invoke(Array.Empty <object>());
return((StridePlatformOptions)configuratorMethod.Invoke(instance, Array.Empty <object>()));
}
catch (InvalidOperationException)
{
var logger = GlobalLogger.GetLogger("Stridelonia");
logger.Debug("No Application configurator found");
return(null);
}
}
public AssetBuilderService([NotNull] string buildDirectory)
{
if (buildDirectory == null)
{
throw new ArgumentNullException(nameof(buildDirectory));
}
// We want at least 2 threads, since one will be used for DynamicBuildStep (which is a special blocking step)
var processorCount = Environment.ProcessorCount;
var threadCount = MathUtil.Clamp(3 * processorCount / 4, 2, processorCount - 1);
// Mount database (otherwise it will be mounted by DynamicBuilder thread, and it might happen too late)
Builder.OpenObjectDatabase(buildDirectory, IndexName);
var builderInstance = new Builder(GlobalLogger.GetLogger("AssetBuilderService"), buildDirectory, IndexName)
{
BuilderName = "AssetBuilderService Builder",
ThreadCount = threadCount,
};
builder = new DynamicBuilder(builderInstance, new AnonymousBuildStepProvider(GetNextBuildStep), "Asset Builder service thread.");
builder.Start();
}
public static void Initialize(IGame game)
{
if (_isInitialize)
{
return;
}
if (game.GetType().Name.Contains("Editor"))
{
var logger = GlobalLogger.GetLogger("Stridelonia");
logger.Info("Stridelonia is disabled in GameStudio");
return;
}
if (Options == null)
{
return;
}
AvaloniaLocator.CurrentMutable.BindToSelf(game);
var dispatcher = game.Services.GetService <StrideDispatcher>();
if (dispatcher == null)
{
dispatcher = new StrideDispatcher(game.Services);
game.Services.AddService(dispatcher);
game.GameSystems.Add(dispatcher);
}
if (Application.Current == null)
{
StartAvalonia();
}
_isInitialize = true;
}
private static void StartAvalonia()
{
if (Options.ConfigureApp == null || Options.ApplicationType == null)
{
var logger = GlobalLogger.GetLogger("Stridelonia");
logger.Debug("No Application in StridePlatformOptions");
return;
}
if (Options.UseMultiThreading)
{
_avaloniaThread = new Thread(AvaloniaThread)
{
Name = "Avalonia Thread"
};
_avaloniaThread.Start(Options);
_initedEvent.WaitOne();
_initedEvent.Dispose();
}
else
{
CreateApplication(Options);
}
}
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");
if (CompileSynchronization.IsSet)
{
CompileSynchronization.Reset(1);
}
else
{
CompileSynchronization.AddCount();
}
// 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);
}
}
CompileSynchronization.Signal();
lock (compilingShaders)
{
compilingShaders.Remove(mixinObjectId);
}
log.CopyTo(effectLog);
return(compiledShader);
}