Exemplo n.º 1
0
        /// <summary>
        /// Initializes all adapters with the specified factory.
        /// </summary>
        /// <param name="factory1">The factory1.</param>
        internal static void Initialize()
        {
            if (staticCollector != null)
            {
                staticCollector.Dispose();
            }
            else
                staticCollector = new DisposeCollector();

            if (D3D != null)
            {
                D3D.Dispose();
                D3D = null;
            }

            D3D = new Direct3D9.Direct3D();

            var adapters = new List<GraphicsAdapter>();
            for (int i = 0; i < D3D.AdapterCount; i++)
            {
                var adapter = new GraphicsAdapter(i);
                staticCollector.Collect(adapter);
                adapters.Add(adapter);
            }

            Default = adapters[0];
            Adapters = adapters.ToArray();
        }
Exemplo n.º 2
0
 public ModeInfo(GraphicsAdapter adapter, int outputIndex, bool isFullScreen, int width, int height)
 {
     Adapter = adapter;
     OutputIndex = outputIndex;
     IsFullScreen = isFullScreen;
     Width = width;
     Height = height;
 }
Exemplo n.º 3
0
        /// <summary>
        /// Initializes a new instance of <see cref="GraphicsOutput" />.
        /// </summary>
        /// <param name="adapter">The adapter.</param>
        /// <param name="output">The DXGI <see cref="Output" /> counterpart of this instance.</param>
        /// <exception cref="System.ArgumentNullException">output</exception>
        /// <exception cref="ArgumentOutOfRangeException">Is thrown when <paramref name="outputOrdinal" /> is less than zero.</exception>
        /// <exception cref="ArgumentNullException">Is thrown when <paramref name="output" /> is null.</exception>
        internal GraphicsOutput(GraphicsAdapter adapter, Output output)
        {
            if(adapter == null) throw new ArgumentNullException("adapter");
            if (output == null) throw new ArgumentNullException("output");

            this.adapter = adapter;
            this.output = ToDispose(output);
            outputDescription = output.Description;
        }
Exemplo n.º 4
0
        /// <summary>
        /// Initializes all adapters with the specified factory.
        /// </summary>
        /// <param name="factory1">The factory1.</param>
        internal static void Initialize(Factory1 factory1)
        {
            if (staticCollector != null)
            {
                staticCollector.Dispose();
            }

            staticCollector = new DisposeCollector();
            Factory = factory1;
            staticCollector.Collect(Factory);

            int countAdapters = Factory.GetAdapterCount1();
            var adapters = new List<GraphicsAdapter>();
            for (int i = 0; i < countAdapters; i++)
            {
                var adapter = new GraphicsAdapter(i);
                staticCollector.Collect(adapter);
                adapters.Add(adapter);
            }

            Default = adapters[0];
            Adapters = adapters.ToArray();
        }
Exemplo n.º 5
0
        protected void AddDevice(GraphicsAdapter graphicsAdapter, DisplayMode mode,  GraphicsDeviceInformation deviceBaseInfo, GameGraphicsParameters prefferedParameters, List<GraphicsDeviceInformation> graphicsDeviceInfos)
        {
            var deviceInfo = deviceBaseInfo.Clone();

            deviceInfo.PresentationParameters.RefreshRate = mode.RefreshRate;

            if (prefferedParameters.IsFullScreen)
            {
                deviceInfo.PresentationParameters.BackBufferWidth = mode.Width;
                deviceInfo.PresentationParameters.BackBufferHeight = mode.Height;
            }
            else
            {
                deviceInfo.PresentationParameters.BackBufferWidth = prefferedParameters.PreferredBackBufferWidth;
                deviceInfo.PresentationParameters.BackBufferHeight = prefferedParameters.PreferredBackBufferHeight;
            }

            // TODO: Handle BackBufferFormat / multisampling / depthstencil format
            deviceInfo.PresentationParameters.BackBufferFormat = prefferedParameters.PreferredBackBufferFormat;
            deviceInfo.PresentationParameters.DepthStencilFormat = prefferedParameters.PreferredDepthStencilFormat;
            deviceInfo.PresentationParameters.MultiSampleCount = MSAALevel.None;

            if (!graphicsDeviceInfos.Contains(deviceInfo))
            {
                graphicsDeviceInfos.Add(deviceInfo);
            }
        }
Exemplo n.º 6
0
 protected void AddDeviceWithDefaultDisplayMode(GameGraphicsParameters prefferedParameters, GraphicsAdapter graphicsAdapter, GraphicsDeviceInformation deviceInfo, List<GraphicsDeviceInformation> graphicsDeviceInfos)
 {
     var displayMode = new DisplayMode(DXGI.Format.B8G8R8A8_UNorm, gameWindow.ClientBounds.Width, gameWindow.ClientBounds.Height, new Rational(60, 1));
     AddDevice(displayMode, deviceInfo, prefferedParameters, graphicsDeviceInfos);
 }
