public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (mode == null) throw new ArgumentNullException("mode"); if (window == null) throw new ArgumentNullException("window"); EglContext eglContext = (EglContext) sharedContext; int major1; int minor1; if (!Egl.Initialize(window.Display, out major1, out minor1)) throw new GraphicsContextException(string.Format("Failed to initialize EGL, error {0}.", (object) Egl.GetError())); this.WindowInfo = window; this.Mode = new EglGraphicsMode().SelectGraphicsMode(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo, major > 1 ? RenderableFlags.ES2 : RenderableFlags.ES); if (!this.Mode.Index.HasValue) throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); IntPtr config = this.Mode.Index.Value; if (window.Surface == IntPtr.Zero) window.CreateWindowSurface(config); int[] attrib_list = new int[3] { 12440, major, 12344 }; this.HandleAsEGLContext = Egl.CreateContext(window.Display, config, eglContext != null ? eglContext.HandleAsEGLContext : IntPtr.Zero, attrib_list); this.MakeCurrent((IWindowInfo) window); }
public SampleBrowser(Context context, IGraphicsContext graphicsContext, IWindowInfo windowInfo) { // TODO: Complete member initialization this.androidContext = context; this.GLGraphicsContext = graphicsContext; this.GlWindowInfo = windowInfo; }
public RotateWidgetRenderableAsset(IGraphicsContext context) { _texture = context.LoadTexture2D("RotationWidget"); _boundingBox = new AxisAlignedBoundingBox2D(0, 0, _texture.Height, _texture.Width); RenderingOffset = - _boundingBox.Center; Origin = _boundingBox.Center; }
public AglContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext) { Debug.Print("Context Type: {0}", shareContext); Debug.Print("Window info: {0}", window); this.graphics_mode = mode; this.carbonWindow = (CarbonWindowInfo)window; if (shareContext is AglContext) shareContextRef = ((AglContext)shareContext).Handle.Handle; if (shareContext is GraphicsContext) { ContextHandle shareHandle = shareContext != null ? (shareContext as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero; shareContextRef = shareHandle.Handle; } if (shareContextRef == IntPtr.Zero) { Debug.Print("No context sharing will take place."); } CreateContext(mode, carbonWindow, shareContextRef, true); }
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { X11WindowInfo x11_win = (X11WindowInfo)window; //EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(x11_win.WindowHandle, Egl.GetDisplay(x11_win.Display)); EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(x11_win.WindowHandle, Egl.GetDisplay(new IntPtr(0))); return new EglContext(handle, egl_win, shareContext, major, minor, flags); }
/// <summary> /// 現在のコンテキストが持つテクスチャをすべて削除します。 /// </summary> /// <remarks> /// OpenGLの終了時に呼ばれます。 /// </remarks> public static void DeleteAll(IGraphicsContext context) { //var context = context; lock (textureListSync) { for (int index = 0; index < textureList.Count; ) { var texture = textureList[index].Target as Texture; if (texture == null) { // 要素を削除したため、indexの更新は行いません。 textureList.RemoveAt(index); continue; } if (texture.Context == context) { // テクスチャを削除 texture.Destroy(); // 要素を削除したため、indexの更新は行いません。 textureList.RemoveAt(index); continue; } index += 1; } } }
bool vsync = true; // Default vsync value is defined as 1 (true) in EGL. #endregion #region Constructors public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (mode == null) throw new ArgumentNullException("mode"); if (window == null) throw new ArgumentNullException("window"); EglContext shared = (EglContext)sharedContext; int dummy_major, dummy_minor; if (!Egl.Initialize(window.Display, out dummy_major, out dummy_minor)) throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError())); WindowInfo = window; Mode = new EglGraphicsMode().SelectGraphicsMode(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo); if (!Mode.Index.HasValue) throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); IntPtr config = Mode.Index.Value; if (window.Surface == IntPtr.Zero) window.CreateWindowSurface(config); int[] attrib_list = new int[] { Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE }; HandleAsEGLContext = Egl.CreateContext(window.Display, config, shared != null ? shared.HandleAsEGLContext : IntPtr.Zero, attrib_list); MakeCurrent(window); }
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { WinWindowInfo win_win = (WinWindowInfo)window; IntPtr egl_display = GetDisplay(win_win.DeviceContext); EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(win_win.WindowHandle, egl_display); return new EglContext(handle, egl_win, shareContext, major, minor, flags); }
public override OpenTK.Graphics.IGraphicsContext CreateGLContext( GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { flags |= GraphicsContextFlags.Embedded; return base.CreateGLContext(mode, window, shareContext, directRendering, major, minor, flags); }
internal iPhoneOSGraphicsContext(ContextHandle handle, IWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { // ignore mode, window iPhoneOSGraphicsContext shared = sharedContext as iPhoneOSGraphicsContext; EAGLRenderingAPI version = 0; if (major == 1 && minor == 1) version = EAGLRenderingAPI.OpenGLES1; else if (major == 2 && minor == 0) version = EAGLRenderingAPI.OpenGLES2; else if (major == 3 && minor == 0) version = EAGLRenderingAPI.OpenGLES3; else throw new ArgumentException (string.Format("Unsupported GLES version {0}.{1}.", major, minor)); if (handle.Handle == IntPtr.Zero) { EAGLContext = shared != null && shared.EAGLContext != null ? new EAGLContext(version, shared.EAGLContext.ShareGroup) : new EAGLContext(version); contextHandle = new ContextHandle(EAGLContext.Handle); } else { EAGLContext = (EAGLContext) Runtime.GetNSObject (handle.Handle); contextHandle = handle; } }
public SceneViewerControl() { Tabs = new ObservableCollection<SceneTabViewModel>(); RemoveTab = new RelayCommand((obj) => { Tabs.Remove(obj as SceneTabViewModel); //MessageBox.Show("New Folder!"); }); InitializeComponent(); AssignPanelEventHandling(xna); ScenesControl.ItemsSource = Tabs; if (DesignerProperties.GetIsInDesignMode(this)) return; _game = new MyGame(xna.Handle); _game.GameWorld.UpdateWorld = false; _context = _game.GraphicsContext; var gameWorldArg = new ConstructorArgument( ApplicationProperties.ISceneViewerGameWorldArgName, _game.GameWorld); _controller = DependencyInjectorHelper .MainWindowKernel .Get<ISceneViewerController>(gameWorldArg); _controller.Control = this; }
public void CreateContext(bool direct, IGraphicsContext source) { if (!(this.Handle == ContextHandle.Zero)) return; ++DummyGLContext.handle_count; this.Handle = new ContextHandle((IntPtr) DummyGLContext.handle_count); }
public void Initialize() { // <Rant> // OpenTK has a great fuckup in its design here. It's absolutly nohm it possible to create // a render context for offscreen rendering without creating an OpenTK window. // before. // Passing Utilities.CreateDummyWindowInfo() or anything else will cause an invalid cast exception // Using Utilities.CreateWindowsWindowInfo(IntPtr.Zero) binds the code to windows only // Really great, why do i need to have a window in order to render to memory? -_- //</Rant> _window = new NativeWindow { Visible = false }; _context = new GraphicsContext(GraphicsMode.Default, _window.WindowInfo, 2, 0, GraphicsContextFlags.Default); _context.MakeCurrent(_window.WindowInfo); _context.LoadAll(); // create offscreen rendertarget with high precision _rtt = new RenderToTexture(1, 1, false, 4, typeof(float)); int precision; int range; GL.GetShaderPrecisionFormat(OpenTK.Graphics.OpenGL.ShaderType.FragmentShader, ShaderPrecisionType.HighFloat, out range, out precision); Debug.WriteLine("Precision: {0}, Range {1}", precision, range); // init SL# Bindings.OpenTK.SLSharp.Init(); }
public override IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { WinWindowInfo win_win = (WinWindowInfo)window; EGLDisplay egl_display = Egl.GetDisplay(EGLNativeDisplayType.Default); // Egl.GetDisplay(new EGLNativeDisplayType(win_win.DeviceContext)); EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(win_win.WindowHandle, egl_display); return new EglContext(mode, egl_win, shareContext, major, minor, flags); }
public static ShaderProgram CreateProgram(IGraphicsContext context, string vertexSource, string fragmentSource) { int vertID = context.CreateShader(ShaderType.VertexShader); int fragID = context.CreateShader(ShaderType.FragmentShader); context.ShaderSource(vertID, vertexSource); context.ShaderSource(fragID, fragmentSource); context.CompileShader(vertID); context.CompileShader(fragID); Debug.LogInfo(context.GetShaderInfoLog(vertID)); Debug.LogInfo(context.GetShaderInfoLog(fragID)); int programID = context.CreateProgram(); context.AttachShader(programID, vertID); context.AttachShader(programID, fragID); context.LinkProgram(programID); Debug.LogInfo(context.GetProgramInfoLog(programID)); return new ShaderProgram(context, vertID, fragID, programID); }
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { WinWindowInfo winWindowInfo = (WinWindowInfo) window; IntPtr display = this.GetDisplay(winWindowInfo.DeviceContext); EglWindowInfo window1 = new EglWindowInfo(winWindowInfo.WindowHandle, display); return (IGraphicsContext) new EglContext(handle, window1, shareContext, major, minor, flags); }
public GraphicsObject() { context = GraphicsContext.CurrentContext; if (context == null) throw new InvalidOperationException("No OpenGL context found " + "for thread " + Thread.CurrentThread.ManagedThreadId); }
public AglContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, GetInt xoffset, GetInt yoffset) { Debug.Print("Share context: {0}", shareContext); Debug.Print("Window info: {0}", window); IntPtr shareContextRef = IntPtr.Zero; XOffset = xoffset; YOffset = yoffset; carbonWindow = window; if (shareContext is AglContext) { shareContextRef = ((AglContext)shareContext).Handle.Handle; } else if (shareContext is GraphicsContext) { ContextHandle shareHandle = shareContext != null ? (shareContext as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero; shareContextRef = shareHandle.Handle; } if (shareContextRef == IntPtr.Zero) { Debug.Print("No context sharing will take place."); } CreateContext(mode, carbonWindow, shareContextRef, true); }
int swap_interval = 1; // Default interval is defined as 1 in EGL. #endregion #region Constructors public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (mode == null) throw new ArgumentNullException("mode"); if (window == null) throw new ArgumentNullException("window"); EglContext shared = (EglContext)sharedContext; int dummy_major, dummy_minor; if (!Egl.Initialize(window.Display, out dummy_major, out dummy_minor)) throw new GraphicsContextException(String.Format("Failed to initialize EGL, error {0}.", Egl.GetError())); WindowInfo = window; // Select an EGLConfig that matches the desired mode. We cannot use the 'mode' // parameter directly, since it may have originated on a different system (e.g. GLX) // and it may not support the desired renderer. Mode = new EglGraphicsMode().SelectGraphicsMode(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo, major > 1 ? RenderableFlags.ES2 : RenderableFlags.ES); if (!Mode.Index.HasValue) throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); IntPtr config = Mode.Index.Value; if (window.Surface == IntPtr.Zero) window.CreateWindowSurface(config); int[] attrib_list = new int[] { Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE }; HandleAsEGLContext = Egl.CreateContext(window.Display, config, shared != null ? shared.HandleAsEGLContext : IntPtr.Zero, attrib_list); MakeCurrent(window); }
public GameWorld(IGraphicsContext graphicsContext) { _scenes = new List<Scene>(); _activeSceneIndex = NO_ACTIVE_SCENE; _graphicsContext = graphicsContext; UpdateWorld = true; }
public VertexBuffer(IGraphicsContext context, BufferUsageHint hint) { this.GraphicsContext = context; this.hint = hint; this.GraphicsContext.GenBuffers(1, out Handle); }
public override void QueueRenderCommands(GameTime gameTime, Renderer renderer, IGraphicsContext context) { List<TerrainNode> nodesToRender = new List<TerrainNode>(); renderer.EnqueueLight(dlight); // todo: maybe can parallelize for (int i = 0; i < rootNodes.Length; i++) { if (rootNodes[i] != null) { List<TerrainNode> nodesFromThisCubeFace = new List<TerrainNode>(); findNodesToRender(nodesFromThisCubeFace, rootNodes[i], context.CurrentCamera); nodesToRender.AddRange(nodesFromThisCubeFace); } } int nodeCount = nodesToRender.Count; NodeCount = nodeCount; if (nodeCount > 0) { TerrainVertex[] vertices = nodesToRender.SelectMany(node => node.Geometry).ToArray(); var command = GenerateRenderCommand(); (command as RenderDeferredCommand<TerrainVertex>).NumVertices = vertices.Length; vertexBuffer.SetData(vertices); renderer.EnqueueDeferred(command as IRenderDeferredCommand); } }
public FreeMovementRenderableAsset(IGraphicsContext context) { _texture = context.LoadTexture2D("freeMovementWidget"); _boundingBox = new AxisAlignedBoundingBox2D(0, 0, _texture.Height, _texture.Width); RenderingOffset = -AABoundingBox.Center; Origin = AABoundingBox.Center; }
protected RenderManager(IGraphicsContext graphics) { _graphics = graphics; // todo: subscribe to changes to asset libraries and build a dirty list for each library which will be processed on the next call to UpdateAssets. also observe changes to group dormancy. // 1. if a mesh has been removed, check the asset group and if it's empty, destroy the buffer. ignore removed meshes; we'll leave them in place for performance reasons. // 2. if a mesh has been added or updated, rebuild the buffer for now. later we may be able to optimise to do in-place buffer updates if it's an issue, but it probably won't be. }
public override void Draw(IGraphicsContext gc) { int depth = CountParentDepth (); Color color = _Colors [depth]; // CountParentDepth is expensive - so don't call ComponentColor here... Color contactColor = color; if (IsNotEmptyString (TypeName) == false) { color = Color.Crimson; } if (IsNotEmptyString (Name) == false) { color = Color.Red; } gc.Color = color; DrawComponent (gc, _Bounds.Left, _Bounds.Top, _Bounds.Width, _Bounds.Height, 20, 2+depth, color); gc.Color = contactColor; gc.Thickness = 2 + depth; if (Selected) { foreach (IGlyph contact in ContactPoints) { contact.Draw (gc); } } }
// Necessary to allow creation of dummy GraphicsContexts (see CreateDummyContext static method). GraphicsContext(ContextHandle handle) { implementation = new OpenTK.Platform.Dummy.DummyGLContext(handle); lock (SyncRoot) { available_contexts.Add((implementation as IGraphicsContextInternal).Context, new WeakReference(this)); } }
public EglContext(ContextHandle handle, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (handle == ContextHandle.Zero) throw new ArgumentException("handle"); if (window == null) throw new ArgumentNullException("window"); this.Handle = handle; }
public void CreateContext(bool direct, IGraphicsContext source) { if (Handle == ContextHandle.Zero) { ++handle_count; Handle = new ContextHandle((IntPtr)handle_count); } }
public AndroidGraphicsContext (GraphicsMode mode, IWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (major < 1 || major > 3) throw new ArgumentException (string.Format("Unsupported GLES version {0}.{1}.", major, minor)); Init (mode, window, sharedContext, major, minor, flags); }
public override void Draw(IGraphicsContext GC) { base.Draw (GC); string s = _PortName; using (Brush brush = new System.Drawing.SolidBrush (Color.Black)) { GC.DrawString (s, brush, 10, new Point (Bounds.Right + 10, Bounds.Top), false); } }
public void Render(GameTime gameTime, IGraphicsContext context) { var device = context.Device; var renderContext = context.RenderContext; // clear render queues normalQueue.Clear(); deferredQueue.Clear(); postProcessQueue.Clear(); lightQueue.Clear(); // HACK: update current camera... camera probably needs to be a GameObject context.CurrentCamera.Update(gameTime); // Depth First Traversal of Scene Graph to queue render commands Engine.SceneGraph.QueueRenderCommands(gameTime, this, context); PrepareForNewFrame(device); // render deferred queue to gbuffer 1st gbuffer.SetAsRenderTarget(); gbuffer.Clear(); while (deferredQueue.Count > 0) { var command = deferredQueue.Dequeue(); ProcessRenderCommand(command, context); } // switch to scene target device.Clear(sceneTarget, Color.Black); device.SetRenderTargets(sceneTarget); // render all the lights to shade deferred objects while (lightQueue.Count > 0) { var light = lightQueue.Dequeue(); gbuffer.RenderDirectionalLight(light); } // render normal queue to scene target // note that we're carrying over depth info from the deferred queue // since we haven't changed depth buffers while (normalQueue.Count > 0) { var command = normalQueue.Dequeue(); ProcessRenderCommand(command, context); } // apply post processes that need to run on the MSAA render target // before it is resolved into the backbuffer while (postProcessQueue.Count > 0) { var command = postProcessQueue.Dequeue(); ProcessRenderCommand(command, context); } // resolve MSAA scene target to back buffer device.Copy((GraphicsResource)sceneTarget, 0, (GraphicsResource)device.BackBuffer, 0, SharpDX.DXGI.Format.R8G8B8A8_UNorm); device.SetRenderTargets(device.BackBuffer); RenderDiagnostics(context); // Present device.Present(); // commit the changes to the image source if (context.ImageSourcePresenter != null) { var renderTarget = ((GraphicsDeviceService)context.GraphicsService).BackBuffer; context.ImageSourcePresenter.Commit(renderTarget); } }
/// <summary> /// Initializes the <see cref="GLWidget"/> with its given values and creates a <see cref="GraphicsContext"/>. /// </summary> private void Initialize() { _Initialized = true; // If this looks uninitialized... initialize. if (ColorBPP == 0) { ColorBPP = 32; if (DepthBPP == 0) { DepthBPP = 16; } } ColorFormat colorBufferColorFormat = new ColorFormat(ColorBPP); ColorFormat accumulationColorFormat = new ColorFormat(AccumulatorBPP); int buffers = 2; if (SingleBuffer) { buffers--; } GraphicsMode graphicsMode = new GraphicsMode(colorBufferColorFormat, DepthBPP, StencilBPP, Samples, accumulationColorFormat, buffers, Stereo); if (Configuration.RunningOnWindows) { Console.WriteLine("OpenTK running on windows"); } else if (Configuration.RunningOnMacOS) { Console.WriteLine("OpenTK running on OSX"); } else { Console.WriteLine("OpenTK running on X11"); } #if GTK3 IntPtr widgetWindowHandle = this.Window.Handle; #else IntPtr widgetWindowHandle = this.GdkWindow.Handle; #endif // IWindowInfo if (Configuration.RunningOnWindows) { _WindowInfo = WinWindowsInfoInitializer.Initialize(widgetWindowHandle); } else if (Configuration.RunningOnMacOS) { _WindowInfo = OSXWindowInfoInitializer.Initialize(widgetWindowHandle); } else { _WindowInfo = XWindowInfoInitializer.Initialize(graphicsMode, this.Display.Handle, this.Screen.Number, widgetWindowHandle, this.Screen.RootWindow.Handle); } // GraphicsContext _GraphicsContext = new GraphicsContext(graphicsMode, _WindowInfo, GlVersionMajor, GlVersionMinor, GraphicsContextFlags); _GraphicsContext.MakeCurrent(_WindowInfo); if (GraphicsContext.ShareContexts) { Interlocked.Increment(ref _GraphicsContextCount); if (!_SharedContextInitialized) { _SharedContextInitialized = true; ((IGraphicsContextInternal)_GraphicsContext).LoadAll(); OnGraphicsContextInitialized(); } } else { ((IGraphicsContextInternal)_GraphicsContext).LoadAll(); OnGraphicsContextInitialized(); } OnInitialized(); }
public MeshBufferManager(IGraphicsContext graphicsContext) { _vertexBufferManager = graphicsContext.VertexBufferManagerFactory.Create <T>(); _indexBufferManager = graphicsContext.IndexBufferManagerFactory.Create(); Disposed += OnDisposed; }
public X11GLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shared, bool direct, int major, int minor, GraphicsContextFlags flags) : base(DesktopBackend.OpenGL) { LongInit(mode, window, shared, direct, major, minor, flags); }
public void CreateWindow(int width, int height, GraphicsMode mode, int major, int minor, GraphicsContextFlags flags, out IGraphicsContext context) { Rect r = new Rect(0, 0, (short)width, (short)height); CreateNativeWindow(mWindowClass, mWindowAttrib, r); Show(); this.context = new GraphicsContext(mode, window, major, minor, flags); this.context.MakeCurrent(window); context = this.context; }
public X11GLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shared, bool direct, int major, int minor, GraphicsContextFlags flags) { if (mode == null) { throw new ArgumentNullException("mode"); } if (window == null) { throw new ArgumentNullException("window"); } // Do not move this lower, as almost everything requires the Display // property to be correctly set. Display = ((X11WindowInfo)window).Display; // Check that GLX is supported. We cannot proceed to create // an OpenGL context without the GLX extension. int error_base; int event_base; int glx_major; int glx_minor; using (new XLock(Display)) { bool supported = Glx.QueryExtension(Display, out error_base, out event_base); supported &= Glx.QueryVersion(Display, out glx_major, out glx_minor); if (supported) { Debug.Print("[X11] GLX supported. Version is {0}.{1}", glx_major, glx_minor); } else { throw new NotSupportedException("[X11] GLX extension is not supported."); } } IntPtr visual = IntPtr.Zero; IntPtr fbconfig = IntPtr.Zero; // Once a window has a visual, we cannot use a different // visual on the OpenGL context, or glXMakeCurrent might fail. // Note: we should only check X11WindowInfo.Visual, as that // is the only property that can be set by Utilities.CreateX11WindowInfo. currentWindow = (X11WindowInfo)window; if (currentWindow.Visual != IntPtr.Zero) { visual = currentWindow.Visual; fbconfig = currentWindow.FBConfig; Mode = currentWindow.GraphicsMode; } if (Mode == null || !Mode.Index.HasValue) { Mode = ModeSelector.SelectGraphicsMode(mode, out visual, out fbconfig); } ContextHandle shareHandle = shared != null ? (shared as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero; Debug.Write("Creating X11GLContext context: "); Debug.Write(direct ? "direct, " : "indirect, "); Debug.WriteLine(shareHandle.Handle == IntPtr.Zero ? "not shared... " : String.Format("shared with ({0})... ", shareHandle)); // Try using the new context creation method. If it fails, fall back to the old one. // For each of these methods, we try two times to create a context: // one with the "direct" flag intact, the other with the flag inversed. // HACK: It seems that Catalyst 9.1 - 9.4 on Linux have problems with contexts created through // GLX_ARB_create_context, including hideous input lag, no vsync and other madness. // Use legacy context creation if the user doesn't request a 3.0+ context. if (fbconfig != IntPtr.Zero && (major * 10 + minor >= 30) && SupportsCreateContextAttribs(Display, currentWindow)) { Handle = CreateContextAttribs(Display, currentWindow.Screen, fbconfig, direct, major, minor, flags, shareHandle); } if (Handle == ContextHandle.Zero) { Handle = CreateContextLegacy(Display, visual, direct, shareHandle); } if (Handle != ContextHandle.Zero) { Debug.Print("Context created (id: {0}).", Handle); } else { throw new GraphicsContextException("Failed to create OpenGL context. Glx.CreateContext call returned 0."); } using (new XLock(Display)) { if (!Glx.IsDirect(Display, Handle.Handle)) { Debug.Print("Warning: Context is not direct."); } } }
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { throw new PlatformNotSupportedException(error_string); }
public IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return(Default.CreateGLContext(handle, window, shareContext, directRendering, major, minor, flags)); }
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { X11WindowInfo x11WindowInfo = (X11WindowInfo)window; EglWindowInfo window1 = new EglWindowInfo(x11WindowInfo.WindowHandle, Egl.GetDisplay(x11WindowInfo.Display)); return((IGraphicsContext) new EglContext(handle, window1, shareContext, major, minor, flags)); }
public X11GLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shared, bool direct, int major, int minor, GraphicsContextFlags flags) { if (mode == null) { throw new ArgumentNullException("mode"); } if (window == null) { throw new ArgumentNullException("window"); } Mode = ModeSelector.SelectGraphicsMode( mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo); // Do not move this lower, as almost everything requires the Display // property to be correctly set. Display = ((X11WindowInfo)window).Display; currentWindow = (X11WindowInfo)window; currentWindow.VisualInfo = SelectVisual(Mode, currentWindow); ContextHandle shareHandle = shared != null ? (shared as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero; Debug.Write("Creating X11GLContext context: "); Debug.Write(direct ? "direct, " : "indirect, "); Debug.WriteLine(shareHandle.Handle == IntPtr.Zero ? "not shared... " : String.Format("shared with ({0})... ", shareHandle)); // Try using the new context creation method. If it fails, fall back to the old one. // For each of these methods, we try two times to create a context: // one with the "direct" flag intact, the other with the flag inversed. // HACK: It seems that Catalyst 9.1 - 9.4 on Linux have problems with contexts created through // GLX_ARB_create_context, including hideous input lag, no vsync and other madness. // Use legacy context creation if the user doesn't request a 3.0+ context. if ((major * 10 + minor >= 30) && SupportsCreateContextAttribs(Display, currentWindow)) { Debug.Write("Using GLX_ARB_create_context... "); unsafe { // We need the FB config for the current GraphicsMode. int count; IntPtr *fbconfigs = Glx.ChooseFBConfig(Display, currentWindow.Screen, new int[] { (int)GLXAttribute.VISUAL_ID, (int)Mode.Index, 0 }, out count); if (count > 0) { List <int> attributes = new List <int>(); attributes.Add((int)ArbCreateContext.MajorVersion); attributes.Add(major); attributes.Add((int)ArbCreateContext.MinorVersion); attributes.Add(minor); if (flags != 0) { attributes.Add((int)ArbCreateContext.Flags); attributes.Add((int)GetARBContextFlags(flags)); attributes.Add((int)ArbCreateContext.ProfileMask); attributes.Add((int)GetARBProfileFlags(flags)); } // According to the docs, " <attribList> specifies a list of attributes for the context. // The list consists of a sequence of <name,value> pairs terminated by the // value 0. [...]" // Is this a single 0, or a <0, 0> pair? (Defensive coding: add two zeroes just in case). attributes.Add(0); attributes.Add(0); using (new XLock(Display)) { Handle = new ContextHandle(Glx.Arb.CreateContextAttribs(Display, *fbconfigs, shareHandle.Handle, direct, attributes.ToArray())); if (Handle == ContextHandle.Zero) { Debug.Write(String.Format("failed. Trying direct: {0}... ", !direct)); Handle = new ContextHandle(Glx.Arb.CreateContextAttribs(Display, *fbconfigs, shareHandle.Handle, !direct, attributes.ToArray())); } } if (Handle == ContextHandle.Zero) { Debug.WriteLine("failed."); } else { Debug.WriteLine("success!"); } using (new XLock(Display)) { Functions.XFree((IntPtr)fbconfigs); } } } } if (Handle == ContextHandle.Zero) { Debug.Write("Using legacy context creation... "); XVisualInfo info = currentWindow.VisualInfo; using (new XLock(Display)) { // Cannot pass a Property by reference. Handle = new ContextHandle(Glx.CreateContext(Display, ref info, shareHandle.Handle, direct)); if (Handle == ContextHandle.Zero) { Debug.WriteLine(String.Format("failed. Trying direct: {0}... ", !direct)); Handle = new ContextHandle(Glx.CreateContext(Display, ref info, IntPtr.Zero, !direct)); } } } if (Handle != ContextHandle.Zero) { Debug.Print("Context created (id: {0}).", Handle); } else { throw new GraphicsContextException("Failed to create OpenGL context. Glx.CreateContext call returned 0."); } using (new XLock(Display)) { if (!Glx.IsDirect(Display, Handle.Handle)) { Debug.Print("Warning: Context is not direct."); } } }
public EglWinContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) : base(mode, window, sharedContext, major, minor, flags | GraphicsContextFlags.Embedded | GraphicsContextFlags.Angle) { }
public void _Render(GameTime gameTime, IGraphicsContext context) { if (isFirst) { skybox = new Skybox(context.Device); isFirst = false; fpsClock.Start(); } var device = context.Device; device.SetRenderTargets(device.DepthStencilBuffer, device.BackBuffer); device.SetViewports(new ViewportF(0, 0, device.BackBuffer.Width, device.BackBuffer.Height)); device.Clear(device.DepthStencilBuffer, SharpDX.Direct3D11.DepthStencilClearFlags.Depth, 1, 0); device.Clear(device.BackBuffer, Color.Black); device.SetBlendState(device.BlendStates.Default); device.SetDepthStencilState(device.DepthStencilStates.None); device.SetRasterizerState(device.RasterizerStates.CullBack); //gbuffer.SetAsRenderTarget(); //gbuffer.Clear(); // update current camera context.CurrentCamera.Update(gameTime); device.SetDepthStencilState(device.DepthStencilStates.Default); // Render SceneGraph to GBuffer //Engine.SceneGraph.Render(gameTime, context); // switch to scene target //device.Clear(sceneTarget, Color.Black); //device.SetRenderTargets(sceneTarget); skybox.QueueRenderCommands(gameTime, this, context); Engine.SceneGraph.QueueRenderCommands(gameTime, this, context); //worldEngine.Skybox.Render(gameTime, context); // Render Custom Visualization Systems device.SetDepthStencilState(device.DepthStencilStates.None); device.SetBlendState(device.BlendStates.Default); // Render Lights //context.GBuffer.RenderDirectionalLight(new Graphics.DirectionalLight()); // Render atmosphere as post-process //worldEngine.Atmosphere.Render(gameTime, context); // copy scene target to back buffer //device.SetRenderTargets(device.BackBuffer); //texToTargetEffect.Parameters["CopyTexture"].SetResource(sceneTarget); //texToTargetEffect.Parameters["CopyTextureSamp"].SetResource(device.SamplerStates.LinearClamp); //device.DrawQuad(texToTargetEffect); frameCount++; if (fpsClock.ElapsedMilliseconds > 1000.0f) { fpsText = string.Format("{0:F2} FPS", (float)frameCount * 1000 / fpsClock.ElapsedMilliseconds); frameCount = 0; fpsClock.Restart(); } context.SpriteBatch.Begin(); context.SpriteBatch.DrawString(font, fpsText, Vector2.Zero, Color.White); context.SpriteBatch.DrawString(font, string.Format("camera X: {0}", context.CurrentCamera.Position.X), new Vector2(0, 15), Color.White); context.SpriteBatch.DrawString(font, string.Format("camera Y: {0}", context.CurrentCamera.Position.Y), new Vector2(0, 30), Color.White); context.SpriteBatch.DrawString(font, string.Format("camera Z: {0}", context.CurrentCamera.Position.Z), new Vector2(0, 45), Color.White); context.SpriteBatch.DrawString(font, string.Format("Camera Height: {0}", context.CurrentCamera.Position.Length()), new Vector2(0, 60), Color.White); context.SpriteBatch.End(); // Present device.Present(); // reset all state device.ClearState(); // commit the changes to the image source if (context.ImageSourcePresenter != null) { var renderTarget = ((GraphicsDeviceService)context.GraphicsService).BackBuffer; context.ImageSourcePresenter.Commit(renderTarget); } }
/// <summary>Constructs a new GameWindow with the specified attributes.</summary> /// <param name="width">The width of the GameWindow in pixels.</param> /// <param name="height">The height of the GameWindow in pixels.</param> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GameWindow.</param> /// <param name="title">The title of the GameWindow.</param> /// <param name="options">GameWindow options regarding window appearance and behavior.</param> /// <param name="device">The OpenTK.Graphics.DisplayDevice to construct the GameWindow in.</param> /// <param name="major">The major version for the OpenGL GraphicsContext.</param> /// <param name="minor">The minor version for the OpenGL GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags version for the OpenGL GraphicsContext.</param> /// <param name="sharedContext">An IGraphicsContext to share resources with.</param> public GameWindow(int width, int height, GraphicsMode mode, string title, GameWindowFlags options, DisplayDevice device, int major, int minor, GraphicsContextFlags flags, IGraphicsContext sharedContext) : this(width, height, mode, title, options, device, major, minor, flags, sharedContext, true) { }
internal void MakeContextCurrent(IGraphicsContext context, global::OpenTK.Platform.IWindowInfo windowInfo) { context.MakeCurrent(windowInfo); PurgeStateCache(); }
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return(new CocoaContext(handle, window, shareContext, major, minor)); }
public override void QueueRenderCommands(GameTime gameTime, Renderer renderer, IGraphicsContext context) { var command = GenerateRenderCommand(); if (command is IRenderDeferredCommand) { Engine.Renderer.EnqueueDeferred(command as IRenderDeferredCommand); } else { Engine.Renderer.EnqueueNormal(command); } }
void LongInit(GraphicsMode mode, IWindowInfo window, IGraphicsContext shared, bool direct, int major, int minor, GraphicsContextFlags flags) { //fixed PEVerify error //move long code from ctor to here if (mode == null) { throw new ArgumentNullException("mode"); } if (window == null) { throw new ArgumentNullException("window"); } Mode = mode; // Do not move this lower, as almost everything requires the Display // property to be correctly set. Display = ((X11WindowInfo)window).Display; currentWindow = (X11WindowInfo)window; currentWindow.VisualInfo = SelectVisual(mode, currentWindow); ContextHandle shareHandle = shared != null ? (shared as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero; Debug.Write("Creating X11GLContext context: "); Debug.Write(direct ? "direct, " : "indirect, "); Debug.WriteLine(shareHandle.Handle == IntPtr.Zero ? "not shared... " : String.Format("shared with ({0})... ", shareHandle)); if (!glx_loaded) { Debug.WriteLine("Creating temporary context to load GLX extensions."); // Create a temporary context to obtain the necessary function pointers. XVisualInfo visual = currentWindow.VisualInfo; IntPtr ctx = IntPtr.Zero; using (new XLock(Display)) { ctx = Glx.CreateContext(Display, ref visual, IntPtr.Zero, true); if (ctx == IntPtr.Zero) { ctx = Glx.CreateContext(Display, ref visual, IntPtr.Zero, false); } } if (ctx != IntPtr.Zero) { new Glx().LoadEntryPoints(); using (new XLock(Display)) { Glx.MakeCurrent(Display, IntPtr.Zero, IntPtr.Zero); //Glx.DestroyContext(Display, ctx); } glx_loaded = true; } } // Try using the new context creation method. If it fails, fall back to the old one. // For each of these methods, we try two times to create a context: // one with the "direct" flag intact, the other with the flag inversed. // HACK: It seems that Catalyst 9.1 - 9.4 on Linux have problems with contexts created through // GLX_ARB_create_context, including hideous input lag, no vsync and other. Use legacy context // creation if the user doesn't request a 3.0+ context. if ((major * 10 + minor >= 30) && Glx.Delegates.glXCreateContextAttribsARB != null) { Debug.Write("Using GLX_ARB_create_context... "); unsafe { // We need the FB config for the current GraphicsMode. int count; IntPtr *fbconfigs = Glx.ChooseFBConfig(Display, currentWindow.Screen, new int[] { (int)GLXAttribute.VISUAL_ID, (int)mode.Index, 0 }, out count); if (count > 0) { List <int> attributes = new List <int>(); attributes.Add((int)ArbCreateContext.MajorVersion); attributes.Add(major); attributes.Add((int)ArbCreateContext.MinorVersion); attributes.Add(minor); if (flags != 0) { #warning "This is not entirely correct: Embedded is not a valid flag! We need to add a GetARBContextFlags(GraphicsContextFlags) method." attributes.Add((int)ArbCreateContext.Flags); attributes.Add((int)flags); } // According to the docs, " <attribList> specifies a list of attributes for the context. // The list consists of a sequence of <name,value> pairs terminated by the // value 0. [...]" // Is this a single 0, or a <0, 0> pair? (Defensive coding: add two zeroes just in case). attributes.Add(0); attributes.Add(0); using (new XLock(Display)) { Handle = new ContextHandle(Glx.Arb.CreateContextAttribs(Display, *fbconfigs, shareHandle.Handle, direct, attributes.ToArray())); if (Handle == ContextHandle.Zero) { Debug.Write(String.Format("failed. Trying direct: {0}... ", !direct)); Handle = new ContextHandle(Glx.Arb.CreateContextAttribs(Display, *fbconfigs, shareHandle.Handle, !direct, attributes.ToArray())); } } if (Handle == ContextHandle.Zero) { Debug.WriteLine("failed."); } else { Debug.WriteLine("success!"); } using (new XLock(Display)) { Functions.XFree((IntPtr)fbconfigs); } } } } if (Handle == ContextHandle.Zero) { Debug.Write("Using legacy context creation... "); XVisualInfo info = currentWindow.VisualInfo; using (new XLock(Display)) { // Cannot pass a Property by reference. Handle = new ContextHandle(Glx.CreateContext(Display, ref info, shareHandle.Handle, direct)); if (Handle == ContextHandle.Zero) { Debug.WriteLine(String.Format("failed. Trying direct: {0}... ", !direct)); Handle = new ContextHandle(Glx.CreateContext(Display, ref info, IntPtr.Zero, !direct)); } } } if (Handle != ContextHandle.Zero) { Debug.Print("Context created (id: {0}).", Handle); } else { throw new GraphicsContextException("Failed to create OpenGL context. Glx.CreateContext call returned 0."); } using (new XLock(Display)) { if (!Glx.IsDirect(Display, Handle.Handle)) { Debug.Print("Warning: Context is not direct."); } } }
public Sdl2PlatformWindow(Size requestWindowSize, WindowMode windowMode, int batchSize) { // Lock the Window/Surface properties until initialization is complete lock (syncObject) { windowSize = requestWindowSize; // Disable legacy scaling on Windows if (Platform.CurrentPlatform == PlatformType.Windows && !Game.Settings.Graphics.DisableWindowsDPIScaling) { SetProcessDPIAware(); } SDL.SDL_Init(SDL.SDL_INIT_NOPARACHUTE | SDL.SDL_INIT_VIDEO); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_DOUBLEBUFFER, 1); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_RED_SIZE, 8); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_GREEN_SIZE, 8); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_BLUE_SIZE, 8); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_ALPHA_SIZE, 0); // Decide between OpenGL and OpenGL ES rendering // Test whether we can use the preferred renderer and fall back to the other if that fails // If neither works we will throw a graphics error later when trying to create the real window bool useGLES; if (Game.Settings.Graphics.PreferGLES) { useGLES = CanCreateGLWindow(3, 0, SDL.SDL_GLprofile.SDL_GL_CONTEXT_PROFILE_ES); } else { useGLES = !CanCreateGLWindow(3, 2, SDL.SDL_GLprofile.SDL_GL_CONTEXT_PROFILE_CORE); } var glMajor = 3; var glMinor = useGLES ? 0 : 2; var glProfile = useGLES ? SDL.SDL_GLprofile.SDL_GL_CONTEXT_PROFILE_ES : SDL.SDL_GLprofile.SDL_GL_CONTEXT_PROFILE_CORE; SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_MAJOR_VERSION, glMajor); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_MINOR_VERSION, glMinor); SDL.SDL_GL_SetAttribute(SDL.SDL_GLattr.SDL_GL_CONTEXT_PROFILE_MASK, (int)glProfile); Console.WriteLine("Using SDL 2 with OpenGL{0} renderer", useGLES ? " ES" : ""); SDL.SDL_DisplayMode display; SDL.SDL_GetCurrentDisplayMode(0, out display); Console.WriteLine("Desktop resolution: {0}x{1}", display.w, display.h); if (windowSize.Width == 0 && windowSize.Height == 0) { Console.WriteLine("No custom resolution provided, using desktop resolution"); windowSize = new Size(display.w, display.h); } Console.WriteLine("Using resolution: {0}x{1}", windowSize.Width, windowSize.Height); var windowFlags = SDL.SDL_WindowFlags.SDL_WINDOW_OPENGL | SDL.SDL_WindowFlags.SDL_WINDOW_ALLOW_HIGHDPI; // HiDPI doesn't work properly on OSX with (legacy) fullscreen mode if (Platform.CurrentPlatform == PlatformType.OSX && windowMode == WindowMode.Fullscreen) { SDL.SDL_SetHint(SDL.SDL_HINT_VIDEO_HIGHDPI_DISABLED, "1"); } window = SDL.SDL_CreateWindow("OpenRA", SDL.SDL_WINDOWPOS_CENTERED, SDL.SDL_WINDOWPOS_CENTERED, windowSize.Width, windowSize.Height, windowFlags); // Work around an issue in macOS's GL backend where the window remains permanently black // (if dark mode is enabled) unless we drain the event queue before initializing GL if (Platform.CurrentPlatform == PlatformType.OSX) { SDL.SDL_Event e; while (SDL.SDL_PollEvent(out e) != 0) { // We can safely ignore all mouse/keyboard events and window size changes // (these will be caught in the window setup below), but do need to process focus if (e.type == SDL.SDL_EventType.SDL_WINDOWEVENT) { switch (e.window.windowEvent) { case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_LOST: Game.HasInputFocus = false; break; case SDL.SDL_WindowEventID.SDL_WINDOWEVENT_FOCUS_GAINED: Game.HasInputFocus = true; break; } } } } surfaceSize = windowSize; windowScale = 1; // Enable high resolution rendering for Retina displays if (Platform.CurrentPlatform == PlatformType.OSX) { // OSX defines the window size in "points", with a device-dependent number of pixels per point. // The window scale is simply the ratio of GL pixels / window points. int width, height; SDL.SDL_GL_GetDrawableSize(Window, out width, out height); surfaceSize = new Size(width, height); windowScale = width * 1f / windowSize.Width; } else if (Platform.CurrentPlatform == PlatformType.Windows) { float ddpi, hdpi, vdpi; if (!Game.Settings.Graphics.DisableWindowsDPIScaling && SDL.SDL_GetDisplayDPI(0, out ddpi, out hdpi, out vdpi) == 0) { windowScale = ddpi / 96; windowSize = new Size((int)(surfaceSize.Width / windowScale), (int)(surfaceSize.Height / windowScale)); } } else { float scale = 1; var scaleVariable = Environment.GetEnvironmentVariable("OPENRA_DISPLAY_SCALE"); if (scaleVariable != null && float.TryParse(scaleVariable, out scale)) { windowScale = scale; windowSize = new Size((int)(surfaceSize.Width / windowScale), (int)(surfaceSize.Height / windowScale)); } } Console.WriteLine("Using window scale {0:F2}", windowScale); if (Game.Settings.Game.LockMouseWindow) { GrabWindowMouseFocus(); } else { ReleaseWindowMouseFocus(); } if (windowMode == WindowMode.Fullscreen) { SDL.SDL_SetWindowFullscreen(Window, (uint)SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN); // Fullscreen mode on OSX will ignore the configured display resolution // and instead always picks an arbitrary scaled resolution choice that may // not match the window size, leading to graphical and input issues. // We work around this by force disabling HiDPI and resetting the window and // surface sizes to match the size that is forced by SDL. // This is usually not what the player wants, but is the best we can consistently do. if (Platform.CurrentPlatform == PlatformType.OSX) { int width, height; SDL.SDL_GetWindowSize(Window, out width, out height); windowSize = surfaceSize = new Size(width, height); windowScale = 1; } } else if (windowMode == WindowMode.PseudoFullscreen) { // Work around a visual glitch in OSX: the window is offset // partially offscreen if the dock is at the left of the screen if (Platform.CurrentPlatform == PlatformType.OSX) { SDL.SDL_SetWindowPosition(Window, 0, 0); } SDL.SDL_SetWindowFullscreen(Window, (uint)SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN_DESKTOP); SDL.SDL_SetHint(SDL.SDL_HINT_VIDEO_MINIMIZE_ON_FOCUS_LOSS, "0"); } } // Run graphics rendering on a dedicated thread. // The calling thread will then have more time to process other tasks, since rendering happens in parallel. // If the calling thread is the main game thread, this means it can run more logic and render ticks. // This is disabled on Windows because it breaks the ability to minimize/restore the window from the taskbar for reasons that we dont understand. var threadedRenderer = Platform.CurrentPlatform != PlatformType.Windows || !Game.Settings.Graphics.DisableWindowsRenderThread; if (!threadedRenderer) { var ctx = new Sdl2GraphicsContext(this); ctx.InitializeOpenGL(); context = ctx; } else { context = new ThreadedGraphicsContext(new Sdl2GraphicsContext(this), batchSize); } SDL.SDL_SetModState(SDL.SDL_Keymod.KMOD_NONE); input = new Sdl2Input(); }
// Called when the widget needs to be (fully or partially) redrawn. protected override bool OnExposeEvent(Gdk.EventExpose eventExpose) { if (!initialized) { initialized = true; // If this looks uninitialized... initialize. if (ColorBPP == 0) { ColorBPP = 32; if (DepthBPP == 0) { DepthBPP = 16; } } ColorFormat colorBufferColorFormat = new ColorFormat(ColorBPP); ColorFormat accumulationColorFormat = new ColorFormat(AccumulatorBPP); int buffers = 2; if (SingleBuffer) { buffers--; } GraphicsMode graphicsMode = new GraphicsMode(colorBufferColorFormat, DepthBPP, StencilBPP, Samples, accumulationColorFormat, buffers, Stereo); // IWindowInfo if (Configuration.RunningOnWindows) { IntPtr windowHandle = gdk_win32_drawable_get_handle(GdkWindow.Handle); windowInfo = OpenTK.Platform.Utilities.CreateWindowsWindowInfo(windowHandle); } else if (Configuration.RunningOnMacOS) { IntPtr windowHandle = gdk_quartz_window_get_nswindow(GdkWindow.Handle); IntPtr contentView = gdk_quartz_window_get_nsview(GdkWindow.Handle); // Problem: gdk_window_ensure_native() crashes when used more than once. // For now, just create a NSView in place and use that instead. // Needs some care updating when resizing, hiding, etc, but seems to work. // (I'd guess this is pretty much what gdk_window_ensure_native() does internally.) var customView = Class.AllocateClass("CustomNSView" + uniqueId++, "NSView"); //Class.RegisterMethod(windowClass, new WindowKeyDownDelegate(WindowKeyDown), "keyDown:", "v@:@"); //Class.RegisterMethod(customView, new OnHitTestDelegate(OnHitTest), "hitTest:", "@@:{NSPoint=ff}"); Class.RegisterMethod(customView, new OnMouseDownDelegate(OnMouseDown), "mouseDown:", "v@:@"); Class.RegisterMethod(customView, new OnMouseDraggedDelegate(OnMouseDragged), "mouseDragged:", "v@:@"); Class.RegisterMethod(customView, new OnMouseUpDelegate(OnMouseUp), "mouseUp:", "v@:@"); Class.RegisterClass(customView); nsView = SendIntPtr(SendIntPtr(customView, sel_registerName("alloc")), sel_registerName("initWithFrame:"), new RectangleF(0, 0, 100, 100)); SendVoid(contentView, sel_registerName("addSubview:"), nsView); // bool native = gdk_window_ensure_native(GdkWindow.Handle); // if (!native) // { // throw new PlatformNotSupportedException("Could not create native view."); // } // // nsView = gdk_quartz_window_get_nsview(GdkWindow.Handle); windowInfo = OpenTK.Platform.Utilities.CreateMacOSWindowInfo(windowHandle, nsView); UpdateNSView(); } else if (Configuration.RunningOnX11) { IntPtr display = gdk_x11_display_get_xdisplay(Display.Handle); int screen = Screen.Number; IntPtr windowHandle = gdk_x11_drawable_get_xid(GdkWindow.Handle); IntPtr rootWindow = gdk_x11_drawable_get_xid(RootWindow.Handle); IntPtr visualInfo; if (graphicsMode.Index.HasValue) { XVisualInfo info = new XVisualInfo(); info.VisualID = graphicsMode.Index.Value; int dummy; visualInfo = XGetVisualInfo(display, XVisualInfoMask.ID, ref info, out dummy); } else { visualInfo = GetVisualInfo(display); } windowInfo = OpenTK.Platform.Utilities.CreateX11WindowInfo(display, screen, windowHandle, rootWindow, visualInfo); XFree(visualInfo); } else { throw new PlatformNotSupportedException(); } // GraphicsContext graphicsContext = new GraphicsContext(graphicsMode, windowInfo, GlVersionMajor, GlVersionMinor, graphicsContextFlags); graphicsContext.MakeCurrent(windowInfo); if (GraphicsContext.ShareContexts) { Interlocked.Increment(ref graphicsContextCount); if (!sharedContextInitialized) { sharedContextInitialized = true; ((IGraphicsContextInternal)graphicsContext).LoadAll(); OnGraphicsContextInitialized(); } } else { ((IGraphicsContextInternal)graphicsContext).LoadAll(); OnGraphicsContextInitialized(); } OnInitialized(); } else { try // Hack: Fix crash when returning from sleep mode on windows, using nvidia drivers. See: http://www.opentk.com/node/2634 { graphicsContext.MakeCurrent(windowInfo); } catch { } } bool result = base.OnExposeEvent(eventExpose); OnRenderFrame(); eventExpose.Window.Display.Sync(); // Add Sync call to fix resize rendering problem (Jay L. T. Cornwall) - How does this affect VSync? graphicsContext.SwapBuffers(); return(result); }
public abstract IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags);
public override IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { X11WindowInfo x11_win = (X11WindowInfo)window; EglWindowInfo egl_win = new OpenTK.Platform.Egl.EglWindowInfo(x11_win.WindowHandle, Egl.GetDisplay(x11_win.Display)); return(new EglContext(handle, egl_win, shareContext, major, minor, flags)); }
public virtual IGraphicsContext CreateGLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { throw new NotImplementedException(); }
private int swap_interval = 1; // Default interval is defined as 1 in EGL. public EglContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { if (mode == null) { throw new ArgumentNullException("mode"); } if (window == null) { throw new ArgumentNullException("window"); } EglContext shared = GetSharedEglContext(sharedContext); WindowInfo = window; // Select an EGLConfig that matches the desired mode. We cannot use the 'mode' // parameter directly, since it may have originated on a different system (e.g. GLX) // and it may not support the desired renderer. Renderable = RenderableFlags.GL; if ((flags & GraphicsContextFlags.Embedded) != 0) { switch (major) { case 3: Renderable = RenderableFlags.ES3; break; case 2: Renderable = RenderableFlags.ES2; break; default: Renderable = RenderableFlags.ES; break; } } RenderApi api = (Renderable & RenderableFlags.GL) != 0 ? RenderApi.GL : RenderApi.ES; Debug.Print("[EGL] Binding {0} rendering API.", api); if (!Egl.BindAPI(api)) { Debug.Print("[EGL] Failed to bind rendering API. Error: {0}", Egl.GetError()); } bool offscreen = (flags & GraphicsContextFlags.Offscreen) != 0; SurfaceType surfaceType = offscreen ? SurfaceType.PBUFFER_BIT : SurfaceType.WINDOW_BIT; Mode = new EglGraphicsMode().SelectGraphicsMode(surfaceType, window.Display, mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo, Renderable); if (!Mode.Index.HasValue) { throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); } IntPtr config = Mode.Index.Value; if (window.Surface == IntPtr.Zero) { if (!offscreen) { window.CreateWindowSurface(config); } else { window.CreatePbufferSurface(config); } } int[] attribList = { Egl.CONTEXT_CLIENT_VERSION, major, Egl.NONE }; var shareContext = shared?.HandleAsEGLContext ?? IntPtr.Zero; HandleAsEGLContext = Egl.CreateContext(window.Display, config, shareContext, attribList); GraphicsContextFlags = flags; }
public EglUnixContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) : base(mode, window, sharedContext, major, minor, flags) { }
private static void SetGLAttributes(GraphicsMode mode, IGraphicsContext shareContext, int major, int minor, GraphicsContextFlags flags) { ContextProfileFlags cpflags = 0; ClearGLAttributes(); if (mode.AccumulatorFormat.BitsPerPixel > 0) { SDL.GL.SetAttribute(ContextAttribute.ACCUM_ALPHA_SIZE, mode.AccumulatorFormat.Alpha); SDL.GL.SetAttribute(ContextAttribute.ACCUM_RED_SIZE, mode.AccumulatorFormat.Red); SDL.GL.SetAttribute(ContextAttribute.ACCUM_GREEN_SIZE, mode.AccumulatorFormat.Green); SDL.GL.SetAttribute(ContextAttribute.ACCUM_BLUE_SIZE, mode.AccumulatorFormat.Blue); } if (mode.Buffers > 0) { SDL.GL.SetAttribute(ContextAttribute.DOUBLEBUFFER, mode.Buffers > 1 ? 1 : 0); } if (mode.ColorFormat > 0) { SDL.GL.SetAttribute(ContextAttribute.ALPHA_SIZE, mode.ColorFormat.Alpha); SDL.GL.SetAttribute(ContextAttribute.RED_SIZE, mode.ColorFormat.Red); SDL.GL.SetAttribute(ContextAttribute.GREEN_SIZE, mode.ColorFormat.Green); SDL.GL.SetAttribute(ContextAttribute.BLUE_SIZE, mode.ColorFormat.Blue); } if (mode.Depth > 0) { SDL.GL.SetAttribute(ContextAttribute.DEPTH_SIZE, mode.Depth); } if (mode.Samples > 0) { SDL.GL.SetAttribute(ContextAttribute.MULTISAMPLEBUFFERS, 1); SDL.GL.SetAttribute(ContextAttribute.MULTISAMPLESAMPLES, mode.Samples); } if (mode.Stencil > 0) { SDL.GL.SetAttribute(ContextAttribute.STENCIL_SIZE, 1); } if (mode.Stereo) { SDL.GL.SetAttribute(ContextAttribute.STEREO, 1); } if (major > 0) { // Workaround for https://github.com/opentk/opentk/issues/44 // Mac OS X desktop OpenGL 3.x/4.x contexts require require // ContextProfileFlags.Core, otherwise they will fail to construct. if (Configuration.RunningOnMacOS && major >= 3 && (flags & GraphicsContextFlags.Embedded) == 0) { cpflags |= ContextProfileFlags.CORE; // According to https://developer.apple.com/graphicsimaging/opengl/capabilities/GLInfo_1075_Core.html // Mac OS X supports 3.2+. Indeed, requesting 3.0 or 3.1 results in failure. if (major == 3 && minor < 2) { minor = 2; } } SDL.GL.SetAttribute(ContextAttribute.CONTEXT_MAJOR_VERSION, major); SDL.GL.SetAttribute(ContextAttribute.CONTEXT_MINOR_VERSION, minor); } if ((flags & GraphicsContextFlags.Debug) != 0) { SDL.GL.SetAttribute(ContextAttribute.CONTEXT_FLAGS, ContextFlags.DEBUG); } /* if ((flags & GraphicsContextFlags.Robust) != 0) { SDL.GL.SetAttribute(ContextAttribute.CONTEXT_FLAGS, ContextFlags.ROBUST_ACCESS_FLAG); } if ((flags & GraphicsContextFlags.ResetIsolation) != 0) { SDL.GL.SetAttribute(ContextAttribute.CONTEXT_FLAGS, ContextFlags.RESET_ISOLATION_FLAG); } */ { if ((flags & GraphicsContextFlags.Embedded) != 0) { cpflags |= ContextProfileFlags.ES; SDL.GL.SetAttribute(ContextAttribute.CONTEXT_EGL, 1); } if ((flags & GraphicsContextFlags.ForwardCompatible) != 0) { cpflags |= ContextProfileFlags.CORE; } if (cpflags != 0) { SDL.GL.SetAttribute(ContextAttribute.CONTEXT_PROFILE_MASK, cpflags); } } if (shareContext != null) { if (shareContext.IsCurrent) { SDL.GL.SetAttribute(ContextAttribute.SHARE_WITH_CURRENT_CONTEXT, 1); } else { Trace.WriteLine("Warning: SDL2 requires a shared context to be current before sharing. Sharing failed."); } } }
public virtual IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return((IGraphicsContext) new X11GLContext(mode, window, shareContext, directRendering, major, minor, flags)); }
public void RenderDeferred(GameTime gameTime, IGraphicsContext context) { throw new NotImplementedException(); }
private void SetupShaderProgram(ref Matrix4 projection, ShaderProgram program) { IGraphicsContext context = program.GraphicsContext; context.UseShaderProgram(program); program.SetUniform(PROJ_MAT, ref projection); program.SetUniform(FORCES, ref this.settings.Forces); program.SetUniform(START_COLOR, settings.StartColor); program.SetUniform(END_COLOR, settings.EndColor); program.SetUniform(START_SIZE, settings.StartSize); program.SetUniform(END_SIZE, settings.EndSize); program.SetUniform(START_ANGULAR_VELOCITY, settings.StartAngularVelocity); program.SetUniform(END_ANGULAR_VELOCITY, settings.EndAngularVelocity); program.SetUniform(COLOR_VARIANCE, settings.ColorVariance); program.SetUniform(SIZE_VARIANCE, settings.SizeVariance); Vector3 g = new Vector3(500, 500, -0); program.SetUniform("gravity_well_1", ref g); g = new Vector3(1550, 500, 0); program.SetUniform("gravity_well_2", ref g); program.SetUniform(START_ALPHA, 1.5f); program.SetUniform(END_ALPHA, 0f); program.SetUniform(LIFE_TIME, settings.LifeTime); program.SetUniform(CURRENT_TIME, this.currentTime); program.SetUniform(TEXTURE, 0); GL.BindVertexArray(this.vba); int posIndex = program.GetAttributeLocation(IN_POS); int veloIndex = program.GetAttributeLocation(IN_VEL); int randomIndex = program.GetAttributeLocation(IN_RANDOM); int offsetIndex = program.GetAttributeLocation(IN_OFFSET); int coordIndex = program.GetAttributeLocation(IN_COORDS); int timeIndex = program.GetAttributeLocation(IN_TIME); context.BindVertexBuffer(this.vertexBuffer); context.EnableVertexAttribArray(posIndex); context.EnableVertexAttribArray(veloIndex); context.EnableVertexAttribArray(randomIndex); context.EnableVertexAttribArray(offsetIndex); context.EnableVertexAttribArray(coordIndex); context.EnableVertexAttribArray(timeIndex); context.VertexAttribPointer(posIndex, 2, VertexAttribPointerType.Float, false, this.queue[0].SizeInBytes, 0); context.VertexAttribPointer(veloIndex, 2, VertexAttribPointerType.Float, false, this.queue[0].SizeInBytes, Vector2.SizeInBytes); context.VertexAttribPointer(randomIndex, 2, VertexAttribPointerType.Float, false, this.queue[0].SizeInBytes, Vector2.SizeInBytes * 2); context.VertexAttribPointer(offsetIndex, 2, VertexAttribPointerType.Float, false, this.queue[0].SizeInBytes, Vector2.SizeInBytes * 3); context.VertexAttribPointer(coordIndex, 2, VertexAttribPointerType.Float, false, this.queue[0].SizeInBytes, Vector2.SizeInBytes * 4); context.VertexAttribPointer(timeIndex, 1, VertexAttribPointerType.Float, false, this.queue[0].SizeInBytes, Vector2.SizeInBytes * 5); GL.BindVertexArray(0); }
public EglWinContext(ContextHandle handle, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) : base(handle, window, sharedContext, major, minor, flags) { }
void InitializeContext() { Toolkit.Init(); // If this looks uninitialized... initialize. if (ColorBPP == 0) { ColorBPP = 24; if (DepthBPP == 0) { DepthBPP = 16; } } ColorFormat colorBufferColorFormat = new ColorFormat(ColorBPP); ColorFormat accumulationColorFormat = new ColorFormat(AccumulatorBPP); int buffers = 2; if (SingleBuffer) { buffers--; } var graphicsMode = new GraphicsMode(colorBufferColorFormat, DepthBPP, StencilBPP, Samples, accumulationColorFormat, buffers, Stereo); // IWindowInfo if (Configuration.RunningOnWindows) { IntPtr windowHandle = gdk_win32_drawable_get_handle(GdkWindow.Handle); windowInfo = Utilities.CreateWindowsWindowInfo(windowHandle); } else if (Configuration.RunningOnMacOS) { IntPtr windowHandle = gdk_x11_drawable_get_xid(GdkWindow.Handle); bool ownHandle = true; bool isControl = true; windowInfo = Utilities.CreateMacOSCarbonWindowInfo(windowHandle, ownHandle, isControl); } else if (Configuration.RunningOnX11) { IntPtr display = gdk_x11_display_get_xdisplay(Display.Handle); int screen = Screen.Number; IntPtr windowHandle = gdk_x11_drawable_get_xid(GdkWindow.Handle); IntPtr rootWindow = gdk_x11_drawable_get_xid(RootWindow.Handle); IntPtr visualInfo; if (graphicsMode.Index.HasValue) { XVisualInfo info = new XVisualInfo(); info.VisualID = graphicsMode.Index.Value; int dummy; visualInfo = XGetVisualInfo(display, XVisualInfoMask.ID, ref info, out dummy); } else { visualInfo = GetVisualInfo(display); } windowInfo = Utilities.CreateX11WindowInfo(display, screen, windowHandle, rootWindow, visualInfo); XFree(visualInfo); } else { throw new PlatformNotSupportedException(); } // GraphicsContext graphicsContext = new GraphicsContext(graphicsMode, windowInfo, GlVersionMajor, GlVersionMinor, graphicsContextFlags); graphicsContext.MakeCurrent(windowInfo); if (GraphicsContext.ShareContexts) { Interlocked.Increment(ref graphicsContextCount); if (!sharedContextInitialized) { sharedContextInitialized = true; ((IGraphicsContextInternal)graphicsContext).LoadAll(); OnGraphicsContextInitialized(); } } else { ((IGraphicsContextInternal)graphicsContext).LoadAll(); OnGraphicsContextInitialized(); } initialized = true; OnInitialized(); //QueueDraw(); }