Example #1
0
        public GraphicsSystem(OpenTKWindow window, float renderQuality = 1f, GraphicsBackEndPreference backEndPreference = GraphicsBackEndPreference.None)
        {
            if (window == null)
            {
                throw new ArgumentNullException(nameof(window));
            }

            bool preferOpenGL = backEndPreference == GraphicsBackEndPreference.OpenGL || !RuntimeInformation.IsOSPlatform(OSPlatform.Windows);

            _window = window;
            Context = CreatePlatformDefaultContext(window, preferOpenGL);
            Context.ResourceFactory.AddShaderLoader(new EmbeddedResourceShaderLoader(typeof(GraphicsSystem).GetTypeInfo().Assembly));
            MaterialCache = new MaterialCache(this);
            BufferCache   = new BufferCache(this);

            ShadowMapStage            = new ShadowMapStage(Context);
            _upscaleStage             = new UpscaleStage(Context, "Upscale", null, null);
            _standardStage            = new StandardPipelineStage(Context, "Standard");
            _alphaBlendStage          = new StandardPipelineStage(Context, "AlphaBlend");
            _alphaBlendStage.Comparer = new FarToNearIndexComparer();
            _overlayStage             = new StandardPipelineStage(Context, "Overlay");
            _pipelineStages           = new PipelineStage[]
            {
                ShadowMapStage,
                _standardStage,
                _alphaBlendStage,
                _upscaleStage,
                _overlayStage,
            };
            _renderer = new Renderer(Context, _pipelineStages);
            SetPreupscaleQuality(renderQuality);

            // Placeholder providers so that materials can bind to them.
            Context.RegisterGlobalDataProvider("ViewMatrix", s_identityProvider);
            Context.RegisterGlobalDataProvider("ProjectionMatrix", s_identityProvider);
            Context.RegisterGlobalDataProvider("CameraInfo", s_noCameraProvider);
            Context.RegisterGlobalDataProvider("LightBuffer", s_noLightProvider);
            Context.RegisterGlobalDataProvider("PointLights", _pointLightsProvider);

            window.Resized += OnWindowResized;

            _freeShapeRenderer          = new ManualWireframeRenderer(Context, RgbaFloat.Pink);
            _freeShapeRenderer.Topology = PrimitiveTopology.LineList;
            AddFreeRenderItem(_freeShapeRenderer);

            _mainThreadID      = Environment.CurrentManagedThreadId;
            _taskScheduler     = new GraphicsSystemTaskScheduler(_mainThreadID);
            _rayCastFilterFunc = RayCastFilter;
        }
Example #2
0
File: Program.cs Project: zhuowp/ge
        public static void Main(string[] args)
        {
            CommandLineOptions commandLineOptions = new CommandLineOptions(args);
            // Force-load prefs.
            var prefs = EditorPreferences.Instance;

            OpenTKWindow window = RuntimeInformation.IsOSPlatform(OSPlatform.Windows)
                ? (OpenTKWindow)new DedicatedThreadWindow(960, 540, WindowState.Maximized)
                : new SameThreadWindow(960, 540, WindowState.Maximized);
            window.Title = "ge.Editor";
            Game game = new Game();
            GraphicsBackEndPreference backEndPref = commandLineOptions.PreferOpenGL ? GraphicsBackEndPreference.OpenGL : GraphicsBackEndPreference.None;
            GraphicsSystem gs = new GraphicsSystem(window, prefs.RenderQuality, backEndPref);
            gs.Context.ResourceFactory.AddShaderLoader(new EmbeddedResourceShaderLoader(typeof(Program).GetTypeInfo().Assembly));
            game.SystemRegistry.Register(gs);
            game.LimitFrameRate = false;

            InputSystem inputSystem = new InputSystem(window);
            inputSystem.RegisterCallback((input) =>
            {
                if (input.GetKeyDown(Key.F4) && (input.GetKey(Key.AltLeft) || input.GetKey(Key.AltRight)))
                {
                    game.Exit();
                }
            });

            game.SystemRegistry.Register(inputSystem);

            ImGuiRenderer imGuiRenderer = new ImGuiRenderer(gs.Context, window.NativeWindow, inputSystem);
            gs.SetImGuiRenderer(imGuiRenderer);

            var als = new AssemblyLoadSystem();
            game.SystemRegistry.Register(als);

            AssetSystem assetSystem = new EditorAssetSystem(Path.Combine(AppContext.BaseDirectory, "Assets"), als.Binder);
            game.SystemRegistry.Register(assetSystem);

            EditorSceneLoaderSystem esls = new EditorSceneLoaderSystem(game, game.SystemRegistry.GetSystem<GameObjectQuerySystem>());
            game.SystemRegistry.Register<SceneLoaderSystem>(esls);
            esls.AfterSceneLoaded += () => game.ResetDeltaTime();

            CommandLineOptions.AudioEnginePreference? audioPreference = commandLineOptions.AudioPreference;
            AudioEngineOptions audioEngineOptions =
                !audioPreference.HasValue ? AudioEngineOptions.Default
                : audioPreference == CommandLineOptions.AudioEnginePreference.None ? AudioEngineOptions.UseNullAudio
                : AudioEngineOptions.UseOpenAL;
            AudioSystem audioSystem = new AudioSystem(audioEngineOptions);
            game.SystemRegistry.Register(audioSystem);

            BehaviorUpdateSystem bus = new BehaviorUpdateSystem(game.SystemRegistry);
            game.SystemRegistry.Register(bus);
            bus.Register(imGuiRenderer);

            PhysicsSystem ps = new PhysicsSystem(PhysicsLayersDescription.Default);
            game.SystemRegistry.Register(ps);

            ConsoleCommandSystem ccs = new ConsoleCommandSystem(game.SystemRegistry);
            game.SystemRegistry.Register(ccs);

            game.SystemRegistry.Register(new SynchronizationHelperSystem());

            window.Closed += game.Exit;

            var editorSystem = new EditorSystem(game.SystemRegistry, commandLineOptions, imGuiRenderer);
            editorSystem.DiscoverComponentsFromAssembly(typeof(Program).GetTypeInfo().Assembly);
            // Editor system registers itself.

            game.RunMainLoop();

            window.NativeWindow.Dispose();

            EditorPreferences.Instance.Save();
        }