示例#1
0
        public void GraphicsCapabilitiesIsBlendEquationSupported()
        {
            tlog.Debug(tag, $"GraphicsCapabilitiesIsBlendEquationSupported START");

            try
            {
                GraphicsCapabilities.IsBlendEquationSupported(BlendEquationType.Color);
            }
            catch (Exception e)
            {
                tlog.Debug(tag, e.Message.ToString());
                Assert.Fail("Caught Exception: Failed!");
            }

            tlog.Debug(tag, $"GraphicsCapabilitiesIsBlendEquationSupported END (OK)");
        }
示例#2
0
        public GraphicsDevice(IGameWindow window, IWindowContainer container, GraphicsContext context, DeviceCreationFlags creationFlags)
        {
            if (window == null)
            {
                throw new ArgumentNullException("window");
            }
            if (container == null)
            {
                throw new ArgumentNullException("container");
            }
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (context.IsDisposed)
            {
                throw new ArgumentException("context is disposed.", "context");
            }

            this.DefaultWindow = window;
            this.container     = container;
            this.Context       = context;
            this.CreationFlags = creationFlags;

            Log.Debug("Got context: [ColorFormat: {0}, Depth: {1}, Stencil: {2}, FSAA Samples: {3}, AccumulatorFormat: {4}, Buffers: {5}, Stereo: {6}]",
                      Context.GraphicsMode.ColorFormat,
                      Context.GraphicsMode.Depth,
                      Context.GraphicsMode.Stencil,
                      Context.GraphicsMode.Samples,
                      Context.GraphicsMode.AccumulatorFormat,
                      Context.GraphicsMode.Buffers,
                      Context.GraphicsMode.Stereo);

            Context.LoadAll();

            capabilities = new GraphicsCapabilities();

            CheckGraphicsCapabilities(LogLevel.Verbose);

            Factory            = new GraphicsFactory(this);
            BindManager        = new OpenGL4.BindManager(this);
            this.RenderContext = new RenderContext(this);

            Context.MakeCurrent(null);
        }
