protected override void Initialize()
{
base.Initialize();
EffectSystem = new EffectSystem(Services);
// If requested in game settings, compile effects remotely and/or notify new shader requests
if (gameSettings != null)
{
EffectSystem.Compiler = EffectSystem.CreateEffectCompiler(EffectSystem, gameSettings.PackageId, gameSettings.EffectCompilation, gameSettings.RecordUsedEffects);
}
GameSystems.Add(EffectSystem);
GameSystems.Add(SceneSystem);
// TODO: data-driven?
//Asset.Serializer.RegisterSerializer(new GpuTextureSerializer2(GraphicsDevice));
//Asset.Serializer.RegisterSerializer(new GpuSamplerStateSerializer2(GraphicsDevice));
//Asset.Serializer.RegisterSerializer(new GpuBlendStateSerializer(GraphicsDevice));
//Asset.Serializer.RegisterSerializer(new GpuRasterizerStateSerializer(GraphicsDevice));
//Asset.Serializer.RegisterSerializer(new GpuDepthStencilStateSerializer(GraphicsDevice));
Asset.Serializer.RegisterSerializer(new ImageSerializer());
Asset.Serializer.RegisterSerializer(new SoundEffectSerializer(Audio.AudioEngine));
Asset.Serializer.RegisterSerializer(new SoundMusicSerializer(Audio.AudioEngine));
// enable multi-touch by default
Input.MultiTouchEnabled = true;
}
public SkyboxGeneratorContext(SkyboxAsset skybox, IDatabaseFileProviderService fileProviderService)
{
Skybox = skybox ?? throw new ArgumentNullException(nameof(skybox));
Services = new ServiceRegistry();
Services.AddService(fileProviderService);
Content = new ContentManager(Services);
Services.AddService <IContentManager>(Content);
Services.AddService(Content);
GraphicsDevice = GraphicsDevice.New();
GraphicsDeviceService = new GraphicsDeviceServiceLocal(Services, GraphicsDevice);
Services.AddService(GraphicsDeviceService);
var graphicsContext = new GraphicsContext(GraphicsDevice);
Services.AddService(graphicsContext);
EffectSystem = new EffectSystem(Services);
EffectSystem.Compiler = EffectSystem.CreateEffectCompiler(Content.FileProvider, EffectSystem);
Services.AddService(EffectSystem);
EffectSystem.Initialize();
((IContentable)EffectSystem).LoadContent();
((EffectCompilerCache)EffectSystem.Compiler).CompileEffectAsynchronously = false;
RenderContext = RenderContext.GetShared(Services);
RenderDrawContext = new RenderDrawContext(Services, RenderContext, graphicsContext);
}
protected override void Initialize()
{
base.Initialize();
//now we probably are capable of detecting the gpu/cpu/etc so we confirm rendering settings
if (AutoLoadDefaultSettings)
{
ConfirmRenderingSettings();
}
// ---------------------------------------------------------
// Add common GameSystems - Adding order is important
// (Unless overriden by gameSystem.UpdateOrder)
// ---------------------------------------------------------
// Add the input manager
Input = InputManagerFactory.NewInputManager(Services, Context);
GameSystems.Add(Input);
// Add the scheduler system
// - Must be after Input, so that scripts are able to get latest input
// - Must be before Entities/Camera/Audio/UI, so that scripts can apply
// changes in the same frame they will be applied
GameSystems.Add(Script);
// Add the Audio System
GameSystems.Add(Audio);
// Add the Font system
GameSystems.Add(gameFontSystem);
//Add the sprite animation System
GameSystems.Add(SpriteAnimation);
GameSystems.Add(ProfilerSystem);
EffectSystem = new EffectSystem(Services);
// If requested in game settings, compile effects remotely and/or notify new shader requests
if (Settings != null)
{
EffectSystem.Compiler = EffectSystem.CreateEffectCompiler(EffectSystem, Settings.PackageId, Settings.EffectCompilation, Settings.RecordUsedEffects);
}
GameSystems.Add(EffectSystem);
GameSystems.Add(SceneSystem);
// TODO: data-driven?
Content.Serializer.RegisterSerializer(new ImageSerializer());
Content.Serializer.RegisterSerializer(new SoundEffectSerializer(Audio.AudioEngine));
Content.Serializer.RegisterSerializer(new SoundMusicSerializer(Audio.AudioEngine));
// enable multi-touch by default
Input.MultiTouchEnabled = true;
OnGameStarted(this);
}
protected override void Initialize()
{
// ---------------------------------------------------------
// Add common GameSystems - Adding order is important
// (Unless overriden by gameSystem.UpdateOrder)
// ---------------------------------------------------------
// Add the input manager
// Add it first so that it can obtained by the UI system
Input = new InputManager(Services);
Services.AddService(Input);
GameSystems.Add(Input);
// Initialize the systems
base.Initialize();
// Add the scheduler system
// - Must be after Input, so that scripts are able to get latest input
// - Must be before Entities/Camera/Audio/UI, so that scripts can apply
// changes in the same frame they will be applied
GameSystems.Add(Script);
// Add the Font system
GameSystems.Add(gameFontSystem);
//Add the sprite animation System
GameSystems.Add(SpriteAnimation);
GameSystems.Add(DebugTextSystem);
GameSystems.Add(ProfilingSystem);
EffectSystem = new EffectSystem(Services);
Services.AddService(EffectSystem);
// If requested in game settings, compile effects remotely and/or notify new shader requests
if (Settings != null)
{
EffectSystem.Compiler = EffectSystem.CreateEffectCompiler(EffectSystem, Settings.PackageId, Settings.EffectCompilation, Settings.RecordUsedEffects);
}
GameSystems.Add(EffectSystem);
GameSystems.Add(Streaming);
GameSystems.Add(SceneSystem);
// Add the Audio System
GameSystems.Add(Audio);
// Add the VR System
GameSystems.Add(VRDeviceSystem);
// TODO: data-driven?
Content.Serializer.RegisterSerializer(new ImageSerializer());
OnGameStarted(this);
}
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 XenkoShaderImporter();
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)EffectSystem.CreateEffectCompiler(MicrothreadLocalDatabases.GetSharedDatabase(), taskSchedulerSelector: taskSchedulerSelector);
StartPushNotificationsTask();
}
public ThumbnailGenerator(EffectCompilerBase effectCompiler)
{
// create base services
Services = new ServiceRegistry();
Services.AddService(MicrothreadLocalDatabases.ProviderService);
ContentManager = new ContentManager(Services);
Services.AddService <IContentManager>(ContentManager);
Services.AddService(ContentManager);
GraphicsDevice = GraphicsDevice.New();
GraphicsContext = new GraphicsContext(GraphicsDevice);
GraphicsCommandList = GraphicsContext.CommandList;
Services.AddService(GraphicsContext);
sceneSystem = new SceneSystem(Services);
Services.AddService(sceneSystem);
fontSystem = new GameFontSystem(Services);
Services.AddService(fontSystem.FontSystem);
Services.AddService <IFontFactory>(fontSystem.FontSystem);
GraphicsDeviceService = new GraphicsDeviceServiceLocal(Services, GraphicsDevice);
Services.AddService(GraphicsDeviceService);
var uiSystem = new UISystem(Services);
Services.AddService(uiSystem);
var physicsSystem = new Bullet2PhysicsSystem(Services);
Services.AddService <IPhysicsSystem>(physicsSystem);
gameSystems = new GameSystemCollection(Services)
{
fontSystem, uiSystem, physicsSystem
};
Services.AddService <IGameSystemCollection>(gameSystems);
Simulation.DisableSimulation = true; //make sure we do not simulate physics within the editor
// initialize base services
gameSystems.Initialize();
// create remaining services
EffectSystem = new EffectSystem(Services);
Services.AddService(EffectSystem);
gameSystems.Add(EffectSystem);
gameSystems.Add(sceneSystem);
EffectSystem.Initialize();
// Mount the same database for the cache
EffectSystem.Compiler = EffectSystem.CreateEffectCompiler(effectCompiler.FileProvider, EffectSystem);
// Deactivate the asynchronous effect compilation
((EffectCompilerCache)EffectSystem.Compiler).CompileEffectAsynchronously = false;
// load game system content
gameSystems.LoadContent();
// create the default fonts
var fontItem = OfflineRasterizedSpriteFontFactory.Create();
fontItem.FontType.Size = 22;
DefaultFont = OfflineRasterizedFontCompiler.Compile(fontSystem.FontSystem, fontItem, true);
// create utility members
nullGameTime = new GameTime();
SpriteBatch = new SpriteBatch(GraphicsDevice);
UIBatch = new UIBatch(GraphicsDevice);
// create the pipeline
SetUpPipeline();
}