Exemplo n.º 7
0
        private void TryAddDeviceWithDisplayMode(GameGraphicsParameters prefferedParameters,
                                                 GraphicsAdapter graphicsAdapter,
                                                 GraphicsDeviceInformation deviceInfo,
                                                 List<GraphicsDeviceInformation> graphicsDeviceInfos)
        {
            // if we want to switch to fullscreen, try to find only needed output, otherwise check them all
            if (prefferedParameters.IsFullScreen)
            {
                if (prefferedParameters.PreferredFullScreenOutputIndex < graphicsAdapter.OutputsCount)
                {
                    var output = graphicsAdapter.GetOutputAt(prefferedParameters.PreferredFullScreenOutputIndex);
                    TryAddDeviceFromOutput(prefferedParameters, output, deviceInfo, graphicsDeviceInfos);
                }
            }
            else
            {
                for (var i = 0; i < graphicsAdapter.OutputsCount; i++)
                {
                    var output = graphicsAdapter.GetOutputAt(i);
                    TryAddDeviceFromOutput(prefferedParameters, output, deviceInfo, graphicsDeviceInfos);
                }
            }


        }
Exemplo n.º 8
0
 private GraphicsDeviceInformation CreateGraphicsDeviceInformation(GameGraphicsParameters prefferedParameters,
                                                                   GraphicsAdapter graphicsAdapter,
                                                                   FeatureLevel featureLevel)
 {
     return new GraphicsDeviceInformation
            {
                Adapter = graphicsAdapter,
                GraphicsProfile = featureLevel,
                PresentationParameters =
                {
                    MultiSampleCount = MSAALevel.None,
                    IsFullScreen = prefferedParameters.IsFullScreen,
                    PreferredFullScreenOutputIndex = prefferedParameters.PreferredFullScreenOutputIndex,
                    DepthBufferShaderResource = prefferedParameters.DepthBufferShaderResource,
                    PresentationInterval = prefferedParameters.SynchronizeWithVerticalRetrace ? PresentInterval.One : PresentInterval.Immediate,
                    DeviceWindowHandle = MainWindow.NativeWindow,
                    RenderTargetUsage = Usage.BackBuffer | Usage.RenderTargetOutput
                }
            };
 }
Exemplo n.º 9
0
        protected void TryFindSupportedFeatureLevel(GameGraphicsParameters prefferedParameters,
                                                    GraphicsAdapter graphicsAdapter,
                                                    List<GraphicsDeviceInformation> graphicsDeviceInfos,
                                                    AddDeviceToListDelegate addDelegate)
        {
            // Check if the adapter has an output with the preffered index
            if (prefferedParameters.IsFullScreen && graphicsAdapter.OutputsCount <= prefferedParameters.PreferredFullScreenOutputIndex)
                return;

            // Iterate on each preferred graphics profile
            foreach (var featureLevel in prefferedParameters.PreferredGraphicsProfile)
            {
                // Check if this profile is supported.
                if (graphicsAdapter.IsProfileSupported(featureLevel))
                {
                    var deviceInfo = CreateGraphicsDeviceInformation(prefferedParameters, graphicsAdapter, featureLevel);

                    addDelegate(prefferedParameters, graphicsAdapter, deviceInfo, graphicsDeviceInfos);

                    // If the profile is supported, we are just using the first best one
                    break;
                }
            }
        }
Exemplo n.º 10
0
        /// <summary>
        /// Appends the information about current graphics adapter and its output and adds it to the list of available graphics modes
        /// </summary>
        /// <param name="sb">Where to write the information</param>
        /// <param name="adapter">The adapter whose information needs to be analyzed</param>
        private void AppendAdapterInfo(StringBuilder sb, GraphicsAdapter adapter)
        {
            var adapterDescription = adapter.Description;

            // general adapter information
            sb.AppendLine(adapterDescription.Description);
            // onboard video RAM
            sb.AppendFormat("VRAM             : {0}MiB{1}", ToMB(adapterDescription.DedicatedVideoMemory), Environment.NewLine);
            // OS RAM dedicated to the adapter (typical for integrated GPUs)
            sb.AppendFormat("Dedicated OS RAM : {0}MiB{1}", ToMB(adapterDescription.DedicatedSystemMemory), Environment.NewLine);
            // OS RAM that can be shared with the adapter (for example, 'Turbo Cache' for NVidia GPUs)
            sb.AppendFormat("Shared OS RAM    : {0}MiB{1}", ToMB(adapterDescription.SharedSystemMemory), Environment.NewLine);

            // iterate trough all outputs attached to this adapter
            for (var i = 0; i < adapter.OutputsCount; i++)
            {
                // write its information
                var output = adapter.GetOutputAt(i);
                sb.AppendFormat("Output {0}; ", i);

                var description = ((Output)output).Description;
                var desktopBounds = description.DesktopBounds;

                sb.AppendFormat("{0}; Attached to desktop: {1}; Desktop bounds: ({2},{3}; {4},{5}); ",
                                description.DeviceName,
                                description.IsAttachedToDesktop,
                                desktopBounds.Left,
                                desktopBounds.Top,
                                desktopBounds.Right,
                                desktopBounds.Bottom);

                sb.AppendLine();
                sb.Append("\tCurrent display mode: ");

                // if there is a display mode - write its information and add it in the list of available modes
                var currentDisplayMode = output.CurrentDisplayMode;
                if (currentDisplayMode != null)
                {
                    if (availableModes.Count < 10)
                    {
                        var modeInfo = new ModeInfo(adapter, i, true, desktopBounds.Width, desktopBounds.Height);
                        availableModes.Add(modeInfo);
                    }

                    sb.AppendFormat("{0}x{1}@{2}, {3}",
                                    currentDisplayMode.Width,
                                    currentDisplayMode.Height,
                                    currentDisplayMode.RefreshRate.Numerator / currentDisplayMode.RefreshRate.Denominator,
                                    currentDisplayMode.Format);
                }
                else
                {
                    sb.Append("null");
                }

                sb.AppendLine();
            }
        }
