public static uint Draw(IFrameBuffer frameBuffer, uint tileSize)
{
uint positionX = (frameBuffer.Width / 2) - ((_width * tileSize) / 2);
uint positionY = (frameBuffer.Height / 2) - ((_height * tileSize) / 2);
//Can't store these as a static fields, they seem to break something
uint[] logo = new uint[] { 0x39E391, 0x44145B, 0x7CE455, 0x450451, 0x450451, 0x451451, 0x44E391 };
uint[] colors = new uint[] { 0x00FF0000, 0x0000FF00, 0x000000FF, 0x00FFFF00 }; //Colors for each pixel
for (int ty = 0; ty < _height; ty++)
{
uint data = logo[ty];
for (int tx = 0; tx < _width; tx++)
{
int mask = 1 << tx;
if ((data & mask) == mask)
{
frameBuffer.FillRectangle(colors[tx / 6], (uint)(positionX + (tileSize * tx)), (uint)(positionY + (tileSize * ty)), tileSize, tileSize); //Each pixel is aprox 5 tiles in width
}
}
}
return(positionY);
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
if (_tween.Task.IsCompleted)
{
return false;
}
_visitTween();
var oldShader = AGSGame.Shader;
_screenVectors.Render(to.Texture);
var shader = GLShader.FromText(VERTEX_SHADER, FRAGMENT_SHADER, _graphics).Compile();
if (shader == null)
{
return false;
}
shader.Bind();
if (!shader.SetVariable("time", _time))
{
shader.Unbind();
return false;
}
_screenVectors.Render(from.Texture);
if (oldShader != null) oldShader.Bind();
else shader.Unbind();
return true;
}
public void RenderBorderFront(AGSBoundingBox square)
{
if (_settings.WindowSize.Equals(_lastWindowSize) && _lastSquare.SameSize(square) &&
_glUtils.DrawQuad(_frameBuffer, square, _quad))
{
return;
}
_frameBuffer?.Dispose();
_lastSquare = square;
_lastWindowSize = _settings.WindowSize;
float width = _glUtils.CurrentResolution.Width - _padding;
float height = _glUtils.CurrentResolution.Height - _padding;
_frameBuffer = _glUtils.BeginFrameBuffer(square, _settings);
if (_frameBuffer == null)
{
return;
}
_glUtils.DrawLine(_padding, _padding, width, height, _lineWidth, _color.R, _color.G, _color.B, _color.A);
_glUtils.DrawLine(_padding, height, width, _padding, _lineWidth, _color.R, _color.G, _color.B, _color.A);
_frameBuffer.End();
_glUtils.DrawQuad(_frameBuffer, square, _quad);
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
if (_tween.Task.IsCompleted)
{
return(false);
}
_visitTween();
var oldShader = AGSGame.Shader;
_screenVectors.Render(to.Texture);
var shader = _game.Factory.Shaders.FromText(null, FRAGMENT_SHADER).Compile();
if (shader == null)
{
return(false);
}
shader.Bind();
if (!shader.SetVariable("time", _time))
{
shader.Unbind();
return(false);
}
_screenVectors.Render(from.Texture);
if (oldShader != null)
{
oldShader.Bind();
}
else
{
shader.Unbind();
}
return(true);
}
public static bool InitVBE(BaseHardwareAbstraction hal)
{
if (!VBE.IsVBEAvailable)
{
return(false);
}
uint memorySize = (uint)(VBE.ScreenWidth * VBE.ScreenHeight * (VBE.BitsPerPixel / 8));
_lfb = hal.GetPhysicalMemory((uint)VBE.MemoryPhysicalLocation.ToInt32(), memorySize);
switch (VBE.BitsPerPixel)
{
case 8: Framebuffer = new FrameBuffer8bpp(_lfb, VBE.ScreenWidth, VBE.ScreenHeight, 0, VBE.Pitch); break;
case 16: Framebuffer = new FrameBuffer16bpp(_lfb, VBE.ScreenWidth, VBE.ScreenHeight, 0, VBE.Pitch); break;
case 24: Framebuffer = new FrameBuffer24bpp(_lfb, VBE.ScreenWidth, VBE.ScreenHeight, 0, VBE.Pitch); break;
case 32: Framebuffer = new FrameBuffer32bpp(_lfb, VBE.ScreenWidth, VBE.ScreenHeight, 0, VBE.Pitch); break;
default:
return(false);
}
return(true);
}
/// <summary>
/// Sets the mode.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <returns></returns>
public bool SetMode(ushort width, ushort height)
{
this.width = width;
this.height = height;
SendCommand(Register.Width, width);
SendCommand(Register.Height, height);
SendCommand(Register.Enable, 1);
offset = GetValue(Register.FrameBufferOffset);
SendCommand(Register.GuestID, 0x5010); // ??
bytesPerLine = GetValue(Register.BytesPerLine);
switch (bitsPerPixel)
{
case 8: frameBuffer = new FrameBuffer8bpp(memory, width, height, offset, bytesPerLine); break;
case 16: frameBuffer = new FrameBuffer16bpp(memory, width, height, offset, bytesPerLine); break;
case 24: frameBuffer = new FrameBuffer24bpp(memory, width, height, offset, bytesPerLine); break;
case 32: frameBuffer = new FrameBuffer32bpp(memory, width, height, offset, bytesPerLine); break;
default: return(false);
}
return(true);
}
public void EndFrame()
{
if (doRender.Count == 0)
{
return;
}
Sheet currentSheet = null;
IFrameBuffer fbo = null;
foreach (var v in doRender)
{
// Change sheet
if (v.First != currentSheet)
{
if (fbo != null)
{
DisableFrameBuffer(fbo);
}
currentSheet = v.First;
fbo = EnableFrameBuffer(currentSheet);
}
v.Second();
}
if (fbo != null)
{
DisableFrameBuffer(fbo);
}
}
/// <summary>
/// Sets the mode.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <returns></returns>
public bool SetMode(ushort width, ushort height)
{
this.width = width;
this.height = height;
// set height & width
SendCommand(Register.Height, height);
SendCommand(Register.Width, width);
SendCommand(Register.BitsPerPixel, 32);
SendCommand(Register.Enable, 1);
// use the host's bits per pixel
bitsPerPixel = 32; // ReadRegister(Register.BitsPerPixel);
// get the frame buffer offset
offset = ReadRegister(Register.FrameBufferOffset);
// get the bytes per line (pitch)
bytesPerLine = ReadRegister(Register.BytesPerLine);
switch (bitsPerPixel)
{
case 8: frameBuffer = new FrameBuffer8bpp(memory, width, height, offset, 1); break;
case 16: frameBuffer = new FrameBuffer16bpp(memory, width, height, offset, 2); break;
case 24: frameBuffer = new FrameBuffer24bpp(memory, width, height, offset, 3); break;
case 32: frameBuffer = new FrameBuffer32bpp(memory, width, height, offset, 4); break;
default: return(false);
}
return(true);
}
public void RenderBorderBack(ISquare square)
{
if (_glUtils.DrawQuad(_frameBuffer, square, _quad))
{
return;
}
float width = _settings.VirtualResolution.Width;
float height = _settings.VirtualResolution.Height;
IGLColor color = IsSelected ? _selectedColor : _color;
IGLColor foldColor = IsSelected ? _selectedFoldColor : _foldColor;
float foldHeight = height * (1f / 5f);
PointF foldBottom = new PointF(width / 2f, foldHeight);
_frameBuffer = _glUtils.BeginFrameBuffer(square, _settings);
_glUtils.DrawQuad(0, new Vector3(0, height, 0), new Vector3(width, height, 0),
new Vector3(), new Vector3(width, 0, 0),
color, color, color, color);
_glUtils.DrawTriangle(0, new GLVertex[] { new GLVertex(new Vector2(), _emptyVector, foldColor),
new GLVertex(foldBottom.ToVector2(), _emptyVector, foldColor), new GLVertex(new Vector2(width, 0), _emptyVector, foldColor) });
_frameBuffer.End();
_glUtils.DrawQuad(_frameBuffer, square, _quad);
}
public void RenderBorderBack(ISquare square)
{
if (_glUtils.DrawQuad(_frameBuffer, square, _quad))
{
return;
}
float width = _settings.VirtualResolution.Width;
float height = _settings.VirtualResolution.Height;
float foldWidth = (width) * (1f / 5f);
float foldHeight = (height) * (1f / 5f);
IGLColor color = IsSelected ? _selectedColor : _color;
IGLColor foldColor = IsSelected ? _selectedFoldColor : _foldColor;
Vector3 foldBottomLeft = new Vector3(width - foldWidth, foldHeight, 0);
Vector3 foldTopLeft = new Vector3(width - foldWidth, 0, 0);
Vector3 foldTopRight = new Vector3(width, foldHeight, 0);
_frameBuffer = _glUtils.BeginFrameBuffer(square, _settings);
_glUtils.DrawQuad(0, new Vector3(0f, height, 0), new Vector3(width - foldWidth, height, 0),
new Vector3(), foldTopLeft,
color, color, color, color);
_glUtils.DrawQuad(0, new Vector3(width - foldWidth, height, 0), new Vector3(width, height, 0),
foldBottomLeft, foldTopRight,
color, color, color, color);
_glUtils.DrawTriangle(0, new GLVertex[] { new GLVertex(foldBottomLeft.Xy, _emptyVector, foldColor),
new GLVertex(foldTopLeft.Xy, _emptyVector, foldColor), new GLVertex(foldTopRight.Xy, _emptyVector, foldColor) });
_frameBuffer.End();
_glUtils.DrawQuad(_frameBuffer, square, _quad);
}
public static void Main()
{
ApplicationRuntime.Init();
MessageManager.OnDispatchError = OnDispatchError;
MessageManager.OnMessageReceived = MessageReceived;
fb = CreateFrameBuffer();
if (fb == null)
{
Console.WriteLine("No Framebuffer found");
ApplicationRuntime.Exit(0);
}
sur = new FramebufferSurface(fb);
gfx = new GraphicsAdapter(sur);
gfx.SetSource(0x00115F9F);
gfx.Rectangle(0, 0, sur.Width, sur.Height);
gfx.Fill();
SysCalls.RegisterService(SysCallTarget.Tmp_DisplayServer_CreateWindow);
SysCalls.RegisterService(SysCallTarget.Tmp_DisplayServer_FlushWindow);
SysCalls.SetServiceStatus(ServiceStatus.Ready);
Console.WriteLine("DisplayServer ready");
while (true)
{
SysCalls.ThreadSleep(0);
}
}
public void BeginFrame(int2 scroll, float zoom)
{
Context.Clear();
var surfaceSize = Window.SurfaceSize;
var surfaceBufferSize = surfaceSize.NextPowerOf2();
if (screenSprite == null || screenSprite.Sheet.Size != surfaceBufferSize)
{
if (screenBuffer != null)
{
screenBuffer.Dispose();
}
// Render the screen into a frame buffer to simplify reading back screenshots
screenBuffer = Context.CreateFrameBuffer(surfaceBufferSize, Color.FromArgb(0xFF, 0, 0, 0));
}
if (screenSprite == null || surfaceSize.Width != screenSprite.Bounds.Width || -surfaceSize.Height != screenSprite.Bounds.Height)
{
var screenSheet = new Sheet(SheetType.BGRA, screenBuffer.Texture);
// Flip sprite in Y to match OpenGL's bottom-left origin
var screenBounds = Rectangle.FromLTRB(0, surfaceSize.Height, surfaceSize.Width, 0);
screenSprite = new Sprite(screenSheet, screenBounds, TextureChannel.RGBA);
}
screenBuffer.Bind();
SetViewportParams(scroll, zoom);
}
public static bool InitVBE(BaseHardwareAbstraction hal)
{
if (!Multiboot.IsMultibootEnabled)
{
return(false);
}
if (!Multiboot.VBEPresent)
{
return(false);
}
VBEMode vbeInfo = Multiboot.VBEModeInfoStructure;
uint memorySize = (uint)(vbeInfo.ScreenWidth * vbeInfo.ScreenHeight * (vbeInfo.BitsPerPixel / 8));
_lfb = hal.RequestPhysicalMemory(vbeInfo.MemoryPhysicalLocation, memorySize);
switch (vbeInfo.BitsPerPixel)
{
case 8: Framebuffer = new FrameBuffer8bpp(_lfb, vbeInfo.ScreenWidth, vbeInfo.ScreenHeight, 0, vbeInfo.Pitch); break;
case 16: Framebuffer = new FrameBuffer16bpp(_lfb, vbeInfo.ScreenWidth, vbeInfo.ScreenHeight, 0, vbeInfo.Pitch); break;
case 24: Framebuffer = new FrameBuffer24bpp(_lfb, vbeInfo.ScreenWidth, vbeInfo.ScreenHeight, 0, vbeInfo.Pitch); break;
case 32: Framebuffer = new FrameBuffer32bpp(_lfb, vbeInfo.ScreenWidth, vbeInfo.ScreenHeight, 0, vbeInfo.Pitch); break;
default:
return(false);
}
return(true);
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
if (_tweenX.Task.IsCompleted && _tweenY.Task.IsCompleted)
{
return(false);
}
if (!_tweenX.Task.IsCompleted)
{
_visitTweenX();
}
if (!_tweenY.Task.IsCompleted)
{
_visitTweenY();
}
var quad = new QuadVectors(_x, _y, _width, _height, _glUtils);
if (_slideIn)
{
_screenVectors.Render(from.Texture);
quad.Render(to.Texture);
}
else
{
_screenVectors.Render(to.Texture);
quad.Render(from.Texture);
}
return(true);
}
public ThreadedFrameBuffer(ThreadedGraphicsContext device, IFrameBuffer frameBuffer)
{
this.device = device;
getTexture = () => frameBuffer.Texture;
bind = frameBuffer.Bind;
unbind = frameBuffer.Unbind;
dispose = frameBuffer.Dispose;
}
public FramebufferSurface(IFrameBuffer dev)
{
Dev = dev;
_addr = dev.Addr;
_Width = dev.Width;
_Height = dev.Height;
_Depth = dev.Depth;
_Pitch = dev.Pitch;
}
/// <summary>
/// Creates a new GraphicContext from <seealso cref="IFrameBuffer"/>
/// </summary>
/// <param name="buffer"></param>
/// <returns></returns>
public static GraphicContext FromBuffer(IFrameBuffer buffer)
{
var c = new GraphicContext();
c._buffer = buffer;
c.OffSet = new Point(0, 0);
c.Size = new Size(buffer.Width, buffer.Height);
return(c);
}
private IFrameBuffer renderToBuffer(IRoom room)
{
TypedParameter sizeParam = new TypedParameter(typeof(Size), _game.Settings.WindowSize);
IFrameBuffer frameBuffer = _resolver.Container.Resolve <IFrameBuffer>(sizeParam);
frameBuffer.Begin();
renderRoom(room);
frameBuffer.End();
return(frameBuffer);
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
if (_tween.Task.IsCompleted)
{
return(false);
}
_visitTween();
_screenVectors.Render(to.Texture);
_screenVectors.Render(from.Texture, a: _alpha);
return(true);
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
if (_tween.Task.IsCompleted)
{
return false;
}
_visitTween();
_screenVectors.Render(to.Texture);
_screenVectors.Render(from.Texture, a: _alpha);
return true;
}
public ThreadedFrameBuffer(ThreadedGraphicsContext device, IFrameBuffer frameBuffer)
{
this.device = device;
getTexture = () => frameBuffer.Texture;
bind = frameBuffer.Bind;
unbind = frameBuffer.Unbind;
dispose = frameBuffer.Dispose;
enableScissor = rect => frameBuffer.EnableScissor((Rectangle)rect);
disableScissor = frameBuffer.DisableScissor;
}
private IFrameBuffer renderToBuffer()
{
TypedParameter sizeParam = new TypedParameter(typeof(Size), new Size(
(int)_window.AppWindowWidth, (int)_window.AppWindowHeight));
IFrameBuffer frameBuffer = _resolver.Container.Resolve <IFrameBuffer>(sizeParam);
frameBuffer.Begin();
_rendererLoop.Tick();
frameBuffer.End();
return(frameBuffer);
}
public void RenderBorderBack(ISquare square)
{
if (_glUtils.DrawQuad(_frameBuffer, square, _quad))
{
return;
}
float width = _settings.VirtualResolution.Width;
float height = _settings.VirtualResolution.Height;
float arrowWidth = width * (1f / 2f);
float arrowHeight = height * (1f / 2f);
float remainingWidth = width - arrowWidth;
float remainingHeight = height - arrowHeight;
PointF point1, point2, point3;
switch (Direction)
{
case ArrowDirection.Right:
point1 = new PointF(remainingWidth / 2f, remainingHeight / 2f); // square.TopLeft + new PointF(remainingWidth / 2f, -remainingHeight / 2f);
point2 = new PointF(remainingWidth / 2f, height - remainingHeight / 2f); //square.BottomLeft + new PointF(remainingWidth / 2f, remainingHeight / 2f);
point3 = new PointF(width - remainingWidth / 2f, height / 2f); //square.BottomRight + new PointF(-remainingWidth / 2f, height / 2f);
break;
case ArrowDirection.Down:
point1 = new PointF(remainingWidth / 2f, remainingHeight / 2f);
point2 = new PointF(width / 2f, height - remainingHeight / 2f);
point3 = new PointF(width - remainingWidth / 2f, remainingHeight / 2f);
break;
case ArrowDirection.Left:
point1 = new PointF(width - remainingWidth / 2f, height - remainingHeight / 2f);
point2 = new PointF(width - remainingWidth / 2f, remainingHeight / 2f);
point3 = new PointF(remainingWidth / 2f, height / 2f);
break;
case ArrowDirection.Up:
point1 = new PointF(remainingWidth / 2f, height - remainingHeight / 2f);
point2 = new PointF(width / 2f, remainingHeight / 2f);
point3 = new PointF(width - remainingWidth / 2f, height - remainingHeight / 2f);
break;
default: throw new NotSupportedException(Direction.ToString());
}
_frameBuffer = _glUtils.BeginFrameBuffer(square, _settings);
_glUtils.DrawTriangle(0, new GLVertex[] { new GLVertex((point1).ToVector2(), _emptyVector, ArrowColor),
new GLVertex((point2).ToVector2(), _emptyVector, ArrowColor), new GLVertex((point3).ToVector2(), _emptyVector, ArrowColor) });
_frameBuffer.End();
_glUtils.DrawQuad(_frameBuffer, square, _quad);
}
public override void DoStart()
{
snapshotFrameInterval = 1;
if (_constStateService.IsVideoMode)
{
snapshotFrameInterval = _constStateService.SnapshotFrameInterval;
}
_cmdBuffer = new FrameBuffer(this, _networkService, 2000, snapshotFrameInterval, MaxPredictFrameCount);
_world = new World();
_dumpHelper = new DumpHelper(_serviceContainer, _world);
_hashHelper = new HashHelper(_serviceContainer, _world, _networkService, _cmdBuffer);
}
public bool DrawQuad(IFrameBuffer frameBuffer, AGSBoundingBox square, GLVertex[] vertices)
{
if (frameBuffer == null)
{
return(false);
}
vertices[0] = new GLVertex(square.BottomLeft.Xy, _bottomLeft, Colors.White);
vertices[1] = new GLVertex(square.BottomRight.Xy, _bottomRight, Colors.White);
vertices[2] = new GLVertex(square.TopRight.Xy, _topRight, Colors.White);
vertices[3] = new GLVertex(square.TopLeft.Xy, _topLeft, Colors.White);
DrawQuad(frameBuffer.Texture.ID, vertices);
return(true);
}
/// <summary>
/// Get a Image from IFrameBuffer with specific Bounds example from Display
/// </summary>
/// <param name="buffer"></param>
/// <param name="rec"></param>
/// <returns></returns>
public static Image FromBuffer(IFrameBuffer buffer, Rectangle rec)
{
var img = new Image(rec.Size.Width, rec.Size.Height);
for (uint x = rec.Location.X; x < rec.Size.Width; x++)
{
for (uint y = rec.Location.Y; y < rec.Size.Height; y++)
{
img.SetPixel(x, y, buffer.GetPixel(x, y));
}
}
return(img);
}
/// <summary>Draws the string.</summary>
public void DrawString(IFrameBuffer frameBuffer, uint color, uint x, uint y, string text)
{
int size8 = size / 8;
string[] lines = text.Split('\n');
for (int l = 0; l < lines.Length; l++)
{
int usedX = 0;
for (int i = 0; i < lines[l].Length; i++)
{
char c = lines[l][i];
int index = charset.IndexOf(c);
if (index < 0)
{
usedX += size / 2;
continue;
}
int maxX = 0, sizePerFont = size * size8 * index, X = usedX + (int)x, Y = (int)y + size * l;
for (int h = 0; h < size; h++)
{
for (int aw = 0; aw < size8; aw++)
{
for (int ww = 0; ww < 8; ww++)
{
if ((buffer[sizePerFont + (h * size8) + aw] & (0x80 >> ww)) != 0)
{
int max = (aw * 8) + ww;
int xx = X + max;
int yy = Y + h;
frameBuffer.SetPixel(color, (uint)xx, (uint)yy);
if (max > maxX)
{
maxX = max;
}
}
}
}
}
usedX += maxX + 2;
}
}
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
if (_tween.Task.IsCompleted)
{
if (_isFadeIn)
{
_isFadeIn = false;
return false;
}
_isFadeIn = true;
_tween = Tween.RunWithExternalVisit(0f, 1f, b => _black = b, _timeInSeconds, _easingFadeIn, out _visitTween);
}
_visitTween();
_screenVectors.Render(_isFadeIn ? to.Texture : from.Texture, _black, _black, _black);
return true;
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
if (_tween.Task.IsCompleted)
{
if (_isFadeIn)
{
_isFadeIn = false;
return(false);
}
_isFadeIn = true;
_tween = Tween.RunWithExternalVisit(0f, 1f, b => _black = b, _timeInSeconds, _easingFadeIn, out _visitTween);
}
_visitTween();
_screenVectors.Render(_isFadeIn ? to.Texture : from.Texture, _black, _black, _black);
return(true);
}
public override void DoStart()
{
this.snapshotFrameInterval = 1;
bool isVideoMode = this._globalStateService.IsVideoMode;
if (isVideoMode)
{
this.snapshotFrameInterval = this._globalStateService.SnapshotFrameInterval;
}
this._cmdBuffer = new FrameBuffer(this, this._networkService, 2000, this.snapshotFrameInterval, 30);
object contexts = this._globalStateService.Contexts;
object logicFeatureObj = this._ecsFactoryService.CreateSystems(contexts, this._serviceContainer);
this._world = (this.FuncCreateWorld(this._serviceContainer, contexts, logicFeatureObj) as World);
this._hashHelper = new HashHelper(this._serviceContainer, this._world, this._networkService, this._cmdBuffer);
this._dumpHelper = new DumpHelper(this._serviceContainer, this._world, this._hashHelper);
}
public void BeginWorld(Rectangle worldViewport)
{
if (renderType != RenderType.None)
{
throw new InvalidOperationException("BeginWorld called with renderType = {0}, expected RenderType.None.".F(renderType));
}
BeginFrame();
var worldBufferSize = worldViewport.Size.NextPowerOf2();
if (worldSprite == null || worldSprite.Sheet.Size != worldBufferSize)
{
if (worldBuffer != null)
{
worldBuffer.Dispose();
}
// Render the world into a framebuffer at 1:1 scaling to allow the depth buffer to match the artwork at all zoom levels
worldBuffer = Context.CreateFrameBuffer(worldBufferSize);
// Pixel art scaling mode is a customized bilinear sampling
worldBuffer.Texture.ScaleFilter = TextureScaleFilter.Linear;
}
if (worldSprite == null || worldViewport.Size != worldSprite.Bounds.Size)
{
var worldSheet = new Sheet(SheetType.BGRA, worldBuffer.Texture);
worldSprite = new Sprite(worldSheet, new Rectangle(int2.Zero, worldViewport.Size), TextureChannel.RGBA);
}
worldBuffer.Bind();
if (worldBufferSize != lastWorldBufferSize || lastWorldViewport != worldViewport)
{
var depthScale = worldBufferSize.Height / (worldBufferSize.Height + depthMargin);
WorldSpriteRenderer.SetViewportParams(worldBufferSize, depthScale, depthScale / 2, worldViewport.Location);
WorldModelRenderer.SetViewportParams(worldBufferSize, worldViewport.Location);
lastWorldViewport = worldViewport;
lastWorldBufferSize = worldBufferSize;
}
renderType = RenderType.World;
}
/// <summary>Sets the mode.</summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <param name="bitsPerPixel">
/// If bitsPerPixel=0, then HostBitsPerPixel is used automatically.
/// If bitsPerPixel!=0, then the requested bitsPerPixel is used.
/// </param>
public bool SVGASetMode(ushort width, ushort height, byte bitsPerPixel = 0)
{
this.width = width;
this.height = height;
if (bitsPerPixel == 0)
{
// use the host's bits per pixel
this.bitsPerPixel = SVGAGetRegister(SVGA_REGISTERS.HostBitsPerPixel);
}
else
{
// use the requested bits per pixel
this.bitsPerPixel = bitsPerPixel;
}
// set height & width
SVGASetRegister(SVGA_REGISTERS.Width, this.width);
SVGASetRegister(SVGA_REGISTERS.Height, this.height);
SVGASetRegister(SVGA_REGISTERS.BitsPerPixel, this.bitsPerPixel);
SVGASetRegister(SVGA_REGISTERS.Enable, 1);
SVGASetRegister(SVGA_REGISTERS.ConfigDone, 1);
// get the frame buffer offset
offset = SVGAGetRegister(SVGA_REGISTERS.FrameBufferOffset);
// get the bytes per line (pitch)
bytesPerLine = SVGAGetRegister(SVGA_REGISTERS.BytesPerLine);
switch (this.bitsPerPixel)
{
case 8: frameBuffer = new FrameBuffer8bpp(memory, width, height, offset, bytesPerLine, false); break;
case 16: frameBuffer = new FrameBuffer16bpp(memory, width, height, offset, bytesPerLine, false); break;
case 24: frameBuffer = new FrameBuffer24bpp(memory, width, height, offset, bytesPerLine, false); break;
case 32: frameBuffer = new FrameBuffer32bpp(memory, width, height, offset, bytesPerLine, false); break;
default: return(false);
}
return(true);
}
public void EndFrame()
{
if (!isInFrame)
{
throw new InvalidOperationException("BeginFrame has not been called. There is no frame to end.");
}
isInFrame = false;
sheetBuilderForFrame = null;
if (doRender.Count == 0)
{
return;
}
Sheet currentSheet = null;
IFrameBuffer fbo = null;
foreach (var v in doRender)
{
// Change sheet
if (v.First != currentSheet)
{
if (fbo != null)
{
DisableFrameBuffer(fbo);
}
currentSheet = v.First;
fbo = EnableFrameBuffer(currentSheet);
}
v.Second();
}
if (fbo != null)
{
DisableFrameBuffer(fbo);
}
doRender.Clear();
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
if (_tweenX.Task.IsCompleted && _tweenY.Task.IsCompleted)
{
return false;
}
if (!_tweenX.Task.IsCompleted) _visitTweenX();
if (!_tweenY.Task.IsCompleted) _visitTweenY();
var quad = new QuadVectors (_x, _y, _width, _height, _glUtils);
if (_slideIn)
{
_screenVectors.Render(from.Texture);
quad.Render(to.Texture);
}
else
{
_screenVectors.Render(to.Texture);
quad.Render(from.Texture);
}
return true;
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
if (_tweenWidth.Task.IsCompleted)
{
if (_isBoxIn)
{
_isBoxIn = false;
return false;
}
_isBoxIn = true;
_tweenWidth = Tween.RunWithExternalVisit(0f, _screenWidth, f => _boxWidth = f, _timeInSeconds, _easingBoxIn, out _visitTweenWidth);
Tween.RunWithExternalVisit(0f, _screenHeight, f => _boxHeight = f, _timeInSeconds, _easingBoxIn, out _visitTweenHeight);
}
_visitTweenWidth();
_visitTweenHeight();
if (_isBoxIn)
{
_screenVectors.Render(to.Texture);
float x = _screenHalfWidth - _boxWidth / 2;
float y = _screenHalfHeight - _boxHeight / 2;
QuadVectors left = new QuadVectors (0f, 0f, x, _screenHeight, _glUtils);
QuadVectors right = new QuadVectors (_screenWidth - x, 0f, x, _screenHeight, _glUtils);
QuadVectors top = new QuadVectors (0f, 0f, _screenWidth, y, _glUtils);
QuadVectors bottom = new QuadVectors (0f, _screenHeight - y, _screenWidth, y, _glUtils);
renderBlackQuads(left, right, top, bottom);
}
else
{
_screenVectors.Render(from.Texture);
QuadVectors quad = new QuadVectors (_screenHalfWidth - _boxWidth / 2, _screenHalfHeight - _boxHeight / 2,
_boxWidth, _boxHeight, _glUtils);
renderBlackQuads(quad);
}
return true;
}
public bool Tick ()
{
if (_gameState.Room == null) return false;
IRoom room = _gameState.Room;
switch (_roomTransitions.State)
{
case RoomTransitionState.NotInTransition:
activateShader();
renderRoom(room);
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(getDisplayList(room), obj => renderObject(room, obj)))
{
if (_fromTransitionBuffer == null) _fromTransitionBuffer = renderToBuffer(room);
_roomTransitions.State = RoomTransitionState.PreparingTransition;
return false;
}
break;
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(room);
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(getDisplayList(room), obj => renderObject(room, obj)))
{
_roomTransitions.SetOneTimeNextTransition(null);
_roomTransitions.State = RoomTransitionState.NotInTransition;
return false;
}
break;
default:
throw new NotSupportedException (_roomTransitions.State.ToString());
}
return true;
}
public bool RenderTransition(IFrameBuffer from, IFrameBuffer to)
{
return false;
}
public abstract bool IsFramebuffer(IFrameBuffer frameBuffer);
/* -----------------------------------------Frame Buffer-----------------------------------------------------------*/ public abstract void BindFramebuffer(int target, IFrameBuffer frameBuffer);
public abstract void DeleteFramebuffer(IFrameBuffer frameBuffer);
/// <summary>
/// Sets the mode.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <returns></returns>
public bool SetMode(ushort width, ushort height)
{
this.width = width;
this.height = height;
// set heigth & width
SendCommand(Register.Height, height);
SendCommand(Register.Width, width);
SendCommand(Register.BitsPerPixel, 32);
SendCommand(Register.Enable, 1);
// use the host's bits per pixel
bitsPerPixel = 32; // ReadRegister(Register.BitsPerPixel);
// get the frame buffer offset
offset = ReadRegister(Register.FrameBufferOffset);
// get the bytes per line (pitch)
bytesPerLine = ReadRegister(Register.BytesPerLine);
switch (bitsPerPixel)
{
case 8: frameBuffer = new FrameBuffer8bpp(memory, width, height, offset, 1); break;
case 16: frameBuffer = new FrameBuffer16bpp(memory, width, height, offset, 2); break;
case 24: frameBuffer = new FrameBuffer24bpp(memory, width, height, offset, 3); break;
case 32: frameBuffer = new FrameBuffer32bpp(memory, width, height, offset, 4); break;
default: return false;
}
return true;
}
/// <summary>
/// Sets the mode.
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <returns></returns>
public bool SetMode(ushort width, ushort height)
{
this.width = width;
this.height = height;
SendCommand(Register.Width, width);
SendCommand(Register.Height, height);
SendCommand(Register.Enable, 1);
offset = GetValue(Register.FrameBufferOffset);
SendCommand(Register.GuestID, 0x5010); // ??
bytesPerLine = GetValue(Register.BytesPerLine);
switch (bitsPerPixel) {
case 8: frameBuffer = new FrameBuffer8bpp(memory, width, height, offset, bytesPerLine); break;
case 16: frameBuffer = new FrameBuffer16bpp(memory, width, height, offset, bytesPerLine); break;
case 24: frameBuffer = new FrameBuffer24bpp(memory, width, height, offset, bytesPerLine); break;
case 32: frameBuffer = new FrameBuffer32bpp(memory, width, height, offset, bytesPerLine); break;
default: return false;
}
return true;
}
void DisableFrameBuffer(IFrameBuffer fbo)
{
Game.Renderer.Flush();
Game.Renderer.Device.DisableDepthBuffer();
fbo.Unbind();
}
