public void End()
{
if (disposed)
{
throw new ObjectDisposedException(this.GetType().ToString());
}
GraphicsContext.Assert();
int current_matrix;
GL.GetInteger(GetPName.MatrixMode, out current_matrix);
viewport = viewport_stack.Pop();
GL.Viewport(viewport.X, viewport.Y, viewport.Width, viewport.Height);
GL.MatrixMode(MatrixMode.Texture);
matrix = texture_stack.Pop();
GL.LoadMatrix(ref matrix);
GL.MatrixMode(MatrixMode.Modelview);
matrix = modelview_stack.Pop();
GL.LoadMatrix(ref matrix);
GL.MatrixMode(MatrixMode.Projection);
matrix = projection_stack.Pop();
GL.LoadMatrix(ref matrix);
GL.MatrixMode((MatrixMode)current_matrix);
}
public static void End()
{
GraphicsContext.Assert();
int current_matrix;
GL.GetInteger(GetPName.MatrixMode, out current_matrix);
viewport = viewport_stack.Pop();
GL.Viewport(viewport.X, viewport.Y, viewport.Width, viewport.Height);
GL.MatrixMode(MatrixMode.Texture);
matrix = texture_stack.Pop();
GL.LoadMatrix(ref matrix);
GL.MatrixMode(MatrixMode.Modelview);
matrix = modelview_stack.Pop();
GL.LoadMatrix(ref matrix);
GL.MatrixMode(MatrixMode.Projection);
matrix = projection_stack.Pop();
GL.LoadMatrix(ref matrix);
GL.MatrixMode((MatrixMode)current_matrix);
}
/// <summary>
/// Checks for errors that might have occurred during video processing. You should avoid calling this method due to performance reasons.
/// Only use it on suspect.
/// </summary>
/// <param name="silent">If true, errors aren't logged.</param>
/// <returns>True, if an error occurred, false if not.</returns>
public static bool CheckOpenGLErrors(bool silent = false, [CallerMemberName] string callerInfoMember = null, [CallerFilePath] string callerInfoFile = null, [CallerLineNumber] int callerInfoLine = -1)
{
// Accessing OpenGL functionality requires context. Don't get confused by AccessViolationExceptions, fail better instead.
GraphicsContext.Assert();
ErrorCode error;
bool found = false;
while ((error = GL.GetError()) != ErrorCode.NoError)
{
if (!silent)
{
Log.Core.WriteError(
"Internal OpenGL error, code {0} at {1} in {2}, line {3}.",
error,
callerInfoMember,
callerInfoFile,
callerInfoLine);
}
found = true;
}
if (found && !silent && System.Diagnostics.Debugger.IsAttached)
{
System.Diagnostics.Debugger.Break();
}
return(found);
}
public static void UpdateCurrentViewport()
{
GraphicsContext.Assert();
Viewport viewport = new Viewport();
GL.GetInteger(GetPName.Viewport, out viewport.X);
currentViewport = viewport;
}
/// <summary>
/// Update the current viewport
/// </summary>
public static void UpdateCurrentViewport()
{
GraphicsContext.Assert();
int[] viewportInts = new int[4];
GL.GetInteger(GetPName.Viewport, viewportInts);
_currentViewport = new Viewport(viewportInts[0], viewportInts[1], viewportInts[2], viewportInts[3]);
}
public static void UpdateCurrentViewport()
{
GraphicsContext.Assert();
int[] viewportInts = new int[4];
//TODO Test that this function returns the expected values -> tested, 96% sure it works.
GL.GetInteger(GetPName.Viewport, viewportInts);
_currentViewport = new Viewport(viewportInts[0], viewportInts[1], viewportInts[2], viewportInts[3]);
}
public static void UpdateCurrentViewportFromHardware()
{
lock (cachedViewportStack) {
GraphicsContext.Assert();
Viewport viewport = new Viewport();
GL.GetInteger(GetPName.Viewport, out viewport.X);
cachedViewportStack.Pop();
cachedViewportStack.Push(viewport);
}
}
private void GameLoop()
{
this.Log("Create graphics context");
context = new GraphicsContext(graphicsMode, window.WindowInfo, 4, 0, GraphicsContextFlags.Debug);
context.MakeCurrent(window.WindowInfo);
GraphicsContext.Assert();
this.Log($"VSync: {Configuration.VSync}");
VSync = Configuration.VSync;
this.Log("Loading OpenGL entry points");
context.LoadAll();
batch = new SpriteBatch(this);
this.Log("Setup OpenGL");
SetupOpenGL();
this.Log("Setup OpenAL");
SetupOpenAL();
LoadAssetProviders();
Load();
window.Visible = true;
CalculateTimings();
Time.Start();
this.Log("Enter game loop");
while (!Closing)
{
if (context.IsDisposed)
{
this.Log("Context not available");
break;
}
updating = true;
InternUpdate();
Render(batch);
updating = false;
}
this.Log("Exited game loop");
Time.Stop();
}
public static void End()
{
GraphicsContext.Assert();
GL.MatrixMode(MatrixMode.Modelview);
GL.PopMatrix(); //pop modelview
GL.MatrixMode(MatrixMode.Projection);
GL.PopMatrix(); //pop projection
GL.MatrixMode(MatrixMode.Modelview);
}
public static void Begin()
{
GraphicsContext.Assert();
Viewport currentVp = (Viewport)CurrentViewport;
GL.MatrixMode(MatrixMode.Projection);
GL.PushMatrix(); //push projection matrix
GL.LoadIdentity();
GL.Ortho(currentVp.X, currentVp.Width, currentVp.Height, currentVp.Y, -1.0, 1.0);
GL.MatrixMode(MatrixMode.Modelview);
GL.PushMatrix(); //push modelview matrix
GL.LoadIdentity();
}
public static void LogOpenGLSpecs()
{
// Accessing OpenGL functionality requires context. Don't get confused by AccessViolationExceptions, fail better instead.
GraphicsContext.Assert();
string versionString = null;
try
{
CheckOpenGLErrors();
versionString = GL.GetString(StringName.Version);
Log.Core.Write(
"OpenGL Version: {0}" + Environment.NewLine +
"Vendor: {1}" + Environment.NewLine +
"Renderer: {2}" + Environment.NewLine +
"Shader Version: {3}",
versionString,
GL.GetString(StringName.Vendor),
GL.GetString(StringName.Renderer),
GL.GetString(StringName.ShadingLanguageVersion));
CheckOpenGLErrors();
}
catch (Exception e)
{
Log.Core.WriteWarning("Can't determine OpenGL specs, because an error occurred: {0}", Log.Exception(e));
}
// Parse the OpenGL version string in order to determine if it's sufficient
if (versionString != null)
{
string[] token = versionString.Split(' ');
for (int i = 0; i < token.Length; i++)
{
Version version;
if (Version.TryParse(token[i], out version))
{
if (version.Major < MinOpenGLVersion.Major || (version.Major == MinOpenGLVersion.Major && version.Minor < MinOpenGLVersion.Minor))
{
Log.Core.WriteWarning(
"The detected OpenGL version {0} appears to be lower than the required minimum. Version {1} or higher is required to run Duality applications.",
version,
MinOpenGLVersion);
}
break;
}
}
}
}
/// <summary>
/// Retrieves all capability values from the currently active graphics context.
/// </summary>
public void RetrieveFromAPI()
{
// Reset all values to default / undefined so we'll end up with only the values we successfully retrieved
this.Reset();
// Accessing OpenGL functionality requires context. Don't get confused by AccessViolationExceptions, fail better instead.
GraphicsContext.Assert();
// Retrieve raw values from OpenGL
try
{
GraphicsBackend.CheckOpenGLErrors();
this.glVersionString = GL.GetString(StringName.Version);
this.glVendor = GL.GetString(StringName.Vendor);
this.glRenderer = GL.GetString(StringName.Renderer);
this.glslVersionString = GL.GetString(StringName.ShadingLanguageVersion);
GraphicsBackend.CheckOpenGLErrors();
}
catch (Exception e)
{
Logs.Core.WriteWarning(
"Unable to determine OpenGL base specs: {0}",
LogFormat.Exception(e));
}
// Retrieve extended / in-depth specs from OpenGL
try
{
GraphicsBackend.CheckOpenGLErrors();
GL.GetInteger(GetPName.MaxTextureSize, out this.maxTextureSize);
GL.GetInteger(GetPName.MaxTextureImageUnits, out this.maxTextureBindings);
GL.GetInteger(GetPName.MaxRenderbufferSize, out this.maxRenderTargetSize);
GraphicsBackend.CheckOpenGLErrors();
}
catch (Exception e)
{
Logs.Core.WriteWarning(
"Unable to determine OpenGL extended specs: {0}",
LogFormat.Exception(e));
}
// Parse raw values such as version strings for higher level info
this.TryParseVersionString(this.glVersionString, out this.glVersion);
this.TryParseVersionString(this.glslVersionString, out this.glslVersion);
// Translate some of the GL-specific attributes to the generalized base class ones
this.apiVersion = this.glslVersion;
}
public static void End()
{
GraphicsContext.Assert();
GL.MatrixMode(MatrixMode.Modelview);
GL.PopMatrix(); //pop modelview
GL.MatrixMode(MatrixMode.Projection);
GL.PopMatrix(); //pop projection
GL.MatrixMode(MatrixMode.Modelview);
GL.Disable(EnableCap.Texture2D);
GL.Disable(EnableCap.Blend);
Begun = false;
}
public static VSyncMode getVSync()
{
EnsureUndisposed();
GraphicsContext.Assert();
if (getContext().SwapInterval < 0)
{
return(VSyncMode.Adaptive);
}
else if (getContext().SwapInterval == 0)
{
return(VSyncMode.Off);
}
else
{
return(VSyncMode.On);
}
}
public static void setVSync(VSyncMode v)
{
EnsureUndisposed();
GraphicsContext.Assert();
switch (v)
{
case VSyncMode.On:
getContext().SwapInterval = 1;
break;
case VSyncMode.Off:
getContext().SwapInterval = 0;
break;
case VSyncMode.Adaptive:
getContext().SwapInterval = -1;
break;
}
}
public void Begin()
{
if (disposed)
{
throw new ObjectDisposedException(this.GetType().ToString());
}
GraphicsContext.Assert();
// Save the state of everything we are going to modify:
// the current matrix mode, viewport state and the projection, modelview and texture matrices.
// All these will be restored in the TextPrinter.End() method.
int current_matrix;
GL.GetInteger(GetPName.MatrixMode, out current_matrix);
GL.GetInteger(GetPName.Viewport, out viewport.X);
viewport_stack.Push(viewport);
GL.GetFloat(GetPName.ProjectionMatrix, out matrix.Row0.X);
projection_stack.Push(matrix);
GL.GetFloat(GetPName.ModelviewMatrix, out matrix.Row0.X);
modelview_stack.Push(matrix);
GL.GetFloat(GetPName.TextureMatrix, out matrix.Row0.X);
texture_stack.Push(matrix);
// Prepare to draw text. We want pixel perfect precision, so we setup a 2D mode,
// with size equal to the window (in pixels).
// While we could also render text in 3D mode, it would be very hard to get
// pixel-perfect precision.
GL.MatrixMode(MatrixMode.Projection);
GL.LoadIdentity();
GL.Ortho(viewport.X, viewport.Width, viewport.Height, viewport.Y, -1.0, 1.0);
GL.MatrixMode(MatrixMode.Modelview);
GL.LoadIdentity();
GL.MatrixMode(MatrixMode.Texture);
GL.LoadIdentity();
GL.MatrixMode((MatrixMode)current_matrix);
}
/// <summary>
/// Enter the gameloop.
/// </summary>
void EnterGameloop()
{
// Create graphics context
this.Log("Creating graphics context");
context = new GraphicsContext(
mode: graphicsMode,
window: window.WindowInfo,
major: 4,
minor: 0,
flags: GraphicsContextFlags.ForwardCompatible
);
// Make the created context the current context
context.MakeCurrent(window.WindowInfo);
// Throw if context is not available
GraphicsContext.Assert();
// Set vsync mode
SetupVsync();
// Load OpenGL entry points
this.Log("Loading OpenGL entry points");
context.LoadAll();
// Initialize the sprite batch
SpriteBatch = new SpriteBatch(this);
// Bind the UI
UI.Bind(this);
// Initialize the game
this.Log("Initializing game");
PreInitialize();
Initialize();
// Set target framerate
// Use 60hz if framerate is not set
var framerate = Configuration.TargetFramerate > 0 ? Configuration.TargetFramerate : 60;
// Prepare timing variables
PrepareTiming(framerate);
// Present the window to the user
window.Visible = true;
// Wait till the window is visible
while (!windowVisible && !window.Focused && !window.Visible)
{
}
// Enter the actual game loop
while (!exit)
{
// Set updating to true
updating = true;
// Invoke waiting actions
for (var i = 0; i < ContextActions.Count; i++)
{
Action action;
if (ContextActions.TryDequeue(out action))
{
try {
action();
} catch (Exception e) {
this.Throw(e.Message);
}
}
}
// Set the paused variable to true
// if the game should be paused and continue
if (pause)
{
paused = true;
continue;
}
// Set the paused variable to false
paused = false;
// Break out of the loop if the context is not available.
if (context.IsDisposed)
{
this.Log("Context not available");
this.Log("Leaving gameloop");
break;
}
// Update current time
currentTime = DateTime.UtcNow;
// Update
InternalUpdate(currentTime);
// Draw
Draw(gameTime);
// Set updating to false
updating = false;
}
}
