private static SwapchainSource GetSwapchainSource(IntPtr window) { SDL.SDL_SysWMinfo sysWmInfo = new SDL.SDL_SysWMinfo(); SDL.SDL_GetVersion(out sysWmInfo.version); SDL.SDL_GetWindowWMInfo(window, ref sysWmInfo); switch (sysWmInfo.subsystem) { case SDL.SDL_SYSWM_TYPE.SDL_SYSWM_WINDOWS: ref var w32Info = ref sysWmInfo.info.win; return(SwapchainSource.CreateWin32(w32Info.window, w32Info.hdc)); case SDL.SDL_SYSWM_TYPE.SDL_SYSWM_X11: ref var x11Info = ref sysWmInfo.info.x11; return(SwapchainSource.CreateXlib( x11Info.display, x11Info.window)); case SDL.SDL_SYSWM_TYPE.SDL_SYSWM_COCOA: ref var cocoaInfo = ref sysWmInfo.info.cocoa; var nsWindow = cocoaInfo.window; return(SwapchainSource.CreateNSWindow(nsWindow)); default: throw new PlatformNotSupportedException("Cannot create a SwapchainSource for " + sysWmInfo.subsystem + "."); } }
public Swapchain CreateSwapchain() { Swapchain swapchain; if (Widget.Backend == GraphicsBackend.OpenGL) { swapchain = Widget.GraphicsDevice.MainSwapchain; } else { // To embed Veldrid in an Eto control, these platform-specific // versions of CreateSwapchain use the technique outlined here: // // https://github.com/mellinoe/veldrid/issues/155 // var source = SwapchainSource.CreateNSView(Control.Handle); swapchain = Widget.GraphicsDevice.ResourceFactory.CreateSwapchain( new SwapchainDescription( source, (uint)RenderWidth, (uint)RenderHeight, Widget.GraphicsDeviceOptions.SwapchainDepthFormat, Widget.GraphicsDeviceOptions.SyncToVerticalBlank, Widget.GraphicsDeviceOptions.SwapchainSrgbFormat)); } return(swapchain); }
public override void ViewDidLoad() { base.ViewDidLoad(); SwapchainSource ss = SwapchainSource.CreateUIView(this.View.Handle); SwapchainDescription scd = new SwapchainDescription( ss, (uint)View.Frame.Width, (uint)View.Frame.Height, PixelFormat.R32_Float, false); if (_backend == GraphicsBackend.Metal) { _gd = GraphicsDevice.CreateMetal(_options); _sc = _gd.ResourceFactory.CreateSwapchain(ref scd); } else if (_backend == GraphicsBackend.OpenGLES) { _gd = GraphicsDevice.CreateOpenGLES(_options, scd); _sc = _gd.MainSwapchain; } else if (_backend == GraphicsBackend.Vulkan) { throw new NotImplementedException(); } GraphicsDeviceCreated?.Invoke(_gd, _gd.ResourceFactory, _sc); _viewLoaded = true; }
public static VeldridRender InitFromMetal(SwapchainSource scs) { try { var gd = GraphicsDevice.CreateMetal(new GraphicsDeviceOptions(), new SwapchainDescription(scs, 20, 20, null, false)); gd.WaitForIdle(); gd.ResizeMainWindow(270, 800); VeldridRender render = new VeldridRender(gd); byte[] data = Helpers.GetAssetByteArray("App.Shaders.Shader.metal"); render.Shaders = new Shader[] { render.graphicsDevice.ResourceFactory.CreateShader(new ShaderDescription(ShaderStages.Vertex, data, "shader_vertex", true)), render.graphicsDevice.ResourceFactory.CreateShader(new ShaderDescription(ShaderStages.Fragment, data, "shader_fragment", true)) }; return(render); } catch (Exception ex) { Logger.AddLog(ex); } return(null); }
public Swapchain CreateSwapchain() { Swapchain swapchain; if (Widget.Backend == GraphicsBackend.OpenGL) { swapchain = Widget.GraphicsDevice.MainSwapchain; } else { // To embed Veldrid in an Eto control, these platform-specific // versions of CreateSwapchain use the technique outlined here: // // https://github.com/mellinoe/veldrid/issues/155 // var source = SwapchainSource.CreateWin32( WinFormsControl.Handle, Marshal.GetHINSTANCE(typeof(VeldridSurface).Module)); var renderSize = RenderSize; swapchain = Widget.GraphicsDevice.ResourceFactory.CreateSwapchain( new SwapchainDescription( source, (uint)renderSize.Width, (uint)renderSize.Height, Widget.GraphicsDeviceOptions.SwapchainDepthFormat, Widget.GraphicsDeviceOptions.SyncToVerticalBlank, Widget.GraphicsDeviceOptions.SwapchainSrgbFormat)); } return(swapchain); }
public VeldridControl(GraphicsDevice graphics, GraphicsDeviceOptions options) { SetStyle(ControlStyles.Opaque, true); SetStyle(ControlStyles.UserPaint, true); SetStyle(ControlStyles.AllPaintingInWmPaint, true); DoubleBuffered = false; var hWnd = Handle; // Will call CreateHandle internally var hInstance = HInstance; uint w = (uint)Width, h = (uint)Height; if (w <= 0) { w = 1; } if (h <= 0) { h = 1; } var source = SwapchainSource.CreateWin32(hWnd, hInstance); var desc = new SwapchainDescription(source, w, h, options.SwapchainDepthFormat, options.SyncToVerticalBlank); Swapchain = graphics.ResourceFactory.CreateSwapchain(desc); Camera = new PerspectiveCamera(Width, Height); }
public Swapchain CreateSwapchain() { Swapchain swapchain; if (Widget.Backend == GraphicsBackend.OpenGL) { swapchain = Widget.GraphicsDevice.MainSwapchain; } else { // To embed Veldrid in an Eto control, these platform-specific // versions of CreateSwapchain use the technique outlined here: // // https://github.com/mellinoe/veldrid/issues/155 // var source = SwapchainSource.CreateXlib( X11Interop.gdk_x11_display_get_xdisplay(Control.Display.Handle), X11Interop.gdk_x11_window_get_xid(Control.Window.Handle)); var renderSize = RenderSize; swapchain = Widget.GraphicsDevice.ResourceFactory.CreateSwapchain( new SwapchainDescription( source, (uint)renderSize.Width, (uint)renderSize.Height, Widget.GraphicsDeviceOptions.SwapchainDepthFormat, Widget.GraphicsDeviceOptions.SyncToVerticalBlank, Widget.GraphicsDeviceOptions.SwapchainSrgbFormat)); } return(swapchain); }
public static unsafe SwapchainSource GetSwapchainSource(Sdl2Window window) { IntPtr sdlHandle = window.SdlWindowHandle; SDL_SysWMinfo sysWmInfo; Sdl2Native.SDL_GetVersion(&sysWmInfo.version); Sdl2Native.SDL_GetWMWindowInfo(sdlHandle, &sysWmInfo); switch (sysWmInfo.subsystem) { case SysWMType.Windows: Win32WindowInfo w32Info = Unsafe.Read <Win32WindowInfo>(&sysWmInfo.info); return(SwapchainSource.CreateWin32(w32Info.Sdl2Window, w32Info.hinstance)); case SysWMType.X11: X11WindowInfo x11Info = Unsafe.Read <X11WindowInfo>(&sysWmInfo.info); return(SwapchainSource.CreateXlib( x11Info.display, x11Info.Sdl2Window)); case SysWMType.Cocoa: CocoaWindowInfo cocoaInfo = Unsafe.Read <CocoaWindowInfo>(&sysWmInfo.info); IntPtr nsWindow = cocoaInfo.Window; return(SwapchainSource.CreateNSWindow(nsWindow)); default: throw new PlatformNotSupportedException("Cannot create a SwapchainSource for " + sysWmInfo.subsystem + "."); } }
public void SurfaceCreated(ISurfaceHolder holder) { if (holder is null) { throw new ArgumentNullException(nameof(holder)); } VeldridSwapchainSource = SwapchainSource.CreateAndroidSurface(holder.Surface.Handle, JNIEnv.Handle); Ready?.Invoke(this, EventArgs.Empty); }
protected override void OnLoad(EventArgs e) { base.OnLoad(e); var currentModule = typeof(VeldridPanel).Module; var hinstance = Marshal.GetHINSTANCE(currentModule); VeldridSwapchainSource = SwapchainSource.CreateWin32(Handle, hinstance); Ready?.Invoke(this, EventArgs.Empty); }
public override void ViewDidLoad() { base.ViewDidLoad(); View.BackgroundColor = UIColor.SystemPinkColor; // device init GraphicsDeviceOptions options = new GraphicsDeviceOptions(false, null, false, ResourceBindingModel.Improved); #if DEBUG options.Debug = true; #endif SwapchainSource ss = SwapchainSource.CreateUIView(this.View.Handle); SwapchainDescription scd = new SwapchainDescription( ss, width, height, PixelFormat.R32_Float, false); graphicsDevice = GraphicsDevice.CreateMetal(options); swapchain = graphicsDevice.ResourceFactory.CreateSwapchain(ref scd); factory = graphicsDevice.ResourceFactory; // resource init CreateSizeDependentResources(); VertexPosition[] quadVertices = { new VertexPosition(new Vector3(-1, 1, 0)), new VertexPosition(new Vector3(1, 1, 0)), new VertexPosition(new Vector3(-1, -1, 0)), new VertexPosition(new Vector3(1, -1, 0)) }; uint[] quadIndices = new uint[] { 0, 1, 2, 1, 3, 2 }; vertexBuffer = factory.CreateBuffer(new BufferDescription(4 * VertexPosition.SizeInBytes, BufferUsage.VertexBuffer)); indexBuffer = factory.CreateBuffer(new BufferDescription(6 * sizeof(uint), BufferUsage.IndexBuffer)); graphicsDevice.UpdateBuffer(vertexBuffer, 0, quadVertices); graphicsDevice.UpdateBuffer(indexBuffer, 0, quadIndices); commandList = factory.CreateCommandList(); viewLoaded = true; displayLink = CADisplayLink.Create(Render); displayLink.PreferredFramesPerSecond = 60; displayLink.AddToRunLoop(NSRunLoop.Main, NSRunLoop.NSDefaultRunLoopMode); }
protected virtual void CreateSwapchain() { var dpiScale = GetDpiScale(); var width = (uint)(ActualWidth < 0 ? 0 : Math.Ceiling(ActualWidth * dpiScale)); var height = (uint)(ActualHeight < 0 ? 0 : Math.Ceiling(ActualHeight * dpiScale)); var mainModule = typeof(VeldridComponent).Module; var hinstance = Marshal.GetHINSTANCE(mainModule); var win32Source = SwapchainSource.CreateWin32(Hwnd, hinstance); var scDesc = new SwapchainDescription(win32Source, width, height, PixelFormat.R32_Float, true); _sc = _gd.ResourceFactory.CreateSwapchain(scDesc); }
public override void ViewDidLoad() { base.ViewDidLoad(); // device init GraphicsDeviceOptions options = new GraphicsDeviceOptions(false, null, false, ResourceBindingModel.Improved); #if DEBUG options.Debug = true; #endif SwapchainSource ss = SwapchainSource.CreateNSView(this.View.Handle); SwapchainDescription scd = new SwapchainDescription( ss, width, height, PixelFormat.R32_Float, false); graphicsDevice = GraphicsDevice.CreateMetal(options); swapchain = graphicsDevice.ResourceFactory.CreateSwapchain(ref scd); factory = graphicsDevice.ResourceFactory; // resource init CreateSizeDependentResources(); VertexPosition[] quadVertices = { new VertexPosition(new Vector3(-1, 1, 0)), new VertexPosition(new Vector3(1, 1, 0)), new VertexPosition(new Vector3(-1, -1, 0)), new VertexPosition(new Vector3(1, -1, 0)) }; uint[] quadIndices = new uint[] { 0, 1, 2, 1, 3, 2 }; vertexBuffer = factory.CreateBuffer(new BufferDescription(4 * VertexPosition.SizeInBytes, BufferUsage.VertexBuffer)); indexBuffer = factory.CreateBuffer(new BufferDescription(6 * sizeof(uint), BufferUsage.IndexBuffer)); graphicsDevice.UpdateBuffer(vertexBuffer, 0, quadVertices); graphicsDevice.UpdateBuffer(indexBuffer, 0, quadIndices); commandList = factory.CreateCommandList(); viewLoaded = true; displayTimer = NSTimer.CreateRepeatingTimer(60.0 / 1000.0, Render); displayTimer.Fire(); }
public MTLSwapchain(MTLGraphicsDevice gd, ref SwapchainDescription description) { _gd = gd; SyncToVerticalBlank = description.SyncToVerticalBlank; _metalLayer = CAMetalLayer.New(); uint width; uint height; SwapchainSource source = description.Source; if (source is NSWindowSwapchainSource nsWindowSource) { NSWindow nswindow = new NSWindow(nsWindowSource.NSWindow); CGSize windowContentSize = nswindow.contentView.frame.size; width = (uint)windowContentSize.width; height = (uint)windowContentSize.height; NSView contentView = nswindow.contentView; contentView.wantsLayer = true; contentView.layer = _metalLayer.NativePtr; } else if (source is UIViewSwapchainSource uiViewSource) { _uiView = new UIView(uiViewSource.UIView); CGSize viewSize = _uiView.frame.size; width = (uint)viewSize.width; height = (uint)viewSize.height; _metalLayer.frame = _uiView.frame; _metalLayer.opaque = true; _uiView.layer.addSublayer(_metalLayer.NativePtr); } else { throw new VeldridException($"A Metal Swapchain can only be created from an NSWindow or UIView."); } _metalLayer.device = _gd.Device; _metalLayer.pixelFormat = MTLPixelFormat.BGRA8Unorm; _metalLayer.framebufferOnly = true; _metalLayer.drawableSize = new CGSize(width, height); GetNextDrawable(); _framebuffer = new MTLSwapchainFramebuffer( gd, this, width, height, description.DepthFormat, PixelFormat.B8_G8_R8_A8_UNorm); }
public static GraphicsDevice CreateDefaultD3D11GraphicsDevice( GraphicsDeviceOptions options, Sdl2Window window) { SwapchainSource source = GetSwapchainSource(window); SwapchainDescription swapchainDesc = new SwapchainDescription( source, (uint)window.Width, (uint)window.Height, options.SwapchainDepthFormat, options.SyncToVerticalBlank, options.SwapchainSrgbFormat); return(GraphicsDevice.CreateD3D11(options, swapchainDesc)); }
public VeldridImGuiWindow(GraphicsDevice gd, ImGuiViewportPtr vp) { _gcHandle = GCHandle.Alloc(this); _gd = gd; _vp = vp; SDL_WindowFlags flags = SDL_WindowFlags.Hidden; if ((vp.Flags & ImGuiViewportFlags.NoTaskBarIcon) != 0) { flags |= SDL_WindowFlags.SkipTaskbar; } if ((vp.Flags & ImGuiViewportFlags.NoDecoration) != 0) { flags |= SDL_WindowFlags.Borderless; } else { flags |= SDL_WindowFlags.Resizable; } if ((vp.Flags & ImGuiViewportFlags.TopMost) != 0) { flags |= SDL_WindowFlags.AlwaysOnTop; } _window = new Sdl2Window( "No Title Yet", (int)vp.Pos.X, (int)vp.Pos.Y, (int)vp.Size.X, (int)vp.Size.Y, flags, false); _window.Resized += () => _vp.PlatformRequestResize = true; _window.Moved += p => _vp.PlatformRequestMove = true; _window.Closed += () => _vp.PlatformRequestClose = true; SwapchainSource scSource = VeldridStartup.GetSwapchainSource(_window); SwapchainDescription scDesc = new SwapchainDescription(scSource, (uint)_window.Width, (uint)_window.Height, null, true, false); _sc = _gd.ResourceFactory.CreateSwapchain(scDesc); _window.Resized += () => _sc.Resize((uint)_window.Width, (uint)_window.Height); unsafe { ViewportDataPtr data = new ViewportDataPtr(Marshal.AllocHGlobal(Unsafe.SizeOf <ViewportDataPtr>())); vp.PlatformUserData = new HandleRef(data, (IntPtr)data.NativePtr).Handle; } vp.PlatformUserData = (IntPtr)_gcHandle; }
private void InitializeSubWindow(GraphicsDevice gd, Sdl2Window sdlWindow) { GcHandle = GCHandle.Alloc(this); graphicsDevice = gd; VSync = gd.SyncToVerticalBlank; window = sdlWindow; SwapchainSource scSrc = WindowStartup.GetSwapchainSource(sdlWindow); SwapchainDescription scDesc = new SwapchainDescription(scSrc, (uint)sdlWindow.Width, (uint)sdlWindow.Height, gd.SwapchainFramebuffer.OutputDescription.DepthAttachment?.Format, VSync); swapchain = gd.ResourceFactory.CreateSwapchain(scDesc); window.Resized += () => swapchain.Resize((uint)window.Width, (uint)window.Height); }
private static unsafe GraphicsDevice CreateMetalGraphicsDevice( GraphicsDeviceOptions options, Sdl2Window window, bool colorSrgb) { SwapchainSource source = GetSwapchainSource(window); SwapchainDescription swapchainDesc = new SwapchainDescription( source, (uint)window.Width, (uint)window.Height, options.SwapchainDepthFormat, options.SyncToVerticalBlank, colorSrgb); return(GraphicsDevice.CreateMetal(options, swapchainDesc)); }
internal static VkSurfaceKHR CreateSurface(VkInstance instance, SwapchainSource swapchainSource) { switch (swapchainSource) { case XlibSwapchainSource xlibSource: return(CreateXlib(instance, xlibSource)); case Win32SwapchainSource win32Source: return(CreateWin32(instance, win32Source)); case AndroidSurfaceSwapchainSource androidSource: return(CreateAndroidSurface(instance, androidSource)); default: throw new VeldridException($"The provided SwapchainSource cannot be used to create a Vulkan surface."); } }
internal static unsafe VkSurfaceSource CreateFromSwapchainSource(SwapchainSource source) { if (source is Win32SwapchainSource win32Source) { return(new Win32VkSurfaceInfo(win32Source.Hinstance, win32Source.Hwnd)); } else if (source is XlibSwapchainSource xlibSource) { return(new XlibVkSurfaceInfo((Display *)xlibSource.Display, new Window { Value = xlibSource.Window })); } else { throw new VeldridException("Unsupported Vulkan SwapchainSource."); } }
public void SurfaceCreated(ISurfaceHolder holder) { bool deviceCreated = false; if (_backend == GraphicsBackend.Vulkan) { if (GraphicsDevice == null) { SwapchainSource ss = SwapchainSource.CreateAndroidSurface(holder.Surface.Handle, JNIEnv.Handle); SwapchainDescription sd = new SwapchainDescription( ss, (uint)Width, (uint)Height, DeviceOptions.SwapchainDepthFormat, DeviceOptions.SyncToVerticalBlank); GraphicsDevice = GraphicsDevice.CreateVulkan(DeviceOptions, sd); deviceCreated = true; } Debug.Assert(MainSwapchain == null); MainSwapchain = GraphicsDevice.MainSwapchain; } else { Debug.Assert(GraphicsDevice == null && MainSwapchain == null); SwapchainSource ss = SwapchainSource.CreateAndroidSurface(holder.Surface.Handle, JNIEnv.Handle); SwapchainDescription sd = new SwapchainDescription( ss, (uint)Width, (uint)Height, DeviceOptions.SwapchainDepthFormat, DeviceOptions.SyncToVerticalBlank); GraphicsDevice = GraphicsDevice.CreateOpenGLES(DeviceOptions, sd); MainSwapchain = GraphicsDevice.MainSwapchain; deviceCreated = true; } if (deviceCreated) { DeviceCreated?.Invoke(); } _surfaceCreated = true; }
public VeldridControl(GraphicsBackend backend, GraphicsDeviceOptions deviceOptions) { if (!(backend == GraphicsBackend.Vulkan || backend == GraphicsBackend.OpenGL || backend == GraphicsBackend.Direct3D11)) { throw new NotSupportedException($"{backend} is not supported on windows."); } if (backend == GraphicsBackend.OpenGL) { throw new NotSupportedException($"{backend} is not currently implemented in this demo."); } _backend = backend; DeviceOptions = deviceOptions; SetStyle(ControlStyles.Opaque, true); SetStyle(ControlStyles.UserPaint, true); SetStyle(ControlStyles.AllPaintingInWmPaint, true); DoubleBuffered = false; NativeMethods.CreateWindow(Handle, MessageHandler, Width, Height, out var hwnd, out var hinstance); HWND = hwnd; HInstance = hinstance; if (_backend == GraphicsBackend.Vulkan) { GraphicsDevice = GraphicsDevice.CreateVulkan(deviceOptions); } else { GraphicsDevice = GraphicsDevice.CreateD3D11(deviceOptions); } const double dpiScale = 1; uint width = (uint)(Width < 0 ? 0 : Math.Ceiling(Width * dpiScale)); uint height = (uint)(Height < 0 ? 0 : Math.Ceiling(Height * dpiScale)); SwapchainSource swapchainSource = SwapchainSource.CreateWin32(HWND, HInstance); SwapchainDescription swapchainDescription = new SwapchainDescription(swapchainSource, width, height, PixelFormat.R32_Float, true); MainSwapchain = GraphicsDevice.ResourceFactory.CreateSwapchain(swapchainDescription); Disposed += OnDisposed; }
public override void MovedToWindow() { base.MovedToWindow(); var swapchainSource = SwapchainSource.CreateUIView(Handle); var swapchainDescription = new SwapchainDescription(swapchainSource, (uint)Frame.Width, (uint)Frame.Height, null, true, true); if (_backend == GraphicsBackend.Metal) { GraphicsDevice = GraphicsDevice.CreateMetal(_deviceOptions); } MainSwapchain = GraphicsDevice.ResourceFactory.CreateSwapchain(swapchainDescription); DeviceReady?.Invoke(); _displayLink = CADisplayLink.Create(HandleDisplayLinkOutputCallback); _displayLink.AddToRunLoop(NSRunLoop.Current, NSRunLoopMode.Default); }
public override void ViewDidMoveToWindow() { base.ViewDidMoveToWindow(); var swapchainSource = SwapchainSource.CreateNSView(Handle); var swapchainDescription = new SwapchainDescription(swapchainSource, (uint)Frame.Width, (uint)Frame.Height, null, true, true); if (_backend == GraphicsBackend.Metal) { GraphicsDevice = GraphicsDevice.CreateMetal(_deviceOptions); } MainSwapchain = GraphicsDevice.ResourceFactory.CreateSwapchain(swapchainDescription); DeviceReady?.Invoke(); _displayLink = new CVDisplayLink(); _displayLink.SetOutputCallback(HandleDisplayLinkOutputCallback); _displayLink.Start(); }
public void Ctor_SetsProperties(PixelFormat?depthFormat, bool syncToVerticalBlank) { Sdl2Window window = new Sdl2Window("SwapchainTestWindow", 0, 0, 100, 100, SDL_WindowFlags.Hidden, false); SwapchainSource source = VeldridStartup.GetSwapchainSource(window); SwapchainDescription swapchainDesc = new SwapchainDescription(source, 100, 100, depthFormat, syncToVerticalBlank); Swapchain swapchain = RF.CreateSwapchain(ref swapchainDesc); if (depthFormat == null) { Assert.Null(swapchain.Framebuffer.DepthTarget); } else { Assert.NotNull(swapchain.Framebuffer.DepthTarget); Assert.Equal(depthFormat, swapchain.Framebuffer.DepthTarget.Value.Target.Format); } Assert.Equal(syncToVerticalBlank, swapchain.SyncToVerticalBlank); window.Close(); }
public IRenderBase GetRender() { MetalInfo(); TaskCompletionSource <VeldridRender> tcs = new TaskCompletionSource <VeldridRender>(); App.RunOnMainThread(() => { //GPU won't always load without these Veldrid.MetalBindings.MTLDevice.MTLCreateSystemDefaultDevice(); MTLDevice.SystemDefault.Dispose(); //Thread.Sleep(50); UIView view = new UIView(); SwapchainSource scs = SwapchainSource.CreateUIView(new UIView().Handle);//Apparently necessary to not native crash when creating Color buffer on A10 processors(A12 won't need) //SwapchainSource scs = SwapchainSource.CreateUIView(UIApplication.SharedApplication.KeyWindow.RootViewController.View.Handle);//Apparently necessary to not native crash when creating Color buffer on A10 processors(A12 won't need) //UIApplication.SharedApplication.KeyWindow.Add(view); /* * Thread.Sleep(50); * * try * { * ViewPtr = UIApplication.SharedApplication.Windows[0].InputViewController.View.Handle; * } * catch { }*/ // IntPtr Handler = UIApplication.SharedApplication.Windows[0].RootViewController.View.Handle; //tcs.TrySetResult(VeldridRender.InitFromMetal(AppDelegate.RootViewControllerHandle)); tcs.SetResult(VeldridRender.InitFromMetal(scs)); }); var render = tcs.Task.Result; MetalInfo(); return(render); }
protected sealed override void Initialize() { var mainModule = typeof(VeldridPanel).Module; var hinstance = Marshal.GetHINSTANCE(mainModule); VeldridSwapchainSource = SwapchainSource.CreateWin32(Hwnd, hinstance); Ready?.Invoke(this, EventArgs.Empty); var here = Parent as FrameworkElement; while (here != null) { if (here is Window window) { window.Closing += Window_Closing; here = null; } else { here = here.Parent as FrameworkElement; } } }
private static GraphicsDevice Init(GraphicsBackend backend, GraphicsDeviceOptions options, SwapchainSource swapchainSource, uint startWidth, uint startHeight) { if (!GraphicsDevice.IsBackendSupported(backend) || backend == GraphicsBackend.OpenGL) { throw new NotSupportedException($"Graphics backend {backend} is not supported on this system."); } if (swapchainSource is null) { throw new ArgumentNullException(nameof(swapchainSource)); } var swapchainDescription = new SwapchainDescription { Source = swapchainSource, Width = startWidth, Height = startHeight, DepthFormat = options.SwapchainDepthFormat, SyncToVerticalBlank = options.SyncToVerticalBlank, ColorSrgb = options.SwapchainSrgbFormat }; var device = backend switch { GraphicsBackend.Direct3D11 => GraphicsDevice.CreateD3D11(options, swapchainDescription), GraphicsBackend.Metal => GraphicsDevice.CreateMetal(options, swapchainDescription), GraphicsBackend.Vulkan => GraphicsDevice.CreateVulkan(options, swapchainDescription), GraphicsBackend.OpenGLES => GraphicsDevice.CreateOpenGLES(options, swapchainDescription), _ => throw new InvalidOperationException($"Can't create a device for GraphicsBackend value: {backend}") }; return(device); }
internal static VkSurfaceKHR CreateSurface(VkGraphicsDevice gd, VkInstance instance, SwapchainSource swapchainSource) { // TODO a null GD is passed from VkSurfaceSource.CreateSurface for compatibility // when VkSurfaceInfo is removed we do not have to handle gd == null anymore var doCheck = gd != null; if (doCheck && !gd.HasSurfaceExtension(CommonStrings.VK_KHR_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_KHR_SURFACE_EXTENSION_NAME}"); } switch (swapchainSource) { case XlibSwapchainSource xlibSource: if (doCheck && !gd.HasSurfaceExtension(CommonStrings.VK_KHR_XLIB_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_KHR_XLIB_SURFACE_EXTENSION_NAME}"); } return(CreateXlib(instance, xlibSource)); case WaylandSwapchainSource waylandSource: if (doCheck && !gd.HasSurfaceExtension(CommonStrings.VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME}"); } return(CreateWayland(instance, waylandSource)); case Win32SwapchainSource win32Source: if (doCheck && !gd.HasSurfaceExtension(CommonStrings.VK_KHR_WIN32_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_KHR_WIN32_SURFACE_EXTENSION_NAME}"); } return(CreateWin32(instance, win32Source)); case AndroidSurfaceSwapchainSource androidSource: if (doCheck && !gd.HasSurfaceExtension(CommonStrings.VK_KHR_ANDROID_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_KHR_ANDROID_SURFACE_EXTENSION_NAME}"); } return(CreateAndroidSurface(instance, androidSource)); case NSWindowSwapchainSource nsWindowSource: if (doCheck && !gd.HasSurfaceExtension(CommonStrings.VK_MVK_MACOS_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_MVK_MACOS_SURFACE_EXTENSION_NAME}"); } return(CreateNSWindowSurface(instance, nsWindowSource)); case UIViewSwapchainSource uiViewSource: if (doCheck && !gd.HasSurfaceExtension(CommonStrings.VK_MVK_IOS_SURFACE_EXTENSION_NAME)) { throw new VeldridException($"The required instance extension was not available: {CommonStrings.VK_MVK_IOS_SURFACE_EXTENSION_NAME}"); } return(CreateUIViewSurface(instance, uiViewSource)); default: throw new VeldridException($"The provided SwapchainSource cannot be used to create a Vulkan surface."); } }