public void Tick()
{
_glUtils.RefreshViewport(_settings, _window, _gameState.Viewport, true);
_glUtils.AdjustResolution(_settings.VirtualResolution.Width, _settings.VirtualResolution.Height);
activateShader();
renderAllViewports();
}
private void onGameWindowLoaded(TypedParameter settingsParameter, IGameSettings settings)
{
TypedParameter gameWindowParameter = new TypedParameter(typeof(IGameWindow), GameWindow);
Settings = _resolver.Container.Resolve <IRuntimeSettings>(settingsParameter, gameWindowParameter);
_graphics.ClearColor(0f, 0f, 0f, 1f);
_graphics.Init();
_glUtils.GenBuffers();
Factory = _resolver.Container.Resolve <IGameFactory>();
IAGSInput input = _resolver.Container.Resolve <IAGSInput>();
input.Init(settings.VirtualResolution);
Input = input;
TypedParameter inputParamater = new TypedParameter(typeof(IInput), Input);
TypedParameter gameParameter = new TypedParameter(typeof(IGame), this);
RenderLoop = _resolver.Container.Resolve <IRendererLoop>(inputParamater, gameParameter, gameWindowParameter);
updateResolver();
HitTest = _resolver.Container.Resolve <IHitTest>();
AudioSettings = _resolver.Container.Resolve <IAudioSettings>();
SaveLoad = _resolver.Container.Resolve <ISaveLoad>();
_glUtils.AdjustResolution(settings.VirtualResolution.Width, settings.VirtualResolution.Height);
Events.OnLoad.Invoke();
}
private void renderObject(IViewport viewport, IObject obj)
{
_matrixUpdater.RefreshMatrix(obj);
Size resolution = obj.RenderLayer == null || obj.RenderLayer.IndependentResolution == null ?
_game.Settings.VirtualResolution :
obj.RenderLayer.IndependentResolution.Value;
_glUtils.AdjustResolution(resolution.Width, resolution.Height);
IImageRenderer imageRenderer = getImageRenderer(obj);
var shader = applyObjectShader(obj);
imageRenderer.Render(obj, viewport);
removeObjectShader(shader);
}
private void renderObject(IRoom room, IObject obj)
{
Size resolution = obj.RenderLayer == null || obj.RenderLayer.IndependentResolution == null ?
_game.Settings.VirtualResolution :
obj.RenderLayer.IndependentResolution.Value;
_glUtils.AdjustResolution(resolution.Width, resolution.Height);
IImageRenderer imageRenderer = getImageRenderer(obj);
imageRenderer.Prepare(obj, obj, room.Viewport);
var shader = applyObjectShader(obj);
imageRenderer.Render(obj, room.Viewport);
removeObjectShader(shader);
}
private void onGameWindowLoaded(TypedParameter settingsParameter, IGameSettings settings)
{
TypedParameter gameWindowParameter = new TypedParameter(typeof(IGameWindow), GameWindow);
Settings = _resolver.Container.Resolve <IRuntimeSettings>(settingsParameter, gameWindowParameter);
_graphics.ClearColor(0f, 0f, 0f, 1f);
_graphics.Init();
_glUtils.GenBuffers();
Factory = _resolver.Container.Resolve <IGameFactory>();
TypedParameter gameParameter = new TypedParameter(typeof(IGame), this);
Settings.Defaults.MessageBox = _resolver.Container.Resolve <IMessageBoxSettings>(gameParameter);
var input = _resolver.Container.Resolve <IInput>();
Input = input;
TypedParameter inputParamater = new TypedParameter(typeof(IInput), Input);
_pipeline = _resolver.Container.Resolve <IAGSRenderPipeline>(gameParameter);
TypedParameter pipelineParameter = new TypedParameter(typeof(IAGSRenderPipeline), _pipeline);
RenderLoop = _resolver.Container.Resolve <IRendererLoop>(inputParamater, gameParameter,
gameWindowParameter, pipelineParameter);
updateResolver();
HitTest = _resolver.Container.Resolve <IHitTest>();
Audio = _resolver.Container.Resolve <IAudioSystem>();
SaveLoad = _resolver.Container.Resolve <ISaveLoad>();
Coordinates = _resolver.Container.Resolve <ICoordinates>();
_roomTransitionWorkflow = _resolver.Container.Resolve <IRoomTransitionWorkflow>();
_glUtils.AdjustResolution(settings.VirtualResolution.Width, settings.VirtualResolution.Height);
_updateMessagePump.Post(_ => Events.OnLoad.Invoke(), null);
}
public bool Tick()
{
_glUtils.RefreshViewport(_game.Settings, _gameWindow, _gameState.Viewport);
_glUtils.AdjustResolution(_game.Settings.VirtualResolution.Width, _game.Settings.VirtualResolution.Height);
var transitionState = _roomTransitions.State;
if (_gameState.Room == null)
{
transitionState = RoomTransitionState.NotInTransition; //If there's no room, then room transition state is meaningless -> we'll interpret as not in transition, which will render the viewports, without a room (so GUIs will still be rendered).
}
switch (transitionState)
{
case RoomTransitionState.NotInTransition:
activateShader();
renderAllViewports();
break;
case RoomTransitionState.BeforeLeavingRoom:
if (_roomTransitions.Transition == null)
{
_roomTransitions.State = RoomTransitionState.NotInTransition;
return(false);
}
else if (_gameState.Cutscene.IsSkipping)
{
_roomTransitions.State = RoomTransitionState.PreparingTransition;
return(false);
}
else if (!_roomTransitions.Transition.RenderBeforeLeavingRoom(
_displayList.GetDisplayList(_gameState.Viewport)))
{
if (_fromTransitionBuffer == null)
{
_fromTransitionBuffer = renderToBuffer();
}
_roomTransitions.State = RoomTransitionState.PreparingTransition;
return(false);
}
break;
case RoomTransitionState.PreparingNewRoomRendering:
case RoomTransitionState.PreparingTransition:
return(false);
case RoomTransitionState.InTransition:
if (_gameState.Cutscene.IsSkipping)
{
_fromTransitionBuffer = null;
_toTransitionBuffer = null;
_roomTransitions.State = RoomTransitionState.AfterEnteringRoom;
return(false);
}
if (_toTransitionBuffer == null)
{
_toTransitionBuffer = renderToBuffer();
}
_glUtils.RefreshViewport(_noAspectRatioSettings, _gameWindow, _gameState.Viewport);
if (!_roomTransitions.Transition.RenderTransition(_fromTransitionBuffer, _toTransitionBuffer))
{
_fromTransitionBuffer = null;
_toTransitionBuffer = null;
_roomTransitions.State = RoomTransitionState.AfterEnteringRoom;
return(false);
}
break;
case RoomTransitionState.AfterEnteringRoom:
if (_gameState.Cutscene.IsSkipping || !_roomTransitions.Transition.RenderAfterEnteringRoom(
_displayList.GetDisplayList(_gameState.Viewport)))
{
_roomTransitions.SetOneTimeNextTransition(null);
_roomTransitions.State = RoomTransitionState.NotInTransition;
return(false);
}
break;
default:
throw new NotSupportedException(_roomTransitions.State.ToString());
}
return(true);
}
public void Start(IGameSettings settings)
{
GameLoop = _resolver.Container.Resolve <IGameLoop>(new TypedParameter(typeof(AGS.API.Size), settings.VirtualResolution));
TypedParameter settingsParameter = new TypedParameter(typeof(IGameSettings), settings);
try { GameWindow = Resolver.Container.Resolve <IGameWindow>(settingsParameter); }
catch (Exception ese)
{
Debug.WriteLine(ese.ToString());
throw;
}
//using (GameWindow)
{
try
{
TypedParameter gameWindowParameter = new TypedParameter(typeof(IGameWindow), GameWindow);
GameWindow.Load += (sender, e) =>
{
Settings = Resolver.Container.Resolve <IRuntimeSettings>(settingsParameter, gameWindowParameter);
_graphics.ClearColor(0f, 0f, 0f, 1f);
_graphics.Init();
_glUtils.GenBuffers();
Factory = Resolver.Container.Resolve <IGameFactory>();
TypedParameter sizeParameter = new TypedParameter(typeof(AGS.API.Size), Settings.VirtualResolution);
Input = _resolver.Container.Resolve <IInput>(gameWindowParameter, sizeParameter);
TypedParameter inputParamater = new TypedParameter(typeof(IInput), Input);
TypedParameter gameParameter = new TypedParameter(typeof(IGame), this);
_renderLoop = _resolver.Container.Resolve <IRendererLoop>(inputParamater, gameParameter);
updateResolver();
AudioSettings = _resolver.Container.Resolve <IAudioSettings>();
SaveLoad = _resolver.Container.Resolve <ISaveLoad>();
_glUtils.AdjustResolution(settings.VirtualResolution.Width, settings.VirtualResolution.Height);
Events.OnLoad.Invoke(sender, new AGSEventArgs());
};
GameWindow.Resize += async(sender, e) =>
{
await Task.Delay(10); //todo: For some reason on the Mac, the GL Viewport assignment is overridden without this delay (so aspect ratio is not preserved), a bug in OpenTK?
resize();
Events.OnScreenResize.Invoke(sender, new AGSEventArgs());
};
GameWindow.UpdateFrame += async(sender, e) =>
{
try
{
_messagePump.PumpMessages();
if (State.Paused)
{
return;
}
adjustSpeed();
await GameLoop.UpdateAsync().ConfigureAwait(false);
AGSEventArgs args = new AGSEventArgs();
//Invoking repeatedly execute asynchronously, as if one subscriber is waiting on another subscriber the event will
//never get to it (for example: calling ChangeRoom from within RepeatedlyExecute calls StopWalking which
//waits for the walk to stop, only the walk also happens on RepeatedlyExecute and we'll hang.
//Since we're running asynchronously, the next UpdateFrame will call RepeatedlyExecute for the walk cycle to stop itself and we're good.
///The downside of this approach is that we need to look out for re-entrancy issues.
await Events.OnRepeatedlyExecute.InvokeAsync(sender, args);
}
catch (Exception ex)
{
Debug.WriteLine(ex.ToString());
throw ex;
}
};
GameWindow.RenderFrame += (sender, e) =>
{
if (_renderLoop == null)
{
return;
}
try
{
// render graphics
_graphics.ClearScreen();
Events.OnBeforeRender.Invoke(sender, _renderEventArgs);
if (_renderLoop.Tick())
{
GameWindow.SwapBuffers();
}
if (Repeat.OnceOnly("SetFirstRestart"))
{
SaveLoad.SetRestartPoint();
}
}
catch (Exception ex)
{
Debug.WriteLine("Exception when rendering:");
Debug.WriteLine(ex.ToString());
throw;
}
};
// Run the game at 60 updates per second
GameWindow.Run(UPDATE_RATE);
} catch (Exception exx)
{
Debug.WriteLine(exx.ToString());
throw;
}
}
}
