internal Renderer(IWindow window, int index, RendererFlags flags, ILogger <Renderer> logger = null) { if (window == null) { throw new ArgumentNullException(nameof(window), "Window has not been initialized. You must first create a Window before creating a Renderer."); } if (index < -1) { throw new ArgumentOutOfRangeException(nameof(index)); } this.logger = logger; Window = window; Index = index; List <RendererFlags> copyFlags = new List <RendererFlags>(); foreach (RendererFlags flag in Enum.GetValues(typeof(RendererFlags))) { if (flags.HasFlag(flag)) { this.flags.Add(flag); } } IntPtr unsafeHandle = SDL.SDL_CreateRenderer(Window.Handle, Index, (SDL.SDL_RendererFlags)flags); if (unsafeHandle == IntPtr.Zero) { throw new InvalidOperationException(Utilities.GetErrorMessage("SDL_CreateRenderer")); } safeHandle = new SafeRendererHandle(unsafeHandle); }
public Renderer(Window window, int index, RendererFlags flags) { if (window == null) { throw new ArgumentNullException(Errors.E_WINDOW_NULL); } Window = window; Index = index; List <RendererFlags> copyFlags = new List <RendererFlags>(); foreach (RendererFlags flag in Enum.GetValues(typeof(RendererFlags))) { if (flags.HasFlag(flag)) { this.flags.Add(flag); } } Handle = SDL.SDL_CreateRenderer(Window.Handle, Index, (uint)flags); if (Handle == IntPtr.Zero) { throw new InvalidOperationException(Utilities.GetErrorMessage("SDL_CreateRenderer")); } }
Window BuildWindow() { ScreenRect wRect = new ScreenRect(Window.Center, Window.Center, 640, 480); WindowFlags wFlags = WindowFlags.Shown; RendererFlags rFlags = RendererFlags.Accelerated | RendererFlags.PresentVSync; return(new Window(windowID, "heng", wRect, wFlags, rFlags)); }
/// <summary> /// Use this function to create a 2D rendering context for a foreign window. /// </summary> /// <param name="windowHandle">The handle of the foreign window</param> /// <param name="index">The index of the rendering driver to initialize, or -1 to initialize the first one supporting the requested flags</param> /// <param name="flags">0, or one or more RendererFlags OR'd together</param> public Renderer(IntPtr windowHandle, int index, RendererFlags flags) { Index = index; Flags = flags; Handle = SDL.SDL_CreateRenderer(windowHandle, index, (uint)flags); if (IntPtr.Zero == Handle) { throw new Exception("Error while trying to create a renderer: " + SDL.SDL_GetError()); } }
public Renderer( Window window, int index = -1, RendererFlags flags = RendererFlags.None ) : this() { var rend = Create(window, index, flags); SetHandle(rend.handle); rend.SetHandle(IntPtr.Zero); }
/// <summary>Creates a SDL Renderer to copy and draw textures to a window /// </summary> /// <param name="index">Index of the renderering driver. -1 to choose the first available.</param> /// <param name="flags">Bit flags indicating the way in which the renderer should be created</param> protected void CreateRenderer(int index, RendererFlags flags) { if (Window == null) { throw new InvalidOperationException("Window has not been initialized. You must first create a Window before creating a Renderer."); } Renderer = new Renderer(this.Window, index, flags); SDL2.SDL.SDL_SetHint(SDL2.SDL.SDL_HINT_RENDER_SCALE_QUALITY, "linear"); }
public IRenderer CreateRenderer(IWindow window, int index, RendererFlags flags) { try { var renderer = new Renderer(window, index, flags, loggerRenderer); logger?.LogTrace($"Renderer created. Handle = {renderer.Handle}, Window Title = {window.Title}, Window Handle = {window.Handle}."); SDL2.SDL.SDL_SetHint(SDL2.SDL.SDL_HINT_RENDER_SCALE_QUALITY, "linear"); return(renderer); } catch (Exception ex) { logger?.LogError(ex, ex.Message); throw; } }
/// <summary> /// Constructs a new Window instance, based on an old instance. /// <para>The window's ID is always kept, but any other parameters set to null /// will carry settings over from the old instance.</para> /// </summary> /// <param name="old">The old instance upon which the new Window is based.</param> /// <param name="title">The title of the window.</param> /// <param name="rect">The dimensions of the window.</param> /// <param name="windowFlags">Configuration settings for the window.</param> /// <param name="rendererFlags">Configuration settings for the window's renderer.</param> public Window(Window old, string title = null, ScreenRect?rect = null, WindowFlags?windowFlags = null, RendererFlags?rendererFlags = null) { if (old != null) { ID = old.ID; Title = title ?? old.Title; Rect = rect ?? old.Rect; WindowFlags = windowFlags ?? old.WindowFlags; RendererFlags = rendererFlags ?? old.RendererFlags; } else { Log.Error("couldn't construct new Window: old Window is null"); } }
public Renderer(Window window, int index, RendererFlags flags) { Debug.Assert(window != null, Errors.E_WINDOW_NULL); Window = window; Index = index; List<RendererFlags> copyFlags = new List<RendererFlags>(); foreach (RendererFlags flag in Enum.GetValues(typeof(RendererFlags))) { if (flags.HasFlag(flag)) { this.flags.Add(flag); } } Handle = SDL.SDL_CreateRenderer(Window.Handle, Index, (uint)flags); if (Handle == IntPtr.Zero) { throw new Exception(Utilities.GetErrorMessage("SDL_CreateRenderer")); } }
/// <summary> /// Constructs a new Window instance. /// </summary> /// <param name="id">The unique ID of the window.</param> /// <param name="title">The title of the window.</param> /// <param name="rect">The dimensions of the window.</param> /// <param name="windowFlags">Configuration settings for the window.</param> /// <param name="rendererFlags">Configuration settings for the window's renderer.</param> public Window(int id, string title, ScreenRect rect, WindowFlags windowFlags, RendererFlags rendererFlags) { if (id > -1) { if (title == null) { Log.Warning("new Window has null title"); title = ""; } ID = id; Title = title; Rect = rect; WindowFlags = windowFlags; RendererFlags = rendererFlags; } else { Log.Error("couldn't construct new Window: ID is negative"); } }
public Renderer(GameWindow sdlWindow, int width, int height, RendererFlags flags = RendererFlags.None, RendererType type = RendererType.Default) { window = sdlWindow; // retrieve platform specific data and pass them to bgfx SDL.SDL_SysWMinfo wmi = window.GetPlatformWindowInfo(); PlatformData platformData = new PlatformData(); switch (wmi.subsystem) { case SDL.SDL_SYSWM_TYPE.SDL_SYSWM_WINDOWS: platformData.WindowHandle = wmi.info.win.window; break; case SDL.SDL_SYSWM_TYPE.SDL_SYSWM_X11: platformData.DisplayType = wmi.info.x11.display; platformData.WindowHandle = wmi.info.x11.window; break; case SDL.SDL_SYSWM_TYPE.SDL_SYSWM_COCOA: platformData.WindowHandle = wmi.info.cocoa.window; break; default: throw new ApplicationException("Failed to initialize renderer, unsupported platform detected"); } if (platformData.WindowHandle == IntPtr.Zero) { throw new ApplicationException("Failed to initialize renderer, invalid platform window handle"); } Bgfx.SetPlatformData(platformData); Bgfx.Init((RendererBackend)type); if (width * height <= 0) { Int2 windowSize = window.ClientSize; width = windowSize.x; height = windowSize.y; } Reset(width, height, flags); shaderPath = Path.Combine(Program.basePath, "Shaders"); switch (rendererType) { case RendererType.Direct3D11: shaderPath = Path.Combine(shaderPath, "dx11"); break; case RendererType.Direct3D9: shaderPath = Path.Combine(shaderPath, "dx9"); break; case RendererType.OpenGL: shaderPath = Path.Combine(shaderPath, "opengl"); break; default: throw new ApplicationException("No shader path defined for renderer " + rendererType.ToString()); } spriteRenderer = new SpriteRenderer(this, width, height); defaultProgram = new ShaderProgram( Path.Combine(shaderPath, "default_vs.bin"), Path.Combine(shaderPath, "default_fs.bin")); textureColor = new Uniform("s_texColor", UniformType.Int1); }
public void Reset(int width, int height, RendererFlags flags) { Bgfx.Reset(width, height, (ResetFlags)flags); }
/// <summary> /// Initializes the renderer with the specified properties. Use <see cref="GetDevices()"/> to get a device list for use with this function. /// </summary> /// <param name="parent">The device to use.</param> /// <param name="mode">The mode the renderer is created with.</param> /// <param name="flags">The flags defining the behaviour during rendering.</param> /// <param name="width">The width in pixel of the backbuffer.</param> /// <param name="height">The height in pixel of the backbuffer.</param> /// <param name="title">The title of the window.</param> public void Initialize(IRenderDevice parent, RendererMode mode, RendererFlags flags, int width, int height, string title) { if ((parent == null) || !(parent is Glfw3Device device)) { throw new ArgumentNullException("device"); } if (Window.Ptr != IntPtr.Zero) { throw new InvalidOperationException("Already initialized!"); } Resolution = new Vector2() { X = width, Y = height }; switch (mode) { case RendererMode.FullScreen: Window = glfw3.CreateWindow(width, height, title, device.Monitor); if (!Window.IsValid) { throw new Exception("No window available!"); } break; case RendererMode.WindowedFullScreen: { glfw3.WindowHint(glfw3.Hint.Decorated, false); Window = glfw3.CreateWindow(width, height, title); if (!Window.IsValid) { throw new Exception("No window available!"); } glfw3.GetMonitorPos(device.Monitor, out var x, out var y); glfw3.SetWindowMonitor(Window, glfw3.Monitor.None, x, y, device.VideoMode.Width, device.VideoMode.Height, 60); break; } case RendererMode.Window: { Window = glfw3.CreateWindow(width, height, title); if (!Window.IsValid) { throw new Exception("No window available!"); } glfw3.GetMonitorPos(device.Monitor, out var x, out var y); glfw3.SetWindowMonitor(Window, glfw3.Monitor.None, x + (width / 4), y + (height / 4), width / 2, height / 2, 60); break; } default: throw new Exception(string.Format("Unknown mode {0}", mode)); } glfw3.MakeContextCurrent(Window); glfw3.SwapInterval(flags.HasFlag(RendererFlags.WaitRetrace) ? 1 : 0); glfw3.SetFramebufferSizeCallback(Window, funcWindowChange = new glfw3.FramebufferSizeFunc(WindowChange)); glfw3.SetWindowCloseCallback(Window, funcWindowClose = new glfw3.WindowCloseFunc(WindowClose)); glfw3.SetMouseButtonCallback(Window, funcMouseButtonChange = new glfw3.MouseButtonFunc(MouseButtonChange)); gl2.GetIntegerv(GL._MAX_TEXTURE_SIZE, out var maxTextureSize); CheckErrors("GL_MAX_TEXTURE_SIZE"); MaxTextureSize = maxTextureSize; Trace.TraceInformation("Max Texture Size is {0}", maxTextureSize); gl2.GetIntegerv(GL._STENCIL_BITS, out var stencilBits); CheckErrors("GL_STENCIL_BITS"); Trace.TraceInformation("Stencil Bit Size is {0}", stencilBits); PrepareShaders(); PrepareBuffers(); // prepare viewport gl2.Enable(GL._BLEND); gl2.BlendFunc(GL._SRC_ALPHA, GL._ONE_MINUS_SRC_ALPHA); gl2.MatrixMode(GL._PROJECTION); UpdateAspectCorrection(); PrepareFramebuffer(); Trace.TraceInformation("Initialized {0} using {1} resolution {2}x{3} using OpenGL {4} Shader {5}", parent, flags, width, height, gl2.GetString(GL._VERSION), gl2.GetString(GL._SHADING_LANGUAGE_VERSION)); }
public Renderer(Window window, int index, RendererFlags flags) : base(SDL_CreateRenderer(window.handle, index, flags)) { }
public static SdlWindow FromHWnd(IntPtr handle, RendererFlags flags = RendererFlags.Default) { var key = "Window" + SdlFactory.WindowID(handle); if (Factory.Get(key, out SdlWindow window, ObjType.Window)) return window;
public Game() { Settings settings = SettingsManager.instance; Log.Info("Initializing FFmpeg..."); FFmpegHelper.Init(); Log.Info("Initializing Audio..."); audio = new AudioEngine(null, settings.audio.driver, (int)settings.audio.sampleRate, (int)settings.audio.bufferLength, settings.audio.resampleQuality); audio.SetVolume(Math.Min(settings.audio.volume, 100) / 100.0f); Log.Info("Audio driver: " + audio.audioDriver.ToString()); if (settings.outputMode != OutputMode.Render) { //SDL.SDL_version sdlVersion; //SDL.SDL_VERSION(out sdlVersion); Log.Info("Initializing SDL video subsystem..."); if (SDL.SDL_InitSubSystem(SDL.SDL_INIT_VIDEO) != 0) { throw new ApplicationException("Failed to initialize video subsystem: " + SDL.SDL_GetError()); } int display = 0; SDL.SDL_DisplayMode displayMode; if (SDL.SDL_GetCurrentDisplayMode(display, out displayMode) != 0) { throw new ApplicationException("SDL_GetCurrentDisplayMode failed: " + SDL.SDL_GetError()); } RendererFlags rendererFlags = RendererFlags.None; int width = (int)settings.video.width; int height = (int)settings.video.height; if (settings.video.vsync) { rendererFlags |= RendererFlags.Vsync; } if (settings.video.mode == VideoMode.Fullscreen) { rendererFlags |= RendererFlags.Fullscreen; } if (width * height == 0 || width > displayMode.w || height > displayMode.h) { width = displayMode.w; height = displayMode.h; } Log.Info("Initializing Game window..."); string windowTitle = string.Format("{0} {1} ({2}-bit)", Program.name, Program.versionDisplay, (IntPtr.Size * 8).ToString()); window = new GameWindow(windowTitle, width, height, settings.video.mode); Log.Info("Initializing Renderer..."); renderer = new Renderer(window, width, height, rendererFlags, settings.video.renderer); Log.Info("Renderer backend: " + renderer.rendererType.ToString()); Log.Info("Initializing Input..."); inputManager = new InputManager(); Log.Info("Loading debug font..."); debugFont = new Font(debugFontPath, 24, FontStyle.Normal, true); if (settings.engine.tickrate != 0) { updateInterval = Math.Max(0.0, 1.0 / settings.engine.tickrate); } if (settings.video.fpsLimit == 0) { renderInterval = 0.0; } else if (settings.video.fpsLimit == -1) { renderInterval = 1.0 / displayMode.refresh_rate; } else { renderInterval = Math.Max(0.0, 1.0 / settings.video.fpsLimit); } } Log.Clear(); if (settings.outputMode == OutputMode.Render) { sceneManager.Push(new RenderAudioScene(this, settings.playPath, settings.outputPath)); } else if (settings.outputMode == OutputMode.DumpTimestamps) { sceneManager.Push(new DumpTimestampsScene(this, settings.playPath, settings.outputPath)); } else if (settings.playPath != null) { sceneManager.Push(new GameplayScene(this, settings.playPath)); } else { sceneManager.Push(new FileSelectScene(this)); } }
protected bool IsRenderingEnabled(RendererFlags flag) { return(Renderer.EnabledRendering.HasFlag(flag)); }
public Renderer CreateRenderer( int index = -1, RendererFlags flags = RendererFlags.None) => new Renderer(this, index, flags);
/// <summary>Creates a SDL Renderer to copy and draw textures to a window /// </summary> /// <param name="flags">Bit flags indicating the way in which the renderer should be created</param> protected void CreateRenderer(RendererFlags flags) { CreateRenderer(EMPTY_INT, flags); }
public static extern Renderer CreateRenderer(Window window, int index = -1, RendererFlags flags = 0);
public static extern Renderer SDL_CreateRenderer( Window window, int index, RendererFlags flags );