Example #1
0
        public static unsafe void SetSDLGLContextAttributes(GraphicsDeviceOptions options, GraphicsBackend backend)
        {
            if (backend != GraphicsBackend.OpenGL && backend != GraphicsBackend.OpenGLES)
            {
                throw new VeldridException(
                          $"{nameof(backend)} must be {nameof(GraphicsBackend.OpenGL)} or {nameof(GraphicsBackend.OpenGLES)}.");
            }

            SDL_GLContextFlag contextFlags = options.Debug ? SDL_GLContextFlag.Debug | SDL_GLContextFlag.ForwardCompatible : SDL_GLContextFlag.ForwardCompatible;

            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextFlags, (int)contextFlags);

            SetMaxGLVersion(backend == GraphicsBackend.OpenGLES);

            int depthBits   = 0;
            int stencilBits = 0;

            if (options.SwapchainDepthFormat.HasValue)
            {
                switch (options.SwapchainDepthFormat)
                {
                case PixelFormat.R16_UNorm:
                    depthBits = 16;
                    break;

                case PixelFormat.D24_UNorm_S8_UInt:
                    depthBits   = 24;
                    stencilBits = 8;
                    break;

                case PixelFormat.R32_Float:
                    depthBits = 32;
                    break;

                case PixelFormat.D32_Float_S8_UInt:
                    depthBits   = 32;
                    stencilBits = 8;
                    break;

                default:
                    throw new VeldridException("Invalid depth format: " + options.SwapchainDepthFormat.Value);
                }
            }

            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.DepthSize, depthBits);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.StencilSize, stencilBits);

            if (options.SwapchainSrgbFormat)
            {
                Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.FramebufferSrgbCapable, 1);
            }
            else
            {
                Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.FramebufferSrgbCapable, 0);
            }
        }
Example #2
0
        private static OpenGLESRenderContext CreateDefaultOpenGLESRenderContext(Sdl2Window window)
        {
            bool debugContext = false;

            debugContext |= s_allowDebugContexts;

            if (debugContext)
            {
                Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextFlags, (int)SDL_GLContextFlag.Debug);
            }

            IntPtr sdlHandle = window.SdlWindowHandle;

            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextProfileMask, (int)SDL_GLProfile.ES);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMajorVersion, 3);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMinorVersion, 0);
            IntPtr contextHandle = Sdl2Native.SDL_GL_CreateContext(sdlHandle);

            Sdl2Native.SDL_GL_MakeCurrent(sdlHandle, contextHandle);

            if (contextHandle == IntPtr.Zero)
            {
                unsafe
                {
                    byte * error       = Sdl2Native.SDL_GetError();
                    string errorString = Utilities.GetString(error);
                    throw new InvalidOperationException("Unable to create GL Context: " + errorString);
                }
            }

            Sdl2Native.SDL_GL_MakeCurrent(sdlHandle, contextHandle);
            OpenGLPlatformContextInfo ci = new OpenGLPlatformContextInfo(
                contextHandle,
                Sdl2Native.SDL_GL_GetProcAddress,
                Sdl2Native.SDL_GL_GetCurrentContext,
                () => Sdl2Native.SDL_GL_SwapWindow(sdlHandle));
            var rc = new OpenGLESRenderContext(window, ci);

            if (debugContext)
            {
                rc.EnableDebugCallback(OpenTK.Graphics.ES30.DebugSeverity.DebugSeverityNotification);
            }
            return(rc);
        }
        public static unsafe GraphicsDevice CreateOpenGLGraphicsDevice(Sdl2Window window, GraphicsDeviceOptions options)
        {
            Sdl2Native.SDL_ClearError();
            var           sdlHandle = window.SdlWindowHandle;
            SDL_SysWMinfo sdlSysWmInfo;

            Sdl2Native.SDL_GetVersion(&sdlSysWmInfo.version);
            Sdl2Native.SDL_GetWMWindowInfo(sdlHandle, &sdlSysWmInfo);

            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextFlags, options.Debug ? 3 : 2);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextProfileMask, 1);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMajorVersion, 4);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMinorVersion, 1);

            options.SwapchainDepthFormat = PixelFormat.D32_Float_S8_UInt;
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.DepthSize, 32);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.StencilSize, 8);

            var contextHandle = Sdl2Native.SDL_GL_CreateContext(sdlHandle);
            var error         = Sdl2Native.SDL_GetError();

            if ((IntPtr)error != IntPtr.Zero)
            {
                var str = GetString(error);
                if (!string.IsNullOrEmpty(str))
                {
                    throw new VeldridException(string.Format("Unable to create OpenGL Context: \"{0}\". This may indicate that the system does not support the requested OpenGL profile, version, or Swapchain format.", str));
                }
            }
            int num1;

            Sdl2Native.SDL_GL_GetAttribute(SDL_GLAttribute.DepthSize, &num1);
            int num2;

            Sdl2Native.SDL_GL_GetAttribute(SDL_GLAttribute.StencilSize, &num2);
            Sdl2Native.SDL_GL_SetSwapInterval(options.SyncToVerticalBlank ? 1 : 0);
            var getProcAddress = new Func <string, IntPtr>(Sdl2Native.SDL_GL_GetProcAddress);
            var makeCurrent    = (Action <IntPtr>)(context => Sdl2Native.SDL_GL_MakeCurrent(sdlHandle, context));
            var deleteContext  = new Action <IntPtr>(Sdl2Native.SDL_GL_DeleteContext);
            var swapBuffers    = (Action)(() => Sdl2Native.SDL_GL_SwapWindow(sdlHandle));
            var platformInfo   = new OpenGLPlatformInfo(contextHandle, getProcAddress, makeCurrent, Sdl2Native.SDL_GL_GetCurrentContext, () => Sdl2Native.SDL_GL_MakeCurrent(new SDL_Window(IntPtr.Zero), IntPtr.Zero), deleteContext, swapBuffers, sync => Sdl2Native.SDL_GL_SetSwapInterval(sync ? 1 : 0));

            return(GraphicsDevice.CreateOpenGL(options, platformInfo, (uint)window.Width, (uint)window.Height));
        }