Exemplo n.º 11
0
 /// <summary>
 /// Dispose all statically cached value by this instance.
 /// </summary>
 public new static void Dispose()
 {
     lock(staticLock)
     {
         Utilities.Dispose(ref staticCollector);
         adapters = null;
         defaultAdapter = null;
         isInitialized = false;
     }
 }
Exemplo n.º 12
0
        /// <summary>
        /// Initializes all adapters with the specified factory.
        /// </summary>
        /// <param name="factory1">The factory1.</param>
        internal static void Initialize(Factory1 factory1)
        {
            if (staticCollector != null)
            {
                staticCollector.Dispose();
            }

            staticCollector = new DisposeCollector();
            defaultFactory = factory1;
            staticCollector.Collect(defaultFactory);

            int countAdapters = defaultFactory.GetAdapterCount1();
            var adapterList = new List<GraphicsAdapter>();
            for (int i = 0; i < countAdapters; i++)
            {
                var adapter = new GraphicsAdapter(i);
                staticCollector.Collect(adapter);
                adapterList.Add(adapter);
            }

            defaultAdapter = adapterList.Count > 0 ? adapterList[0] : null;
            adapters = adapterList.ToArray();
        }
Exemplo n.º 13
0
        protected void AddDevice(GraphicsAdapter graphicsAdapter, DisplayMode mode,  GraphicsDeviceInformation deviceBaseInfo, GameGraphicsParameters prefferedParameters, List<GraphicsDeviceInformation> graphicsDeviceInfos)
        {
            var deviceInfo = deviceBaseInfo.Clone();

            PresentParameters p = new PresentParameters();
            p.InitDefaults();

            p.FullScreenRefreshRateInHz = mode.RefreshRate;

            if (prefferedParameters.IsFullScreen)
            {
                p.BackBufferWidth = prefferedParameters.PreferredBackBufferWidth;
                p.BackBufferHeight = prefferedParameters.PreferredBackBufferHeight;
                p.Windowed = false;
            }
            else
            {
                p.BackBufferWidth = prefferedParameters.PreferredBackBufferWidth;
                p.BackBufferHeight = prefferedParameters.PreferredBackBufferHeight;
                p.Windowed = true;
                p.FullScreenRefreshRateInHz = 0;
            }

            p.DeviceWindowHandle = MainWindow.NativeWindow.Handle;
            p.AutoDepthStencilFormat = prefferedParameters.PreferredDepthStencilFormat;
            p.MultiSampleQuality = 0;
            p.PresentationInterval = prefferedParameters.SynchronizeWithVerticalRetrace ? PresentInterval.One : PresentInterval.Immediate;
            p.SwapEffect = SwapEffect.Discard;
            p.PresentFlags = PresentFlags.Video;            

            deviceInfo.PresentationParameters = p;
            deviceInfo.Adapter = GraphicsAdapter.Adapters[prefferedParameters.PreferredVideoAdapter];

            if (!graphicsDeviceInfos.Contains(deviceInfo))
            {
                graphicsDeviceInfos.Add(deviceInfo);
            }
        }
Exemplo n.º 14
0
 public GenericGraphicsDevice(Device existingDevice, GraphicsAdapter adapter = null)
     : base(existingDevice, adapter)
 {
 }
Exemplo n.º 15
0
 public GenericGraphicsDevice(GraphicsAdapter adapter, DeviceCreationFlags flags = DeviceCreationFlags.None, params FeatureLevel[] featureLevels)
     : base(adapter, flags, featureLevels)
 {
 }
Exemplo n.º 16
0
        private void TryAddDeviceWithDisplayMode(GameGraphicsParameters prefferedParameters,
                                                 GraphicsAdapter graphicsAdapter,
                                                 GraphicsDeviceInformation deviceInfo,
                                                 List<GraphicsDeviceInformation> graphicsDeviceInfos)
        {
            if (graphicsAdapter.CurrentDisplayMode != null)
                AddDevice(graphicsAdapter, graphicsAdapter.CurrentDisplayMode, deviceInfo, prefferedParameters, graphicsDeviceInfos);

            if (prefferedParameters.IsFullScreen)
            {
                // Get display mode for the particular width, height, pixelformat
                foreach (var displayMode in graphicsAdapter.SupportedDisplayModes)
                    AddDevice(graphicsAdapter, displayMode, deviceInfo, prefferedParameters, graphicsDeviceInfos);
            }
        }