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
);
