public void TestReferenceCount() { // By default, runs without EGL Egl.IsRequired = false; using (DeviceContext deviceContext = DeviceContext.Create()) { Assert.AreEqual(0, deviceContext.RefCount); Assert.IsFalse(deviceContext.IsDisposed); deviceContext.IncRef(); Assert.AreEqual(1, deviceContext.RefCount); Assert.IsFalse(deviceContext.IsDisposed); deviceContext.IncRef(); Assert.AreEqual(2, deviceContext.RefCount); Assert.IsFalse(deviceContext.IsDisposed); deviceContext.DecRef(); Assert.AreEqual(1, deviceContext.RefCount); Assert.IsFalse(deviceContext.IsDisposed); deviceContext.DecRef(); Assert.AreEqual(0, deviceContext.RefCount); Assert.IsTrue(deviceContext.IsDisposed); } }
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); } } }
static void Main(string[] args) { Gl.Initialize(); try { // Gl.CurrentExtensions.FramebufferObject_ARB = false; // Test P-Buffer // Egl.IsRequired = Egl.IsAvailable; // Test EGL (not yet working) if (Gl.CurrentExtensions.FramebufferObject_ARB) { using (DeviceContext deviceContext = DeviceContext.Create()) { RenderOsdFramebuffer(deviceContext); } } else { // Fallback to old-school pbuffer using (INativePBuffer nativeBuffer = DeviceContext.CreatePBuffer(new DevicePixelFormat(24), 800, 600)) { using (DeviceContext deviceContext = DeviceContext.Create(nativeBuffer)) { RenderOsdPBuffer(deviceContext); } } } } catch (Exception exception) { Console.WriteLine("Unexpected exception: {0}", exception.ToString()); } }
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); } }
static void Main() { string envDebug = Environment.GetEnvironmentVariable("DEBUG"); if (envDebug == "GL") { KhronosApi.RegisterApplicationLogDelegate(delegate (string format, object[] args) { Console.WriteLine(format, args); }); } try { // Gl.CurrentExtensions.FramebufferObject_ARB = false; // Test P-Buffer // Egl.IsRequired = Egl.IsAvailable; // Test EGL (not yet working) if (Gl.CurrentExtensions.FramebufferObject_ARB) { using (DeviceContext deviceContext = DeviceContext.Create()) { RenderOsdFramebuffer(deviceContext); } } else { // Fallback to old-school pbuffer using (INativePBuffer nativeBuffer = DeviceContext.CreatePBuffer(new DevicePixelFormat(24), 800, 600)) { using (DeviceContext deviceContext = DeviceContext.Create(nativeBuffer)) { RenderOsdPBuffer(deviceContext); } } } } catch (Exception exception) { Console.WriteLine("Unexpected exception: {0}", exception.ToString()); } }
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 void DeviceContext_Create1_Core() { DeviceContext deviceContext = null; // "Windowless" DeviceContext creation should be possible on every platform Assert.DoesNotThrow(() => deviceContext = DeviceContext.Create()); Assert.IsNotNull(deviceContext); // Release resources deviceContext.Dispose(); }
public void TestConstructor() { using (DeviceContext deviceContext = DeviceContext.Create()) { GraphicsContext graphicsContext; using (graphicsContext = new GraphicsContext(deviceContext)) { TestConstructProperties(graphicsContext); } TestDisposedProperties(graphicsContext); } }
private void TestAvailableAPIs_Core() { using (DeviceContext deviceContext = DeviceContext.Create()) { if (deviceContext.IsPixelFormatSet == false) { deviceContext.ChoosePixelFormat(new DevicePixelFormat(24)); } Assert.IsNotNull(deviceContext.AvailableAPIs); CollectionAssert.IsNotEmpty(deviceContext.AvailableAPIs); } }
public Device(DevicePixelFormat pixelFormat) { if (DeviceContext.IsPBufferSupported) { _NativePBuffer = DeviceContext.CreatePBuffer(pixelFormat, 64, 64); Context = DeviceContext.Create(_NativePBuffer); } else { Assert.Inconclusive("no UI backend available"); } }
public void TryCreateContext() { int major = 2; int minor = 1; Gl.Initialize(); var deviceContext = DeviceContext.Create(); GlContext glContext = GlContext.TryCreate(deviceContext, major, minor, SharpRetro.LibRetro.retro_hw_context_type.RETRO_HW_CONTEXT_OPENGL, false); Assert.NotNull(glContext); glContext.Dispose(); }
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()); } }
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); }
protected override void OnRealized() { // Base implementation base.OnRealized(); IntPtr winHandle = GetWindowHandle(); if (winHandle != IntPtr.Zero) { _DeviceContext = DeviceContext.Create(IntPtr.Zero, GetWindowHandle()); _DeviceContext.ChoosePixelFormat(new DevicePixelFormat(24)); _GraphicsContext = _DeviceContext.CreateContext(IntPtr.Zero); } }
private void TestCreateContext_DefaultAPI_Core(string api) { using (DeviceContext deviceContext = DeviceContext.Create()) { 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); } } } }
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 void DeviceContext_Create3_Core() { if (DeviceContext.IsPBufferSupported == false) { Assert.Inconclusive("platform don't support P-Buffers"); } DeviceContext deviceContext = null; using (INativePBuffer nativePBuffer = DeviceContext.CreatePBuffer(new DevicePixelFormat(24), 64, 64)) { Assert.DoesNotThrow(() => deviceContext = DeviceContext.Create(nativePBuffer)); Assert.IsNotNull(nativePBuffer); // Release resources deviceContext.Dispose(); } }
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); }); }
public bool SetHWRender(ref retro_hw_render_callback hwRenderCallback) { if (_deviceContext != null) { return(false); } _deviceContext = DeviceContext.Create(); // Try and create an openGl context using the attributes specified in the callback _glContext = GlContext.TryCreate(_deviceContext, (int)hwRenderCallback.version_major, (int)hwRenderCallback.version_minor, (retro_hw_context_type)hwRenderCallback.context_type, hwRenderCallback.debug_context); // Creation might fail if the system doesn't // support the requested attributes if (_glContext == null) { return(false); } // ToDo: Some cores seem to need a separate shared context // but can't get it to work yet... if (_haveSharedContext) { _sharedGlContext = _glContext.CreateSharedContext(); } // Render context that the libretro core will render to, contains a texture buffer and an optional depth/stencil buffer. _libretroContext = new LibretroRenderContext(hwRenderCallback.depth, hwRenderCallback.stencil, hwRenderCallback.bottom_left_origin); // Get the libretro core callbacks _contextResetDlgt = hwRenderCallback.context_reset != IntPtr.Zero ? Marshal.GetDelegateForFunctionPointer <retro_hw_context_reset_t>(hwRenderCallback.context_reset) : null; _contextDestroyDlgt = hwRenderCallback.context_destroy != IntPtr.Zero ? Marshal.GetDelegateForFunctionPointer <retro_hw_context_reset_t>(hwRenderCallback.context_destroy) : null; // Pass the opengl callbacks back to the core hwRenderCallback.get_proc_address = Marshal.GetFunctionPointerForDelegate(_getProcAddressDelegate); hwRenderCallback.get_current_framebuffer = Marshal.GetFunctionPointerForDelegate(_getCurrentFramebufferDlgt); return(true); }
public void FixtureSetUp() { try { // Support ES tests Egl.IsRequired = IsEsTest; // Create device context _DeviceContext = DeviceContext.Create(); List <DevicePixelFormat> pixelFormats = _DeviceContext.PixelsFormats.Choose(new DevicePixelFormat(24)); if (pixelFormats.Count == 0) { throw new NotSupportedException("unable to find suitable pixel format"); } } catch { // Release resources manually FixtureTearDown(); throw; } }
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> /// Create the device context and set the pixel format. /// </summary> private void CreateDeviceContext(IntPtr displayHandle, IntPtr windowHandle, DevicePixelFormat controlReqFormat) { #region Support ES/SC API switch (_ProfileType) { case ProfileType.Embedded: DeviceContext.DefaultAPI = KhronosVersion.ApiGles2; break; case ProfileType.SecurityCritical2: DeviceContext.DefaultAPI = KhronosVersion.ApiGlsc2; break; } #endregion #region Create device context DeviceContext = DeviceContext.Create(displayHandle, windowHandle); DeviceContext.IncRef(); #endregion #region Set pixel format DevicePixelFormatCollection pixelFormats = DeviceContext.PixelsFormats; List <DevicePixelFormat> matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if (matchingPixelFormats.Count == 0 && controlReqFormat.MultisampleBits > 0) { // Try to select the maximum multisample configuration int multisampleBits = 0; pixelFormats.ForEach(delegate(DevicePixelFormat item) { multisampleBits = Math.Max(multisampleBits, item.MultisampleBits); }); controlReqFormat.MultisampleBits = multisampleBits; matchingPixelFormats = pixelFormats.Choose(controlReqFormat); } if (matchingPixelFormats.Count == 0 && controlReqFormat.DoubleBuffer) { // Try single buffered pixel formats controlReqFormat.DoubleBuffer = false; matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException( $"unable to find a suitable pixel format: {pixelFormats.GuessChooseError(controlReqFormat)}"); } } else if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException( $"unable to find a suitable pixel format: {pixelFormats.GuessChooseError(controlReqFormat)}"); } DeviceContext.SetPixelFormat(matchingPixelFormats[0]); #endregion #region Set V-Sync if (Gl.PlatformExtensions.SwapControl) { int swapInterval = SwapInterval; // Mask value in case it is not supported if (!Gl.PlatformExtensions.SwapControlTear && swapInterval == -1) { swapInterval = 1; } DeviceContext.SwapInterval(swapInterval); } #endregion }
/// <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 device context and set the pixel format. /// </summary> private void CreateDeviceContext(DevicePixelFormat controlReqFormat) { #region Create device context _DeviceContext = DeviceContext.Create(GetDisplay(), GetWindowHandle()); _DeviceContext.IncRef(); #endregion #region Set pixel format DevicePixelFormatCollection pixelFormats = _DeviceContext.PixelsFormats; List <DevicePixelFormat> matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if ((matchingPixelFormats.Count == 0) && controlReqFormat.MultisampleBits > 0) { // Try to select the maximum multisample configuration int multisampleBits = 0; pixelFormats.ForEach(delegate(DevicePixelFormat item) { multisampleBits = Math.Max(multisampleBits, item.MultisampleBits); }); controlReqFormat.MultisampleBits = multisampleBits; matchingPixelFormats = pixelFormats.Choose(controlReqFormat); } if ((matchingPixelFormats.Count == 0) && controlReqFormat.DoubleBuffer) { // Try single buffered pixel formats controlReqFormat.DoubleBuffer = false; matchingPixelFormats = pixelFormats.Choose(controlReqFormat); if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException(String.Format("unable to find a suitable pixel format: {0}", pixelFormats.GuessChooseError(controlReqFormat))); } } else if (matchingPixelFormats.Count == 0) { throw new InvalidOperationException(String.Format("unable to find a suitable pixel format: {0}", pixelFormats.GuessChooseError(controlReqFormat))); } _DeviceContext.SetPixelFormat(matchingPixelFormats[0]); #endregion #region Set V-Sync if (Gl.PlatformExtensions.SwapControl) { int swapInterval = SwapInterval; // Mask value in case it is not supported if (!Gl.PlatformExtensions.SwapControlTear && swapInterval == -1) { swapInterval = 1; } _DeviceContext.SwapInterval(swapInterval); } #endregion }
public OpenGLDevice(Win32Window window) { DeviceContext.DefaultAPI = Khronos.KhronosVersion.ApiGl; InitializeCache(); this.deviceContext = DeviceContext.Create(IntPtr.Zero, window.handle); this.deviceContext.IncRef(); Debug.LogFormat("OpenGL API: {0}", this.deviceContext.CurrentAPI); List <DevicePixelFormat> pixelFormats = this.deviceContext.PixelsFormats.Choose( new DevicePixelFormat { RgbaUnsigned = true, RenderWindow = true, ColorBits = 32, DepthBits = 24, StencilBits = 8, MultisampleBits = 0, DoubleBuffer = false, } ); this.deviceContext.SetPixelFormat(pixelFormats[0]); if (Gl.PlatformExtensions.SwapControl) { int swapInterval = 1; // Mask value in case it is not supported if (!Gl.PlatformExtensions.SwapControlTear && swapInterval == -1) { swapInterval = 1; } this.deviceContext.SwapInterval(swapInterval); } if (this.glContext != IntPtr.Zero) { throw new InvalidOperationException("context already created"); } if ((this.glContext = this.deviceContext.CreateContext(IntPtr.Zero)) == IntPtr.Zero) { throw new InvalidOperationException("unable to create render context"); } this.MakeCurrent(); Gl.ClearColor(0.192157f, 0.301961f, 0.474510f, 1.0f); Gl.DepthFunc(DepthFunction.Lequal); Gl.Light(LightName.Light0, LightParameter.Position, new float[] { 1.0f, 1.0f, 1.0f, 0.0f }); Gl.Enable(EnableCap.Light0); Gl.Enable(EnableCap.Texture2d); Gl.Enable(EnableCap.TextureCoordArray); Gl.ShadeModel(ShadingModel.Smooth); Gl.Hint(HintTarget.PerspectiveCorrectionHint, HintMode.Nicest); }
public void FixtureSetUp() { _DeviceContext = DeviceContext.Create(); _Context = new GraphicsContext(_DeviceContext); }