Example #4
0
        private static OpenGLRenderContext CreateDefaultOpenGLRenderContext(Sdl2Window window)
        {
            bool debugContext = false;

#if DEBUG
            debugContext = Preferences.Instance.AllowOpenGLDebugContexts;
#endif
            IntPtr sdlHandle = window.SdlWindowHandle;
            if (debugContext)
            {
                Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextFlags, (int)SDL_GLContextFlag.Debug);
            }

            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextProfileMask, (int)SDL_GLProfile.Core);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMajorVersion, 4);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMinorVersion, 0);

            IntPtr contextHandle = Sdl2Native.SDL_GL_CreateContext(sdlHandle);
            if (contextHandle == IntPtr.Zero)
            {
                unsafe
                {
                    byte * error       = Sdl2Native.SDL_GetError();
                    string errorString = Utilities.GetString(error);
                    throw new InvalidOperationException("Unable to create GL Context: " + errorString);
                }
            }

            Sdl2Native.SDL_GL_MakeCurrent(sdlHandle, contextHandle);
            OpenGLPlatformContextInfo ci = new OpenGLPlatformContextInfo(
                contextHandle,
                Sdl2Native.SDL_GL_GetProcAddress,
                Sdl2Native.SDL_GL_GetCurrentContext,
                () => Sdl2Native.SDL_GL_SwapWindow(sdlHandle));
            var rc = new OpenGLRenderContext(window, ci);
            if (debugContext)
            {
                // Slows things down significantly -- Only use when debugging something specific.
                rc.EnableDebugCallback(OpenTK.Graphics.OpenGL.DebugSeverity.DebugSeverityNotification);
            }
            return(rc);
        }
