public GraphicsMode SelectGraphicsMode(ColorFormat color, int depth, int stencil, int samples, ColorFormat accum, int buffers, bool stereo) { GraphicsMode gfx = new GraphicsMode((IntPtr)1, color, depth, stencil, samples, accum, buffers, stereo); System.Diagnostics.Debug.Print("Created dummy graphics mode."); return gfx; }
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 CarbonGLNative(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { CreateNativeWindow(WindowClass.Document, WindowAttributes.StandardDocument | WindowAttributes.StandardHandler | WindowAttributes.InWindowMenu | WindowAttributes.LiveResize, new Rect((short)x, (short)y, (short)width, (short)height)); }
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); }
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; CreateContext(mode, carbonWindow, shareContextRef, true); }
public static Bitmap imageLoader(GBAROM ROM, int imageOffset, int paletteOffset, int width, int height, bool isImageCompressed, bool isPaletteCompressed, bool transparent, GraphicsMode mode) { DataBuffer rawGraphics = new DataBuffer(0x8000); DataBuffer rawPalette = new DataBuffer(0x100); if (isImageCompressed) { rawGraphics.ReadCompressedData(ROM, imageOffset); } else { int gfxlength = GBAGraphics.RawGraphicsLength(new Size(width * 8, height * 8), mode); rawGraphics.ReadData(ROM, imageOffset, gfxlength); } if (isPaletteCompressed) { rawPalette.ReadCompressedData(ROM, paletteOffset); } else { rawPalette.ReadData(ROM, paletteOffset, 0x200); } byte[] graphics = rawGraphics.ToArray(); int bitsPerPixel = GBAGraphics.BitsPerPixel(mode); int length = Math.Min(bitsPerPixel * width * height / 8, graphics.Length); Color[] palette; if (rawPalette.Length > 0 && paletteOffset != 0) palette = GBAPalette.ToPalette(rawPalette.ToArray(), 0, rawPalette.Length / 2); else { palette = new Color[16]; for (int i = 0; i < palette.Length; i++) palette[i] = Color.FromArgb(i * (256 / palette.Length), i * (256 / palette.Length), i * (256 / palette.Length)); } int empty; if(transparent) palette[0] = Color.FromArgb(0, palette[0]); return GBAGraphics.ToBitmap(graphics, length, 0, palette, width, mode, out empty); }
public override INativeWindow CreateNativeWindow(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { throw new PlatformNotSupportedException(error_string); }
internal static void Main(string[] args) { CurrentHost = new Host(); // file system FileSystem = FileSystem.FromCommandLineArgs(args, CurrentHost); FileSystem.CreateFileSystem(); Renderer = new NewRenderer(); CurrentRoute = new CurrentRoute(CurrentHost, Renderer); Sounds = new Sounds(); Options.LoadOptions(); TrainManager = new TrainManager(CurrentHost, Renderer, Interface.CurrentOptions, FileSystem); Plugins.LoadPlugins(); // command line arguments StringBuilder objectsToLoad = new StringBuilder(); if (args.Length != 0) { for (int i = 0; i < args.Length; i++) { if (args[i] != null) { if (System.IO.File.Exists(args[i])) { for (int j = 0; j < CurrentHost.Plugins.Length; j++) { if (CurrentHost.Plugins[j].Object != null && CurrentHost.Plugins[j].Object.CanLoadObject(args[i])) { objectsToLoad.Append(args[i] + " "); continue; } if (CurrentHost.Plugins[j].Route != null && CurrentHost.Plugins[j].Route.CanLoadRoute(args[i])) { if (string.IsNullOrEmpty(CurrentRouteFile)) { CurrentRouteFile = args[i]; processCommandLineArgs = true; } } } } else if (args[i].ToLowerInvariant() == "/enablehacks") { //Deliberately undocumented option for debugging use Interface.CurrentOptions.EnableBveTsHacks = true; for (int j = 0; j < CurrentHost.Plugins.Length; j++) { if (CurrentHost.Plugins[j].Object != null) { CompatabilityHacks enabledHacks = new CompatabilityHacks { BveTsHacks = true, CylinderHack = false, BlackTransparency = true }; CurrentHost.Plugins[j].Object.SetCompatibilityHacks(enabledHacks); } } } } } } if (objectsToLoad.Length != 0) { string File = System.IO.Path.Combine(Application.StartupPath, "ObjectViewer.exe"); if (System.IO.File.Exists(File)) { System.Diagnostics.Process.Start(File, objectsToLoad.ToString()); if (string.IsNullOrEmpty(CurrentRouteFile)) { //We only supplied objects, so launch Object Viewer instead Environment.Exit(0); } } } var options = new ToolkitOptions(); Plugins.LoadPlugins(); options.Backend = PlatformBackend.PreferX11; Toolkit.Init(options); string folder = Program.FileSystem.GetDataFolder("Languages"); Translations.LoadLanguageFiles(folder); Interface.CurrentOptions.ObjectOptimizationBasicThreshold = 1000; Interface.CurrentOptions.ObjectOptimizationFullThreshold = 250; // application currentGraphicsMode = new GraphicsMode(new ColorFormat(8, 8, 8, 8), 24, 8, Interface.CurrentOptions.AntiAliasingLevel); if (Renderer.Screen.Width == 0 || Renderer.Screen.Height == 0) { //Duff values saved, so reset to something sensible else we crash Renderer.Screen.Width = 1024; Renderer.Screen.Height = 768; } Renderer.CameraTrackFollower = new TrackFollower(Program.CurrentHost); currentGameWindow = new RouteViewer(Renderer.Screen.Width, Renderer.Screen.Height, currentGraphicsMode, "Route Viewer", GameWindowFlags.Default); currentGameWindow.Visible = true; currentGameWindow.TargetUpdateFrequency = 0; currentGameWindow.TargetRenderFrequency = 0; currentGameWindow.Title = "Route Viewer"; processCommandLineArgs = true; currentGameWindow.Run(); //Unload Sounds.Deinitialize(); }
/// <summary>Draw slider and background dc</summary> private void DrawTrack() { BitBlt(_cControlDc.Hdc, 0, 0, _cTrackDc.Width, _cTrackDc.Height, _cTrackDc.Hdc, 0, 0, 0xCC0020); if (TrackStyle == TrackType.Progress) { Rectangle trackRect = GetTrackRectangle(); Rectangle buttonRect = GetButtonRectangle(); int length; trackRect.Inflate(-1, -1); if (Orientation == Orientation.Horizontal) { if (_iValue == _iMinimum) { length = 0; } else if (_iValue == _iMaximum) { if (SmoothScrolling) { length = buttonRect.Right - (trackRect.Left + 1); trackRect.Width = length; } else { length = buttonRect.Right - (trackRect.Left + 2); trackRect.Width = length; } } else { length = buttonRect.Right - (trackRect.Left + (int)(buttonRect.Width * .5f)); trackRect.Width = length; } } else { if (_iValue == _iMinimum) { length = 0; } else if (_iValue == _iMaximum) { if (SmoothScrolling) { length = trackRect.Bottom - (buttonRect.Top + 1); trackRect.Y = buttonRect.Top - 1; trackRect.Height = length; } else { length = trackRect.Bottom - (buttonRect.Top + 3); trackRect.Height = length; } } else { length = trackRect.Bottom - (buttonRect.Top + (int)(buttonRect.Height * .5f)); trackRect.Y = buttonRect.Top + (int)(buttonRect.Height * .5f) - 2; trackRect.Height = length; } } if (length > 1) { using (Graphics g = Graphics.FromHdc(_cControlDc.Hdc)) { using (GraphicsMode mode = new GraphicsMode(g, SmoothingMode.HighQuality)) { using (GraphicsPath gp = CreateRoundRectanglePath(g, trackRect, 2)) { using (LinearGradientBrush fillBrush = new LinearGradientBrush( buttonRect, Color.FromArgb(120, Color.White), Color.FromArgb(250, TrackProgressColor), (Orientation == Orientation.Horizontal) ? LinearGradientMode.Vertical : LinearGradientMode.Horizontal)) { Blend blnd = new Blend(); blnd.Positions = new[] { 0f, .5f, 1f }; blnd.Factors = new[] { .5f, .7f, .3f }; fillBrush.Blend = blnd; g.FillPath(fillBrush, gp); } } } } } } }
public INativeWindow CreateNativeWindow(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { throw new PlatformNotSupportedException(error_string); }
public IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window) { //return new WinDXContext( mode, (WinWindowInfo)window ); return new WinGLContext(mode, (WinWindowInfo)window); }
public static byte[] ToGBARaw(Bitmap image, Color[] palette, GraphicsMode mode) { byte[] result = null; switch (mode) { case GraphicsMode.Tile8bit: result = ToTile8bit(image, palette); break; case GraphicsMode.Tile4bit: result = ToTile4bit(image, palette); break; case GraphicsMode.BitmapTrueColour: result = ToBitmapTrueColour(image); break; case GraphicsMode.Bitmap8bit: result = ToBitmapIndexed(image, palette); break; } return result; }
void CreateContext(GraphicsMode mode, CarbonWindowInfo carbonWindow, IntPtr shareContextRef, bool fullscreen) { Debug.Print("AGL pixel format attributes:"); AGLPixelFormat myAGLPixelFormat; // Choose a pixel format with the attributes we specified. IntPtr gdevice; IntPtr cgdevice = GetQuartzDevice(carbonWindow); if (cgdevice == IntPtr.Zero) cgdevice = (IntPtr)DisplayDevice.Default.Id; OSStatus status = Carbon.API.DMGetGDeviceByDisplayID(cgdevice, out gdevice, false); if (status != OSStatus.NoError) throw new MacOSException(status, "DMGetGDeviceByDisplayID failed."); IGraphicsMode selector = new MacOSGraphicsMode(gdevice); Mode = selector.SelectGraphicsMode( mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo); MyAGLReportError("aglChoosePixelFormat"); Debug.Print("Creating AGL context. Sharing with {0}", shareContextRef); myAGLPixelFormat = Mode.Index.Value; // create the context and share it with the share reference. Handle = new ContextHandle(Agl.aglCreateContext(myAGLPixelFormat, shareContextRef)); MyAGLReportError("aglCreateContext"); // Free the pixel format from memory. Agl.aglDestroyPixelFormat(myAGLPixelFormat); MyAGLReportError("aglDestroyPixelFormat"); Debug.Print("IsControl: {0}", carbonWindow.IsControl); SetDrawable(carbonWindow); SetBufferRect(carbonWindow); Update(carbonWindow); MakeCurrent(carbonWindow); Debug.Print("context: {0}", Handle.Handle); }
/// <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) { 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 = FindSharedContext(); // Todo: Add a DummyFactory implementing IPlatformFactory. if (designMode) { implementation = Factory.Embedded.CreateGLContext(mode, window, shareContext, direct_rendering, major, minor, flags); GetCurrentContext = Factory.Embedded.CreateGetCurrentGraphicsContext(); } else { Factory factory = null; GetCurrentContext = null; switch ((flags & GraphicsContextFlags.Embedded) == GraphicsContextFlags.Embedded) { case false: factory = Factory.Default; break; case true: factory = 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, direct_rendering, major, minor, flags); } available_contexts.Add((this as IGraphicsContextInternal).Context, new WeakReference(this)); } finally { // Debug.Unindent(); } } }
public NativeWindow(GraphicsMode mode, WindowOptions options) { if (options.ScreenMode == ScreenMode.Native && DisplayDevice.Default != null) { options.Width = DisplayDevice.Default.Width; options.Height = DisplayDevice.Default.Height; } GameWindowFlags windowFlags = GameWindowFlags.Default; if (options.ScreenMode == ScreenMode.FixedWindow) { windowFlags = GameWindowFlags.FixedWindow; } else if (options.ScreenMode == ScreenMode.Fullscreen || options.ScreenMode == ScreenMode.Native) { windowFlags = GameWindowFlags.Fullscreen; } this.refreshMode = options.RefreshMode; this.internalWindow = new InternalWindow( this, options.Width, options.Height, mode, options.Title, windowFlags); this.internalWindow.MakeCurrent(); this.internalWindow.CursorVisible = true; if (!options.SystemCursorVisible) { this.internalWindow.Cursor = MouseCursor.Empty; } this.internalWindow.VSync = (options.RefreshMode != RefreshMode.VSync) ? VSyncMode.Off : VSyncMode.On; Log.Core.Write( "Window Specification: " + Environment.NewLine + "Buffers: {0}" + Environment.NewLine + "Samples: {1}" + Environment.NewLine + "ColorFormat: {2}" + Environment.NewLine + "AccumulatorFormat: {3}" + Environment.NewLine + "Depth: {4}" + Environment.NewLine + "Stencil: {5}" + Environment.NewLine + "VSync: {6}" + Environment.NewLine + "SwapInterval: {7}", this.internalWindow.Context.GraphicsMode.Buffers, this.internalWindow.Context.GraphicsMode.Samples, this.internalWindow.Context.GraphicsMode.ColorFormat, this.internalWindow.Context.GraphicsMode.AccumulatorFormat, this.internalWindow.Context.GraphicsMode.Depth, this.internalWindow.Context.GraphicsMode.Stencil, this.internalWindow.VSync, this.internalWindow.Context.SwapInterval); // Retrieve icon from executable file and set it as window icon string executablePath = null; try { Assembly entryAssembly = Assembly.GetEntryAssembly(); if (entryAssembly != null) { executablePath = Path.GetFullPath(entryAssembly.Location); if (File.Exists(executablePath)) { this.internalWindow.Icon = Icon.ExtractAssociatedIcon(executablePath); } } } // As described in issue 301 (https://github.com/AdamsLair/duality/issues/301), the // icon extraction can fail with an exception under certain circumstances. Don't fail // just because of an icon. Log the error and continue. catch (Exception e) { Log.Core.WriteError( "There was an exception while trying to extract the " + "window icon from the game's main executable '{0}'. This is " + "uncritical, but still an error: {1}", executablePath, Log.Exception(e)); } if (options.ScreenMode == ScreenMode.FullWindow) { this.internalWindow.WindowState = WindowState.Fullscreen; } DualityApp.TargetResolution = new Vector2(this.internalWindow.ClientSize.Width, this.internalWindow.ClientSize.Height); // Register events and input this.HookIntoDuality(); // Determine OpenGL capabilities and log them GraphicsBackend.LogOpenGLSpecs(); }
public void CreateWithParams(GraphicsMode mode, int major, int minor, GraphicsContextFlags flags) { WinFormsControl = new WinGLUserControl(mode, major, minor, flags); Control.Focusable = true; Control.Background = System.Windows.SystemColors.ControlBrush; }
public InternalWindow(NativeWindow parent, int w, int h, GraphicsMode mode, string title, GameWindowFlags flags) : base(w, h, mode, title, flags) { this.parent = parent; }
// NOTE: Only works with Compiler x64, NativeWindow runs but freezes on x86. public DemoWindow(int width, int height, GraphicsMode gm) //: base (width, height, GraphicsMode.Default, "MonoNanoGUI Demo Window", GameWindowFlags.Default, DisplayDevice.Default, 3, 3, GraphicsContextFlags.ForwardCompatible) : base(width, height, gm, "MonoNanoGUI Demo Window") { }
public EglWinContext(GraphicsMode mode, EglWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) : base(mode, window, sharedContext, major, minor, flags) { }
public static byte[][] GenerateGBAImage(Bitmap bitmap, GraphicsMode mode) { byte[][] result; Bitmap quantazised; BitmapData bmp; switch (mode) { case GraphicsMode.Tile8bit: result = new byte[3][]; quantazised = Quantazase(bitmap); result[0] = ToTile8bit(bitmap, quantazised.Palette.Entries); result[1] = toRawGBAPalette(quantazised.Palette.Entries); //yes, I'm lazy result[2] = new byte[result[0].Length * 2]; fixed (byte* temp = &result[2][0]) { short* pointer = (short*)temp; int tiles = 0; for (int i = 0; i < result[0].Length; i++) { pointer[i] = (short)tiles++; } } break; case GraphicsMode.Tile4bit: result = new byte[3][]; quantazised = Quantazase(bitmap); result[0] = ToTile4bit(bitmap, quantazised.Palette.Entries); result[1] = toRawGBAPalette(quantazised.Palette.Entries); //yes, I'm lazy result[2] = new byte[result[0].Length * 2]; fixed (byte* temp = &result[2][0]) { short* pointer = (short*)temp; int tiles = 0; for (int i = 0; i < result[0].Length; i++) { pointer[i] = (short)tiles++; } } break; default: throw new ArgumentException(); } return result; }
/// <summary>Constructs a new GLWidget using a given GraphicsMode</summary> public GLWidget(GraphicsMode graphicsMode) : this(graphicsMode, 1, 0, GraphicsContextFlags.Default) { }
public static Bitmap ToBitmap(byte[] GBAGraphics, int length, int index, Color[] palette, int width, GraphicsMode mode, out int emptyGraphicBlocks) { fixed (byte* pointer = &GBAGraphics[index]) { return ToBitmap(pointer, length, palette, width, mode, out emptyGraphicBlocks); } }
/// <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; } } GraphicsMode graphicsMode = new GraphicsMode(); if (Configuration.RunningOnWindows) { Debug.WriteLine("OpenTK running on windows"); } else if (Configuration.RunningOnMacOS) { Debug.WriteLine("OpenTK running on OSX"); } else { Debug.WriteLine("OpenTK running on X11"); } IntPtr widgetWindowHandle = Window.Handle; // IWindowInfo if (Configuration.RunningOnWindows) { _WindowInfo = Utilities.CreateWindowsWindowInfo(widgetWindowHandle); } else if (Configuration.RunningOnMacOS) { _WindowInfo = Utilities.CreateMacOSWindowInfo(widgetWindowHandle); } else { _WindowInfo = X11.XWindowInfoInitializer.Initialize(graphicsMode, this.Display.Handle, this.Screen.Display.NMonitors, 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 IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return(default_implementation.CreateGLContext(mode, window, shareContext, directRendering, major, minor, flags)); }
protected void ChildCtorOnlyResetGraphicMode(GraphicsMode mode) { this.format = mode; }
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; }
/// <summary> /// Constructs a new GLControl with the specified GraphicsMode. /// </summary> /// <param name="mode">The OpenTK.Graphics.GraphicsMode of the control.</param> public GLControl(GraphicsMode mode) : this(mode, 1, 0, GraphicsContextFlags.Default) { }
public INativeWindow CreateNativeWindow(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { return default_implementation.CreateNativeWindow(x, y, width, height, title, mode, options, device); }
/// <summary>Initializes the default values of the screen.</summary> internal static void Initialize() { //Initialize the values used by the renderer Program.Renderer.Screen.Width = Interface.CurrentOptions.FullscreenMode ? Interface.CurrentOptions.FullscreenWidth : Interface.CurrentOptions.WindowWidth; Program.Renderer.Screen.Height = Interface.CurrentOptions.FullscreenMode ? Interface.CurrentOptions.FullscreenHeight : Interface.CurrentOptions.WindowHeight; Program.Renderer.Screen.Fullscreen = Interface.CurrentOptions.FullscreenMode; //Set a new graphics mode, using 8 bits for R,G,B,A & a 8 bit stencil buffer (Currently unused) GraphicsMode currentGraphicsMode = new GraphicsMode(new ColorFormat(8, 8, 8, 8), 24, 8, Interface.CurrentOptions.AntiAliasingLevel); if (Interface.CurrentOptions.FullscreenMode) { IList <DisplayResolution> resolutions = OpenTK.DisplayDevice.Default.AvailableResolutions; bool resolutionFound = false; foreach (DisplayResolution currentResolution in resolutions) { //Test resolution if (currentResolution.Width == Interface.CurrentOptions.FullscreenWidth && currentResolution.Height == Interface.CurrentOptions.FullscreenHeight && currentResolution.BitsPerPixel == Interface.CurrentOptions.FullscreenBits) { try { OpenTK.DisplayDevice.Default.ChangeResolution(currentResolution); Program.currentGameWindow = new OpenBVEGame(currentResolution.Width, currentResolution.Height, currentGraphicsMode, GameWindowFlags.Default) { Visible = true, WindowState = WindowState.Fullscreen, }; resolutionFound = true; break; } catch { //A candidate resolution was found, but we failed to switch to it //Carry on enumerating through the rest of the resolutions, in case one with //a different refresh rate but identical properties works resolutionFound = false; } } } if (resolutionFound == false) { //Our resolution was not found at all MessageBox.Show( "The graphics card driver reported that the selected resolution was not supported:" + Environment.NewLine + Interface.CurrentOptions.FullscreenWidth + " x " + Interface.CurrentOptions.FullscreenHeight + " " + Interface.CurrentOptions.FullscreenBits + "bit color" + Environment.NewLine + "Please check your resolution settings.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Hand); Program.RestartArguments = " "; return; } } else { try { Program.currentGameWindow = new OpenBVEGame(Interface.CurrentOptions.WindowWidth, Interface.CurrentOptions.WindowHeight, currentGraphicsMode, GameWindowFlags.Default) { Visible = true }; } catch { //Windowed mode failed to launch MessageBox.Show("An error occured whilst tring to launch in windowed mode at resolution:" + Environment.NewLine + Interface.CurrentOptions.WindowWidth + " x " + Interface.CurrentOptions.WindowHeight + " " + Environment.NewLine + "Please check your resolution settings.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Hand); Program.RestartArguments = " "; return; } } if (Program.currentGameWindow == null) { //We should never really get an unspecified error here, but it's good manners to handle all cases MessageBox.Show("An unspecified error occured whilst attempting to launch the graphics subsystem.", Application.ProductName, MessageBoxButtons.OK, MessageBoxIcon.Hand); Program.RestartArguments = " "; return; } Program.currentGameWindow.TargetUpdateFrequency = 0; Program.currentGameWindow.TargetRenderFrequency = 0; Program.currentGameWindow.VSync = Interface.CurrentOptions.VerticalSynchronization ? VSyncMode.On : VSyncMode.Off; }
void CreateContext(GraphicsMode mode, IWindowInfo carbonWindow, IntPtr shareContextRef, bool fullscreen) { Debug.Print("AGL pixel format attributes:"); // Choose a pixel format with the attributes we specified. AGLPixelFormat pixelformat; AglGraphicsMode selector = new AglGraphicsMode(); Mode = selector.SelectGraphicsMode( mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples, mode.AccumulatorFormat, mode.Buffers, mode.Stereo, out pixelformat); MyAGLReportError("aglChoosePixelFormat"); Debug.Print("Creating AGL context. Sharing with {0}", shareContextRef); // create the context and share it with the share reference. Handle = new ContextHandle(Agl.aglCreateContext(pixelformat, shareContextRef)); MyAGLReportError("aglCreateContext"); // Free the pixel format from memory. Agl.aglDestroyPixelFormat(pixelformat); MyAGLReportError("aglDestroyPixelFormat"); SetDrawable(carbonWindow); SetBufferRect(carbonWindow); Update(carbonWindow); MakeCurrent(carbonWindow); Debug.Print("context: {0}", Handle.Handle); dummyContext = new GraphicsContext(Handle, GetAddress, delegate() { return new ContextHandle(Agl.aglGetCurrentContext()); }); }
public NativeWindow(GraphicsMode mode, WindowOptions options) { if (options.ScreenMode == ScreenMode.Fullscreen || options.ScreenMode == ScreenMode.FullWindow) { if (DisplayDevice.Default != null) { options.Size = new Point2( DisplayDevice.Default.Width, DisplayDevice.Default.Height); } } GameWindowFlags windowFlags = GameWindowFlags.Default; if (options.ScreenMode == ScreenMode.FixedWindow) { windowFlags = GameWindowFlags.FixedWindow; } else if (options.ScreenMode == ScreenMode.Fullscreen) { windowFlags = GameWindowFlags.Fullscreen; } VSyncMode vsyncMode; switch (options.RefreshMode) { default: case RefreshMode.NoSync: case RefreshMode.ManualSync: vsyncMode = VSyncMode.Off; break; case RefreshMode.VSync: vsyncMode = VSyncMode.On; break; case RefreshMode.AdaptiveVSync: vsyncMode = VSyncMode.Adaptive; break; } this.refreshMode = options.RefreshMode; this.internalWindow = new InternalWindow( this, options.Size.X, options.Size.Y, mode, options.Title, windowFlags); this.internalWindow.MakeCurrent(); this.internalWindow.CursorVisible = true; if (!options.SystemCursorVisible) { this.internalWindow.Cursor = MouseCursor.Empty; } this.internalWindow.VSync = vsyncMode; // Log some general info on the graphics context we've set up GraphicsBackend.LogOpenGLContextSpecs(this.internalWindow.Context); // Retrieve icon from executable file and set it as window icon string executablePath = null; try { Assembly entryAssembly = Assembly.GetEntryAssembly(); if (entryAssembly != null) { executablePath = Path.GetFullPath(entryAssembly.Location); if (File.Exists(executablePath)) { this.internalWindow.Icon = Icon.ExtractAssociatedIcon(executablePath); } } } // As described in issue 301 (https://github.com/AdamsLair/duality/issues/301), the // icon extraction can fail with an exception under certain circumstances. Don't fail // just because of an icon. Log the error and continue. catch (Exception e) { Logs.Core.WriteWarning( "There was an exception while trying to extract the " + "window icon from the game's main executable '{0}'. This is " + "uncritical, but still means something went wrong: {1}", executablePath, LogFormat.Exception(e)); } if (options.ScreenMode == ScreenMode.FullWindow) { this.internalWindow.WindowState = WindowState.Fullscreen; } DualityApp.WindowSize = new Point2(this.internalWindow.ClientSize.Width, this.internalWindow.ClientSize.Height); // Register events and input this.HookIntoDuality(); // Let's see what rendering features we have available GraphicsBackend.ActiveInstance.QueryOpenGLCapabilities(); }
/// <summary>Draw the slider ticks</summary> private void DrawTicks(Graphics g, Rectangle bounds) { Rectangle trackRect = GetTrackRectangle(); float increment = (float)Increment(); increment = (float)Increment(); int count = (int)(IncrementScale()); float endcap = (Orientation == Orientation.Horizontal ? (float)trackRect.Right - (1 + ButtonSize.Width / 2) : (float)trackRect.Bottom - (1 + ButtonSize.Height / 2)); float offset = 0; int shadowlen = TickMaxLength - 1; int spacer = TickMaxLength + TickMinPadding; RectangleF buttonRect = GetButtonRectangle(); switch (TickType) { #region Composite Style case TickMode.Composite: { using (GraphicsMode md = new GraphicsMode(g, SmoothingMode.None)) { switch (TickStyle) { case TickStyle.Both: { if (Orientation == Orientation.Horizontal) { float top = buttonRect.Top - spacer; float bottom = buttonRect.Bottom + spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(val, top), new PointF(val, top + TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, top + 1), new PointF(val + 1, top + shadowlen)); g.DrawLine(pn2, new PointF(val, bottom), new PointF(val, bottom - TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, bottom), new PointF(val + 1, bottom - shadowlen)); } else { g.DrawLine(pn, new PointF(val, top), new PointF(val, top + 2)); g.DrawLine(pn, new PointF(val, bottom), new PointF(val, bottom - 2)); } } } } else { float left = buttonRect.Left - spacer; float right = buttonRect.Right + spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(left, val), new PointF(left + TickMaxLength, val)); g.DrawLine(pn3, new PointF(left + 1, val + 1), new PointF(left + shadowlen, val + 1)); g.DrawLine(pn2, new PointF(right, val), new PointF(right - TickMaxLength, val)); g.DrawLine(pn3, new PointF(right, val + 1), new PointF(right - shadowlen, val + 1)); } else { g.DrawLine(pn, new PointF(left, val), new PointF(left + 2, val)); g.DrawLine(pn, new PointF(right, val), new PointF(right - 2, val)); } } } } break; } case TickStyle.BottomRight: { if (Orientation == Orientation.Horizontal) { float bottom = buttonRect.Bottom + spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(val, bottom), new PointF(val, bottom - TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, bottom), new PointF(val + 1, bottom - shadowlen)); } else { g.DrawLine(pn, new PointF(val, bottom), new PointF(val, bottom - 2)); } } } } else { float right = buttonRect.Right + spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(right, val), new PointF(right - TickMaxLength, val)); g.DrawLine(pn3, new PointF(right, val + 1), new PointF(right - shadowlen, val + 1)); } else { g.DrawLine(pn, new PointF(right, val), new PointF(right - 2, val)); } } } } break; } case TickStyle.TopLeft: { if (Orientation == Orientation.Horizontal) { float top = buttonRect.Top - spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(val, top), new PointF(val, top + TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, top + 1), new PointF(val + 1, top + shadowlen)); } else { g.DrawLine(pn, new PointF(val, top), new PointF(val, top + 2)); } } } } else { float left = buttonRect.Left - spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(left, val), new PointF(left + TickMaxLength, val)); g.DrawLine(pn3, new PointF(left + 1, val + 1), new PointF(left + shadowlen, val + 1)); } else { g.DrawLine(pn, new PointF(left, val), new PointF(left + 2, val)); } } } } break; } } } break; } #endregion #region Large Stepped Style case TickMode.LargeStepped: { using (GraphicsMode md = new GraphicsMode(g, SmoothingMode.None)) { switch (TickStyle) { case TickStyle.Both: { if (Orientation == Orientation.Horizontal) { float top = buttonRect.Top - spacer; float bottom = buttonRect.Bottom + spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { if (Mod(i, LargeChange)) { val = (increment * i) + offset; g.DrawLine(pn2, new PointF(val, top), new PointF(val, top + TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, top + 1), new PointF(val + 1, top + shadowlen)); g.DrawLine(pn2, new PointF(val, bottom), new PointF(val, bottom - TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, bottom), new PointF(val + 1, bottom - shadowlen)); } } } } else { float left = buttonRect.Left - spacer; float right = buttonRect.Right + spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { if (Mod(i, LargeChange)) { val = (increment * i) + offset; g.DrawLine(pn2, new PointF(left, val), new PointF(left + TickMaxLength, val)); g.DrawLine(pn3, new PointF(left + 1, val + 1), new PointF(left + shadowlen, val + 1)); g.DrawLine(pn2, new PointF(right, val), new PointF(right - TickMaxLength, val)); g.DrawLine(pn3, new PointF(right, val + 1), new PointF(right - shadowlen, val + 1)); } } } } break; } case TickStyle.BottomRight: { if (Orientation == Orientation.Horizontal) { float bottom = buttonRect.Bottom + spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { if (Mod(i, LargeChange)) { val = (increment * i) + offset; g.DrawLine(pn2, new PointF(val, bottom), new PointF(val, bottom - TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, bottom), new PointF(val + 1, bottom - shadowlen)); } } } } else { float right = buttonRect.Right + spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(right, val), new PointF(right - TickMaxLength, val)); g.DrawLine(pn3, new PointF(right, val + 1), new PointF(right - shadowlen, val + 1)); } } } } break; } case TickStyle.TopLeft: { if (Orientation == Orientation.Horizontal) { float top = buttonRect.Top - spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(val, top), new PointF(val, top + TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, top + 1), new PointF(val + 1, top + shadowlen)); } } } } else { float left = buttonRect.Left - spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(left, val), new PointF(left + TickMaxLength, val)); g.DrawLine(pn3, new PointF(left + 1, val + 1), new PointF(left + shadowlen, val + 1)); } } } } break; } } } break; } #endregion #region Precision Style case TickMode.Precision: { using (GraphicsMode md = new GraphicsMode(g, SmoothingMode.None)) { float split = increment * .5f; bool valid = split > 2; switch (TickStyle) { case TickStyle.Both: { if (Orientation == Orientation.Horizontal) { float top = buttonRect.Top - spacer; float bottom = buttonRect.Bottom + spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(val, top), new PointF(val, top + TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, top + 1), new PointF(val + 1, top + shadowlen)); g.DrawLine(pn2, new PointF(val, bottom), new PointF(val, bottom - TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, bottom), new PointF(val + 1, bottom - shadowlen)); if (valid && val < endcap) { g.DrawLine(pn, new PointF(val + split, top), new PointF(val + split, top + 1)); g.DrawLine(pn, new PointF(val + split, bottom), new PointF(val + split, bottom - 1)); } } else { g.DrawLine(pn, new PointF(val, top), new PointF(val, top + 2)); g.DrawLine(pn, new PointF(val, bottom), new PointF(val, bottom - 2)); if (valid && val < endcap) { g.DrawLine(pn, new PointF(val + split, top), new PointF(val + split, top + 1)); g.DrawLine(pn, new PointF(val + split, bottom), new PointF(val + split, bottom - 1)); } } } } } else { float left = buttonRect.Left - spacer; float right = buttonRect.Right + spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(left, val), new PointF(left + TickMaxLength, val)); g.DrawLine(pn3, new PointF(left + 1, val + 1), new PointF(left + shadowlen, val + 1)); g.DrawLine(pn2, new PointF(right, val), new PointF(right - TickMaxLength, val)); g.DrawLine(pn3, new PointF(right, val + 1), new PointF(right - shadowlen, val + 1)); if (valid && val < endcap) { g.DrawLine(pn, new PointF(left, val + split), new PointF(left + 1, val + split)); g.DrawLine(pn, new PointF(right, val + split), new PointF(right - 1, val + split)); } } else { g.DrawLine(pn, new PointF(left, val), new PointF(left + 2, val)); g.DrawLine(pn, new PointF(right, val), new PointF(right - 2, val)); if (valid && val < endcap) { g.DrawLine(pn, new PointF(left, val + split), new PointF(left + 1, val + split)); g.DrawLine(pn, new PointF(right, val + split), new PointF(right - 1, val + split)); } } } } } break; } case TickStyle.BottomRight: { if (Orientation == Orientation.Horizontal) { float bottom = buttonRect.Bottom + spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(val, bottom), new PointF(val, bottom - TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, bottom), new PointF(val + 1, bottom - shadowlen)); if (valid && val < endcap) g.DrawLine(pn, new PointF(val + split, bottom), new PointF(val + split, bottom - 1)); } else { g.DrawLine(pn, new PointF(val, bottom), new PointF(val, bottom - 2)); if (valid && val < endcap) g.DrawLine(pn, new PointF(val + split, bottom), new PointF(val + split, bottom - 1)); } } } } else { float right = buttonRect.Right + spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(right, val), new PointF(right - TickMaxLength, val)); g.DrawLine(pn3, new PointF(right, val + 1), new PointF(right - shadowlen, val + 1)); if (valid && val < endcap) g.DrawLine(pn, new PointF(right, val + split), new PointF(right - 2, val + split)); } else { g.DrawLine(pn, new PointF(right, val), new PointF(right - 2, val)); if (valid && val < endcap) g.DrawLine(pn, new PointF(right, val + split), new PointF(right - 2, val + split)); } } } } break; } case TickStyle.TopLeft: { if (Orientation == Orientation.Horizontal) { float top = buttonRect.Top - spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(val, top), new PointF(val, top + TickMaxLength)); g.DrawLine(pn3, new PointF(val + 1, top + 1), new PointF(val + 1, top + shadowlen)); if (valid && val < endcap) g.DrawLine(pn, new PointF(val + split, top), new PointF(val + split, top + 1)); } else { g.DrawLine(pn, new PointF(val, top), new PointF(val, top + 2)); if (valid && val < endcap) g.DrawLine(pn, new PointF(val + split, top), new PointF(val + split, top + 1)); } } } } else { float left = buttonRect.Left - spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; if (Mod(i, LargeChange)) { g.DrawLine(pn2, new PointF(left, val), new PointF(left + TickMaxLength, val)); g.DrawLine(pn3, new PointF(left + 1, val + 1), new PointF(left + shadowlen, val + 1)); if (valid && val < endcap) g.DrawLine(pn, new PointF(left, val + split), new PointF(left + 2, val + split)); } else { g.DrawLine(pn, new PointF(left, val), new PointF(left + 2, val)); if (valid && val < endcap) g.DrawLine(pn, new PointF(left, val + split), new PointF(left + 2, val + split)); } } } } break; } } } break; } #endregion #region Standard Tick Style case TickMode.Standard: { using (GraphicsMode md = new GraphicsMode(g, SmoothingMode.None)) { switch (TickStyle) { case TickStyle.Both: { if (Orientation == Orientation.Horizontal) { float top = buttonRect.Top - spacer; float bottom = buttonRect.Bottom + spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; g.DrawLine(pn, new PointF(val, top), new PointF(val, top + 2)); g.DrawLine(pn, new PointF(val, bottom), new PointF(val, bottom - 2)); } } } else { float left = buttonRect.Left - spacer; float right = buttonRect.Right + spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; g.DrawLine(pn, new PointF(left, val), new PointF(left + 2, val)); g.DrawLine(pn, new PointF(right, val), new PointF(right - 2, val)); } } } break; } case TickStyle.BottomRight: { if (Orientation == Orientation.Horizontal) { float bottom = buttonRect.Bottom + spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; g.DrawLine(pn, new PointF(val, bottom), new PointF(val, bottom - 2)); } } } else { float right = buttonRect.Right + spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; g.DrawLine(pn, new PointF(right, val), new PointF(right - 2, val)); } } } break; } case TickStyle.TopLeft: { if (Orientation == Orientation.Horizontal) { float top = buttonRect.Top - spacer; offset = (ButtonSize.Width / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; g.DrawLine(pn, new PointF(val, top), new PointF(val, top + 2)); } } } else { float left = buttonRect.Left - spacer; offset = (ButtonSize.Height / 2) + TrackPadding; float val = offset; using (Pen pn = new Pen(TickColor, .5f), pn2 = new Pen(TickColor, 1f), pn3 = new Pen(Color.FromArgb(100, Color.DarkGray), 1f)) { for (int i = 0; i < count + 1; i++) { val = (increment * i) + offset; g.DrawLine(pn, new PointF(left, val), new PointF(left + 2, val)); } } } break; } } } break; } #endregion } }
public GLSurface(GraphicsMode graphicsMode) : this(graphicsMode, 1, 0, GraphicsContextFlags.Default) { }
public override IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { throw new PlatformNotSupportedException(error_string); }
public GLSurface(GraphicsMode mode, int major, int minor, GraphicsContextFlags flags) { Handler.CreateWithParams(mode, major, minor, flags); Initialize(); }
public static int BitsPerPixel(GraphicsMode mode) { switch (mode) { case GraphicsMode.Tile8bit: return 8; case GraphicsMode.Tile4bit: return 4; case GraphicsMode.BitmapTrueColour: return 16; case GraphicsMode.Bitmap8bit: return 8; default: return 0; } }
/// <summary> /// Try to create the graphics context. /// </summary> /// <param name="requestedWidth">The requested width.</param> /// <param name="requestedHeight">The requested height.</param> /// <param name="graphicMode">The graphics mode.</param> /// <param name="versionMajor">The major version of OpenGL.</param> /// <param name="versionMinor">The minor version of OpenGL.</param> /// <param name="creationFlags">The creation flags.</param> /// <returns>The created GameWindow.</returns> private static OpenTK.GameWindow TryGameWindow(int requestedWidth, int requestedHeight, GraphicsMode graphicMode, int versionMajor, int versionMinor, GraphicsContextFlags creationFlags) { try { #if SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGL || SILICONSTUDIO_XENKO_GRAPHICS_API_OPENGLES // Preload proper SDL native library (depending on CPU type) // This is for OpenGL ES on desktop Core.NativeLibrary.PreloadLibrary("SDL2.dll"); #endif var gameWindow = new OpenTK.GameWindow(requestedWidth, requestedHeight, graphicMode, GameContext.ProductName, GameWindowFlags.Default, DisplayDevice.Default, versionMajor, versionMinor, creationFlags); return(gameWindow); } catch (Exception) { return(null); } }
public static int RawGraphicsLength(Size size, GraphicsMode mode) { return size.Width * size.Height * BitsPerPixel(mode) / 8; }
public override INativeWindow CreateNativeWindow(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { return((INativeWindow)_platform_factory.CreateNativeWindow(x, y, width, height, title, mode, options, device)); }
public static Bitmap ToBitmap(byte* GBAGraphics, int length, Color[] palette, int width, GraphicsMode mode, out int emptyGraphicBlocks) { Bitmap result = null; emptyGraphicBlocks = 0; switch (mode) { case GraphicsMode.Tile8bit: result = FromTile8bit(GBAGraphics, length, palette, width, out emptyGraphicBlocks); break; case GraphicsMode.Tile4bit: result = FromTile4bit(GBAGraphics, length, palette, width, out emptyGraphicBlocks); break; case GraphicsMode.BitmapTrueColour: result = FromBitmapTrueColour(GBAGraphics, length, palette, width, out emptyGraphicBlocks); break; case GraphicsMode.Bitmap8bit: result = FromBitmapIndexed(GBAGraphics, length, palette, width, out emptyGraphicBlocks); break; } return result; }
public virtual INativeWindow CreateNativeWindow(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { return(new X11GLNative(x, y, width, height, title, mode, options, device)); }
/// <summary> /// /// </summary> /// <param name="graphics"></param> /// <param name="mode"></param> /// <param name="TSAdata"></param> /// <param name="offset"></param> /// <param name="TSAsize"></param> /// <returns>Tile8bit raw GBA graphics</returns> public static byte[] TSAmap(byte[] graphics, GraphicsMode mode, byte[] TSAdata, int offset, Size TSAsize) { byte[] result; if (TSAsize.Height * TSAsize.Width > TSAdata.Length / 2) { TSAsize.Height = TSAdata.Length / (2 * TSAsize.Width); } fixed (byte* graphicsPointer = &graphics[0]) { fixed (byte* TSApointer = &TSAdata[offset]) { switch (mode) { case GraphicsMode.Tile8bit: result = TSAmapFrom8bitTileGraphics(graphicsPointer, graphics.Length / 64, TSApointer, TSAsize); break; case GraphicsMode.Tile4bit: result = TSAmapFrom4bitTileGraphics(graphicsPointer, graphics.Length / 32, TSApointer, TSAsize); break; default: throw new ArgumentException("GraphicsMode has to be either Tile8bit or Tile4bit"); } } } return result; }
public virtual IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return(new X11GLContext(mode, window, shareContext, directRendering, major, minor, flags)); }
public static extern GraphicsMode SetGraphicsMode(IntPtr hdc, GraphicsMode iMode);
void CreateContext(GraphicsMode mode, CarbonWindowInfo carbonWindow, IntPtr shareContextRef, bool fullscreen) { List<int> aglAttributes = new List<int>(); Debug.Print("AGL pixel format attributes:"); Debug.Indent(); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_RGBA); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_DOUBLEBUFFER); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_RED_SIZE, mode.ColorFormat.Red); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_GREEN_SIZE, mode.ColorFormat.Green); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_BLUE_SIZE, mode.ColorFormat.Blue); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ALPHA_SIZE, mode.ColorFormat.Alpha); if (mode.Depth > 0) AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_DEPTH_SIZE, mode.Depth); if (mode.Stencil > 0) AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_STENCIL_SIZE, mode.Stencil); if (mode.AccumulatorFormat.BitsPerPixel > 0) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_RED_SIZE, mode.AccumulatorFormat.Red); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_GREEN_SIZE, mode.AccumulatorFormat.Green); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_BLUE_SIZE, mode.AccumulatorFormat.Blue); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_ALPHA_SIZE, mode.AccumulatorFormat.Alpha); } if (mode.Samples > 1) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_SAMPLE_BUFFERS_ARB, 1); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_SAMPLES_ARB, mode.Samples); } if (fullscreen) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_FULLSCREEN); } AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_NONE); Debug.Unindent(); Debug.Write("Attribute array: "); for (int i = 0; i < aglAttributes.Count; i++) Debug.Write(aglAttributes[i].ToString() + " "); Debug.WriteLine(""); AGLPixelFormat myAGLPixelFormat; // Choose a pixel format with the attributes we specified. if (fullscreen) { IntPtr gdevice; IntPtr cgdevice = GetQuartzDevice(carbonWindow); if (cgdevice == IntPtr.Zero) cgdevice = (IntPtr)DisplayDevice.Default.Id; OSStatus status = Carbon.API.DMGetGDeviceByDisplayID(cgdevice, out gdevice, false); if (status != OSStatus.NoError) throw new MacOSException(status, "DMGetGDeviceByDisplayID failed."); myAGLPixelFormat = Agl.aglChoosePixelFormat(ref gdevice, 1, aglAttributes.ToArray()); Agl.AglError err = Agl.GetError(); if (err == Agl.AglError.BadPixelFormat) { Debug.Print("Failed to create full screen pixel format."); Debug.Print("Trying again to create a non-fullscreen pixel format."); CreateContext(mode, carbonWindow, shareContextRef, false); return; } } else { myAGLPixelFormat = Agl.aglChoosePixelFormat(IntPtr.Zero, 0, aglAttributes.ToArray()); MyAGLReportError("aglChoosePixelFormat"); } Debug.Print("Creating AGL context. Sharing with {0}", shareContextRef); // create the context and share it with the share reference. Handle = new ContextHandle(Agl.aglCreateContext(myAGLPixelFormat, shareContextRef)); MyAGLReportError("aglCreateContext"); // Free the pixel format from memory. Agl.aglDestroyPixelFormat(myAGLPixelFormat); MyAGLReportError("aglDestroyPixelFormat"); Debug.Print("IsControl: {0}", carbonWindow.IsControl); SetDrawable(carbonWindow); SetBufferRect(carbonWindow); Update(carbonWindow); MakeCurrent(carbonWindow); Debug.Print("context: {0}", Handle.Handle); }
private IntPtr SelectPixelFormat(GraphicsMode mode, int majorVersion, int minorVersion) { List <NSOpenGLPixelFormatAttribute> attributes = new List <NSOpenGLPixelFormatAttribute>(); var profile = NSOpenGLProfile.VersionLegacy; if (majorVersion > 3 || (majorVersion == 3 && minorVersion >= 2)) { profile = NSOpenGLProfile.Version3_2Core; Debug.Print("Running the OpenGL core profile."); } else { Debug.Print("Running the legacy OpenGL profile. Start with version major=3, minor=2 or later for the 3.2 profile."); } Debug.Print("NSGL pixel format attributes:"); Debug.Indent(); AddPixelAttrib(attributes, NSOpenGLPixelFormatAttribute.OpenGLProfile, (int)profile); if (mode.ColorFormat.BitsPerPixel > 0) { AddPixelAttrib(attributes, NSOpenGLPixelFormatAttribute.ColorSize, mode.ColorFormat.BitsPerPixel); } if (mode.Depth > 0) { AddPixelAttrib(attributes, NSOpenGLPixelFormatAttribute.DepthSize, mode.Depth); } if (mode.Stencil > 0) { AddPixelAttrib(attributes, NSOpenGLPixelFormatAttribute.StencilSize, mode.Stencil); } if (mode.AccumulatorFormat.BitsPerPixel > 0) { AddPixelAttrib(attributes, NSOpenGLPixelFormatAttribute.AccumSize, mode.AccumulatorFormat.BitsPerPixel); } if (mode.Samples > 1) { AddPixelAttrib(attributes, NSOpenGLPixelFormatAttribute.SampleBuffers, 1); AddPixelAttrib(attributes, NSOpenGLPixelFormatAttribute.Samples, mode.Samples); } if (mode.Buffers > 1) { AddPixelAttrib(attributes, NSOpenGLPixelFormatAttribute.DoubleBuffer); } // If at least a single accelerated pixel format is available, // then use that. If no accelerated formats are available, fall // back to software rendering. if (IsAccelerationSupported()) { AddPixelAttrib(attributes, NSOpenGLPixelFormatAttribute.Accelerated); } AddPixelAttrib(attributes, (NSOpenGLPixelFormatAttribute)0); Debug.Unindent(); Debug.Write("Attribute array: "); for (int i = 0; i < attributes.Count; i++) { Debug.Write(attributes[i].ToString() + " "); } Debug.WriteLine(""); // Create pixel format var pixelFormat = Cocoa.SendIntPtr(Class.Get("NSOpenGLPixelFormat"), Selector.Alloc); unsafe { fixed(NSOpenGLPixelFormatAttribute *ptr = attributes.ToArray()) { pixelFormat = Cocoa.SendIntPtr(pixelFormat, Selector.Get("initWithAttributes:"), (IntPtr)ptr); } } return(pixelFormat); }
public INativeWindow CreateNativeWindow(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { return(default_implementation.CreateNativeWindow(x, y, width, height, title, mode, options, device)); }
public virtual IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return new X11GLContext(mode, window, shareContext, directRendering, major, minor, flags); }
public IGraphicsContext CreateESContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, int major, int minor, GraphicsContextFlags flags) { throw new PlatformNotSupportedException(error_string); }
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"); } // IWindowInfo if (Configuration.RunningOnWindows) { _WindowInfo = InitializeWindows(); } else if (Configuration.RunningOnMacOS) { _WindowInfo = InitializeOSX(); } else { _WindowInfo = InitializeX(graphicsMode); } // 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 IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext, bool directRendering, int major, int minor, GraphicsContextFlags flags) { return default_implementation.CreateGLContext(mode, window, shareContext, directRendering, major, minor, flags); }
/// <summary>Create the track dc</summary> private void CreateTrack() { Rectangle bounds = new Rectangle(0, 0, Width, Height); Rectangle trackRect = GetTrackRectangle(); using (Graphics g = Graphics.FromHdc(_cTrackDc.Hdc)) { // fill it in if (BackgroundImage != null) { using (GraphicsMode md = new GraphicsMode(g, SmoothingMode.HighQuality)) { using (ImageAttributes ia = new ImageAttributes()) g.DrawImage(BackgroundImage, bounds, 0, 0, BackgroundImage.Width, BackgroundImage.Height, GraphicsUnit.Pixel, ia); } } else { DrawBackGround(g, bounds); } // draw ticks if (TickStyle != TickStyle.None) DrawTicks(g, bounds); // create the path if (Orientation == Orientation.Horizontal)//***offsets wrong on createpath? trackRect.Width -= 1; else trackRect.Height -= 1; using (GraphicsMode mode = new GraphicsMode(g, SmoothingMode.HighQuality)) { // draw track shadow if (TrackShadow) { trackRect.Inflate(2, 2); using (GraphicsPath gp = CreateRoundRectanglePath(g, trackRect, 2)) { // light shadow using (Pen pn = new Pen(Color.FromArgb(80, TrackShadowColor), 1f)) g.DrawPath(pn, gp); } trackRect.Inflate(-1, -1); using (GraphicsPath gp = CreateRoundRectanglePath(g, trackRect, 2)) { // darker using (Pen pn = new Pen(Color.FromArgb(120, TrackShadowColor), 1f)) g.DrawPath(pn, gp); } trackRect.Inflate(-1, -1); } using (GraphicsPath gp = CreateRoundRectanglePath(g, trackRect, 2)) { // fill color if (TrackFillColor != Color.Transparent) { using (Brush br = new SolidBrush(TrackFillColor)) g.FillPath(br, gp); } // draw the outline using (Pen pn = new Pen(TrackBorderColor, 1f)) g.DrawPath(pn, gp); } } } }
public IGraphicsContext CreateGLContext(GraphicsMode mode, IWindowInfo window) { return new AglContext(mode, window); }
private void DrawFlyOut(Graphics g) { Rectangle buttonRect = GetButtonRectangle(); Rectangle flyoutRect; int pos; string data = ""; if (Orientation == Orientation.Horizontal) { pos = buttonRect.Left + (int)(buttonRect.Width * .5f); int offset = (int)(FlyOutMaxWidth * .5f); flyoutRect = new Rectangle(pos - offset, buttonRect.Top - (FlyOutMaxDepth + FlyOutSpacer), FlyOutMaxWidth, FlyOutMaxDepth); offset -= 8; using (GraphicsMode mode = new GraphicsMode(g, SmoothingMode.HighQuality)) { using (GraphicsPath gp = CreatePointedRectangularPath(g, flyoutRect, PointDirection.Bottom, 5, 4, offset)) { using (Brush br = new SolidBrush(Color.FromArgb(220, Color.White))) g.FillPath(br, gp); using (Pen pn = new Pen(Color.FromArgb(160, Color.DimGray))) g.DrawPath(pn, gp); if (FlyOutInfo != null) FlyOutInfo(ref data); if (data.Length == 0) data = Value.ToString("0"); using (StringFormat sf = new StringFormat()) { sf.FormatFlags = StringFormatFlags.NoWrap; sf.Alignment = StringAlignment.Center; sf.LineAlignment = StringAlignment.Center; using (Font ft = new Font("Arial", 8f, FontStyle.Regular)) g.DrawString(data, ft, Brushes.Black, flyoutRect, sf); } } } } else { pos = buttonRect.Top + (int)(buttonRect.Height * .5f); int offset = (int)(FlyOutMaxWidth * .5f); flyoutRect = new Rectangle(buttonRect.Left - (FlyOutMaxDepth + FlyOutSpacer), pos - offset, FlyOutMaxDepth, FlyOutMaxWidth); using (GraphicsMode mode = new GraphicsMode(g, SmoothingMode.HighQuality)) { using (GraphicsPath gp = CreatePointedRectangularPath(g, flyoutRect, PointDirection.Right, 5, 4, 1)) { using (Brush br = new SolidBrush(Color.FromArgb(200, Color.White))) g.FillPath(br, gp); using (Pen pn = new Pen(Color.FromArgb(240, ButtonBorderColor))) g.DrawPath(pn, gp); if (FlyOutInfo != null) FlyOutInfo(ref data); if (data.Length == 0) data = Value.ToString("0"); flyoutRect.Width -= 4; using (StringFormat sf = new StringFormat()) { sf.FormatFlags = StringFormatFlags.NoWrap; sf.Alignment = StringAlignment.Center; sf.LineAlignment = StringAlignment.Center; using (Font ft = new Font("Arial", 8f, FontStyle.Regular)) g.DrawString(data, ft, Brushes.Black, flyoutRect, sf); } } } } }
public void CreateWithParams(GraphicsMode mode, int major, int minor, GraphicsContextFlags flags) { Control = new MacGLView8(mode, major, minor, flags); Control.CanFocus = true; }
public WinGLContext(GraphicsMode format, WinWindowInfo window, IGraphicsContext sharedContext, int major, int minor, GraphicsContextFlags flags) { lock (WinGLContext.SyncRoot) { if (window == null) { throw new ArgumentNullException("window", "Must point to a valid window."); } if (window.WindowHandle == IntPtr.Zero) { throw new ArgumentException("window", "Must be a valid window."); } this.Mode = format; this.SetGraphicsModePFD(format, window); lock (WinGLContext.LoadLock) { if (!WinGLContext.wgl_loaded) { ContextHandle local_0 = new ContextHandle(Wgl.Imports.CreateContext(window.DeviceContext)); Wgl.Imports.MakeCurrent(window.DeviceContext, local_0.Handle); Wgl.LoadAll(); Wgl.Imports.MakeCurrent(IntPtr.Zero, IntPtr.Zero); Wgl.Imports.DeleteContext(local_0.Handle); WinGLContext.wgl_loaded = true; } if (Wgl.Delegates.wglCreateContextAttribsARB != null) { try { List <int> local_1 = new List <int>(); local_1.Add(8337); local_1.Add(major); local_1.Add(8338); local_1.Add(minor); if (flags != GraphicsContextFlags.Default) { local_1.Add(8340); local_1.Add((int)flags); } local_1.Add(0); local_1.Add(0); this.Handle = new ContextHandle(Wgl.Arb.CreateContextAttribs(window.DeviceContext, sharedContext != null ? (sharedContext as IGraphicsContextInternal).Context.Handle : IntPtr.Zero, local_1.ToArray())); int temp_84 = this.Handle == ContextHandle.Zero ? 1 : 0; } catch (EntryPointNotFoundException exception_0) { } catch (NullReferenceException exception_1) { } } } if (this.Handle == ContextHandle.Zero) { this.Handle = new ContextHandle(Wgl.Imports.CreateContext(window.DeviceContext)); if (this.Handle == ContextHandle.Zero) { this.Handle = new ContextHandle(Wgl.Imports.CreateContext(window.DeviceContext)); } if (this.Handle == ContextHandle.Zero) { throw new GraphicsContextException(string.Format("Context creation failed. Wgl.CreateContext() error: {0}.", (object)Marshal.GetLastWin32Error())); } } if (sharedContext == null) { return; } Marshal.GetLastWin32Error(); Wgl.Imports.ShareLists((sharedContext as IGraphicsContextInternal).Context.Handle, this.Handle.Handle); } }
public virtual INativeWindow CreateNativeWindow(int x, int y, int width, int height, string title, GraphicsMode mode, GameWindowFlags options, DisplayDevice device) { return new X11GLNative(x, y, width, height, title, mode, options, device); }
void CreateContext(GraphicsMode mode, CarbonWindowInfo carbonWindow, IntPtr shareContextRef, bool fullscreen) { List <int> aglAttributes = new List <int>(); Debug.Print("AGL pixel format attributes:"); Debug.Indent(); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_RGBA); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_DOUBLEBUFFER); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_RED_SIZE, mode.ColorFormat.Red); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_GREEN_SIZE, mode.ColorFormat.Green); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_BLUE_SIZE, mode.ColorFormat.Blue); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ALPHA_SIZE, mode.ColorFormat.Alpha); if (mode.Depth > 0) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_DEPTH_SIZE, mode.Depth); } if (mode.Stencil > 0) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_STENCIL_SIZE, mode.Stencil); } if (mode.AccumulatorFormat.BitsPerPixel > 0) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_RED_SIZE, mode.AccumulatorFormat.Red); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_GREEN_SIZE, mode.AccumulatorFormat.Green); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_BLUE_SIZE, mode.AccumulatorFormat.Blue); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_ALPHA_SIZE, mode.AccumulatorFormat.Alpha); } if (mode.Samples > 1) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_SAMPLE_BUFFERS_ARB, 1); AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_SAMPLES_ARB, mode.Samples); } if (fullscreen) { AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_FULLSCREEN); } AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_NONE); Debug.Unindent(); Debug.Write("Attribute array: "); for (int i = 0; i < aglAttributes.Count; i++) { Debug.Write(aglAttributes[i].ToString() + " "); } Debug.WriteLine(""); AGLPixelFormat myAGLPixelFormat; // Choose a pixel format with the attributes we specified. if (fullscreen) { IntPtr gdevice; IntPtr cgdevice = GetQuartzDevice(carbonWindow); if (cgdevice == IntPtr.Zero) { cgdevice = (IntPtr)DisplayDevice.Default.Id; } OSStatus status = Carbon.API.DMGetGDeviceByDisplayID(cgdevice, out gdevice, false); if (status != OSStatus.NoError) { throw new MacOSException(status, "DMGetGDeviceByDisplayID failed."); } myAGLPixelFormat = Agl.aglChoosePixelFormat(ref gdevice, 1, aglAttributes.ToArray()); Agl.AglError err = Agl.GetError(); if (err == Agl.AglError.BadPixelFormat) { Debug.Print("Failed to create full screen pixel format."); Debug.Print("Trying again to create a non-fullscreen pixel format."); CreateContext(mode, carbonWindow, shareContextRef, false); return; } } else { myAGLPixelFormat = Agl.aglChoosePixelFormat(IntPtr.Zero, 0, aglAttributes.ToArray()); MyAGLReportError("aglChoosePixelFormat"); } Debug.Print("Creating AGL context. Sharing with {0}", shareContextRef); // create the context and share it with the share reference. Handle = new ContextHandle(Agl.aglCreateContext(myAGLPixelFormat, shareContextRef)); MyAGLReportError("aglCreateContext"); // Free the pixel format from memory. Agl.aglDestroyPixelFormat(myAGLPixelFormat); MyAGLReportError("aglDestroyPixelFormat"); Debug.Print("IsControl: {0}", carbonWindow.IsControl); SetDrawable(carbonWindow); SetBufferRect(carbonWindow); Update(carbonWindow); MakeCurrent(carbonWindow); Debug.Print("context: {0}", Handle.Handle); }