public void TestConstructorRaw() { using (DeviceContext deviceContext = DeviceContext.Create()) { // Create a context manually IntPtr glContext = deviceContext.CreateContext(IntPtr.Zero); // Create a GraphicsContext on glContext GraphicsContext graphicsContext = null; try { Assert.DoesNotThrow(delegate { graphicsContext = new GraphicsContext(deviceContext, glContext); }); TestConstructProperties(graphicsContext); Assert.AreEqual(glContext, graphicsContext.Handle, "GL context handle different from original"); Assert.IsTrue(deviceContext.RefCount > 0, "DeviceContext is not referenced"); } finally { if (graphicsContext != null) { graphicsContext.Dispose(); TestDisposedProperties(graphicsContext); } } Assert.IsTrue(deviceContext.RefCount == 0, "DeviceContext was not referenced"); // Context won't be deleted by GraphicsContext in this case deviceContext.DeleteContext(glContext); } }
private static void RenderOsdPBuffer(DeviceContext deviceContext) { IntPtr glContext = IntPtr.Zero; uint framebuffer = 0; uint renderbuffer = 0; try { // Create context and make current on this thread if ((glContext = deviceContext.CreateContext(IntPtr.Zero)) == IntPtr.Zero) throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error()); // XXX deviceContext.MakeCurrent(glContext); // Create framebuffer resources int w = Math.Min(800, 800); int h = Math.Min(600, 800); RenderOsd(w, h); SnapshotOsd(w, h); } finally { if (renderbuffer != 0) Gl.DeleteRenderbuffers(renderbuffer); if (framebuffer != 0) Gl.DeleteFramebuffers(framebuffer); if (glContext != IntPtr.Zero) deviceContext.DeleteContext(glContext); } }
private void TestGetCurrentContext_Core() { using (DeviceContext deviceContext = DeviceContext.Create()) { if (deviceContext.IsPixelFormatSet == false) { deviceContext.ChoosePixelFormat(new DevicePixelFormat(24)); } IntPtr currentContext = DeviceContext.GetCurrentContext(); // Initially no current context Assert.AreEqual(IntPtr.Zero, currentContext); IntPtr glContext = deviceContext.CreateContext(IntPtr.Zero); try { deviceContext.MakeCurrent(glContext); // No the previously GL context is current on this thread currentContext = DeviceContext.GetCurrentContext(); Assert.AreEqual(glContext, currentContext); deviceContext.MakeCurrent(IntPtr.Zero); } finally { deviceContext.DeleteContext(glContext); } } }
public static void Init() { Gl.Initialize(); pixelBuff = DeviceContext.CreatePBuffer(new DevicePixelFormat(24), 128, 128); devCtx = DeviceContext.Create(pixelBuff); glCtx = devCtx.CreateContext(IntPtr.Zero); devCtx.MakeCurrent(glCtx); }
private static void RenderOsdFramebuffer(DeviceContext deviceContext) { IntPtr glContext = IntPtr.Zero; uint framebuffer = 0; uint renderbuffer = 0; try { // Create context and make current on this thread if ((glContext = deviceContext.CreateContext(IntPtr.Zero)) == IntPtr.Zero) { throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error()); // XXX } deviceContext.MakeCurrent(glContext); // Create framebuffer resources int w = Math.Min(800, Gl.CurrentLimits.MaxRenderbufferSize); int h = Math.Min(600, Gl.CurrentLimits.MaxRenderbufferSize); renderbuffer = Gl.GenRenderbuffer(); Gl.BindRenderbuffer(RenderbufferTarget.Renderbuffer, renderbuffer); Gl.RenderbufferStorage(RenderbufferTarget.Renderbuffer, InternalFormat.Rgb8, w, h); framebuffer = Gl.GenFramebuffer(); Gl.BindFramebuffer(FramebufferTarget.ReadFramebuffer, framebuffer); Gl.BindFramebuffer(FramebufferTarget.Framebuffer, framebuffer); Gl.FramebufferRenderbuffer(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, RenderbufferTarget.Renderbuffer, renderbuffer); FramebufferStatus framebufferStatus = Gl.CheckFramebufferStatus(FramebufferTarget.Framebuffer); if (framebufferStatus != FramebufferStatus.FramebufferComplete) { throw new InvalidOperationException("framebuffer not complete"); } Gl.DrawBuffers(Gl.COLOR_ATTACHMENT0); RenderOsd(w, h); Gl.ReadBuffer(ReadBufferMode.ColorAttachment0); SnapshotOsd(w, h); } finally { if (renderbuffer != 0) { Gl.DeleteRenderbuffers(renderbuffer); } if (framebuffer != 0) { Gl.DeleteFramebuffers(framebuffer); } if (glContext != IntPtr.Zero) { deviceContext.DeleteContext(glContext); } } }
static void Main() { try { string envDebug = Environment.GetEnvironmentVariable("DEBUG"); if (envDebug == "GL") { KhronosApi.Log += delegate(object sender, KhronosLogEventArgs e) { Console.WriteLine(e.ToString()); }; KhronosApi.LogEnabled = true; } // RPi runs on EGL Egl.IsRequired = true; if (Egl.IsAvailable == false) { throw new InvalidOperationException("EGL is not available. Aborting."); } using (VideoCoreWindow nativeWindow = new VideoCoreWindow()) { using (DeviceContext eglContext = DeviceContext.Create(nativeWindow.Display, nativeWindow.Handle)) { eglContext.ChoosePixelFormat(new DevicePixelFormat(32)); IntPtr glContext = eglContext.CreateContext(IntPtr.Zero); eglContext.MakeCurrent(glContext); Initialize(); Gl.Viewport(0, 0, 1920, 1080); Gl.ClearColor(0.0f, 0.0f, 0.0f, 1.0f); while (true) { Gl.Clear(ClearBufferMask.ColorBufferBit); Draw(); eglContext.SwapBuffers(); break; } System.Threading.Thread.Sleep(10000); Terminate(); eglContext.DeleteContext(glContext); } } } catch (Exception exception) { Console.WriteLine(exception.ToString()); } }
private void DeviceContext_CreateContext_DefaultAPI_Core(string api) { using (Device device = new Device()) { DeviceContext deviceContext = device.Context; List <string> availableAPIs = new List <string>(deviceContext.AvailableAPIs); if (availableAPIs.Contains(api) == false) { Assert.Inconclusive("underlying device is unable to support '" + api + "'"); } if (deviceContext.IsPixelFormatSet == false) { deviceContext.ChoosePixelFormat(new DevicePixelFormat(24)); } IntPtr glContext = deviceContext.CreateContext(IntPtr.Zero); Assert.AreNotEqual(IntPtr.Zero, glContext); try { if (deviceContext.MakeCurrent(glContext) == false) { Assert.Fail("unable to make current"); } string glVersionString = Gl.GetString(StringName.Version); KhronosVersion glVersion = KhronosVersion.Parse(glVersionString); switch (api) { case KhronosVersion.ApiGlsc2: // SC2 is a special case: based on ES2 Assert.AreEqual(KhronosVersion.ApiGles2, glVersion.Api); break; default: Assert.AreEqual(api, glVersion.Api); break; } deviceContext.MakeCurrent(IntPtr.Zero); } finally { if (glContext != IntPtr.Zero) { deviceContext.DeleteContext(glContext); } } } }
void InitOpenGL() { // Create OpenGL device context _deviceContext = DeviceContext.Create(IntPtr.Zero, _hWnd); // Choose pixel format _deviceContext.ChoosePixelFormat(new DevicePixelFormat(24)); // Create OpenGL Context _ctx = _deviceContext.CreateContext(IntPtr.Zero); // Make context current _deviceContext.MakeCurrent(_ctx); }
private void TestUserCase1_Core() { using (DeviceContext deviceContext = DeviceContext.Create()) { if (deviceContext.IsPixelFormatSet == false) { deviceContext.ChoosePixelFormat(new DevicePixelFormat(24)); } IntPtr glContext = deviceContext.CreateContext(IntPtr.Zero); deviceContext.MakeCurrent(glContext); // Perform drawing... deviceContext.MakeCurrent(IntPtr.Zero); deviceContext.DeleteContext(glContext); } }
private static void RenderOsdFramebuffer(DeviceContext deviceContext) { IntPtr glContext = IntPtr.Zero; uint framebuffer = 0; uint renderbuffer = 0; try { // Create context and make current on this thread if ((glContext = deviceContext.CreateContext(IntPtr.Zero)) == IntPtr.Zero) throw new System.ComponentModel.Win32Exception(System.Runtime.InteropServices.Marshal.GetLastWin32Error()); // XXX deviceContext.MakeCurrent(glContext); // Create framebuffer resources int w = Math.Min(800, Gl.CurrentLimits.MaxRenderBufferSize); int h = Math.Min(600, Gl.CurrentLimits.MaxRenderBufferSize); renderbuffer = Gl.GenRenderbuffer(); Gl.BindRenderbuffer(Gl.RENDERBUFFER, renderbuffer); Gl.RenderbufferStorage(Gl.RENDERBUFFER, Gl.RGB8, w, h); framebuffer = Gl.GenFramebuffer(); Gl.BindFramebuffer(Gl.READ_FRAMEBUFFER, framebuffer); Gl.BindFramebuffer(Gl.FRAMEBUFFER, framebuffer); Gl.FramebufferRenderbuffer(Gl.FRAMEBUFFER, Gl.COLOR_ATTACHMENT0, Gl.RENDERBUFFER, renderbuffer); int framebufferStatus = Gl.CheckFramebufferStatus(Gl.FRAMEBUFFER); if (framebufferStatus != Gl.FRAMEBUFFER_COMPLETE) throw new InvalidOperationException("framebuffer not complete"); Gl.DrawBuffers(Gl.COLOR_ATTACHMENT0); RenderOsd(w, h); Gl.ReadBuffer(ReadBufferMode.ColorAttachment0); SnapshotOsd(w, h); } finally { if (renderbuffer != 0) Gl.DeleteRenderbuffers(renderbuffer); if (framebuffer != 0) Gl.DeleteFramebuffers(framebuffer); if (glContext != IntPtr.Zero) deviceContext.DeleteContext(glContext); } }
public Sender() { _sendPool = new DedicatedThreadPool(new DedicatedThreadPoolSettings(1, ThreadType.Background, "Send-Pool")); _sendPool.QueueUserWorkItem(() => { // Initialize Static Core _deviceContext = DeviceContext.Create(); _glContext = _deviceContext.CreateContext(IntPtr.Zero); _deviceContext.MakeCurrent(_glContext); //_senderLocker = new object(); // Initialize Core _sender = new SpoutSender(); _sender.CreateSender(SenderName, _width, _height, 0); }); }
private void TestUserCase3_Core() { if (DeviceContext.IsPBufferSupported == false) { Assert.Inconclusive("platform don't support P-Buffers"); } using (INativePBuffer nativePBuffer = DeviceContext.CreatePBuffer(new DevicePixelFormat(24), 64, 64)) { using (DeviceContext deviceContext = DeviceContext.Create(nativePBuffer)) { // The pixel format is already defined by INativePBuffer Assert.IsTrue(deviceContext.IsPixelFormatSet); IntPtr glContext = deviceContext.CreateContext(IntPtr.Zero); deviceContext.MakeCurrent(glContext); // Perform drawing... deviceContext.MakeCurrent(IntPtr.Zero); deviceContext.DeleteContext(glContext); } } }
public RCode CreateDevice(Dictionary <string, object> parameters, bool bFullScreen, bool bVSYNC) { IntPtr window = IntPtr.Zero; IntPtr display = IntPtr.Zero; if (parameters.ContainsKey("windowPtr")) { window = (IntPtr)parameters["windowPtr"]; } if (parameters.ContainsKey("displayPtr")) { display = (IntPtr)parameters["displayPtr"]; } deviceContext = DeviceContext.Create(display, window); deviceContext.ChoosePixelFormat(new DevicePixelFormat() { DoubleBuffer = true }); renderContext = deviceContext.CreateContext(IntPtr.Zero); if (renderContext == IntPtr.Zero) { return(RCode.FAIL); } if (!deviceContext.MakeCurrent(renderContext)) { return(RCode.FAIL); } deviceContext.SwapInterval(0); Gl.Enable(EnableCap.Blend); Gl.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha); Gl.Enable(EnableCap.Texture2d); return(RCode.OK); }
private void TestCreateContextAttrib_Core() { using (DeviceContext deviceContext = DeviceContext.Create()) { if (deviceContext.IsPixelFormatSet == false) { deviceContext.ChoosePixelFormat(new DevicePixelFormat(24)); } IntPtr glContext = IntPtr.Zero; Assert.DoesNotThrow(delegate() { glContext = deviceContext.CreateContext(IntPtr.Zero); }); try { Assert.AreNotEqual(IntPtr.Zero, glContext); Assert.DoesNotThrow(delegate() { deviceContext.MakeCurrent(glContext); }); Assert.DoesNotThrow(delegate() { deviceContext.MakeCurrent(IntPtr.Zero); }); } finally { if (glContext != IntPtr.Zero) { deviceContext.DeleteContext(glContext); } } } }
/// <summary> /// This is called immediately after the surface is first created. /// </summary> /// <param name="holder"> /// The SurfaceHolder whose surface is being created. /// </param> public void SurfaceCreated(ISurfaceHolder holder) { Debug.WriteLine("Sparrow: SurfaceCreated"); // Get actual native window handle _NativeWindowHandle = ANativeWindow_fromSurface(JNIEnv.Handle, holder.Surface.Handle); // Create device context _DeviceContext = DeviceContext.Create(IntPtr.Zero, _NativeWindowHandle); _DeviceContext.IncRef(); // Set pixel format DevicePixelFormatCollection pixelFormats = _DeviceContext.PixelsFormats; DevicePixelFormat controlReqFormat = new DevicePixelFormat(); controlReqFormat.RgbaUnsigned = true; controlReqFormat.RenderWindow = true; controlReqFormat.ColorBits = 24; //controlReqFormat.DepthBits = (int)DepthBits; //controlReqFormat.StencilBits = (int)StencilBits; //controlReqFormat.MultisampleBits = (int)MultisampleBits; //controlReqFormat.DoubleBuffer = true; List <DevicePixelFormat> matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException("unable to find a suitable pixel format"); } _DeviceContext.SetPixelFormat(matchingPixelFormats[0]); // Create OpenGL context using compatibility profile if ((_RenderContext = _DeviceContext.CreateContext(IntPtr.Zero)) == IntPtr.Zero) { throw new InvalidOperationException("unable to create render context"); } // Make context current if (_DeviceContext.MakeCurrent(_RenderContext) == false) { throw new InvalidOperationException("unable to make context current"); } Invalidate(); if (_RenderTimer != null) { throw new InvalidOperationException("rendering already active"); } if (SparrowSharp.Root == null) { SparrowSharp.NativeWindow = this; // TODO get viewport dimensions? SparrowSharp.Start((uint)Width, (uint)Height, (uint)Width, (uint)Height, _rootClass); } else { SparrowSharp.OnContextCreated(); } _RenderTimerDueTime = (int)Math.Ceiling(1000.0f / 60.0f); _RenderTimer = new Timer(RenderTimerCallback, null, _RenderTimerDueTime, Timeout.Infinite); }
/// <summary> /// Create the NativeWindow context, eventually shared with others. /// </summary> protected void CreateDesktopContext() { if (GLContext != IntPtr.Zero) { throw new InvalidOperationException("context already created"); } IntPtr sharingContext = IntPtr.Zero; bool shareResources = false; if (shareResources) { List <IntPtr> sharingContextes; if (_SharingGroups.TryGetValue(ContextSharingGroup, out sharingContextes)) { sharingContext = sharingContextes.Count > 0 ? sharingContextes[0] : IntPtr.Zero; } else { _SharingGroups.Add(ContextSharingGroup, new List <IntPtr>()); } } if (Gl.PlatformExtensions.CreateContext_ARB) { List <int> attributes = new List <int>(); uint contextProfile = 0, contextFlags = 0; bool debuggerAttached = Debugger.IsAttached; #region WGL_ARB_create_context|GLX_ARB_create_context // The default values for WGL_CONTEXT_MAJOR_VERSION_ARB and WGL_CONTEXT_MINOR_VERSION_ARB are 1 and 0 respectively. In this // case, implementations will typically return the most recent version of OpenGL they support which is backwards compatible with OpenGL 1.0 // (e.g. 3.0, 3.1 + GL_ARB_compatibility, or 3.2 compatibility profile) [from WGL_ARB_create_context spec] Debug.Assert(Wgl.CONTEXT_MAJOR_VERSION_ARB == Glx.CONTEXT_MAJOR_VERSION_ARB); Debug.Assert(Wgl.CONTEXT_MINOR_VERSION_ARB == Glx.CONTEXT_MINOR_VERSION_ARB); if (ContextVersion != null) { attributes.AddRange(new int[] { Wgl.CONTEXT_MAJOR_VERSION_ARB, ContextVersion.Major, Wgl.CONTEXT_MINOR_VERSION_ARB, ContextVersion.Minor }); } else { // Note: this shouldn't be necessary since defaults are defined. However, on certains drivers this arguments are // required for specifying CONTEXT_FLAGS_ARB and CONTEXT_PROFILE_MASK_ARB attributes: // - Required by NVIDIA 266.72 on GeForce GT 540M on Windows 7 x64 attributes.AddRange(new int[] { Wgl.CONTEXT_MAJOR_VERSION_ARB, 1, Wgl.CONTEXT_MINOR_VERSION_ARB, 0 }); } if (_DebugContextBit == AttributePermission.Enabled || debuggerAttached && _DebugContextBit == AttributePermission.EnabledInDebugger) { Debug.Assert(Wgl.CONTEXT_DEBUG_BIT_ARB == Glx.CONTEXT_DEBUG_BIT_ARB); contextFlags |= Wgl.CONTEXT_DEBUG_BIT_ARB; } if (_ForwardCompatibleContextBit == AttributePermission.Enabled || debuggerAttached && _ForwardCompatibleContextBit == AttributePermission.EnabledInDebugger) { Debug.Assert(Wgl.CONTEXT_FORWARD_COMPATIBLE_BIT_ARB == Glx.CONTEXT_FORWARD_COMPATIBLE_BIT_ARB); contextFlags |= Wgl.CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; } #endregion #region WGL_ARB_create_context_profile|GLX_ARB_create_context_profile if (Gl.PlatformExtensions.CreateContextProfile_ARB) { switch (_ProfileType) { case ProfileType.Core: Debug.Assert(Wgl.CONTEXT_CORE_PROFILE_BIT_ARB == Glx.CONTEXT_CORE_PROFILE_BIT_ARB); contextProfile |= Wgl.CONTEXT_CORE_PROFILE_BIT_ARB; break; case ProfileType.Compatibility: Debug.Assert(Wgl.CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB == Glx.CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB); contextProfile |= Wgl.CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; break; } } #endregion #region WGL_ARB_create_context_robustness|GLX_ARB_create_context_robustness if (Gl.PlatformExtensions.CreateContextRobustness_ARB) { if (_RobustContextBit == AttributePermission.Enabled || debuggerAttached && _RobustContextBit == AttributePermission.EnabledInDebugger) { Debug.Assert(Wgl.CONTEXT_ROBUST_ACCESS_BIT_ARB == Glx.CONTEXT_ROBUST_ACCESS_BIT_ARB); contextFlags |= Wgl.CONTEXT_ROBUST_ACCESS_BIT_ARB; } } #endregion Debug.Assert(Wgl.CONTEXT_FLAGS_ARB == Glx.CONTEXT_FLAGS_ARB); if (contextFlags != 0) { attributes.AddRange(new int[] { Wgl.CONTEXT_FLAGS_ARB, unchecked ((int)contextFlags) }); } Debug.Assert(Wgl.CONTEXT_PROFILE_MASK_ARB == Glx.CONTEXT_PROFILE_MASK_ARB); Debug.Assert(contextProfile == 0 || Gl.PlatformExtensions.CreateContextProfile_ARB); if (contextProfile != 0) { attributes.AddRange(new int[] { Wgl.CONTEXT_PROFILE_MASK_ARB, unchecked ((int)contextProfile) }); } attributes.Add(0); if ((GLContext = DeviceContext.CreateContextAttrib(sharingContext, attributes.ToArray())) == IntPtr.Zero) { throw new InvalidOperationException($"unable to create render context ({Gl.GetError()})"); } } else { // Create OpenGL context using compatibility profile if ((GLContext = DeviceContext.CreateContext(sharingContext)) == IntPtr.Zero) { throw new InvalidOperationException("unable to create render context"); } } // Allow other GlControl instances to reuse this GlControl context if (shareResources) { if (_SharingWindows.ContainsKey(ContextSharingGroup)) { throw new InvalidOperationException($"another GlControl has created sharing group {ContextSharingGroup}"); } _SharingWindows.Add(ContextSharingGroup, this); } // Allow other GlControl instances to share resources with this context if (shareResources) { List <IntPtr> sharingContextes; // Get the list previously created _SharingGroups.TryGetValue(ContextSharingGroup, out sharingContextes); // ...and register this context among the others sharingContextes.Add(GLContext); } }
/// <summary> /// Create the GlWidget context. /// </summary> private void CreateContext() { if (_GraphicsContext != IntPtr.Zero) { throw new InvalidOperationException("context already created"); } IntPtr sharingContext = IntPtr.Zero; if (Gl.PlatformExtensions.CreateContext_ARB) { List <int> attributes = new List <int>(); uint contextProfile = 0, contextFlags = 0; bool debuggerAttached = Debugger.IsAttached; #region WGL_ARB_create_context|GLX_ARB_create_context #endregion #region WGL_ARB_create_context_profile|GLX_ARB_create_context_profile if (Gl.PlatformExtensions.CreateContextProfile_ARB) { } #endregion #region WGL_ARB_create_context_robustness|GLX_ARB_create_context_robustness if (Gl.PlatformExtensions.CreateContextRobustness_ARB) { } #endregion Debug.Assert(Wgl.CONTEXT_FLAGS_ARB == Glx.CONTEXT_FLAGS_ARB); if (contextFlags != 0) { attributes.AddRange(new int[] { Wgl.CONTEXT_FLAGS_ARB, unchecked ((int)contextFlags) }); } Debug.Assert(Wgl.CONTEXT_PROFILE_MASK_ARB == Glx.CONTEXT_PROFILE_MASK_ARB); Debug.Assert(contextProfile == 0 || Gl.PlatformExtensions.CreateContextProfile_ARB); if (contextProfile != 0) { attributes.AddRange(new int[] { Wgl.CONTEXT_PROFILE_MASK_ARB, unchecked ((int)contextProfile) }); } attributes.Add(0); if ((_GraphicsContext = _DeviceContext.CreateContextAttrib(sharingContext, attributes.ToArray())) == IntPtr.Zero) { throw new InvalidOperationException(String.Format("unable to create render context ({0})", Gl.GetError())); } } else { // Create OpenGL context using compatibility profile if ((_GraphicsContext = _DeviceContext.CreateContext(sharingContext)) == IntPtr.Zero) { throw new InvalidOperationException("unable to create render context"); } } }