Example #5
0
        //public static OpenGLESRenderContext CreateDefaultOpenGLESRenderContext(ref RenderContextCreateInfo contextCI, Sdl2Window window)
        //{
        //    if (contextCI.DebugContext)
        //    {
        //        Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextFlags, (int)SDL_GLContextFlag.Debug);
        //    }

        //    IntPtr sdlHandle = window.SdlWindowHandle;
        //    Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextProfileMask, (int)SDL_GLProfile.ES);
        //    Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMajorVersion, 3);
        //    Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMinorVersion, 0);
        //    IntPtr contextHandle = Sdl2Native.SDL_GL_CreateContext(sdlHandle);
        //    Sdl2Native.SDL_GL_MakeCurrent(sdlHandle, contextHandle);

        //    if (contextHandle == IntPtr.Zero)
        //    {
        //        unsafe
        //        {
        //            byte* error = Sdl2Native.SDL_GetError();
        //            string errorString = Utilities.GetString(error);
        //            throw new VeldridException("Unable to create GL Context: " + errorString);
        //        }
        //    }

        //    OpenGLPlatformContextInfo ci = new OpenGLPlatformContextInfo(
        //        contextHandle,
        //        Sdl2Native.SDL_GL_GetProcAddress,
        //        Sdl2Native.SDL_GL_GetCurrentContext,
        //        () => Sdl2Native.SDL_GL_SwapWindow(sdlHandle));
        //    OpenGLESRenderContext rc = new OpenGLESRenderContext(window, ci);
        //    if (contextCI.DebugContext)
        //    {
        //        rc.EnableDebugCallback(OpenTK.Graphics.ES30.DebugSeverity.DebugSeverityLow);
        //    }
        //    return rc;
        //}

        public static GraphicsDevice CreateDefaultOpenGLRenderContext(ref GraphicsDeviceCreateInfo gdCI, Sdl2Window window)
        {
            IntPtr sdlHandle = window.SdlWindowHandle;

            if (gdCI.DebugDevice)
            {
                Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextFlags, (int)SDL_GLContextFlag.Debug);
            }

            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextProfileMask, (int)SDL_GLProfile.Core);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMajorVersion, 4);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMinorVersion, 0);

            IntPtr contextHandle = Sdl2Native.SDL_GL_CreateContext(sdlHandle);

            if (contextHandle == IntPtr.Zero)
            {
                unsafe
                {
                    byte * error       = Sdl2Native.SDL_GetError();
                    string errorString = GetString(error);
                    throw new VeldridException("Unable to create GL Context: " + errorString);
                }
            }

            int result = Sdl2Native.SDL_GL_SetSwapInterval(0);

            OpenGLPlatformInfo platformInfo = new OpenGLPlatformInfo(
                contextHandle,
                Sdl2Native.SDL_GL_GetProcAddress,
                context => Sdl2Native.SDL_GL_MakeCurrent(sdlHandle, context),
                Sdl2Native.SDL_GL_DeleteContext,
                () => Sdl2Native.SDL_GL_SwapWindow(sdlHandle));

            return(Hacks.CreateOpenGL(
                       platformInfo,
                       (uint)window.Width,
                       (uint)window.Height,
                       gdCI.DebugDevice));
        }
Example #6
0
        public static GraphicsDevice CreateDefaultOpenGLGraphicsDevice(GraphicsDeviceOptions options, Sdl2Window window)
        {
            IntPtr sdlHandle = window.SdlWindowHandle;

            if (options.Debug)
            {
                Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextFlags, (int)SDL_GLContextFlag.Debug);
            }

            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextProfileMask, (int)SDL_GLProfile.Core);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMajorVersion, 4);
            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.ContextMinorVersion, 0);

            int depthBits = 0;

            if (options.SwapchainDepthFormat.HasValue)
            {
                switch (options.SwapchainDepthFormat)
                {
                case PixelFormat.R16_UNorm:
                    depthBits = 16;
                    break;

                case PixelFormat.R32_Float:
                    depthBits = 32;
                    break;

                default:
                    throw new VeldridException("Invalid depth format: " + options.SwapchainDepthFormat.Value);
                }
            }

            Sdl2Native.SDL_GL_SetAttribute(SDL_GLAttribute.DepthSize, depthBits);

            IntPtr contextHandle = Sdl2Native.SDL_GL_CreateContext(sdlHandle);

            if (contextHandle == IntPtr.Zero)
            {
                unsafe
                {
                    byte * error       = Sdl2Native.SDL_GetError();
                    string errorString = GetString(error);
                    throw new VeldridException("Unable to create GL Context: " + errorString);
                }
            }

            int result = Sdl2Native.SDL_GL_SetSwapInterval(options.SyncToVerticalBlank ? 1 : 0);

            OpenGLPlatformInfo platformInfo = new OpenGLPlatformInfo(
                contextHandle,
                Sdl2Native.SDL_GL_GetProcAddress,
                context => Sdl2Native.SDL_GL_MakeCurrent(sdlHandle, context),
                () => Sdl2Native.SDL_GL_GetCurrentContext(),
                () => Sdl2Native.SDL_GL_MakeCurrent(new SDL_Window(IntPtr.Zero), IntPtr.Zero),
                Sdl2Native.SDL_GL_DeleteContext,
                () => Sdl2Native.SDL_GL_SwapWindow(sdlHandle),
                sync => Sdl2Native.SDL_GL_SetSwapInterval(sync ? 1 : 0));

            return(GraphicsDevice.CreateOpenGL(
                       options,
                       platformInfo,
                       (uint)window.Width,
                       (uint)window.Height));
        }