public NativeWindowProvider(string name, int width, int height) { var graphicsMode = new GraphicsMode(new ColorFormat(32), 24, 0, 0); Window = new NativeWindow(width, height, name, GameWindowFlags.Default, graphicsMode, DisplayDevice.Default); Window.Visible = true; }
public Main(GraphicsMode mode, string title, GameWindowFlags flags) : base((int)Constants.Graphics.ScreenResolution.X, (int)Constants.Graphics.ScreenResolution.Y, mode, title, flags) { Engines = new List<Engine>(); Constants.SetupEngines(this); Constants.Engines.Input.SetMouseShow(false); }
public CanvasForm(Control parent) { InitializeComponent(); ContextContainer = new Panel(); ContextContainer.Padding = new Padding(1); ContextContainer.BackColor = Color.Black; Console.WriteLine(ContextContainer.Anchor); GraphicsMode mode = new GraphicsMode( new ColorFormat(8, 8, 8, 8), 8, 8, MSAASamples, new ColorFormat(8, 8, 8, 8), 2, false ); GLContext = new GLControl(mode, 2, 0, GraphicsContextFlags.Default); GLContext.Dock = DockStyle.Fill; GLContext.VSync = true; GLContext.Paint += new PaintEventHandler(this.GLContext_Paint); GLContext.MouseDown += new MouseEventHandler(this.GLContext_MouseDown); GLContext.MouseMove += new MouseEventHandler(this.GLContext_MouseMove); GLContext.MouseUp += new MouseEventHandler(this.GLContext_MouseUp); ContextContainer.Controls.Add(GLContext); Controls.Add(ContextContainer); // Setup stuff TopLevel = false; parent.Controls.Add(this); }
public Game(int width, int height, GraphicsMode m, string title) : base(width, height, m, title) { // OpenTK configuration // VSync = VSyncMode.Adaptive; // Our initialization // core = new Core(Color.FromArgb(255, 2, 0, 8)); core.LoadScene(new TestScene("test scene", new Vector2(ClientSize.Width, ClientSize.Height))); core.ActiveScene = "test scene"; // Subscribe to OpenTK events // RenderFrame += OnRenderFrame; UpdateFrame += OnUpdateFrame; Resize += OnResize; Load += OnLoad; Closing += OnClosing; // Bind key event handlers // keyBinder = new Keybinder(Keyboard); keyBinder.SubscribeListener(Key.V, VsyncToggle); keyBinder.SubscribeListener(Key.Q, Quit); keyBinder.SubscribeListener(Key.F4, Quit); keyBinder.SubscribeListener(Key.Enter, ToggleWindowedFullscreen); }
internal X11GLControl(GraphicsMode mode, Control control) { if (mode == null) throw new ArgumentNullException("mode"); if (control == null) throw new ArgumentNullException("control"); // Note: the X11 window is created with a default XVisualInfo, // that is not necessarily compatible with the desired GraphicsMode. // This manifests in Nvidia binary drivers that fail in Glx.MakeCurrent() // when GraphicsMode has a 32bpp color format. // To work around this issue, we implicitly select a 24bpp color format when 32bpp is // requested - this appears to work correctly in all cases. // (The loss of the alpha channel does not matter, since WinForms do not support // translucent windows on X11 in the first place.) this.mode = new GraphicsMode( new ColorFormat(mode.ColorFormat.Red, mode.ColorFormat.Green, mode.ColorFormat.Blue, 0), mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo); if (xplatui == null) throw new PlatformNotSupportedException( "System.Windows.Forms.XplatUIX11 missing. Unsupported platform or Mono runtime version, aborting."); // get the required handles from the X11 API. display = (IntPtr)GetStaticFieldValue(xplatui, "DisplayHandle"); rootWindow = (IntPtr)GetStaticFieldValue(xplatui, "RootWindow"); int screen = (int)GetStaticFieldValue(xplatui, "ScreenNo"); window_info = Utilities.CreateX11WindowInfo(display, screen, control.Handle, rootWindow, IntPtr.Zero); }
public override IGraphicsContext CreateGLContext(GraphicsMode mode, 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(mode, egl_win, shareContext, major, minor, flags); }
/// <summary> /// Constructor /// </summary> public OpenGLWriteableBitmapUpdater(Size size, GraphicsMode graphicsMode, Action<GLControl> onPrepare = null, Action<GLControl> onFinalize = null) { this.loaded = false; this.Size = size; this.framebufferId = -1; this.OnPrepare += onPrepare; this.OnFinalize += onFinalize; messagingTask.StartMessageLoop( prepare: () => { this.glControl = new GLControl(graphicsMode); this.glControl.MakeCurrent(); if (this.OnPrepare != null) { this.OnPrepare(this.glControl); this.OnPrepare -= onPrepare; } }, finalize: () => { if (this.OnFinalize != null) { this.OnFinalize(this.glControl); this.OnFinalize -= onFinalize; } this.glControl.Context.MakeCurrent(null); this.glControl.Dispose(); }); }
public void Run() { GraphicsMode gmode = new GraphicsMode(GraphicsMode.Default.ColorFormat, GraphicsMode.Default.Depth, GraphicsMode.Default.Stencil, 0); DisplayDevice dd = DisplayDevice.Default; NativeWindow nw = new NativeWindow(Width, Height, "Test", GameWindowFlags.Default, gmode, dd); GraphicsContext glContext = new GraphicsContext(gmode, nw.WindowInfo, 3, 0, GraphicsContextFlags.Default); glContext.LoadAll(); glContext.MakeCurrent(nw.WindowInfo); if (Load()) { nw.Visible = true; while (nw.Visible) { Frame(); glContext.SwapBuffers(); Thread.Sleep(1000 / 60); //"60" fps (not really...) nw.ProcessEvents(); } nw.Visible = false; } Unload(); }
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); }
public override IGraphicsContext CreateGLContext(GraphicsMode mode, 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(mode, window1, shareContext, major, minor, flags); }
private void Form1_Load(object sender, EventArgs e) { Closing += Form1_Closing; WindowInfo = Utilities.CreateWindowsWindowInfo(panel1.Handle); var WindowMode = new GraphicsMode(32, 24, 0, 0, 0, 2); WindowContext = new GraphicsContext(WindowMode, WindowInfo, 2, 0, GraphicsContextFlags.Debug); WindowContext.MakeCurrent(WindowInfo); WindowContext.LoadAll(); // as IGraphicsContextInternal) WindowContext.SwapInterval = 1; GL.Viewport(0, 0, panel1.Width, panel1.Height); GL.Enable(EnableCap.DepthTest); GL.Disable(EnableCap.CullFace); GL.ClearColor(Color.DarkBlue); try { state.LoadCLRPackage(); state.DoString(@" import ('LUA', 'LUA') "); } catch (LuaException ex) { MessageBox.Show(ex.Message, "LUA Package Exception", MessageBoxButtons.OK); } state["x"] = 0.0; state["y"] = 1.0; state["fn"] = 0; script = textBox1.Text; timer1.Enabled = true; }
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 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); }
static void Main() { Dictionary<GraphicsMode, GraphicsMode> modes = new Dictionary<GraphicsMode, GraphicsMode>(); Trace.WriteLine("Cl (RGBA): Color format (total bits and bits per channel)."); Trace.WriteLine("Dp : Depth buffer bits."); Trace.WriteLine("St : Stencil buffer bits."); Trace.WriteLine("AA : Sample count for anti-aliasing."); Trace.WriteLine("Stereo : Stereoscoping rendering supported."); Trace.WriteLine(""); Trace.WriteLine("Cl (RGBA), Dp, St, AA, Stereo"); Trace.WriteLine("-----------------------------"); foreach (ColorFormat color in new ColorFormat[] { 32, 24, 16, 8 }) foreach (int depth in new int[] { 24, 16 }) foreach (int stencil in new int[] { 8, 0 }) foreach (int samples in new int[] { 0, 2, 4, 6, 8, 16 }) foreach (bool stereo in new bool[] { false, true }) { try { GraphicsMode mode = new GraphicsMode(color, depth, stencil, samples, 0, 2, stereo); if (!modes.ContainsKey(mode)) modes.Add(mode, mode); } catch { } } foreach (GraphicsMode mode in modes.Keys) Trace.WriteLine(String.Format("{0}, {1:00}, {2:00}, {3:00}, {4}", mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.Stereo)); }
public void Evaluate(int SpreadMax) { if (InputChanged() || FFirstRun) { FFirstRun = false; FPinOutOutput.SliceCount = SpreadMax; ColorFormat FColorFormat; ColorFormat FAccumulatorFormat; for (int i=0; i<SpreadMax; i++) { if (FPinInColorFormat[i] == null) FColorFormat = new ColorFormat(32); else FColorFormat = FPinInColorFormat[i]; if (FPinInAccumulatorFormat[i] == null) FAccumulatorFormat = new ColorFormat(0); else FAccumulatorFormat = FPinInAccumulatorFormat[i]; FPinOutOutput[i] = new GraphicsMode(FColorFormat, FPinInDepthBufferDepth[i], FPinInStencilBufferDepth[i], FPinInMSAA[i], FAccumulatorFormat, FPinInBuffers[i], FPinInStereo[i]); } } }
/// <summary> /// Constructor that passes parameters to the OpenTK GameWindow /// </summary> public TextureMapping_Net(int width, int height, OpenTK.Graphics.GraphicsMode mode, string title) : base(width, height, mode, title) { this.VSync = VSyncMode.On; }
internal CarbonGLControl(GraphicsMode mode, Control owner) { this.mode = mode; this.control = owner; window_info = Utilities.CreateMacOSCarbonWindowInfo(control.Handle, false, true); }
public override IGraphicsContext CreateGLContext(GraphicsMode mode, 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(mode, egl_win, shareContext, major, minor, flags); }
// This method is called everytime the context needs // to be recreated. Use it to set any egl-specific settings // prior to context creation protected override void CreateFrameBuffer() { ContextRenderingApi = GLVersion.ES2; // the default GraphicsMode that is set consists of (16, 16, 0, 0, 2, false) try { Debug.WriteLine("Loading with default settings"); // if you don't call this, the context won't be created base.CreateFrameBuffer(); return; } catch (Exception ex) { Log.Verbose("AGS", "{0}", ex); } // this is a graphics setting that sets everything to the lowest mode possible so // the device returns a reliable graphics setting. try { Log.Verbose("AGS", "Loading with custom Android settings (low mode)"); GraphicsMode = new GraphicsMode(0, 0, 0, 0, 0, 0, false); // if you don't call this, the context won't be created base.CreateFrameBuffer(); return; } catch (Exception ex) { Log.Verbose("AGS", "{0}", ex); } throw new Exception("Can't load egl, aborting"); }
public X11GLContext(GraphicsMode mode, IWindowInfo window) { if (mode == null) throw new ArgumentNullException("mode"); if (window == null) throw new ArgumentNullException("window"); Debug.Print( "Creating X11GLContext context: " ); currentWindow = (X11WindowInfo)window; Display = API.DefaultDisplay; XVisualInfo info = currentWindow.VisualInfo; Mode = GetGraphicsMode( info ); // Cannot pass a Property by reference. ContextHandle = Glx.glXCreateContext(Display, ref info, IntPtr.Zero, true); if (ContextHandle == IntPtr.Zero) { Debug.Print("failed. Trying indirect... "); ContextHandle = Glx.glXCreateContext(Display, ref info, IntPtr.Zero, false); } if (ContextHandle != IntPtr.Zero) Debug.Print("Context created (id: {0}).", ContextHandle); else throw new GraphicsContextException("Failed to create OpenGL context. Glx.CreateContext call returned 0."); if (!Glx.glXIsDirect(Display, ContextHandle)) Debug.Print("Warning: Context is not direct."); }
public SDL2GLNative(int x, int y, int width, int height, string title, GraphicsMode mode,GameWindowFlags options, DisplayDevice device) : this() { if (width <= 0) throw new ArgumentOutOfRangeException("width", "Must be higher than zero."); if (height <= 0) throw new ArgumentOutOfRangeException("height", "Must be higher than zero."); Debug.Indent(); IntPtr windowId; desiredSizeX = width; desiredSizeY = height; isFullscreen = options.HasFlag(GameWindowFlags.Fullscreen); if (isFullscreen) { FixupFullscreenRes(width,height,out width, out height); } lock (API.sdl_api_lock) { API.Init (API.INIT_VIDEO); API.VideoInit("",0); // NOTE: Seriously, letting the user set x and y coords is a _bad_ idea. We'll let the WM take care of it. windowId = API.CreateWindow(title, 0x1FFF0000, 0x1FFF0000, width, height, API.WindowFlags.OpenGL | ((isFullscreen)?API.WindowFlags.Fullscreen:0)); } window = new SDL2WindowInfo(windowId); inputDriver = new SDL2Input(window); Debug.Unindent(); }
public GraphicsMode SelectGraphicsMode(GraphicsMode desired_mode, out IntPtr visual, out IntPtr fbconfig) { GraphicsMode gfx; GraphicsMode mode = new GraphicsMode(desired_mode); visual = IntPtr.Zero; fbconfig = IntPtr.Zero; IntPtr display = API.DefaultDisplay; do { // Try to select a visual using Glx.ChooseFBConfig and Glx.GetVisualFromFBConfig. // This is only supported on GLX 1.3 - if it fails, fall back to Glx.ChooseVisual. fbconfig = SelectFBConfig(mode); if (fbconfig != IntPtr.Zero) visual = Glx.GetVisualFromFBConfig(display, fbconfig); if (visual == IntPtr.Zero) visual = SelectVisual(mode); if (visual == IntPtr.Zero) { // Relax parameters and retry if (!Utilities.RelaxGraphicsMode(ref mode)) throw new GraphicsModeException("Requested GraphicsMode not available."); } } while (visual == IntPtr.Zero); XVisualInfo info = (XVisualInfo)Marshal.PtrToStructure(visual, typeof(XVisualInfo)); gfx = CreateGraphicsMode(display, ref info); return gfx; }
public static IGraphicsContext CreateGraphicsContext(GraphicsMode mode, IWindowInfo window, int major, int minor, GraphicsContextFlags flags) { GraphicsContext graphicsContext = new GraphicsContext(mode, window, major, minor, flags); graphicsContext.MakeCurrent(window); graphicsContext.LoadAll(); return (IGraphicsContext) graphicsContext; }
public GameCanvas(int width, int height, GraphicsMode context, string title) : base(width, height, context, title) { m_StaticBody.BodyType = BodyType.Static; ThisCanvas = this; }
private GraphicsMode GetDefaultGraphicsMode() { int[] aaLevels = new int[] { 0, 2, 4, 6, 8, 16 }; HashSet<GraphicsMode> availGraphicsModes = new HashSet<GraphicsMode>(new GraphicsModeComparer()); foreach (int samplecount in aaLevels) { GraphicsMode mode = new GraphicsMode(32, 24, 0, samplecount, new OpenTK.Graphics.ColorFormat(0), 2, false); if (!availGraphicsModes.Contains(mode)) availGraphicsModes.Add(mode); } int highestAALevel = MathF.RoundToInt(MathF.Log(MathF.Max(availGraphicsModes.Max(m => m.Samples), 1.0f), 2.0f)); int targetAALevel = highestAALevel; if (DualityApp.AppData.MultisampleBackBuffer) { switch (DualityApp.UserData.AntialiasingQuality) { case AAQuality.High: targetAALevel = highestAALevel; break; case AAQuality.Medium: targetAALevel = highestAALevel / 2; break; case AAQuality.Low: targetAALevel = highestAALevel / 4; break; case AAQuality.Off: targetAALevel = 0; break; } } else { targetAALevel = 0; } int targetSampleCount = MathF.RoundToInt(MathF.Pow(2.0f, targetAALevel)); return availGraphicsModes.LastOrDefault(m => m.Samples <= targetSampleCount) ?? availGraphicsModes.Last(); }
public BasicDemo(GraphicsMode mode) : base(800, 600, mode, "BulletSharp OpenTK Demo") { VSync = VSyncMode.Off; physics = new Physics(); }
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); }
internal X11GLControl(GraphicsMode mode, Control control) { if (mode == null) throw new ArgumentNullException("mode"); if (control == null) throw new ArgumentNullException("control"); if (!mode.Index.HasValue) throw new GraphicsModeException("Invalid or unsupported GraphicsMode."); this.mode = mode; // Use reflection to retrieve the necessary values from Mono's Windows.Forms implementation. Type xplatui = Type.GetType("System.Windows.Forms.XplatUIX11, System.Windows.Forms"); if (xplatui == null) throw new PlatformNotSupportedException( "System.Windows.Forms.XplatUIX11 missing. Unsupported platform or Mono runtime version, aborting."); // get the required handles from the X11 API. display = (IntPtr)GetStaticFieldValue(xplatui, "DisplayHandle"); IntPtr rootWindow = (IntPtr)GetStaticFieldValue(xplatui, "RootWindow"); int screen = (int)GetStaticFieldValue(xplatui, "ScreenNo"); // get the XVisualInfo for this GraphicsMode XVisualInfo info = new XVisualInfo(); info.VisualID = mode.Index.Value; int dummy; IntPtr infoPtr = XGetVisualInfo(display, 1 /* VisualInfoMask.ID */, ref info, out dummy); info = (XVisualInfo)Marshal.PtrToStructure(infoPtr, typeof(XVisualInfo)); // set the X11 colormap. SetStaticFieldValue(xplatui, "CustomVisual", info.Visual); SetStaticFieldValue(xplatui, "CustomColormap", XCreateColormap(display, rootWindow, info.Visual, 0)); window_info = Utilities.CreateX11WindowInfo(display, screen, control.Handle, rootWindow, infoPtr); }
/// <summary> /// Initializes a new instance of the <see cref="GameContext" /> class. /// </summary> /// <param name="control">The control.</param> /// <param name="requestedWidth">Width of the requested.</param> /// <param name="requestedHeight">Height of the requested.</param> public GameContext(OpenTK.GameWindow control, int requestedWidth = 0, int requestedHeight = 0) { var creationFlags = GraphicsContextFlags.Default; #if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES creationFlags |= GraphicsContextFlags.Embedded; #endif if (requestedWidth == 0 || requestedHeight == 0) { requestedWidth = 1280; requestedHeight = 720; } // force the stencil buffer to be not null. var defaultMode = GraphicsMode.Default; var graphicMode = new GraphicsMode(defaultMode.ColorFormat, defaultMode.Depth, 8, defaultMode.Samples, defaultMode.AccumulatorFormat, defaultMode.Buffers, defaultMode.Stereo); GraphicsContext.ShareContexts = true; if (control == null) { int versionMajor, versionMinor; if (RequestedGraphicsProfile == null || RequestedGraphicsProfile.Length == 0) { #if SILICONSTUDIO_PARADOX_GRAPHICS_API_OPENGLES versionMajor = 3; versionMinor = 0; #else // PC: 4.3 is commonly available (= compute shaders) // MacOS X: 4.1 maximum versionMajor = 4; versionMinor = 1; #endif Control = TryGameWindow(requestedWidth, requestedHeight, graphicMode, versionMajor, versionMinor, creationFlags); } else { foreach (var profile in RequestedGraphicsProfile) { OpenGLUtils.GetGLVersion(profile, out versionMajor, out versionMinor); var gameWindow = TryGameWindow(requestedWidth, requestedHeight, graphicMode, versionMajor, versionMinor, creationFlags); if (gameWindow != null) { Control = gameWindow; break; } } } } else Control = control; if (Control == null) throw new Exception("Unable to initialize graphics context."); RequestedWidth = requestedWidth; RequestedHeight = requestedHeight; ContextType = AppContextType.DesktopOpenTK; }
public LinuxNativeWindow(IntPtr display, IntPtr gbm, int fd, int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice display_device) { Debug.Print("[KMS] Creating window on display {0:x}", display); Title = title; display_device = display_device ?? DisplayDevice.Default; if (display_device == null) { throw new NotSupportedException("[KMS] Driver does not currently support headless systems"); } window = new LinuxWindowInfo(display, fd, gbm, display_device.Id as LinuxDisplay); // Note: we only support fullscreen windows on KMS. // We implicitly override the requested width and height // by the width and height of the DisplayDevice, if any. width = display_device.Width; height = display_device.Height; bounds = new Rectangle(0, 0, width, height); client_size = bounds.Size; if (!mode.Index.HasValue) { mode = new EglGraphicsMode().SelectGraphicsMode(window, mode, 0); } Debug.Print("[KMS] Selected EGL mode {0}", mode); SurfaceFormat format = GetSurfaceFormat(display, mode); SurfaceFlags usage = SurfaceFlags.Rendering | SurfaceFlags.Scanout; if (!Gbm.IsFormatSupported(gbm, format, usage)) { Debug.Print("[KMS] Failed to find suitable surface format, using XRGB8888"); format = SurfaceFormat.XRGB8888; } Debug.Print("[KMS] Creating GBM surface on {0:x} with {1}x{2} {3} [{4}]", gbm, width, height, format, usage); IntPtr gbm_surface = Gbm.CreateSurface(gbm, width, height, format, usage); if (gbm_surface == IntPtr.Zero) { throw new NotSupportedException("[KMS] Failed to create GBM surface for rendering"); } window.Handle = gbm_surface; Debug.Print("[KMS] Created GBM surface {0:x}", window.Handle); window.CreateWindowSurface(mode.Index.Value); Debug.Print("[KMS] Created EGL surface {0:x}", window.Surface); cursor_default = CreateCursor(gbm, Cursors.Default); cursor_empty = CreateCursor(gbm, Cursors.Empty); Cursor = MouseCursor.Default; exists = true; }
public GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil, int samples, ColorFormat accum, int buffers, bool stereo) { GraphicsMode gfx; // The actual GraphicsMode that will be selected. IntPtr visual = IntPtr.Zero; IntPtr display = API.DefaultDisplay; do { // Try to select a visual using Glx.ChooseFBConfig and Glx.GetVisualFromFBConfig. // This is only supported on GLX 1.3 - if it fails, fall back to Glx.ChooseVisual. visual = SelectVisualUsingFBConfig(color, depth, stencil, samples, accum, buffers, stereo); if (visual == IntPtr.Zero) visual = SelectVisualUsingChooseVisual(color, depth, stencil, samples, accum, buffers, stereo); if (visual == IntPtr.Zero) { // Relax parameters and retry if (!Utilities.RelaxGraphicsMode(ref color, ref depth, ref stencil, ref samples, ref accum, ref buffers, ref stereo)) throw new GraphicsModeException("Requested GraphicsMode not available."); } } while (visual == IntPtr.Zero); XVisualInfo info = (XVisualInfo)Marshal.PtrToStructure(visual, typeof(XVisualInfo)); // See what we *really* got: int r, g, b, a; Glx.GetConfig(display, ref info, GLXAttribute.ALPHA_SIZE, out a); Glx.GetConfig(display, ref info, GLXAttribute.RED_SIZE, out r); Glx.GetConfig(display, ref info, GLXAttribute.GREEN_SIZE, out g); Glx.GetConfig(display, ref info, GLXAttribute.BLUE_SIZE, out b); int ar, ag, ab, aa; Glx.GetConfig(display, ref info, GLXAttribute.ACCUM_ALPHA_SIZE, out aa); Glx.GetConfig(display, ref info, GLXAttribute.ACCUM_RED_SIZE, out ar); Glx.GetConfig(display, ref info, GLXAttribute.ACCUM_GREEN_SIZE, out ag); Glx.GetConfig(display, ref info, GLXAttribute.ACCUM_BLUE_SIZE, out ab); Glx.GetConfig(display, ref info, GLXAttribute.DEPTH_SIZE, out depth); Glx.GetConfig(display, ref info, GLXAttribute.STENCIL_SIZE, out stencil); Glx.GetConfig(display, ref info, GLXAttribute.SAMPLES, out samples); Glx.GetConfig(display, ref info, GLXAttribute.DOUBLEBUFFER, out buffers); ++buffers; // the above lines returns 0 - false and 1 - true. int st; Glx.GetConfig(display, ref info, GLXAttribute.STEREO, out st); stereo = st != 0; gfx = new GraphicsMode(info.VisualID, new ColorFormat(r, g, b, a), depth, stencil, samples, new ColorFormat(ar, ag, ab, aa), buffers, stereo); using (new XLock(display)) { Functions.XFree(visual); } return gfx; }
public MyEglWin(IntPtr hwnd, IntPtr eglDisplay, int major, int minor, OpenTK.Graphics.GraphicsMode mode, GraphicsContextFlags flags) { Hwnd = hwnd; _eglDisplay = eglDisplay; _egl_win = new OpenTK.Platform.Egl.EglWindowInfo(hwnd, _eglDisplay); _eglWinContext = new EglWinContext(mode, _egl_win, null, major, minor, flags); }
public TestSync() { InitializeComponent(); var mode = new OpenTK.Graphics.GraphicsMode(32, 24, 8, 0, 0, 2, false); // combined 32 max of depth/stencil glwfc = new GLOFC.WinForm.GLWinFormControl(glControlContainer, mode); systemtimer.Interval = 25; systemtimer.Tick += new EventHandler(SystemTick); systemtimer.Start(); }
/// <summary> /// Entry point of this application /// </summary> public static void Main() { // Print some help info Console.WriteLine("\n--------------------------------------------------------------"); Console.WriteLine("Texture Mapping with OpenGL and DotNet"); OpenTK.Graphics.GraphicsMode mode = new OpenTK.Graphics.GraphicsMode(32, // bits color buffer 24, // bits depth buffer 0, // bits stencil buffer 4); // No. of sample for AA TextureMapping_Net app = new TextureMapping_Net(640, 480, mode, "OpenGL Texture Mapping (.NET)"); app.Run(30.0, 0.0); }
static void Main(string[] args) { ContextSettings contextSettings = new ContextSettings(24, 0, 0); var window = new RenderWindow(new SFML.Window.VideoMode(640, 480), "ImGui + SFML + .Net = <3", Styles.Default, contextSettings); OpenTK.Graphics.GraphicsMode graphicsMode = new OpenTK.Graphics.GraphicsMode(32, (int)contextSettings.DepthBits, (int)contextSettings.StencilBits, (int)contextSettings.AntialiasingLevel); OpenTK.Platform.IWindowInfo windowInfo = OpenTK.Platform.Utilities.CreateWindowsWindowInfo(window.SystemHandle); OpenTK.Graphics.GraphicsContext context = new OpenTK.Graphics.GraphicsContext(graphicsMode, windowInfo); context.MakeCurrent(windowInfo); context.LoadAll(); window.SetFramerateLimit(60); ImGuiSfml.Init(window); window.Closed += (s, e) => window.Close(); CircleShape shape = new CircleShape(100); shape.FillColor = Color.Green; Clock deltaClock = new Clock(); while (window.IsOpen) { window.DispatchEvents(); ImGuiSfml.Update(window, deltaClock.Restart()); ImGui.ShowDemoWindow(); //ImGui.ShowTestWindow(); /* * ImGui.Begin("Hello, world!"); * ImGui.Button("Look at this pretty button"); * ImGui.End(); */ window.Clear(); window.Draw(shape); ImGuiSfml.Render(window); window.Display(); } }
/* * Textures found at: * http://www.solarsystemscope.com/nexus/textures/planet_textures/ */ public RenderWindow(int width, int height, OpenTK.Graphics.GraphicsMode mode, string title) : base(width, height, mode, title) { physController = new PhysicsController(); camController = new CameraController(new double[] { 0, 0.0f, -5000000 }); graphController = new GraphicsController(); graphController.ReadObjFile("sphere.obj"); int[] newTextureIds = new int[11]; newTextureIds[0] = graphController.LoadTexture("Textures/texture_sun.jpg"); newTextureIds[1] = graphController.LoadTexture("Textures/texture_mercury.jpg"); newTextureIds[2] = graphController.LoadTexture("Textures/texture_venus_atmosphere.jpg"); newTextureIds[3] = graphController.LoadTexture("Textures/texture_earth_surface.jpg"); newTextureIds[4] = graphController.LoadTexture("Textures/texture_mars.jpg"); newTextureIds[5] = graphController.LoadTexture("Textures/texture_jupiter.jpg"); newTextureIds[6] = graphController.LoadTexture("Textures/texture_saturn.jpg"); newTextureIds[7] = graphController.LoadTexture("Textures/texture_uranus.jpg"); newTextureIds[8] = graphController.LoadTexture("Textures/texture_neptune.jpg"); newTextureIds[9] = graphController.LoadTexture("Textures/texture_moon.jpg"); newTextureIds[10] = graphController.LoadTexture("Textures/texture_skybox.jpg"); textureIds = newTextureIds; }
/// <summary> /// Constructs a new GraphicsContext with the specified GraphicsMode, version and flags, and attaches it to the specified window. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param> /// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param> /// <param name="major">The major version of the new GraphicsContext.</param> /// <param name="minor">The minor version of the new GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags for the GraphicsContext.</param> /// <remarks> /// Different hardware supports different flags, major and minor versions. Invalid parameters will be silently ignored. /// </remarks> public GraphicsContext(GraphicsMode mode, IWindowInfo window, int major, int minor, GraphicsContextFlags flags) { bool designMode = false; if (mode == null && window == null) { designMode = true; } else if (mode == null) { throw new ArgumentNullException("mode", "Must be a valid GraphicsMode."); } else if (window == null) { throw new ArgumentNullException("window", "Must point to a valid window."); } // Silently ignore invalid major and minor versions. if (major <= 0) { major = 1; } if (minor < 0) { minor = 0; } Debug.Print("Creating GraphicsContext."); try { Debug.Indent(); Debug.Print("GraphicsMode: {0}", mode); Debug.Print("IWindowInfo: {0}", window); Debug.Print("GraphicsContextFlags: {0}", flags); Debug.Print("Requested version: {0}.{1}", major, minor); IGraphicsContext shareContext = null; if (GraphicsContext.ShareContexts) { lock (context_lock) { // A small hack to create a shared context with the first available context. foreach (WeakReference r in GraphicsContext.available_contexts.Values) { shareContext = (IGraphicsContext)r.Target; break; } } } // Todo: Add a DummyFactory implementing IPlatformFactory. if (designMode) #if !IPHONE { implementation = new Platform.Dummy.DummyGLContext(); } #else { implementation = Factory.Embedded.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags); } #endif else { switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded) { case false: implementation = Factory.Default.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags); break; case true: implementation = Factory.Embedded.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags); break; } } lock (context_lock) { available_contexts.Add((this as IGraphicsContextInternal).Context, new WeakReference(this)); } }
/// <summary> /// Constructs a new GraphicsContext with the specified GraphicsMode, version and flags, and attaches it to the specified window. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param> /// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param> /// <param name="major">The major version of the new GraphicsContext.</param> /// <param name="minor">The minor version of the new GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags for the GraphicsContext.</param> /// <remarks> /// Different hardware supports different flags, major and minor versions. Invalid parameters will be silently ignored. /// </remarks> public GraphicsContext(GraphicsMode mode, IWindowInfo window, int major, int minor, GraphicsContextFlags flags) { lock (SyncRoot) { bool designMode = false; if (mode == null && window == null) { designMode = true; } else if (mode == null) { throw new ArgumentNullException("mode", "Must be a valid GraphicsMode."); } else if (window == null) { throw new ArgumentNullException("window", "Must point to a valid window."); } // Silently ignore invalid major and minor versions. if (major <= 0) { major = 1; } if (minor < 0) { minor = 0; } Debug.Print("Creating GraphicsContext."); try { Debug.Indent(); Debug.Print("GraphicsMode: {0}", mode); Debug.Print("IWindowInfo: {0}", window); Debug.Print("GraphicsContextFlags: {0}", flags); Debug.Print("Requested version: {0}.{1}", major, minor); IGraphicsContext shareContext = shareContext = FindSharedContext(); // Todo: Add a DummyFactory implementing IPlatformFactory. if (designMode) { implementation = new Platform.Dummy.DummyGLContext(); } else { IPlatformFactory factory = null; switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded) { case false: factory = Factory.Default; break; case true: factory = Factory.Embedded; break; } implementation = factory.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags); // Note: this approach does not allow us to mix native and EGL contexts in the same process. // This should not be a problem, as this use-case is not interesting for regular applications. // Note 2: some platforms may not support a direct way of getting the current context // (this happens e.g. with DummyGLContext). In that case, we use a slow fallback which // iterates through all known contexts and checks if any is current (check GetCurrentContext // declaration). if (GetCurrentContext == null) { GetCurrentContextDelegate temp = factory.CreateGetCurrentGraphicsContext(); if (temp != null) { GetCurrentContext = temp; } } } available_contexts.Add((this as IGraphicsContextInternal).Context, new WeakReference(this)); } finally { Debug.Unindent(); } } }
public GameWindowNative(int width, int height, OpenTK.Graphics.GraphicsMode mode, GameWindowFlags flags, int openGlMajor, int openGlMinor) : base(width, height, mode, "Server Context", flags, DisplayDevice.Default, openGlMajor, openGlMinor, OpenTK.Graphics.GraphicsContextFlags.Default) { }
/// <summary> /// Constructs a new GraphicsContext with the specified GraphicsMode, version and flags, and attaches it to the /// specified window. A dummy context will be created if both /// the handle and the window are null. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param> /// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param> /// <param name="shareContext">The GraphicsContext to share resources with, or null for explicit non-sharing.</param> /// <param name="major">The major version of the new GraphicsContext.</param> /// <param name="minor">The minor version of the new GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags for the GraphicsContext.</param> /// <remarks> /// Different hardware supports different flags, major and minor versions. Invalid parameters will be silently ignored. /// </remarks> public GraphicsContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, int major, int minor, GraphicsContextFlags flags) { lock (SyncRoot) { var designMode = false; if (mode == null && window == null) { designMode = true; } else if (mode == null) { throw new ArgumentNullException(nameof(mode), "Must be a valid GraphicsMode."); } else if (window == null) { throw new ArgumentNullException(nameof(window), "Must point to a valid window."); } // Silently ignore invalid major and minor versions. if (major <= 0) { major = 1; } if (minor < 0) { minor = 0; } // Angle needs an embedded context const GraphicsContextFlags useAngleFlag = GraphicsContextFlags.Angle | GraphicsContextFlags.AngleD3D9 | GraphicsContextFlags.AngleD3D11 | GraphicsContextFlags.AngleOpenGL; var useAngle = false; if ((flags & useAngleFlag) != 0) { flags |= GraphicsContextFlags.Embedded; useAngle = true; } Debug.Print("Creating GraphicsContext."); try { Debug.Indent(); Debug.Print("GraphicsMode: {0}", mode); Debug.Print("IWindowInfo: {0}", window); Debug.Print("GraphicsContextFlags: {0}", flags); Debug.Print("Requested version: {0}.{1}", major, minor); // Todo: Add a DummyFactory implementing IPlatformFactory. if (designMode) { implementation = new DummyGLContext(); } else { IPlatformFactory factory = null; switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded) { case false: factory = Factory.Default; break; case true: factory = useAngle ? Factory.Angle : Factory.Embedded; break; } // Note: this approach does not allow us to mix native and EGL contexts in the same process. // This should not be a problem, as this use-case is not interesting for regular applications. // Note 2: some platforms may not support a direct way of getting the current context // (this happens e.g. with DummyGLContext). In that case, we use a slow fallback which // iterates through all known contexts and checks if any is current (check GetCurrentContext // declaration). if (GetCurrentContext == null) { GetCurrentContext = factory.CreateGetCurrentGraphicsContext(); } implementation = factory.CreateGLContext(mode, window, shareContext, DirectRendering, major, minor, flags); handle_cached = ((IGraphicsContextInternal)implementation).Context; factory.RegisterResource(this); } AddContext(this); } finally { Debug.Unindent(); } } }
/// <summary> /// Constructs a new GraphicsContext with the specified GraphicsMode and attaches it to the specified window. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param> /// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param> public GraphicsContext(GraphicsMode mode, IWindowInfo window) : this(mode, window, 1, 0, GraphicsContextFlags.Default) { }
/// <summary> /// Constructs a new GraphicsContext with the specified GraphicsMode, version and flags, and attaches it to the /// specified window. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the GraphicsContext.</param> /// <param name="window">The OpenTK.Platform.IWindowInfo to attach the GraphicsContext to.</param> /// <param name="major">The major version of the new GraphicsContext.</param> /// <param name="minor">The minor version of the new GraphicsContext.</param> /// <param name="flags">The GraphicsContextFlags for the GraphicsContext.</param> /// <remarks> /// Different hardware supports different flags, major and minor versions. Invalid parameters will be silently ignored. /// </remarks> public GraphicsContext(GraphicsMode mode, IWindowInfo window, int major, int minor, GraphicsContextFlags flags) : this(mode, window, FindSharedContext(), major, minor, flags) { }
internal GraphicsMode(GraphicsMode mode) : this(mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo) { }
public EditorProgram(int w, int h, GRFX.GraphicsMode mode) : base(w, h, mode) { }