示例#3
0
        private void CheckGraphicsCapabilities(LogLevel logLevel)
        {
            openGLCapabilities = new OpenGLGraphicsCapabilities();
            capabilities       = new GraphicsCapabilities();

            openGLCapabilities.OpenGLVersion = new Version(GL.GetInteger(GetPName.MajorVersion), GL.GetInteger(GetPName.MinorVersion));

            Log.Write(logLevel, "OpenGL Diagnostics:");
            Log.Write(logLevel, "\tOpenGL Version: {0}", openGLCapabilities.OpenGLVersion.ToString());

            //GLSL Version string auslesen
            string glslVersionString = "";

            if (openGLCapabilities.OpenGLVersion >= new Version(4, 3) && !string.IsNullOrWhiteSpace(glslVersionString = GL.GetString(StringName.ShadingLanguageVersion)))
            {
                string glslVersionStringMajor = glslVersionString.Substring(0, glslVersionString.IndexOf('.'));
                string glslVersionStringMinor = glslVersionString.Substring(glslVersionString.IndexOf('.') + 1, 1);

                int glslVersionMajor;
                int glslVersionMinor;
                if (!int.TryParse(glslVersionStringMajor, out glslVersionMajor) || !int.TryParse(glslVersionStringMinor, out glslVersionMinor))
                {
                    throw new DotGame.Graphics.GraphicsException("Could not determine supported GLSL version");
                }

                //Nicht Version mit String initialisieren da 4.40 als Major 4 und Minor 40 aufgefasst wird
                openGLCapabilities.GLSLVersion = new Version(glslVersionMajor, glslVersionMinor);
            }
            else if (glslVersions.ContainsKey(openGLCapabilities.OpenGLVersion))
            {
                openGLCapabilities.GLSLVersion = glslVersions[openGLCapabilities.OpenGLVersion];
            }
            else
            {
                throw new Exception("Could not determine supported GLSL version");
            }

            CheckGLError("Init Version");

            Log.Write(logLevel, "\tGLSL Version: {0}", openGLCapabilities.GLSLVersion.ToString());
            Log.Write(logLevel, "\tExtensions supported:");

            //Extensions überprüfen
            int extensionCount = GL.GetInteger(GetPName.NumExtensions);
            var extensions     = new List <string>();

            if (GL.GetError() == ErrorCode.NoError)
            {
                for (int i = 0; i < extensionCount; i++)
                {
                    extensions.Add(GL.GetString(StringNameIndexed.Extensions, i));
                }
            }
            else
            {
                var extensionString = GL.GetString(StringName.Extensions);
                extensions.AddRange(extensionString.Split(' '));
            }
            foreach (var extension in extensions)
            {
                switch (extension)
                {
                case "GL_EXT_texture_compression_s3tc":
                    openGLCapabilities.SupportsS3TextureCompression = true;
                    Log.Write(logLevel, "\t\t" + "GL_EXT_texture_compression_s3tc");
                    break;

                case "GL_EXT_texture_filter_anisotropic":
                    openGLCapabilities.SupportsAnisotropicFiltering = true;
                    openGLCapabilities.MaxAnisotropicFiltering      = (int)GL.GetFloat((GetPName)OpenTK.Graphics.OpenGL.ExtTextureFilterAnisotropic.MaxTextureMaxAnisotropyExt);
                    Log.Write(logLevel, "\t\t" + "GL_EXT_texture_filter_anisotropic");
                    CheckGLError("Init GL_EXT_texture_filter_anisotropic");
                    break;


                case "GL_ARB_debug_output":
                    openGLCapabilities.SupportsDebugOutput = true;

                    if (CreationFlags.HasFlag(DeviceCreationFlags.Debug))
                    {
                        onDebugMessage = new DebugProc(OnDebugMessage);
                        GL.Enable(EnableCap.DebugOutput);
                        GL.DebugMessageCallback(onDebugMessage, IntPtr.Zero);

                        GL.DebugMessageControl(DebugSourceControl.DontCare, DebugTypeControl.DontCare, DebugSeverityControl.DontCare, 0, new int[0], true);
                    }
                    Log.Write(logLevel, "\t\t" + "GL_ARB_debug_output");
                    CheckGLError("Init GL_ARB_debug_output");
                    break;

                case "GL_ARB_get_program_binary":
                    capabilities.SupportsBinaryShaders = true;
                    Log.Write(logLevel, "\t\t" + "GL_ARB_get_program_binary");
                    break;

                case "GL_ARB_texture_storage":
                    openGLCapabilities.SupportsTextureStorage = true;
                    Log.Write(logLevel, "\t\t" + "GL_ARB_texture_storage");
                    break;

                case "GL_ARB_buffer_storage":
                    openGLCapabilities.SupportsBufferStorage = true;
                    Log.Write(logLevel, "\t\t" + "GL_ARB_buffer_storage");
                    break;

                case "GL_ARB_invalidate_subdata":
                    openGLCapabilities.SupportsResourceValidation = true;
                    Log.Write(logLevel, "\t\t" + "GL_ARB_invalidate_subdata");
                    break;

                case "GL_EXT_direct_state_access":
                    if (openGLCapabilities.DirectStateAccess == DirectStateAccess.None)
                    {
                        openGLCapabilities.DirectStateAccess = DirectStateAccess.Extension;
                    }

                    Log.Write(logLevel, "\t\t" + "GL_EXT_direct_state_access");
                    break;

                case "GL_ARB_direct_state_access":
                    //openGLCapabilities.DirectStateAccess = DirectStateAccess.Core;
                    Log.Write(logLevel, "\t\t" + "GL_ARB_direct_state_access");
                    break;

                case "GL_ARB_vertex_attrib_binding":
                    openGLCapabilities.VertexAttribBinding          = true;
                    openGLCapabilities.MaxVertexAttribBindings      = GL.GetInteger((GetPName)All.MaxVertexAttribBindings);
                    openGLCapabilities.MaxVertexAttribBindingOffset = GL.GetInteger((GetPName)All.MaxVertexAttribRelativeOffset);
                    openGLCapabilities.MaxVertexAttribStride        = GL.GetInteger((GetPName)All.MaxVertexAttribStride);
                    Log.Write(logLevel, "\t\t" + "GL_ARB_vertex_attrib_binding");
                    CheckGLError("Init GL_ARB_vertex_attrib_binding");
                    break;
                }
            }

            openGLCapabilities.TextureUnits = GL.GetInteger(GetPName.MaxCombinedTextureImageUnits);
            CheckGLError("Init MaxCombinedTextureImageUnits");
            openGLCapabilities.MaxTextureLoDBias = GL.GetInteger(GetPName.MaxTextureLodBias);
            CheckGLError("Init MaxTextureLodBias");
            openGLCapabilities.MaxTextureSize = GL.GetInteger(GetPName.MaxTextureSize);
            CheckGLError("Init MaxTextureSize");
            openGLCapabilities.MaxVertexAttribs = GL.GetInteger(GetPName.MaxVertexAttribs);
            CheckGLError("Init MaxVertexAttribs");
            openGLCapabilities.MaxUniformBlockSize = GL.GetInteger(GetPName.MaxUniformBlockSize);
            CheckGLError("Init MaxUniformBlockSize");
            openGLCapabilities.MaxUniformBufferBindings = GL.GetInteger(GetPName.MaxUniformBufferBindings);
            CheckGLError("Init MaxUniformBufferBindings");
        }
示例#4
0
 internal static void Initialize(GraphicsDevice device)
 {
     GraphicsCapabilities.NonPowerOfTwo          = GraphicsCapabilities.GetNonPowerOfTwo(device);
     GraphicsCapabilities.TextureFilterAnisotric = true;
 }